From 1d4dfdf271155f94ed4684b92bf426de8445aa4c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 5 Feb 2001 23:28:01 +0000
Subject: [PATCH 001/369] converted <> to &lt;&gt;

[SVN r8954]
---
 doc/pointers.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/pointers.html b/doc/pointers.html
index 26f96f0d..bf8ec8ae 100644
--- a/doc/pointers.html
+++ b/doc/pointers.html
@@ -90,7 +90,7 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
 
   PyObject* to_python(const Foo* p)
   {
-      return to_python(const_cast<Foo*>(p));
+      return to_python(const_cast&lt;Foo*&gt;(p));
   }
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
 </pre></blockquote>

From 4d19be8ea477d05df16c979032326175d088d299 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 6 Feb 2001 03:08:00 +0000
Subject: [PATCH 002/369] PyExtensionClassConverters<Foo> ->
 python_extension_class_converters&ltFoo&gt

[SVN r8968]
---
 doc/pointers.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/pointers.html b/doc/pointers.html
index bf8ec8ae..e26cea02 100644
--- a/doc/pointers.html
+++ b/doc/pointers.html
@@ -85,7 +85,7 @@ code before the last Python reference to it disappears:
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   PyObject* to_python(Foo* p)
   {
-      return boost::python::PyExtensionClassConverters<Foo>::ptr_to_python(p);
+      return boost::python::python_extension_class_converters&ltFoo&gt::ptr_to_python(p);
   }
 
   PyObject* to_python(const Foo* p)

From 1d17690f694f72b7b663f048f93b4f356905a404 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 7 Feb 2001 23:50:41 +0000
Subject: [PATCH 003/369] Add back old example files that were accidentally
 removed from the main branch.

[SVN r9016]
---
 example/example1.cpp     | 54 ++++++++++++++++++++++++++++++++++++++++
 example/rwgk1.cpp        | 41 ++++++++++++++++++++++++++++++
 example/test_example1.py | 50 +++++++++++++++++++++++++++++++++++++
 example/test_rwgk1.py    | 17 +++++++++++++
 4 files changed, 162 insertions(+)
 create mode 100644 example/example1.cpp
 create mode 100644 example/rwgk1.cpp
 create mode 100644 example/test_example1.py
 create mode 100644 example/test_rwgk1.py

diff --git a/example/example1.cpp b/example/example1.cpp
new file mode 100644
index 00000000..467ac0dc
--- /dev/null
+++ b/example/example1.cpp
@@ -0,0 +1,54 @@
+#include <string.h>
+
+namespace hello {
+  class world
+  {
+   public:
+      world(int) {}
+      ~world() {}
+      const char* get() const { return "hi, world"; }
+  };
+
+  size_t length(const world& x) { return strlen(x.get()); }
+}
+
+#include <boost/python/class_builder.hpp>
+
+// Python requires an exported function called init<module-name> in every
+// extension module. This is where we build the module contents.
+extern "C"
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+void inithello()
+{
+    try
+    {
+       // create an object representing this extension module
+       boost::python::module_builder hello("hello");
+
+       // Create the Python type object for our extension class
+       boost::python::class_builder<hello::world> world_class(hello, "world");
+
+       // Add the __init__ function
+       world_class.def(boost::python::constructor<int>());
+       // Add a regular member function
+       world_class.def(&hello::world::get, "get");
+
+       // Add a regular function to the module
+       hello.def(hello::length, "length");
+    }
+    catch(...)
+    {
+       boost::python::handle_exception();    // Deal with the exception for Python
+    }
+}
+
+// Win32 DLL boilerplate
+#if defined(_WIN32)
+#include <windows.h>
+extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID)
+{
+    return 1;
+}
+#endif // _WIN32
diff --git a/example/rwgk1.cpp b/example/rwgk1.cpp
new file mode 100644
index 00000000..b21ae4d1
--- /dev/null
+++ b/example/rwgk1.cpp
@@ -0,0 +1,41 @@
+#include <string>
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A couple of simple C++ functions that we want to expose to Python.
+  std::string greet() { return "hello, world"; }
+  int square(int number) { return number * number; }
+}
+
+#include <boost/python/class_builder.hpp>
+
+namespace python = boost::python;
+
+// Python requires an exported function called init<module-name> in every
+// extension module. This is where we build the module contents.
+extern "C"
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+void initrwgk1()
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("rwgk1");
+
+    // Add regular functions to the module.
+    this_module.def(greet, "greet");
+    this_module.def(square, "square");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+
+// Win32 DLL boilerplate
+#if defined(_WIN32)
+#include <windows.h>
+extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
+#endif // _WIN32
diff --git a/example/test_example1.py b/example/test_example1.py
new file mode 100644
index 00000000..0e3a9a18
--- /dev/null
+++ b/example/test_example1.py
@@ -0,0 +1,50 @@
+r'''
+//  (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.
+
+That's it! If we build this shared library and put it on our PYTHONPATH we can
+now access our C++ class and function from Python.
+
+    >>> import hello
+    >>> hi_world = hello.world(3)
+    >>> hi_world.get()
+    'hi, world'
+    >>> hello.length(hi_world)
+    9
+
+We can even make a subclass of hello.world:
+
+
+    >>> class my_subclass(hello.world):
+    ...     def get(self):
+    ...         return 'hello, world'
+    ...
+    >>> y = my_subclass(2)
+    >>> y.get()
+    'hello, world'
+
+Pretty cool! You can't do that with an ordinary Python extension type!
+
+    >>> hello.length(y)
+    9
+
+Of course, you may now have a slightly empty feeling in the pit of your little
+pythonic stomach. Perhaps you feel your subclass deserves to have a length() of
+12? If so, read on...
+'''
+from hello import *
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_example1
+    doctest.testmod(test_example1)
+    
+if __name__ == '__main__':
+    run()
diff --git a/example/test_rwgk1.py b/example/test_rwgk1.py
new file mode 100644
index 00000000..87298875
--- /dev/null
+++ b/example/test_rwgk1.py
@@ -0,0 +1,17 @@
+r'''>>> import rwgk1
+    >>> print rwgk1.greet()
+    hello, world
+    >>> number = 11
+    >>> print number, '*', number, '=', rwgk1.square(number)
+    11 * 11 = 121
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_rwgk1
+    doctest.testmod(test_rwgk1)
+
+if __name__ == '__main__':
+    run()

From 0d04bf8e34031d7413bce85c4eeabf73e5024445 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 7 Feb 2001 23:58:44 +0000
Subject: [PATCH 004/369] Remove example files that were accidentally added to
 the main branch.

[SVN r9017]
---
 example/README                 |  6 +++
 example/dvect.cpp              | 69 ----------------------------------
 example/dvect.h                | 32 ----------------
 example/ivect.cpp              | 69 ----------------------------------
 example/ivect.h                | 32 ----------------
 example/noncopyable_export.cpp | 24 ------------
 example/noncopyable_import.cpp | 42 ---------------------
 example/store.h                | 14 -------
 example/tst_dvect.py           | 16 --------
 example/tst_ivect.py           | 16 --------
 example/tst_noncopyable.py     |  8 ----
 11 files changed, 6 insertions(+), 322 deletions(-)
 create mode 100644 example/README
 delete mode 100644 example/dvect.cpp
 delete mode 100644 example/dvect.h
 delete mode 100644 example/ivect.cpp
 delete mode 100644 example/ivect.h
 delete mode 100644 example/noncopyable_export.cpp
 delete mode 100644 example/noncopyable_import.cpp
 delete mode 100644 example/store.h
 delete mode 100644 example/tst_dvect.py
 delete mode 100644 example/tst_ivect.py
 delete mode 100644 example/tst_noncopyable.py

diff --git a/example/README b/example/README
new file mode 100644
index 00000000..34b50d61
--- /dev/null
+++ b/example/README
@@ -0,0 +1,6 @@
+To get started with the Boost Python Library, use the examples
+getting_started?.cpp and abstract.cpp.
+
+The files example1.cpp and rwgk1.cpp are obsolete. They are only
+included because the makefiles in the build directory still refer to
+them. This will be fixed later.
diff --git a/example/dvect.cpp b/example/dvect.cpp
deleted file mode 100644
index 3228010c..00000000
--- a/example/dvect.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "ivect.h"
-#include "dvect.h"
-#include <boost/python/class_builder.hpp>
-#include <boost/python/detail/import_extension_class.hpp>
-namespace python = boost::python;
-
-namespace {
-
-  vects::ivect dvect_as_ivect(const vects::dvect& dv)
-  {
-    vects::ivect iv(dv.size());
-    vects::ivect::iterator iviter = iv.begin();
-    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
-    return iv;
-  }
-
-  boost::python::tuple ivect_as_tuple(const vects::ivect& iv)
-  {
-    return iv.as_tuple();
-  }
-
-  std::auto_ptr<vects::ivect> auto_ptr_ivect(const vects::dvect& dv)
-  {
-    return std::auto_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
-  }
-
-  boost::shared_ptr<vects::ivect> shared_ptr_ivect(const vects::dvect& dv)
-  {
-    return boost::shared_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
-  }
-
-  boost::python::tuple auto_ptr_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
-  {
-    return iv->as_tuple();
-  }
-
-  boost::python::tuple shared_ptr_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
-  {
-    return iv->as_tuple();
-  }
-}
-
-extern "C"
-DL_EXPORT(void)
-initdvect()
-{
-  try
-  {
-    python::module_builder this_module("dvect");
-
-    python::x_class_builder<vects::dvect> dvect_class(this_module, "dvect");
-
-    python::import_class_builder<vects::ivect> ivect_class("ivect", "ivect");
-
-    dvect_class.def(python::constructor<python::tuple>());
-    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
-    dvect_class.def(dvect_as_ivect, "as_ivect");
-
-    this_module.def(ivect_as_tuple, "ivect_as_tuple");
-    dvect_class.def(auto_ptr_ivect, "auto_ptr_ivect");
-    dvect_class.def(shared_ptr_ivect, "shared_ptr_ivect");
-    this_module.def(auto_ptr_ivect_as_tuple, "auto_ptr_ivect_as_tuple");
-    this_module.def(shared_ptr_ivect_as_tuple, "shared_ptr_ivect_as_tuple");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/dvect.h b/example/dvect.h
deleted file mode 100644
index 8ffe7b50..00000000
--- a/example/dvect.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef DVECT_H
-#define DVECT_H
-
-#include <vector>
-#include <boost/python/class_builder.hpp>
-
-namespace vects {
-
-  struct dvect : public std::vector<double>
-  {
-    dvect() : std::vector<double>() {}
-    dvect(size_t n) : std::vector<double>(n) {}
-    dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator v_it = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          boost::python::type<double>());
-    }
-
-    boost::python::tuple as_tuple() const
-    {
-      boost::python::tuple t(size());
-      for (int i = 0; i < size(); i++)
-        t.set_item(i,
-          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
-      return t;
-    }
-  };
-}
-
-#endif // DVECT_H
diff --git a/example/ivect.cpp b/example/ivect.cpp
deleted file mode 100644
index f8ca8707..00000000
--- a/example/ivect.cpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#include "ivect.h"
-#include "dvect.h"
-#include <boost/python/class_builder.hpp>
-#include <boost/python/detail/import_extension_class.hpp>
-namespace python = boost::python;
-
-namespace {
-
-  vects::dvect ivect_as_dvect(const vects::ivect& iv)
-  {
-    vects::dvect dv(iv.size());
-    vects::dvect::iterator dviter = dv.begin();
-    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
-    return dv;
-  }
-
-  boost::python::tuple dvect_as_tuple(const vects::dvect& dv)
-  {
-    return dv.as_tuple();
-  }
-
-  std::auto_ptr<vects::dvect> auto_ptr_dvect(const vects::ivect& iv)
-  {
-    return std::auto_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
-  }
-
-  boost::shared_ptr<vects::dvect> shared_ptr_dvect(const vects::ivect& iv)
-  {
-    return boost::shared_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
-  }
-
-  boost::python::tuple auto_ptr_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
-  {
-    return dv->as_tuple();
-  }
-
-  boost::python::tuple shared_ptr_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
-  {
-    return dv->as_tuple();
-  }
-}
-
-extern "C"
-DL_EXPORT(void)
-initivect()
-{
-  try
-  {
-    python::module_builder this_module("ivect");
-
-    python::x_class_builder<vects::ivect> ivect_class(this_module, "ivect");
-
-    python::import_class_builder<vects::dvect> dvect_class("dvect", "dvect");
-
-    ivect_class.def(python::constructor<python::tuple>());
-    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
-    ivect_class.def(ivect_as_dvect, "as_dvect");
-
-    this_module.def(dvect_as_tuple, "dvect_as_tuple");
-    ivect_class.def(auto_ptr_dvect, "auto_ptr_dvect");
-    ivect_class.def(shared_ptr_dvect, "shared_ptr_dvect");
-    this_module.def(auto_ptr_dvect_as_tuple, "auto_ptr_dvect_as_tuple");
-    this_module.def(shared_ptr_dvect_as_tuple, "shared_ptr_dvect_as_tuple");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/ivect.h b/example/ivect.h
deleted file mode 100644
index a0187307..00000000
--- a/example/ivect.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef IVECT_H
-#define IVECT_H
-
-#include <vector>
-#include <boost/python/class_builder.hpp>
-
-namespace vects {
-
-  struct ivect : public std::vector<int>
-  {
-    ivect() : std::vector<int>() {}
-    ivect(size_t n) : std::vector<int>(n) {}
-    ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
-    {
-      std::vector<int>::iterator v_it = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          boost::python::type<int>());
-    }
-
-    boost::python::tuple as_tuple() const
-    {
-      boost::python::tuple t(size());
-      for (int i = 0; i < size(); i++)
-        t.set_item(i,
-          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
-      return t;
-    }
-  };
-}
-
-#endif // IVECT_H
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
deleted file mode 100644
index 82c3f049..00000000
--- a/example/noncopyable_export.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <boost/python/class_builder.hpp>
-#include <boost/python/detail/import_extension_class.hpp>
-namespace python = boost::python;
-
-#include "store.h"
-
-extern "C"
-DL_EXPORT(void)
-initnoncopyable_export()
-{
-  try
-  {
-    python::module_builder this_module("noncopyable_export");
-
-    python::xptr_class_builder<store> store_class(this_module, "store");
-
-    store_class.def(python::constructor<int>());
-    store_class.def(&store::recall, "recall");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
deleted file mode 100644
index 529c9f42..00000000
--- a/example/noncopyable_import.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include <boost/python/class_builder.hpp>
-#include <boost/python/detail/import_extension_class.hpp>
-namespace python = boost::python;
-
-#include "store.h"
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A function with store objects as both input and output parameters.
-  // Because the copy constructor is disabled, we cannot pass a store
-  // object by value. Instead, we pass a smart pointer.
-  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
-  {
-    int sum = s1.recall() + s2.recall();
-    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
-    return ss;
-  }
-}
-
-extern "C"
-DL_EXPORT(void)
-initnoncopyable_import()
-{
-  try
-  {
-    python::module_builder this_module("noncopyable_import");
-
-    python::import_class_builder<store>
-      dvect_class("noncopyable_export", "store");
-
-    // Imagine all the additional classes with member functions
-    // that have store objects as input and output parameters.
-    // Lots and lots of them.
-    // However, to keep this example simple, we only define a
-    // module-level function.
-    this_module.def(add_stores, "add_stores");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/store.h b/example/store.h
deleted file mode 100644
index 74ef0477..00000000
--- a/example/store.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef STORE_H
-#define STORE_H
-
-class store
-{
-  private:
-    store(const store&) { } // Disable the copy constructor.
-    int number;
-  public:
-    store(const int i) : number(i) { }
-    int recall() const { return number; }
-};
-
-#endif // STORE_H
diff --git a/example/tst_dvect.py b/example/tst_dvect.py
deleted file mode 100644
index 563f0ad5..00000000
--- a/example/tst_dvect.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import dvect
-print dvect.dvect.__converters__
-dv = dvect.dvect((1,2,3,4,5))
-print dv
-print dv.as_tuple()
-iv = dv.as_ivect()
-print iv
-print iv.as_tuple()
-print dvect.ivect_as_tuple(iv)
-aiv = dv.auto_ptr_ivect()
-print aiv
-siv = dv.shared_ptr_ivect()
-print dvect.auto_ptr_ivect_as_tuple(aiv)
-print dvect.ivect_as_tuple(aiv)
-print dvect.shared_ptr_ivect_as_tuple(siv)
-print dvect.ivect_as_tuple(siv)
diff --git a/example/tst_ivect.py b/example/tst_ivect.py
deleted file mode 100644
index 58bc323f..00000000
--- a/example/tst_ivect.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import ivect
-print ivect.ivect.__converters__
-iv = ivect.ivect((1,2,3,4,5))
-print iv
-print iv.as_tuple()
-dv = iv.as_dvect()
-print dv
-print dv.as_tuple()
-print ivect.dvect_as_tuple(dv)
-adv = iv.auto_ptr_dvect()
-print adv
-sdv = iv.shared_ptr_dvect()
-print ivect.auto_ptr_dvect_as_tuple(adv)
-print ivect.dvect_as_tuple(adv)
-print ivect.shared_ptr_dvect_as_tuple(sdv)
-print ivect.dvect_as_tuple(sdv)
diff --git a/example/tst_noncopyable.py b/example/tst_noncopyable.py
deleted file mode 100644
index 913df039..00000000
--- a/example/tst_noncopyable.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import noncopyable_export
-import noncopyable_import
-s1 = noncopyable_export.store(1)
-print s1.recall()
-s2 = noncopyable_export.store(2)
-print s2.recall()
-s3 = noncopyable_import.add_stores(s1, s2)
-print s3.recall()

From f3d9193743d8635a46b53c7d36a3c77d8c61c83c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 8 Feb 2001 01:54:59 +0000
Subject: [PATCH 005/369] Fix for linux gcc-2.95.2

[SVN r9023]
---
 example/getting_started5.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/example/getting_started5.cpp b/example/getting_started5.cpp
index bbe4725a..4b64e4b8 100644
--- a/example/getting_started5.cpp
+++ b/example/getting_started5.cpp
@@ -70,7 +70,8 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
   //
   MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
   {
-    python::tuple tup = python::tuple(python::ref(p, ref::increment_count));
+    python::tuple tup
+      = python::tuple(python::ref(p, python::ref::increment_count));
     if (tup.size() != 3) {
       PyErr_SetString(PyExc_ValueError,
         "expecting exactly 3 values in tuple.");

From b000c759477dc3cdaaa6ced47accf92e890fc7f3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 23 Feb 2001 08:58:32 +0000
Subject: [PATCH 006/369] Fix for python::tuple.set_item() memory leak.

[SVN r9316]
---
 example/getting_started5.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/getting_started5.cpp b/example/getting_started5.cpp
index 4b64e4b8..c9f1ce36 100644
--- a/example/getting_started5.cpp
+++ b/example/getting_started5.cpp
@@ -97,7 +97,7 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
   {
     python::tuple result(3);
     for (int i = 0; i < 3; i++)
-      result.set_item(i, to_python(hkl.v[i]));
+      result.set_item(i, python::ref(to_python(hkl.v[i])));
     return result.reference().release();
   }
 

From 977841a7f383115244b27fdf58a4af6429852ff8 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 2 Mar 2001 01:48:30 +0000
Subject: [PATCH 007/369] Use PyObject_INIT() instead of hand-initializing
 objects

[SVN r9375]
---
 include/boost/python/detail/base_object.hpp |  6 ++--
 include/boost/python/detail/wrap_python.hpp |  7 +++++
 src/extension_class.cpp                     |  7 +++--
 src/functions.cpp                           | 31 ++++++++++++---------
 4 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/include/boost/python/detail/base_object.hpp b/include/boost/python/detail/base_object.hpp
index f8ed665b..bf0faa7b 100644
--- a/include/boost/python/detail/base_object.hpp
+++ b/include/boost/python/detail/base_object.hpp
@@ -5,6 +5,9 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+//
+// Revision History:
+// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
 #ifndef BASE_OBJECT_DWA051600_H_
 # define BASE_OBJECT_DWA051600_H_
@@ -46,9 +49,8 @@ base_object<python_type>::base_object(PyTypeObject* type_obj)
     std::
 #endif
 		memset(bp, 0, sizeof(base_python_type));
-    ob_refcnt = 1;
-    ob_type = type_obj;
     Py_INCREF(type_obj);
+    PyObject_INIT(bp, type_obj);
 }
 
 template <class python_type>
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index eb831b68..9e57c287 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -15,6 +15,9 @@
 //  To use the Python debugging library, #define BOOST_DEBUG_PYTHON on the
 //  compiler command-line.
 
+// Revision History:
+// 01 Mar 01  define PyObject_INIT() for Python 1.x
+
 #ifdef _DEBUG
 # ifndef BOOST_DEBUG_PYTHON
 #  undef _DEBUG // Don't let Python force the debug library just because we're debugging.
@@ -76,3 +79,7 @@ typedef int pid_t;
 # define _DEBUG
 #endif
 
+#if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
+# define PyObject_INIT(op, typeobj) \
+	( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+#endif
diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index c15e538b..47862ec7 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -5,6 +5,9 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+//
+// Revision History:
+// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
 #include <boost/python/detail/extension_class.hpp>
 #include <cstring>
@@ -446,8 +449,8 @@ operator_dispatcher::operator_dispatcher(const ref& o, const ref& s)
     : m_object(o), m_self(s), m_free_list_link(0)
 
 {
-    ob_refcnt = 1;
-    ob_type = &type_obj;
+    PyObject* self = this;
+    PyObject_INIT(self, &type_obj);
 }
 
 operator_dispatcher* 
diff --git a/src/functions.cpp b/src/functions.cpp
index e166c91c..71b59136 100644
--- a/src/functions.cpp
+++ b/src/functions.cpp
@@ -5,6 +5,9 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+//
+// Revision History:
+// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
 #include <boost/python/detail/functions.hpp>
 #include <boost/python/detail/types.hpp>
@@ -97,19 +100,6 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
     return 0;
 }
 
-bound_function* bound_function::create(const ref& target, const ref& fn)
-{
-    bound_function* const result = free_list;
-    if (result == 0)
-        return new bound_function(target, fn);
-    
-    free_list = result->m_free_list_link;
-    result->m_target = target;
-    result->m_unbound_function = fn;
-    Py_INCREF(result);
-    return result;
-}
-
 // The instance class whose obj represents the type of bound_function
 // objects in Python. bound_functions must be GetAttrable so the __doc__
 // attribute of built-in Python functions can be accessed when bound.
@@ -123,6 +113,21 @@ private: // type_object<bound_function> hook override
     void dealloc(bound_function*) const;
 };
 
+bound_function* bound_function::create(const ref& target, const ref& fn)
+{
+    bound_function* const result = free_list;
+    if (result == 0)
+        return new bound_function(target, fn);
+    
+    free_list = result->m_free_list_link;
+    result->m_target = target;
+    result->m_unbound_function = fn;
+
+    PyObject* self = result;
+    PyObject_INIT(self, type_object::instance());
+    return result;
+}
+
 bound_function::bound_function(const ref& target, const ref& fn)
     : python_object(type_object::instance()),
       m_target(target),

From f5fa4a460a27afdfb53b5054c6a9550c009b1817 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 3 Mar 2001 10:22:35 +0000
Subject: [PATCH 008/369] Wrong file name replaced (instance.hpp ->
 singleton.hpp).

[SVN r9390]
---
 src/gen_all.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/gen_all.py b/src/gen_all.py
index 416c66f1..3877d181 100644
--- a/src/gen_all.py
+++ b/src/gen_all.py
@@ -10,7 +10,7 @@ def gen_all(args):
     open('caller.hpp', 'w').write(gen_caller(args))
     open('init_function.hpp', 'w').write(gen_init_function(args))
     open('signatures.hpp', 'w').write(gen_signatures(args))
-    open('instance.hpp', 'w').write(gen_singleton(args))
+    open('singleton.hpp', 'w').write(gen_singleton(args))
     open('extension_class.hpp', 'w').write(gen_extclass(args))
 
 if __name__ == '__main__':

From 51d60a603590d559647283bbf3d9c33ebf866002 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 3 Mar 2001 11:48:52 +0000
Subject: [PATCH 009/369] added: converters for [plain] char and std::complex

[SVN r9397]
---
 include/boost/python/conversions.hpp | 39 ++++++++++++++++++++++++++++
 src/conversions.cpp                  | 21 +++++++++++++++
 test/comprehensive.cpp               | 34 ++++++++++++++++++++++++
 test/comprehensive.py                | 33 +++++++++++++++++++++++
 4 files changed, 127 insertions(+)

diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index d11f7f14..b633c0ee 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -5,6 +5,9 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+//
+// Revision History:
+// Mar 03 01  added: converters for [plain] char and std::complex (Ralf W. Grosse-Kunstleve)
 
 #ifndef METHOD_DWA122899_H_
 # define METHOD_DWA122899_H_
@@ -16,6 +19,7 @@
 # include <boost/smart_ptr.hpp>
 # include <boost/python/errors.hpp>
 # include <string>
+# include <complex>
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
 
@@ -100,6 +104,10 @@ 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(char);
+char from_python(PyObject*, boost::python::type<char>);
+char from_python(PyObject*, boost::python::type<const char&>);
+
 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&>);
@@ -130,6 +138,32 @@ 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&>);
 
+template <class T>
+PyObject* to_python(const std::complex<T>& sc) {
+    Py_complex pcc;
+    pcc.real = sc.real();
+    pcc.imag = sc.imag();
+    return PyComplex_FromCComplex(pcc);
+}
+
+template <class T>
+std::complex<T> from_python(PyObject* p,
+                            boost::python::type<const std::complex<T>&>) {
+    if (! PyComplex_Check(p)) {
+      PyErr_SetString(PyExc_TypeError, "expected a complex number");
+      throw boost::python::argument_error();
+    }
+    return std::complex<T>(
+      static_cast<T>(PyComplex_RealAsDouble(p)),
+      static_cast<T>(PyComplex_ImagAsDouble(p)));
+}
+
+template <class T>
+inline std::complex<T> from_python(PyObject* p,
+                                   boost::python::type<std::complex<T> >) {
+    return from_python(p, boost::python::type<const std::complex<T>&>());
+}
+
 // For when your C++ function really wants to pass/return a PyObject*
 PyObject* to_python(PyObject*);
 PyObject* from_python(PyObject*, boost::python::type<PyObject*>);
@@ -304,6 +338,11 @@ inline unsigned short from_python(PyObject* p, boost::python::type<const unsigne
     return from_python(p, boost::python::type<unsigned short>());
 }
 
+inline char from_python(PyObject* p, boost::python::type<const char&>)
+{
+    return from_python(p, boost::python::type<char>());
+}
+
 inline signed char from_python(PyObject* p, boost::python::type<const signed char&>)
 {
     return from_python(p, boost::python::type<signed char>());
diff --git a/src/conversions.cpp b/src/conversions.cpp
index ded01e0e..369f197a 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -5,6 +5,9 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+//
+// Revision History:
+// Mar 03 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
 
 #include <boost/python/conversions.hpp>
 #include <typeinfo>
@@ -160,6 +163,24 @@ unsigned short from_python(PyObject* p, boost::python::type<unsigned short> type
     return integer_from_python(p, type);
 }
 
+PyObject* to_python(char c)
+{
+    if (c == '\0') return PyString_FromString("");
+    return PyString_FromStringAndSize(&c, 1);
+}
+
+char from_python(PyObject* p, boost::python::type<char>)
+{
+    int l = -1;
+    if (PyString_Check(p)) l = PyString_Size(p);
+    if (l < 0 || l > 1) {
+        PyErr_SetString(PyExc_TypeError, "expected string of length 0 or 1");
+        throw boost::python::argument_error();
+    }
+    if (l == 0) return '\0';
+    return PyString_AsString(p)[0];
+}
+
 PyObject* to_python(unsigned char i)
 {
 	return integer_to_python(i);
diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 7fad74bb..592b0ebd 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -815,6 +815,25 @@ namespace bpl_test {
           w.set_secret_number(number);
   }
 
+  // Test plain char converters.
+  char get_plain_char() { return 'x'; }
+  std::string use_plain_char(char c) { return std::string(3, c); }
+  std::string use_const_plain_char(const char c) { return std::string(5, c); }
+
+  // Test std::complex<double> converters.
+  std::complex<double> dpolar(double rho, double theta) {
+    return std::polar(rho, theta);
+  }
+  double dreal(const std::complex<double>& c) { return c.real(); }
+  double dimag(std::complex<double> c) { return c.imag(); }
+
+  // Test std::complex<float> converters.
+  std::complex<float> fpolar(float rho, float theta) {
+    return std::polar(rho, theta);
+  }
+  double freal(const std::complex<float>& c) { return c.real(); }
+  double fimag(std::complex<float> c) { return c.imag(); }
+
 /************************************************************/
 /*                                                          */
 /*                       init the module                    */
@@ -1036,6 +1055,21 @@ void init_module(boost::python::module_builder& m)
     world_class.def(world_getinitargs, "__getinitargs__");
     world_class.def(world_getstate, "__getstate__");
     world_class.def(world_setstate, "__setstate__");
+
+    // Test plain char converters.
+    m.def(get_plain_char, "get_plain_char");
+    m.def(use_plain_char, "use_plain_char");
+    m.def(use_const_plain_char, "use_const_plain_char");
+
+    // Test std::complex<double> converters.
+    m.def(dpolar, "dpolar");
+    m.def(dreal, "dreal");
+    m.def(dimag, "dimag");
+
+    // Test std::complex<float> converters.
+    m.def(fpolar, "fpolar");
+    m.def(freal, "freal");
+    m.def(fimag, "fimag");
 }
 
 PyObject* raw(const boost::python::tuple& args, const boost::python::dictionary& keywords)
diff --git a/test/comprehensive.py b/test/comprehensive.py
index a8e181d2..8bc8021c 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -1070,6 +1070,39 @@ test methodologies for wrapping functions that return a pointer
     3
     >>> eo.second
     1
+
+======== test [plain] char converters ==============
+    >>> get_plain_char()
+    'x'
+    >>> use_plain_char('a')
+    'aaa'
+    >>> use_const_plain_char('b')
+    'bbbbb'
+
+======== test std::complex converters ==============
+    >>> c = dpolar(3, 5)
+    >>> type(c)
+    <type 'complex'>
+    >>> '%.3g' % (dreal(c))
+    '0.851'
+    >>> '%.3g' % (dimag(c))
+    '-2.88'
+    >>> '%.3g' % (freal(c))
+    '0.851'
+    >>> '%.3g' % (fimag(c))
+    '-2.88'
+    >>> c = fpolar(7, 13)
+    >>> type(c)
+    <type 'complex'>
+    >>> '%.3g' % (fimag(c))
+    '2.94'
+    >>> '%.3g' % (freal(c))
+    '6.35'
+    >>> '%.3g' % (dimag(c))
+    '2.94'
+    >>> '%.3g' % (dreal(c))
+    '6.35'
+
 '''
 
 from test import *

From 1d4427c056ef90b36aaaecc9babc86a778b82e95 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 3 Mar 2001 12:05:15 +0000
Subject: [PATCH 010/369] "T" replaced by "Held" to reduce chances of name
 clashes.

[SVN r9398]
---
 .../boost/python/detail/extension_class.hpp   | 30 +++++++++----------
 src/gen_extclass.py                           | 10 +++----
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 94d9bf6b..bf43ec5c 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -61,7 +61,7 @@ T* check_non_null(T* p)
     return p;
 }
 
-template <class T> class held_instance;
+template <class Held> class held_instance;
 
 typedef void* (*conversion_function_ptr)(void*);
 
@@ -613,33 +613,33 @@ class extension_class
 
 // 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
+template <class Held>
+class held_instance : public Held
 {
     // There are no member functions: we want to avoid inadvertently overriding
-    // any virtual functions in T.
+    // any virtual functions in Held.
 public:
-    held_instance(PyObject*) : T() {}
+    held_instance(PyObject*) : Held() {}
     template <class A1>
-    held_instance(PyObject*, A1 a1) : T(a1) {}
+    held_instance(PyObject*, A1 a1) : Held(a1) {}
     template <class A1, class A2>
-    held_instance(PyObject*, A1 a1, A2 a2) : T(a1, a2) {}
+    held_instance(PyObject*, A1 a1, A2 a2) : Held(a1, a2) {}
     template <class A1, class A2, class A3>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : T(a1, a2, a3) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : Held(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) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : Held(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) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : Held(a1, a2, a3, a4, a5) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : T(a1, a2, a3, a4, a5, a6) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : Held(a1, a2, a3, a4, a5, a6) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : T(a1, a2, a3, a4, a5, a6, a7) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : Held(a1, a2, a3, a4, a5, a6, a7) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : T(a1, a2, a3, a4, a5, a6, a7, a8) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : Held(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>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : Held(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>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : Held(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
 };
 
 // Abstract base class for all obj holders. Base for template class
diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index f8906970..7c378d45 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -66,7 +66,7 @@ T* check_non_null(T* p)
     return p;
 }
 
-template <class T> class held_instance;
+template <class Held> class held_instance;
 
 typedef void* (*conversion_function_ptr)(void*);
 
@@ -613,15 +613,15 @@ class extension_class
 
 // 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
+template <class Held>
+class held_instance : public Held
 {
     // There are no member functions: we want to avoid inadvertently overriding
-    // any virtual functions in T.
+    // any virtual functions in Held.
 public:"""
         + gen_functions("""%{
     template <%(class A%n%:, %)>%}
-    held_instance(PyObject*%(, A%n% a%n%)) : T(%(a%n%:, %)) {}""", args)
+    held_instance(PyObject*%(, A%n% a%n%)) : Held(%(a%n%:, %)) {}""", args)
         + """
 };
 

From b06d9e50ebf64969d198ab03430d21eb40cb8442 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 3 Mar 2001 12:55:53 +0000
Subject: [PATCH 011/369] added: pickle safety measures; bug fix: use
 bound_function::create()

[SVN r9399]
---
 include/boost/python/class_builder.hpp | 10 ++++++
 src/classes.cpp                        | 46 ++++++++++++++++++++------
 test/comprehensive.py                  | 41 +++++++++++++++++++++++
 3 files changed, 87 insertions(+), 10 deletions(-)

diff --git a/include/boost/python/class_builder.hpp b/include/boost/python/class_builder.hpp
index 7ef843c4..4a9ec1b2 100644
--- a/include/boost/python/class_builder.hpp
+++ b/include/boost/python/class_builder.hpp
@@ -1,3 +1,6 @@
+// Revision History:
+// Mar 03 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
+
 #ifndef CLASS_WRAPPER_DWA101000_H_
 # define CLASS_WRAPPER_DWA101000_H_
 
@@ -24,6 +27,13 @@ class class_builder
     
     ~class_builder()
     {}
+
+    inline void dict_defines_state() {
+      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__dict_defines_state__");
+    }
+    inline void getstate_manages_dict() {
+      add(ref(BOOST_PYTHON_CONVERSION::to_python(1)), "__getstate_manages_dict__");
+    }
     
     // define constructors
     template <class signature>
diff --git a/src/classes.cpp b/src/classes.cpp
index 2901aa81..625d67b7 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -5,6 +5,10 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+//
+// Revision History:
+// Mar 03 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
+// Mar 03 01  bug fix: use bound_function::create() (instead of new bound_function)
 
 #include <boost/python/classes.hpp>
 #include <boost/python/detail/functions.hpp>
@@ -67,8 +71,7 @@ namespace {
 
   ref global_class_reduce()
   {
-      static ref result(detail::new_wrapped_function(class_reduce));
-      return result;
+      return ref(detail::new_wrapped_function(class_reduce));
   }
   
 
@@ -93,17 +96,41 @@ namespace {
       ref getstate(PyObject_GetAttrString(obj, const_cast<char*>("__getstate__")),
                    ref::null_ok);
       PyErr_Clear();
+
+      ref dict(PyObject_GetAttrString(obj, const_cast<char*>("__dict__")), ref::null_ok);
+      PyErr_Clear();
+
       if (getstate.get() != 0)
       {
+          if (dict.get() != 0 && dictionary(dict).size() > 0)
+          {
+              ref getstate_manages_dict(PyObject_GetAttrString(instance_class.get(), const_cast<char*>("__getstate_manages_dict__")), ref::null_ok);
+              PyErr_Clear();
+              if (getstate_manages_dict.get() == 0)
+              {
+                  PyErr_SetString(PyExc_RuntimeError, "Incomplete pickle support (__getstate_manages_dict__ not set)");
+                  throw error_already_set();
+              }
+          }
+
           ref state = ref(PyEval_CallObject(getstate.get(), NULL));
           return tuple(instance_class, initargs, state);
       }
 
-      ref state(PyObject_GetAttrString(obj, const_cast<char*>("__dict__")), ref::null_ok);
-      PyErr_Clear();
-      if (state.get() != 0 && dictionary(state).size() > 0)
+      if (getinitargs.get() == 0)
       {
-          return tuple(instance_class, initargs, state);
+          ref dict_defines_state(PyObject_GetAttrString(instance_class.get(), const_cast<char*>("__dict_defines_state__")), ref::null_ok);
+          PyErr_Clear();
+          if (dict_defines_state.get() == 0)
+          {
+              PyErr_SetString(PyExc_RuntimeError, "Incomplete pickle support (__dict_defines_state__ not set)");
+              throw error_already_set();
+          }
+      }
+
+      if (dict.get() != 0 && dictionary(dict).size() > 0)
+      {
+          return tuple(instance_class, initargs, dict);
       }
 
       return tuple(instance_class, initargs);
@@ -111,8 +138,7 @@ namespace {
 
   ref global_instance_reduce()
   {
-      static ref result(detail::new_wrapped_function(instance_reduce));
-      return result;
+      return ref(detail::new_wrapped_function(instance_reduce));
   }
 }
 
@@ -177,7 +203,7 @@ namespace detail {
       if (!BOOST_CSTD_::strcmp(name, "__reduce__"))
       {
           ref target(as_object(this), ref::increment_count);
-          return new bound_function(target, global_class_reduce());
+          return bound_function::create(target, global_class_reduce());
       }
       
       ref local_attribute = m_name_space.get_item(string(name).reference());
@@ -348,7 +374,7 @@ PyObject* instance::getattr(const char* name, bool use_special_function)
 
     if (!BOOST_CSTD_::strcmp(name, "__reduce__"))
     {
-      return new detail::bound_function(ref(this, ref::increment_count), global_instance_reduce());
+      return detail::bound_function::create(ref(this, ref::increment_count), global_instance_reduce());
     }
     
     ref local_attribute = m_name_space.get_item(string(name).reference());
diff --git a/test/comprehensive.py b/test/comprehensive.py
index 8bc8021c..3c7f3c61 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -239,6 +239,47 @@ Pickling tests:
     Hello from California! 42
     Hello from California! 0
 
+Pickle safety measures:
+    >>> r=Rational(3, 4)
+    >>> r
+    Rational(3, 4)
+    >>> try: s=pickle.dumps(r)
+    ... except RuntimeError, err: print err[0]
+    ... 
+    Incomplete pickle support (__dict_defines_state__ not set)
+    >>> class myrational(Rational):
+    ...   __dict_defines_state__ = 1 # this is a lie but good enough for testing.
+    ...             
+    >>> r=myrational(3, 4)
+    >>> r
+    Rational(3, 4)
+    >>> s=pickle.dumps(r)
+
+    >>> class myworld(world):
+    ...   def __init__(self):
+    ...     world.__init__(self, 'anywhere')
+    ...     self.x = 1
+    ... 
+    >>> w = myworld()
+    >>> w.greet()
+    'Hello from anywhere!'
+    >>> w.__dict__
+    {'x': 1}
+    >>> try: s=pickle.dumps(w)
+    ... except RuntimeError, err: print err[0]
+    ... 
+    Incomplete pickle support (__getstate_manages_dict__ not set)
+
+    >>> class myunsafeworld(myworld):
+    ...   __getstate_manages_dict__ = 1 # this is a lie but good enough for testing.
+    ... 
+    >>> w = myunsafeworld()
+    >>> w.greet()
+    'Hello from anywhere!'
+    >>> w.__dict__
+    {'x': 1}
+    >>> s=pickle.dumps(w)
+
 Special member attributes. Tests courtesy of Barry Scott <barry@scottb.demon.co.uk>
 
     >>> class DerivedFromFoo(Foo):

From fc62d3b44ec404cb470746c3c681764b846b88a8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 3 Mar 2001 14:46:26 +0000
Subject: [PATCH 012/369] New Makefiles for tru64_cxx, linux_gcc, mingw32.

[SVN r9400]
---
 build/Makefile.linux_gcc | 166 +++++++++++++++++++++++++++++++
 build/Makefile.mingw32   | 210 +++++++++++++++++++++++++++++++++++++++
 build/Makefile.tru64_cxx | 170 +++++++++++++++++++++++++++++++
 build/tru64.mak          |  51 ----------
 4 files changed, 546 insertions(+), 51 deletions(-)
 create mode 100644 build/Makefile.linux_gcc
 create mode 100644 build/Makefile.mingw32
 create mode 100644 build/Makefile.tru64_cxx
 delete mode 100644 build/tru64.mak

diff --git a/build/Makefile.linux_gcc b/build/Makefile.linux_gcc
new file mode 100644
index 00000000..3e8f1041
--- /dev/null
+++ b/build/Makefile.linux_gcc
@@ -0,0 +1,166 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Set the BOOST pathname below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+
+BOOST= /net/cci/rwgk/boost
+
+PYEXE= /usr/local/Python-1.5.2/bin/python
+PYINC= -I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE= /usr/local/Python-2.0/bin/python
+#PYINC= -I/usr/local/Python-2.0/include/python2.0
+#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
+#STLPORTOPTS= \
+# -D__USE_STD_IOSTREAM \
+# -D__STL_NO_SGI_IOSTREAMS \
+# -D__STL_USE_NATIVE_STRING \
+# -D__STL_NO_NEW_C_HEADERS \
+# -D_RWSTD_COMPILE_INSTANTIATE=1
+#STLPORTINC= -I/usr/local/STLport-4.1b4/stlport
+#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
+#STLPORTINC= -I/net/cci/xp/C++_C_headers
+
+STDOPTS= -ftemplate-depth-21
+WARNOPTS=
+# use -msg_display_number to obtain integer tags for -msg_disable
+
+CPP= g++
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS) -g
+MAKEDEP= -M
+
+LD= g++
+LDOPTS= -shared
+
+#HIDDEN= -hidden
+
+BPL_SRC = $(BOOST)/libs/python/src
+BPL_TST = $(BOOST)/libs/python/test
+BPL_EXA = $(BOOST)/libs/python/example
+SOFTLINKS = \
+$(BPL_SRC)/classes.cpp \
+$(BPL_SRC)/conversions.cpp \
+$(BPL_SRC)/extension_class.cpp \
+$(BPL_SRC)/functions.cpp \
+$(BPL_SRC)/init_function.cpp \
+$(BPL_SRC)/module_builder.cpp \
+$(BPL_SRC)/objects.cpp \
+$(BPL_SRC)/types.cpp \
+$(BPL_TST)/comprehensive.cpp \
+$(BPL_TST)/comprehensive.hpp \
+$(BPL_TST)/comprehensive.py \
+$(BPL_TST)/doctest.py \
+$(BPL_EXA)/abstract.cpp \
+$(BPL_EXA)/getting_started1.cpp \
+$(BPL_EXA)/getting_started2.cpp \
+$(BPL_EXA)/getting_started3.cpp \
+$(BPL_EXA)/getting_started4.cpp \
+$(BPL_EXA)/getting_started5.cpp \
+$(BPL_EXA)/test_abstract.py \
+$(BPL_EXA)/test_getting_started1.py \
+$(BPL_EXA)/test_getting_started2.py \
+$(BPL_EXA)/test_getting_started3.py \
+$(BPL_EXA)/test_getting_started4.py \
+$(BPL_EXA)/test_getting_started5.py
+
+OBJ = classes.o conversions.o extension_class.o functions.o \
+      init_function.o module_builder.o \
+      objects.o types.o
+DEPOBJ= $(OBJ) comprehensive.o abstract.o \
+        getting_started1.o getting_started2.o getting_started3.o \
+        getting_started4.o getting_started5.o
+
+.SUFFIXES: .o .cpp
+
+all: libbpl.a test.so abstract.so \
+     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started4.so getting_started5.so
+
+softlinks:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ ! -e "$$bn" ]; then \
+              echo "ln -s $$pn ."; \
+	      ln -s "$$pn" .; \
+            else \
+              echo "info: no softlink created (file exists): $$bn"; \
+	    fi; \
+	  done
+
+unlink:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ -L "$$bn" ]; then \
+              echo "rm $$bn"; \
+              rm "$$bn"; \
+            elif [ -e "$$bn" ]; then \
+              echo "info: not a softlink: $$bn"; \
+	    fi; \
+	  done
+
+libbpl.a: $(OBJ)
+	rm -f libbpl.a
+	ar r libbpl.a $(OBJ)
+
+test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+getting_started3.so: $(OBJ) getting_started3.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
+
+getting_started4.so: $(OBJ) getting_started4.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.so
+
+getting_started5.so: $(OBJ) getting_started5.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_getting_started4.py
+	$(PYEXE) test_getting_started5.py
+
+clean:
+	rm -f $(OBJ) libbpl.a libbpl.a.input
+	rm -f comprehensive.o test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f getting_started3.o getting_started3.so
+	rm -f getting_started4.o getting_started4.so
+	rm -f getting_started5.o getting_started5.so
+	rm -f so_locations *.pyc
+	rm -rf cxx_repository
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+
diff --git a/build/Makefile.mingw32 b/build/Makefile.mingw32
new file mode 100644
index 00000000..2d86efcd
--- /dev/null
+++ b/build/Makefile.mingw32
@@ -0,0 +1,210 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Set the BOOST_* pathnames below.
+#
+#   The idea is that the build directory is on a Unix filesystem that
+#   is mounted on a PC using SAMBA. Use this makefile under both Unix
+#   and Windows:
+#
+#   Unix: make softlinks     Create softlinks to source code and tests
+#   Win:  make               Compile all sources
+#   Win:  make test          Run doctest tests
+#   Unix: make clean         Remove all object files
+#   Unix: make unlink        Remove softlinks
+
+# To install mingw32, follow instructions at:
+#   http://starship.python.net/crew/kernr/mingw32/Notes.html
+# In particular, install:
+#   ftp://ftp.xraylith.wisc.edu/pub/khan/gnu-win32/mingw32/gcc-2.95.2/gcc-2.95.2-msvcrt.exe
+#   ftp://ftp.xraylith.wisc.edu/pub/khan/gnu-win32/mingw32/gcc-2.95.2/fixes/quote-fix-msvcrt.exe
+#   http://starship.python.net/crew/kernr/mingw32/Python-1.5.2-mingw32.zip
+# Unpack the first two archives in the default locations and update your PATH.
+# Unpack the third archive in \usr.
+
+# Note: comprehensive.cpp generates compiler errors and later crashes.
+#   L:\boost\boost\python\detail\extension_class.hpp:643: warning:
+#   alignment of `vtable for class
+#   boost::python::detail::held_instance<bpl_test::Derived1>'
+#   is greater than maximum object file alignment. Using 16.
+# Could this be fixed with compiler options?
+# -fhuge-objects looks interesting, but requires recompiling the C++ library.
+#                (what exactly does that mean?)
+# -fvtable-thunks eliminates the compiler warning, but "import test" still
+#                 causes a crash.
+
+BOOST_UNIX= /net/cci/rwgk/boost
+BOOST_WIN= "L:\boost"
+
+PYEXE= "C:\Program files\Python\python.exe"
+PYINC= -I"C:\usr\include\python1.5"
+PYLIB= "C:\usr\lib\libpython15.a"
+
+STDOPTS= -ftemplate-depth-21
+WARNOPTS=
+
+CPP= g++
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS) -g
+
+LD= g++
+LDOPTS= -shared
+
+BPL_SRC = $(BOOST_UNIX)/libs/python/src
+BPL_TST = $(BOOST_UNIX)/libs/python/test
+BPL_EXA = $(BOOST_UNIX)/libs/python/example
+SOFTLINKS = \
+$(BPL_SRC)/classes.cpp \
+$(BPL_SRC)/conversions.cpp \
+$(BPL_SRC)/extension_class.cpp \
+$(BPL_SRC)/functions.cpp \
+$(BPL_SRC)/init_function.cpp \
+$(BPL_SRC)/module_builder.cpp \
+$(BPL_SRC)/objects.cpp \
+$(BPL_SRC)/types.cpp \
+$(BPL_TST)/comprehensive.cpp \
+$(BPL_TST)/comprehensive.hpp \
+$(BPL_TST)/comprehensive.py \
+$(BPL_TST)/doctest.py \
+$(BPL_EXA)/abstract.cpp \
+$(BPL_EXA)/getting_started1.cpp \
+$(BPL_EXA)/getting_started2.cpp \
+$(BPL_EXA)/getting_started3.cpp \
+$(BPL_EXA)/getting_started4.cpp \
+$(BPL_EXA)/getting_started5.cpp \
+$(BPL_EXA)/passing_char.cpp \
+$(BPL_EXA)/test_abstract.py \
+$(BPL_EXA)/test_getting_started1.py \
+$(BPL_EXA)/test_getting_started2.py \
+$(BPL_EXA)/test_getting_started3.py \
+$(BPL_EXA)/test_getting_started4.py \
+$(BPL_EXA)/test_getting_started5.py
+
+DEFS= \
+test \
+abstract \
+getting_started1 \
+getting_started2 \
+getting_started3 \
+getting_started4 \
+getting_started5
+
+OBJ = classes.o conversions.o extension_class.o functions.o \
+      init_function.o module_builder.o \
+      objects.o types.o
+
+.SUFFIXES: .o .cpp
+
+all: libbpl.a test.pyd abstract.pyd \
+     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
+     getting_started4.pyd getting_started5.pyd
+
+softlinks: defs
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ ! -e "$$bn" ]; then \
+              echo "ln -s $$pn ."; \
+	      ln -s "$$pn" .; \
+            else \
+              echo "info: no softlink created (file exists): $$bn"; \
+	    fi; \
+	  done
+
+unlink: rmdefs
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ -L "$$bn" ]; then \
+              echo "rm $$bn"; \
+              rm "$$bn"; \
+            elif [ -e "$$bn" ]; then \
+              echo "info: not a softlink: $$bn"; \
+	    fi; \
+	  done
+
+defs:
+	@ for def in $(DEFS); \
+	  do \
+            echo "EXPORTS\n\tinit$$def" > $$def.def; \
+	  done
+
+rmdefs:
+	@ for def in $(DEFS); \
+	  do \
+            rm $$def.def; \
+	  done
+
+libbpl.a: $(OBJ)
+	del libbpl.a
+	ar r libbpl.a $(OBJ)
+
+DLLWRAPOPTS= -s --driver-name g++ -s
+             --entry _DllMainCRTStartup@12 --target=i386-mingw32
+
+test.pyd: $(OBJ) comprehensive.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname test.pyd \
+          --def test.def \
+          $(OBJ) comprehensive.o $(PYLIB)
+
+abstract.pyd: $(OBJ) abstract.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname abstract.pyd \
+          --def abstract.def \
+          $(OBJ) abstract.o $(PYLIB)
+
+getting_started1.pyd: $(OBJ) getting_started1.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started1.pyd \
+          --def getting_started1.def \
+          $(OBJ) getting_started1.o $(PYLIB)
+
+getting_started2.pyd: $(OBJ) getting_started2.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started2.pyd \
+          --def getting_started2.def \
+          $(OBJ) getting_started2.o $(PYLIB)
+
+getting_started3.pyd: $(OBJ) getting_started3.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started3.pyd \
+          --def getting_started3.def \
+          $(OBJ) getting_started3.o $(PYLIB)
+
+getting_started4.pyd: $(OBJ) getting_started4.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started4.pyd \
+          --def getting_started4.def \
+          $(OBJ) getting_started4.o $(PYLIB)
+
+getting_started5.pyd: $(OBJ) getting_started5.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname getting_started5.pyd \
+          --def getting_started5.def \
+          $(OBJ) getting_started5.o $(PYLIB)
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_getting_started4.py
+	$(PYEXE) test_getting_started5.py
+
+clean:
+	rm -f $(OBJ) libbpl.a libbpl.a.input
+	rm -f comprehensive.o test.pyd
+	rm -f abstract.o abstract.pyd
+	rm -f getting_started1.o getting_started1.pyd
+	rm -f getting_started2.o getting_started2.pyd
+	rm -f getting_started3.o getting_started3.pyd
+	rm -f getting_started4.o getting_started4.pyd
+	rm -f getting_started5.o getting_started5.pyd
+	rm -f so_locations *.pyc
+	rm -rf cxx_repository
diff --git a/build/Makefile.tru64_cxx b/build/Makefile.tru64_cxx
new file mode 100644
index 00000000..7b932bd3
--- /dev/null
+++ b/build/Makefile.tru64_cxx
@@ -0,0 +1,170 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Set the BOOST pathname below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+
+BOOST= /net/cci/rwgk/boost
+
+PYEXE= /usr/local/Python-1.5.2/bin/python
+PYINC= -I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE= /usr/local/Python-2.0/bin/python
+#PYINC= -I/usr/local/Python-2.0/include/python2.0
+#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
+#STLPORTOPTS= \
+# -D__USE_STD_IOSTREAM \
+# -D__STL_NO_SGI_IOSTREAMS \
+# -D__STL_USE_NATIVE_STRING \
+# -D__STL_NO_NEW_C_HEADERS \
+# -D_RWSTD_COMPILE_INSTANTIATE=1
+#STLPORTINC= -I/usr/local/STLport-4.1b4/stlport
+#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
+STLPORTINC= -I/net/cci/xp/C++_C_headers
+
+STDOPTS= -std strict_ansi
+WARNOPTS= -msg_disable 186,450,1115
+# use -msg_display_number to obtain integer tags for -msg_disable
+
+CPP= cxx
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS) -g
+MAKEDEP= -Em
+
+LD= cxx
+LDOPTS= -shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
+
+#HIDDEN= -hidden
+
+BPL_SRC = $(BOOST)/libs/python/src
+BPL_TST = $(BOOST)/libs/python/test
+BPL_EXA = $(BOOST)/libs/python/example
+SOFTLINKS = \
+$(BPL_SRC)/classes.cpp \
+$(BPL_SRC)/conversions.cpp \
+$(BPL_SRC)/extension_class.cpp \
+$(BPL_SRC)/functions.cpp \
+$(BPL_SRC)/init_function.cpp \
+$(BPL_SRC)/module_builder.cpp \
+$(BPL_SRC)/objects.cpp \
+$(BPL_SRC)/types.cpp \
+$(BPL_TST)/comprehensive.cpp \
+$(BPL_TST)/comprehensive.hpp \
+$(BPL_TST)/comprehensive.py \
+$(BPL_TST)/doctest.py \
+$(BPL_EXA)/abstract.cpp \
+$(BPL_EXA)/getting_started1.cpp \
+$(BPL_EXA)/getting_started2.cpp \
+$(BPL_EXA)/getting_started3.cpp \
+$(BPL_EXA)/getting_started4.cpp \
+$(BPL_EXA)/getting_started5.cpp \
+$(BPL_EXA)/test_abstract.py \
+$(BPL_EXA)/test_getting_started1.py \
+$(BPL_EXA)/test_getting_started2.py \
+$(BPL_EXA)/test_getting_started3.py \
+$(BPL_EXA)/test_getting_started4.py \
+$(BPL_EXA)/test_getting_started5.py
+
+OBJ = classes.o conversions.o extension_class.o functions.o \
+      init_function.o module_builder.o \
+      objects.o types.o
+DEPOBJ= $(OBJ) comprehensive.o abstract.o \
+        getting_started1.o getting_started2.o getting_started3.o \
+        getting_started4.o getting_started5.o
+
+.SUFFIXES: .o .cpp
+
+all: libbpl.a test.so abstract.so \
+     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started4.so getting_started5.so
+
+softlinks:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ ! -e "$$bn" ]; then \
+              echo "ln -s $$pn ."; \
+	      ln -s "$$pn" .; \
+            else \
+              echo "info: no softlink created (file exists): $$bn"; \
+	    fi; \
+	  done
+
+unlink:
+	@ for pn in $(SOFTLINKS); \
+	  do \
+            bn=`basename "$$pn"`; \
+	    if [ -L "$$bn" ]; then \
+              echo "rm $$bn"; \
+              rm "$$bn"; \
+            elif [ -e "$$bn" ]; then \
+              echo "info: not a softlink: $$bn"; \
+	    fi; \
+	  done
+
+libbpl.a: $(OBJ)
+	rm -f libbpl.a
+	cd cxx_repository; \
+          ls -1 > ../libbpl.a.input; \
+          ar r ../libbpl.a -input ../libbpl.a.input
+	rm -f libbpl.a.input
+	ar r libbpl.a $(OBJ)
+
+test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+getting_started3.so: $(OBJ) getting_started3.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
+
+getting_started4.so: $(OBJ) getting_started4.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.so
+
+getting_started5.so: $(OBJ) getting_started5.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_getting_started4.py
+	$(PYEXE) test_getting_started5.py
+
+clean:
+	rm -f $(OBJ) libbpl.a libbpl.a.input
+	rm -f comprehensive.o test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f getting_started3.o getting_started3.so
+	rm -f getting_started4.o getting_started4.so
+	rm -f getting_started5.o getting_started5.so
+	rm -f so_locations *.pyc
+	rm -rf cxx_repository
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+
diff --git a/build/tru64.mak b/build/tru64.mak
deleted file mode 100644
index 6631615c..00000000
--- a/build/tru64.mak
+++ /dev/null
@@ -1,51 +0,0 @@
-#
-# Tested with:
-# Compaq C++ V6.2-024 for Digital UNIX V5.0 (Rev. 910)
-#
-# Python 1.5.2 was installed without any customizations.
-# boost_all.zip vers. 1.18.1 was unpacked using unzip -aa and not modified.
-# STLport-4.1b3 was unpacked using unzip -aa and not modified.
-#
-# Initial version 2000-10-20: Ralf W. Grosse-Kunstleve, rwgk@cci.lbl.gov
-#
-
-PYINC= /usr/local/include/python1.5
-BOOSTINC= /usr/local/boost_1_18_1
-STLPORTINC= /usr/local/STLport-4.1b3/stlport
-STLPORTOPTS= \
- -D__USE_STD_IOSTREAM \
- -D__STL_NO_SGI_IOSTREAMS \
- -D__STL_NO_NEW_C_HEADERS \
- -D_RWSTD_COMPILE_INSTANTIATE=1
-
-STDOPTS= -std strict_ansi
-WARNOPTS= -msg_disable 186,450,1115
-# use -msg_display_number to obtain integer tags for -msg_disable
-
-CPP= cxx
-CPPOPTS= -I$(STLPORTINC) $(STLPORTOPTS) -I$(BOOSTINC) -I$(PYINC) \
-         $(STDOPTS) $(WARNOPTS)
-
-LD= cxx
-LDOPTS= -shared -expect_unresolved '*'
-
-OBJ = extclass.o functions.o init_function.o module.o newtypes.o \
-      objects.o py.o subclass.o
-
-.SUFFIXES: .o .cpp
-
-all: demo.so hello.so
-
-demo.so: $(OBJ) extclass_demo.o
-	$(LD) $(LDOPTS) $(OBJ) extclass_demo.o -o demo.so
-
-hello.so: $(OBJ) example1.o
-	$(LD) $(LDOPTS) $(OBJ) example1.o -o hello.so
-
-.cpp.o:
-	-$(CPP) $(CPPOPTS) $(INC) -c $*.cpp
-
-clean:
-	rm -f $(OBJ) extclass_demo.o example1.o demo.so hello.so so_locations
-	rm -rf cxx_repository
-	rm -f *.pyc

From 28e6a84acbf5c2fe893d5ca74b49dc78764588e9 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:10:16 +0000
Subject: [PATCH 013/369] Fixed std::complex<> stuff to work with MSVC

[SVN r9408]
---
 include/boost/python/conversions.hpp | 82 +++++++++++++++++++++-------
 1 file changed, 61 insertions(+), 21 deletions(-)

diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index b633c0ee..47f80989 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -7,7 +7,9 @@
 //  producing this work.
 //
 // Revision History:
-// Mar 03 01  added: converters for [plain] char and std::complex (Ralf W. Grosse-Kunstleve)
+// 04 Mar 01  Fixed std::complex<> stuff to work with MSVC (David Abrahams)
+// 03 Mar 01  added: converters for [plain] char and std::complex
+//            (Ralf W. Grosse-Kunstleve)
 
 #ifndef METHOD_DWA122899_H_
 # define METHOD_DWA122899_H_
@@ -19,8 +21,18 @@
 # include <boost/smart_ptr.hpp>
 # include <boost/python/errors.hpp>
 # include <string>
+
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  pragma warning(push)
+#  pragma warning(disable:4275) // disable a bogus warning caused by <complex>
+# endif
+
 # include <complex>
 
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  pragma warning(pop)
+# endif
+
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
 
 // This can be instantiated on an enum to provide the to_python/from_python
@@ -74,6 +86,30 @@ inline void xdecref(T* p)
 	xdecref_impl(reinterpret_cast<PyObject*>(p_base));
 }
 
+namespace detail {
+
+  void expect_complex(PyObject*);
+
+  template <class T>
+  std::complex<T> complex_from_python(PyObject* p, boost::python::type<T>)
+  {
+      expect_complex(p);
+
+      return std::complex<T>(
+        static_cast<T>(PyComplex_RealAsDouble(p)),
+        static_cast<T>(PyComplex_ImagAsDouble(p)));
+  }
+
+  template <class T>
+  PyObject* complex_to_python(const std::complex<T>& sc) {
+      Py_complex pcc;
+      pcc.real = sc.real();
+      pcc.imag = sc.imag();
+      return PyComplex_FromCComplex(pcc);
+  }
+
+}
+
 }} // namespace boost::python
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
@@ -138,30 +174,34 @@ 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&>);
 
-template <class T>
-PyObject* to_python(const std::complex<T>& sc) {
-    Py_complex pcc;
-    pcc.real = sc.real();
-    pcc.imag = sc.imag();
-    return PyComplex_FromCComplex(pcc);
+inline PyObject* to_python(const std::complex<float>& x)
+{
+    return boost::python::detail::complex_to_python<float>(x);
 }
 
-template <class T>
-std::complex<T> from_python(PyObject* p,
-                            boost::python::type<const std::complex<T>&>) {
-    if (! PyComplex_Check(p)) {
-      PyErr_SetString(PyExc_TypeError, "expected a complex number");
-      throw boost::python::argument_error();
-    }
-    return std::complex<T>(
-      static_cast<T>(PyComplex_RealAsDouble(p)),
-      static_cast<T>(PyComplex_ImagAsDouble(p)));
+inline PyObject* to_python(const std::complex<double>& x)
+{
+    return boost::python::detail::complex_to_python<double>(x);
 }
 
-template <class T>
-inline std::complex<T> from_python(PyObject* p,
-                                   boost::python::type<std::complex<T> >) {
-    return from_python(p, boost::python::type<const std::complex<T>&>());
+inline std::complex<double> from_python(PyObject* p,
+                                   boost::python::type<std::complex<double> >) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
+}
+
+inline std::complex<double> from_python(PyObject* p,
+                                   boost::python::type<const std::complex<double>&>) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<double>());
+}
+
+inline std::complex<float> from_python(PyObject* p,
+                                   boost::python::type<std::complex<float> >) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
+}
+
+inline std::complex<float> from_python(PyObject* p,
+                                   boost::python::type<const std::complex<float>&>) {
+    return boost::python::detail::complex_from_python(p, boost::python::type<float>());
 }
 
 // For when your C++ function really wants to pass/return a PyObject*

From 0b97d9bae58d79e4c834f9e5a809a4fe36116368 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:12:30 +0000
Subject: [PATCH 014/369] Some fixes so it will compile with Intel C++

[SVN r9409]
---
 include/boost/python/detail/config.hpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index faf52ee4..3207f7c6 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -6,6 +6,9 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 
+//  Revision History:
+//  04 Mar 01  Some fixes so it will compile with Intel C++ (Dave Abrahams)
+
 #ifndef CONFIG_DWA052200_H_
 # define CONFIG_DWA052200_H_
 
@@ -46,8 +49,9 @@
 # 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)
+// user is concerned), but without it you need a fix if you're using MSVC or
+// Intel C++
+# if defined(BOOST_MSVC_STD_ITERATOR)
 #  define BOOST_CSTD_
 # else
 #  define BOOST_CSTD_ std

From a40daca9ef899a340608ee22b729a53160bb46b1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:14:04 +0000
Subject: [PATCH 015/369] *** empty log message ***

[SVN r9410]
---
 include/boost/python/detail/wrap_python.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index 9e57c287..d5b75374 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -16,7 +16,8 @@
 //  compiler command-line.
 
 // Revision History:
-// 01 Mar 01  define PyObject_INIT() for Python 1.x
+// 04 Mar 01  Rolled in some changes from the Dragon fork (Dave Abrahams)
+// 01 Mar 01  define PyObject_INIT() for Python 1.x (Dave Abrahams)
 
 #ifdef _DEBUG
 # ifndef BOOST_DEBUG_PYTHON
@@ -64,6 +65,8 @@ typedef int pid_t;
 #   define _MSC_VER 900
 #  endif
 
+# elif defined(_MSC_VER)
+#  include <limits> // prevents Python.h from defining LONGLONG_MAX, LONGLONG_MIN, and ULONGLONG_MAX
 # endif
 
 #endif // _WIN32

From 71aff9f0e8fce2dda850f08f861dc9fcbbc3f39b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:41:47 +0000
Subject: [PATCH 016/369] Changed library name to libboost_python.a

[SVN r9411]
---
 build/como.mak | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/build/como.mak b/build/como.mak
index 5a9920d8..c6f340a5 100644
--- a/build/como.mak
+++ b/build/como.mak
@@ -1,3 +1,5 @@
+# Revision History:
+# 04 Mar 01  Changed library name to libboost_python.a (David Abrahams)
 LIBSRC = \
     classes.cpp \
     conversions.cpp \
@@ -30,8 +32,8 @@ endif
             | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
                 [ -s $@ ] || rm -f $@
 
-example1: example1.o libpycpp.a
-	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYHTON_LIB) example1.o -L. -lpycpp
+example1: example1.o libboost_python.a
+	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYHTON_LIB) example1.o -L. -lboost_python
 	python ../example/test_example1.py
 
 example1.o: ../example/example1.cpp
@@ -40,9 +42,9 @@ example1.o: ../example/example1.cpp
 clean:
 	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
 
-libpycpp.a: $(LIBOBJ)
-	rm -f libpycpp.a
-	ar cq libpycpp.a $(LIBOBJ)
+libboost_python.a: $(LIBOBJ)
+	rm -f libboost_python.a
+	ar cq libboost_python.a $(LIBOBJ)
 
 DEP = $(OBJ:.o=.d)
 

From 4aa4f1c3b3b625450c1875548a49731db8bd6f3d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:45:02 +0000
Subject: [PATCH 017/369] Added DebugPython target; cleaned up some mess
 introduced by others

[SVN r9412]
---
 build/bpl_static.dsp | 31 ++++++++++++++++++++++++++++---
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/build/bpl_static.dsp b/build/bpl_static.dsp
index 701dd309..92af59c7 100644
--- a/build/bpl_static.dsp
+++ b/build/bpl_static.dsp
@@ -4,7 +4,7 @@
 
 # TARGTYPE "Win32 (x86) Static Library" 0x0104
 
-CFG=bpl_static - Win32 Debug
+CFG=bpl_static - Win32 DebugPython
 !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 !MESSAGE use the Export Makefile command and run
 !MESSAGE 
@@ -13,12 +13,13 @@ CFG=bpl_static - Win32 Debug
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
 !MESSAGE 
-!MESSAGE NMAKE /f "bpl_static.mak" CFG="bpl_static - Win32 Debug"
+!MESSAGE NMAKE /f "bpl_static.mak" CFG="bpl_static - Win32 DebugPython"
 !MESSAGE 
 !MESSAGE Possible choices for configuration are:
 !MESSAGE 
 !MESSAGE "bpl_static - Win32 Release" (based on "Win32 (x86) Static Library")
 !MESSAGE "bpl_static - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE "bpl_static - Win32 DebugPython" (based on "Win32 (x86) Static Library")
 !MESSAGE 
 
 # Begin Project
@@ -64,7 +65,30 @@ LIB32=link.exe -lib
 # PROP Intermediate_Dir "Debug"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W4 /WX /Gm /GR /GX /ZI /Od /I "d:\boost\type_traits" /I "..\..\.." /I "c:\progra~1\python20\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "bpl_static - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "bpl_static___Win32_DebugPython"
+# PROP BASE Intermediate_Dir "bpl_static___Win32_DebugPython"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugPython"
+# PROP Intermediate_Dir "DebugPython"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "BOOST_DEBUG_PYTHON" /FR /YX /FD /GZ /EHs /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe
@@ -80,6 +104,7 @@ LIB32=link.exe -lib
 
 # Name "bpl_static - Win32 Release"
 # Name "bpl_static - Win32 Debug"
+# Name "bpl_static - Win32 DebugPython"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

From 4b926b7c7fa3aaf563745281034ed2405cf8b36b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:48:50 +0000
Subject: [PATCH 018/369] Changed library name to libboost_python.a, various
 cleanups, attempted Cygwin compatibility. Still needs testing on Linux.

[SVN r9413]
---
 build/gcc.mak | 40 ++++++++++++++++++++++++++++++----------
 1 file changed, 30 insertions(+), 10 deletions(-)

diff --git a/build/gcc.mak b/build/gcc.mak
index d0b42548..f71185e0 100644
--- a/build/gcc.mak
+++ b/build/gcc.mak
@@ -1,3 +1,10 @@
+#  Revision History
+
+#  04 Mar 01 Changed library name to libboost_python.a, various cleanups,
+#            attempted Cygwin compatibility. Still needs testing on Linux
+#            (David Abrahams)
+
+
 LIBSRC = \
     classes.cpp \
     conversions.cpp \
@@ -11,13 +18,16 @@ LIBSRC = \
 LIBOBJ = $(LIBSRC:.cpp=.o)
 OBJ = $(LIBOBJ)
 
+PYTHON_INC=$(ROOT)/usr/local/include/python2.0
+# libpython2.0.dll
 
 ifeq "$(OS)" "Windows_NT"
-PYTHON_LIB=c:/tools/python/libs/python15.lib
-INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -Ic:/tools/python/include
+ROOT=c:/cygnus
+INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -I$(PYTHON_INC)
 MODULE_EXTENSION=dll
+PYTHON_LIB=c:/cygnus/usr/local/lib/python2.0/config/libpython2.0.dll.a
 else
-INC = -I/usr/local/include/python1.5
+INC = -I$(PYTHON_INC)
 MODULE_EXTENSION=so
 endif
 
@@ -31,20 +41,30 @@ endif
                 [ -s $@ ] || rm -f $@
 
 
-example1: example1.o libpycpp.a
-	g++ -shared -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYHTON_LIB) example1.o -L. -lpycpp
-	python ../example/test_example1.py
+PYTHON = python
+
+test: comprehensive.o libboost_python.a
+	g++ $(CXXFLAGS) -shared -o ../test/boost_python_test.$(MODULE_EXTENSION) comprehensive.o -L. -lboost_python  $(PYTHON_LIB)
+	$(PYTHON) ../test/comprehensive.py
+
+comprehensive.o: ../test/comprehensive.cpp
+	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
+
+
+example1: example1.o libboost_python.a
+	g++ $(CXXFLAGS) -shared -o ../example/hellomodule.$(MODULE_EXTENSION) example1.o -L. -lboost_python  $(PYTHON_LIB)
+	$(PYTHON) ../example/test_example1.py
 
 example1.o: ../example/example1.cpp
-	g++ -fPIC -Wall -W $(INC) -o $*.o -c $<
+	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
 
 
 clean:
 	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
 
-libpycpp.a: $(LIBOBJ)
-	rm -f libpycpp.a
-	ar cq libpycpp.a $(LIBOBJ)
+libboost_python.a: $(LIBOBJ)
+	rm -f libboost_python.a
+	ar cq libboost_python.a $(LIBOBJ)
 
 DEP = $(OBJ:.o=.d)
 

From f82151f925a3481ea05dd1b095069d5b5401f3ab Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:48:55 +0000
Subject: [PATCH 019/369] no message

[SVN r9414]
---
 build/build.opt | Bin 84480 -> 80384 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/build/build.opt b/build/build.opt
index a650cf1f83e6ca05cbe1a0fccd96f89b59f47f31..9cdea95b7eef30bf876fd69fc7e9971cd8f4a6f9 100644
GIT binary patch
literal 80384
zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;!F$-42&?o00YCn|NsAkxG);Tu3%tb_&*AU
zObGn_|Np-N0|Nsy0|NsK0|Nsq0|PkD*%=rZI2afhI2jlixEL51xEUbv&C9^Rz{kMA
zz|X+IAi%)DAjrVLAjH7HAk4tPAi}`FAPQ9{&cMJR!N9;E$-uxM#lXNI&A`AQ!@$5G
z%fP@O$H2fK4^`*Sz`&ryz`&r)z`&rwz`&r&z`&r!z`&r+z`&rvz`&r%z`&pdRjb3m
zz@W>(z@W##z@X2-z+k|@z+lM0z+l9{z+lY4z+eJZXU4$5V9vn6V8Ot^V9CJ1V8y_|
zV9mh5V8g(`V9UV3V8_6~V9&t7;K0DZ;K;zh-~`p@!oa}b%D}+j#=yYf&cMLn!N9=a
z$-uzi#lXPe&A`Cm!@$7c%fP_k2UXw9z`zj5z`zj1z`zj9z`zi~z`zj7z`zj3z`zjB
zz`zi}z`zj6z`zj2z`zg<)f3CWz!1m4z!1;Cz>vVez>vtmz>vhiz>v(qz>vbgz>vzo
zz>vnkz>v<sz>vYfz>vwnz>vkjz>v+rz>vehz>o_yC!c|Vp@4ybp^$-rp@@Njp_qYz
zp@e~fp_GAvp^Slnp&Y6X6u(sr3=Gu_3=B043=Fjl3=DM)3=H)Q3=9omx92nDGn6nW
zFt{@0F_bVAF;s%GG0|9zffb(Lk;@8f1~eopN*q~ofDyU82xrJ=C}PNFC}t>NNMuN6
zNM%r92xcf@NMtAhhXposki`@jm>5Bs4U|4XG_o8nHmDo}CsuIW7ct~Blrt1Fq=Lf{
zmmXZ=0t`%ypu7XhE5zE*12PPhS-|Nng&~un1RM$=VNx+40}~@Ce}e1=VPf=)ffPaQ
zXJlXn=X;it)Z!8iXRDZ`{QTmQn4HX{;+TTUl8pSkn55FooRk=lJebf+DJ}rj0$fQ2
zIq}6Mi6xoInt1dfRKYZ|7L})G8*1Uv16B|NCSjU5QY#X33vyBo4e;oLsfmFxV7fKp
z^OLetlS>q|bQIuBO&zR86&EGPWaed-#HW?!C6{F8=jkOE6o8aE`TGZl#Q1nR1;+$L
zhIsh<#W;m}`nbe|xCV#BxVSony2FG)3gaQ1c#v$oi=K;*PpyKUktrzXVHiEWW>kah
zwX#adk55j_$r&t;HU^cmFgJrUJDkJ7z%c4)>Lm|j15i;S0m^C$x(eZ$dB#QxE~!bS
z=>g!J2+DOJtd(pPQ<9&b1J9wLBwLUS$)}J^Yh)0gqL-4B!ytrd7%28cP=te0b5awF
zK~)d9er9E0bl`N(&nqd)&(U=TDF@lg!NBOi3lnuJN=*b+N#OP%69Yqos7qo=Vo7B|
zs)BE3abiwpdR}g79;iYBt6*hdI3VDdoSa%*tPqx&pOXm6S1^Ow7#I%ldgdtvB&Me-
zxE2-VgX%M|HdzLS1Hzs;IjQN1ISQV6#U(|h;2a6l*~7qaK-96QD6vw(DZex?rC7nW
zA~`iRB^6YYf=%dUU^pP=mXn`YqTrI6mtT~dn4{odkXn?O2UpU^z;HkWswA^4GbL3a
zsZt>-wFp$hg3V9^yCSbFF()%c!6mb}Aip>h+5P<p13dFmD-x4S6oOKVOLO49pTNLy
zKpbL&C)60Q8;}i|$iQ%b52D7uEVU>tCm&RUgYBQhz;HkiA{AVcn4GQPoROLg5B$jt
z3<vljvY~k?s5-?N7!Gjy<tzB6=H?fH>vd2>sxmMfknqdTOU}<L$;>NFOv*_Ghg$)%
zdkA@Y3MgPb^GZ_FQ;QT_u!b8EN~VI+1<Vw5e@_Eh5m1y_mYI{9o|=L!0sIAp8YEEA
zb(=CW9N=~F@lo*0FHvv<r4CrCabjdRAPJK3%*!mvOw7rw0w+fWx5UgGM9QgS$UPw7
zo1apelZt6XJwxsR;eew2<kXbXA}sP8Aa}vy+9NS9B?p|jK%t*pocloBH#4~?zc@dw
zM8R2G8xi;*c^Fng%j8CS1~K4#4lW9GL0oZXtC$dfe;-(V1QH7la*hGD<JrO!OOi7T
z85kf8BN)RN#xP-E*uccV5CF1|A-U2mGbfdeLnJuZDTo_VgcOzL>18l7@H05Oq!y&+
zrKIMesNyLAS&)-jmYRc48GBlJie5%R0d9l%lM;(lp_MXzl^l8bd8zo7aF-M%CZ{GP
zCTHVw6fdl5FUD`0aB4+KYF=?>eqMZXPGT_u)x7zjf~6$Ch=4ktocz3WNP7gIBe}s=
zrV=oWzq}~1ARZE9_&vjul9^mWgtf($#kt^QkI!)&$@zI{nd$hH@FthVmlP#tmJsj(
zZ*gv7QAvD3NfCbc^A_i1CZ`hi0DD1YZfY(*mvMsXDMGGF163M?ZQ}y9)KUpJT@ci+
zL$oLHW(U69)RK(+6k=?KMghLe#hsZ~Qj`p;FYpBj2VvXziZj#m5=%;p2qwtnd{8^R
zg0PXi#hH2OIjJT2dH5rqBQv)kzo-PC2e=`&5r|VRSfa%nVx=XSIhiGu_}#=+P?-v9
zsTAXL6(^`<D=ALFr-l!b*C6i4r;sy0DJwI#0B>Q-Ta=oXT9lfXOrVq$f>;_4ZZQ%{
zy!@aPPFzkdO3X_qB8PG%CKZFqX}nR&Sx^b;T&Cg+6CO}GPB`d<@{_<FDxy5W1&ddF
ziG;JDG6mEw$LBb{;*z3FVhVcpg37c4{Qk_%Pbn@fAe0Muiogw-#2ox-mz6`r#VZ_2
zo@ZcWVq)ZB_yQfv1vQdDcmlXxz`(%F#AxVKnw*)EsNkHRSDc@d%1{pKx4L{4VtBCl
zPx<%7f69Y7xmJS4G&rH-h#>tS3>rfOVVGH<@h%XS`!5d~ax`P`bBPC815z`J85l;x
zU^EQqod%deT}(Fcus^6r48jpi3=E(w3mVo3Wn&Q50p(NZ)Bs2g2n#baFl>j4gVccV
zA1EKx1p%o6VVHR!c^E#yz`!sKT3mqCfbbb61_llA*epyH0|QJQ$XJjX5XNO5NEb*u
zNDT<%QwLHDG84;iC#aK!+FqmH0MF?7AM(I5Ekk;U4qA?m|AAW7u-rL1{s$_fM#uj~
z$N%#4K!bar0uwUSGdli<eN=LE{15kl?dbR)bbxzw{10s`e{}p0Y4&4u{4Wn>qGxpc
z4|DQsbo_60{BLxuir!;YqxMlh&2ca=Gx+*=`7kkXhNKpkIF}Zcr7F5uftMO278jHy
zo5ds+7lf8%=D=vsa=5La<&L10zX7R5X`od#dC92?MhXG>MJ0qa>w*S3M#ujk>*PU0
z9WXq)l#Y5Mt)t_AqwD_|7#K#^|BbHy8(sgGoH4ro4|#>-==wk0%Q3k}*Z+YQ!Sar-
z|3euC8eRW~5*(xJ|FA3x=N(=DhqR1-bp0P}yau$G2-L>~t^EVx(e;1SAIE`(^(Z|W
zwxpy1Z2Pan88R927*fFdqCxo<A68;uVgxNx0i7EFS{IB@Elf@k#DMNU4ra(_C}k)D
z@BEHuaAwGd?n2LJ$YF?Q@MOqiNMiu+!~^NUf;FJ~zd?3`Fcu{kLfRk^sQsP{0SulD
z@eD}}1z;PCp?l9W!8`In3h`q(1|~+(qC?PvM`G;<ZvqA#h5$Za0AhbCLj^-3LoV1A
zso+x$@Y@TMl_JCc;4Ph?!x_K}Fj*PEd%roIK|7qnGE>W0ZCw3>?2t(w@NQA)ek5cG
z4p4oE&?6t7UzA;3keHmRpbp+!pl+pLqEJwj588XJQLHJD1m7~Qkd~Q~TFeuiUs{x$
zssJ*km=CsV8zRRI-v13@bAcUzsfEWQH8CZ%2%;b2FeIfo1PHkjq76c#d2n?9_vrp_
z8XgZYy8nB0|96Q3`cCH2^`E2bKS$Sp20I0f?*GPIi8Q+Z8~tE{(f!|`)--gf>*)S(
zq`(;6{|!wQqx-*c&wq{X{{{~&z{YGx_kWL$Cz3LrII4DNr5DFJkaJ%JZ1VC;6hKFU
z73JsTq^8($Bty@FWMDu#=@CPj2uvCBk&z4x@Z%bZ)c`pZl33N?5lhhc;pq4u_&6}|
za$Q<&S|6fIDZ$kklt3SuAG9lNK}(}Y&wm8P8fa2!bpJOf6h_DYM#uj~$Nxsh|F9mz
zIXeC~I{t^}aMjWAztQnO%t?dM@xRgWztQs_N6%Yi7+PahqhpKIkFSJRkUPEPke23Q
zxq5;RAq}}xg@eI40J5%+fKDldPWYV`(EBDp>n0gNmk=?4Sg%+?om~*?H<$$)1dza@
z8GIoINEv>u1e`_K0O(v910w@BgL6n?QF>~LXGv-<9{=EVF-Vetn?OpSwxTSIWMtri
zgtmK8erW+z1*H5&SpbPg9dk-*0V9J5@>%|%t2`1j^HPgY45X$)!e{^UWR|2BC6?q9
zI6s}Yq_iN1h=Zkx+q*{8G%yF`oHcw0JPVO@tTZtPh7-H#jHt7~!OL|CACApU)Okll
z-uA$glUYo}9RtK(4M1G)MKrM}vm_%owInl{s1v@4Ia!>a=u_-@K&z4o2Qx7z1`%<o
z0+E+E5OHKa4{>LTvu6@IOrA5Du<!Xx^D>k3Q;5jI90iqxjyV?r#SQ2Vo>Zcuo7i1x
z#9zEX%<=Wa9YiRaoS#>gS_HmfgqXWBsJN$$Jvp@ubW%L-o)9tD7Z6@-MeMa5L|=pe
zDijE(IKHIPw6xSB!U~DKwT0MgN{G8XhlmsRh(C9Y$O~nNye)wvIkC6|{|y2hpbJ#+
zE0HWIO3W(;oec!dr18ZCsmb{D2tr~DssX=RevlK0QYnJ&68r{>z%MT&%5?tX#9ZRa
zAxMJ_nZ!DvOMEdz)NLlC_rD;Hb|k9dM_hYobpQA0{_mtxy!T&Gv92bvtwzrMFW|di
zKpoFfJQ@O{Aut*OqaiRF0;3@?VnV=+nUNVZ7GA-q&+tN|9yA0$V*Ebp(a{hX=^+4{
z|C50qzJX=-j|V1+KKF-Lmjp}~?s-2p1_p+gtdn&!6?Bsolpy!KDrBVQ<m6i`KzaGa
z)(ZK>ddV3nnME4vdV2a01Ue8zT@$V<B|jM?f~FMe03>xFMe$H!Lu&;Tu3k}To<_8~
zZkc+lrV_|yFIc6}F5!-W&I+Ygq=E`f$dn~W=^Ivdq)AQ01g03wE_fK=oW2AZGepAz
z<n%YJtZ=U({Es(*fPxS*i3>4+8*D%Tct-<B<OQn+diaBGKnienD$UGEfyPCAie73(
zDoFX@3_Or0A?XCfLWB%-))jqv8E2*e6;wD<6G#egK!X%O?W6X@GG9<?G13`6c&4C{
zb`dc$2tg*aQ<F;&gP>3sQga3xGTKVCi4f%wlGt0UN9X@W=l`&bg^teuL9_Gd{9h`T
z<S{z`hb2%(=l_D8f=1{6&^L4tv6zJ$GILyve`<Gh{tsFvkFNj6z3OFzo&Pa9{|D+E
zjpES|7!85Z5Eu=C(GVC}Apkr7yojNkA)O(cgp<c1;UvPq#J~yNM}~gN3Pc4a82}Q3
zo<9z=zl0%`0d)2{NQx9J#K6SJ!@$76%Yb>GA}(`cKoTk-f`I{MKZHj*$;H3~J`x+`
zcMvAVgglTU==t-`3^@#m48;t^3}FnJ45<v|3<?Y+p1)7B{gp`e!{&b^A*Zclnf&1d
z%b?Hv;8rgRRu7-=fKH2m2Ivu!Bp}{P)?U<kAFw|7j1CRveV`VACw;(da%X%{NAiWi
zX2CrSp2PsDfQ<Tsyb7Be0kMaqw-M78xZ@q<Ig)2=2450*!-_l&g@{KG3lR*^jx_r0
z4feDT%5K;a2}m4wc!Ff1){IWtfX9Te?^uLP*FZ?@Dn{pjune{mxu$q@|5qM3?I9l{
zGP?gOCly*Ujqd+KPaUKCzeGUyXO8awLQfcw8VZ?2EPX&KT}J1B&;xFC{s)wyh}!dC
zl$w@Wl$u9q%l7E}&*=OQazO;@YK-F15Eu=C(GVC7fzc2c4S^980<iIaoQKYHfQHM_
zNB?oE76GY-4~0X={y{^hj18czWuP(Qm#jUg<Nitc`NbvikewCrApIoH0f3GJDoV{r
z%`46<OSM)&;UY%(brjTfb(4znvs3eQ6H80-bqh+0U>iM9Cnkv8_5t!0VnA33<Z!sh
z;d1~GZ-bN~W&;Lg06;cxfZ~Us_Yt1PnG8T4hIk!fB1!u=-mvoO>4QTMu@z*Hg&D|y
zuRvE`gHJ9*1PF9g41HPvYpwtlF<4R!NEm0hf+V4KjLr#w#|h9!{CSBy_Kx@y$#{|z
zb8?arle6(JE+zF8I%3bABKjaJA~&KCdE_FghpZ8KLL=en1j6T%5pgslKjK_90&9W=
z!RaL)d|P=cfnz9%Iq8m=)3XR4aYx)4XGEU1Na`VT#EoDRc_Jj?GeG&15{pygAq%+i
zXR*=yUonqzAHDwpTn!)%pc9^w;sl)?N1$9F_9#{^Q0+jd;1EQ;nk%EA0QdOg==eW+
zgpQ8?kB<L4W1TA_@<dD04r)#<D#|Y+P&yEEn(yfOZ=l}FC>{-g(GVC7fzc2c4S~@R
z7<?fxdj8wsi<40ojfMcdLf{lrBl!GB(Akd~HNBuoI(k_>YR_m0jD`T2A+U$}2RPq?
z&TZY$MgF<1UQCQEpxI1N-j}d#9L@h^#>c3((GVDlApl$dBg24nJ|pN#NVN3@j11i1
znbOo^z2t%dP>F#u#|jk_POT^bt;5OBiwCQQspU;8%}XxH%+G`CMw=3W>PKIg4i$zU
z?*!#TCvc!Vv^x+P7&u^ut}-w%GNSo|fdNA~#u1hb$YB905m~`Ie6fTIS*EdomI`4p
zjFCYQb?p*%|6wT0fW!x3Z=ml_XJKGq06PXL>LFf*hv5JJ3=DbDlU70Jtb!sQvD^jc
zIu($z(e*!xuscIX*Z)8#uF+TPKsF%|y+4--g`?|#Qj<&Y-C8=j{wKK-X|=%U`X7w_
z&7<poV7r?!nlpG;ZV<bokI3s9;q5KFmX5CfL0>L1y8Z{LcmpjYEK1Hu1+8Aiz2=CB
z(}?+sGt=`DOG=AU2`r5u{^n%f;>^7CoYa#1JOa!9AU8qatJL5f1iX1=^!!)o+Hv%5
z7T!=J{vKLlZ(8Oe<^T<1Zs{If|AW$&A?N<b^9+nkpcB--{0DXQ5F;29K>c0@1_ov(
zMnj*{<jj;r1?T*{;{2RchH_9p(&eiV!-K_t%D*rEQy$F8wGwm&8|WN3W`q$8?9g-J
zU}hySFff3y+<$om1_lN*20xd0kTo!Mqcj6N%tpgvG%V<m1{xU{7@8Ou82<hL{~v@~
z85kJa7#JAZ85kHk7#J8j85kJ47#JA385kIP7#J9O85kJ)7#JA(85kHQFfcGogzBBl
zz`!ttfq`Kv0|Ub}1_p-d3=9l27#J94GB7aAVqjpH4OIs!J4W%~2?0h1RtC^G;Q#-O
z4BQOP&N;<yIVr(8`AJA)f}kRuu>n3N2;o8o3L$LpAR>r~(P4rPVUCXf#ut|)mSiS_
zsyk?CF*2YHO=Aq~LIV$Nz#2o@==d*aK%K6ehC$=oqx(NW$$79{<TX0}J39XB6ofK2
ziMMw<I{rI4{>#A6fPH@vMso&lQW_oqMH!9YO)iTsDN4*NAuwRbTb!F%R1#lMLSXkb
zu@}jWj{lC1|6<S1qvOA$<G%!pqY-xh*Xa1~=r|)i#u-QL7@X<Mg&~z8iJ_Dsogtke
zm7xeUh({6@BIEv>7LW}xAcBFxg(06InW2;+mm!rQkD-L27$QtG3A%p>c{G(6jgvr%
zp!e^9n3Q5t?Wfc}bp4dr&&9yZ06xeJZYan!I0rO}Uky6F#L6lqKOS_}i3aqj9tABO
z1vpbv$Jr_de2!mCPG(Xubirs$aZz#%NOL@F`7dZaFi5GBzkhH@jE|>Na7;jCh=;#l
zj8mwmk4sF5Yj8-6i>p(pJ4_g)Fdo8*2g$~}=(+g#)GFv1nIb!K)X}sHX=8&S7}7)3
z(V*#boU5uqlLsKIm24GLlAoW0lFtf~!DpC3v!0Pbe2QL5P7VW(69#dvNS0+_U|?ln
zbl?On)h)`;(RBtzKFC%M21W;7n5a`xYGO7_hKYfpLDVI&BoTD3l7eq$abiwpdR}g7
zUI|PED+9v;0mtOz)Z$`=u+03NM9^LUm?Rqm!vS8;JcWS7^i%~`(CI5M8CeE~1Hzs;
zIjQN1ISQV6#U(|h;9UeT`5p#_1EP*aMTwOPPWh#IDa8t|70IcoDXA$i6}=1$2gKZR
z@)JuGTvGG$i*gfl6#NTPixTtTO8OWW4v0XNWR_*7q$(s;Dnz9g<-^QS1G^%xEHNiD
zMZqPrxFEkc6WRU!2m?IxQY#XZOB8}qi%WChzMsIra6lYlgD2D&up5vKnaIF!fDfX^
zzbv&VEhoPmX8$Axh692Sso;{t<ZK0J(0VSI>|_Rp1N;!#(7Y5>o#G4(2RQxm6?{{3
z^NYZ@zJVfAm4V@agkOGMa(-S(W?pGxQcfy3+zOE0L&(!pKmqHSSCX2ZTBP8DHQb0$
zG8L3AV5Xq^dm6}!fTGN@%$(Hp)D&z9;4diDAc2Ce+mw;v0I!RWkAh!*iGmv_b-+T*
ziIL%eBuK_HFS8^wF(<PMoE#P05;JoUDW{Gh_ke(JeoARhDy9+j47mq{1B&vKQ&UQd
zu*h?O+y#qkkHox`oK%?Y$;G)3#C<c9i}H)}(@GSawY3p}4~iWaRzl0<MtTO|`V?|b
zt}cix?raqk;_vSRt3*L!!9mV3p!r<3@Whhj3_}J62*U`*ForQq7#KD%F)##x>|;O~
zxEo#nJG%ZCl<f5~@T?e3&d*EBOvk5Wbo>{7OBUK@H@ve5qv!vjFX$dU|8MmCKkNhg
zqw9ZBDsFPt|8j`9c!h)7CZl*X1V%$(Gz3ONU^E0qLtw;&!07pZBPOaxJvtf!7$LyM
z02%;9KKE;MDvfqiX+v_-a)?f)At&`AlBSIfM(6)V=l{@WvPS3sM(6+X^FWh(p!GDP
z^MCkmPvR~qN=#0L+}4MC_6lh`D&D!6(fuE|cE)gw&i`?UfTm?e@Bd28Lz#paJ^u$j
z?aK+e*|4NI1>Y<=UoLow3GDhq++`MLeo|IuZb1${!+48Q(^894^O95XpQto?{txbO
d9^L-|?l{5D>=`}(XK=3DAKgze8ZXpH0|0G)Qbqs(

literal 84480
zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;!F$-42&?o00YCn|NsAkxG);TZeU<w_&*AU
zObGn_|Np-N0|Nsy0|NsK0|Nsq0|PkD*%=rZI2afhI2jlixEL51xEUbv&C9^Rz{kMA
zz|X+IAi%)DAjrVLAjH7HAk4tPAi}`FAPQ9{&cMJR!N9;E$-uxM#lXNI&A`AQ!@$5G
z%fP@O$H2fK4^@}Sz`&ryz`&r)z`&rwz`&r&z`&r!z`&r+z`&rvz`&r%z`&pdRjb3m
zz@W>(z@W##z@X2-z+k|@z+lM0z+l9{z+lY4z+l3_z+lS2z+lF}z+le6z+l0^z+lP1
zz+lC|z+lb5z+l6`z+lV3z+eY8&w+t~!I6Q1!HI!^!I^=9!G(c=!Igo5!Ht1|!JUDD
z!GnQ;!IOc3!Ha=`!JC1B!H0o?!Iy!7!H<D~!JmPFA%KB_A&`NAA&7y2A((-IAp~k}
z7y|=CI0FMi1Oo#@Bm)CO6axc8Gy?-e3<Cp0ECT~W90LPGJOcwm0s{j>A_D_M5(5K6
zG6Mrc3RM4e1_p+71_p)<1_p*q1_p*K1_p*~1_p*41_p*)1_p*a1_p+F1_p)#1_p*g
z1_p*A1_p*=1_p)_1_p*ws2Sx93=9<v3=EYF3=CBa3=Gu_3=B043=Fjl3=DM)3=H*9
zbwLdI4EYQt3<?ac40#MC3`Jlapqxw`7Gq$A=XX$=!Kdqk;AeOHhy#qs<wZC{K0^^h
zHbXH(0Yf4~GD9kZ0z)uE2}2@72?Ho?;4=>-r@+9(2uib{v<u2~ATdH1RE~iYD>&|p
z81fm)8HyQF!Qn_qFS@({0}~@C?|{llV(sSv83M{I;PjTlkjYR24h4`fshE#}i4l}X
zL3V>MG5W<oilFv0GO&X4JxfVyafwE<RZLQTesM`mPG(YZOhIKyMt)vQQfX#RN(@LI
zOz5Q)7l3L3uB3vT_~MeplFVdHJo*r-U>aGA%G0wAwVZL=1y&FPCSjU5QY#X33vyBo
z4e;0nQxgMYz;x@y=pmt!{QMla?=tg}b4pWEW0G?ci;MG<vQm>v^fHuUc)2*0koD;4
z#bDP)juwzdD#+28mzJ4MitAD`lS@dqCoMB4l?+`u`HAFMR+^Vgx@DQU1^GoJMO0=U
z8IH@$D=A9ONKMWrCD3y+i^;GmCqFNp^l->cEy>7FAwyq&N^xlcsbQF#pHfOr(#WmM
zP0Y#3PbMW4b1Msq@=Nkb(L#DK<R@ii<`(3TVo5<_NpeO`YFR32x++srlS)a-y9Jf0
zMMe2V#UwedGOZw$G!38<oJ1|4T7fi6Kst&_^GMNDl$e)JMk!RBlbKA8wvwVua`Ins
zWicdEkm9wHqQvCXq(st6m6Fl|d|3}tZ6_z@<iwX0C1#cs>tz%aU{+&LW%-bb1h<Nm
z)RM%^oS6Kicp{BNXeg;HNF~AznI)-3i6!|(_}rOa08xY2GtgEF$eoZd#qBF3rKxx=
zhA9NK3F5)+AL7-g66M<byt34y;>`R!VpKx|Hz~0=H6B*T5%eWgQ*vT)3BE9fdKIRc
zV9G#MpIT9png{YmJh=TtyhUlHdC4WDc|S8Rvm_p-k9eE%^7B%OS6!T$o|jlsT0~SV
zLIbThGcP?SwIn}}cxynJgoKzcFG?(khlD&4cEIWlf=L8Ybdiw2A&HL|hm(?Zi&E24
zi&FEF@kUc|ZemeMd_f7`d<zOzBFdi9lFXdUl1gw;GC-R8SqzI9nFRD=PO#`RfN%`5
z8i*2b4+7i`O3u$MC`!!$rTj98qZyJIRxvUOFfeqm=z}q+i#3WzLtr!nMnhmU1V%$(
zu!aCLXhw$(JnRn|eg@$PCI*HHjF4e{n6q_2BYx1S0gxIH7G`E(*bWtksrv)vgN9>4
zYCsrf9!w30KEc4iFbz8G08#_OXP6imG{9rCAQcb{QwK5@qy~g>nFrDV(hgDs!uZsI
z)Pl^+iy0mN!x#!39sh$RiqY{u(8vuuk3jkhkWK(810JK}e+8rCf1~4nuu^4o{I9qq
zW_0{-bo_60{14|4J!G&i20FqxI{p_kI{pXhvy9@=5Eu=C(GVC7fzc44N(gW;Ff;i2
zc=<3faE7E7mpGRem8B}WSj7|<CC4Nd7nCKNfvC`u%p4f4mt0V=6|^)MwDLC~wJ0sW
zC^s=LIaR?(At1k~gs^5^(0a+y@judsQIesP^O(yzaIH=pUH=CkyBb~p2U^Pu8-mCk
zUH=DK^gFu#uX1$#A1EOdkFNiNE|G_<5QL69jIRGHE+%1l6nG6BQ7gxiN7w(2uKxqC
zKSNqu2H9@{$$+Ede~{47(}V6v8Xf<mN`G(EkkJqr4S~@R7!85Z5CDY$w*A-P44Djh
z3@PA!(I7SWuo43kBj|hp(B5MZ#-|o0rwC#|_aA#Q1Tc6q#4{u@6fop4#4{8__kL%B
zcf^Af;>U6fOpG9VVHm$^h^#h<0v#>@-ro<gAGF&XWH(5P6fDHR1U?%9G$0Cc12KB-
zL5e_!86er8%22_O$dC&Tg;emV1|UU*u@nOnBWTehXfY$P_J@Lu1s(bTUVzEU0N(q}
z=?vQJ6qcD<&T8Z8A7qD23L!ReD?s}=5NVte9B!F8sR+a5!}E)>iwhEyQx(*~+o{y8
z6igHfit<6*tu=}@A*Rt^6~taN$C9+In2f#4pxq-msiXV9A^Yw@8@fmz3LoA74GF!`
z{onbBCETPZqtWr-(eYpK=^vxxzu?`C@X?mh@n6tv8Mv)8I{u3?Gk`iUIlBKlGbd(r
z|2MesKpD6m-Tw{hWR2p{5Eu=C(GVC7fzc2coFS0#3Ua2e1kw<nu0nWbp0SaF3+Tu)
zK7<71G(`>u=K#pS9Zo$`2t5ig!-7(CQWJ|)!DE%6LxLGVtXHg{aZ3>EH<$$qBb=s!
zlriGf%EloQ9PAXtz{tSO;2e@zl%87RS(2KI$2oW{1W7`T<O$9%ElN&R01ayvGcs^N
z!oa;KzqA0Vf|WzW#Vef0BQ-H4wTPfP=9JU|Mg|cEXP4B1)V!3`yyQyf{JfIH%)Hbh
zsDa#&mNt0XBqIYqvQm&MpsG0G1CV&sz;~bGR>OmQt{rY=>;;e$=5VXvEPxFu;8w$n
zGMSG@9m=6+xYhBa4XNT*$%ndy8Mi`iq?6rntKtWpI)-%M5N?&+NSi+Ks6tw$idz*2
zY#}giCA=u@Z`|s5kQajDR>lcGjS;sR9^`W`aVrzTTvLWyF%R<SFm7esNc;40tKvmD
zQV@?ilrscztK&i5!iq;3^2wgKm2o2-IE7mk2W*TJw-O%YMc=rUalnSqaVy~kkAD!h
zkss~YE!-yZp^mfRR>*}o{Svn#KGe}~+zQ!~Q_B)_^fGX(0HsQzeZhl#Kn89zIpL$r
zxYh6_m8PYo77-3(uEeBbP!Ups&lg;XgBEaG$pNWX@R`G#hJ2PUZlkzh1yMl(Zbclh
z69{oDfz+Ku)QNPi?WkFo5w1CTM{7HHV+g5*L(STbxGIW@l_IEIA-at)THArz!N^fh
zxLh2q?I67eq);2YwH*;v&j3`2RITlZ>$Op{PNa4pgxG3`lbBv5aor0dThhce^NDJd
z5Z_~@MF~zsKHw#`6GB{-1`0aDg()$80%AK+RPQ?wIYL2H&w;r9EYgh(xZAEoRzQRc
zWnu?Ki0TP|QZ3Q_8KQe-M0R|LXt5E|k0q)zLtJr7d`FSs@D|ba6H#3iB6^6#^g)Ol
ztRl9aBX;bFxDgAYN8E_66Cu4t2niaZ9mS&|Fd71*Aut*OqaiRF0;3@?8UiGQ02dP@
z3ut1U<H2X{74ly}*SwOTdsOLY2#kinXb6mkz-S1JhQLq^0oeLKA<)HU@Wp!Im46%{
zA@ntWSk#Gt)WNmlS?343Bl`ubRI(N7Rm#xy2&omRAO&w&*`Y>&crRJ&bu$%olNFR8
z%T*LWc3CSxIr+ub3i-u)$r&k`MH=dQdioFqQlqX3R|Q%e2EVP%S^<TtS5%s(5v{IU
zrmmx)uB)3=l%JiNr<+(>lCN7(QluWMsRU{qAr>cM@jgfaWLYA}!9@6v6&$)C#e>6l
z*cM?zR~MqMq{JH4pk$9FTtLE5W2n7)k}oK=n7H+rNSBl|G6+FdZKfudAXZ&MT}Z^*
z6QahW`B3kV#64|5+~6rub6LEgMRM@FG;v!=^hhl6lVe29MG!ODLd+<)5M=Ep@_szr
zo+Z58hKTWIA{S(EfmV1xE{MhLAYxY^5-~GE<oXnD$b=vGwoW|mB66iDKiVAxcuXX6
z>W}DYCr;4Cw<X0X_?D~@KMPLGvOHdtD@k#CmB@)}&}<wijS#g`n8-;sq9>w=m~7?;
z1u)Xh!ni$5%%ndT;{I9O1`(bQC4N;YF;i_s&K?uH_<^|jbbhpB9&rZ;ar2mh;G9KV
z0SHQSM9%;dw>q7Od0igj7CRHUR-6NNcQc-VBWj&KPf;SMf&{Gr#<x^e7|V8M+*S)>
zTu6;uEwRfvxWO?DIYJblX~;KD<5oxH+5}KyE=tZw1zkvw+c2WnClIrAn-i2Y3Diu)
zHGYV!zKEUtCVHs=52!$gT{w?B)QDJ81DVMtrUgn=$b!mpf|X@{ZUNE}M7W(#OxukJ
zFB0E)AT0|LmtBa={Y2GUyeOOfaR(exy#*rLdPFzciEUpJlk<pZG7!^XCn^II)rBCw
zbw^~Ao%psV5leK4?(`Aa2qD~eAu42v>?VL33ZSx#sKzPLTY`vg`4H2hB%<L#baR;4
z)lEc}@5HxKiEP({Dq~2;4PSSM$c_gQ4Jcw;yo4L<po9df)`?0;M77z8YfKW`Fd?$h
zNnBH$q`?T{`&Y!KPU0Hu#J2y4YC{t{%tUlk7m~^eGy;hmCnKpTPUPk`qFaKb^vXcF
zn{ZQ`h@mMW$DC5rQj1dal2buP&EsyYKw6;4BxEB!v5jV;sv{yi1#tlpEn#9x4`M17
zA}eHK8au?6LWC=KVoPM=hiQp!L=v}<nE2Kham5rUQ$Pv>d{rJ1jR0axPa<mqA{$V|
z^pQYyBhig4BHOT_U?W_X5Zf;xw%8`J<w4{?5OKvj5&a}0t2!e3szf(&iEir<-Ps^&
z?+VfN5|vwQM7Cdv8D1x%e@S$Eo~ZsKQN3}h)^^0TBB@y?l2<Bovw+tBr502$>N9}W
z0A}W-LZ?KDt%iuIXGiw|V%^#fUHX9MU<#s(<<WhBdC8SXyP%0GONptviLA+ptbhm?
z%EUG#i7NO&?GEbKQ$$t;M6}q5sM(1syNN4qiLW|G_W?Qu5!;$3t_??YAB5;S5z<?P
zkf6mzqj)p~MnhmU1V%%Egb;wO{}oHENCeFZ8^Razf>){Xz=YA)0pn0F0aFh*2D+FR
zb(Jh)kuOLbvH%sdAeP|j*_W)7QP%@!q~_%0!<YIJw;(trKN++{7;Wt^)a6JEhe3+s
zp~8mN;HAfKE@I(utfmquym15w$bX2{!Eaa*i+_ixUqK#%L>P#LSQ!oNHKMN=#t|%_
z5QFL%7K?+48IUHnBSB<O4$^lda6ByWg960QQ4u$&OJsit)IlM7V3gS5Y1GS=anE}Y
z+qouoWQgeg1rcpr;zoC=K1)r+j4@F?YvLy-i0OlaQVG%BSR%%FNtv=Ee(e%*tC5KA
z-xGD1C*gS$qB~y1tPCQ0Hi5`xd894(B5KHkh{0uI=JSZ0gduiToVdmK#C4^K8Db}T
z&Vl}mmq?kcCu(My$ay+qCw7Qk{7=llH&N5{M9*~)J0e5Gz#B1pDu@bvk`}@cIdDkS
zN=zarB0=>i;X;zwWu3%MiVz;=g^XJvlLT)BAgbaeCSs{uITKOe5?_asRv{2q<BqQX
zMVc2Ork1Bt6-re3K~$Yid^d*3YMbclk+`}xGd(Y{q_l|8z6~Om8xdY2L{!KUSuKLv
z)<pNfh^<43-}yvLElNavM)f+B>OCtW>ptS@D<UgDB6@SwtI<FSiRexm6$ea+?NAZ9
z>WjFkM3S04#E-2I+rp#j7z}a4D#Z45h#gd+W{-%JE(O&Gb4VFX0OfANYxam39wMq^
zL2OS3xfKdwkFNhkUQ0sEcmc7c5aG(5*b<reRy@%|K*W^<#J9$XE2co1f^Zj&h(-Xh
zr6-X!0g(+TVh1pZZe$VJh6M#1;j)D25j$cJoFBdQ3Q{-{zw?Xe&IVB(e4-~A2#-OK
z)M6vD{Yp%SiHQCs(d~Jn`j14dAtSb7Kvd_8xK<<)6+NUrCSp$vd8M)^LjZ#(Lp(zf
zLpeh_LpFmUXl9lKEW*IV$iu+E@E;0@(V7NQqyQoq7-058c%+kD3`}slK~5mXgffsK
z5fH(^;LMQ2kjPNXP|Og<kjaqBP|l#h5YCXvkjIe1kk3#KQG|z7BE$Yhka<x1T^Lds
zk{C)E(izejQW=UsG9+Ok1|~+3zhRgd&D|hH5+H(s0k-}_xTrim8*T9iCs+)9<p(yE
zqF|NS)_g#g3J|%rqZf5;2iQ<ruI+$Y0AA+-W}~d?067}5Pz4lR*t`x>MZ{8$!RR%}
zS`^SS4oED4SOgbzU<(6K*bJxD97L7yL=1ZqRqYU8ZWG;%C#FS8T=$!(kRY~+N!;uv
zs8K?6Q<<pRpP23&5ew0YY?c$-=_a~WNVvyH<X9yUtqtNEwM2G~h#fE{YRZq8wk6RG
zM`AmRp!7)euqN>nT|`b@5qH%rk;B2njI|Rx`ao>(5i{RJxTiuykAavGWl)!y@JIuZ
z!vn+)h!WQoAb!S#+AB7QADt#<Zkf0tA5sQvNf}=yc8w)*cVrVc97fboED<v?#0+o|
zIY>j=EIP3rUy|lLh#sZ@<w+ujv4}i(i`ZdUqJ~<CA7O>`(ve9*H;yB#g|J80e*`-P
zk(P3atVD@B{gJ392(b%=h-&&1(dZ<)%};D2oS6EUnA*0WvbZF%Bo*I@9Yl2=h-$$T
z-$x>{kxq2uo2Vuyv4?(-uK!5IxUHI)HYpJ`Bh{PzME0pj=r9r2lm}IZL^M%}n}s2w
z)j@1~pKu$Uq>d6Xt#u+BbHrBpL^kV*Yp#>j79zfdO>D1<xK=iidvJ(r<`Uc88D0NT
zfP2RgD0dTX>=H3hLsX}O*r6y$`xBXjOmPz1F(9g<C&E(@7Z5SmMNH{IOvOTEg-px<
zBC(|q;n6%|OJw4ECqy?Qi7N?+Z;cUGOo1{5;VO@aMgXy;Cy_M)kwcusjJAX7MxqC`
ziEP7yf{k!lLTtZ)*kYT=p++L>ZsMi{i0CH~S=A9SX+!LYHSsM!qB|Qz4N4F_utMb)
z+vxfa=oBYWwH<M-NNU!J<dw?s`F{qatFjmv7#YyE<ufqwc%&w#q!uZF_L3AcGB7Z3
zz>Y>BPC3S<T@1)pf(&E@&%rY=FfyW9&d2~=ijZ7T0Gg!6a0+3wSwNHg)N&|ju?1+(
z8-`gJ7#P47AcY~sGw?9_|DS;Y=^8t*PX~Hw!|41!bU4B}Kd&S)GcUD>lpIb(RYKGt
zAo2N@=w=)-Et1jsf0W|_iD_bh?%5;UP9?U}MRcoxaF2n=u__{J8{!)^L^h6zZA}q1
z_)gSdY*J}jT51sy@kHbi1)!$;==?v%xGk}LEn?;y2)9&;nUP2)9Os}e6Jb?Eb`Oai
z5F@TBI6D8&&)|%>mlf2?gx1ER^Z$r5nMddU^YC9~LF_ObQC)4~N7x`Em&oMk{6A6_
zCVpAm==?wGG1f%4`H3CpL#vPfGcqzU2{16MkpIffk-)$K>(Y+WqhK@yhJOhB{r~@e
z69WT7GXn!d3j+f~D+2>V8v_GFI|Bnl2Ll5`Cj$dR7Xt&szyJUL_b@Op^fE9o^f53n
z^fNFpOkiMOn8?7uFo}VIVKM^)!xRPvhN%n;4AY?ML3(B~FfhzwU|^Wdz`!tvfq`Kz
z0|Uc61_p-t3=9kl7#J89GB7YKVqjoc4Alb~S{udm3jsz3RtC`U<^TVT4BQOP&N;<y
zIVr(8`AJAanV?+2*Z>~jgfQWwnh-8zs1w9aMT`!UF-8kBXLS5mPfuS@Paia7jdUC_
zNyipL2be)d#Dm#bwziFq|BjCT61aYmsJSj;o1Vl?_JYRSh@L7ZYV{~F%Qr^He?@|W
zoq|Tke=!C+LFsXH{1+owM#q0g$A7WiX-3?VuhIQq(545{AQ>?W+(yTLN5_AQit%l_
zA!d&z@#EUWtRx^}A;jqTFV>kYA{w2e<G-MBg;6{j0;3^7ixA*qU}j)oU}a!n5CV-A
z!H;kP-~I)%Py|I7dYczW0?*A(IBx+1>BDt^kSy38j1HWj)p$kuIl9gu)u45u91M&O
zyf9IxqSVA}m<$sGLxZSGVo4&XgQnn{S)7=YnVy%MnpXl-!OFmJK)^9MIkmW0AuKaL
zC$S_mKMy9!#=vlZ*E3HcATd2v!L_I;AAJ56$VyoTh6BQ$IXS86i8%_MdBr6~rOC)T
zdl(oFh&mP(B~~gp<(KBA6f3w^B&VjPq^7{k?qy&&Am)~npID;clA4!al$)5N;9rnh
zl$Zxs(#ODXKm@8Jvn(?uRUxTTAu6>fA7+Lc*cEwYi8+}m3ND$&1^LC9$gb!|7~q+g
zT9KGsq7al?T$%&-{R9Sv1L6=HJfX&b-GFS!L<WWfd=NGMWvNAJIr-pI&p@FtiGksO
zAVey-Br!Q#!8s!}86NnP85j=mLu5nqQc!h@GcX+B^vhT9P0h_Os)YGRm4V@agkOGM
za(-S(W?pGxQcfy3+zOE0L&(!pKmqHSSCX2ZTBP8DHQb0$G8L3AV5Xq^dm6}!fTGN@
z%$(Hp)D&z9;4diDAc2Ce+mw;v0I!RWkAh!*iGmv_b-?`Z#K>?!5+vi9msygTn3Gur
zPL2w0iJ3WwlvBr$dqBW9KczG$71M}%hTH?f0Y&-AsVSvJSmZfC?t;a&M`B(|PAbgy
z<l@{1;=Y;5Mft_~X(bBI+S-V~2gNoBgVchi1K7e7OOi7T85kf8BN)RN#xP-E*uccd
z5CGOxl$e*EN_bt>==dM<p~9o<KaoRYbp0pR9s-e@Ziw8JMa-5+Vs{^oj{l90|Ba6S
zf#ytz+KNrYNerXoe;K$p&J%m?&glBjq{QOXlHwG6V}zsQf7nVcqM9JYrbD8(evOX*
zf%+Sxcr*k?LtubHpq{Z2y#9N^yD!`fb8mAGkTXWD9Swoe5Ey_EaAC-2NM<Ny$Yn@n
z$YUsBC??SjB4pfuF#}`=^!^DDlTwVlTAEU`$k9KP?Pp^EtpKlJm11FG0LKeF0G#!m
zwY3=-7}yvdl-_{X3n}jy0>NXx3=9kkWtSNk)ENSKwlD;;L-iHxa>z00y$e<kQwNa(
z&F?^1$RtQTg0BW;!e}U$K{?qfrX)W<r#L3JxGdQ$Cd}E=BE~Z>Ij1xwH73H>)z?2L
zQmxw9#KO$X(!xd8#M0GC*U-?}P1niI#7x(~z|qmbz{J_m$knKpfk6jqD#&@TsQdH(
z|Noc&|NlS6z`y{)Dl7~PFPIn@m<KpeZZa@1d<I7Xf`&SuK?z@=gt<D0_y<uXOzto+
zFo3Wf3j@O&CI$wk0S=P}==Kp%IDod1fM^)jPPU3k%Fiz@iOI=KDvl|rEXl~vivdkx
z#w6$G78Ipsq~;Z8mZj<?7Zj*f8#%ffnL8Rg>l&K7nd%xEx)|s>x*0lw5{!YfrGcBJ
zi>n!d1oMf3fdPa=pn=0Uz<~n_kPQqB43-QG3@{oNI0o>*fdmmWbW&1F5;JpRQY%V8
zVUwR1pPZ9e3|<#bmE;4nJ&75Td>95egh1}$0uc-h3@{qXWl(d*mVBV+9K}HPQIMK)
zKnE6q=Gf7T8Ycz@1`rlvVPMz-DvNOKe;+;nBNciQ!07oOIF3jdo&RwPBIZoc(epnF
zFxMRue>yQSYfDGhe`B4<9i9KdRlR}oBoW7$j^6(fMAVrj#N^S@`Jd7Gp907!<)i0+
cz}o(!^k@i-ybu_j{~394KI-Gq5P*dM06)EQvH$=8


From bf5eec727e06ee5fbeaa19a2a8ff9870f66c2ff0 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:53:00 +0000
Subject: [PATCH 020/369] Added DebugPython target

[SVN r9415]
---
 build/example1/example1.dsp | 39 +++++++++++++++++++++++++++-----
 build/rwgk1/rwgk1.dsp       | 38 +++++++++++++++++++++++++++----
 build/test/test.dsp         | 45 ++++++++++++++++++++++++++++++++-----
 3 files changed, 107 insertions(+), 15 deletions(-)

diff --git a/build/example1/example1.dsp b/build/example1/example1.dsp
index 78d1f0d8..dcff3f55 100644
--- a/build/example1/example1.dsp
+++ b/build/example1/example1.dsp
@@ -4,7 +4,7 @@
 
 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
 
-CFG=example1 - Win32 Debug
+CFG=example1 - Win32 DebugPython
 !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 !MESSAGE use the Export Makefile command and run
 !MESSAGE 
@@ -13,12 +13,13 @@ CFG=example1 - Win32 Debug
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
 !MESSAGE 
-!MESSAGE NMAKE /f "example1.mak" CFG="example1 - Win32 Debug"
+!MESSAGE NMAKE /f "example1.mak" CFG="example1 - Win32 DebugPython"
 !MESSAGE 
 !MESSAGE Possible choices for configuration are:
 !MESSAGE 
 !MESSAGE "example1 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE "example1 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "example1 - Win32 DebugPython" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE 
 
 # Begin Project
@@ -68,8 +69,8 @@ LINK32=link.exe
 # PROP Intermediate_Dir "Debug"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ  /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ  /c
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -79,7 +80,34 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"Debug/hello.dll" /pdbtype:sept /libpath:"c:\tools\python\libs"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"Debug/hello.dll" /pdbtype:sept /libpath:"c:\tools\python\libs"
+
+!ELSEIF  "$(CFG)" == "example1 - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "example1___Win32_DebugPython"
+# PROP BASE Intermediate_Dir "example1___Win32_DebugPython"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugPython"
+# PROP Intermediate_Dir "DebugPython"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /EHs /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"Debug/hello.dll" /pdbtype:sept /libpath:"c:\tools\python\libs"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"DebugPython/hello_d.dll" /pdbtype:sept /libpath:"c:\tools\python\src\PCbuild"
 
 !ENDIF 
 
@@ -87,6 +115,7 @@ LINK32=link.exe
 
 # Name "example1 - Win32 Release"
 # Name "example1 - Win32 Debug"
+# Name "example1 - Win32 DebugPython"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
diff --git a/build/rwgk1/rwgk1.dsp b/build/rwgk1/rwgk1.dsp
index 18526979..daf736b3 100644
--- a/build/rwgk1/rwgk1.dsp
+++ b/build/rwgk1/rwgk1.dsp
@@ -4,7 +4,7 @@
 
 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
 
-CFG=rwgk1 - Win32 Debug
+CFG=rwgk1 - Win32 DebugPython
 !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 !MESSAGE use the Export Makefile command and run
 !MESSAGE 
@@ -13,12 +13,13 @@ CFG=rwgk1 - Win32 Debug
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
 !MESSAGE 
-!MESSAGE NMAKE /f "rwgk1.mak" CFG="rwgk1 - Win32 Debug"
+!MESSAGE NMAKE /f "rwgk1.mak" CFG="rwgk1 - Win32 DebugPython"
 !MESSAGE 
 !MESSAGE Possible choices for configuration are:
 !MESSAGE 
 !MESSAGE "rwgk1 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE "rwgk1 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "rwgk1 - Win32 DebugPython" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE 
 
 # Begin Project
@@ -65,9 +66,10 @@ LINK32=link.exe
 # PROP Use_Debug_Libraries 1
 # PROP Output_Dir "Debug"
 # PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -77,7 +79,34 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+
+!ELSEIF  "$(CFG)" == "rwgk1 - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "rwgk1___Win32_DebugPython"
+# PROP BASE Intermediate_Dir "rwgk1___Win32_DebugPython"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugPython"
+# PROP Intermediate_Dir "DebugPython"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"DebugPython/rwgk1_d.dll" /pdbtype:sept /libpath:"C:\tools\python\src\PCbuild"
 
 !ENDIF 
 
@@ -85,6 +114,7 @@ LINK32=link.exe
 
 # Name "rwgk1 - Win32 Release"
 # Name "rwgk1 - Win32 Debug"
+# Name "rwgk1 - Win32 DebugPython"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
diff --git a/build/test/test.dsp b/build/test/test.dsp
index a29d011a..0816bf1e 100644
--- a/build/test/test.dsp
+++ b/build/test/test.dsp
@@ -4,7 +4,7 @@
 
 # TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
 
-CFG=test - Win32 Debug
+CFG=test - Win32 DebugPython
 !MESSAGE This is not a valid makefile. To build this project using NMAKE,
 !MESSAGE use the Export Makefile command and run
 !MESSAGE 
@@ -13,12 +13,13 @@ CFG=test - Win32 Debug
 !MESSAGE You can specify a configuration when running NMAKE
 !MESSAGE by defining the macro CFG on the command line. For example:
 !MESSAGE 
-!MESSAGE NMAKE /f "test.mak" CFG="test - Win32 Debug"
+!MESSAGE NMAKE /f "test.mak" CFG="test - Win32 DebugPython"
 !MESSAGE 
 !MESSAGE Possible choices for configuration are:
 !MESSAGE 
 !MESSAGE "test - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE "test - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "test - Win32 DebugPython" (based on "Win32 (x86) Dynamic-Link Library")
 !MESSAGE 
 
 # Begin Project
@@ -44,6 +45,7 @@ RSC=rc.exe
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /c
 # ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /Zm200 /c
+# SUBTRACT CPP /Fr
 # ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
@@ -53,7 +55,7 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /libpath:"c:\tools\python\libs"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"Release/boost_python_test.dll" /libpath:"c:\tools\python\libs"
 
 !ELSEIF  "$(CFG)" == "test - Win32 Debug"
 
@@ -68,8 +70,9 @@ LINK32=link.exe
 # PROP Intermediate_Dir "Debug"
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ  /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
+# SUBTRACT CPP /Fr
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -79,7 +82,36 @@ BSC32=bscmake.exe
 # ADD BSC32 /nologo
 LINK32=link.exe
 # ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"Debug/boost_python_test.dll" /pdbtype:sept /libpath:"c:\tools\python\libs"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "test - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "test___Win32_DebugPython"
+# PROP BASE Intermediate_Dir "test___Win32_DebugPython"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugPython"
+# PROP Intermediate_Dir "DebugPython"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
+# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /Zm200 /EHs /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+# SUBTRACT BASE LINK32 /pdb:none
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /debug /machine:I386 /out:"DebugPython/boost_python_test_d.dll" /pdbtype:sept /libpath:"c:\tools\python\src\PCbuild"
 # SUBTRACT LINK32 /pdb:none
 
 !ENDIF 
@@ -88,6 +120,7 @@ LINK32=link.exe
 
 # Name "test - Win32 Release"
 # Name "test - Win32 Debug"
+# Name "test - Win32 DebugPython"
 # Begin Group "Source Files"
 
 # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

From afdaa4d0d848ec7242cf5b5f1d4d8a00e1639e20 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:55:35 +0000
Subject: [PATCH 021/369] Rolled in const_cast from Dragon fork

[SVN r9416]
---
 src/classes.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/classes.cpp b/src/classes.cpp
index 625d67b7..c609eeef 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -7,8 +7,9 @@
 //  producing this work.
 //
 // Revision History:
-// Mar 03 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
-// Mar 03 01  bug fix: use bound_function::create() (instead of new bound_function)
+// 04 Mar 01  Rolled in const_cast from Dragon fork (Dave Abrahams)
+// 03 Mar 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
+// 03 Mar 01  bug fix: use bound_function::create() (instead of new bound_function)
 
 #include <boost/python/classes.hpp>
 #include <boost/python/detail/functions.hpp>
@@ -881,7 +882,7 @@ namespace {
               PyObject *globals = PyEval_GetGlobals();
               if (globals != NULL)
               {
-                  PyObject *module_name = PyDict_GetItemString(globals, "__name__");
+                  PyObject *module_name = PyDict_GetItemString(globals, const_cast<char*>("__name__"));
                   if (module_name != NULL)
                       name_space.set_item(module_key, module_name);
               }

From a3f822b7d3b24fa9d179e68bfe7cc93093fe368d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sun, 4 Mar 2001 15:56:07 +0000
Subject: [PATCH 022/369] Documentation for pickle support.

[SVN r9417]
---
 doc/index.html  |   2 +-
 doc/pickle.html | 223 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 224 insertions(+), 1 deletion(-)
 create mode 100644 doc/pickle.html

diff --git a/doc/index.html b/doc/index.html
index 9ddd65d3..4550be5c 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -116,7 +116,7 @@ among others.
       <li>Advanced Topics
 
         <ol>
-          <li>Pickling
+          <li><a href="pickle.html">Pickle Support</a>
 
           <li>class_builder&lt;&gt;
 
diff --git a/doc/pickle.html b/doc/pickle.html
new file mode 100644
index 00000000..0e64d6fc
--- /dev/null
+++ b/doc/pickle.html
@@ -0,0 +1,223 @@
+<html>
+<head>
+ <title>BPL Pickle Support</title>
+</head>
+<body>
+
+<img src="../../../c++boost.gif"
+     alt="c++boost.gif (8819 bytes)"
+     align="center"
+     width="277" height="86"> 
+
+</body>
+<hr>
+<h1>BPL Pickle Support</h1>
+
+Pickle is a Python module for object serialization, also known
+as persistence, marshalling, or flattening.
+
+<p>
+It is often necessary to save and restore the contents of an object to
+a file. One approach to this problem is to write a pair of functions
+that read and write data from a file in a special format. A powerful
+alternative approach is to use Python's pickle module. Exploiting
+Python's ability for introspection, the pickle module recursively
+converts nearly arbitrary Python objects into a stream of bytes that
+can be written to a file.
+
+<p>
+The Boost Python Library supports the pickle module by emulating the
+interface implemented by Jim Fulton's ExtensionClass module that is
+included in the ZOPE distribution
+(<a href="http://www.zope.org/">http://www.zope.org/</a>).
+This interface is similar to that for regular Python classes as
+described in detail in the Python Library Reference for pickle:
+
+<blockquote>
+    <a href="http://www.python.org/doc/current/lib/module-pickle.html"
+            >http://www.python.org/doc/current/lib/module-pickle.html</a>
+</blockquote>
+
+<hr>
+<h1>The BPL Pickle Interface</h1>
+
+At the user level, the BPL pickle interface involves three special
+methods:
+
+<dl>
+<dt>
+<strong>__getinitargs__</strong>
+<dd>
+  When an instance of a BPL extension class is pickled, the pickler
+  tests if the instance has a __getinitargs__ method. This method must
+  return a Python tuple. When the instance is restored by the
+  unpickler, the contents of this tuple are used as the arguments for
+  the class constructor.
+
+  <p>
+  If __getinitargs__ is not defined, the class constructor will be
+  called without arguments.
+
+<p>
+<dt>
+<strong>__getstate__</strong>
+
+<dd>
+  When an instance of a BPL extension class is pickled, the pickler
+  tests if the instance has a __getstate__ method. This method should
+  return a Python object representing the state of the instance.
+
+  <p>
+  If __getstate__ is not defined, the instance's __dict__ is pickled
+  (if it is not empty).
+
+<p>
+<dt>
+<strong>__setstate__</strong>
+
+<dd>
+  When an instance of a BPL extension class is restored by the
+  unpickler, it is first constructed using the result of
+  __getinitargs__ as arguments (see above). Subsequently the unpickler
+  tests if the new instance has a __setstate__ method. If so, this
+  method is called with the result of __getstate__ (a Python object) as
+  the argument.
+
+  <p>
+  If __setstate__ is not defined, the result of __getstate__ must be
+  a Python dictionary. The items of this dictionary are added to
+  the instance's __dict__.
+</dl>
+
+If both __getstate__ and __setstate__ are defined, the Python object
+returned by __getstate__ need not be a dictionary. The __getstate__ and
+__setstate__ methods can do what they want.
+
+<hr>
+<h1>Pitfalls and Safety Guards</h1>
+
+In BPL extension modules with many extension classes, providing
+complete pickle support for all classes would be a significant
+overhead. In general complete pickle support should only be implemented
+for extension classes that will eventually be pickled. However, the
+author of a BPL extension module might not anticipate correctly which
+classes need support for pickle. Unfortunately, the pickle protocol
+described above has two important pitfalls that the end user of a BPL
+extension module might not be aware of:
+
+<dl>
+<dt>
+<strong>Pitfall 1:</strong>
+Both __getinitargs__ and __getstate__ are not defined.
+
+<dd>
+  In this situation the unpickler calls the class constructor without
+  arguments and then adds the __dict__ that was pickled by default to
+  that of the new instance.
+
+  <p>
+  However, most C++ classes wrapped with the BPL will have member data
+  that are not restored correctly by this procedure. To alert the user
+  to this problem, a safety guard is provided. If both __getinitargs__
+  and __getstate__ are not defined, the BPL tests if the class has an
+  attribute __dict_defines_state__. An exception is raised if this
+  attribute is not defined:
+
+<pre>
+    RuntimeError: Incomplete pickle support (__dict_defines_state__ not set)
+</pre>
+
+  In the rare cases where this is not the desired behavior, the safety
+  guard can deliberately be disabled. The corresponding C++ code for
+  this is, e.g.:
+
+<pre>
+    class_builder<your_class> py_your_class(your_module, "your_class");
+    py_your_class.dict_defines_state();
+</pre>
+
+  It is also possible to override the safety guard at the Python level.
+  E.g.:
+
+<pre>
+    import your_bpl_module
+    class your_class(your_bpl_module.your_class):
+      __dict_defines_state__ = 1
+</pre>
+
+<p>
+<dt>
+<strong>Pitfall 2:</strong>
+__getstate__ is defined and the instance's __dict__ is not empty.
+
+<dd>
+  The author of a BPL extension class might provide a __getstate__
+  method without considering the possibilities that:
+
+  <p>
+  <ul>
+  <li>
+    his class is used as a base class. Most likely the __dict__ of
+    instances of the derived class needs to be pickled in order to
+    restore the instances correctly.
+
+  <p>
+  <li>
+    the user adds items to the instance's __dict__ directly. Again,
+    the __dict__ of the instance then needs to be pickled.
+  </ul>
+  <p>
+
+  To alert the user to this highly unobvious problem, a safety guard is
+  provided. If __getstate__ is defined and the instance's __dict__ is
+  not empty, the BPL tests if the class has an attribute
+  __getstate_manages_dict__. An exception is raised if this attribute
+  is not defined:
+
+<pre>
+    RuntimeError: Incomplete pickle support (__getstate_manages_dict__ not set)
+</pre>
+
+  To resolve this problem, it should first be established that the
+  __getstate__ and __setstate__ methods manage the instances's __dict__
+  correctly. Note that this can be done both at the C++ and the Python
+  level. Finally, the safety guard should intentionally be overridden.
+  E.g. in C++:
+
+<pre>
+    class_builder<your_class> py_your_class(your_module, "your_class");
+    py_your_class.getstate_manages_dict();
+</pre>
+
+  In Python:
+
+<pre>
+    import your_bpl_module
+    class your_class(your_bpl_module.your_class):
+      __getstate_manages_dict__ = 1
+      def __getstate__(self):
+        # your code here
+      def __setstate__(self, state):
+        # your code here
+</pre>
+</dl>
+
+<hr>
+<h1>Practical Advice</h1>
+
+<ul>
+<li>
+  Avoid using __getstate__ if the instance can also be reconstructed
+  by way of __getinitargs__. This automatically avoids Pitfall 2.
+
+<p>
+<li>
+  If __getstate__ is required, include the instance's __dict__ in the
+  Python object that is returned.
+</ul>
+
+<hr>
+<address>
+Author: Ralf W. Grosse-Kunstleve, March 2001
+</address>
+</html>

From af6cfd0ea8b5c854e66ecc8540f8c3fb54860e54 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:56:38 +0000
Subject: [PATCH 023/369] std::complex<> fixes for MSVC

[SVN r9418]
---
 src/conversions.cpp | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/conversions.cpp b/src/conversions.cpp
index 369f197a..88e30048 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -7,7 +7,8 @@
 //  producing this work.
 //
 // Revision History:
-// Mar 03 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
+// 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
+// 03 Mar 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
 
 #include <boost/python/conversions.hpp>
 #include <typeinfo>
@@ -47,6 +48,19 @@ void handle_exception()
     }
 }
 
+namespace detail {
+
+  void expect_complex(PyObject* p)
+  {
+      if (!PyComplex_Check(p))
+      {
+          PyErr_SetString(PyExc_TypeError, "expected a complex number");
+          throw boost::python::argument_error();
+      }
+  }
+
+} // namespace boost::python::detail
+
 }} // namespace boost::python
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE

From f6ba5a41da56aabcd0c337b1bd3fcaf36923d889 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:57:47 +0000
Subject: [PATCH 024/369] Use PyObject_INIT() instead of trying to
 hand-initialize

[SVN r9419]
---
 src/extension_class.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index 47862ec7..f71976b9 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -7,7 +7,7 @@
 //  producing this work.
 //
 // Revision History:
-// Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
+// 04 Mar 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
 #include <boost/python/detail/extension_class.hpp>
 #include <cstring>
@@ -463,7 +463,9 @@ operator_dispatcher::create(const ref& object, const ref& self)
     free_list = result->m_free_list_link;
     result->m_object = object;
     result->m_self = self;
-    Py_INCREF(result);
+
+    PyObject* result_as_pyobject = result;
+    PyObject_INIT(result_as_pyobject, &type_obj);
     return result;
 }
 

From 405710e635cce91ce42a0bd82ba4925cc82dc4dc Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 15:59:52 +0000
Subject: [PATCH 025/369] Changed name of extension module so it would work
 with DebugPython, eliminated useless test that aggravated MSVC

[SVN r9420]
---
 test/comprehensive.cpp | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 592b0ebd..57edd687 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -5,6 +5,10 @@
 //
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
+
+//  Revision History:
+//  04 Mar 01  Changed name of extension module so it would work with DebugPython,
+//             eliminated useless test that aggravated MSVC (David Abrahams)
 #include "comprehensive.hpp"
 #include <boost/python/class_builder.hpp>
 #include <stdio.h> // used for portability on broken compilers
@@ -818,7 +822,14 @@ namespace bpl_test {
   // Test plain char converters.
   char get_plain_char() { return 'x'; }
   std::string use_plain_char(char c) { return std::string(3, c); }
-  std::string use_const_plain_char(const char c) { return std::string(5, c); }
+
+  // This doesn't test anything but the compiler, since it has the same signature as the above.
+  // Since MSVC is broken and gets the signature wrong, we'll skip it.
+  std::string use_const_plain_char(
+#ifndef BOOST_MSVC6_OR_EARLIER
+      const 
+#endif
+      char c) { return std::string(5, c); }
 
   // Test std::complex<double> converters.
   std::complex<double> dpolar(double rho, double theta) {
@@ -1091,18 +1102,18 @@ PyObject* raw(const boost::python::tuple& args, const boost::python::dictionary&
 
 void init_module()
 {
-    boost::python::module_builder test("test");
-    init_module(test);
+    boost::python::module_builder boost_python_test("boost_python_test");
+    init_module(boost_python_test);
 
     // Just for giggles, add a raw metaclass.
-    test.add(new boost::python::meta_class<boost::python::instance>);
+    boost_python_test.add(new boost::python::meta_class<boost::python::instance>);
 }
 
 extern "C"
 #ifdef _WIN32
 __declspec(dllexport)
 #endif
-void inittest()
+void initboost_python_test()
 {
     try {
         bpl_test::init_module();

From 7208104122237e24eafd16f471ebc6eedf289e6b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 4 Mar 2001 16:02:46 +0000
Subject: [PATCH 026/369] Changed name of extension module so it would work
 with DebugPython, fixed exception message checking to work with Python 2.0

[SVN r9421]
---
 test/comprehensive.py | 44 ++++++++++++++++++++++++++++++-------------
 1 file changed, 31 insertions(+), 13 deletions(-)

diff --git a/test/comprehensive.py b/test/comprehensive.py
index 3c7f3c61..c8033575 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -7,6 +7,15 @@ r'''
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 
+//  Revision History:
+//  04 Mar 01 Changed name of extension module so it would work with DebugPython,
+//            fixed exception message checking to work with Python 2.0
+//            (Dave Abrahams)
+
+Load up the extension module
+
+    >>> from boost_python_test import *
+
 Automatic checking of the number and type of arguments. Foo's constructor takes
 a single long parameter. 
 
@@ -17,9 +26,9 @@ a single long parameter.
 
     >>> try: ext = Foo('foo')
     ... except TypeError, err:
-    ...     assert re.match(
-    ... '(illegal argument type for built-in operation)|(an integer is required)', str(err))
-    ... else: print 'no exception'
+    ...    assert_integer_expected(err)
+    ... else:
+    ...    print 'no exception'
 
     >>> ext = Foo(1)
 
@@ -209,7 +218,7 @@ Polymorphism also works:
 Pickling tests:
 
     >>> world.__module__
-    'test'
+    'boost_python_test'
     >>> world.__safe_for_unpickling__
     1
     >>> world.__reduce__()
@@ -697,10 +706,11 @@ Testing interaction between callbacks, base declarations, and overloading
     >>> c = CallbackTest()
     >>> c.testCallback(1)
     2
-    >>> c.testCallback('foo')
-    Traceback (innermost last):
-      File "<stdin>", line 1, in ?
-    TypeError: illegal argument type for built-in operation
+    
+    >>> try: c.testCallback('foo')
+    ... except TypeError, err: assert_integer_expected(err)
+    ... else: print 'no exception'
+
     >>> c.callback(1)
     2
     >>> c.callback('foo')
@@ -719,10 +729,11 @@ Testing interaction between callbacks, base declarations, and overloading
     -1
     >>> r.callback('foo')
     'foo 1'
-    >>> r.testCallback('foo')
-    Traceback (innermost last):
-      File "<stdin>", line 1, in ?
-    TypeError: illegal argument type for built-in operation
+    
+    >>> try: r.testCallback('foo')
+    ... except TypeError, err: assert_integer_expected(err)
+    ... else: print 'no exception'
+    
     >>> r.testCallback(1)
     -1
     >>> testCallback(r, 1)
@@ -1145,8 +1156,15 @@ test methodologies for wrapping functions that return a pointer
     '6.35'
 
 '''
+#'
+
+def assert_integer_expected(err):
+  """Handle a common error report which appears differently in Python 1.5.x and 2.0"""
+  assert isinstance(err, TypeError)
+  message = str(err)
+  assert (message == "illegal argument type for built-in operation"
+          or message == "an integer is required")
 
-from test import *
 import string
 import re
 import sys

From 03dd2883f71fd8753148a3493ff4a70f909bd4f4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sun, 4 Mar 2001 17:39:14 +0000
Subject: [PATCH 027/369] file name change: test.so -> boost_python_test.so

[SVN r9426]
---
 build/Makefile.linux_gcc |  8 ++++----
 build/Makefile.mingw32   | 16 ++++++++--------
 build/Makefile.tru64_cxx |  8 ++++----
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/build/Makefile.linux_gcc b/build/Makefile.linux_gcc
index 3e8f1041..7021e221 100644
--- a/build/Makefile.linux_gcc
+++ b/build/Makefile.linux_gcc
@@ -79,7 +79,7 @@ DEPOBJ= $(OBJ) comprehensive.o abstract.o \
 
 .SUFFIXES: .o .cpp
 
-all: libbpl.a test.so abstract.so \
+all: libbpl.a boost_python_test.so abstract.so \
      getting_started1.so getting_started2.so getting_started3.so \
      getting_started4.so getting_started5.so
 
@@ -111,8 +111,8 @@ libbpl.a: $(OBJ)
 	rm -f libbpl.a
 	ar r libbpl.a $(OBJ)
 
-test.so: $(OBJ) comprehensive.o
-	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o test.so -lm
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
 
 abstract.so: $(OBJ) abstract.o
 	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
@@ -146,7 +146,7 @@ test:
 
 clean:
 	rm -f $(OBJ) libbpl.a libbpl.a.input
-	rm -f comprehensive.o test.so
+	rm -f comprehensive.o boost_python_test.so
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
diff --git a/build/Makefile.mingw32 b/build/Makefile.mingw32
index 2d86efcd..7c5f2c52 100644
--- a/build/Makefile.mingw32
+++ b/build/Makefile.mingw32
@@ -31,8 +31,8 @@
 # Could this be fixed with compiler options?
 # -fhuge-objects looks interesting, but requires recompiling the C++ library.
 #                (what exactly does that mean?)
-# -fvtable-thunks eliminates the compiler warning, but "import test" still
-#                 causes a crash.
+# -fvtable-thunks eliminates the compiler warning,
+# but "import boost_python_test" still causes a crash.
 
 BOOST_UNIX= /net/cci/rwgk/boost
 BOOST_WIN= "L:\boost"
@@ -82,7 +82,7 @@ $(BPL_EXA)/test_getting_started4.py \
 $(BPL_EXA)/test_getting_started5.py
 
 DEFS= \
-test \
+boost_python_test \
 abstract \
 getting_started1 \
 getting_started2 \
@@ -96,7 +96,7 @@ OBJ = classes.o conversions.o extension_class.o functions.o \
 
 .SUFFIXES: .o .cpp
 
-all: libbpl.a test.pyd abstract.pyd \
+all: libbpl.a boost_python_test.pyd abstract.pyd \
      getting_started1.pyd getting_started2.pyd getting_started3.pyd \
      getting_started4.pyd getting_started5.pyd
 
@@ -143,10 +143,10 @@ libbpl.a: $(OBJ)
 DLLWRAPOPTS= -s --driver-name g++ -s
              --entry _DllMainCRTStartup@12 --target=i386-mingw32
 
-test.pyd: $(OBJ) comprehensive.o
+boost_python_test.pyd: $(OBJ) comprehensive.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname test.pyd \
-          --def test.def \
+          --dllname boost_python_test.pyd \
+          --def boost_python_test.def \
           $(OBJ) comprehensive.o $(PYLIB)
 
 abstract.pyd: $(OBJ) abstract.o
@@ -199,7 +199,7 @@ test:
 
 clean:
 	rm -f $(OBJ) libbpl.a libbpl.a.input
-	rm -f comprehensive.o test.pyd
+	rm -f comprehensive.o boost_python_test.pyd
 	rm -f abstract.o abstract.pyd
 	rm -f getting_started1.o getting_started1.pyd
 	rm -f getting_started2.o getting_started2.pyd
diff --git a/build/Makefile.tru64_cxx b/build/Makefile.tru64_cxx
index 7b932bd3..2b417944 100644
--- a/build/Makefile.tru64_cxx
+++ b/build/Makefile.tru64_cxx
@@ -79,7 +79,7 @@ DEPOBJ= $(OBJ) comprehensive.o abstract.o \
 
 .SUFFIXES: .o .cpp
 
-all: libbpl.a test.so abstract.so \
+all: libbpl.a boost_python_test.so abstract.so \
      getting_started1.so getting_started2.so getting_started3.so \
      getting_started4.so getting_started5.so
 
@@ -115,8 +115,8 @@ libbpl.a: $(OBJ)
 	rm -f libbpl.a.input
 	ar r libbpl.a $(OBJ)
 
-test.so: $(OBJ) comprehensive.o
-	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o test.so -lm
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
 
 abstract.so: $(OBJ) abstract.o
 	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
@@ -150,7 +150,7 @@ test:
 
 clean:
 	rm -f $(OBJ) libbpl.a libbpl.a.input
-	rm -f comprehensive.o test.so
+	rm -f comprehensive.o boost_python_test.so
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so

From 5ad51c36fb5bc0d3055977409512e099a0e79a38 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 5 Mar 2001 03:43:10 +0000
Subject: [PATCH 028/369] Turned off "enable minimal rebuild", which causes
 INTERNAL COMPILER ERRORs

[SVN r9437]
---
 build/bpl_static.dsp        | 4 ++--
 build/example1/example1.dsp | 4 ++--
 build/rwgk1/rwgk1.dsp       | 4 ++--
 build/test/test.dsp         | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/build/bpl_static.dsp b/build/bpl_static.dsp
index 92af59c7..ca70236d 100644
--- a/build/bpl_static.dsp
+++ b/build/bpl_static.dsp
@@ -65,7 +65,7 @@ LIB32=link.exe -lib
 # PROP Intermediate_Dir "Debug"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm- /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe
@@ -88,7 +88,7 @@ LIB32=link.exe -lib
 # PROP Intermediate_Dir "DebugPython"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W4 /WX /Gm /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "BOOST_DEBUG_PYTHON" /FR /YX /FD /GZ /EHs /c
+# ADD CPP /nologo /MDd /W4 /WX /Gm- /GR /GX /Zi /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "BOOST_DEBUG_PYTHON" /FR /YX /FD /GZ /EHs /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe
diff --git a/build/example1/example1.dsp b/build/example1/example1.dsp
index dcff3f55..4d95aa97 100644
--- a/build/example1/example1.dsp
+++ b/build/example1/example1.dsp
@@ -70,7 +70,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -97,7 +97,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 1
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /EHs /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /EHs /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
diff --git a/build/rwgk1/rwgk1.dsp b/build/rwgk1/rwgk1.dsp
index daf736b3..67476984 100644
--- a/build/rwgk1/rwgk1.dsp
+++ b/build/rwgk1/rwgk1.dsp
@@ -69,7 +69,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
@@ -96,7 +96,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 1
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
diff --git a/build/test/test.dsp b/build/test/test.dsp
index 0816bf1e..4bd2822a 100644
--- a/build/test/test.dsp
+++ b/build/test/test.dsp
@@ -71,7 +71,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
 # SUBTRACT CPP /Fr
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
@@ -100,7 +100,7 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 1
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /Zm200 /EHs /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /Zm200 /EHs /c
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"

From 7d29c6a0f79680e5a0512b396dc4c0691a2a5482 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 5 Mar 2001 03:44:46 +0000
Subject: [PATCH 029/369] tests for null pointer <=> None conversions

[SVN r9438]
---
 test/comprehensive.cpp | 24 +++++++++++++++++++++++-
 test/comprehensive.py  | 15 +++++++++++++++
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 57edd687..3d173310 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -242,6 +242,23 @@ boost::shared_ptr<Foo> Baz::create_foo()
     return boost::shared_ptr<Foo>(new DerivedFromFoo(0));
 }
 
+// Used to check conversion to None
+boost::shared_ptr<Foo> foo_factory(bool create)
+{
+    return boost::shared_ptr<Foo>(create ? new DerivedFromFoo(0) : 0);
+}
+
+// Used to check conversion from None
+bool foo_ptr_is_null(Foo* p)
+{
+    return p == 0;
+}
+
+bool foo_shared_ptr_is_null(boost::shared_ptr<Foo> p)
+{
+    return p.get() == 0;
+}
+
 // We can accept smart pointer parameters
 int Baz::get_foo_value(boost::shared_ptr<Foo> foo)
 {
@@ -408,7 +425,7 @@ static int testUpcast(Base* b)
 
 static std::auto_ptr<Base> derived1Factory(int i)
 {
-    return std::auto_ptr<Base>(new Derived1(i));
+    return std::auto_ptr<Base>(i < 0 ? 0 : new Derived1(i));
 }
 
 static std::auto_ptr<Base> derived2Factory(int i)
@@ -1081,6 +1098,11 @@ void init_module(boost::python::module_builder& m)
     m.def(fpolar, "fpolar");
     m.def(freal, "freal");
     m.def(fimag, "fimag");
+
+    // Test new null-pointer<->None conversions
+    m.def(foo_factory, "foo_factory");
+    m.def(foo_ptr_is_null, "foo_ptr_is_null");
+    m.def(foo_shared_ptr_is_null, "foo_shared_ptr_is_null");
 }
 
 PyObject* raw(const boost::python::tuple& args, const boost::python::dictionary& keywords)
diff --git a/test/comprehensive.py b/test/comprehensive.py
index c8033575..c1424d25 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -73,6 +73,21 @@ We can subclass Foo.
     >>> b.call_pure()
     'not pure anymore!'
 
+None corresponds to a NULL pointer or smart pointer
+    >>> f = foo_factory(1)
+    >>> f.add_len('xxx')
+    1000
+    >>> foo_factory(0) is None
+    1
+    >>> foo_ptr_is_null(None)
+    1
+    >>> foo_ptr_is_null(f)
+    0
+    >>> foo_shared_ptr_is_null(None)
+    1
+    >>> foo_shared_ptr_is_null(f)
+    0
+    
 If no __init__ function is defined, the one from the base class takes effect, just
 like in a Python class.
 

From a559a371b1c839e7189afa3aa7c8b8da9890d17e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 5 Mar 2001 03:48:38 +0000
Subject: [PATCH 030/369] enable null pointer <=> None conversions

[SVN r9439]
---
 .../boost/python/detail/extension_class.hpp   | 82 +++++++++++++++----
 src/gen_extclass.py                           | 82 +++++++++++++++----
 2 files changed, 130 insertions(+), 34 deletions(-)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index bf43ec5c..987d753e 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -22,6 +22,7 @@
 # include <boost/python/detail/init_function.hpp>
 # include <typeinfo>
 # include <boost/smart_ptr.hpp>
+# include <boost/type_traits.hpp>
 
 namespace boost { namespace python {
 
@@ -133,6 +134,26 @@ class class_registry
     static std::vector<derived_class_info> static_derived_class_info;
 };
 
+template <bool is_pointer>
+struct is_null_helper
+{
+    template <class Ptr>
+    static bool test(Ptr x) { return x == 0; }
+};
+
+template <>
+struct is_null_helper<false>
+{
+    template <class Ptr>
+    static bool test(const Ptr& x) { return x.get() == 0; }
+};
+
+template <class Ptr>
+bool is_null(const Ptr& x)
+{
+    return is_null_helper<(is_pointer<Ptr>::value)>::test(x);
+};
+
 }}} // namespace boost::python::detail
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
@@ -178,9 +199,9 @@ class python_extension_class_converters
                 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*>)
+
+    friend
+    T* non_null_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);
@@ -201,9 +222,18 @@ class python_extension_class_converters
         throw boost::python::argument_error();
     }
 
-    // Convert to PtrType, where PtrType can be dereferenced to obtain a T.
+    // Convert to T*
+    friend T* from_python(PyObject* obj, boost::python::type<T*>)
+    {
+        if (obj == Py_None)
+            return 0;
+        else
+            return non_null_from_python(obj, boost::python::type<T*>());
+    }
+
+    // Extract from obj a mutable reference to the PtrType object which is holding a T.
     template <class PtrType>
-    static PtrType& ptr_from_python(PyObject* obj, boost::python::type<PtrType>)
+    static PtrType& smart_ptr_reference(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);
@@ -220,9 +250,27 @@ class python_extension_class_converters
         throw boost::python::argument_error();
     }
 
+    // Extract from obj a constant reference to the PtrType object which is holding a T.
+    // If obj is None, the reference denotes a default-constructed PtrType
     template <class PtrType>
-    static PyObject* ptr_to_python(PtrType x)
+    static const PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
     {
+        if (obj == Py_None)
+        {
+            static PtrType null_ptr;
+            return null_ptr;
+        }
+        return smart_ptr_reference(obj, boost::python::type<PtrType>());
+    }
+        
+    template <class PtrType>
+    static PyObject* smart_ptr_to_python(PtrType x)
+    {
+        if (boost::python::detail::is_null(x))
+        {
+            return boost::python::detail::none();
+        }
+        
         boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
         result->add_implementation(
             std::auto_ptr<boost::python::detail::instance_holder_base>(
@@ -254,7 +302,7 @@ class python_extension_class_converters
  
     // 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*>())); }
+        { return *boost::python::detail::check_non_null(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&>)
@@ -265,28 +313,28 @@ class python_extension_class_converters
         { 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> >()); }
+        { return smart_ptr_reference(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<std::auto_ptr<T> >)
+        { return smart_ptr_value(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> >()); }
+        { return smart_ptr_value(p, boost::python::type<std::auto_ptr<T> >()); }
 
     friend PyObject* to_python(std::auto_ptr<T> x)
-        { return ptr_to_python(x); }
+        { return smart_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> >()); }
+        { return smart_ptr_reference(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<boost::shared_ptr<T> >)
+        { return smart_ptr_value(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> >()); }
+        { return smart_ptr_value(p, boost::python::type<boost::shared_ptr<T> >()); }
 
     friend PyObject* to_python(boost::shared_ptr<T> x)
-        { return ptr_to_python(x); }
+        { return smart_ptr_to_python(x); }
 };
 
 // Convert T to_python, instantiated on demand and only if there isn't a
diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index 7c378d45..2d261289 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -27,6 +27,7 @@ def gen_extclass(args):
 # include <boost/python/detail/init_function.hpp>
 # include <typeinfo>
 # include <boost/smart_ptr.hpp>
+# include <boost/type_traits.hpp>
 
 namespace boost { namespace python {
 
@@ -138,6 +139,26 @@ class class_registry
     static std::vector<derived_class_info> static_derived_class_info;
 };
 
+template <bool is_pointer>
+struct is_null_helper
+{
+    template <class Ptr>
+    static bool test(Ptr x) { return x == 0; }
+};
+
+template <>
+struct is_null_helper<false>
+{
+    template <class Ptr>
+    static bool test(const Ptr& x) { return x.get() == 0; }
+};
+
+template <class Ptr>
+bool is_null(const Ptr& x)
+{
+    return is_null_helper<(is_pointer<Ptr>::value)>::test(x);
+};
+
 }}} // namespace boost::python::detail
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
@@ -183,9 +204,9 @@ class python_extension_class_converters
                 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*>)
+
+    friend
+    T* non_null_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);
@@ -206,9 +227,18 @@ class python_extension_class_converters
         throw boost::python::argument_error();
     }
 
-    // Convert to PtrType, where PtrType can be dereferenced to obtain a T.
+    // Convert to T*
+    friend T* from_python(PyObject* obj, boost::python::type<T*>)
+    {
+        if (obj == Py_None)
+            return 0;
+        else
+            return non_null_from_python(obj, boost::python::type<T*>());
+    }
+
+    // Extract from obj a mutable reference to the PtrType object which is holding a T.
     template <class PtrType>
-    static PtrType& ptr_from_python(PyObject* obj, boost::python::type<PtrType>)
+    static PtrType& smart_ptr_reference(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);
@@ -225,9 +255,27 @@ class python_extension_class_converters
         throw boost::python::argument_error();
     }
 
+    // Extract from obj a constant reference to the PtrType object which is holding a T.
+    // If obj is None, the reference denotes a default-constructed PtrType
     template <class PtrType>
-    static PyObject* ptr_to_python(PtrType x)
+    static const PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
     {
+        if (obj == Py_None)
+        {
+            static PtrType null_ptr;
+            return null_ptr;
+        }
+        return smart_ptr_reference(obj, boost::python::type<PtrType>());
+    }
+        
+    template <class PtrType>
+    static PyObject* smart_ptr_to_python(PtrType x)
+    {
+        if (boost::python::detail::is_null(x))
+        {
+            return boost::python::detail::none();
+        }
+        
         boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
         result->add_implementation(
             std::auto_ptr<boost::python::detail::instance_holder_base>(
@@ -259,7 +307,7 @@ class python_extension_class_converters
  
     // 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*>())); }
+        { return *boost::python::detail::check_non_null(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&>)
@@ -270,28 +318,28 @@ class python_extension_class_converters
         { 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> >()); }
+        { return smart_ptr_reference(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<std::auto_ptr<T> >)
+        { return smart_ptr_value(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> >()); }
+        { return smart_ptr_value(p, boost::python::type<std::auto_ptr<T> >()); }
 
     friend PyObject* to_python(std::auto_ptr<T> x)
-        { return ptr_to_python(x); }
+        { return smart_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> >()); }
+        { return smart_ptr_reference(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<boost::shared_ptr<T> >)
+        { return smart_ptr_value(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> >()); }
+        { return smart_ptr_value(p, boost::python::type<boost::shared_ptr<T> >()); }
 
     friend PyObject* to_python(boost::shared_ptr<T> x)
-        { return ptr_to_python(x); }
+        { return smart_ptr_to_python(x); }
 };
 
 // Convert T to_python, instantiated on demand and only if there isn't a

From 1edec9ff89141b4624e8824f7b806369d70c8fe1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 5 Mar 2001 14:41:57 +0000
Subject: [PATCH 031/369] no message

[SVN r9443]
---
 build/build.opt | Bin 80384 -> 86528 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/build/build.opt b/build/build.opt
index 9cdea95b7eef30bf876fd69fc7e9971cd8f4a6f9..5086795feff7997de1d0b50d82b2404da330c819 100644
GIT binary patch
literal 86528
zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;!F$-42&?o00YCn|NsAkxG);Tu3%tb_&*AU
zObGn_|Np-N0|Nsy0|NsK0|Nsq0|PkD*%=rZI2afhI2jlixEL51xEUbv&C9^Rz{kMA
zz|X+IAi%)DAjrVLAjH7HAk4tPAi}`FAPQ9{&cMJR!N9;E$-uxM#lXNI&A`AQ!@$5G
z%fP@O$H2fK4^`*Sz`&ryz`&r)z`&rwz`&r&z`&r!z`&r+z`&rvz`&r%z`&pdRjb3m
zz@W>(z@W##z@X2-z+k|@z+lM0z+l9{z+lY4z+eJZXU4$5V9vn6V8Ot^V9CJ1V8y_|
zV9mh5V8g(`V9UV3V8_6~V9&t7;K0DZ;K;zh-~`p@!oa}b%D}+j#=yYf&cMLn!N9=a
z$-uzi#lXPe&A`Cm!@$7c%fP_k2UXw9z`zj5z`zj1z`zj9z`zi~z`zj7z`zj3z`zjB
zz`zi}z`zj6z`zj2z`zg<)f3CWz!1m4z!1;Cz>vVez>vtmz>vhiz>v(qz>vbgz>vzo
zz>vnkz>v<sz>vYfz>vwnz>vkjz>v+rz>vehz>o_yC!c|Vp@4ybp^$-rp@@Njp_qYz
zp@e~fp_GAvp^Slnp&Y6X6u(sr3=Gu_3=B043=Fjl3=DM)3=H)Q3=9omx92nDGn6nW
zFt{@0F_bVAF;s%GG0|9zffb(Lk;@8f1}MDhZ&P1-fDyU82xrJ=C}PNFC}t>NNMuN6
zNM%r92xcf@NMtAhhXposki`@jm>5Bs4U|4XG_o8nHmDo}CsuIW7ct~Blrt1Fq=Lf{
zmmXZ=0t`%ypu7XhE5zE*12PPhS-|Nng&~un1RM$=VNx+40}~@Ce}e1=VPf=)ffPaQ
zXJlXn=X;it)Z!8iXRDZ`{QTmQn4HX{;+TTUl8pSkn55FooRk=lJebf+DJ}rj0$fQ2
zIq}6Mi6xoInt1dfRKYZ|7L})G8*1Uv16B|NCSjU5QY#X33vyBo4e;oLsfmFxV7fu&
z8Z(0=0}}&N5vYa&;cJWx41A0X3}#FW4BJ2<0>z+E1YuJq28NxCkdl#+fuR8;whOAB
zxq&k%H9fPqB(<m*RN8<_O-Tl32IeAA9tPn<j0_CFpm`d^2N}-Xz~-Bpn_pCE&J1!8
zBLhea3x<P0%0odR4AKLwPC-Q|sHn|ngjB(HPzQmEUXWVm1}^8soE(MVlEma}WaC+j
ziWwOg4lyt=Tw!8hSj@!0pw7g=0MY_A9b96AjIU&6U_dq=RFbE#Lew%haJys{Cl(i{
z<|gG-euvf*Am_6eEnr|^0O5b2uwjIhVjwSo%>QB7&j>2DL2QtZKw${NfBygf|MLI;
z{~$RK-p|CqFbx#e4V>ZmMcKs#iOH#EoS;BrW?*GtWDqC@nFxwCSh${rhAqfsQ2zV(
z|9?Hm<eSV43?Mn?1`glUyi$dv#3E2|Ff%YRFf#oA4=y9YdB2AdQi*^J231ZVgJ2kB
zP!%hr;sQDQE)%${WB`eQ)G{}41eYY{r6d-msDWG!ZWsOk&sg%8iGkrdBLl+;W(I~(
zCP=LZs_j4qgIozpM-_|=4DE~%IpzjdCs6K!nZm;G|36a+NTo9a1H(&3Nc{kEBFq$!
zb6B8}|CSL_mohhSyOn|>Ke;G1H4l`#K_-B_%Ul8~lR+`52(2SQW`Qu+MGd@Q+ZB8>
z^D><hi;!KxSSruLz+lhFz_6Bufgu(eugI<d`DF(S1H)8kjn3S_>=@z$s+&Q9&Cc-u
zKV#`xGyt+0gdw(b1f>?|mlh?bLNtN0+W-H|1T?X^WG3e1r^|!Gor!^&;s1XYtXg1h
z1(){F5G#d;7>9FyUP)1YPBAFBKn)*|L9C?)po9pjl0k(6)YC`~b}vdS$jD4C7G(sr
zmRP{Hvw<~%6jd=XFnBRS>VFU)<V%pzu(bIZ+BRTrU~|sT$uBAvM>2*TY)lv<14B6z
z1H)-XNRtBHm?I1f3{BAH26F>vNNPoiLP&mojyMa*L68vSD4hg#xdsyh!wG0cftkeI
zz~Y*cSpo}kCQ$8-HT)17SY1++O4H52Ar5NM{r}HUwulkZ=4)kww2eTjVIdAmqqYnT
z4O1Bz7$(C*oXx2yzq~jV)c67=PmsloWoYT+EXWuT1_d2+18ZPuYEdPqsR+^`3(CLc
z_;m=lB$gy5B^IYDxMU`#7bWH*Yi1;%nKdLaDJK<K2NMAu95CxZl>p3*%;gr0kVa)E
zBczcB@(~C_e8m!$nOcr)3k#^R29kqgkYW%92{1SC1%q>m0yN3OLJ(Xq5^x|}P-=31
zQ3}j935Ngw69{PG49~1eEJ|@oEHZ+|I1j`B{~hHMnHU&AF*<>nf#EAOfg#8Epa1{s
zGng0{BAFni(t|hsjQ{^LGH@_ByW}Tlhv%g*GRUwnH2nJizaA9%utF8mhm-=f%E5Ik
z0|RT3BttQ%RR?OMf`Wj7f#JoR4o2k$CQ$#g;V0CDzu+<-s(_&a)E}*fm<AF%3QE~X
zCVZIL&#2tM%)rFJ&;Zg2Djz{*7($07)Bpefk#sDm0_gzdV2BQA&lX7q14C&H1H;}J
z1_stx1_s|)28OAz3=9uq85lI;7#ND<7#Q}&F)*;jGcfqYGcZhzXJB|7&%j`qz`#(S
zz`$@Jfq_9Tk%1vMk%3`vA_D_!5(7hU5(7hI5(7h25(7hT5(C4HBnF0iNem2slNcD-
zk{K8RlNlK1Br`BPPi9~+N?~BAO<`a-ox;E%mde18lFGoaDV2fYZz=<WM;Zgeq%;PG
zyJ-vzkJA_!UZgQFNT)L}q^2`4WT!JQbfq&eOipKDxS!6zpq;_MP@ciSa5#g3fj^Uh
zAuf}FVO1sr!_Q0x29GQThACML3=gsx7__q)7|OF57;3W_7@D#f7#3zTFr3V0U^t)6
zz#y5!z#yN)z@U`Fz@VJNz)+aOz_2-of#GBh1H<ba28Ope3=Fop3=GM+3=G-13=C6p
z85q{&GBDf&b!hS!7;N(x7&7x17&hiHFg(v=V6e((V5rJxV7QUbz@SvXz|dX5z;M5S
zfg!k%fnj4I1A{>k1H+6W1_q^K28OA{3=Fy@3=9S(3=D=P3=E|u3=ES>7#P-;Ffgny
zVPM!^!oYB^gn@yjl!1Z0l!1Yxlz}0vl!2kDl!0MFDFefiQU-=&r3?(`N*Ng5mNGDW
zC}m*ySjxcQSjNE6TE@U|v5bL1qMU&trksIcWjO=GnQ{h(kL3&uIu#5IdKC-|W)%z!
zu@wvqy%h`$eH9E02P+sDu2nEFysKbf(5Pf!aI9otNUmgHSW?NraIlhr;cX=YgJ~55
zLs%69Lr)b0!)<5>&7qosVOli<!~SXp2F@A=hO`<6hRHPy49{yA7`$s47;0)67;e=v
zFu2w+FjUnsFg&VbU<j#aVCV&<$OZ<6>IMdeoec~OyFeYgMg|70Mg|7$Mg|7cMg|7Y
zMg|6-Mg|7oMh1r2jSLL88yOgsniv?on-~~6niv?mniv=+H!(2mYhqw{+{D1}q=|t+
zvYCNFu9<-$rI~@DznOtyW-|lBnq~%u_00?n8=4syZZ|V9+-+uHc-G9oAkxCXpx?s4
zVA8_CP}{=5P}jo1u)BqU;dKiGgJ3HIgLEqcgMBLlgHtO5gL5kbgIg;DLv||zLtZNb
zLw+j*Lw73!!<JSChKH>T43AqG7zElF7=+pw7=+sx81&m17&6)z7&_Y+7`odS7<RNV
zFzjk$VA$Qpz;L~dfq}D~fq}c7fx*3<fx)MpfuXjYfnh^C1H-0v28PY;3=HSn85pj$
zGcf#aXJAn8U|`VfU|<OEU|@*sU|@*qU|=ZgU|^{2U|?9<!N72(gMr~%2Ll6pCj$d#
zCj*0ECj*0SCj&!ECj&!UCj-OjP6mb>oeT`$I~f>QyBHYQyBHWax)>N#x)>Pzx)>M&
zx)>PhyBHW6yBHXnx)>Oyb}=yA>0)5G*Tujf-Oa$@*v-HY*Ui9?(9OV**v-ID(#^oI
zx0``se>VdIQx5}!Mh^o+a1R4RK@S5%Q4a${aSsDSTMq-nnH~m)b3F_U-+LGse)cdh
z{OVy~;O%8#i0oxxi0)-zXzyiU=<H=+=;~!)nA^+1@VJ+O;b|`e14kbN16Lmd19u+-
zgIpg2LslOHLrxz9!=ye2hADjv3{(3U7-sY_FzoJQVA$8kz;LmTfq}oDfkCOCfg!7(
zfuXjaf#GyN1H+kq28Pf53=CiTL1ilfS2LbuWES9HIIuaLC87@0@Ic6ovIc($I5RRb
zF$*v-fZ}e#$%&w*+u(Qfs0&9!U^E1%5(1#UIs+Sc*dNs40O1HG28IcYkYRn89Xim0
z0W_QdQUk)m%nS_Mq2e%gf1rF&qZy<Igkk2v)PQJEuXGv%sK1IBFgnA;zyRv8g5+Ts
zrVeB*$Se@XWgbWmsIw1J1H$;!fz*P`1dUmNy80kK6oUqTKzMZgkAY!y{14ROWPo*5
zN5}u5c?6nu8b-(e{{J5x{{zj9f(l$Yq|`Aw{>Q+;FgpJCe{}qBbo_60{BLypZ*=@`
zbo>w6JQ$@0Q3(8pj{k8eq_f;e0CoEZk>f_4G8zJ-Awbg*;9y{8@b&TXVPfD6Ni8mM
zE-flcRdlh6DK1KmNh~fXOEv>hp(U9)Fj_CUpkOO#xg%)hZ$N5MT7FS(VqS8pf{{W%
zeo+Zw&AOn45+F|{_?fbS)*1gu&}DnhzyO+=XZXAaJR->elLM&(VbH+dS3GjR@yPu{
zlLOf&zzDIAWiP6IAUQ#(92*unA*dWT7P%KtKM0`7f!q(mAU}xWk(0t92O4dWMUw-$
zlNIU~Y;wX-IVCLmM4*cZRj|mh;gMs9nu)Ft<Tnro`A;3qOprJTgXA>u$Z6w|)4?NW
zh(it(W+rHIpfKZr`T?69%$??F`at3!4Dy5M`=8~YC4e_rY{6+4Bo4wLIcYp{N;u>|
zdX@3Wf#gT=Xb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S0iBLx1lLe~FPFzPdmj{i|3
zL`TgS4S}H(0@(Inhcjd{<T0dx_eB%(i4p@7BWSDzv;!8jYL1Y4kUVHFB6trbcq3ar
zLn%WMc;|OKgEK=ubQgL)Lk>ecgC|2CLmC5UuRBN|Hmm{N{|&Mmgt4hX7t;m_K=(g;
zG6XPqGQ=|^F%*DpEQanq&jjzt2Pwpl<rtV4L1RCl1&_qqZwfLJbQl8od;y64sSFhi
zi43`5SEPbZH2^6hjHSr%KWJ|$_;3dB0!&s0@ZN7u=bXgi;;_ura#kBx{~$YLk_WW;
zTOk>wAhj4-g2OE{Cl#Sb9=>^3K^?qnT-{2+M4_N4KPxr4M59<!0I?ZdAuTf}wU`IG
zvkhcSF&}K#Hbjmay#E`*<^nqaQwxtrYGO)ikpfsh#9>HEaR{JT3Q+?g(R{-&I{wQ5
zABP8xosN$GGBAve{}L{fMpcZ4z-S1JhQMeDjE2By2#kinXb6mkz-R~z&JY+K{~et1
zGU}?)5THj0IL?6_9426smtUfg3^^1nCpE=RBpJ(DkPMKqLShv|PI@F(HT;N23=JGG
zw=gguojM5`KO7zZ1D&ahwq6l5RyVr-lYs%-8qd-7pY$kIM(r34fzc2c4S~@R7!85Z
z5Eu=C(GVC7fzc2cj3F>O{x=w7Wz<chAwZuHNO%RgP(%)CX`Ze^cxIllkplSG{{ZkM
zFnkDU$ek)249)?Nb$tYMN+EPAzzhyb%}GrxP6e%-WCWd64c__v3bdUW%=!&xf&4Fl
zMKjn{gtZcI7GVR}I7EVjoq`w`8MqmoLlTS9Q%gKcQgiY62d|4kk_6lYQUbLVWsM>u
z0~aK;-HY-|3!o}kIYeB%!ci7L;!($(l3KvXAj076l3I|Omy(*7T<M&jSCW{Sms*5k
zAT<@Tr<JGZWfT-JGVmi?3|g!SwUZ~aB(*59B)<s1GTxHXf}GU+B+xQay$syOaTiw>
z=jNxB=A`0N#g&|&mzJ51-%1Y1<wy9;5z0@BPfpCqi7zQi%q%I!Zyr}cWol7Teo-+#
z6M55e@)Ju4`;#+2DJwI#AP28m;N`l6&EhUC$;`<tsl@Mmo`S@Z<cyruvQ)g5^5kR|
z6XAZ|<T9cHjXN{1q$oKfH8~rfPel`pGD|XYQ%f?Fi87V5pb~U#72Y($pPUc6ZK{HB
z`0;>NB@<T0Sx}h*x<v(_M>t>!6L$*dNy$tmB7iwEa|`l|O7L06lbfGXTv|X#8GB}O
zD*mLwnM~OC{H1xB$@wWnWMPhiN<vN&0mV&zab`&>QPIs?l$e)Jgw1@psU;ctDTF=4
zm6%jqQk0mCH+Z>0DpHdY2_)U*{JgT%qT<Z_Jfi%<S6ot*nU_x3jqC-LX$5#wID2wx
zSt8!d%n7<jr=&OqUn*iRsLV~x#ixR|I43iisNe?|+=RUbDijE-;!7$`OG_;xtdKXq
z08#}JD8PA(a}$e7;tNU$)K%P&ileAB4_~No5Ox?p(RB+?PChYdf+wvskBGd=k(^ju
zf<Mc1lvIKe7rvTZvZN?6uNZVT5Hw-O7Z;=^<2P0i5-3m&_|@`*oIsRH5p<W}H&`Sw
zCo?@SH#M(>DAW0i6LX0xhae3$WD?Zg8^xm`Fd71*Auv!OFgpG>P$55R?`Q}Nd<fLD
zHiGYe8a@AE;NxP{1*0J_8UmvsFd71*AwaJXfX)BOzz^SmP11qq*&wrjJTOW0xj($R
zBw)I5&-;O{lY7I;jx-+#nFR!izhIS0wu&jq&(A52fsCm^DZSK+RFHy~tdn&!6?Bso
zlpv$s3K^+6Ir-KKP+oqqwL*TeUUEiCW|4-vo}NAgfld-p*MzG|$xjA}pecpA97!EW
zQ9M-G&{_e7t5;N-rxC5LTc#eXsRWu>{0*PL6oYAjhXFWPL5d(VpCFICVTIhV4q^{s
zUqhk}<TZr<@g@+EQb;I(SP<=?Fc_Q>3v$^DRt@wt2|6e}z}cxZGbaU_KI2nhDfA61
zH#oW>xd`M*M94sAK+&g{ab_A&fq)}5fu!&TG)Mu|K59=a^97|ALvE)BP3sopnSw^z
zxx>gH1ewrIO)f!9NJCvn%^7IOXe-esLX<<u(fL2{@`us+KgencQ0j&z(9!w7%$!tc
zSd7m9f!ER?rH;}0KXAD*I{$~BFd)?mG6|}dNAYL~jE2By2n<vRjL!cJRLGCoI~oE5
z9|EKEe*+%}qb?W?fq@DE*!ky04CM^z4A~@{JPvWO2m=!XCj$cm=pIL6&p!_UX_WvG
z3=A;)OBhlaKxeN*M2RPb7?>D&7#J9M85kIdwLb=Ayb6dw*bm{6PI56Yf$as^4Z_5j
zkOxu(J%8SrA%`K6p_rkVA&eoDA(f$=L4kq9^Y=-%zY@uQ*!+(q<g|4xlRunb8T6SS
z-0DTa>f!Sp<j(E%qR#Dr4TaCz&|q!{Y5{m+2h2v9)d3CuqfS&IM)HNh%HbXckNAVs
z6ET%D7(EG@ivmqnKxSk>EQDuq$2&+JL<h+8s8b&xk(aE4&$lGZ=YYJ22nOizC;IFS
z_OuVmZrBnDNE~-~f@GoAj858s2h*_cSVSIC!>(d<{s*?_6KR}!bpID<6D(4IjPCzJ
z3y{(MUzJG7V|4!)V%BeT{}+4$baek0sGTy3M?+vV1cqV=jL!cI#aJ74^JoZACj>_4
zf2b3Vqo$08z)%bU*!aH$Xy6-l3>&g)odYC+KKhSSwFpQx+!&;>f5ryTEy18cRKyrD
z!2xo_h&yBexd(MlASpk;xFjC3HzXcpF^Tg7pmT(ZQZrKXiZjbntrbwXh|zx?1$ABB
zq@w)n)I8n9(vp1Lf|4T4jUGZE`{5o3&jElu3-LC{^+b3UGV%^m{E~Ihc@+|EAU`2S
z!Eq)7kTQtZL9ADx%b^(tp}#;*dc(@Arw@)VNO}i}QF~edYpwv57FbdZNEm0hf+R=h
z1dtCCL?7|zCGyxi;!h;w0iDAHImip&fk&jCLPzYmQ$!zRMdHClM4nqm<Oz+Wp2<e!
zfsTZCpAbIAjEIvQ`4Pvk5jX`*5S+Z?!Izt-5;zHrn1k_%Ic$sYiFm{viALn%jKpnV
z5JdzTQRie4d4MG0BSZN?r_#kkP71?+k{3r_ejb6d3yC|Wj~8@sT1jSp9)ZLmoLW%=
zYE0zk#e<Uxe&-Qe01$b)8#ma>R02-qFE2_gfHs-%JCFE*Z6eR4B<^rlBF?}h_ViF<
zXKaW)p^)%iCr;3zbOd66*fU<aK-CVRB1SMXFS8^bmOSxCDDm@~uwzK^Rd=8whw#y?
zL>zNS%AtRJ#hK}Oi6x~)1d}<aEuWK0#PO}X#hH2OIjJT2dH6$*h!a)0A%zlw_$TW0
zVd4(uCF)FJ5|2M5X401ra>g>myZBDIB<h^vqSUn1qSQP>$IJ>rEG4e$CI0M8Vo!%9
zYSSk%CkqpK3MXlYOT&(q#+PG>If0m*U3*kKla}~HJ&9bs!c&w8s<%Ps+~Nxw<RwH9
zHmIXDibq3W*oVOA`2Vnv;!zKdh5*hG_|L+~%q+mbFnazY&LA3<7!8488v^w#jidR0
z*v9Ut$3{Z{e+c|%W@H(y|M7>>sO)G64A&5Vt^bi>KsuihbR{I(o<l|k_ykjOK>=u0
z2g;-=R19MV3@VN^g9a5ro4J6Bq7U*yh2bOXP(E~?1<FIa1CfD&19s>t7Jo1>U?|5p
z!jb_wEI`YaSiw7dsbv}qXsHkb10y3w5DS8)E#NDX^sxJnkpWFv1|&WRdjoxcItv2>
z1K2T0Q4jGdJOuy$XJCMwX*;_9CkERwub`ZOSP%tWn}fbBcy#>_-R>M6UH?Pm#bu-G
ze-Qf_QK~Y$7uJrh|A7{9qw9a5MH<o;VT{%f-lR0T{s(>)HBuOkuK$5%u+jBDm>Fzz
z{ZBITkp!dbe{kI^Kf3-0GxK0y{{z|oo5}{8|0Dg@-qH0x!*y(E)L+9t1R5C_7@8Ou
z82<hL{~v@~85kJa7#JAZ85kHk7#J8j85kJ47#JA385kIP7#J9O85kJ)7#JA(85kHQ
zFfcGoWME*J#K6EXnSp^}3IhYfR0alyX$%Yu(-{~TW-u@?%!Hafn}LC04g&+jTm}Y)
zc?=8;^BEWz7BDa{EM#C{Sj51<u$X~?VF?2R!%_wYhGh&449lVVKx0;;n06t+$iT_~
z8VCIUpOJx^!Pz;d*exd|I43^|X-p853m6;VV}cMaWS|hj1`i^Fm>4}E=n&@U_-}l1
zNn%N6GH5gz8d{^{zeObq1G|M6wAXWV|0iU{Gsg4*7vzdA_oDpL0%)HUq7tcO7<?Cb
zjgJ40j{oMN^pZ#Se?oKb=>AWPtK3HSe=^`4LMcwnO(kw?Z%Srz3E|CPqx(O>7o&~t
z|3odGNB4hXIh=WP|0hOKjlMJp@7&tx`0wcWZ*Z_v(CGe8(5TEP9t{CpA>hK0%8<lR
z%8<^G&XCGbgi9GtaUnA9zi9!PrUN1v7+e_g8Il=F8FCp?8S)rP7>XgnM3bQVhmc1{
ziP1O<q(}xtPzRH0KXq(Hm_mvDTnx+%;s~R#+@dt28g$5rl~qc9Jm^Rg4d~fB3R*e}
zaHgh?vsDauEH5S}GpRTRawcC)aZz#%NHgMulH`H{kWwdq|KN}qA5W*?n1IL-4}ZTH
zr%+EHmzWUO;E)&>SEo>Sm@r6TJcJVul8txKbMf)1RnRjsMRqkP2$1=sj;3Bn8yg^p
z><|g*A?#?-904fA(L;KFby`t=F7)sw<ZKAecve=BOlM^UI)un3sUQb@B&L;BP-1yV
zYH^8zmYt@Ko?Z+bfpzIaH0h_LmLz88=wms+idxy#$P(lyTz=a_p5L4ji&F=;#}1I^
zF_+Y$%(B!J!{O{XqrvUD6XeC5b7D>o=(I>so*Vqhb02x03`$MTFG?BQ@wb;uuO;TC
z5ArhQ2zfs9FH0@T$xloHrOd${b!2)FIqMB>5AG%}2Ho=W2e-fevoKbJ+ZBk`2&91#
zkJhq?ha4YTl3G-Z)Kqaa)Iqdc9KqcUP*G}UWmTM;SX2^UP*N0Mk`HSE6_=z~S%FUE
z28pAXGO#Tjb3=SBo&VgF1(A^sS^z_uZdO(qsW~a}nR&$}iFwJX$iZP`r+^~__4M=x
zv`t7Lq$o>FPRNPLiQL5GWH_i36F)_X3DiCzH93Lw4AlfhS=MvQ&qper-175b^$m{P
z1<j|$8Hq)yDQIPsTYmnaPFK7XrmHH_lU3CaO;w*Msqu(QQ)P)crKyM>|3DYpX5axK
zTwVG9LIa<623>%G0t@G@4j@So)=IXDDap^zK^Z?SNCqD^4;@l9GKf#nOUcP$kY!+C
zU}a!*-~?TOP?Vpe>kMmja4;}B@WMo$ic%A^VKPh%3=N_#i6x1k5h4ZO%;LnH%=En6
z)Vvay3RVV&0|Ji8$*IM~3SpV~IpEV%VUlbN3<r2U^ArLS(^C~(i;D8WvjrfB%Q7$=
z5cbT;Nlj18QSi(wE-5Na2A#VK)7itoa6r_ts3@^g!70BqFQr()wIVq+H6=9#rlOaD
z;eeQ1PJUvEf=g;%eo<~>j)H$dYEfbyTuC1T!vPVflFYKqlvIVJN`<J@qI{ScYG7C7
zl_ln6rYN{%78m3fXCk|zA7OxJUTQ^Ra*0AvYH?`}-1ie07!HU-Z198{19k(lArl!G
z4)8(LfcjHuIr-%<`zJ9l91w&^1(zfyXDc{oq$a}ye=-BZ0e*;VXkJQc5wcEk28IKi
ze)$T%sk!+@l`!*E85j;o_~qv%=jWAV=9MNU<)nhctpM3QggiY36tJFoC8_DDMG7uh
z!;J_fQ$gthW(vB$r-7^pD9S9$%t=j8O~IA`{(?dc5-8}pO&J*u@VfZ;DEQ@<D7b-A
z2h9IYj0^`PK{B3snI)NtIhj@9<f!15n3;n}Idu%V2LyccQ%ZAEF^#Ba$UPt&P?VpX
zno?SXMV<rXE?8W9B<7{$q{3`ZF3x=*?wgrhlwX{mR-)jnt&IqLP?`r}(BThCXqnbX
z&j38{0qOVXg1F+&Rxu&|{ywnD4v<)IkaG+XT1C)I2OAAqug?~qSdyG!$iM($7{M6E
zFop>O!v-b>h5(Q|L4F#=qalDL1V+#Q!xAW?LZcxtLPB8l{J#+r(WBlR4FN16P|w^r
zdj2Pta2XXE4S~@R7!85Z5Eu=C;T!^N42%q%3>B<WEF9qTIuL$!)_2y{X2`L!0$mwd
zkeUKt#2a6bpP5&ZT4a-ypPvJo=gCpfh>uTBNlnht($q+TFFXXVR?xJ=vT|6#pu)hw
z!rUY^(FC!G*oXnN8XRK33xtA`YB-k{!|pyT2A!6xR&C_yYGm$c?5t~O?q;fMXy{^~
z>*!|aq-$W{Xy9yV;AZLKYF5j@09|~}02&+vEwcpSKmY&#fBFCae~=sq-)CfC*u}`e
zz&^m?a+869;WacQU^JA=fCv}xWFvHvAO^A|AO<wd55A31t=ibc!pzLl!bR7_($z`V
z(9qdU*U8Pq3=}So1_mb1hDNSN1j5CMfq?;pze2->ZGgiCUwYAkrx$GDf=DwN1qD<I
z8!-k31`s|84I9=04ja%3J)l!|K<NZVgV-Rf<P4i-$}KKSHj4>!wzP=x%uCKGO-YUM
zb@lZRill0oTw;RcBbEUU6Oi9QafD2R*dVNoEliw)LSjI}^nR}4dd>j>R4H6Q83=^`
zK?8+(fCFU-BLl-$P$|fOpg{ow!V1_k5oi+#<X&2;BomNLAiM_}B1{7uA`clD7?>Ct
z7(|e0ko!Pb8y+IayIerWxyN9f+)kC`0;-2V_yRKngE<rE0D91wS|F!DFum*OeGCi?
zS0PrzX(*RL1|B$&G8evN4|K6ERgwxQ<ACrpXlOuA7=zi*z(DWN_{hM(z|6?Npn^oh
zTw{<7+Yki_4ajsLtY$`A4M}ncfhHcAp?kHE+b$6d3=AO54b4mi$O{2MGq0oTe@im*
z^9Fpo%jo*w(e=M%E|DHx|C>kLV)D`Tzj?)(`FZilIf=!^*w@=TB^E=@|1GhCo&ReE
z={w?HPCmN+7u4RfvKn3gi!WV`uKy*jkQ!b8TZFa;$SIKuX=il(Z+>10XjSm&`rrIK
eP?roe#4)=5cXa(P+7jc@^}nFZF^WfS2mk=&D+65s

literal 80384
zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;!F$-42&?o00YCn|NsAkxG);Tu3%tb_&*AU
zObGn_|Np-N0|Nsy0|NsK0|Nsq0|PkD*%=rZI2afhI2jlixEL51xEUbv&C9^Rz{kMA
zz|X+IAi%)DAjrVLAjH7HAk4tPAi}`FAPQ9{&cMJR!N9;E$-uxM#lXNI&A`AQ!@$5G
z%fP@O$H2fK4^`*Sz`&ryz`&r)z`&rwz`&r&z`&r!z`&r+z`&rvz`&r%z`&pdRjb3m
zz@W>(z@W##z@X2-z+k|@z+lM0z+l9{z+lY4z+eJZXU4$5V9vn6V8Ot^V9CJ1V8y_|
zV9mh5V8g(`V9UV3V8_6~V9&t7;K0DZ;K;zh-~`p@!oa}b%D}+j#=yYf&cMLn!N9=a
z$-uzi#lXPe&A`Cm!@$7c%fP_k2UXw9z`zj5z`zj1z`zj9z`zi~z`zj7z`zj3z`zjB
zz`zi}z`zj6z`zj2z`zg<)f3CWz!1m4z!1;Cz>vVez>vtmz>vhiz>v(qz>vbgz>vzo
zz>vnkz>v<sz>vYfz>vwnz>vkjz>v+rz>vehz>o_yC!c|Vp@4ybp^$-rp@@Njp_qYz
zp@e~fp_GAvp^Slnp&Y6X6u(sr3=Gu_3=B043=Fjl3=DM)3=H)Q3=9omx92nDGn6nW
zFt{@0F_bVAF;s%GG0|9zffb(Lk;@8f1~eopN*q~ofDyU82xrJ=C}PNFC}t>NNMuN6
zNM%r92xcf@NMtAhhXposki`@jm>5Bs4U|4XG_o8nHmDo}CsuIW7ct~Blrt1Fq=Lf{
zmmXZ=0t`%ypu7XhE5zE*12PPhS-|Nng&~un1RM$=VNx+40}~@Ce}e1=VPf=)ffPaQ
zXJlXn=X;it)Z!8iXRDZ`{QTmQn4HX{;+TTUl8pSkn55FooRk=lJebf+DJ}rj0$fQ2
zIq}6Mi6xoInt1dfRKYZ|7L})G8*1Uv16B|NCSjU5QY#X33vyBo4e;oLsfmFxV7fKp
z^OLetlS>q|bQIuBO&zR86&EGPWaed-#HW?!C6{F8=jkOE6o8aE`TGZl#Q1nR1;+$L
zhIsh<#W;m}`nbe|xCV#BxVSony2FG)3gaQ1c#v$oi=K;*PpyKUktrzXVHiEWW>kah
zwX#adk55j_$r&t;HU^cmFgJrUJDkJ7z%c4)>Lm|j15i;S0m^C$x(eZ$dB#QxE~!bS
z=>g!J2+DOJtd(pPQ<9&b1J9wLBwLUS$)}J^Yh)0gqL-4B!ytrd7%28cP=te0b5awF
zK~)d9er9E0bl`N(&nqd)&(U=TDF@lg!NBOi3lnuJN=*b+N#OP%69Yqos7qo=Vo7B|
zs)BE3abiwpdR}g79;iYBt6*hdI3VDdoSa%*tPqx&pOXm6S1^Ow7#I%ldgdtvB&Me-
zxE2-VgX%M|HdzLS1Hzs;IjQN1ISQV6#U(|h;2a6l*~7qaK-96QD6vw(DZex?rC7nW
zA~`iRB^6YYf=%dUU^pP=mXn`YqTrI6mtT~dn4{odkXn?O2UpU^z;HkWswA^4GbL3a
zsZt>-wFp$hg3V9^yCSbFF()%c!6mb}Aip>h+5P<p13dFmD-x4S6oOKVOLO49pTNLy
zKpbL&C)60Q8;}i|$iQ%b52D7uEVU>tCm&RUgYBQhz;HkiA{AVcn4GQPoROLg5B$jt
z3<vljvY~k?s5-?N7!Gjy<tzB6=H?fH>vd2>sxmMfknqdTOU}<L$;>NFOv*_Ghg$)%
zdkA@Y3MgPb^GZ_FQ;QT_u!b8EN~VI+1<Vw5e@_Eh5m1y_mYI{9o|=L!0sIAp8YEEA
zb(=CW9N=~F@lo*0FHvv<r4CrCabjdRAPJK3%*!mvOw7rw0w+fWx5UgGM9QgS$UPw7
zo1apelZt6XJwxsR;eew2<kXbXA}sP8Aa}vy+9NS9B?p|jK%t*pocloBH#4~?zc@dw
zM8R2G8xi;*c^Fng%j8CS1~K4#4lW9GL0oZXtC$dfe;-(V1QH7la*hGD<JrO!OOi7T
z85kf8BN)RN#xP-E*uccV5CF1|A-U2mGbfdeLnJuZDTo_VgcOzL>18l7@H05Oq!y&+
zrKIMesNyLAS&)-jmYRc48GBlJie5%R0d9l%lM;(lp_MXzl^l8bd8zo7aF-M%CZ{GP
zCTHVw6fdl5FUD`0aB4+KYF=?>eqMZXPGT_u)x7zjf~6$Ch=4ktocz3WNP7gIBe}s=
zrV=oWzq}~1ARZE9_&vjul9^mWgtf($#kt^QkI!)&$@zI{nd$hH@FthVmlP#tmJsj(
zZ*gv7QAvD3NfCbc^A_i1CZ`hi0DD1YZfY(*mvMsXDMGGF163M?ZQ}y9)KUpJT@ci+
zL$oLHW(U69)RK(+6k=?KMghLe#hsZ~Qj`p;FYpBj2VvXziZj#m5=%;p2qwtnd{8^R
zg0PXi#hH2OIjJT2dH5rqBQv)kzo-PC2e=`&5r|VRSfa%nVx=XSIhiGu_}#=+P?-v9
zsTAXL6(^`<D=ALFr-l!b*C6i4r;sy0DJwI#0B>Q-Ta=oXT9lfXOrVq$f>;_4ZZQ%{
zy!@aPPFzkdO3X_qB8PG%CKZFqX}nR&Sx^b;T&Cg+6CO}GPB`d<@{_<FDxy5W1&ddF
ziG;JDG6mEw$LBb{;*z3FVhVcpg37c4{Qk_%Pbn@fAe0Muiogw-#2ox-mz6`r#VZ_2
zo@ZcWVq)ZB_yQfv1vQdDcmlXxz`(%F#AxVKnw*)EsNkHRSDc@d%1{pKx4L{4VtBCl
zPx<%7f69Y7xmJS4G&rH-h#>tS3>rfOVVGH<@h%XS`!5d~ax`P`bBPC815z`J85l;x
zU^EQqod%deT}(Fcus^6r48jpi3=E(w3mVo3Wn&Q50p(NZ)Bs2g2n#baFl>j4gVccV
zA1EKx1p%o6VVHR!c^E#yz`!sKT3mqCfbbb61_llA*epyH0|QJQ$XJjX5XNO5NEb*u
zNDT<%QwLHDG84;iC#aK!+FqmH0MF?7AM(I5Ekk;U4qA?m|AAW7u-rL1{s$_fM#uj~
z$N%#4K!bar0uwUSGdli<eN=LE{15kl?dbR)bbxzw{10s`e{}p0Y4&4u{4Wn>qGxpc
z4|DQsbo_60{BLxuir!;YqxMlh&2ca=Gx+*=`7kkXhNKpkIF}Zcr7F5uftMO278jHy
zo5ds+7lf8%=D=vsa=5La<&L10zX7R5X`od#dC92?MhXG>MJ0qa>w*S3M#ujk>*PU0
z9WXq)l#Y5Mt)t_AqwD_|7#K#^|BbHy8(sgGoH4ro4|#>-==wk0%Q3k}*Z+YQ!Sar-
z|3euC8eRW~5*(xJ|FA3x=N(=DhqR1-bp0P}yau$G2-L>~t^EVx(e;1SAIE`(^(Z|W
zwxpy1Z2Pan88R927*fFdqCxo<A68;uVgxNx0i7EFS{IB@Elf@k#DMNU4ra(_C}k)D
z@BEHuaAwGd?n2LJ$YF?Q@MOqiNMiu+!~^NUf;FJ~zd?3`Fcu{kLfRk^sQsP{0SulD
z@eD}}1z;PCp?l9W!8`In3h`q(1|~+(qC?PvM`G;<ZvqA#h5$Za0AhbCLj^-3LoV1A
zso+x$@Y@TMl_JCc;4Ph?!x_K}Fj*PEd%roIK|7qnGE>W0ZCw3>?2t(w@NQA)ek5cG
z4p4oE&?6t7UzA;3keHmRpbp+!pl+pLqEJwj588XJQLHJD1m7~Qkd~Q~TFeuiUs{x$
zssJ*km=CsV8zRRI-v13@bAcUzsfEWQH8CZ%2%;b2FeIfo1PHkjq76c#d2n?9_vrp_
z8XgZYy8nB0|96Q3`cCH2^`E2bKS$Sp20I0f?*GPIi8Q+Z8~tE{(f!|`)--gf>*)S(
zq`(;6{|!wQqx-*c&wq{X{{{~&z{YGx_kWL$Cz3LrII4DNr5DFJkaJ%JZ1VC;6hKFU
z73JsTq^8($Bty@FWMDu#=@CPj2uvCBk&z4x@Z%bZ)c`pZl33N?5lhhc;pq4u_&6}|
za$Q<&S|6fIDZ$kklt3SuAG9lNK}(}Y&wm8P8fa2!bpJOf6h_DYM#uj~$Nxsh|F9mz
zIXeC~I{t^}aMjWAztQnO%t?dM@xRgWztQs_N6%Yi7+PahqhpKIkFSJRkUPEPke23Q
zxq5;RAq}}xg@eI40J5%+fKDldPWYV`(EBDp>n0gNmk=?4Sg%+?om~*?H<$$)1dza@
z8GIoINEv>u1e`_K0O(v910w@BgL6n?QF>~LXGv-<9{=EVF-Vetn?OpSwxTSIWMtri
zgtmK8erW+z1*H5&SpbPg9dk-*0V9J5@>%|%t2`1j^HPgY45X$)!e{^UWR|2BC6?q9
zI6s}Yq_iN1h=Zkx+q*{8G%yF`oHcw0JPVO@tTZtPh7-H#jHt7~!OL|CACApU)Okll
z-uA$glUYo}9RtK(4M1G)MKrM}vm_%owInl{s1v@4Ia!>a=u_-@K&z4o2Qx7z1`%<o
z0+E+E5OHKa4{>LTvu6@IOrA5Du<!Xx^D>k3Q;5jI90iqxjyV?r#SQ2Vo>Zcuo7i1x
z#9zEX%<=Wa9YiRaoS#>gS_HmfgqXWBsJN$$Jvp@ubW%L-o)9tD7Z6@-MeMa5L|=pe
zDijE(IKHIPw6xSB!U~DKwT0MgN{G8XhlmsRh(C9Y$O~nNye)wvIkC6|{|y2hpbJ#+
zE0HWIO3W(;oec!dr18ZCsmb{D2tr~DssX=RevlK0QYnJ&68r{>z%MT&%5?tX#9ZRa
zAxMJ_nZ!DvOMEdz)NLlC_rD;Hb|k9dM_hYobpQA0{_mtxy!T&Gv92bvtwzrMFW|di
zKpoFfJQ@O{Aut*OqaiRF0;3@?VnV=+nUNVZ7GA-q&+tN|9yA0$V*Ebp(a{hX=^+4{
z|C50qzJX=-j|V1+KKF-Lmjp}~?s-2p1_p+gtdn&!6?Bsolpy!KDrBVQ<m6i`KzaGa
z)(ZK>ddV3nnME4vdV2a01Ue8zT@$V<B|jM?f~FMe03>xFMe$H!Lu&;Tu3k}To<_8~
zZkc+lrV_|yFIc6}F5!-W&I+Ygq=E`f$dn~W=^Ivdq)AQ01g03wE_fK=oW2AZGepAz
z<n%YJtZ=U({Es(*fPxS*i3>4+8*D%Tct-<B<OQn+diaBGKnienD$UGEfyPCAie73(
zDoFX@3_Or0A?XCfLWB%-))jqv8E2*e6;wD<6G#egK!X%O?W6X@GG9<?G13`6c&4C{
zb`dc$2tg*aQ<F;&gP>3sQga3xGTKVCi4f%wlGt0UN9X@W=l`&bg^teuL9_Gd{9h`T
z<S{z`hb2%(=l_D8f=1{6&^L4tv6zJ$GILyve`<Gh{tsFvkFNj6z3OFzo&Pa9{|D+E
zjpES|7!85Z5Eu=C(GVC}Apkr7yojNkA)O(cgp<c1;UvPq#J~yNM}~gN3Pc4a82}Q3
zo<9z=zl0%`0d)2{NQx9J#K6SJ!@$76%Yb>GA}(`cKoTk-f`I{MKZHj*$;H3~J`x+`
zcMvAVgglTU==t-`3^@#m48;t^3}FnJ45<v|3<?Y+p1)7B{gp`e!{&b^A*Zclnf&1d
z%b?Hv;8rgRRu7-=fKH2m2Ivu!Bp}{P)?U<kAFw|7j1CRveV`VACw;(da%X%{NAiWi
zX2CrSp2PsDfQ<Tsyb7Be0kMaqw-M78xZ@q<Ig)2=2450*!-_l&g@{KG3lR*^jx_r0
z4feDT%5K;a2}m4wc!Ff1){IWtfX9Te?^uLP*FZ?@Dn{pjune{mxu$q@|5qM3?I9l{
zGP?gOCly*Ujqd+KPaUKCzeGUyXO8awLQfcw8VZ?2EPX&KT}J1B&;xFC{s)wyh}!dC
zl$w@Wl$u9q%l7E}&*=OQazO;@YK-F15Eu=C(GVC7fzc2c4S^980<iIaoQKYHfQHM_
zNB?oE76GY-4~0X={y{^hj18czWuP(Qm#jUg<Nitc`NbvikewCrApIoH0f3GJDoV{r
z%`46<OSM)&;UY%(brjTfb(4znvs3eQ6H80-bqh+0U>iM9Cnkv8_5t!0VnA33<Z!sh
z;d1~GZ-bN~W&;Lg06;cxfZ~Us_Yt1PnG8T4hIk!fB1!u=-mvoO>4QTMu@z*Hg&D|y
zuRvE`gHJ9*1PF9g41HPvYpwtlF<4R!NEm0hf+V4KjLr#w#|h9!{CSBy_Kx@y$#{|z
zb8?arle6(JE+zF8I%3bABKjaJA~&KCdE_FghpZ8KLL=en1j6T%5pgslKjK_90&9W=
z!RaL)d|P=cfnz9%Iq8m=)3XR4aYx)4XGEU1Na`VT#EoDRc_Jj?GeG&15{pygAq%+i
zXR*=yUonqzAHDwpTn!)%pc9^w;sl)?N1$9F_9#{^Q0+jd;1EQ;nk%EA0QdOg==eW+
zgpQ8?kB<L4W1TA_@<dD04r)#<D#|Y+P&yEEn(yfOZ=l}FC>{-g(GVC7fzc2c4S~@R
z7<?fxdj8wsi<40ojfMcdLf{lrBl!GB(Akd~HNBuoI(k_>YR_m0jD`T2A+U$}2RPq?
z&TZY$MgF<1UQCQEpxI1N-j}d#9L@h^#>c3((GVDlApl$dBg24nJ|pN#NVN3@j11i1
znbOo^z2t%dP>F#u#|jk_POT^bt;5OBiwCQQspU;8%}XxH%+G`CMw=3W>PKIg4i$zU
z?*!#TCvc!Vv^x+P7&u^ut}-w%GNSo|fdNA~#u1hb$YB905m~`Ie6fTIS*EdomI`4p
zjFCYQb?p*%|6wT0fW!x3Z=ml_XJKGq06PXL>LFf*hv5JJ3=DbDlU70Jtb!sQvD^jc
zIu($z(e*!xuscIX*Z)8#uF+TPKsF%|y+4--g`?|#Qj<&Y-C8=j{wKK-X|=%U`X7w_
z&7<poV7r?!nlpG;ZV<bokI3s9;q5KFmX5CfL0>L1y8Z{LcmpjYEK1Hu1+8Aiz2=CB
z(}?+sGt=`DOG=AU2`r5u{^n%f;>^7CoYa#1JOa!9AU8qatJL5f1iX1=^!!)o+Hv%5
z7T!=J{vKLlZ(8Oe<^T<1Zs{If|AW$&A?N<b^9+nkpcB--{0DXQ5F;29K>c0@1_ov(
zMnj*{<jj;r1?T*{;{2RchH_9p(&eiV!-K_t%D*rEQy$F8wGwm&8|WN3W`q$8?9g-J
zU}hySFff3y+<$om1_lN*20xd0kTo!Mqcj6N%tpgvG%V<m1{xU{7@8Ou82<hL{~v@~
z85kJa7#JAZ85kHk7#J8j85kJ47#JA385kIP7#J9O85kJ)7#JA(85kHQFfcGogzBBl
zz`!ttfq`Kv0|Ub}1_p-d3=9l27#J94GB7aAVqjpH4OIs!J4W%~2?0h1RtC^G;Q#-O
z4BQOP&N;<yIVr(8`AJA)f}kRuu>n3N2;o8o3L$LpAR>r~(P4rPVUCXf#ut|)mSiS_
zsyk?CF*2YHO=Aq~LIV$Nz#2o@==d*aK%K6ehC$=oqx(NW$$79{<TX0}J39XB6ofK2
ziMMw<I{rI4{>#A6fPH@vMso&lQW_oqMH!9YO)iTsDN4*NAuwRbTb!F%R1#lMLSXkb
zu@}jWj{lC1|6<S1qvOA$<G%!pqY-xh*Xa1~=r|)i#u-QL7@X<Mg&~z8iJ_Dsogtke
zm7xeUh({6@BIEv>7LW}xAcBFxg(06InW2;+mm!rQkD-L27$QtG3A%p>c{G(6jgvr%
zp!e^9n3Q5t?Wfc}bp4dr&&9yZ06xeJZYan!I0rO}Uky6F#L6lqKOS_}i3aqj9tABO
z1vpbv$Jr_de2!mCPG(Xubirs$aZz#%NOL@F`7dZaFi5GBzkhH@jE|>Na7;jCh=;#l
zj8mwmk4sF5Yj8-6i>p(pJ4_g)Fdo8*2g$~}=(+g#)GFv1nIb!K)X}sHX=8&S7}7)3
z(V*#boU5uqlLsKIm24GLlAoW0lFtf~!DpC3v!0Pbe2QL5P7VW(69#dvNS0+_U|?ln
zbl?On)h)`;(RBtzKFC%M21W;7n5a`xYGO7_hKYfpLDVI&BoTD3l7eq$abiwpdR}g7
zUI|PED+9v;0mtOz)Z$`=u+03NM9^LUm?Rqm!vS8;JcWS7^i%~`(CI5M8CeE~1Hzs;
zIjQN1ISQV6#U(|h;9UeT`5p#_1EP*aMTwOPPWh#IDa8t|70IcoDXA$i6}=1$2gKZR
z@)JuGTvGG$i*gfl6#NTPixTtTO8OWW4v0XNWR_*7q$(s;Dnz9g<-^QS1G^%xEHNiD
zMZqPrxFEkc6WRU!2m?IxQY#XZOB8}qi%WChzMsIra6lYlgD2D&up5vKnaIF!fDfX^
zzbv&VEhoPmX8$Axh692Sso;{t<ZK0J(0VSI>|_Rp1N;!#(7Y5>o#G4(2RQxm6?{{3
z^NYZ@zJVfAm4V@agkOGMa(-S(W?pGxQcfy3+zOE0L&(!pKmqHSSCX2ZTBP8DHQb0$
zG8L3AV5Xq^dm6}!fTGN@%$(Hp)D&z9;4diDAc2Ce+mw;v0I!RWkAh!*iGmv_b-+T*
ziIL%eBuK_HFS8^wF(<PMoE#P05;JoUDW{Gh_ke(JeoARhDy9+j47mq{1B&vKQ&UQd
zu*h?O+y#qkkHox`oK%?Y$;G)3#C<c9i}H)}(@GSawY3p}4~iWaRzl0<MtTO|`V?|b
zt}cix?raqk;_vSRt3*L!!9mV3p!r<3@Whhj3_}J62*U`*ForQq7#KD%F)##x>|;O~
zxEo#nJG%ZCl<f5~@T?e3&d*EBOvk5Wbo>{7OBUK@H@ve5qv!vjFX$dU|8MmCKkNhg
zqw9ZBDsFPt|8j`9c!h)7CZl*X1V%$(Gz3ONU^E0qLtw;&!07pZBPOaxJvtf!7$LyM
z02%;9KKE;MDvfqiX+v_-a)?f)At&`AlBSIfM(6)V=l{@WvPS3sM(6+X^FWh(p!GDP
z^MCkmPvR~qN=#0L+}4MC_6lh`D&D!6(fuE|cE)gw&i`?UfTm?e@Bd28Lz#paJ^u$j
z?aK+e*|4NI1>Y<=UoLow3GDhq++`MLeo|IuZb1${!+48Q(^894^O95XpQto?{txbO
d9^L-|?l{5D>=`}(XK=3DAKgze8ZXpH0|0G)Qbqs(


From 2e145ea9163340ef7f4ab94cf7bb3ddbc74d511d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Mon, 5 Mar 2001 23:41:37 +0000
Subject: [PATCH 032/369] Use file name "libboost_python.a"; rename makefiles.

[SVN r9449]
---
 build/{Makefile.linux_gcc => linux_gcc.mak} | 10 +++++-----
 build/{Makefile.mingw32 => mingw32.mak}     | 10 +++++-----
 build/{Makefile.tru64_cxx => tru64_cxx.mak} | 16 ++++++++--------
 3 files changed, 18 insertions(+), 18 deletions(-)
 rename build/{Makefile.linux_gcc => linux_gcc.mak} (96%)
 rename build/{Makefile.mingw32 => mingw32.mak} (96%)
 rename build/{Makefile.tru64_cxx => tru64_cxx.mak} (93%)

diff --git a/build/Makefile.linux_gcc b/build/linux_gcc.mak
similarity index 96%
rename from build/Makefile.linux_gcc
rename to build/linux_gcc.mak
index 7021e221..a07bb5da 100644
--- a/build/Makefile.linux_gcc
+++ b/build/linux_gcc.mak
@@ -79,7 +79,7 @@ DEPOBJ= $(OBJ) comprehensive.o abstract.o \
 
 .SUFFIXES: .o .cpp
 
-all: libbpl.a boost_python_test.so abstract.so \
+all: libboost_python.a boost_python_test.so abstract.so \
      getting_started1.so getting_started2.so getting_started3.so \
      getting_started4.so getting_started5.so
 
@@ -107,9 +107,9 @@ unlink:
 	    fi; \
 	  done
 
-libbpl.a: $(OBJ)
-	rm -f libbpl.a
-	ar r libbpl.a $(OBJ)
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
+	ar r libboost_python.a $(OBJ)
 
 boost_python_test.so: $(OBJ) comprehensive.o
 	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
@@ -145,7 +145,7 @@ test:
 	$(PYEXE) test_getting_started5.py
 
 clean:
-	rm -f $(OBJ) libbpl.a libbpl.a.input
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
 	rm -f comprehensive.o boost_python_test.so
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
diff --git a/build/Makefile.mingw32 b/build/mingw32.mak
similarity index 96%
rename from build/Makefile.mingw32
rename to build/mingw32.mak
index 7c5f2c52..014af132 100644
--- a/build/Makefile.mingw32
+++ b/build/mingw32.mak
@@ -96,7 +96,7 @@ OBJ = classes.o conversions.o extension_class.o functions.o \
 
 .SUFFIXES: .o .cpp
 
-all: libbpl.a boost_python_test.pyd abstract.pyd \
+all: libboost_python.a boost_python_test.pyd abstract.pyd \
      getting_started1.pyd getting_started2.pyd getting_started3.pyd \
      getting_started4.pyd getting_started5.pyd
 
@@ -136,9 +136,9 @@ rmdefs:
             rm $$def.def; \
 	  done
 
-libbpl.a: $(OBJ)
-	del libbpl.a
-	ar r libbpl.a $(OBJ)
+libboost_python.a: $(OBJ)
+	del libboost_python.a
+	ar r libboost_python.a $(OBJ)
 
 DLLWRAPOPTS= -s --driver-name g++ -s
              --entry _DllMainCRTStartup@12 --target=i386-mingw32
@@ -198,7 +198,7 @@ test:
 	$(PYEXE) test_getting_started5.py
 
 clean:
-	rm -f $(OBJ) libbpl.a libbpl.a.input
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
 	rm -f comprehensive.o boost_python_test.pyd
 	rm -f abstract.o abstract.pyd
 	rm -f getting_started1.o getting_started1.pyd
diff --git a/build/Makefile.tru64_cxx b/build/tru64_cxx.mak
similarity index 93%
rename from build/Makefile.tru64_cxx
rename to build/tru64_cxx.mak
index 2b417944..3fd584b7 100644
--- a/build/Makefile.tru64_cxx
+++ b/build/tru64_cxx.mak
@@ -79,7 +79,7 @@ DEPOBJ= $(OBJ) comprehensive.o abstract.o \
 
 .SUFFIXES: .o .cpp
 
-all: libbpl.a boost_python_test.so abstract.so \
+all: libboost_python.a boost_python_test.so abstract.so \
      getting_started1.so getting_started2.so getting_started3.so \
      getting_started4.so getting_started5.so
 
@@ -107,13 +107,13 @@ unlink:
 	    fi; \
 	  done
 
-libbpl.a: $(OBJ)
-	rm -f libbpl.a
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
 	cd cxx_repository; \
-          ls -1 > ../libbpl.a.input; \
-          ar r ../libbpl.a -input ../libbpl.a.input
-	rm -f libbpl.a.input
-	ar r libbpl.a $(OBJ)
+          ls -1 > ../libboost_python.a.input; \
+          ar r ../libboost_python.a -input ../libboost_python.a.input
+	rm -f libboost_python.a.input
+	ar r libboost_python.a $(OBJ)
 
 boost_python_test.so: $(OBJ) comprehensive.o
 	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
@@ -149,7 +149,7 @@ test:
 	$(PYEXE) test_getting_started5.py
 
 clean:
-	rm -f $(OBJ) libbpl.a libbpl.a.input
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
 	rm -f comprehensive.o boost_python_test.so
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so

From 149cc499ede69475159d5a120c3213597c9d410a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Mon, 5 Mar 2001 23:46:43 +0000
Subject: [PATCH 033/369] Remove spurious ";"

[SVN r9450]
---
 include/boost/python/detail/extension_class.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 987d753e..4afffcae 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -152,7 +152,7 @@ template <class Ptr>
 bool is_null(const Ptr& x)
 {
     return is_null_helper<(is_pointer<Ptr>::value)>::test(x);
-};
+}
 
 }}} // namespace boost::python::detail
 

From fdff5e33b3745a4768caf0145d57d3cce7f1a668 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 6 Mar 2001 00:02:01 +0000
Subject: [PATCH 034/369] temp file for branching

[SVN r9451]
---
 src/x_class_builder.cpp | 118 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 src/x_class_builder.cpp

diff --git a/src/x_class_builder.cpp b/src/x_class_builder.cpp
new file mode 100644
index 00000000..cf81a3f7
--- /dev/null
+++ b/src/x_class_builder.cpp
@@ -0,0 +1,118 @@
+# include <boost/python/x_class_builder.hpp>
+namespace python = boost::python;
+# include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
+# include <string.h> // MSVC6.0SP4 does not know std::strcmp
+
+namespace {
+
+  PyObject *get_module_dict(const char *module_name)
+  {
+    python::ref module_obj(PyImport_ImportModule((char*) module_name));
+    PyObject *module_dict = PyModule_GetDict(module_obj.get());
+    if (module_dict == 0) throw python::import_error();
+    return module_dict;
+  }
+}
+
+namespace boost { namespace python { namespace detail {
+
+#ifndef SPECIAL_PYCVTSOBJECT
+
+void *import_converters(const std::string& module_name,
+                        const std::string& klass_name,
+                        const std::string& attribute_name)
+{
+  static std::string err;
+  PyObject *module_dict
+    = get_module_dict(const_cast<char*>(module_name.c_str()));
+  PyObject *klass
+    = PyDict_GetItemString(module_dict, const_cast<char*>(klass_name.c_str()));
+  if (klass == 0) {
+    err = std::string("module ") + module_name + " has no attribute "
+          + klass_name;
+    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+    throw python::import_error();
+  }
+  python::ref c_obj(PyObject_GetAttrString(klass,
+    const_cast<char*>(attribute_name.c_str())), ref::null_ok);
+  if (c_obj.get() == 0) {
+    err = std::string("object ") + module_name + "." + klass_name
+          + " has no attribute " + attribute_name;
+    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+    throw python::import_error();
+  }
+  if (! PyCObject_Check(c_obj.get())) {
+    err = std::string("object ") + module_name + "." + klass_name + "."
+          + attribute_name + " is not a PyCObject";
+    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+    throw python::import_error();
+  }
+  return PyCObject_AsVoidPtr(c_obj.get());
+}
+
+#else
+
+PyObject *new_import_converters(const std::string& module_name,
+                                const std::string& klass_name,
+                                const std::string& attribute_name)
+{
+  static std::string err;
+  PyObject *module_dict
+    = get_module_dict(const_cast<char*>(module_name.c_str()));
+  PyObject *klass
+    = PyDict_GetItemString(module_dict, const_cast<char*>(klass_name.c_str()));
+  if (klass == 0) {
+    err = std::string("module ") + module_name + " has no attribute "
+          + klass_name;
+    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+    throw python::import_error();
+  }
+  python::ref cvts_obj(PyObject_GetAttrString(klass,
+    const_cast<char*>(attribute_name.c_str())), ref::null_ok);
+  if (cvts_obj.get() == 0) {
+    err = std::string("object ") + module_name + "." + klass_name
+          + " has no attribute " + attribute_name;
+    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+    throw python::import_error();
+  }
+  // Weak point: direct access to ob_type->tp_name
+  if (strcmp(cvts_obj->ob_type->tp_name, "PyCvtsObject") != 0) {
+    err = std::string("object ") + module_name + "." + klass_name + "."
+          + attribute_name + " is not a PyCvtsObject";
+    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+    throw python::import_error();
+  }
+  return cvts_obj.release();
+}
+
+#endif // SPECIAL_PYCVTSOBJECT
+
+void check_export_converters_api(const int importing_major,
+                                 const int importing_minor,
+                                 const int imported_major,
+                                 const int imported_minor)
+{
+  if (importing_major != imported_major) {
+    // Python uses fprintf(stderr, ...) for API warnings.
+    fprintf(stderr,
+      "Fatal: EXPORT_CONVERTERS_API mismatch:"
+      " Importing module = %d.%d"
+      " Imported module = %d.%d\n",
+      importing_major, importing_minor,
+      imported_major, imported_minor);
+    PyErr_SetString(PyExc_RuntimeError,
+      "Fatal: EXPORT_CONVERTERS_API mismatch");
+    throw import_error();
+  }
+  if (importing_minor != imported_minor) {
+    // Python uses fprintf(stderr, ...) for API warnings.
+    fprintf(stderr,
+      "Warning: EXPORT_CONVERTERS_API mismatch:"
+      " Importing module = %d.%d"
+      " Imported module = %d.%d\n",
+      importing_major, importing_minor,
+      imported_major, imported_minor);
+  }
+}
+
+}}} // namespace boost::python::detail

From f49141f71ede423a1ae6f52f85f3a5b054c869e9 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 6 Mar 2001 00:04:28 +0000
Subject: [PATCH 035/369] temp file removed after branching

[SVN r9452]
---
 src/x_class_builder.cpp | 118 ----------------------------------------
 1 file changed, 118 deletions(-)
 delete mode 100644 src/x_class_builder.cpp

diff --git a/src/x_class_builder.cpp b/src/x_class_builder.cpp
deleted file mode 100644
index cf81a3f7..00000000
--- a/src/x_class_builder.cpp
+++ /dev/null
@@ -1,118 +0,0 @@
-# include <boost/python/x_class_builder.hpp>
-namespace python = boost::python;
-# include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
-# include <string.h> // MSVC6.0SP4 does not know std::strcmp
-
-namespace {
-
-  PyObject *get_module_dict(const char *module_name)
-  {
-    python::ref module_obj(PyImport_ImportModule((char*) module_name));
-    PyObject *module_dict = PyModule_GetDict(module_obj.get());
-    if (module_dict == 0) throw python::import_error();
-    return module_dict;
-  }
-}
-
-namespace boost { namespace python { namespace detail {
-
-#ifndef SPECIAL_PYCVTSOBJECT
-
-void *import_converters(const std::string& module_name,
-                        const std::string& klass_name,
-                        const std::string& attribute_name)
-{
-  static std::string err;
-  PyObject *module_dict
-    = get_module_dict(const_cast<char*>(module_name.c_str()));
-  PyObject *klass
-    = PyDict_GetItemString(module_dict, const_cast<char*>(klass_name.c_str()));
-  if (klass == 0) {
-    err = std::string("module ") + module_name + " has no attribute "
-          + klass_name;
-    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-    throw python::import_error();
-  }
-  python::ref c_obj(PyObject_GetAttrString(klass,
-    const_cast<char*>(attribute_name.c_str())), ref::null_ok);
-  if (c_obj.get() == 0) {
-    err = std::string("object ") + module_name + "." + klass_name
-          + " has no attribute " + attribute_name;
-    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-    throw python::import_error();
-  }
-  if (! PyCObject_Check(c_obj.get())) {
-    err = std::string("object ") + module_name + "." + klass_name + "."
-          + attribute_name + " is not a PyCObject";
-    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-    throw python::import_error();
-  }
-  return PyCObject_AsVoidPtr(c_obj.get());
-}
-
-#else
-
-PyObject *new_import_converters(const std::string& module_name,
-                                const std::string& klass_name,
-                                const std::string& attribute_name)
-{
-  static std::string err;
-  PyObject *module_dict
-    = get_module_dict(const_cast<char*>(module_name.c_str()));
-  PyObject *klass
-    = PyDict_GetItemString(module_dict, const_cast<char*>(klass_name.c_str()));
-  if (klass == 0) {
-    err = std::string("module ") + module_name + " has no attribute "
-          + klass_name;
-    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-    throw python::import_error();
-  }
-  python::ref cvts_obj(PyObject_GetAttrString(klass,
-    const_cast<char*>(attribute_name.c_str())), ref::null_ok);
-  if (cvts_obj.get() == 0) {
-    err = std::string("object ") + module_name + "." + klass_name
-          + " has no attribute " + attribute_name;
-    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-    throw python::import_error();
-  }
-  // Weak point: direct access to ob_type->tp_name
-  if (strcmp(cvts_obj->ob_type->tp_name, "PyCvtsObject") != 0) {
-    err = std::string("object ") + module_name + "." + klass_name + "."
-          + attribute_name + " is not a PyCvtsObject";
-    PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-    throw python::import_error();
-  }
-  return cvts_obj.release();
-}
-
-#endif // SPECIAL_PYCVTSOBJECT
-
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor)
-{
-  if (importing_major != imported_major) {
-    // Python uses fprintf(stderr, ...) for API warnings.
-    fprintf(stderr,
-      "Fatal: EXPORT_CONVERTERS_API mismatch:"
-      " Importing module = %d.%d"
-      " Imported module = %d.%d\n",
-      importing_major, importing_minor,
-      imported_major, imported_minor);
-    PyErr_SetString(PyExc_RuntimeError,
-      "Fatal: EXPORT_CONVERTERS_API mismatch");
-    throw import_error();
-  }
-  if (importing_minor != imported_minor) {
-    // Python uses fprintf(stderr, ...) for API warnings.
-    fprintf(stderr,
-      "Warning: EXPORT_CONVERTERS_API mismatch:"
-      " Importing module = %d.%d"
-      " Imported module = %d.%d\n",
-      importing_major, importing_minor,
-      imported_major, imported_minor);
-  }
-}
-
-}}} // namespace boost::python::detail

From 23725680c9b8ab8068e26b46512936d260fb95df Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 6 Mar 2001 00:05:41 +0000
Subject: [PATCH 036/369] temp file before branching

[SVN r9453]
---
 include/boost/python/x_class_builder.hpp | 361 +++++++++++++++++++++++
 1 file changed, 361 insertions(+)
 create mode 100644 include/boost/python/x_class_builder.hpp

diff --git a/include/boost/python/x_class_builder.hpp b/include/boost/python/x_class_builder.hpp
new file mode 100644
index 00000000..4b3da600
--- /dev/null
+++ b/include/boost/python/x_class_builder.hpp
@@ -0,0 +1,361 @@
+#ifndef X_CLASS_BUILDER_HPP
+# define X_CLASS_BUILDER_HPP
+
+# include <boost/python/class_builder.hpp>
+
+//QUESTIONMARK
+//  Do we really need the special PyCvtsObject?
+//  Is there a better way of creating the special PyCvtsObject?
+//  My solution adds a lot of code including several reinterpret_cast.
+//#define SPECIAL_PYCVTSOBJECT
+
+namespace boost { namespace python {
+    struct import_error : error_already_set {};
+    struct export_error : error_already_set {};
+}}
+
+namespace boost { namespace python { namespace detail {
+
+// Concept: throw exception if api_major is changed
+//          show warning on stderr if api_minor is changed
+const int EXPORT_CONVERTERS_API_MAJOR = 1;
+const int EXPORT_CONVERTERS_API_MINOR = 1;
+const std::string converters_attribute_name = "__converters__";
+#ifndef SPECIAL_PYCVTSOBJECT
+void *import_converters(const std::string& module_name,
+                        const std::string& klass_name,
+                        const std::string& attribute_name);
+#else
+PyObject *new_import_converters(const std::string& module_name,
+                                const std::string& klass_name,
+                                const std::string& attribute_name);
+#endif
+void check_export_converters_api(const int importing_major,
+                                 const int importing_minor,
+                                 const int imported_major,
+                                 const int imported_minor);
+
+}}}
+
+// forward declaration
+namespace boost { namespace python { namespace detail {
+template <class T> class import_extension_class;
+}}}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+//QUESTIONMARK
+//  This class is a look-alike of class python_extension_class_converters.
+//  Is there a way to ensure that the siblings stay in sync?
+template <class T>
+class python_import_extension_class_converters
+{
+ public:
+
+    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>)
+    {
+        return python_import_extension_class_converters();
+    }
+
+    PyObject* to_python(const T& x) const
+    {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend T* from_python(PyObject* obj, boost::python::type<T*>)
+    {
+        return boost::python::detail::import_extension_class<T>::get_converters()->Tptr_from_python(obj);
+    }
+
+    // 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 boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_from_python(p);
+    }
+
+    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_from_python(p);
+    }
+
+    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_from_python(p);
+    }
+
+    friend PyObject* to_python(std::auto_ptr<T> x) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_from_python(p);
+    }
+
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_from_python(p);
+    }
+
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_from_python(p);
+    }
+
+    friend PyObject* to_python(boost::shared_ptr<T> x) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+};
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+namespace boost { namespace python {
+
+BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
+
+// A pointer to this class is exported/imported via the Python API.
+// All functions are virtual. This is, what we really export/import
+// is essentially just a pointer to a vtbl.
+template <class T>
+struct export_converters_base
+{
+  virtual const int get_api_major() const {
+    return detail::EXPORT_CONVERTERS_API_MAJOR; }
+  virtual const int get_api_minor() const {
+    return detail::EXPORT_CONVERTERS_API_MINOR; }
+  virtual PyObject *to_python(const T& x) = 0;
+  virtual PyObject *to_python(std::auto_ptr<T> x) = 0;
+  virtual PyObject *to_python(boost::shared_ptr<T> x) = 0;
+  virtual T* Tptr_from_python(PyObject* obj) = 0;
+  virtual std::auto_ptr<T>& auto_ptr_from_python(PyObject *obj) = 0;
+  virtual boost::shared_ptr<T>& shared_ptr_from_python(PyObject *obj) = 0;
+};
+
+// Converters to be used if T is not copyable.
+template <class T>
+struct export_ptr_converters : export_converters_base<T>
+{
+  virtual PyObject *to_python(const T& x) {
+    PyErr_SetString(PyExc_RuntimeError,
+      "to_python(const T&) converter not exported");
+    throw import_error();
+  }
+  virtual PyObject *to_python(std::auto_ptr<T> x) {
+    return BOOST_PYTHON_CONVERSION::to_python(x);
+  }
+  virtual PyObject *to_python(boost::shared_ptr<T> x) {
+    return BOOST_PYTHON_CONVERSION::to_python(x);
+  }
+  virtual T* Tptr_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T*>());
+  }
+  virtual std::auto_ptr<T>& auto_ptr_from_python(PyObject *obj) {
+    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::ptr_from_python(obj, boost::python::type<std::auto_ptr<T> >());
+  }
+  virtual boost::shared_ptr<T>& shared_ptr_from_python(PyObject *obj) {
+    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::ptr_from_python(obj, boost::python::type<boost::shared_ptr<T> >());
+  }
+};
+
+// The addditional to_python() converter that can be used if T is copyable.
+template <class T>
+struct export_converters : export_ptr_converters<T>
+{
+  virtual PyObject *to_python(const T& x) {
+    BOOST_PYTHON_CONVERSION::python_extension_class_converters<T> cv;
+    return cv.to_python(x);
+  }
+};
+
+namespace detail {
+
+//QUESTIONMARK
+//  A stripped-down, modified version of class extension_class.
+//  Would it make sense to establish a formal relationship
+//  between the two classes?
+template <class T>
+class import_extension_class
+    : public python_import_extension_class_converters<T>
+{
+ public:
+    inline import_extension_class(const char *module, const char* klass) {
+      m_module = module;
+      m_klass = klass;
+    }
+
+    static boost::python::export_converters_base<T>* get_converters();
+
+  private:
+    static std::string m_module;
+    static std::string m_klass;
+    static boost::python::export_converters_base<T>* imported_converters;
+};
+
+template <class T> std::string import_extension_class<T>::m_module;
+template <class T> std::string import_extension_class<T>::m_klass;
+template <class T>
+boost::python::export_converters_base<T>*
+import_extension_class<T>::imported_converters = 0;
+
+#ifdef SPECIAL_PYCVTSOBJECT
+
+// A special PyObject for passing pointers to export_converters_base<T>
+template <class T>
+struct PyCvtsObject {
+    PyObject_HEAD
+    export_converters_base<T>* cvts;
+};
+
+template <class T>
+void DEL_PyCvtsObject(PyCvtsObject<T>* self) { PyMem_DEL(self); }
+
+template <class T>
+PyObject *create_PyCvtsObject(export_converters_base<T>* cvts)
+{
+    static char PyCvtsObject_Type__doc__[] =
+        "Boost Python Library (BPL) converters objects to be exported from\n"
+        "one extension module to another.";
+
+    static PyTypeObject PyCvtsObject_Type = {
+        PyObject_HEAD_INIT(&PyType_Type)
+        0,                              /*ob_size*/
+        "PyCvtsObject",                 /*tp_name*/
+        sizeof(PyCvtsObject<T>),        /*tp_basicsize*/
+        0,                              /*tp_itemsize*/
+        /* methods */
+        (destructor)(static_cast<void (*)(PyCvtsObject<T>*)>
+           (DEL_PyCvtsObject)),         /*tp_dealloc*/
+        (printfunc)0,                   /*tp_print*/
+        (getattrfunc)0,                 /*tp_getattr*/
+        (setattrfunc)0,                 /*tp_setattr*/
+        (cmpfunc)0,                     /*tp_compare*/
+        (reprfunc)0,                    /*tp_repr*/
+        0,                              /*tp_as_number*/
+        0,                              /*tp_as_sequence*/
+        0,                              /*tp_as_mapping*/
+        (hashfunc)0,                    /*tp_hash*/
+        (ternaryfunc)0,                 /*tp_call*/
+        (reprfunc)0,                    /*tp_str*/
+
+        /* Space for future expansion */
+        0L,0L,0L,0L,
+        PyCvtsObject_Type__doc__        /* Documentation string */
+    };
+
+    PyCvtsObject<T>* self = PyObject_NEW(PyCvtsObject<T>, &PyCvtsObject_Type);
+    if (self == 0) throw export_error();
+    self->cvts = cvts;
+    return reinterpret_cast<PyObject*>(self);
+}
+
+#endif // SPECIAL_PYCVTSOBJECT
+
+template <class T>
+boost::python::export_converters_base<T>*
+import_extension_class<T>::get_converters() {
+  if (imported_converters == 0) {
+#ifndef SPECIAL_PYCVTSOBJECT
+    void *cobject
+      = import_converters(m_module, m_klass, converters_attribute_name);
+    imported_converters
+      = static_cast<boost::python::export_converters_base<T>*>(cobject);
+#else
+    ref cvts_obj(
+      new_import_converters(m_module, m_klass, converters_attribute_name));
+    PyCvtsObject<T>* cvts = reinterpret_cast<PyCvtsObject<T>*>(cvts_obj.get());
+    imported_converters = cvts->cvts;
+#endif
+    check_export_converters_api(
+      EXPORT_CONVERTERS_API_MAJOR,
+      EXPORT_CONVERTERS_API_MINOR,
+      imported_converters->get_api_major(),
+      imported_converters->get_api_minor());
+  }
+  return imported_converters;
+}
+
+}}} // namespace boost::python::detail
+
+namespace boost { namespace python {
+
+//QUESTIONMARK
+//  A stripped-down, modified version of class class_builder.
+//  Would it make sense to establish a formal relationship
+//  between the two classes?
+template <class T>
+class import_class_builder
+    : python_import_extension_class_converters<T>
+{
+ public:
+    import_class_builder(const char *module, const char* klass)
+        : m_class(new detail::import_extension_class<T>(module, klass))
+    { }
+ private:
+
+    //QUESTIONMARK
+    //reference<detail::import_extension_class<T> > m_class;
+    boost::shared_ptr<detail::import_extension_class<T> > m_class;
+};
+
+}} // namespace boost::python
+
+namespace boost { namespace python {
+
+// A class_builder that exports the converter functions.
+template <class T, class U = detail::held_instance<T>,
+          class C = export_converters<T> >
+class x_class_builder
+    : public class_builder<T, U>
+{
+  private:
+    static C export_cvts;
+
+  public:
+    x_class_builder(module_builder& module, const char* name)
+        : class_builder<T, U>(module, name) {
+#ifndef SPECIAL_PYCVTSOBJECT
+    add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      const_cast<char*>(detail::converters_attribute_name.c_str()));
+#else
+    add(ref(detail::create_PyCvtsObject(&export_cvts)),
+      const_cast<char*>(detail::converters_attribute_name.c_str()));
+#endif
+  }
+};
+
+template <class T, class U, class C>
+C x_class_builder<T, U, C>::export_cvts;
+
+//QUESTIONMARK
+//  Is there a better way of making it easy for the end-user
+//  to choose between x_class_builder and xptr_class_builder?
+template <class T, class U = detail::held_instance<T>,
+          class C = export_ptr_converters<T> >
+class xptr_class_builder : public x_class_builder<T, U, C>
+{
+  public:
+    xptr_class_builder(module_builder& module, const char* name)
+        : x_class_builder<T, U, C >(module, name) { }
+};
+
+}} // namespace boost::python
+
+#endif // X_CLASS_BUILDER_HPP

From 5b13e75fa585d73753627a2f4df1cb2c8fa2128e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 6 Mar 2001 00:06:55 +0000
Subject: [PATCH 037/369] temp file removed after branching.

[SVN r9454]
---
 include/boost/python/x_class_builder.hpp | 361 -----------------------
 1 file changed, 361 deletions(-)
 delete mode 100644 include/boost/python/x_class_builder.hpp

diff --git a/include/boost/python/x_class_builder.hpp b/include/boost/python/x_class_builder.hpp
deleted file mode 100644
index 4b3da600..00000000
--- a/include/boost/python/x_class_builder.hpp
+++ /dev/null
@@ -1,361 +0,0 @@
-#ifndef X_CLASS_BUILDER_HPP
-# define X_CLASS_BUILDER_HPP
-
-# include <boost/python/class_builder.hpp>
-
-//QUESTIONMARK
-//  Do we really need the special PyCvtsObject?
-//  Is there a better way of creating the special PyCvtsObject?
-//  My solution adds a lot of code including several reinterpret_cast.
-//#define SPECIAL_PYCVTSOBJECT
-
-namespace boost { namespace python {
-    struct import_error : error_already_set {};
-    struct export_error : error_already_set {};
-}}
-
-namespace boost { namespace python { namespace detail {
-
-// Concept: throw exception if api_major is changed
-//          show warning on stderr if api_minor is changed
-const int EXPORT_CONVERTERS_API_MAJOR = 1;
-const int EXPORT_CONVERTERS_API_MINOR = 1;
-const std::string converters_attribute_name = "__converters__";
-#ifndef SPECIAL_PYCVTSOBJECT
-void *import_converters(const std::string& module_name,
-                        const std::string& klass_name,
-                        const std::string& attribute_name);
-#else
-PyObject *new_import_converters(const std::string& module_name,
-                                const std::string& klass_name,
-                                const std::string& attribute_name);
-#endif
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor);
-
-}}}
-
-// forward declaration
-namespace boost { namespace python { namespace detail {
-template <class T> class import_extension_class;
-}}}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-//QUESTIONMARK
-//  This class is a look-alike of class python_extension_class_converters.
-//  Is there a way to ensure that the siblings stay in sync?
-template <class T>
-class python_import_extension_class_converters
-{
- public:
-
-    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>)
-    {
-        return python_import_extension_class_converters();
-    }
-
-    PyObject* to_python(const T& x) const
-    {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-
-    friend T* from_python(PyObject* obj, boost::python::type<T*>)
-    {
-        return boost::python::detail::import_extension_class<T>::get_converters()->Tptr_from_python(obj);
-    }
-
-    // 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 boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_from_python(p);
-    }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_from_python(p);
-    }
-
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_from_python(p);
-    }
-
-    friend PyObject* to_python(std::auto_ptr<T> x) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_from_python(p);
-    }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_from_python(p);
-    }
-
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_from_python(p);
-    }
-
-    friend PyObject* to_python(boost::shared_ptr<T> x) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-};
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
-
-// A pointer to this class is exported/imported via the Python API.
-// All functions are virtual. This is, what we really export/import
-// is essentially just a pointer to a vtbl.
-template <class T>
-struct export_converters_base
-{
-  virtual const int get_api_major() const {
-    return detail::EXPORT_CONVERTERS_API_MAJOR; }
-  virtual const int get_api_minor() const {
-    return detail::EXPORT_CONVERTERS_API_MINOR; }
-  virtual PyObject *to_python(const T& x) = 0;
-  virtual PyObject *to_python(std::auto_ptr<T> x) = 0;
-  virtual PyObject *to_python(boost::shared_ptr<T> x) = 0;
-  virtual T* Tptr_from_python(PyObject* obj) = 0;
-  virtual std::auto_ptr<T>& auto_ptr_from_python(PyObject *obj) = 0;
-  virtual boost::shared_ptr<T>& shared_ptr_from_python(PyObject *obj) = 0;
-};
-
-// Converters to be used if T is not copyable.
-template <class T>
-struct export_ptr_converters : export_converters_base<T>
-{
-  virtual PyObject *to_python(const T& x) {
-    PyErr_SetString(PyExc_RuntimeError,
-      "to_python(const T&) converter not exported");
-    throw import_error();
-  }
-  virtual PyObject *to_python(std::auto_ptr<T> x) {
-    return BOOST_PYTHON_CONVERSION::to_python(x);
-  }
-  virtual PyObject *to_python(boost::shared_ptr<T> x) {
-    return BOOST_PYTHON_CONVERSION::to_python(x);
-  }
-  virtual T* Tptr_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T*>());
-  }
-  virtual std::auto_ptr<T>& auto_ptr_from_python(PyObject *obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::ptr_from_python(obj, boost::python::type<std::auto_ptr<T> >());
-  }
-  virtual boost::shared_ptr<T>& shared_ptr_from_python(PyObject *obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::ptr_from_python(obj, boost::python::type<boost::shared_ptr<T> >());
-  }
-};
-
-// The addditional to_python() converter that can be used if T is copyable.
-template <class T>
-struct export_converters : export_ptr_converters<T>
-{
-  virtual PyObject *to_python(const T& x) {
-    BOOST_PYTHON_CONVERSION::python_extension_class_converters<T> cv;
-    return cv.to_python(x);
-  }
-};
-
-namespace detail {
-
-//QUESTIONMARK
-//  A stripped-down, modified version of class extension_class.
-//  Would it make sense to establish a formal relationship
-//  between the two classes?
-template <class T>
-class import_extension_class
-    : public python_import_extension_class_converters<T>
-{
- public:
-    inline import_extension_class(const char *module, const char* klass) {
-      m_module = module;
-      m_klass = klass;
-    }
-
-    static boost::python::export_converters_base<T>* get_converters();
-
-  private:
-    static std::string m_module;
-    static std::string m_klass;
-    static boost::python::export_converters_base<T>* imported_converters;
-};
-
-template <class T> std::string import_extension_class<T>::m_module;
-template <class T> std::string import_extension_class<T>::m_klass;
-template <class T>
-boost::python::export_converters_base<T>*
-import_extension_class<T>::imported_converters = 0;
-
-#ifdef SPECIAL_PYCVTSOBJECT
-
-// A special PyObject for passing pointers to export_converters_base<T>
-template <class T>
-struct PyCvtsObject {
-    PyObject_HEAD
-    export_converters_base<T>* cvts;
-};
-
-template <class T>
-void DEL_PyCvtsObject(PyCvtsObject<T>* self) { PyMem_DEL(self); }
-
-template <class T>
-PyObject *create_PyCvtsObject(export_converters_base<T>* cvts)
-{
-    static char PyCvtsObject_Type__doc__[] =
-        "Boost Python Library (BPL) converters objects to be exported from\n"
-        "one extension module to another.";
-
-    static PyTypeObject PyCvtsObject_Type = {
-        PyObject_HEAD_INIT(&PyType_Type)
-        0,                              /*ob_size*/
-        "PyCvtsObject",                 /*tp_name*/
-        sizeof(PyCvtsObject<T>),        /*tp_basicsize*/
-        0,                              /*tp_itemsize*/
-        /* methods */
-        (destructor)(static_cast<void (*)(PyCvtsObject<T>*)>
-           (DEL_PyCvtsObject)),         /*tp_dealloc*/
-        (printfunc)0,                   /*tp_print*/
-        (getattrfunc)0,                 /*tp_getattr*/
-        (setattrfunc)0,                 /*tp_setattr*/
-        (cmpfunc)0,                     /*tp_compare*/
-        (reprfunc)0,                    /*tp_repr*/
-        0,                              /*tp_as_number*/
-        0,                              /*tp_as_sequence*/
-        0,                              /*tp_as_mapping*/
-        (hashfunc)0,                    /*tp_hash*/
-        (ternaryfunc)0,                 /*tp_call*/
-        (reprfunc)0,                    /*tp_str*/
-
-        /* Space for future expansion */
-        0L,0L,0L,0L,
-        PyCvtsObject_Type__doc__        /* Documentation string */
-    };
-
-    PyCvtsObject<T>* self = PyObject_NEW(PyCvtsObject<T>, &PyCvtsObject_Type);
-    if (self == 0) throw export_error();
-    self->cvts = cvts;
-    return reinterpret_cast<PyObject*>(self);
-}
-
-#endif // SPECIAL_PYCVTSOBJECT
-
-template <class T>
-boost::python::export_converters_base<T>*
-import_extension_class<T>::get_converters() {
-  if (imported_converters == 0) {
-#ifndef SPECIAL_PYCVTSOBJECT
-    void *cobject
-      = import_converters(m_module, m_klass, converters_attribute_name);
-    imported_converters
-      = static_cast<boost::python::export_converters_base<T>*>(cobject);
-#else
-    ref cvts_obj(
-      new_import_converters(m_module, m_klass, converters_attribute_name));
-    PyCvtsObject<T>* cvts = reinterpret_cast<PyCvtsObject<T>*>(cvts_obj.get());
-    imported_converters = cvts->cvts;
-#endif
-    check_export_converters_api(
-      EXPORT_CONVERTERS_API_MAJOR,
-      EXPORT_CONVERTERS_API_MINOR,
-      imported_converters->get_api_major(),
-      imported_converters->get_api_minor());
-  }
-  return imported_converters;
-}
-
-}}} // namespace boost::python::detail
-
-namespace boost { namespace python {
-
-//QUESTIONMARK
-//  A stripped-down, modified version of class class_builder.
-//  Would it make sense to establish a formal relationship
-//  between the two classes?
-template <class T>
-class import_class_builder
-    : python_import_extension_class_converters<T>
-{
- public:
-    import_class_builder(const char *module, const char* klass)
-        : m_class(new detail::import_extension_class<T>(module, klass))
-    { }
- private:
-
-    //QUESTIONMARK
-    //reference<detail::import_extension_class<T> > m_class;
-    boost::shared_ptr<detail::import_extension_class<T> > m_class;
-};
-
-}} // namespace boost::python
-
-namespace boost { namespace python {
-
-// A class_builder that exports the converter functions.
-template <class T, class U = detail::held_instance<T>,
-          class C = export_converters<T> >
-class x_class_builder
-    : public class_builder<T, U>
-{
-  private:
-    static C export_cvts;
-
-  public:
-    x_class_builder(module_builder& module, const char* name)
-        : class_builder<T, U>(module, name) {
-#ifndef SPECIAL_PYCVTSOBJECT
-    add(
-      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
-      const_cast<char*>(detail::converters_attribute_name.c_str()));
-#else
-    add(ref(detail::create_PyCvtsObject(&export_cvts)),
-      const_cast<char*>(detail::converters_attribute_name.c_str()));
-#endif
-  }
-};
-
-template <class T, class U, class C>
-C x_class_builder<T, U, C>::export_cvts;
-
-//QUESTIONMARK
-//  Is there a better way of making it easy for the end-user
-//  to choose between x_class_builder and xptr_class_builder?
-template <class T, class U = detail::held_instance<T>,
-          class C = export_ptr_converters<T> >
-class xptr_class_builder : public x_class_builder<T, U, C>
-{
-  public:
-    xptr_class_builder(module_builder& module, const char* name)
-        : x_class_builder<T, U, C >(module, name) { }
-};
-
-}} // namespace boost::python
-
-#endif // X_CLASS_BUILDER_HPP

From 2d568b1c0fd9b786d93b10e5f96a9118ce865274 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 6 Mar 2001 01:13:35 +0000
Subject: [PATCH 038/369] Fixed a bug which prevented auto_ptr values from
 being converted to_python

[SVN r9455]
---
 include/boost/python/detail/extension_class.hpp | 14 ++++++++++----
 src/gen_extclass.py                             | 16 +++++++++++-----
 2 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 4afffcae..125f1eed 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -9,6 +9,10 @@
 //  This file automatically generated for 10-argument constructors by
 //  gen_extclass.python
 
+//  Revision History:
+//  05 Mar 01  Fixed a bug which prevented auto_ptr values from being converted
+//             to_python (Dave Abrahams)
+
 #ifndef EXTENSION_CLASS_DWA052000_H_
 # define EXTENSION_CLASS_DWA052000_H_
 
@@ -250,10 +254,12 @@ class python_extension_class_converters
         throw boost::python::argument_error();
     }
 
-    // Extract from obj a constant reference to the PtrType object which is holding a T.
-    // If obj is None, the reference denotes a default-constructed PtrType
+    // Extract from obj a reference to the PtrType object which is holding a
+    // T. If it weren't for auto_ptr, it would be a constant reference. Do not
+    // modify the referent except by copying an auto_ptr! If obj is None, the
+    // reference denotes a default-constructed PtrType
     template <class PtrType>
-    static const PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
+    static PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
     {
         if (obj == Py_None)
         {
@@ -315,7 +321,7 @@ class python_extension_class_converters
     friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&>)
         { return smart_ptr_reference(p, boost::python::type<std::auto_ptr<T> >()); }
     
-    friend const std::auto_ptr<T>& from_python(PyObject* 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 smart_ptr_value(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>&>)
diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index 2d261289..8de8a1ae 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -14,6 +14,10 @@ def gen_extclass(args):
 //  This file automatically generated for %d-argument constructors by
 //  gen_extclass.python
 
+//  Revision History:
+//  05 Mar 01  Fixed a bug which prevented auto_ptr values from being converted
+//             to_python (Dave Abrahams)
+
 #ifndef EXTENSION_CLASS_DWA052000_H_
 # define EXTENSION_CLASS_DWA052000_H_
 
@@ -157,7 +161,7 @@ template <class Ptr>
 bool is_null(const Ptr& x)
 {
     return is_null_helper<(is_pointer<Ptr>::value)>::test(x);
-};
+}
 
 }}} // namespace boost::python::detail
 
@@ -255,10 +259,12 @@ class python_extension_class_converters
         throw boost::python::argument_error();
     }
 
-    // Extract from obj a constant reference to the PtrType object which is holding a T.
-    // If obj is None, the reference denotes a default-constructed PtrType
+    // Extract from obj a reference to the PtrType object which is holding a
+    // T. If it weren't for auto_ptr, it would be a constant reference. Do not
+    // modify the referent except by copying an auto_ptr! If obj is None, the
+    // reference denotes a default-constructed PtrType
     template <class PtrType>
-    static const PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
+    static PtrType& smart_ptr_value(PyObject* obj, boost::python::type<PtrType>)
     {
         if (obj == Py_None)
         {
@@ -320,7 +326,7 @@ class python_extension_class_converters
     friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&>)
         { return smart_ptr_reference(p, boost::python::type<std::auto_ptr<T> >()); }
     
-    friend const std::auto_ptr<T>& from_python(PyObject* 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 smart_ptr_value(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>&>)

From b0d6d40c2a800159cacbe796f96c069ec503fc2a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 6 Mar 2001 01:14:47 +0000
Subject: [PATCH 039/369] Suppress warnings under Cygwin with Python 2.0

[SVN r9456]
---
 include/boost/python/detail/wrap_python.hpp | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index d5b75374..b7a47513 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -16,9 +16,13 @@
 //  compiler command-line.
 
 // Revision History:
+// 05 Mar 01  Suppress warnings under Cygwin with Python 2.0 (Dave Abrahams)
 // 04 Mar 01  Rolled in some changes from the Dragon fork (Dave Abrahams)
 // 01 Mar 01  define PyObject_INIT() for Python 1.x (Dave Abrahams)
 
+
+#include <patchlevel.h>
+
 #ifdef _DEBUG
 # ifndef BOOST_DEBUG_PYTHON
 #  undef _DEBUG // Don't let Python force the debug library just because we're debugging.
@@ -37,9 +41,11 @@ typedef int pid_t;
 #  define WORD_BIT 32
 #  define hypot _hypot
 #  include <stdio.h>
-#  define HAVE_CLOCK
-#  define HAVE_STRFTIME
-#  define HAVE_STRERROR
+#  if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
+#   define HAVE_CLOCK
+#   define HAVE_STRFTIME
+#   define HAVE_STRERROR
+#  endif
 #  define NT_THREADS
 #  define WITH_THREAD
 #  ifndef NETSCAPE_PI

From dd0e42cf7252e41d3c3e1c5d5854d614c446d57a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 6 Mar 2001 02:44:32 +0000
Subject: [PATCH 040/369] temp files before branching

[SVN r9457]
---
 example/dvect.cpp              | 68 ++++++++++++++++++++++++++++++++++
 example/dvect.h                | 32 ++++++++++++++++
 example/ivect.cpp              | 68 ++++++++++++++++++++++++++++++++++
 example/ivect.h                | 32 ++++++++++++++++
 example/noncopyable.h          | 14 +++++++
 example/noncopyable_export.cpp | 23 ++++++++++++
 example/noncopyable_import.cpp | 41 ++++++++++++++++++++
 example/tst_dvect.py           | 16 ++++++++
 example/tst_ivect.py           | 16 ++++++++
 example/tst_noncopyable.py     |  8 ++++
 10 files changed, 318 insertions(+)
 create mode 100644 example/dvect.cpp
 create mode 100644 example/dvect.h
 create mode 100644 example/ivect.cpp
 create mode 100644 example/ivect.h
 create mode 100644 example/noncopyable.h
 create mode 100644 example/noncopyable_export.cpp
 create mode 100644 example/noncopyable_import.cpp
 create mode 100644 example/tst_dvect.py
 create mode 100644 example/tst_ivect.py
 create mode 100644 example/tst_noncopyable.py

diff --git a/example/dvect.cpp b/example/dvect.cpp
new file mode 100644
index 00000000..47f70d3b
--- /dev/null
+++ b/example/dvect.cpp
@@ -0,0 +1,68 @@
+#include "ivect.h"
+#include "dvect.h"
+#include <boost/python/x_class_builder.hpp>
+namespace python = boost::python;
+
+namespace {
+
+  vects::ivect dvect_as_ivect(const vects::dvect& dv)
+  {
+    vects::ivect iv(dv.size());
+    vects::ivect::iterator iviter = iv.begin();
+    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
+    return iv;
+  }
+
+  boost::python::tuple ivect_as_tuple(const vects::ivect& iv)
+  {
+    return iv.as_tuple();
+  }
+
+  std::auto_ptr<vects::ivect> auto_ptr_ivect(const vects::dvect& dv)
+  {
+    return std::auto_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
+  }
+
+  boost::shared_ptr<vects::ivect> shared_ptr_ivect(const vects::dvect& dv)
+  {
+    return boost::shared_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
+  }
+
+  boost::python::tuple auto_ptr_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
+  {
+    return iv->as_tuple();
+  }
+
+  boost::python::tuple shared_ptr_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
+  {
+    return iv->as_tuple();
+  }
+}
+
+extern "C"
+DL_EXPORT(void)
+initdvect()
+{
+  try
+  {
+    python::module_builder this_module("dvect");
+
+    python::x_class_builder<vects::dvect> dvect_class(this_module, "dvect");
+
+    python::import_class_builder<vects::ivect> ivect_class("ivect", "ivect");
+
+    dvect_class.def(python::constructor<python::tuple>());
+    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
+    dvect_class.def(dvect_as_ivect, "as_ivect");
+
+    this_module.def(ivect_as_tuple, "ivect_as_tuple");
+    dvect_class.def(auto_ptr_ivect, "auto_ptr_ivect");
+    dvect_class.def(shared_ptr_ivect, "shared_ptr_ivect");
+    this_module.def(auto_ptr_ivect_as_tuple, "auto_ptr_ivect_as_tuple");
+    this_module.def(shared_ptr_ivect_as_tuple, "shared_ptr_ivect_as_tuple");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/dvect.h b/example/dvect.h
new file mode 100644
index 00000000..8ffe7b50
--- /dev/null
+++ b/example/dvect.h
@@ -0,0 +1,32 @@
+#ifndef DVECT_H
+#define DVECT_H
+
+#include <vector>
+#include <boost/python/class_builder.hpp>
+
+namespace vects {
+
+  struct dvect : public std::vector<double>
+  {
+    dvect() : std::vector<double>() {}
+    dvect(size_t n) : std::vector<double>(n) {}
+    dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator v_it = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<double>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (int i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+  };
+}
+
+#endif // DVECT_H
diff --git a/example/ivect.cpp b/example/ivect.cpp
new file mode 100644
index 00000000..dfd90fc9
--- /dev/null
+++ b/example/ivect.cpp
@@ -0,0 +1,68 @@
+#include "ivect.h"
+#include "dvect.h"
+#include <boost/python/x_class_builder.hpp>
+namespace python = boost::python;
+
+namespace {
+
+  vects::dvect ivect_as_dvect(const vects::ivect& iv)
+  {
+    vects::dvect dv(iv.size());
+    vects::dvect::iterator dviter = dv.begin();
+    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
+    return dv;
+  }
+
+  boost::python::tuple dvect_as_tuple(const vects::dvect& dv)
+  {
+    return dv.as_tuple();
+  }
+
+  std::auto_ptr<vects::dvect> auto_ptr_dvect(const vects::ivect& iv)
+  {
+    return std::auto_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
+  }
+
+  boost::shared_ptr<vects::dvect> shared_ptr_dvect(const vects::ivect& iv)
+  {
+    return boost::shared_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
+  }
+
+  boost::python::tuple auto_ptr_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
+  {
+    return dv->as_tuple();
+  }
+
+  boost::python::tuple shared_ptr_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
+  {
+    return dv->as_tuple();
+  }
+}
+
+extern "C"
+DL_EXPORT(void)
+initivect()
+{
+  try
+  {
+    python::module_builder this_module("ivect");
+
+    python::x_class_builder<vects::ivect> ivect_class(this_module, "ivect");
+
+    python::import_class_builder<vects::dvect> dvect_class("dvect", "dvect");
+
+    ivect_class.def(python::constructor<python::tuple>());
+    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
+    ivect_class.def(ivect_as_dvect, "as_dvect");
+
+    this_module.def(dvect_as_tuple, "dvect_as_tuple");
+    ivect_class.def(auto_ptr_dvect, "auto_ptr_dvect");
+    ivect_class.def(shared_ptr_dvect, "shared_ptr_dvect");
+    this_module.def(auto_ptr_dvect_as_tuple, "auto_ptr_dvect_as_tuple");
+    this_module.def(shared_ptr_dvect_as_tuple, "shared_ptr_dvect_as_tuple");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/ivect.h b/example/ivect.h
new file mode 100644
index 00000000..a0187307
--- /dev/null
+++ b/example/ivect.h
@@ -0,0 +1,32 @@
+#ifndef IVECT_H
+#define IVECT_H
+
+#include <vector>
+#include <boost/python/class_builder.hpp>
+
+namespace vects {
+
+  struct ivect : public std::vector<int>
+  {
+    ivect() : std::vector<int>() {}
+    ivect(size_t n) : std::vector<int>(n) {}
+    ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
+    {
+      std::vector<int>::iterator v_it = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<int>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (int i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+  };
+}
+
+#endif // IVECT_H
diff --git a/example/noncopyable.h b/example/noncopyable.h
new file mode 100644
index 00000000..de7b3672
--- /dev/null
+++ b/example/noncopyable.h
@@ -0,0 +1,14 @@
+#ifndef NONCOPYABLE_H
+#define NONCOPYABLE_H
+
+class store
+{
+  private:
+    store(const store&) { } // Disable the copy constructor.
+    int number;
+  public:
+    store(const int i) : number(i) { }
+    int recall() const { return number; }
+};
+
+#endif // NONCOPYABLE_H
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
new file mode 100644
index 00000000..31cbe7c8
--- /dev/null
+++ b/example/noncopyable_export.cpp
@@ -0,0 +1,23 @@
+#include <boost/python/x_class_builder.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+extern "C"
+DL_EXPORT(void)
+initnoncopyable_export()
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_export");
+
+    python::xptr_class_builder<store> store_class(this_module, "store");
+
+    store_class.def(python::constructor<int>());
+    store_class.def(&store::recall, "recall");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
new file mode 100644
index 00000000..f2b2c6d0
--- /dev/null
+++ b/example/noncopyable_import.cpp
@@ -0,0 +1,41 @@
+#include <boost/python/x_class_builder.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A function with store objects as both input and output parameters.
+  // Because the copy constructor is disabled, we cannot pass a store
+  // object by value. Instead, we pass a smart pointer.
+  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
+  {
+    int sum = s1.recall() + s2.recall();
+    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
+    return ss;
+  }
+}
+
+extern "C"
+DL_EXPORT(void)
+initnoncopyable_import()
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_import");
+
+    python::import_class_builder<store>
+      dvect_class("noncopyable_export", "store");
+
+    // Imagine all the additional classes with member functions
+    // that have store objects as input and output parameters.
+    // Lots and lots of them.
+    // However, to keep this example simple, we only define a
+    // module-level function.
+    this_module.def(add_stores, "add_stores");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/tst_dvect.py b/example/tst_dvect.py
new file mode 100644
index 00000000..563f0ad5
--- /dev/null
+++ b/example/tst_dvect.py
@@ -0,0 +1,16 @@
+import dvect
+print dvect.dvect.__converters__
+dv = dvect.dvect((1,2,3,4,5))
+print dv
+print dv.as_tuple()
+iv = dv.as_ivect()
+print iv
+print iv.as_tuple()
+print dvect.ivect_as_tuple(iv)
+aiv = dv.auto_ptr_ivect()
+print aiv
+siv = dv.shared_ptr_ivect()
+print dvect.auto_ptr_ivect_as_tuple(aiv)
+print dvect.ivect_as_tuple(aiv)
+print dvect.shared_ptr_ivect_as_tuple(siv)
+print dvect.ivect_as_tuple(siv)
diff --git a/example/tst_ivect.py b/example/tst_ivect.py
new file mode 100644
index 00000000..58bc323f
--- /dev/null
+++ b/example/tst_ivect.py
@@ -0,0 +1,16 @@
+import ivect
+print ivect.ivect.__converters__
+iv = ivect.ivect((1,2,3,4,5))
+print iv
+print iv.as_tuple()
+dv = iv.as_dvect()
+print dv
+print dv.as_tuple()
+print ivect.dvect_as_tuple(dv)
+adv = iv.auto_ptr_dvect()
+print adv
+sdv = iv.shared_ptr_dvect()
+print ivect.auto_ptr_dvect_as_tuple(adv)
+print ivect.dvect_as_tuple(adv)
+print ivect.shared_ptr_dvect_as_tuple(sdv)
+print ivect.dvect_as_tuple(sdv)
diff --git a/example/tst_noncopyable.py b/example/tst_noncopyable.py
new file mode 100644
index 00000000..913df039
--- /dev/null
+++ b/example/tst_noncopyable.py
@@ -0,0 +1,8 @@
+import noncopyable_export
+import noncopyable_import
+s1 = noncopyable_export.store(1)
+print s1.recall()
+s2 = noncopyable_export.store(2)
+print s2.recall()
+s3 = noncopyable_import.add_stores(s1, s2)
+print s3.recall()

From 53d2398e0654b67463c4326b7dc8ba134d925711 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 6 Mar 2001 02:45:39 +0000
Subject: [PATCH 041/369] remove temp files after branching.

[SVN r9459]
---
 example/dvect.cpp              | 68 ----------------------------------
 example/dvect.h                | 32 ----------------
 example/ivect.cpp              | 68 ----------------------------------
 example/ivect.h                | 32 ----------------
 example/noncopyable.h          | 14 -------
 example/noncopyable_export.cpp | 23 ------------
 example/noncopyable_import.cpp | 41 --------------------
 example/tst_dvect.py           | 16 --------
 example/tst_ivect.py           | 16 --------
 example/tst_noncopyable.py     |  8 ----
 10 files changed, 318 deletions(-)
 delete mode 100644 example/dvect.cpp
 delete mode 100644 example/dvect.h
 delete mode 100644 example/ivect.cpp
 delete mode 100644 example/ivect.h
 delete mode 100644 example/noncopyable.h
 delete mode 100644 example/noncopyable_export.cpp
 delete mode 100644 example/noncopyable_import.cpp
 delete mode 100644 example/tst_dvect.py
 delete mode 100644 example/tst_ivect.py
 delete mode 100644 example/tst_noncopyable.py

diff --git a/example/dvect.cpp b/example/dvect.cpp
deleted file mode 100644
index 47f70d3b..00000000
--- a/example/dvect.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "ivect.h"
-#include "dvect.h"
-#include <boost/python/x_class_builder.hpp>
-namespace python = boost::python;
-
-namespace {
-
-  vects::ivect dvect_as_ivect(const vects::dvect& dv)
-  {
-    vects::ivect iv(dv.size());
-    vects::ivect::iterator iviter = iv.begin();
-    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
-    return iv;
-  }
-
-  boost::python::tuple ivect_as_tuple(const vects::ivect& iv)
-  {
-    return iv.as_tuple();
-  }
-
-  std::auto_ptr<vects::ivect> auto_ptr_ivect(const vects::dvect& dv)
-  {
-    return std::auto_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
-  }
-
-  boost::shared_ptr<vects::ivect> shared_ptr_ivect(const vects::dvect& dv)
-  {
-    return boost::shared_ptr<vects::ivect>(new vects::ivect(dvect_as_ivect(dv)));
-  }
-
-  boost::python::tuple auto_ptr_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
-  {
-    return iv->as_tuple();
-  }
-
-  boost::python::tuple shared_ptr_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
-  {
-    return iv->as_tuple();
-  }
-}
-
-extern "C"
-DL_EXPORT(void)
-initdvect()
-{
-  try
-  {
-    python::module_builder this_module("dvect");
-
-    python::x_class_builder<vects::dvect> dvect_class(this_module, "dvect");
-
-    python::import_class_builder<vects::ivect> ivect_class("ivect", "ivect");
-
-    dvect_class.def(python::constructor<python::tuple>());
-    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
-    dvect_class.def(dvect_as_ivect, "as_ivect");
-
-    this_module.def(ivect_as_tuple, "ivect_as_tuple");
-    dvect_class.def(auto_ptr_ivect, "auto_ptr_ivect");
-    dvect_class.def(shared_ptr_ivect, "shared_ptr_ivect");
-    this_module.def(auto_ptr_ivect_as_tuple, "auto_ptr_ivect_as_tuple");
-    this_module.def(shared_ptr_ivect_as_tuple, "shared_ptr_ivect_as_tuple");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/dvect.h b/example/dvect.h
deleted file mode 100644
index 8ffe7b50..00000000
--- a/example/dvect.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef DVECT_H
-#define DVECT_H
-
-#include <vector>
-#include <boost/python/class_builder.hpp>
-
-namespace vects {
-
-  struct dvect : public std::vector<double>
-  {
-    dvect() : std::vector<double>() {}
-    dvect(size_t n) : std::vector<double>(n) {}
-    dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator v_it = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          boost::python::type<double>());
-    }
-
-    boost::python::tuple as_tuple() const
-    {
-      boost::python::tuple t(size());
-      for (int i = 0; i < size(); i++)
-        t.set_item(i,
-          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
-      return t;
-    }
-  };
-}
-
-#endif // DVECT_H
diff --git a/example/ivect.cpp b/example/ivect.cpp
deleted file mode 100644
index dfd90fc9..00000000
--- a/example/ivect.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-#include "ivect.h"
-#include "dvect.h"
-#include <boost/python/x_class_builder.hpp>
-namespace python = boost::python;
-
-namespace {
-
-  vects::dvect ivect_as_dvect(const vects::ivect& iv)
-  {
-    vects::dvect dv(iv.size());
-    vects::dvect::iterator dviter = dv.begin();
-    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
-    return dv;
-  }
-
-  boost::python::tuple dvect_as_tuple(const vects::dvect& dv)
-  {
-    return dv.as_tuple();
-  }
-
-  std::auto_ptr<vects::dvect> auto_ptr_dvect(const vects::ivect& iv)
-  {
-    return std::auto_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
-  }
-
-  boost::shared_ptr<vects::dvect> shared_ptr_dvect(const vects::ivect& iv)
-  {
-    return boost::shared_ptr<vects::dvect>(new vects::dvect(ivect_as_dvect(iv)));
-  }
-
-  boost::python::tuple auto_ptr_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
-  {
-    return dv->as_tuple();
-  }
-
-  boost::python::tuple shared_ptr_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
-  {
-    return dv->as_tuple();
-  }
-}
-
-extern "C"
-DL_EXPORT(void)
-initivect()
-{
-  try
-  {
-    python::module_builder this_module("ivect");
-
-    python::x_class_builder<vects::ivect> ivect_class(this_module, "ivect");
-
-    python::import_class_builder<vects::dvect> dvect_class("dvect", "dvect");
-
-    ivect_class.def(python::constructor<python::tuple>());
-    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
-    ivect_class.def(ivect_as_dvect, "as_dvect");
-
-    this_module.def(dvect_as_tuple, "dvect_as_tuple");
-    ivect_class.def(auto_ptr_dvect, "auto_ptr_dvect");
-    ivect_class.def(shared_ptr_dvect, "shared_ptr_dvect");
-    this_module.def(auto_ptr_dvect_as_tuple, "auto_ptr_dvect_as_tuple");
-    this_module.def(shared_ptr_dvect_as_tuple, "shared_ptr_dvect_as_tuple");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/ivect.h b/example/ivect.h
deleted file mode 100644
index a0187307..00000000
--- a/example/ivect.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef IVECT_H
-#define IVECT_H
-
-#include <vector>
-#include <boost/python/class_builder.hpp>
-
-namespace vects {
-
-  struct ivect : public std::vector<int>
-  {
-    ivect() : std::vector<int>() {}
-    ivect(size_t n) : std::vector<int>(n) {}
-    ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
-    {
-      std::vector<int>::iterator v_it = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          boost::python::type<int>());
-    }
-
-    boost::python::tuple as_tuple() const
-    {
-      boost::python::tuple t(size());
-      for (int i = 0; i < size(); i++)
-        t.set_item(i,
-          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
-      return t;
-    }
-  };
-}
-
-#endif // IVECT_H
diff --git a/example/noncopyable.h b/example/noncopyable.h
deleted file mode 100644
index de7b3672..00000000
--- a/example/noncopyable.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef NONCOPYABLE_H
-#define NONCOPYABLE_H
-
-class store
-{
-  private:
-    store(const store&) { } // Disable the copy constructor.
-    int number;
-  public:
-    store(const int i) : number(i) { }
-    int recall() const { return number; }
-};
-
-#endif // NONCOPYABLE_H
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
deleted file mode 100644
index 31cbe7c8..00000000
--- a/example/noncopyable_export.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-#include <boost/python/x_class_builder.hpp>
-namespace python = boost::python;
-
-#include "noncopyable.h"
-
-extern "C"
-DL_EXPORT(void)
-initnoncopyable_export()
-{
-  try
-  {
-    python::module_builder this_module("noncopyable_export");
-
-    python::xptr_class_builder<store> store_class(this_module, "store");
-
-    store_class.def(python::constructor<int>());
-    store_class.def(&store::recall, "recall");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
deleted file mode 100644
index f2b2c6d0..00000000
--- a/example/noncopyable_import.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#include <boost/python/x_class_builder.hpp>
-namespace python = boost::python;
-
-#include "noncopyable.h"
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A function with store objects as both input and output parameters.
-  // Because the copy constructor is disabled, we cannot pass a store
-  // object by value. Instead, we pass a smart pointer.
-  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
-  {
-    int sum = s1.recall() + s2.recall();
-    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
-    return ss;
-  }
-}
-
-extern "C"
-DL_EXPORT(void)
-initnoncopyable_import()
-{
-  try
-  {
-    python::module_builder this_module("noncopyable_import");
-
-    python::import_class_builder<store>
-      dvect_class("noncopyable_export", "store");
-
-    // Imagine all the additional classes with member functions
-    // that have store objects as input and output parameters.
-    // Lots and lots of them.
-    // However, to keep this example simple, we only define a
-    // module-level function.
-    this_module.def(add_stores, "add_stores");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/tst_dvect.py b/example/tst_dvect.py
deleted file mode 100644
index 563f0ad5..00000000
--- a/example/tst_dvect.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import dvect
-print dvect.dvect.__converters__
-dv = dvect.dvect((1,2,3,4,5))
-print dv
-print dv.as_tuple()
-iv = dv.as_ivect()
-print iv
-print iv.as_tuple()
-print dvect.ivect_as_tuple(iv)
-aiv = dv.auto_ptr_ivect()
-print aiv
-siv = dv.shared_ptr_ivect()
-print dvect.auto_ptr_ivect_as_tuple(aiv)
-print dvect.ivect_as_tuple(aiv)
-print dvect.shared_ptr_ivect_as_tuple(siv)
-print dvect.ivect_as_tuple(siv)
diff --git a/example/tst_ivect.py b/example/tst_ivect.py
deleted file mode 100644
index 58bc323f..00000000
--- a/example/tst_ivect.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import ivect
-print ivect.ivect.__converters__
-iv = ivect.ivect((1,2,3,4,5))
-print iv
-print iv.as_tuple()
-dv = iv.as_dvect()
-print dv
-print dv.as_tuple()
-print ivect.dvect_as_tuple(dv)
-adv = iv.auto_ptr_dvect()
-print adv
-sdv = iv.shared_ptr_dvect()
-print ivect.auto_ptr_dvect_as_tuple(adv)
-print ivect.dvect_as_tuple(adv)
-print ivect.shared_ptr_dvect_as_tuple(sdv)
-print ivect.dvect_as_tuple(sdv)
diff --git a/example/tst_noncopyable.py b/example/tst_noncopyable.py
deleted file mode 100644
index 913df039..00000000
--- a/example/tst_noncopyable.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import noncopyable_export
-import noncopyable_import
-s1 = noncopyable_export.store(1)
-print s1.recall()
-s2 = noncopyable_export.store(2)
-print s2.recall()
-s3 = noncopyable_import.add_stores(s1, s2)
-print s3.recall()

From 116b3db1d1b6ebbaab7aca99401b6a8dd332d613 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 6 Mar 2001 20:55:09 +0000
Subject: [PATCH 042/369] Fixed typo in use of "PYTHON_LIB"

[SVN r9467]
---
 build/como.mak | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/build/como.mak b/build/como.mak
index c6f340a5..581eefea 100644
--- a/build/como.mak
+++ b/build/como.mak
@@ -1,5 +1,7 @@
 # Revision History:
+# 06 Mar 01  Fixed typo in use of "PYTHON_LIB" (Dave Abrahams)
 # 04 Mar 01  Changed library name to libboost_python.a (David Abrahams)
+
 LIBSRC = \
     classes.cpp \
     conversions.cpp \
@@ -33,7 +35,7 @@ endif
                 [ -s $@ ] || rm -f $@
 
 example1: example1.o libboost_python.a
-	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYHTON_LIB) example1.o -L. -lboost_python
+	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYTHON_LIB) example1.o -L. -lboost_python
 	python ../example/test_example1.py
 
 example1.o: ../example/example1.cpp

From 617bcdac9f81d1486c585158b9c7694f2f5c48fd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 03:39:31 +0000
Subject: [PATCH 043/369] Major doc updates

[SVN r9470]
---
 doc/building.html          | 195 +++++++++++++++++++++++++++++--------
 doc/comparisons.html       |  61 +++++++-----
 doc/enums.html             |  43 +++++---
 doc/example1.html          | 112 ++++++---------------
 doc/exporting_classes.html | 144 +++++++++++++++++++++++++++
 doc/extending.html         |   4 +-
 doc/index.html             |  91 +++++++++--------
 doc/inheritance.html       |  26 ++---
 doc/overloading.html       |   6 +-
 doc/overriding.html        |  98 +++++++++++--------
 doc/pickle.html            |  28 +++---
 doc/pointers.html          |   4 +-
 doc/special.html           |  28 +++---
 doc/under-the-hood.html    |   4 +-
 14 files changed, 551 insertions(+), 293 deletions(-)
 create mode 100644 doc/exporting_classes.html

diff --git a/doc/building.html b/doc/building.html
index 4ac2343c..6627bbe8 100644
--- a/doc/building.html
+++ b/doc/building.html
@@ -1,44 +1,157 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Building an Extension Module
-    </title>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+
+    <title>Building an Extension Module</title>
+
     <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Building an Extension Module
-      </h1>
-      <p>
-         Right now, the only supported configuration is one in which the BPL
-         source files are statically linked with the source for your extension
-         module. You may first build them into a library and link it with your
-         extension module source, but the effect is the same as compiling all
-         the source files together. Some users have successfully built the
-         sources into a shared library, and support for a shared library
-         build is planned, but not yet implemented. The BPL source files are:
-<blockquote>
-<pre>
-<a href="../../../libs/python/src/extension_class.cpp">extclass.cpp</a>
-<a href="../../../libs/python/src/functions.cpp">functions.cpp</a>
-<a href="../../../libs/python/src/init_function.cpp">init_function.cpp</a>
-<a href="../../../libs/python/src/module_builder.cpp">module.cpp</a>
-<a href="../../../libs/python/src/types.cpp">newtypes.cpp</a>
-<a href="../../../libs/python/src/objects.cpp">objects.cpp</a>
-<a href="../../../libs/python/src/conversions.cpp">py.cpp</a>
-<a href="../../../libs/python/src/classes.cpp">subclass.cpp</a>
-         </pre>
-         </blockquote>
-               <p>
-         Next: <a href="enums.html">Enums</a>
-         Previous: <a href="under-the-hood.html">A Peek Under the Hood</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
-        sell and distribute this document is granted provided this copyright
-        notice appears in all copies. This document is provided ``as
-        is'' without express or implied warranty, and with no claim as to
-        its suitability for any purpose.
-      <p>
-         Updated: Nov 26, 2000
+      <h1><img width="277" height="86" id="_x0000_i1025" align="center" src=
+      "../../../c++boost.gif" alt="c++boost.gif (8819 bytes)">Building an
+      Extension Module</h1>
+
+      <p>The build process for Boost is currently undergoing some evolution,
+      and, it is to be hoped, improvement. The following facts may help:
+
+      <ul>
+        <li>
+          Makefiles for various platforms reside in the Boost subdirectory
+          <tt>libs/python/build</tt>: 
+
+          <ul>
+            <li><a href="../build/como.mak">como.mak</a> (Comeau C++ on Linux)
+
+            <li><a href="../build/linux_gcc.mak">linux_gcc.mak</a> (GCC on
+            Linux/Unix)
+
+            <li><a href="../build/gcc.mak">gcc.mak</a> (older makefile for GCC
+            on Linux/Unix. Deprecated.)
+
+            <li><a href="../build/mingw32.mak">mingw32.mak</a>
+            (highly-specialized makefile for mingw32 (Win32-targeted) GCC. Read
+            the header comment).
+
+            <li><a href="../build/tru64_cxx.mak">tru64_cxx.mak</a> (Compaq
+            Alpha).
+          </ul>
+          <br>
+
+        <li>
+          A project workspace for Microsoft Visual Studio is provided at <tt><a
+          href="../build/build.dsw">libs/python/build/build.dsw</a></tt>. The
+          include paths for this project may need to be changed for your
+          installation. They currently assume that python has been installed at
+          <tt>c:\tools\python</tt>. Three configurations of all targets are
+          supported: 
+
+          <ul>
+            <li>Release (optimization, <tt>-DNDEBUG</tt>)
+
+            <li>Debug (no optimization <tt>-D_DEBUG</tt>)
+
+            <li>DebugPython (no optimization, <tt>-D_DEBUG
+            -DBOOST_DEBUG_PYTHON</tt>)
+          </ul>
+
+          <p>When extension modules are built with Visual C++ using
+          <tt>-D_DEBUG</tt>, Python defaults to <i>force</i> linking with a
+          special debugging version of the Python DLL. Since this debug DLL
+          isn't supplied with the default Python installation for Windows,
+          Boost.Python uses <tt><a href=
+          "../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
+          to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
+          <tt>#include</tt>d.
+
+          <p>If you want the extra runtime checks available with the debugging
+          version of the library, <tt>#define BOOST_DEBUG_PYTHON</tt> to
+          re-enable library forcing, and link with the DebugPython version of
+          <tt>boost_python.lib</tt>. You'll need to get the debugging version
+          of the Python executable (<tt>python_d.exe</tt>) and DLL
+          (<tt>python20_d.dll</tt> or <tt>python15_d.dll</tt>). The Python
+          sources include project files for building these. If you <a href=
+          "http://www.python.org">download</a> them, change the name of the
+          top-level directory to <tt>src</tt>, and install it under
+          <tt>c:\tools\python</tt>, the workspace supplied by Boost.Python will
+          be able to use it without modification. Just open
+          <tt>c:\tools\python\src\pcbuild\pcbuild.dsw</tt> and invoke "build
+          all" to generate all the debugging targets.
+
+          <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
+          any source files <tt>#include &lt;<a href=
+          "../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
+          instead of the usual <tt>Python.h</tt>, or you will have link
+          incompatibilities.<br>
+          <br>
+
+
+        <li>
+          The makefiles and Visual Studio project can all build at least the
+          following: 
+
+          <ul>
+            <li>The <tt>boost_python</tt> library for static linking with your
+            extension module. On the various Unices, this library will be
+            called <tt>libboost_python.a</tt>. On Win32 platforms, the library
+            will be called <tt>boost_python.lib</tt>.
+
+            <li>A comprehensive test of Boost.Python features. This test builds
+            a Boost.Python extension module, then runs Python to import the
+            module, and runs a series of tests on it using <tt><a href=
+            "../test/doctest.py">doctest</a></tt>. Source code for the module
+            and tests is available in the Boost subdirectory
+            <tt>libs/python/test</tt>.<br>
+
+
+            <li>Various examples from the Boost subdirectory
+            <tt>libs/python/example</tt>. Which examples are built currently
+            depends on the platform. The most up-to-date examples are
+            <tt>getting_started</tt><i>n</i><tt>.cpp</tt> from <a href=
+            "http://cci.lbl.gov/staff/ralf_grosse-kunstleve.html">Ralf W.
+            Grosse-Kunstleve</a>. All these examples include a doctest modeled
+            on the comprehensive test above.<br>
+            <br>
+
+          </ul>
+
+        <li>
+          If your platform isn't directly supported, you can build a static
+          library from the following source files (in the Boost subdirectory
+          <tt>libs/python/src</tt>), or compile them directly and link the
+          resulting objects into your extension module: 
+
+          <ul>
+            <li><a href=
+            "../../../libs/python/src/extension_class.cpp">extension_class.cpp</a>
+
+            <li><a href=
+            "../../../libs/python/src/functions.cpp">functions.cpp</a>
+
+            <li><a href=
+            "../../../libs/python/src/init_function.cpp">init_function.cpp</a>
+
+            <li><a href=
+            "../../../libs/python/src/module_builder.cpp">module_builder.cpp</a>
+
+            <li><a href="../../../libs/python/src/types.cpp">types.cpp</a>
+
+            <li><a href="../../../libs/python/src/objects.cpp">objects.cpp</a>
+
+            <li><a href=
+            "../../../libs/python/src/conversions.cpp">conversions.cpp</a>
+
+            <li><a href="../../../libs/python/src/classes.cpp">classes.cpp</a>
+          </ul>
+      </ul>
+
+      <p>Next: <a href="enums.html">Wrapping Enums</a> Previous: <a href=
+      "under-the-hood.html">A Peek Under the Hood</a> Up: <a href=
+      "index.html">Top</a>
+
+      <p>&copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+      sell and distribute this document is granted provided this copyright
+      notice appears in all copies. This document is provided ``as is'' without
+      express or implied warranty, and with no claim as to its suitability for
+      any purpose.
+
+      <p>Updated: Mar 6, 2001
     </div>
 
diff --git a/doc/comparisons.html b/doc/comparisons.html
index 336220fb..6f082d51 100644
--- a/doc/comparisons.html
+++ b/doc/comparisons.html
@@ -6,13 +6,14 @@
     <div>
       <h1>
          <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Comparisons with
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)"><br>
+        Comparisons with
         Other Systems
       </h1>
       
       <h2>CXX</h2>
       <p>
-        Like BPL, <a href="http://cxx.sourceforge.net/">CXX</a> attempts to
+        Like Boost.Python, <a href="http://cxx.sourceforge.net/">CXX</a> attempts to
         provide a C++-oriented interface to Python. In most cases, as with the
         boost library, it relieves the user from worrying about
         reference-counts. Both libraries automatically convert thrown C++
@@ -40,9 +41,15 @@
       <p>
         As far as I can tell, CXX enables one to write what is essentially
         idiomatic Python code in C++, manipulating Python objects through the
-        same fully-generic interfaces we use in Python. While you're hardly programming directly to the ``bare
-        metal'' with CXX, it basically presents a ``C++-ized''
-        version of the Python 'C' API.
+        same fully-generic interfaces we use in Python. While you're hardly
+        programming directly to the ``bare metal'' with CXX, it basically
+        presents a ``C++-ized'' version of the Python 'C' API. Some fraction of
+        that capability is available in Boost.Python through <tt><a
+        href="../../../boost/python/objects.hpp">boost/python/objects.hpp</a></tt>,
+        which provides C++ objects corresponding to Python lists, tuples,
+        strings, and dictionaries, and through <tt><a
+        href="../../../boost/python/callback.hpp">boost/python/callback.hpp</a></tt>,
+        which allows you to call back into python with C++ arguments.
 
       <p>
         <a href="mailto:dubois1@llnl.gov">Paul F. Dubois</a>, the original
@@ -65,7 +72,7 @@ that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
         languages. Swig relies on a parser to read your source code and produce
         additional source code files which can be compiled into a Python (or
         Perl or Tcl) extension module. It has been successfully used to create
-        many Python extension modules. Like BPL, SWIG is trying to allow an
+        many Python extension modules. Like Boost.Python, SWIG is trying to allow an
         existing interface to be wrapped with little or no change to the
         existing code. The documentation says ``SWIG parses a form of ANSI C
         syntax that has been extended with a number of special directives. As a
@@ -78,15 +85,15 @@ that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
         couldnt handle templates, didnt do func overloading properly etc.  For
         ANSI C libraries this was fine.  But for usual C++ code this was a
         problem.  Simple things work.  But for anything very complicated (or
-        realistic), one had to write code by hand.  I believe BPL doesn't have
+        realistic), one had to write code by hand.  I believe Boost.Python doesn't have
         this problem[<a href="#sic">sic</a>]...  IMHO overloaded functions are very important to
         wrap correctly.''<br><i>-Prabhu Ramachandran</i>
         </blockquote>
         
       <p>
-        By contrast, BPL doesn't attempt to parse C++ - the problem is simply
+        By contrast, Boost.Python doesn't attempt to parse C++ - the problem is simply
         too complex to do correctly. <a name="sic">Technically</a>, one does
-        write code by hand to use BPL. The goal, however, has been to make
+        write code by hand to use Boost.Python. The goal, however, has been to make
         that code nearly as simple as listing the names of the classes and
         member functions you want to expose in Python.
 
@@ -95,7 +102,7 @@ that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
         <a
         href="http://www.thekompany.com/projects/pykde/background.php3?dhtml_ok=1">SIP</a>
         is a system similar to SWIG, though seemingly more
-        C++-oriented. The author says that like BPL, SIP supports overriding
+        C++-oriented. The author says that like Boost.Python, SIP supports overriding
         extension class member functions in Python subclasses. It appears to
         have been designed specifically to directly support some features of
         PyQt/PyKDE, which is its primary client. Documentation is almost
@@ -113,7 +120,7 @@ that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
         to a wide range of computer languages, including Common Lisp, C++, C,
         Modula-3, and Python. ILU can parse the ISL to generate a C++ language
         header file describing the interface, of which the user is expected to
-        provide an implementation. Unlike BPL, this means that the system
+        provide an implementation. Unlike Boost.Python, this means that the system
         imposes implementation details on your C++ code at the deepest level. It
         is worth noting that some of the C++ names generated by ILU are supposed
         to be reserved to the C++ implementation. It is unclear from the
@@ -148,7 +155,7 @@ an inheritance relationship?
       <h2>Zope ExtensionClasses</h2>
       <p>
          <a href="http:http://www.digicool.com/releases/ExtensionClass">
-        ExtensionClasses in Zope</a> use the same underlying mechanism as BPL
+        ExtensionClasses in Zope</a> use the same underlying mechanism as Boost.Python
         to support subclassing of extension types in Python, including
         multiple-inheritance. Both systems support pickling/unpickling of
         extension class instances in very similar ways. Both systems rely on the
@@ -158,31 +165,35 @@ an inheritance relationship?
       <p>
         The major differences are:
       <ul>
+        <li>Zope is entirely 'C' language-based. It doesn't require a C++
+        compiler, so it's much more portable than Boost.Python, which stresses
+        the limits of even some modern C++ implementations.
+
         <li>
-          BPL lifts the burden on the user to parse and convert function
+          Boost.Python lifts the burden on the user to parse and convert function
           argument types. Zope provides no such facility.
         <li>
-          BPL lifts the burden on the user to maintain Python
+          Boost.Python lifts the burden on the user to maintain Python
           reference-counts.
         <li>
-          BPL supports function overloading; Zope does not.
+          Boost.Python supports function overloading; Zope does not.
         <li>
-          BPL supplies a simple mechanism for exposing read-only and
+          Boost.Python supplies a simple mechanism for exposing read-only and
           read/write access to data members of the wrapped C++ type as Python
           attributes.
         <li>
           Writing a Zope ExtensionClass is significantly more complex than
-          exposing a C++ class to python using BPL (mostly a summary of the
+          exposing a C++ class to python using Boost.Python (mostly a summary of the
           previous 4 items). <a href= 
           "http://www.digicool.com/releases/ExtensionClass/MultiMapping.html">A
           Zope Example</a> illustrates the differences.
         <li>
           Zope's ExtensionClasses are specifically motivated by ``the need for a
-          C-based persistence mechanism''. BPL's are motivated by the desire
+          C-based persistence mechanism''. Boost.Python's are motivated by the desire
           to simply reflect a C++ API into Python with as little modification as
           possible.
         <li>
-          The following Zope restriction does not apply to BPL: ``At most one
+          The following Zope restriction does not apply to Boost.Python: ``At most one
           base extension direct or indirect super class may define C data
           members. If an extension subclass inherits from multiple base
           extension classes, then all but one must be mix-in classes that
@@ -191,21 +202,21 @@ an inheritance relationship?
           Zope requires use of the somewhat funky inheritedAttribute (search for
           ``inheritedAttribute'' on <a
           href="http://www.digicool.com/releases/ExtensionClass">this page</a>)
-          method to access base class methods. In BPL, base class methods can
+          method to access base class methods. In Boost.Python, base class methods can
           be accessed in the usual way by writing
           ``<code>BaseClass.method</code>''.
         <li>
           Zope supplies some creative but esoteric idioms such as <a href= 
           "http://www.digicool.com/releases/ExtensionClass/Acquisition.html">
-          Acquisition</a>. No specific support for this is built into BPL.
+          Acquisition</a>. No specific support for this is built into Boost.Python.
         <li>
           Zope's ComputedAttribute support is designed to be used from Python.
           <a href="special.html#getter_setter">The analogous feature of
-          BPL</a> can be used from C++ or Python. The feature is arguably
-          easier to use in BPL.
+          Boost.Python</a> can be used from C++ or Python. The feature is arguably
+          easier to use in Boost.Python.
       </ul>
       <p>
-        Next: <a href="example1.html">A Simple Example Using BPL</a>
+        Next: <a href="example1.html">A Simple Example Using Boost.Python</a>
         Previous: <a href="extending.html">A Brief Introduction to writing Python Extension Modules</a>
         Up: <a href="index.html">Top</a>
       <p>
@@ -215,6 +226,6 @@ an inheritance relationship?
         express or implied warranty, and with no claim as to its suitability
         for any purpose.
       <p>
-         Updated: Nov 26, 2000
+         Updated: Mar 6, 2001
     </div>
 
diff --git a/doc/enums.html b/doc/enums.html
index 04138ff1..32d61447 100644
--- a/doc/enums.html
+++ b/doc/enums.html
@@ -6,7 +6,8 @@
     <div>
       <h1>
          <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Wrapping enums
+        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)"><br>
+        Wrapping enums
       </h1>
 
 <p>Because there is in general no way to deduce that a value of arbitrary type T
@@ -17,24 +18,39 @@ enums). Once you have done that, you can write some simple
 <code>from_python()</code> and <code>to_python()</code> functions.
 
 <p>If you are satisfied with a Python int as a way to represent your enum
-values, we provide a shorthand for these functions. You just need to
-instantiate <code>boost::python::enum_as_int_converters&lt;EnumType&gt;</code> where
+values, we provide a shorthand for these functions. You just need to cause
+<code>boost::python::enum_as_int_converters&lt;EnumType&gt;</code> to be
+instantiated, where
 <code>EnumType</code> is your enumerated type. There are two convenient ways to do this:
 
 <ol>
-<li><blockquote>
+<li>Explicit instantiation:
+
+<blockquote><pre>
+  template class boost::python::enum_as_int_converters&lt;my_enum&gt;;
+</blockquote></pre>
+
+Some buggy C++ implementations require a class to be instantiated in the same
+namespace in which it is defined. In that case, the simple incantation above becomes:
+
+<blockquote>
 <pre>
    ...
 } // close my_namespace
+
 // drop into namespace python and explicitly instantiate
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-  template class enum_as_int_converters<extclass_demo::EnumOwner::enum_type>;
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
+namespace boost { namespace python {
+  template class enum_as_int_converters&lt;my_enum_type&gt;;
+}} // namespace boost::python
+
 namespace my_namespace { // re-open my_namespace
    ...
 </pre>
 </blockquote>
-<li><blockquote><pre>
+
+
+<li>If you have such an implementation, you may find this technique more convenient 
+<blockquote><pre>
 // instantiate as base class in any namespace
 struct EnumTypeConverters
     : boost::python::enum_as_int_converters&lt;EnumType&gt;
@@ -71,7 +87,8 @@ BOOST_PYTHON_END_CONVERSION_NAMESPACE
  <code>long</code> type.
 
 You may also want to add a bunch of lines like this to your module
-initialization:
+initialization. These bind the corresponding enum values to the appropriate
+names so they can be used from Python:
 
 <blockquote><pre>
 mymodule.add(boost::python::to_python(enum_value_1), "enum_value_1");
@@ -83,12 +100,12 @@ You can also add these to an extension class definition, if your enum happens to
 be local to a class and you want the analogous interface in Python:
 
 <blockquote><pre>
-my_class.add(boost::python::to_python(enum_value_1), "enum_value_1");
-my_class.add(boost::python::to_python(enum_value_2), "enum_value_2");
+my_class_builder.add(boost::python::to_python(enum_value_1), "enum_value_1");
+my_class_builder.add(boost::python::to_python(enum_value_2), "enum_value_2");
 ...
 </pre></blockquote>
                <p>
-         Next: <a href="pointers.html">Pointers</a>
+         Next: <a href="pointers.html">Pointers and Smart Pointers</a>
          Previous: <a href="building.html">Building an Extension Module</a>
          Up: <a href="index.html">Top</a>
       <p>
@@ -98,6 +115,6 @@ my_class.add(boost::python::to_python(enum_value_2), "enum_value_2");
         is'' without express or implied warranty, and with no claim as to
         its suitability for any purpose.
       <p>
-         Updated: Nov 26, 2000
+         Updated: Mar 6, 2001
     </div>
 
diff --git a/doc/example1.html b/doc/example1.html
index 655f3d6a..402cc7a6 100644
--- a/doc/example1.html
+++ b/doc/example1.html
@@ -18,104 +18,56 @@
 <pre>
 #include &lt;string&gt;
 
-namespace hello {
-  class world
-  {
-   public:
-      world(int);
-      ~world();
-      std::string greet() const { return "hi, world"; }
-    ...
-  };
-  std::size_t length(const world&amp; x) { return std::strlen(x.greet()); }
+namespace { // Avoid cluttering the global namespace.
+
+  // A couple of simple C++ functions that we want to expose to Python.
+  std::string greet() { return "hello, world"; }
+  int square(int number) { return number * number; }
 }
 
 </pre>
       </blockquote>
       <p>
-         Here is the C++ code for a python module called <code>hello</code>
-        which exposes the API using:
+        Here is the C++ code for a python module called <tt>getting_started1</tt>
+        which exposes the API.
       <blockquote>
 <pre>
 #include &lt;boost/python/class_builder.hpp&gt;
-// Python requires an exported function called init&lt;module-name&gt; in every
-// extension module. This is where we build the module contents.
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void inithello()
+namespace python = boost::python;
+
+BOOST_PYTHON_MODULE_INIT(getting_started1)
 {
-    try
-    {
-       // create an object representing this extension module
-       boost::python::module_builder m("hello");
-       // Create the Python type object for our extension class
-       boost::python::class_builder&lt;hello::world&gt; world_class(m, "world");
-       // Add the __init__ function
-       world_class.def(boost::python::constructor&lt;int&gt;());
-       // Add a regular member function
-       world_class.def(&amp;hello::world::get, "get");
-       // Add a regular function to the module
-       m.def(hello::length, "length");
-    }
-    catch(...)
-    {
-       boost::python::handle_exception();    // Deal with the exception for Python
-    }
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("getting_started1");
+
+    // Add regular functions to the module.
+    this_module.def(greet, "greet");
+    this_module.def(square, "square");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
 }
-// Win32 DLL boilerplate
-#if defined(_WIN32)
-#include &lt;windows.h&gt;
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID)
-{
-    return 1;
-}
-#endif // _WIN32
 </pre>
       </blockquote>
       <p>
          That's it! If we build this shared library and put it on our <code>
-        PYTHONPATH</code> we can now access our C++ class and function from
+        PYTHONPATH</code> we can now access our C++ functions from
         Python.
       <blockquote>
 <pre>
-&gt;&gt;&gt; import hello
-&gt;&gt;&gt; hi_world = hello.world(3)
-&gt;&gt;&gt; hi_world.greet()
-'hi, world'
-&gt;&gt;&gt; hello.length(hi_world)
-9
+&gt;&gt;&gt; import getting_started1
+&gt;&gt;&gt; print getting_started1.greet()
+hello, world
+&gt;&gt;&gt; number = 11
+&gt;&gt;&gt; print number, '*', number, '=', getting_started1.square(number)
+11 * 11 = 121
 </pre>
-      </blockquote>
       <p>
-         We can even make a subclass of <code>hello.world</code>:
-      <blockquote>
-<pre>
-&gt;&gt;&gt; class my_subclass(hello.world):
-...     def greet(self):
-...         return 'hello, world'
-...
-&gt;&gt;&gt; y = my_subclass(4)
-&gt;&gt;&gt; y.greet()
-'hello, world'
-</pre>
-      </blockquote>
-      <p>
-         Pretty cool! You can't do that with an ordinary Python extension type!
-      <blockquote>
-<pre>
-&gt;&gt;&gt; hello.length(y)
-9
-</pre>
-      </blockquote>
-      <p>
-         Of course, you may now have a slightly empty feeling in the pit of
-        your little pythonic stomach. Perhaps you feel your subclass deserves
-        to have a <code>length()</code> of <code>12</code>? If so, <a href= 
-        "overriding.html">read on</a>...
-      <p>
-        Next: <a href="overriding.html">Overridable virtual functions</a>
+        Next: <a href="exporting_classes.html">Exporting Classes</a>
          Previous: <a href="comparisons.html">Comparisons with other systems</a>  Up:
         <a href="index.html">Top</a>
       <p>
@@ -125,6 +77,6 @@ extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID)
         express or implied warranty, and with no claim as to its suitability
         for any purpose.
       <p>
-         Updated: Nov 26, 2000
+         Updated: Mar 6, 2000
     </div>
 
diff --git a/doc/exporting_classes.html b/doc/exporting_classes.html
new file mode 100644
index 00000000..e5932e70
--- /dev/null
+++ b/doc/exporting_classes.html
@@ -0,0 +1,144 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+    <title>
+      Exporting Classes
+    </title>
+    <div>
+      <h1>
+         <img width="277" height="86" id="_x0000_i1025" src="../../../c++boost.gif" alt=
+        "c++boost.gif (8819 bytes)">
+      </h1>
+      <h1>
+         Exporting Classes
+      </h1>
+      <p>
+         Now let's expose a C++ class to Python:
+
+<blockquote><pre>
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class hello
+  {
+    public:
+      hello(const std::string&amp; country) { this-&gt;country = country; }
+      std::string greet() const { return "Hello from " + country; }
+    private:
+      std::string country;
+  };
+
+  // A function taking a hello object as an argument.
+  std::string invite(const hello&amp; w) {
+    return w.greet() + "! Please come soon!";
+  }
+}
+
+</blockquote></pre>      <p>
+      To expose the class, we use a <tt>class_builder</tt> in addition to the
+      <tt>module_builder</tt> from the previous example. Class member functions
+      are exposed by using the <tt>def()</tt> member function on the
+      <tt>class_builder</tt>:
+<blockquote><pre>
+#include &lt;boost/python/class_builder.hpp&gt;
+namespace python = boost::python;
+
+BOOST_PYTHON_MODULE_INIT(getting_started2)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("getting_started2");
+
+    // Create the Python type object for our extension class.
+    python::class_builder&lt;hello&gt; hello_class(this_module, "hello");
+
+    // Add the __init__ function.
+    hello_class.def(python::constructor&lt;std::string&gt;());
+    // Add a regular member function.
+    hello_class.def(&amp;hello::greet, "greet");
+
+    // Add invite() as a regular function to the module.
+    this_module.def(invite, "invite");
+
+    // Even better, invite() can also be made a member of hello_class!!!
+    hello_class.def(invite, "invite");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+</blockquote></pre>
+      <p>
+Now we can use the class normally from Python:
+
+<blockquote><pre>
+&gt;&gt;&gt; from getting_started2 import *
+&gt;&gt;&gt; hi = hello('California')
+&gt;&gt;&gt; hi.greet()
+'Hello from California'
+&gt;&gt;&gt; invite(hi)
+'Hello from California! Please come soon!'
+&gt;&gt;&gt; hi.invite()
+'Hello from California! Please come soon!'
+</blockquote></pre>
+
+Notes:<ul>
+<li> We expose the class' constructor by calling <tt>def()</tt> on the
+      <tt>class_builder</tt> with an argument whose type is
+      <tt>constructor&lt;</tt><i>params</i><tt>&gt;</tt>, where <i>params</i>
+      matches the list of constructor argument types:
+
+
+<li>Regular member functions are defined by calling <tt>def()</tt> with a
+      member function pointer and its Python name:
+
+<li>Any function added to a class whose initial argument matches the class (or
+any base) will act like a member function in Python.
+</ul>
+      <p>
+         We can even make a subclass of <code>hello.world</code>:
+
+<blockquote><pre>
+&gt;&gt;&gt; class wordy(hello):
+...     def greet(self):
+...         return hello.greet(self) + ', where the weather is fine'
+...
+&gt;&gt;&gt; hi2 = wordy('Florida')
+&gt;&gt;&gt; hi2.greet()
+'Hello from Florida, where the weather is fine'
+&gt;&gt;&gt; invite(hi2)
+'Hello from Florida! Please come soon!'
+</blockquote></pre>
+      <p>
+         Pretty cool! You can't do that with an ordinary Python extension type!
+
+         Of course, you may now have a slightly empty feeling in the pit of
+        your little pythonic stomach. Perhaps you wanted to see the following
+        <tt>wordy</tt> invitation:
+
+<blockquote><pre>
+'Hello from Florida, where the weather is fine! Please come soon!'
+</blockquote></pre>
+
+        After all, <tt>invite</tt> calls <tt>hello::greet()</tt>, and you
+        reimplemented that in your Python subclass, <tt>wordy</tt>. If so, <a
+        href= "overriding.html">read on</a>...
+
+      <p>
+        Next: <a href="overriding.html">Overridable virtual functions</a>
+         Previous: <a href="example1.html">A Simple Example</a>  Up:
+        <a href="index.html">Top</a>
+      <p>
+         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+        sell and distribute this document is granted provided this copyright
+        notice appears in all copies. This document is provided "as is" without
+        express or implied warranty, and with no claim as to its suitability
+        for any purpose.
+      <p>
+         Updated: Mar 6, 2001
+    </div>
+
diff --git a/doc/extending.html b/doc/extending.html
index c4a3a5e4..8839ab43 100644
--- a/doc/extending.html
+++ b/doc/extending.html
@@ -56,10 +56,10 @@
       sublcassing the extension type. Aside from being tedious, it's not really
       the same as having a true class, because there's no way for the user to
       override a method of the extension type which is called from the
-      extension module. BPL solves this problem by taking advantage of <a
+      extension module. Boost.Python solves this problem by taking advantage of <a
       href="http://www.python.org/doc/essays/metaclasses/">Python's metaclass
       feature</a> to provide objects which look, walk, and hiss almost exactly
-      like regular Python classes. BPL classes are actually cleaner than
+      like regular Python classes. Boost.Python classes are actually cleaner than
       Python classes in some subtle ways; a more detailed discussion will
       follow (someday).</p>
     <p>Next: <a href="comparisons.html">Comparisons with Other Systems</a> Up: <a
diff --git a/doc/index.html b/doc/index.html
index 4550be5c..5a64bf62 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -2,11 +2,11 @@
 "http://www.w3.org/TR/REC-html40/strict.dtd">
     <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
     <title>
-      The Boost Python Library (BPL)
+      The Boost Python Library (Boost.Python)
     </title>
     <h1>
        <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277"
-      align="center" height="86">The Boost Python Library (BPL)
+      align="center" height="86"><br>The Boost Python Library (Boost.Python)
     </h1>
 
 <h2>Synopsis</h2>
@@ -15,9 +15,9 @@
       href="http://www.python.org">Python</a> such that the Python interface is
       very similar to the C++ interface. It is designed to be minimally
       intrusive on your C++ design. In most cases, you should not have to alter
-      your C++ classes in any way in order to use them with BPL. The system
+      your C++ classes in any way in order to use them with Boost.Python. The system
       <em>should</em> simply ``reflect'' your C++ classes and functions into
-      Python. The major features of BPL include support for:
+      Python. The major features of Boost.Python include support for:
 <ul>
 <li><a href="inheritance.html">Subclassing extension types in Python</a>
 <li><a href="overriding.html">Overriding virtual functions in Python</a>
@@ -28,9 +28,27 @@ among others.
 
 
 <h2>Supported Platforms</h2>
-<p>BPL has been tested in the following configurations:
+<p>Boost.Python is known to have been tested in the following configurations:
 
 <ul>
+<li>Against Python 2.0 using the following compiler/library combinations:
+<ul>
+  <li><a
+  href="http://msdn.microsoft.com/vstudio/sp/vs6sp4/dnldoverview.asp">MSVC++6sp4</a>
+  with the native library.
+
+  <li>An upcoming release of <a
+        href="http://www.metrowerks.com/products/windows/">Metrowerks
+        CodeWarrior Pro6 for Windows</a> with the native library (the first
+        release has a bug that's fatal to Boost.Python)
+
+        <li><a
+        href="http://developer.intel.com/software/products/compilers/c50/">Intel
+        C++ 5.0</a>. Compilation succeeds, but tests <font
+        color="#FF0000"><b>FAILED at runtime</b></font> due to a bug in its
+        exception-handling implementation.
+</ul>
+
 <li>Against Python 1.5.2 using the following compiler/library: 
 
   <ul>
@@ -52,24 +70,17 @@ among others.
   href="mailto:rwgk@cci.lbl.gov">Ralf W. Grosse-Kunstleve</a>] 
 
   <li>An upcoming release of <a href="http://www.metrowerks.com/products/windows/">Metrowerks CodeWarrior
-        Pro6 for Windows</a> (the first release has a bug that's fatal to BPL)
+        Pro6 for Windows</a> (the first release has a bug that's fatal to Boost.Python)
   </ul>
-<br>
-<li>Against Python 2.0 using the following compiler/library combinations:
-<ul>
-  <li><a
-  href="http://msdn.microsoft.com/vstudio/sp/vs6sp4/dnldoverview.asp">MSVC++6sp4</a> [by
-  <a href="mailto:aleaxit@yahoo.com">Alex Martelli</a>]
-</ul>
 </ul>
 
 <h2>Credits</h2>
 <ul>
       <li><a href="../../../people/dave_abrahams.htm">David Abrahams</a> originated
-      and wrote the library.
+      and wrote most of the library, and continues to coordinate development.
 
       <li><a href="mailto:koethe@informatik.uni-hamburg.de">Ullrich Koethe</a>
-      had independently developed a similar system. When he discovered BPL,
+      had independently developed a similar system. When he discovered Boost.Python,
       he generously contributed countless hours of coding and much insight into
       improving it. He is responsible for an early version of the support for <a
       href="overloading.html">function overloading</a> and wrote the support for
@@ -78,16 +89,22 @@ among others.
       Python and C++, and has designed an extremely easy-to-use way of 
       exposing <a href="special.html#numeric">numeric operators</a>, including
       a way to avoid explicit coercion by means of overloading.
+      
+      <li><a href="http://cci.lbl.gov/staff/ralf_grosse-kunstleve.html">Ralf W.
+      Grosse-Kunstleve</a> contributed <a href="pickle.html">pickle support</a>
+      and numerous other small improvements. He's working on a way to allow
+      types exported by multiple modules to interact.
 
       <li>The members of the boost mailing list and the Python community
       supplied invaluable early feedback. In particular, Ron Clarke, Mark Evans,
-      Anton Gluck, Ralf W. Grosse-Kunstleve, Chuck Ingold, Prabhu Ramachandran,
-      and Barry Scott took the brave step of trying to use BPL while it was
-      still in early stages of development.
+      Anton Gluck, Chuck Ingold, Prabhu Ramachandran,n and Barry Scott took the
+      brave step of trying to use Boost.Python while it was still in early
+      stages of development.
 
-      <li>The development of BPL wouldn't have been
-      possible without the generous support of <a href="http://www.dragonsys.com/">Dragon Systems/Lernout and
-      Hauspie, Inc</a> who supported its development as an open-source project.
+      <li>The development of Boost.Python wouldn't have been possible without
+      the generous support of <a href="http://www.dragonsys.com/">Dragon
+      Systems/Lernout and Hauspie, Inc</a> who supported its development as an
+      open-source project.
 </ul>
 
     <h2>Table of Contents</h2>
@@ -96,11 +113,13 @@ among others.
       <li><a href="extending.html">A Brief Introduction to writing Python
         extension modules</a>
 
-      <li><a href="comparisons.html">Comparisons between BPL and other
+      <li><a href="comparisons.html">Comparisons between Boost.Python and other
         systems for extending Python</a>
 
       <li><a href="example1.html">A Simple Example</a>
 
+      <li><a href="exporting_classes.html">Exporting Classes</a>
+
       <li><a href="overriding.html">Overridable Virtual Functions</a>
 
       <li><a href="overloading.html">Function Overloading</a>
@@ -113,33 +132,19 @@ among others.
 
       <li><a href="building.html">Building an Extension Module</a>
 
-      <li>Advanced Topics
+      <li><a href="pickle.html">Pickle Support</a>
 
-        <ol>
-          <li><a href="pickle.html">Pickle Support</a>
+      <li><a href="enums.html">Wrapping Enums</a>
 
-          <li>class_builder&lt;&gt;
+      <li><a href="pointers.html">Pointers and Smart Pointers</a>
 
-          <li><a href="enums.html">enums</a>
-
-          <li>References
-
-          <li><a href="pointers.html">Pointers and Smart Pointers</a>
-
-          <li>Built-in Python Types
-
-          <li>Other Extension Types
-
-          <li>Templates
-          
-          <li><a href="data_structures.txt">Internal Data Structures</a>
-        </ol>
+      <li><a href="data_structures.txt">Internal Data Structures</a>
           
 </ol>  
  
     <p>
       Documentation is a major ongoing project; assistance is greatly
-      appreciated! In the meantime, useful examples of every BPL feature should
+      appreciated! In the meantime, useful examples of every Boost.Python feature should
       be evident in the regression test files <code>test/comprehensive.[<a
       href="../test/comprehensive.py">py</a>/<a
       href="../test/comprehensive.hpp">hpp</a>/<a
@@ -150,11 +155,11 @@ among others.
       "http://www.egroups.com/list/boost">the boost mailing list</a>.
 
     <p>
-       &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+       &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
       sell and distribute this document is granted provided this copyright
       notice appears in all copies. This document is provided ``as is'' without
       express or implied warranty, and with no claim as to its suitability for
       any purpose.
     <p>
-       Updated: Nov 26, 2000
+       Updated: Mar 6, 2001
 
diff --git a/doc/inheritance.html b/doc/inheritance.html
index d11899c8..cd95c744 100644
--- a/doc/inheritance.html
+++ b/doc/inheritance.html
@@ -12,10 +12,10 @@
 <h2>Inheritance in Python</h2>
 
       <p>
-         BPL extension classes support single and multiple-inheritance in
+         Boost.Python extension classes support single and multiple-inheritance in
          Python, just like regular Python classes. You can arbitrarily mix
          built-in Python classes with extension classes in a derived class'
-         tuple of bases. Whenever a BPL extension class is among the bases for a
+         tuple of bases. Whenever a Boost.Python extension class is among the bases for a
          new class in Python, the result is an extension class:
 <blockquote>
 <pre>
@@ -37,7 +37,7 @@
 
 <h2><a name="implicit_conversion">Reflecting C++ Inheritance Relationships</a></h2>
       <p>
-        BPL also allows us to represent C++ inheritance relationships so that
+        Boost.Python also allows us to represent C++ inheritance relationships so that
         wrapped derived classes may be passed where values, pointers, or
         references to a base class are expected as arguments. The
         <code>declare_base</code> member function of
@@ -76,11 +76,7 @@ int get_derived_x(const Derived& d) {
 // namespace alias for code brevity
 namespace python = boost::python;
 
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void initmy_module()
+BOOST_PYTHON_MODULE_INIT(my_module)
 {
     try
     {
@@ -115,11 +111,19 @@ void initmy_module()
 &gt;&gt;&gt; derived = Derived()
 &gt;&gt;&gt; get_name(base)
 'Base'
-</pre><i>objects of wrapped class Derived may be passed where Base is expected</i><pre>
+</pre>
+</blockquote>
+<i>objects of wrapped class Derived may be passed where Base is expected</i>
+<blockquote>
+<pre>
 &gt;&gt;&gt; get_name(derived) 
 'Derived'
-</pre><i>objects of wrapped class Derived can be passed where Derived is 
-expected but where type information has been lost.</i><pre>
+</pre>
+</blockquote>
+<i>objects of wrapped class Derived can be passed where Derived is 
+expected but where type information has been lost.</i>
+<blockquote>
+<pre>
 &gt;&gt;&gt; get_derived_x(derived_as_base()) 
 -1
 </pre>
diff --git a/doc/overloading.html b/doc/overloading.html
index 6979efd0..242e023f 100644
--- a/doc/overloading.html
+++ b/doc/overloading.html
@@ -29,7 +29,7 @@ private:
 };
   ...
 
-void initoverload_demo()
+BOOST_PYTHON_MODULE_INIT(overload_demo)
 {
     try
     {
@@ -144,12 +144,12 @@ namespace scope as Python member functions.
          Previous: <a href="overriding.html">Overridable Virtual Functions</a>
          Up: <a href="index.html">Top</a>
       <p>
-         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+         &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
         sell and distribute this document is granted provided this copyright
         notice appears in all copies. This document is provided ``as
         is'' without express or implied warranty, and with no claim as to
         its suitability for any purpose.
       <p>
-         Updated: Nov 26, 2000
+         Updated: Mar 6, 2001
     </div>
 
diff --git a/doc/overriding.html b/doc/overriding.html
index ae629580..7b28add1 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -9,7 +9,7 @@
     <h1>Overridable Virtual Functions</h1>
 
 <p> 
-  In the <a href="example1.html">previous example</a> we exposed a simple
+  In the <a href="exporting_classes.html">previous example</a> we exposed a simple
   C++ class in Python and showed that we could write a subclass. We even
   redefined one of the functions in our derived class. Now we will learn
   how to make the function behave virtually <em>when called from C++</em>. 
@@ -17,16 +17,17 @@
 
 <h2><a name="overriding_example">Example</a></h2>
 
-<p>In this example, it is assumed that <code>world::greet()</code> is a virtual
+<p>In this example, it is assumed that <code>hello::greet()</code> is a virtual
 member function:
 
 <blockquote><pre>
-class world
+class hello
 {
  public:
-    world(int);
-    virtual ~world();
-    <b>virtual</b> std::string greet() const { return "hi, world"; }
+    hello(const std::string&amp; country) { this-&gt;country = country; }
+    <b>virtual</b> std::string greet() const { return "Hello from " + country; }
+    virtual ~hello(); // Good practice 
+    ...
 };
 </pre></blockquote>
 
@@ -37,21 +38,28 @@ class world
 
 <ol>
 
-  <li><a name="derived_1">A</a> <code>PyObject*</code> data member that holds a
-  reference to the corresponding Python object.
+  <li><a name="derived_1">A</a> <code>PyObject*</code> data member (usually
+  called <tt>self</tt>) that holds a pointer to the Python object corresponding
+  to our C++ <tt>hello</tt> instance.
 
-  <li><a name="derived_2">A</a> constructor for each exposed constructor of the
-  base class which stores an additional initial <code>PyObject*</code> argument
-  in the data member described above.
+  <li><a name="derived_2">For</a>  each exposed constructor of the
+  base class <tt>T</tt>, a constructor which takes the same parameters preceded by an initial
+  <code>PyObject*</code> argument. The initial argument should be stored in the <tt>self</tt> data
+  member described above. 
+
+  <li>If the class being wrapped is ever returned <i>by
+  value</i> from a wrapped function, be sure you do the same for the
+  <tt>T</tt>'s copy constructor: you'll need a constructor taking arguments
+  <tt>(PyObject*,&nbsp;const&nbsp;T&amp;)</tt>.
 
   <li><a name="derived_3">An</a> implementation of each virtual function you may
   wish to override in Python which uses
-  <code>boost::python::callback&lt<i>return-type</i>&gt;::call_method()</code> to call
+  <tt>callback&lt</tt><i>return-type</i><tt>&gt;::call_method(self,&nbsp;&quot;</tt><i>name</i><tt>&quot;,&nbsp;</tt><i>args...</i><tt>)</tt> to call
   the Python override.
 
   <li><a name="derived_4">For</a> each non-pure virtual function meant to be
   overridable from Python, a static member function (or a free function) taking
-  a reference or pointer to the base type as the first parameter and which
+  a reference or pointer to the <tt>T</tt> as the first parameter and which
   forwards any additional parameters neccessary to the <i>default</i>
   implementation of the virtual function. See also <a href="#private">this
   note</a> if the base class virtual function is private.
@@ -59,52 +67,60 @@ class world
 </ol>
 
 <blockquote><pre>
-struct world_callback : world
+struct hello_callback : hello
 {
-    world_callback(PyObject* self, int x) // <a href="#derived_2">2</a>
-        : world(x),
-          m_self(self) {}
+    // hello constructor storing initial self_ parameter
+    hello_callback(PyObject* self_, const std::string&amp; x) // <a href="#derived_2">2</a>
+        : hello(x), self(self_) {}
 
-    std::string greet() const // <a href="#derived_3">3</a>
-        { return boost::python::callback&lt;std::string&gt;::call_method(m_self, "get"); }
+    // In case hello is returned by-value from a wrapped function
+    hello_callback(PyObject* self_, const hello&amp; x) // <a href="#derived_3">3</a>
+        : hello(x), self(self_) {}
 
-    static std::string <a name= "default_implementation">default_get</a>(const hello::world& self) const // <a href="#derived_4">4</a>
-        { return self.world::greet(); }
+    // Override greet to call back into Python
+    std::string greet() const // <a href="#derived_4">4</a>
+        { return boost::python::callback&lt;std::string&gt;::call_method(m_self, "greet"); }
+
+    // Supplies the default implementation of greet
+    static std::string <a name= "default_implementation">default_greet</a>(const hello& self) const // <a href="#derived_5">5</a>
+        { return self.hello::greet(); }
  private:
     PyObject* m_self; // <a href="#derived_1">1</a>
 };
 </pre></blockquote>
 
 <p>
-  Finally, we add <code>world_callback</code> to the <code>
-  class_builder&lt;&gt;</code> declaration in our module initialization
+  Finally, we add <tt>hello_callback</tt> to the <tt>
+  class_builder&lt;&gt;</tt> declaration in our module initialization
   function, and when we define the function, we must tell py_cpp about the default
   implementation:
 
 <blockquote><pre>
 // Create the <a name=
-"world_class">Python type object</a> for our extension class
-boost::python::class_builder&lt;hello::world<strong>,world_callback&gt;</strong> world_class(hello, "world");
+"hello_class">Python type object</a> for our extension class
+boost::python::class_builder&lt;hello<strong>,hello_callback&gt;</strong> hello_class(hello, "hello");
 // Add a virtual member function
-world_class.def(&amp;world::get, "get", &amp;<b>world_callback::default_get</b>);
+hello_class.def(&amp;hello::greet, "greet", &amp;<b>hello_callback::default_greet</b>);
 </pre></blockquote>
 
 <p>
- Now our subclass of <code>hello.world</code> behaves as expected:
+ Now our Python subclass of <tt>hello</tt> behaves as expected:
 
 <blockquote><pre>
-&gt;&gt;&gt; class my_subclass(hello.world):
+&gt;&gt;&gt; class wordy(hello):
 ...     def greet(self):
-...         return 'hello, world'
+...         return hello.greet(self) + ', where the weather is fine'
 ...
-&gt;&gt;&gt; hello.length(my_subclass())
-12
+&gt;&gt;&gt; hi2 = wordy('Florida')
+&gt;&gt;&gt; hi2.greet()
+'Hello from Florida, where the weather is fine'
+&gt;&gt;&gt; invite(hi2)
+'Hello from Florida, where the weather is fine! Please come soon!'
 </pre></blockquote>
-
     <p>
       <a name="why_derived">*</a>You may ask, "Why do we need this derived
       class? This could have been designed so that everything gets done right
-      inside of <code>hello::world</code>." One of the goals of py_cpp is to be
+      inside of <tt>hello</tt>." One of the goals of py_cpp is to be
       minimally intrusive on an existing C++ design. In principle, it should be
       possible to expose the interface for a 3rd party library without changing
       it. To unintrusively hook into the virtual functions so that a Python
@@ -117,10 +133,10 @@ world_class.def(&amp;world::get, "get", &amp;<b>world_callback::default_get</b>)
       deal with than a virtual function with a default implementation. First of
       all, you obviously don't need to <a href="#default_implementation"> supply
       a default implementation</a>. Secondly, you don't need to call
-      <code>def()</code> on the <code>extension_class&lt;&gt;</code> instance
+      <tt>def()</tt> on the <tt>extension_class&lt;&gt;</tt> instance
       for the virtual function. In fact, you wouldn't <em>want</em> to: if the
       corresponding attribute on the Python class stays undefined, you'll get an
-      <code>AttributeError</code> in Python when you try to call the function,
+      <tt>AttributeError</tt> in Python when you try to call the function,
       indicating that it should have been implemented. For example:
     <blockquote>
 <pre>
@@ -132,11 +148,7 @@ struct baz_callback {
     int pure(int x) { boost::python::callback&lt;int&gt;::call_method(m_self, "pure", x); }
 };
 
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-initfoobar()
+BOOST_PYTHON_MODULE_INIT(foobar)
 {
     try
     {
@@ -182,14 +194,14 @@ href="http://cs.calvin.edu/c++/C++Standard-Nov97/basic.html#basic.def.odr">ODR</
 
     <p>
       Next: <a href="overloading.html">Function Overloading</a>
-      Previous: <a href="example1.html">A Simple Example Using py_cpp</a>
+      Previous: <a href="exporting_classes.html">Exporting Classes</a>
       Up: <a href="index.html">Top</a>
     <p>
-      &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
+      &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,
       sell and distribute this document is granted provided this copyright
       notice appears in all copies. This document is provided "as is" without
       express or implied warranty, and with no claim as to its suitability for
       any purpose.
     <p>
-      Updated: Nov 26, 2000
+      Updated: Mar 6, 2001
 
diff --git a/doc/pickle.html b/doc/pickle.html
index 0e64d6fc..7b559e68 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -1,6 +1,6 @@
 <html>
 <head>
- <title>BPL Pickle Support</title>
+ <title>Boost.Python Pickle Support</title>
 </head>
 <body>
 
@@ -11,7 +11,7 @@
 
 </body>
 <hr>
-<h1>BPL Pickle Support</h1>
+<h1>Boost.Python Pickle Support</h1>
 
 Pickle is a Python module for object serialization, also known
 as persistence, marshalling, or flattening.
@@ -39,16 +39,16 @@ described in detail in the Python Library Reference for pickle:
 </blockquote>
 
 <hr>
-<h1>The BPL Pickle Interface</h1>
+<h1>The Boost.Python Pickle Interface</h1>
 
-At the user level, the BPL pickle interface involves three special
+At the user level, the Boost.Python pickle interface involves three special
 methods:
 
 <dl>
 <dt>
 <strong>__getinitargs__</strong>
 <dd>
-  When an instance of a BPL extension class is pickled, the pickler
+  When an instance of a Boost.Python extension class is pickled, the pickler
   tests if the instance has a __getinitargs__ method. This method must
   return a Python tuple. When the instance is restored by the
   unpickler, the contents of this tuple are used as the arguments for
@@ -63,7 +63,7 @@ methods:
 <strong>__getstate__</strong>
 
 <dd>
-  When an instance of a BPL extension class is pickled, the pickler
+  When an instance of a Boost.Python extension class is pickled, the pickler
   tests if the instance has a __getstate__ method. This method should
   return a Python object representing the state of the instance.
 
@@ -76,7 +76,7 @@ methods:
 <strong>__setstate__</strong>
 
 <dd>
-  When an instance of a BPL extension class is restored by the
+  When an instance of a Boost.Python extension class is restored by the
   unpickler, it is first constructed using the result of
   __getinitargs__ as arguments (see above). Subsequently the unpickler
   tests if the new instance has a __setstate__ method. If so, this
@@ -96,13 +96,13 @@ __setstate__ methods can do what they want.
 <hr>
 <h1>Pitfalls and Safety Guards</h1>
 
-In BPL extension modules with many extension classes, providing
+In Boost.Python extension modules with many extension classes, providing
 complete pickle support for all classes would be a significant
 overhead. In general complete pickle support should only be implemented
 for extension classes that will eventually be pickled. However, the
-author of a BPL extension module might not anticipate correctly which
+author of a Boost.Python extension module might not anticipate correctly which
 classes need support for pickle. Unfortunately, the pickle protocol
-described above has two important pitfalls that the end user of a BPL
+described above has two important pitfalls that the end user of a Boost.Python
 extension module might not be aware of:
 
 <dl>
@@ -116,10 +116,10 @@ Both __getinitargs__ and __getstate__ are not defined.
   that of the new instance.
 
   <p>
-  However, most C++ classes wrapped with the BPL will have member data
+  However, most C++ classes wrapped with Boost.Python will have member data
   that are not restored correctly by this procedure. To alert the user
   to this problem, a safety guard is provided. If both __getinitargs__
-  and __getstate__ are not defined, the BPL tests if the class has an
+  and __getstate__ are not defined, Boost.Python tests if the class has an
   attribute __dict_defines_state__. An exception is raised if this
   attribute is not defined:
 
@@ -151,7 +151,7 @@ Both __getinitargs__ and __getstate__ are not defined.
 __getstate__ is defined and the instance's __dict__ is not empty.
 
 <dd>
-  The author of a BPL extension class might provide a __getstate__
+  The author of a Boost.Python extension class might provide a __getstate__
   method without considering the possibilities that:
 
   <p>
@@ -170,7 +170,7 @@ __getstate__ is defined and the instance's __dict__ is not empty.
 
   To alert the user to this highly unobvious problem, a safety guard is
   provided. If __getstate__ is defined and the instance's __dict__ is
-  not empty, the BPL tests if the class has an attribute
+  not empty, Boost.Python tests if the class has an attribute
   __getstate_manages_dict__. An exception is raised if this attribute
   is not defined:
 
diff --git a/doc/pointers.html b/doc/pointers.html
index e26cea02..fdbee797 100644
--- a/doc/pointers.html
+++ b/doc/pointers.html
@@ -13,7 +13,7 @@
 
       <p>
 In general, raw pointers passed to or returned from functions are problematic
-for BPL because pointers have too many potential meanings. Is it an iterator?
+for Boost.Python because pointers have too many potential meanings. Is it an iterator?
 A pointer to a single element? An array? When used as a return value, is the
 caller expected to manage (delete) the pointed-to object or is the pointer
 really just a reference? If the latter, what happens to Python references to the
@@ -46,7 +46,7 @@ const Foo& f_wrapper() { return *f(); }
 my_module.def(f_wrapper, "f");
 </pre></blockquote>
 <p>
-Foo must have a public copy constructor for this technique to work, since BPL
+Foo must have a public copy constructor for this technique to work, since Boost.Python
 converts <code>const T&</code> values <code>to_python</code> by copying the <code>T</code>
 value into a new extension instance.
 
diff --git a/doc/special.html b/doc/special.html
index 50cee505..0caa1924 100644
--- a/doc/special.html
+++ b/doc/special.html
@@ -12,7 +12,7 @@
          Overview
       </h2>
       <p>
-         BPL supports all of the standard <a href=
+         Boost.Python supports all of the standard <a href=
         "http://www.python.org/doc/current/ref/specialnames.html">
         special method names</a> supported by real Python class instances <em>
         except</em> <code>__complex__</code> (more on the reasons <a href=
@@ -44,7 +44,7 @@
           
           <pre>    my_class.def(boost::python::constructor<...>())</pre> 
           
-          (see section <a href="example1.html">"A Simple Example Using BPL"</a>).<p>
+          (see section <a href="example1.html">"A Simple Example Using Boost.Python"</a>).<p>
         <dt>
           <b><tt class='method'>__del__</tt></b>(<i>self</i>)
         <dd>
@@ -104,7 +104,7 @@ std::string to_string(Foo const&amp; f)
 boost::python::class_builder&lt;Foo&gt; foo_class(my_module, "Foo");
 foo_class.def(&amp;to_string, "__str__");
 </pre></blockquote>
-      Note that BPL also supports <em>automatic wrapping</em> of
+      Note that Boost.Python also supports <em>automatic wrapping</em> of
       <code>__str__</code> and <code>__cmp__</code>. This is explained in the <a
       href="#numeric">next section</a> and the <a href="#numeric_table">Table of
       Automatically Wrapped Methods</a>.
@@ -117,7 +117,7 @@ foo_class.def(&amp;to_string, "__str__");
       href="http://www.python.org/doc/current/ref/numeric-types.html">numeric
       protocols</a>. This is the same basic technique used to expose
       <code>to_string()</code> as <code>__str__()</code> above, and is <a
-      href="#numeric_manual">covered in detail below</a>.  BPL also supports
+      href="#numeric_manual">covered in detail below</a>.  Boost.Python also supports
       <i>automatic wrapping</i> of numeric operators whenever they have already
       been defined in C++.
 
@@ -174,7 +174,7 @@ a = i + b;
 bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;(), boost::python::right_operand&lt;int&gt;());
 bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;(), boost::python::left_operand&lt;int&gt;());
 </pre></blockquote>
-      BPL uses overloading to register several variants of the same
+      Boost.Python uses overloading to register several variants of the same
       operation (more on this in the context of <a href="#coercion">
       coercion</a>). Again, several operators can be exported at once: 
 <blockquote><pre>
@@ -283,13 +283,13 @@ bignum_class.def(&amp;rmod,  "__rmod__");
       coercion functions can be difficult if many type combinations must be
       supported. 
       <p>
-        BPL solves this problem the same way that C++ does: with <em><a
+        Boost.Python solves this problem the same way that C++ does: with <em><a
         href="overloading.html">overloading</a></em>. This technique drastically
         simplifies the code neccessary to support operators: you just register
-        operators for all desired type combinations, and BPL automatically
+        operators for all desired type combinations, and Boost.Python automatically
         ensures that the correct function is called in each case; there is no
         need for user-defined coercion functions. To enable operator
-        overloading, BPL provides a standard coercion which is <em>implicitly
+        overloading, Boost.Python provides a standard coercion which is <em>implicitly
         registered</em> whenever automatic operator wrapping is used.
       <p>
         If you wrap all operator functions manually, but still want to use
@@ -370,7 +370,7 @@ bignum_class.def((ternary_function2)&amp;power,  "__pow__");
 
       In the second variant, however, <code>BigNum</code> appears only as second
       argument, and in the last one it's the third argument. These functions
-      must be presented to BPL such that that the <code>BigNum</code>
+      must be presented to Boost.Python such that that the <code>BigNum</code>
       argument appears in first position:
 
 <blockquote><pre>
@@ -397,7 +397,7 @@ Note that "__rrpow__" is an extension not present in plain Python.
 
 <h2><a name="numeric_table">Table of Automatically Wrapped Methods</a></h2>
       <p>
-         BPL can automatically wrap the following <a href=
+         Boost.Python can automatically wrap the following <a href=
          "http://www.python.org/doc/current/ref/specialnames.html">
          special methods</a>:
 
@@ -772,13 +772,13 @@ KeyError: 2
 <h2><a name="getter_setter">Customized Attribute Access</a></h2>
 
       <p>
-        Just like built-in Python classes, BPL extension classes support <a
+        Just like built-in Python classes, Boost.Python extension classes support <a
         href="http://www.python.org/doc/current/ref/attribute-access.html">special
         the usual attribute access methods</a> <code>__getattr__</code>,
         <code>__setattr__</code>, and <code>__delattr__</code>.
         Because writing these functions can
         be tedious in the common case where the attributes being accessed are
-        known statically, BPL checks the special names
+        known statically, Boost.Python checks the special names
 
       <ul>
         <li>
@@ -794,7 +794,7 @@ KeyError: 2
       following shows how we can implement a ``computed attribute'' in Python: 
       <blockquote>
 <pre>
-&gt;&gt;&gt; class Range(AnyBPLExtensionClass):
+&gt;&gt;&gt; class Range(AnyBoost.PythonExtensionClass):
 ...    def __init__(self, start, end):
 ...        self.start = start
 ...        self.end = end
@@ -810,7 +810,7 @@ KeyError: 2
          Direct Access to Data Members
       </h4>
       <p>
-         BPL uses the special <code>
+         Boost.Python uses the special <code>
         __xxxattr__<em>&lt;name&gt;</em>__</code> functionality described above
         to allow direct access to data members through the following special
         functions on <code>class_builder&lt;&gt;</code> and <code>
diff --git a/doc/under-the-hood.html b/doc/under-the-hood.html
index 902804d3..733f0f54 100644
--- a/doc/under-the-hood.html
+++ b/doc/under-the-hood.html
@@ -22,7 +22,7 @@
       "example1.html#add_world_class">add it to the module</a> it goes into the
       module's dictionary to be looked up under the name "world".
     <p>
-      BPL uses C++'s template argument deduction mechanism to determine the
+      Boost.Python uses C++'s template argument deduction mechanism to determine the
       types of arguments to functions (except constructors, for which we must
       <a href="example1.html#Constructor_example">provide an argument list</a>
       because they can't be named in C++). Then, it calls the appropriate
@@ -48,7 +48,7 @@
       the top of your module's init function, then <code>def</code> the member
       functions later to avoid problems with inter-class dependencies.
     <p>
-      Next: <a href="building.html">Building a Module with BPL</a>
+      Next: <a href="building.html">Building a Module with Boost.Python</a>
       Previous: <a href="special.html">Special Method and Operator Support</a>
       Up: <a href="index.html">Top</a>
     <p>

From 00cea4ff83e2d64c3273fab652171cf4ca192a88 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 03:40:47 +0000
Subject: [PATCH 044/369] Added getting_started targets

[SVN r9471]
---
 build/build.dsw |  34 ++++++++++++++++++++++++++++++++++
 build/build.opt | Bin 86528 -> 116224 bytes
 2 files changed, 34 insertions(+)

diff --git a/build/build.dsw b/build/build.dsw
index f4ee1a11..8de38493 100644
--- a/build/build.dsw
+++ b/build/build.dsw
@@ -30,6 +30,40 @@ Package=<4>
 
 ###############################################################################
 
+Project: "getting_started1"=.\getting_started1\getting_started1.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name bpl_static
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "getting_started2"=.\getting_started2\getting_started2.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+    begin source code control
+    getting_started2
+    .\getting_started2
+    end source code control
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name bpl_static
+    End Project Dependency
+}}}
+
+###############################################################################
+
 Project: "rwgk1"=.\rwgk1\rwgk1.dsp - Package Owner=<4>
 
 Package=<5>
diff --git a/build/build.opt b/build/build.opt
index 5086795feff7997de1d0b50d82b2404da330c819..89eb84a706504d37bff9685be4808fda8baf9b81 100644
GIT binary patch
literal 116224
zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;!F$-42&?o00YCn|NsAkxG);Tu3}(d_&*AU
zObGn_|Np-N0|Nsy0|NsK0|Nsq0|PkD*%=rZI2afhI2jlixEL51xEUbv&C9^Rz{kMA
zz|X+IAi%)DAjrVLAjH7HAk4tPAi}`FAPQ9{&cMJR!N9;E$-uxM#lXNI&A`AQ!@$5G
z%fP@O$H2fK4^<b*z`&ryz`&r)z`&rwz`&r&z`&r!z`&r+z`&rvz`&r%z`&pdRjb3m
zz@W>(z@W##z@X2-z+k|@z+lM0z+l9{z+lY4z+eJZXU4$5V9vn6V8Ot^V9CJ1V8y_|
zV9mh5V8g(`V9UV3V8_6~V9&t7;K0DZ;K;zh;Kabd;LO0l;KIPb;L5<j;Ksnf;LgCn
z;K9Ja;K{(i;Kjhe;LX6m-~%<^kAZ=~pMilPfPsM_kb!|Ah=GA2n1O*Ign@w}l!1XE
zjDdk6oPmKM0;+yB0|P@e0|P@00|P@W0|P@G0|P@m0|P?>0|P@M0|P@60|P@c0|P?}
z0|P@UR8Kks149M_14AYQ149-A14A|g149l214AwY14AAI14BLo1497=14AJL149u5
z14A(b149V|14AhT149`D14B6j149J^14AX$JWxE>FfcIGGB7aIF)%RHGcYhTfZd+Y
zkk3%UpuphDkjGHMPz2Ti%E`oGF$Pw6en&1Vu<EY;v2E9~1B}S!ML0t~LlHwZLoq`E
zLn1>mLn?y;Loh=LLn1>7I4rQ5gCwZHz{Cj3Y@l=rqLHL<GC}1SII)7`zK9{8p`4+Z
zAr%~sI5pvr5MW?p1mzu2ULn?g9*|j}%mPktDGZqmCE!p136qNX7?>DA=7H=6VPf=)
zffPaQXJlXn=XaKp)Z!8iXRDZ`{QTmQn4HX{;+TTUl8pSkn55FooRk=lJebf+DJ}rj
z0$fQ2Iq}6Mi6xoInt1dfRKYZ|7L})G8*1Uv16B|NCSjU5QY#X33vyBo4e;oLsfmFx
zV7dj;Q%g!R^U^`?Eh<S(F?7IV3cA`DbOBtZ8j)bC5xS{HFjE;AKxOYJ9u0@#o(4e0
z&?p``A;21vn54sa9$aG;>~hEf)gs8gN9V)j%%dNInlmsioPNPx3)WJQ+6AUT64>g%
zhO5T{Kng$@)W!v=gEoJlOb7*%2eF_us3{C?+nhan_AHV(xS>X@`$0V<P`eI<IdmLB
zO*jUP<}(cc|0foKXhsG`1|Ek0|2xVjGBGerWn^HOz|6q#l@V+SxTOrUnTdg+0pz<#
zCP)kVf=C79|No2(91PAb`N`Sgc`1wximVI`zyANPXJYvO|M&m@phg}8$OWJ__+ut;
zgAZgJxNZC&Di0C3pgM<9xdGfVYWVyAe?23^|NsB~|F4JW2B~QVwX?t`f_MxJ5oa10
zl^d8rJwmt+P^cnwsG{lMh&s=p+yIUNunuTX5y{NaGJm+2`GdiKkn}rBj+77pmFGH)
z^B6%rC1T5MP}tzAcV;w~fsAC>v3wSo2B`&=%pe*WlUeV8jX*XJZV9N*Ph`CbD}_ON
zQR^KBaQy=k2Vsz9Ao?<hfrLR~ATEf$0%9OxkQj&yqOXD&NEjpr;)3XFAO;c!iGjEv
z`Z|b#gh65;E{MJXVjy9V7>Em^Z-N*|7$gSbg6LZy1`-B|fw&<0Hi&_QL1G{-h`s}2
zAYqUghzp|cf*42`BnIMw=zAar5(bHZxFGsIh=GJbVjwPz2C-rIO~wJxP!gC68V9?f
z!o>p`QveGvFff2?Wyo+1Ob9&Q2H|jkYG4SHfq~%%!*50=1|Eh3&#y8V{6mED1gOQ#
zOpJy;rOBBoi3-m7dBypk7#NvAtp%9+?~DJGUl8D`1&t|y#{Q7q0V}&<W`V}9Kv?d-
zJZK0JH0%a;3ryW8J=&fbO#_2F4S?J4Y~W#kP!|P+BbXQ%Kv^6#tPd+!bfCotXowf2
z284x~85p)h#bN6HK>46XK1dA+!_0%J0nsNI7#OBOryW3QK==$31A_*%tOKb5VVF9Q
zu^=@djLSTbdXRRI8W6^(4x|=jCbp4I^x;1Akvc=zNFDm9;^_F_;7;qKWzpb@A5bP7
z#Um#KM#uj~$Nxsh{{~kXJQC}~kyGN1`V<rbpoaeF_#b544>T?anRi00<pYJ!==dKf
zr9dz!JU}cEJv#me3JC~?)fJ$@0gwo2><@%T$Nxs_bXeLLrH58p;9y{8@b&TXVPfD6
zNi8mME-flcRdlh6DK1KmNh~fXOEv>hp(U9)Fj_CUpkOO#xg%)hZ$N5MT7FS(VqS8p
zf{{W%eo+Zw&AQMzh0*ap<Ryut>;FdAJu(cfvV+pH9@K^y#Um#KM#uj~$Nxsh|3+3B
zPiY-N3;iRf#2xi1C<H*`IHTi#qvL;|v;f1PGy!6R=+X6m|NoD!{~N8BX;IgXnmM@B
z6}J7?;S8A!c?>DwebJyY5+7D#U}6N7p`bGYkk_o^)1wHIgzi5MX2@qKWhesg{ElaE
zX2^%`LeFQ&VTfn&WXNMk1MhVQX~Bjy7(lC+K{i7$HZ|yC+8_a_{hkZ~44w?}3`q<H
zU>l2}d(Sh$JMuva@nbm#CPvVrL(qapkPGmuhRB+NDA3^r;PV9__NOvbFeEbMf?bgc
zKGguEh%lCd?tcf_4Z?(VFfjOn6oC$B058B~Wx!a+$myJuSX>;InOe?j<LVz|hfMN-
zHi9c8gA}9|LnL^?JGD{8INUOGQV}M|hvye%7Z)TZrz)s}_mitzDVQk~6y;~7CYNXw
zYYHH?i7TXK=A;($1m~9)C8sKYj49@W?dOKbiJ`5~G=d0oL!1HD&INWQm<e$s4n0Ij
zqPPU29zvpdF*Rj${pa8=>qhIM!4*HCVrUePoDdit{~aCw9UcE2TxIY`tP@90i9703
zPzZqfr=#P)qvOAzv;f1PGy!6R=+W`t(edArSPzc+d9*F&I0tg(E5;b0b~5g>AkoL)
z7)Vi!VUvJOUVe!}a(-S(QGQNNYKol*HmeyJz(-UPs~B>~B(bXDr%PgJ;DEV>fdT2j
zOYo@Z==k3VTdz1;UQ)Nb1hv0L@yH2*(ec00@xRgWKkAmDqjeJL;W=_j+)<x`LI5<z
zGdlh^I{pVr3or~y6CgH-9v%N19se7xM@g?oN5gFBhgrfa$T=W#NDJ_E6~Z&~jExjr
zQj<#41HhNS@FAojryp`KI0ryh?-9@`h0v)0GdL(UCpED+6|`=W5p)R=_=MY6te~<O
zB=#H30+r4ZSTuuO1yY7zD*<N_Hh_&oBskb9h=GxTo549Gu_!&Y#Iqzd7mt7Nx)>x$
zz)c_}P+L(J9WpX-K|<TTD8IA-s)Ch6#KkL|$0Ic{CAA2$OcIYe=9JU|Mg|cEXP4B1
z)V!3`yyQyf{JfIH%)HbhsDbQh<tcg@1qF-@{K(2c3oxN7crr^;ixNxni|{MsEh#O?
zNzG3JE$!6Hz-=6Nab<CCeoARhDn3<Q$@zI{nd$hg<bYgNgwGtI{G|Bg#GIV?lA^@S
zl4AVkaTQdi78T_e72`9JH!UYWv4pTcIrEdUGII-Z@R|i)P)pb>?$VOXoXnC+{Lbeo
zNGwUt$Vn|r#cL@~PG&I??&nP|BP!6iGxJJ{k~311v+?;<G_feNBqKMqBr};PQ#lJN
zL6=P7O(Xot`JlU@DhP)k4`@j+VP%{Jl_{XY51&UkU<ng<3g=15OeP|LIWlt#@{3CF
zS;mu_pHf^}Ku8&TW^yY2q`{d?*!TRUd6~)iDMVypj)F=;P7(pdO@47^Nh(p%&0Cb1
zmrjJue7UJ58Tl!MJ;RllR9sS&n2a}gxj`yYlM)Fe-Q@hdvecsD%=|o}{K8jUQk0pO
zPS}m?1(j(9cvCoga%x#3-ptIIlvtcvQk;S>6|omo=BDQ2Q^8xDlbK9Z@Pi9(!d?Rv
z3WQbhC6%V7r4|uZ$eUjPse%X;;Jn4TiA5#x1tkRPDsD){QB<0TFH|@PJB**`x`ihv
zpO`eklUABXL|)}cPAo3LpXE79DnW@0U(L=BQbJUk7AYx8%qs?+`9qxY#GK6Zyxi2h
z5~7sz7boTtS58QxyCc51AT=3(KnOyjktmlynpZ?Ln}|)3#HBRilM&&(OjIL=$Ye%j
z(~ro82X$MB#8+1&wE+pYhe@p3h$uyfZBp_Q*<2*1jY4E2kk|s1s74?W?Gz%KeMC0q
zh;JPd(^98<n@*I(RtGUHJfb>P#5975>yHfPMjdet6jFOF#P*r!+C(I_aYsa}p2$WF
zAEbW|sdw?Uu!w2B65U87Vl;p{%_edhA;dSeNNKJR-*6Hktwly+dynX56Om;%kwX+j
zb@GU)e~Ij76Wit^wiF<~h9cZkB(i=Yrj{VN&?B;qKvXqL+*l*welc-fdtw`|)E=E6
zrj8}tSR$@(K|=8ly7wJlaZOycPkh6i=xUJY3Wad%ow(s=B3jVIwIGP>Xc1k>k=XeF
zIg;?;ED<$7alK07#yE)W#t_?IB)<1dR0EiZaamFu=Y)Ih#Ef?n(^?{_uS;ydlRC{N
z;u|Z(H<n0j){xS+BC!cXPNNXgY(geMbAh9HGz3ONU^E0qLtr!nMnhmU1V%$(Gz3ON
zU^E0qLtr!nMnhmU1V%$(Gz2IO0oeL~8Tb*qutoadb@q_e|2!~B^tJzZbxFW<;a>O8
z#=yYvhLs&@KLBJG07(1=t5mX8Oi6xzPH_xml^&GRORY!+DR{{`SvONbH(5amvVK+}
zBQ+-{-&z66%P+Q8$S>AQ&Pd5D(ooma(}y6?!NBU8a8)V!$siFlrBIh6sRJpBhYA~7
zE1+=oic0e|qSbZF)MGW3KpP8w!#6O9!L-1`0356!MUd?aAdkFZWd)0Z*hARYkf;NB
z4dH*h2?V4R5(*#|L^~)924}>AT=s%h13gWGE=mk=b}G%xNr9%%_!L+QeZ$HPj#x-8
z0(lY<GSEF0=-W$hW*SgN$B~*qQg{OzqyTCkwKtaV1*H}voz#tI3kuTlIgAWKkPR)V
z$t8#lDNq*@vE~voP)>b?5OX2q==y&mmVpy7Ur6FS<zQYaM(SiA(X-lwS9K6x=RnMy
zAmQ0ZV%G=|Jr56>cP702i|AQzqF3G!xfF%Cl@mm)93p<|naHJcM6MU0(v0lr`hU=t
zNTj`vkV=4vDu&n;NnA=JJ{b|t%fzkJAa0w<==y)ywppY!LSofML@7e-It*eL&JeMB
ziO3a}L~p1XUH=c>HcrIaAtD!>lG^GZW@RU0`O|p@MkZ!P9)>Uf|NjSd6JU4(Xfr<O
zejp}BL!Z**%#=h0=ls0l{G3#Va?m|PE?<Qh9xVP-{(bSEaz1XZUpx#944feKFawaz
zhJ=}wz`(!&!gBxR6&M&8%s@&(){LGbG4#)o7>&cxI3za>fXabUJhDQ-kl_LoGsw%#
z`V0&p3}TOBx`zPl{=*`Ma)xw<Y!YrBgg8}%feBpigYrJ8T>ufqPey^Hq4y8M>@Q(R
zWdPm12$CWN3o$S;@-Z+l@G~$l5Nm%L$N~)z!N35sKb;|!p@g9XeDh^GLp<0mi3~*y
zAa|wU2^B2{CPr2U1_o{t?5_q{Z37~RwciM$7z?RI#{HKwLFTA{2nGh&{EsB$@<c3?
zKb&A0^qC*r>P5lo;qx8j&h7M~&h3B=h0og1U~UI$0eE5u%to2j0S*46PE;XA@`b_5
z;T{H$_=D6FF_kkIJqekM0!>yxW@JDtglBQbJ4hWw2gviNQy(Cam#l-&w<OHxfV_tY
z2IyP``s@w%v=7Q@*b)gy9CvtvWTDoKPTF8Su?#XshfJcMX$FxaViXUe5SbjE{~4YC
zK^qe$btGnV{>Le3bp8iibRmrzkIw(#J}{5?oq^=+vLj{FAEYWEqUIQ#|3OaM#2q|I
z?0#P2wrCT-&77n?v4nS!kIw%<kCH`70ig1p@IG_GM;Z{b4VuU^M2J6KgQ$Zk=zXRq
zsjZID`5(|&)F>XEj~Gn@Ln94<Mmk3E$O?hc`JcfN->~t25zxRld<+{pXwLx>L?8Lb
zsuHUpXvmbY0kpyc#6pY>6C4;vjI=`rj(bq&0+RCci%a4mdqUztP9$+&0CXaGQEEnN
zUU6nws<i?N7cuIuqoA&<n^csaotmecSXz>=TToJjxxqsSWIsIIz+?X)&qBNnay=2A
zg^aj^6u)F0bY6u-8^}+H(QgS%Pb0QCK)epp@Cr0B#xMx|1#;3GR$e`QaC||W4icmG
zbO6>|0m}DSQVmELXSjkSN90_9Ao!r;_$1Kwnp6U3xf8Jzng?`BJLH&ue8-^^vzDGC
zFF%jKT?<4X|5#p>SO6{0@Sk8VoLW%=Dz@_T;=uufUo|&aO)8a+$|rW9ixae#oPeE(
z^@jzx2LnkQUf~6;WG>0f&m&+rH)J~kAyq_Ow8B@MnVy$eQd&ePkOedIGE3rNF2o;g
zL<J7v(J4~L4S0)E(^894^9bD_!Uf7hgz_S>iG}b$kPzeuVd9DaF4(O-_;NRqYuQOZ
z{WLQ#Jtws!KM#NO62HWsA9SThJS4f|H<P4+O@73I;si1QPf;Q$LxC<H!55&!kChX7
zy9jYvl!#-ViO!!yPRbCos++j+L83A_u|*oGS)KT47GetpB2x+x`w@sb%9-ffe~8^s
zK}6eusB({}0*I)MIYex&B({A)czYqS#WnFm=|pc3<R`lELqfqxbO}dz7ZouR5yT%;
zN@U$bN^^mvvY*)PwM6bdB)*0sV)GM``(a2t>6NH<dQM_-F|3}&-5@14mk_<~gVZJl
zG4oS|cM21`m5Y?=a#H$fB(>;>oZ};U12HiNt`oOalW^0OwB8zt#|#rQ%}4yqIMFlm
zM0P2OYYG!Lzfas@^MpG@#N7lyO!t+@+X6sy;e<;SqFRC=qX<u{6S<d@#EvyNOKqq)
z&;sdQAd{fcuu(i30;3@?8UmvsFd71*Aut*Oqai?E2>fScWC6|9&Is*dJn;M~d4`PY
z8V!Nb5Eu=C(GVC7fzc2cQX$aDz`)SNz`)SVz`)SLz`)STz`)SPz`)SXz`)SKz`)SS
zz`)SOz`)SWz`)SMz`)SUz`)SQz`)SYz`!tpfq`Kn0|Ub(1_p-73=9lY7#J9)GB7Yq
zV_;yI&cMJhgMoqJ-~a#rXE87^%w}L<n8U!pFqeUWVIBhm!+Zt?h6M}^3=0_;7#1-w
zFf3+ZU|7Pyz_65ofngZ~1H*C#28I<33=At77#LPT%>kLUmVtp`9RmZydIkoD4Gatn
z8yOfFHZd?TY-V6!*uucTuobFyI|Bp54h9B>oeT^NyBHW4b~7+A>|tPF*vr7cu#bU(
zVLw#eK?VkfLktWIhZz_cjxaDV9A#i&IL5%haGZgG;RFK%!$}4PhEog-45t|w7|t*-
zFq~yzU^vIXz;K>{f#CuJ1H(lI28K%v3=Ef{=7CyJ*BBTWt}`$&++bi}xXHl4aEpO~
z;Wh&U!yN_&hPw<54EGoq816GLFg##jV0Z}C2RgfAATVtGr(Ak!Nl9j2dVFz7Vo^zI
ziXrNnMiF#r^i`n*^edq2hZ_%FY6@zDLe7GQEW{&l_BZ+p(M_l;MA2;{v_KSkN;lGZ
z-^G>1)(XXy#d-yaB^i2&1)$^qK&Obu#DLa5A}IuM<1y{SDvVfM3Oy(s+u}+BAxUyT
zA+IhSM!}?l9_H{Ag|w&>J+MeTy&H3d=u6gN6ok+frRaxP5X`Hf3XVW31t}pahCm9T
z?id!QToAuVftZB_q%Q0sdbtbX#j8Xt)gf|jmdIHtBGy)swA6v<wO>RmO(1P1m)M02
zB}IvO#cBCPx$z}MiJ2t?7UL1W_J-IAeqyGOiM&pps8w6Uu2&*vnFFayCwPmAo02AK
zAy|H1T4p-_6`8~=Atz^ImAFZ4B367+`zCu*mMjsq2m>;6PAF3ly?TuBx)>totO>9C
zAZ|vVs0HT4E;%Ch+<xL$gb=-miRhJn#I7YJeswDG>+XnK(nIWeTf%Eih+OAK<U$f6
z)`Akf0E)<!eV_#=kQ}I&fqO+9QOjLPT(C#vq9CFcA`!nnk=Tqz;@TPF77Z6v!uBoT
z4r&rs?dRm@r4x=jV$YB#c4-(9%ke>pits8XVpd?$Y`q~ViyjFt9)_%1BH|Pw5*wJr
z#W0asos^oJ$a0O?G(%ioC#Ri6M5CUlW%xvuaKvr2<0rbULTopVxRsH_W_04au0%C(
zi0t+eS0)gyaf#_p6H~Gf+fg8;pdh~MMohPX$VLM(y(l7k@FexSiAx;B?UEv5On~?{
zAkhN?wCTSS-TO@@Tz3=Gfg-hsOwzJ^;#(uc?l>WOOBadFN#aH(U^{aObT^6XeG}1K
zC%$1ye2<NYoi0Ro>IipoiSMP6*kmR=c0oi-lW=dJ*d8-+dr?Vgj}ke~Ky<$vRD%*O
zGKlJl5ZenPc7&1WUMaB_6EP}HTvwlP+nw0q3R1`Di5Oudy4yfZqlZ-Y5!?7AqPQU<
zwuo$j5ZRa{qP;*;TZZT+0}<T~61#Z0`6<Pv1qJy<CHMwlNZd3=d_$Dj96maSfO!Tg
z5jmWwMlvy-0do4r#I<4w*TYnA+L1C6K}-{vxVoG8emUV*1(9_-;pP=l353Z0e||w~
zQDRAc5rM`nu`MFvTckucH;HcR5L+n|-#R6}|43ZJVss86Cl$J&gUE&{Z0sA~5i=xq
z`iL7>By!k}=u>!zZN!q;AtI{fPSju~k*C~{(76ZC!VvC!5IY`BM9&VCs7BNr0`bGL
zkZuDq30hq>ibq3WGz3ONU^E0qLjW@b{xdSNF$pj*jPC!$44YAr(GVC7fzc2c4S~@R
z7!85Z5Eu=C(GVDJA%JWDuMz5YO7#7|MuhhNqUlH9Q;3j8+W!mL4NKJiUqbsZjp)4N
z*T`A{+m2r&lpVhypCL9bgHjUuE=okOfH$#%G!VQ$W(WrbWNR{LlP)CcK`g{AGwAzA
z(E^98Yg<4eitXl?AsL9E;DQ7kC@n!JUC?*)5=df5I)}yn+X0#fDJd<;A>zJtVwYl%
zym=7fXE_M3+!|dKm6u$JbSLlVswn(>bw^i4A*U8n*NqdqVPd4LiXwU;JF&~BMps3_
zSCovdigHN>okWz1TELI4ipont3lbtXNfEJCgXlHvL~gevZbxBeUJ2o4H8fcjMf}zj
z;?_?M<f<s-wJ;DisJ}CcM?+vV1V%$(Gz3ONU^E0qLtr!nMnhmU1V%$(Gz3ONV5Eh>
z=>0DvEyhRvI~oFr5b$IOVDMy!M+lI};$mQ8K)$zt80~97ibOyJ1A{X|4nrbCF+(v!
z7(*sQDnmJg0z)`MCPN-W3PV0aIYbd2Qi%-vw}H%q+V8@U%8<lR%8<^G&XCGb1d<^M
z3z1>}0gw$EAcBFxg(06InW2;+mm!rQkD-L27$QtGDME(*S3suAfCvT#*!nLS2Ck%n
z9MJ6#C7H<#42%qDt3enU;G@0C1qGm$Cn&o_p<)<kTtLN<Hbp~4&?dE@qUdK(L51P_
z_@R90Ic`uMk4I`^N@|e;XvVvkk%57M1A3i<Ar^lyFkmR>3ra1{FD*(=MVNpT79ax!
z(C-=mg&n$}5d#AQBWqE4dN$SUWdW@zqn0N?xfJAX7-nH$U;tZy<XMRG;o<lHKLZ2F
zmtT;u6mE3=SAJ0m_JxDQtS1EJ!qN3#c_oRNd8tLv<!__wzfhL`KugLDd}k|=a&{Sd
z0gc~a$P6Ztw;Lqp<PfEDbp026ImGCxSk742LyVq^#eh9vh&dB>bp02;1J?+jiZ#0a
z3v)3}a$-(SQetv8{&kq6r(&Tl>l!^33(HzJB2S<nUH^r7E+Mv4u|6>{GJ!^LKzDx|
z{JYNZees|23j$oVJPZsBoD2*M%&_hv0|Ns)6i)#4i5VCe5};V_zq|qi1A`ezDM$*Y
zZj?rZ*=SgdhQ(k^1B?u;44_SM|Nk>Ga5FeN=M=l;qy*>WCn1drf%A0(d{hX+g$xxz
z*x+F#2orr&%n-XUXt0c-Bp!C`x*l{W550Q{6&@Y`3q~8DBx4YBbo?*1A{CU>NB4h*
zXXY6jDS)>agR&=d=nQSdpNqjcpeR4fy(qu50ICAAgc>dF;Z%n)u8vbBQdz^uAOx{D
zHMs=Qw};wK#6?P@<A0;$f1~?9QTvgj`#<rIJB;rC9Nquv6hy64@khu1M#ul~-q|sF
zDn9O8P6^-hH#+{837`L?!v4?E@xRe=slhldHR>k%q)RRaW(Hx<AOIYrj}y(P&dkd!
zv9e0Zj|WZTX~aWTbtq`*D8QMTI?h%xN%{H3B{4afNyRY*l_eSZc`?OB$uS_!DC2w}
zrB43-!67j|o=(9r0g)jd{(dn|p`Jc2F(IzOAu%qlPND8FVUWUj2qzvS8}Fj$;^R}R
zpl4(XcQFG4cnK;pf7H>*1qD<JX=4NAkR2k)V;DMme|1_>er`M@Zy{$xaK^K;f=F0d
zl~fj_+JF}Gf>w`OSp_AQholylC}`Pf>gegkz!6xNK17p#N@_`BW{!SpMM-L2ab|vA
zJosW4P`8;%iO9&v5??CXL!RH95{pv@x5o~U=P{SmqRg_?6vN@{IitbtxfA5YoHKN(
z3n<SG{^YrjJWmFtCg&HW4DR^bOQzQn^U?=-nR0|YpZS-i7Ukq8rhroB;Ep;nJ&2t3
z2Db-ylNW<-`T2v}U;kMctHJFGL~8`nz=%g{S;Qyj=ar=vm82FGBQ;eV4RsLh7DsS*
z1GH+;&dRDdH?gQBzM!Niz9b*k0xB*^v9d}m1qqZCp_nqTEgf_4ng>{G2fe*aVGubX
z2ayxGLF8mOsDp@`qEzITpO2J`-175b<pPd$1WmBT8Hq)yDWEill$PA`^9OTCeWoP0
z5f@Hni8-aIh~9>tp5B0VBg_myOE@GzT^rOB>LJI0gO(qHuvW5FOi6xz4$4qOL2^=Q
zW=;xpbi&9WK1DAjCx-$3Y<feu!O*kmL0K977;S_i_%aIg^UBebKpY4%O9aLBcq~CX
z@f@UAmVtqRm4VTL(>Xt{q$oc}*BK-V@-hblqXREY)Tt;nF&ies#K6!X>XKNJ2<jOs
z_+}O-=47Vl<)-G9z*Mj@FdPtYOioTME>;N3%+E<I$;{7#NwP689N_iLQwT^*PgQU&
zD#{1%k_A~Q%fN6z*fS?5H9av$!85P8q^L9*S!WLe!vRspqN2n~1*iPdyp&=E*NWuS
z)Rfc|nAyDy3<t#Aa`F>P6kJmC@{4j4a}@kR*A?f%mGm(%91wvj$t=rENmWRyRESC~
z%7>Yu26jbWSz=CRih@gKaY24@CbBE~5e9hXrB);+mna0K7MJG0eLsPL;ea^A22ZFl
zU^gHeGLeDd03SpRs2!D-lMmjT3<`xw3=9VZAyUC5iOJat&Kar6@W7wUz;J*cA{&~Q
zl3IkUQ=Ea}0H<HRf^TYWeo-aNKdKB22PFLR^OE!PN;30G6O(dM!Qobb>>fg%o&pM3
z&%Bb<^wc5+7p&n%gp#SCbOAF3-QUwdRs<AfmSyIorl+Q0O8|dCp#}*Qbls+m3<r2!
ze0&uA@=FxlK&b=fe<wzU1Ck&a&%Df%%*33`DsXaCa7)b0L8P2IhTH=JzWFJoIjNXN
z)HCEB5DqBHPfkrKEy5zt0df~Cu00a-QgTvZwkH?oJ`nfKOfJeV&QB{*aMspF1U@LX
zK^V00QVFeuG14;tk9R`aJGvmQxU*GEh`+xNY>*Qq798XpLxfflG}FOGgLdq)g(sFI
zXBaXtKo~|ahB1s`!oaYBiGd*i<W7*EM)7C}jE2By2#kinXb6mkz-S1JhQMeDAcer_
z`EN*pG0Gebfzc2c4S~@R7!83D5&~=tj0{{16|7P$oD4Hi{OqjntgX$!z`({ZApv}1
zAXql#9YY{!XelR&fq_GyiIG8_A&_SaLm+6qCP+cSE{7Zs_6;B<3}6Bz2*#OZU<!=@
zsfP%GwgkICm<%u)%4JZ)xx5gzgSZ&9g;=fH$kElv+|k%s*U;R}RM*hZ#X#55&Cp5L
zz`)VK+0wwx(#6%RmVrSBYB0!!pb0t<{`3F;|Cj&&{|Cu|@O?%GhFy#d3>*U-E;kt%
z7+yo&3!|Z2q;LUGVnJs%Vj!!zVnD<F#h^7@YSqRj7G`Fa7B0Fbmaa~^hK9~=x=wB;
zW}t9!G%zr6HZ*cIA`mW43=9k){1qB5>;oJw_|l6OJiTBG7et!LC@7#x*oZMOFo5t$
zXxOj~aM<)QFfh!6CK4D8<uWKa!=}b^i_4PDV#1s)En+<Ll5<K^Qe%8wef@(XsTwAi
zm>~Ixb%4VJ<bO~cA=4l>2rFX?6X&3i7|?LNpKG|Db3g!93KviY0^xtqKw%l+Kv}}b
zz_1lm3Nj#QP=J820`^P<S_Gb2M73fCWD^MQfrbe40Efs!1_lNuMg|7Z`M@w5<USDA
zhKC69DtFLqZcK81Zb4CM259wcSt`}*q6^Fn4CYJ>3`_$YIQtkF7_Nds0*Qul8D!vr
z11WRiOLnN1R6rRAgr7k}gK>aE<0Gilhh`ozC=Ck@gJjr-2uNr^rUhX&Gumn>s)bMl
z0|NsHb3-!|!vKd6C^Wc11Oo#DjD~U<RN!SUG;Bb-MIaNpuvHs+$t2Z8plMmqc~zj+
z90<c&bf8ingnOZ(k~iSX-AC8|jjsPAZ;9mS`ah)oDcDz$61T1mv}_c-OHBh@KwDXj
z%=Lf&Ss9s_1xl<c81)%$Burqmg7h7&tTIw_QsOi7ic1pnl99I)f%Y`mDd1R2Inb*E
zAxm#zRWYazfYml2`v2&<Quyvk0wKjq(F$Cr#3~(Vu7cF<RzxJLsv(-HM&cS=P;SDR
v%Y+6#?F_m_%b>ub>Z0Y*b-<(RfI*3BbRF>MI^dGzjL~(#pekt;lN<s75h=QT

literal 86528
zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;!F$-42&?o00YCn|NsAkxG);Tu3%tb_&*AU
zObGn_|Np-N0|Nsy0|NsK0|Nsq0|PkD*%=rZI2afhI2jlixEL51xEUbv&C9^Rz{kMA
zz|X+IAi%)DAjrVLAjH7HAk4tPAi}`FAPQ9{&cMJR!N9;E$-uxM#lXNI&A`AQ!@$5G
z%fP@O$H2fK4^`*Sz`&ryz`&r)z`&rwz`&r&z`&r!z`&r+z`&rvz`&r%z`&pdRjb3m
zz@W>(z@W##z@X2-z+k|@z+lM0z+l9{z+lY4z+eJZXU4$5V9vn6V8Ot^V9CJ1V8y_|
zV9mh5V8g(`V9UV3V8_6~V9&t7;K0DZ;K;zh-~`p@!oa}b%D}+j#=yYf&cMLn!N9=a
z$-uzi#lXPe&A`Cm!@$7c%fP_k2UXw9z`zj5z`zj1z`zj9z`zi~z`zj7z`zj3z`zjB
zz`zi}z`zj6z`zj2z`zg<)f3CWz!1m4z!1;Cz>vVez>vtmz>vhiz>v(qz>vbgz>vzo
zz>vnkz>v<sz>vYfz>vwnz>vkjz>v+rz>vehz>o_yC!c|Vp@4ybp^$-rp@@Njp_qYz
zp@e~fp_GAvp^Slnp&Y6X6u(sr3=Gu_3=B043=Fjl3=DM)3=H)Q3=9omx92nDGn6nW
zFt{@0F_bVAF;s%GG0|9zffb(Lk;@8f1}MDhZ&P1-fDyU82xrJ=C}PNFC}t>NNMuN6
zNM%r92xcf@NMtAhhXposki`@jm>5Bs4U|4XG_o8nHmDo}CsuIW7ct~Blrt1Fq=Lf{
zmmXZ=0t`%ypu7XhE5zE*12PPhS-|Nng&~un1RM$=VNx+40}~@Ce}e1=VPf=)ffPaQ
zXJlXn=X;it)Z!8iXRDZ`{QTmQn4HX{;+TTUl8pSkn55FooRk=lJebf+DJ}rj0$fQ2
zIq}6Mi6xoInt1dfRKYZ|7L})G8*1Uv16B|NCSjU5QY#X33vyBo4e;oLsfmFxV7fu&
z8Z(0=0}}&N5vYa&;cJWx41A0X3}#FW4BJ2<0>z+E1YuJq28NxCkdl#+fuR8;whOAB
zxq&k%H9fPqB(<m*RN8<_O-Tl32IeAA9tPn<j0_CFpm`d^2N}-Xz~-Bpn_pCE&J1!8
zBLhea3x<P0%0odR4AKLwPC-Q|sHn|ngjB(HPzQmEUXWVm1}^8soE(MVlEma}WaC+j
ziWwOg4lyt=Tw!8hSj@!0pw7g=0MY_A9b96AjIU&6U_dq=RFbE#Lew%haJys{Cl(i{
z<|gG-euvf*Am_6eEnr|^0O5b2uwjIhVjwSo%>QB7&j>2DL2QtZKw${NfBygf|MLI;
z{~$RK-p|CqFbx#e4V>ZmMcKs#iOH#EoS;BrW?*GtWDqC@nFxwCSh${rhAqfsQ2zV(
z|9?Hm<eSV43?Mn?1`glUyi$dv#3E2|Ff%YRFf#oA4=y9YdB2AdQi*^J231ZVgJ2kB
zP!%hr;sQDQE)%${WB`eQ)G{}41eYY{r6d-msDWG!ZWsOk&sg%8iGkrdBLl+;W(I~(
zCP=LZs_j4qgIozpM-_|=4DE~%IpzjdCs6K!nZm;G|36a+NTo9a1H(&3Nc{kEBFq$!
zb6B8}|CSL_mohhSyOn|>Ke;G1H4l`#K_-B_%Ul8~lR+`52(2SQW`Qu+MGd@Q+ZB8>
z^D><hi;!KxSSruLz+lhFz_6Bufgu(eugI<d`DF(S1H)8kjn3S_>=@z$s+&Q9&Cc-u
zKV#`xGyt+0gdw(b1f>?|mlh?bLNtN0+W-H|1T?X^WG3e1r^|!Gor!^&;s1XYtXg1h
z1(){F5G#d;7>9FyUP)1YPBAFBKn)*|L9C?)po9pjl0k(6)YC`~b}vdS$jD4C7G(sr
zmRP{Hvw<~%6jd=XFnBRS>VFU)<V%pzu(bIZ+BRTrU~|sT$uBAvM>2*TY)lv<14B6z
z1H)-XNRtBHm?I1f3{BAH26F>vNNPoiLP&mojyMa*L68vSD4hg#xdsyh!wG0cftkeI
zz~Y*cSpo}kCQ$8-HT)17SY1++O4H52Ar5NM{r}HUwulkZ=4)kww2eTjVIdAmqqYnT
z4O1Bz7$(C*oXx2yzq~jV)c67=PmsloWoYT+EXWuT1_d2+18ZPuYEdPqsR+^`3(CLc
z_;m=lB$gy5B^IYDxMU`#7bWH*Yi1;%nKdLaDJK<K2NMAu95CxZl>p3*%;gr0kVa)E
zBczcB@(~C_e8m!$nOcr)3k#^R29kqgkYW%92{1SC1%q>m0yN3OLJ(Xq5^x|}P-=31
zQ3}j935Ngw69{PG49~1eEJ|@oEHZ+|I1j`B{~hHMnHU&AF*<>nf#EAOfg#8Epa1{s
zGng0{BAFni(t|hsjQ{^LGH@_ByW}Tlhv%g*GRUwnH2nJizaA9%utF8mhm-=f%E5Ik
z0|RT3BttQ%RR?OMf`Wj7f#JoR4o2k$CQ$#g;V0CDzu+<-s(_&a)E}*fm<AF%3QE~X
zCVZIL&#2tM%)rFJ&;Zg2Djz{*7($07)Bpefk#sDm0_gzdV2BQA&lX7q14C&H1H;}J
z1_stx1_s|)28OAz3=9uq85lI;7#ND<7#Q}&F)*;jGcfqYGcZhzXJB|7&%j`qz`#(S
zz`$@Jfq_9Tk%1vMk%3`vA_D_!5(7hU5(7hI5(7h25(7hT5(C4HBnF0iNem2slNcD-
zk{K8RlNlK1Br`BPPi9~+N?~BAO<`a-ox;E%mde18lFGoaDV2fYZz=<WM;Zgeq%;PG
zyJ-vzkJA_!UZgQFNT)L}q^2`4WT!JQbfq&eOipKDxS!6zpq;_MP@ciSa5#g3fj^Uh
zAuf}FVO1sr!_Q0x29GQThACML3=gsx7__q)7|OF57;3W_7@D#f7#3zTFr3V0U^t)6
zz#y5!z#yN)z@U`Fz@VJNz)+aOz_2-of#GBh1H<ba28Ope3=Fop3=GM+3=G-13=C6p
z85q{&GBDf&b!hS!7;N(x7&7x17&hiHFg(v=V6e((V5rJxV7QUbz@SvXz|dX5z;M5S
zfg!k%fnj4I1A{>k1H+6W1_q^K28OA{3=Fy@3=9S(3=D=P3=E|u3=ES>7#P-;Ffgny
zVPM!^!oYB^gn@yjl!1Z0l!1Yxlz}0vl!2kDl!0MFDFefiQU-=&r3?(`N*Ng5mNGDW
zC}m*ySjxcQSjNE6TE@U|v5bL1qMU&trksIcWjO=GnQ{h(kL3&uIu#5IdKC-|W)%z!
zu@wvqy%h`$eH9E02P+sDu2nEFysKbf(5Pf!aI9otNUmgHSW?NraIlhr;cX=YgJ~55
zLs%69Lr)b0!)<5>&7qosVOli<!~SXp2F@A=hO`<6hRHPy49{yA7`$s47;0)67;e=v
zFu2w+FjUnsFg&VbU<j#aVCV&<$OZ<6>IMdeoec~OyFeYgMg|70Mg|7$Mg|7cMg|7Y
zMg|6-Mg|7oMh1r2jSLL88yOgsniv?on-~~6niv?mniv=+H!(2mYhqw{+{D1}q=|t+
zvYCNFu9<-$rI~@DznOtyW-|lBnq~%u_00?n8=4syZZ|V9+-+uHc-G9oAkxCXpx?s4
zVA8_CP}{=5P}jo1u)BqU;dKiGgJ3HIgLEqcgMBLlgHtO5gL5kbgIg;DLv||zLtZNb
zLw+j*Lw73!!<JSChKH>T43AqG7zElF7=+pw7=+sx81&m17&6)z7&_Y+7`odS7<RNV
zFzjk$VA$Qpz;L~dfq}D~fq}c7fx*3<fx)MpfuXjYfnh^C1H-0v28PY;3=HSn85pj$
zGcf#aXJAn8U|`VfU|<OEU|@*sU|@*qU|=ZgU|^{2U|?9<!N72(gMr~%2Ll6pCj$d#
zCj*0ECj*0SCj&!ECj&!UCj-OjP6mb>oeT`$I~f>QyBHYQyBHWax)>N#x)>Pzx)>M&
zx)>PhyBHW6yBHXnx)>Oyb}=yA>0)5G*Tujf-Oa$@*v-HY*Ui9?(9OV**v-ID(#^oI
zx0``se>VdIQx5}!Mh^o+a1R4RK@S5%Q4a${aSsDSTMq-nnH~m)b3F_U-+LGse)cdh
z{OVy~;O%8#i0oxxi0)-zXzyiU=<H=+=;~!)nA^+1@VJ+O;b|`e14kbN16Lmd19u+-
zgIpg2LslOHLrxz9!=ye2hADjv3{(3U7-sY_FzoJQVA$8kz;LmTfq}oDfkCOCfg!7(
zfuXjaf#GyN1H+kq28Pf53=CiTL1ilfS2LbuWES9HIIuaLC87@0@Ic6ovIc($I5RRb
zF$*v-fZ}e#$%&w*+u(Qfs0&9!U^E1%5(1#UIs+Sc*dNs40O1HG28IcYkYRn89Xim0
z0W_QdQUk)m%nS_Mq2e%gf1rF&qZy<Igkk2v)PQJEuXGv%sK1IBFgnA;zyRv8g5+Ts
zrVeB*$Se@XWgbWmsIw1J1H$;!fz*P`1dUmNy80kK6oUqTKzMZgkAY!y{14ROWPo*5
zN5}u5c?6nu8b-(e{{J5x{{zj9f(l$Yq|`Aw{>Q+;FgpJCe{}qBbo_60{BLypZ*=@`
zbo>w6JQ$@0Q3(8pj{k8eq_f;e0CoEZk>f_4G8zJ-Awbg*;9y{8@b&TXVPfD6Ni8mM
zE-flcRdlh6DK1KmNh~fXOEv>hp(U9)Fj_CUpkOO#xg%)hZ$N5MT7FS(VqS8pf{{W%
zeo+Zw&AOn45+F|{_?fbS)*1gu&}DnhzyO+=XZXAaJR->elLM&(VbH+dS3GjR@yPu{
zlLOf&zzDIAWiP6IAUQ#(92*unA*dWT7P%KtKM0`7f!q(mAU}xWk(0t92O4dWMUw-$
zlNIU~Y;wX-IVCLmM4*cZRj|mh;gMs9nu)Ft<Tnro`A;3qOprJTgXA>u$Z6w|)4?NW
zh(it(W+rHIpfKZr`T?69%$??F`at3!4Dy5M`=8~YC4e_rY{6+4Bo4wLIcYp{N;u>|
zdX@3Wf#gT=Xb6mkz-S1JhQMeDjE2By2#kinXb6mkz-S0iBLx1lLe~FPFzPdmj{i|3
zL`TgS4S}H(0@(Inhcjd{<T0dx_eB%(i4p@7BWSDzv;!8jYL1Y4kUVHFB6trbcq3ar
zLn%WMc;|OKgEK=ubQgL)Lk>ecgC|2CLmC5UuRBN|Hmm{N{|&Mmgt4hX7t;m_K=(g;
zG6XPqGQ=|^F%*DpEQanq&jjzt2Pwpl<rtV4L1RCl1&_qqZwfLJbQl8od;y64sSFhi
zi43`5SEPbZH2^6hjHSr%KWJ|$_;3dB0!&s0@ZN7u=bXgi;;_ura#kBx{~$YLk_WW;
zTOk>wAhj4-g2OE{Cl#Sb9=>^3K^?qnT-{2+M4_N4KPxr4M59<!0I?ZdAuTf}wU`IG
zvkhcSF&}K#Hbjmay#E`*<^nqaQwxtrYGO)ikpfsh#9>HEaR{JT3Q+?g(R{-&I{wQ5
zABP8xosN$GGBAve{}L{fMpcZ4z-S1JhQMeDjE2By2#kinXb6mkz-R~z&JY+K{~et1
zGU}?)5THj0IL?6_9426smtUfg3^^1nCpE=RBpJ(DkPMKqLShv|PI@F(HT;N23=JGG
zw=gguojM5`KO7zZ1D&ahwq6l5RyVr-lYs%-8qd-7pY$kIM(r34fzc2c4S~@R7!85Z
z5Eu=C(GVC7fzc2cj3F>O{x=w7Wz<chAwZuHNO%RgP(%)CX`Ze^cxIllkplSG{{ZkM
zFnkDU$ek)249)?Nb$tYMN+EPAzzhyb%}GrxP6e%-WCWd64c__v3bdUW%=!&xf&4Fl
zMKjn{gtZcI7GVR}I7EVjoq`w`8MqmoLlTS9Q%gKcQgiY62d|4kk_6lYQUbLVWsM>u
z0~aK;-HY-|3!o}kIYeB%!ci7L;!($(l3KvXAj076l3I|Omy(*7T<M&jSCW{Sms*5k
zAT<@Tr<JGZWfT-JGVmi?3|g!SwUZ~aB(*59B)<s1GTxHXf}GU+B+xQay$syOaTiw>
z=jNxB=A`0N#g&|&mzJ51-%1Y1<wy9;5z0@BPfpCqi7zQi%q%I!Zyr}cWol7Teo-+#
z6M55e@)Ju4`;#+2DJwI#AP28m;N`l6&EhUC$;`<tsl@Mmo`S@Z<cyruvQ)g5^5kR|
z6XAZ|<T9cHjXN{1q$oKfH8~rfPel`pGD|XYQ%f?Fi87V5pb~U#72Y($pPUc6ZK{HB
z`0;>NB@<T0Sx}h*x<v(_M>t>!6L$*dNy$tmB7iwEa|`l|O7L06lbfGXTv|X#8GB}O
zD*mLwnM~OC{H1xB$@wWnWMPhiN<vN&0mV&zab`&>QPIs?l$e)Jgw1@psU;ctDTF=4
zm6%jqQk0mCH+Z>0DpHdY2_)U*{JgT%qT<Z_Jfi%<S6ot*nU_x3jqC-LX$5#wID2wx
zSt8!d%n7<jr=&OqUn*iRsLV~x#ixR|I43iisNe?|+=RUbDijE-;!7$`OG_;xtdKXq
z08#}JD8PA(a}$e7;tNU$)K%P&ileAB4_~No5Ox?p(RB+?PChYdf+wvskBGd=k(^ju
zf<Mc1lvIKe7rvTZvZN?6uNZVT5Hw-O7Z;=^<2P0i5-3m&_|@`*oIsRH5p<W}H&`Sw
zCo?@SH#M(>DAW0i6LX0xhae3$WD?Zg8^xm`Fd71*Auv!OFgpG>P$55R?`Q}Nd<fLD
zHiGYe8a@AE;NxP{1*0J_8UmvsFd71*AwaJXfX)BOzz^SmP11qq*&wrjJTOW0xj($R
zBw)I5&-;O{lY7I;jx-+#nFR!izhIS0wu&jq&(A52fsCm^DZSK+RFHy~tdn&!6?Bso
zlpv$s3K^+6Ir-KKP+oqqwL*TeUUEiCW|4-vo}NAgfld-p*MzG|$xjA}pecpA97!EW
zQ9M-G&{_e7t5;N-rxC5LTc#eXsRWu>{0*PL6oYAjhXFWPL5d(VpCFICVTIhV4q^{s
zUqhk}<TZr<@g@+EQb;I(SP<=?Fc_Q>3v$^DRt@wt2|6e}z}cxZGbaU_KI2nhDfA61
zH#oW>xd`M*M94sAK+&g{ab_A&fq)}5fu!&TG)Mu|K59=a^97|ALvE)BP3sopnSw^z
zxx>gH1ewrIO)f!9NJCvn%^7IOXe-esLX<<u(fL2{@`us+KgencQ0j&z(9!w7%$!tc
zSd7m9f!ER?rH;}0KXAD*I{$~BFd)?mG6|}dNAYL~jE2By2n<vRjL!cJRLGCoI~oE5
z9|EKEe*+%}qb?W?fq@DE*!ky04CM^z4A~@{JPvWO2m=!XCj$cm=pIL6&p!_UX_WvG
z3=A;)OBhlaKxeN*M2RPb7?>D&7#J9M85kIdwLb=Ayb6dw*bm{6PI56Yf$as^4Z_5j
zkOxu(J%8SrA%`K6p_rkVA&eoDA(f$=L4kq9^Y=-%zY@uQ*!+(q<g|4xlRunb8T6SS
z-0DTa>f!Sp<j(E%qR#Dr4TaCz&|q!{Y5{m+2h2v9)d3CuqfS&IM)HNh%HbXckNAVs
z6ET%D7(EG@ivmqnKxSk>EQDuq$2&+JL<h+8s8b&xk(aE4&$lGZ=YYJ22nOizC;IFS
z_OuVmZrBnDNE~-~f@GoAj858s2h*_cSVSIC!>(d<{s*?_6KR}!bpID<6D(4IjPCzJ
z3y{(MUzJG7V|4!)V%BeT{}+4$baek0sGTy3M?+vV1cqV=jL!cI#aJ74^JoZACj>_4
zf2b3Vqo$08z)%bU*!aH$Xy6-l3>&g)odYC+KKhSSwFpQx+!&;>f5ryTEy18cRKyrD
z!2xo_h&yBexd(MlASpk;xFjC3HzXcpF^Tg7pmT(ZQZrKXiZjbntrbwXh|zx?1$ABB
zq@w)n)I8n9(vp1Lf|4T4jUGZE`{5o3&jElu3-LC{^+b3UGV%^m{E~Ihc@+|EAU`2S
z!Eq)7kTQtZL9ADx%b^(tp}#;*dc(@Arw@)VNO}i}QF~edYpwv57FbdZNEm0hf+R=h
z1dtCCL?7|zCGyxi;!h;w0iDAHImip&fk&jCLPzYmQ$!zRMdHClM4nqm<Oz+Wp2<e!
zfsTZCpAbIAjEIvQ`4Pvk5jX`*5S+Z?!Izt-5;zHrn1k_%Ic$sYiFm{viALn%jKpnV
z5JdzTQRie4d4MG0BSZN?r_#kkP71?+k{3r_ejb6d3yC|Wj~8@sT1jSp9)ZLmoLW%=
zYE0zk#e<Uxe&-Qe01$b)8#ma>R02-qFE2_gfHs-%JCFE*Z6eR4B<^rlBF?}h_ViF<
zXKaW)p^)%iCr;3zbOd66*fU<aK-CVRB1SMXFS8^bmOSxCDDm@~uwzK^Rd=8whw#y?
zL>zNS%AtRJ#hK}Oi6x~)1d}<aEuWK0#PO}X#hH2OIjJT2dH6$*h!a)0A%zlw_$TW0
zVd4(uCF)FJ5|2M5X401ra>g>myZBDIB<h^vqSUn1qSQP>$IJ>rEG4e$CI0M8Vo!%9
zYSSk%CkqpK3MXlYOT&(q#+PG>If0m*U3*kKla}~HJ&9bs!c&w8s<%Ps+~Nxw<RwH9
zHmIXDibq3W*oVOA`2Vnv;!zKdh5*hG_|L+~%q+mbFnazY&LA3<7!8488v^w#jidR0
z*v9Ut$3{Z{e+c|%W@H(y|M7>>sO)G64A&5Vt^bi>KsuihbR{I(o<l|k_ykjOK>=u0
z2g;-=R19MV3@VN^g9a5ro4J6Bq7U*yh2bOXP(E~?1<FIa1CfD&19s>t7Jo1>U?|5p
z!jb_wEI`YaSiw7dsbv}qXsHkb10y3w5DS8)E#NDX^sxJnkpWFv1|&WRdjoxcItv2>
z1K2T0Q4jGdJOuy$XJCMwX*;_9CkERwub`ZOSP%tWn}fbBcy#>_-R>M6UH?Pm#bu-G
ze-Qf_QK~Y$7uJrh|A7{9qw9a5MH<o;VT{%f-lR0T{s(>)HBuOkuK$5%u+jBDm>Fzz
z{ZBITkp!dbe{kI^Kf3-0GxK0y{{z|oo5}{8|0Dg@-qH0x!*y(E)L+9t1R5C_7@8Ou
z82<hL{~v@~85kJa7#JAZ85kHk7#J8j85kJ47#JA385kIP7#J9O85kJ)7#JA(85kHQ
zFfcGoWME*J#K6EXnSp^}3IhYfR0alyX$%Yu(-{~TW-u@?%!Hafn}LC04g&+jTm}Y)
zc?=8;^BEWz7BDa{EM#C{Sj51<u$X~?VF?2R!%_wYhGh&449lVVKx0;;n06t+$iT_~
z8VCIUpOJx^!Pz;d*exd|I43^|X-p853m6;VV}cMaWS|hj1`i^Fm>4}E=n&@U_-}l1
zNn%N6GH5gz8d{^{zeObq1G|M6wAXWV|0iU{Gsg4*7vzdA_oDpL0%)HUq7tcO7<?Cb
zjgJ40j{oMN^pZ#Se?oKb=>AWPtK3HSe=^`4LMcwnO(kw?Z%Srz3E|CPqx(O>7o&~t
z|3odGNB4hXIh=WP|0hOKjlMJp@7&tx`0wcWZ*Z_v(CGe8(5TEP9t{CpA>hK0%8<lR
z%8<^G&XCGbgi9GtaUnA9zi9!PrUN1v7+e_g8Il=F8FCp?8S)rP7>XgnM3bQVhmc1{
ziP1O<q(}xtPzRH0KXq(Hm_mvDTnx+%;s~R#+@dt28g$5rl~qc9Jm^Rg4d~fB3R*e}
zaHgh?vsDauEH5S}GpRTRawcC)aZz#%NHgMulH`H{kWwdq|KN}qA5W*?n1IL-4}ZTH
zr%+EHmzWUO;E)&>SEo>Sm@r6TJcJVul8txKbMf)1RnRjsMRqkP2$1=sj;3Bn8yg^p
z><|g*A?#?-904fA(L;KFby`t=F7)sw<ZKAecve=BOlM^UI)un3sUQb@B&L;BP-1yV
zYH^8zmYt@Ko?Z+bfpzIaH0h_LmLz88=wms+idxy#$P(lyTz=a_p5L4ji&F=;#}1I^
zF_+Y$%(B!J!{O{XqrvUD6XeC5b7D>o=(I>so*Vqhb02x03`$MTFG?BQ@wb;uuO;TC
z5ArhQ2zfs9FH0@T$xloHrOd${b!2)FIqMB>5AG%}2Ho=W2e-fevoKbJ+ZBk`2&91#
zkJhq?ha4YTl3G-Z)Kqaa)Iqdc9KqcUP*G}UWmTM;SX2^UP*N0Mk`HSE6_=z~S%FUE
z28pAXGO#Tjb3=SBo&VgF1(A^sS^z_uZdO(qsW~a}nR&$}iFwJX$iZP`r+^~__4M=x
zv`t7Lq$o>FPRNPLiQL5GWH_i36F)_X3DiCzH93Lw4AlfhS=MvQ&qper-175b^$m{P
z1<j|$8Hq)yDQIPsTYmnaPFK7XrmHH_lU3CaO;w*Msqu(QQ)P)crKyM>|3DYpX5axK
zTwVG9LIa<623>%G0t@G@4j@So)=IXDDap^zK^Z?SNCqD^4;@l9GKf#nOUcP$kY!+C
zU}a!*-~?TOP?Vpe>kMmja4;}B@WMo$ic%A^VKPh%3=N_#i6x1k5h4ZO%;LnH%=En6
z)Vvay3RVV&0|Ji8$*IM~3SpV~IpEV%VUlbN3<r2U^ArLS(^C~(i;D8WvjrfB%Q7$=
z5cbT;Nlj18QSi(wE-5Na2A#VK)7itoa6r_ts3@^g!70BqFQr()wIVq+H6=9#rlOaD
z;eeQ1PJUvEf=g;%eo<~>j)H$dYEfbyTuC1T!vPVflFYKqlvIVJN`<J@qI{ScYG7C7
zl_ln6rYN{%78m3fXCk|zA7OxJUTQ^Ra*0AvYH?`}-1ie07!HU-Z198{19k(lArl!G
z4)8(LfcjHuIr-%<`zJ9l91w&^1(zfyXDc{oq$a}ye=-BZ0e*;VXkJQc5wcEk28IKi
ze)$T%sk!+@l`!*E85j;o_~qv%=jWAV=9MNU<)nhctpM3QggiY36tJFoC8_DDMG7uh
z!;J_fQ$gthW(vB$r-7^pD9S9$%t=j8O~IA`{(?dc5-8}pO&J*u@VfZ;DEQ@<D7b-A
z2h9IYj0^`PK{B3snI)NtIhj@9<f!15n3;n}Idu%V2LyccQ%ZAEF^#Ba$UPt&P?VpX
zno?SXMV<rXE?8W9B<7{$q{3`ZF3x=*?wgrhlwX{mR-)jnt&IqLP?`r}(BThCXqnbX
z&j38{0qOVXg1F+&Rxu&|{ywnD4v<)IkaG+XT1C)I2OAAqug?~qSdyG!$iM($7{M6E
zFop>O!v-b>h5(Q|L4F#=qalDL1V+#Q!xAW?LZcxtLPB8l{J#+r(WBlR4FN16P|w^r
zdj2Pta2XXE4S~@R7!85Z5Eu=C;T!^N42%q%3>B<WEF9qTIuL$!)_2y{X2`L!0$mwd
zkeUKt#2a6bpP5&ZT4a-ypPvJo=gCpfh>uTBNlnht($q+TFFXXVR?xJ=vT|6#pu)hw
z!rUY^(FC!G*oXnN8XRK33xtA`YB-k{!|pyT2A!6xR&C_yYGm$c?5t~O?q;fMXy{^~
z>*!|aq-$W{Xy9yV;AZLKYF5j@09|~}02&+vEwcpSKmY&#fBFCae~=sq-)CfC*u}`e
zz&^m?a+869;WacQU^JA=fCv}xWFvHvAO^A|AO<wd55A31t=ibc!pzLl!bR7_($z`V
z(9qdU*U8Pq3=}So1_mb1hDNSN1j5CMfq?;pze2->ZGgiCUwYAkrx$GDf=DwN1qD<I
z8!-k31`s|84I9=04ja%3J)l!|K<NZVgV-Rf<P4i-$}KKSHj4>!wzP=x%uCKGO-YUM
zb@lZRill0oTw;RcBbEUU6Oi9QafD2R*dVNoEliw)LSjI}^nR}4dd>j>R4H6Q83=^`
zK?8+(fCFU-BLl-$P$|fOpg{ow!V1_k5oi+#<X&2;BomNLAiM_}B1{7uA`clD7?>Ct
z7(|e0ko!Pb8y+IayIerWxyN9f+)kC`0;-2V_yRKngE<rE0D91wS|F!DFum*OeGCi?
zS0PrzX(*RL1|B$&G8evN4|K6ERgwxQ<ACrpXlOuA7=zi*z(DWN_{hM(z|6?Npn^oh
zTw{<7+Yki_4ajsLtY$`A4M}ncfhHcAp?kHE+b$6d3=AO54b4mi$O{2MGq0oTe@im*
z^9Fpo%jo*w(e=M%E|DHx|C>kLV)D`Tzj?)(`FZilIf=!^*w@=TB^E=@|1GhCo&ReE
z={w?HPCmN+7u4RfvKn3gi!WV`uKy*jkQ!b8TZFa;$SIKuX=il(Z+>10XjSm&`rrIK
eP?roe#4)=5cXa(P+7jc@^}nFZF^WfS2mk=&D+65s


From 98b31ed07389a28079818dc2806674e5da1f2137 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 03:53:14 +0000
Subject: [PATCH 045/369] use BOOST_PYTHON_MODULE_INIT, update getting_started2
 for better documentation

[SVN r9472]
---
 example/getting_started1.cpp     |  4 +---
 example/getting_started2.cpp     | 33 ++++++++++++++++----------------
 example/getting_started3.cpp     |  4 +---
 example/getting_started4.cpp     |  4 +---
 example/getting_started5.cpp     |  4 +---
 example/test_getting_started2.py | 26 +++++++++++++++++--------
 6 files changed, 38 insertions(+), 37 deletions(-)

diff --git a/example/getting_started1.cpp b/example/getting_started1.cpp
index 9679a2a4..7a8e9087 100644
--- a/example/getting_started1.cpp
+++ b/example/getting_started1.cpp
@@ -12,9 +12,7 @@ namespace python = boost::python;
 
 // Python requires an exported function called init<module-name> in every
 // extension module. This is where we build the module contents.
-extern "C"
-DL_EXPORT(void)
-initgetting_started1()
+BOOST_PYTHON_MODULE_INIT(getting_started1)
 {
   try
   {
diff --git a/example/getting_started2.cpp b/example/getting_started2.cpp
index 82b4a6df..72b04105 100644
--- a/example/getting_started2.cpp
+++ b/example/getting_started2.cpp
@@ -1,29 +1,28 @@
 #include <iostream>
 #include <string>
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
 
 namespace { // Avoid cluttering the global namespace.
 
   // A friendly class.
-  class world
+  class hello
   {
+    public:
+      hello(const std::string& country) { this->country = country; }
+      std::string greet() const { return "Hello from " + country; }
     private:
       std::string country;
-    public:
-      world(const std::string& country) { this->country = country; }
-      std::string greet() const { return "Hello from " + country + "!"; }
   };
 
-  // A function taking a world object as an argument.
-  std::string invite(const world& w) {
-    return w.greet() + " Please come soon!";
+  // A function taking a hello object as an argument.
+  std::string invite(const hello& w) {
+    return w.greet() + "! Please come soon!";
   }
 }
 
-extern "C"
-DL_EXPORT(void)
-initgetting_started2()
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+BOOST_PYTHON_MODULE_INIT(getting_started2)
 {
   try
   {
@@ -31,18 +30,18 @@ initgetting_started2()
     python::module_builder this_module("getting_started2");
 
     // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
+    python::class_builder<hello> hello_class(this_module, "hello");
 
     // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
+    hello_class.def(python::constructor<std::string>());
     // Add a regular member function.
-    world_class.def(&world::greet, "greet");
+    hello_class.def(&hello::greet, "greet");
 
     // Add invite() as a regular function to the module.
     this_module.def(invite, "invite");
 
-    // Even better, invite() can also be made a member of world_class!!!
-    world_class.def(invite, "invite");
+    // Even better, invite() can also be made a member of hello_class!!!
+    hello_class.def(invite, "invite");
   }
   catch(...)
   {
diff --git a/example/getting_started3.cpp b/example/getting_started3.cpp
index 7e827249..799f5cac 100644
--- a/example/getting_started3.cpp
+++ b/example/getting_started3.cpp
@@ -91,9 +91,7 @@ namespace { // Avoid cluttering the global namespace.
   }
 }
 
-extern "C"
-DL_EXPORT(void)
-initgetting_started3()
+BOOST_PYTHON_MODULE_INIT(getting_started3)
 {
   try
   {
diff --git a/example/getting_started4.cpp b/example/getting_started4.cpp
index 0c7bd7ee..199ef7a9 100644
--- a/example/getting_started4.cpp
+++ b/example/getting_started4.cpp
@@ -74,9 +74,7 @@ namespace { // Avoid cluttering the global namespace.
   }
 }
 
-extern "C"
-DL_EXPORT(void)
-initgetting_started4()
+BOOST_PYTHON_MODULE_INIT(getting_started4)
 {
   try
   {
diff --git a/example/getting_started5.cpp b/example/getting_started5.cpp
index c9f1ce36..be033224 100644
--- a/example/getting_started5.cpp
+++ b/example/getting_started5.cpp
@@ -103,9 +103,7 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-extern "C"
-DL_EXPORT(void)
-initgetting_started5()
+BOOST_PYTHON_MODULE_INIT(getting_started5)
 {
   try
   {
diff --git a/example/test_getting_started2.py b/example/test_getting_started2.py
index 09215816..49cf765d 100644
--- a/example/test_getting_started2.py
+++ b/example/test_getting_started2.py
@@ -1,11 +1,21 @@
-r'''>>> import getting_started2
-    >>> w = getting_started2.world('California')
-    >>> print w.greet()
-    Hello from California!
-    >>> print getting_started2.invite(w)
-    Hello from California! Please come soon!
-    >>> print w.invite()
-    Hello from California! Please come soon!
+r'''>>> from getting_started2 import *
+    >>> hi = hello('California')
+    >>> hi.greet()
+    'Hello from California'
+    >>> invite(hi)
+    'Hello from California! Please come soon!'
+    >>> hi.invite()
+    'Hello from California! Please come soon!'
+
+    >>> class wordy(hello):
+    ...     def greet(self):
+    ...         return hello.greet(self) + ', where the weather is fine'
+    ...
+    >>> hi2 = wordy('Florida')
+    >>> hi2.greet()
+    'Hello from Florida, where the weather is fine'
+    >>> invite(hi2)
+    'Hello from Florida! Please come soon!'
 '''
 
 def run(args = None):

From 041409d71570d18cd25351936c4f817db47cd520 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 03:53:56 +0000
Subject: [PATCH 046/369] use BOOST_PYTHON_MODULE_INIT

[SVN r9473]
---
 test/comprehensive.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 3d173310..7699b01f 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -1131,11 +1131,7 @@ void init_module()
     boost_python_test.add(new boost::python::meta_class<boost::python::instance>);
 }
 
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void initboost_python_test()
+BOOST_PYTHON_MODULE_INIT(boost_python_test)
 {
     try {
         bpl_test::init_module();

From a350b666faafe048311aabcc7d9baa48732fce72 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 03:56:25 +0000
Subject: [PATCH 047/369] Added BOOST_PYTHON_MODULE_INIT

[SVN r9475]
---
 include/boost/python/detail/config.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 3207f7c6..9792695e 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -57,4 +57,10 @@
 #  define BOOST_CSTD_ std
 # endif
 
+#ifdef _WIN32
+# define BOOST_PYTHON_MODULE_INIT(name) extern "C" __declspec(dllexport) void init##name()
+#else
+# define BOOST_PYTHON_MODULE_INIT(name) extern "C" void init##name()
+#endif
+
 #endif // CONFIG_DWA052200_H_

From 5759ce9ba0ad80126051762d56492ce0a33b5239 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 22:27:22 +0000
Subject: [PATCH 048/369] no message

[SVN r9482]
---
 build/getting_started1/getting_started1.dsp | 136 ++++++++++++++++++++
 build/getting_started2/getting_started2.dsp | 135 +++++++++++++++++++
 2 files changed, 271 insertions(+)
 create mode 100644 build/getting_started1/getting_started1.dsp
 create mode 100644 build/getting_started2/getting_started2.dsp

diff --git a/build/getting_started1/getting_started1.dsp b/build/getting_started1/getting_started1.dsp
new file mode 100644
index 00000000..a41eb057
--- /dev/null
+++ b/build/getting_started1/getting_started1.dsp
@@ -0,0 +1,136 @@
+# Microsoft Developer Studio Project File - Name="getting_started1" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=getting_started1 - Win32 DebugPython
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "getting_started1.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "getting_started1.mak" CFG="getting_started1 - Win32 DebugPython"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "getting_started1 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "getting_started1 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "getting_started1 - Win32 DebugPython" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=xicl6.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "getting_started1 - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=xilink6.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 /libpath:"c:\tools\python\libs"
+
+!ELSEIF  "$(CFG)" == "getting_started1 - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /GR /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=xilink6.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+
+!ELSEIF  "$(CFG)" == "getting_started1 - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "DebugPython"
+# PROP BASE Intermediate_Dir "DebugPython"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "DebugPython"
+# PROP Intermediate_Dir "DebugPython"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /D "BOOST_DEBUG_PYTHON" /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=xilink6.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:no /pdb:"DebugPython/boost_python_test_d.pdb" /debug /machine:I386 /out:"DebugPython/getting_started1_d.dll" /pdbtype:sept /libpath:"c:\tools\python\src\PCbuild"
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "getting_started1 - Win32 Release"
+# Name "getting_started1 - Win32 Debug"
+# Name "getting_started1 - Win32 DebugPython"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\example\getting_started1.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/build/getting_started2/getting_started2.dsp b/build/getting_started2/getting_started2.dsp
new file mode 100644
index 00000000..284bab21
--- /dev/null
+++ b/build/getting_started2/getting_started2.dsp
@@ -0,0 +1,135 @@
+# Microsoft Developer Studio Project File - Name="getting_started2" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=getting_started2 - Win32 DebugPython
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "getting_started2.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "getting_started2.mak" CFG="getting_started2 - Win32 DebugPython"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "getting_started2 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "getting_started2 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "getting_started2 - Win32 DebugPython" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName "getting_started2"
+# PROP Scc_LocalPath "."
+CPP=xicl6.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "getting_started2 - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=xilink6.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 /libpath:"c:\tools\python\libs"
+
+!ELSEIF  "$(CFG)" == "getting_started2 - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /FR /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=xilink6.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
+
+!ELSEIF  "$(CFG)" == "getting_started2 - Win32 DebugPython"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "getting_started2___Win32_DebugPython"
+# PROP BASE Intermediate_Dir "getting_started2___Win32_DebugPython"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "getting_started2___Win32_DebugPython"
+# PROP Intermediate_Dir "getting_started2___Win32_DebugPython"
+# PROP Ignore_Export_Lib 1
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm- /GR /GX /Zi /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /D "BOOST_DEBUG_PYTHON" /FR /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=xilink6.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:"DebugPython/getting_started2_d.dll" /pdbtype:sept /libpath:"c:\tools\python\src\pcbuild"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "getting_started2 - Win32 Release"
+# Name "getting_started2 - Win32 Debug"
+# Name "getting_started2 - Win32 DebugPython"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\example\getting_started2.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

From 945344b3cd440b9260b2536cb2b3c3f9e0c24714 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 7 Mar 2001 23:31:32 +0000
Subject: [PATCH 049/369] *** empty log message ***

[SVN r9483]
---
 doc/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/index.html b/doc/index.html
index 5a64bf62..c6e0722e 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -97,7 +97,7 @@ among others.
 
       <li>The members of the boost mailing list and the Python community
       supplied invaluable early feedback. In particular, Ron Clarke, Mark Evans,
-      Anton Gluck, Chuck Ingold, Prabhu Ramachandran,n and Barry Scott took the
+      Anton Gluck, Chuck Ingold, Prabhu Ramachandran, and Barry Scott took the
       brave step of trying to use Boost.Python while it was still in early
       stages of development.
 

From bdbd9a0f5fcd711bd3fbca0477914fbf9c741348 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 8 Mar 2001 01:32:12 +0000
Subject: [PATCH 050/369] class_builder<your_class> ->
 class_builder&lt;your_class&gt;

[SVN r9484]
---
 doc/pickle.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/pickle.html b/doc/pickle.html
index 7b559e68..ef3d8d0d 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -132,7 +132,7 @@ Both __getinitargs__ and __getstate__ are not defined.
   this is, e.g.:
 
 <pre>
-    class_builder<your_class> py_your_class(your_module, "your_class");
+    class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
     py_your_class.dict_defines_state();
 </pre>
 
@@ -185,7 +185,7 @@ __getstate__ is defined and the instance's __dict__ is not empty.
   E.g. in C++:
 
 <pre>
-    class_builder<your_class> py_your_class(your_module, "your_class");
+    class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
     py_your_class.getstate_manages_dict();
 </pre>
 

From a55948071695439f870126c1d686d4aeac4df8b3 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 8 Mar 2001 03:01:29 +0000
Subject: [PATCH 051/369] py_cpp => Boost.Python

[SVN r9485]
---
 doc/overriding.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/overriding.html b/doc/overriding.html
index 7b28add1..b29bf0e6 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -92,7 +92,7 @@ struct hello_callback : hello
 <p>
   Finally, we add <tt>hello_callback</tt> to the <tt>
   class_builder&lt;&gt;</tt> declaration in our module initialization
-  function, and when we define the function, we must tell py_cpp about the default
+  function, and when we define the function, we must tell Boost.Python about the default
   implementation:
 
 <blockquote><pre>
@@ -120,7 +120,7 @@ hello_class.def(&amp;hello::greet, "greet", &amp;<b>hello_callback::default_gree
     <p>
       <a name="why_derived">*</a>You may ask, "Why do we need this derived
       class? This could have been designed so that everything gets done right
-      inside of <tt>hello</tt>." One of the goals of py_cpp is to be
+      inside of <tt>hello</tt>." One of the goals of Boost.Python is to be
       minimally intrusive on an existing C++ design. In principle, it should be
       possible to expose the interface for a 3rd party library without changing
       it. To unintrusively hook into the virtual functions so that a Python

From 33ea0dbdeeadd3b4ad77f223843276d9a08867f6 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 9 Mar 2001 02:40:06 +0000
Subject: [PATCH 052/369] temp file before branching

[SVN r9515]
---
 doc/cross_module_dependencies.html | 253 +++++++++++++++++++++++++++++
 1 file changed, 253 insertions(+)
 create mode 100644 doc/cross_module_dependencies.html

diff --git a/doc/cross_module_dependencies.html b/doc/cross_module_dependencies.html
new file mode 100644
index 00000000..3d416bf5
--- /dev/null
+++ b/doc/cross_module_dependencies.html
@@ -0,0 +1,253 @@
+<html>
+<head>
+ <title>Cross-extension-module dependencies</title>
+</head>
+<body>
+
+<img src="../../../c++boost.gif"
+     alt="c++boost.gif (8819 bytes)"
+     align="center"
+     width="277" height="86"> 
+
+</body>
+<hr>
+<h1>Cross-extension-module dependencies</h1>
+
+It is good programming practice to organize large projects as modules
+that interact with each other via well defined interfaces. With
+Boost.Python it is possible to reflect this organization at the C++
+level at the Python level. This is, each logical C++ module can be
+organized as a separate Python extension module.
+
+<p>
+At first sight this might seem natural and straightforward. However, it
+is a fairly complex problem to establish cross-extension-module
+dependencies while maintaining the same ease of use Boost.Python
+provides for classes that are wrapped in the same extension module. To
+a large extent this complexity can be hidden from the author of a
+Boost.Python extension module, but not entirely.
+
+<h1>The recipe</h1>
+
+Suppose there is an extension module that exposes certain instances of
+the C++ std::vector template library such that it can be used from
+Python in the following manner:
+
+<pre>
+import std_vector
+v = std_vector.double([1, 2, 3, 4])
+v.push_back(5)
+v.size()
+</pre>
+
+Suppose the std_vector module is done well and reflects all C++
+functions that are useful at the Python level, for all C++ built-in
+data types (std_vector.int, std_vector.long, etc.).
+
+<p>
+Suppose further that there is statistic module with a C++ class that
+has constructors or member functions that use or return a std::vector.
+For example:
+
+<pre>
+class xy {
+  private:
+    std::vector&lt;double&gt; m_x;
+    std::vector&lt;double&gt; m_y;
+  public:
+    xy(const std::vector&lt;double&gt;&amp; x, const std::vector&lt;double&gt;&amp; y) : m_x(x), m_y(y) {}
+    const std::vector&lt;double&gt;&amp; x() const { return m_x; }
+    const std::vector&lt;double&gt;&amp; y() const { return m_y; }
+    double correlation();
+}
+</pre>
+
+What is more natural then reusing the std_vector extension module to
+expose these constructors or functions to Python?
+
+<p>
+Unfortunately, what seems natural needs a little work in both the
+std_vector and the statistics module.
+
+<p>
+In the std_vector extension module, std::vector&lt;double&gt; needs to be
+exposed to Python with the x_class_builder&lt;&gt; template instead of the
+regular class_builder&lt;&gt;. For example:
+
+<pre>
+  x_class_builder&lt;std::vector&lt;double&gt; &gt; v_double(std_vector_module, &quot;double&quot;);
+</pre>
+
+In the extension module that wraps class xy we need to use
+the import_class_builder&lt;&gt; template:
+
+<pre>
+  import_class_builder&lt;std::vector&lt;double&gt; &gt; v_double(&quot;std_vector&quot;, &quot;double&quot;);
+</pre>
+
+That is all. All the properties that are defined for std_vector.double
+in the std_vector Boost.Python module will be available for the
+returned objects of xy.x() and xy.y(). Similarly, the constructor for
+xy will accept objects that were created by the std_vector module.
+
+<h1>Non-copyable types</h1>
+
+The x_class_builder&lt;T&gt; instantiates template functions that invoke the
+copy constructor of T. For a T that is non-copyable this will result in
+compile-time error messages. In such a case, another variety of the
+class_builder&lt;&gt;, the xptr_class_builder&lt;&gt; must be used.
+For example:
+
+<pre>
+xptr_class_builder&lt;store&gt; py_store(your_module, &quot;store&quot;);
+</pre>
+
+The corresponding import_class_builder&lt;&gt; does not need any special
+attention:
+
+<pre>
+import_class_builder&lt;store&gt; py_store(&quot;noncopyable_export&quot;, &quot;store&quot;);
+</pre>
+
+<h1>Python module search path</h1>
+
+The std_vector and statistics modules can now be used in the following
+way:
+
+<pre>
+import std_vector
+import statistics
+x = std_vector.double([1, 2, 3, 4])
+y = std_vector.double([2, 4, 6, 8])
+xy = statistics.xy(x, y)
+xy.correlation()
+</pre>
+
+In this example it is clear that Python has to be able to find both the
+std_vector and the statistics extension module. In other words, both
+extension modules need to be in the Python module search path
+(sys.path).
+
+<p>
+The situation is not always that obvious. Suppose the statistics
+module has a random function that returns a vector of random
+numbers with a given length:
+
+<pre>
+import statistics
+x = statistics.random(5)
+y = statistics.random(5)
+xy = statistics.xy(x, y)
+xy.correlation()
+</pre>
+
+A naive user will not easily anticipate that the std_vector module is
+used to pass the x and y vectors around. If the std_vector module is in
+the Python module search path, this form of ignorance is of no harm.
+On the contrary, we are glad that we do not have to bother the user
+with details like this.
+
+<p>
+If the std_vector module is not in the Python module search path, a
+Python exception will be raised:
+
+<pre>
+Traceback (innermost last):
+  File &quot;foo.py&quot;, line 2, in ?
+    x = statistics.random(5)
+ImportError: No module named std_vector
+</pre>
+
+As is the case with any system of a non-trivial complexity, it is
+important that the setup is consistent and complete.
+
+<h1>Two-way module dependencies</h1>
+
+Boost.Python supports two-way module dependencies. This is best
+illustrated by a simple example.
+
+<p>
+Suppose there is a module ivect that implements vectors of integers,
+and a similar module dvect that implements vectors of doubles. We want
+to be able do convert an integer vector to a double vector and vice
+versa. For example:
+
+<pre>
+import ivect
+iv = ivect.ivect((1,2,3,4,5))
+dv = iv.as_dvect()
+</pre>
+
+The last expression will implicitly import the dvect module in order to
+enable the conversion of the C++ representation of dvect to a Python
+object. The analogous is possible for a dvect:
+
+<pre>
+import dvect
+dv = dvect.dvect((1,2,3,4,5))
+iv = dv.as_ivect()
+</pre>
+
+Now the ivect module is imported implicitly.
+
+<p>
+Note that the two-way dependencies are possible because the
+dependencies are resolved only when needed. This is, the initialization
+of the ivect module does not rely on the dvect module, and vice versa.
+Only if as_dvect() or as_ivect() is actually invoked will the
+corresponding module be implicitly imported. This also means that, for
+example, the dvect module does not have to be available at all if
+as_dvect() is never used.
+
+<h1>Clarification of compile-time and link-time dependencies</h1>
+
+Boost.Python's support for resolving cross-module dependencies at
+runtime does not imply that compile-time dependencies are eliminated.
+For example, the statistics extension module in the example above will
+need to #include &lt;vector&gt;. This is immediately obvious from the
+definition of class xy.
+
+<p>
+If a library is wrapped that consists of both header files and compiled
+components (e.g. libdvect.a, dvect.lib, etc.), both the Boost.Python
+extension module with the x_class_wrapper&lt;&gt; and the module with the
+import_class_wrapper&lt;&gt; need to be linked against the object library.
+Ideally one would build a shared library (e.g.  libdvect.so, dvect.dll,
+etc.). However, this introduces the issue of getting the search path
+for the dynamic loading configured correctly. For small libraries it is
+therefore often more convenient to ignore the fact that the object
+files are loaded into memory more than once.
+
+<p>
+The main purpose of Boost.Python's support for resolving cross-module
+dependencies at runtime is to allow for a modular system layout. With
+this support it is straightforward to reflect C++ code organization at
+the Python level. Without the cross-module support, a multi-purpose
+module like std_vector would be impractical because the entire wrapper
+code would somehow have to be duplicated in all extension modules that
+use it, making them harder to maintain and harder to build.
+
+<p>
+Finally, there is an important psychological component. If a group of
+classes is lumped together with many others in a huge module, the
+authors will have difficulties in being identified with their work.
+The situation is much more transparent if the work is represented by
+a module with a recognizable name. This is not just a question of
+strong egos, but also of getting credit and funding.
+
+<h1>Why not use the x_class_builder universally?</h1>
+
+There is some overhead associated with the Boost.Python cross-module
+support. Depending on the platform, the code generated by
+x_class_builder&lt;&gt; is roughly 10%-20% larger than that generated by
+class_builder&lt;&gt;. For a large extension module with many wrapped
+classes, this could mean a significant difference. Therefore the
+general recommendation is to use x_class_wrapper&lt;&gt; only for classes
+that are likely to be used as function arguments or return values in
+other modules.
+
+<hr>
+<address>
+Author: Ralf W. Grosse-Kunstleve, March 2001
+</address>
+</html>

From a6b0fa546a1d0f0cfc08068ebaa9bfad3c7c8b9a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 9 Mar 2001 02:41:16 +0000
Subject: [PATCH 053/369] temp file removed after branching.

[SVN r9516]
---
 doc/cross_module_dependencies.html | 253 -----------------------------
 1 file changed, 253 deletions(-)
 delete mode 100644 doc/cross_module_dependencies.html

diff --git a/doc/cross_module_dependencies.html b/doc/cross_module_dependencies.html
deleted file mode 100644
index 3d416bf5..00000000
--- a/doc/cross_module_dependencies.html
+++ /dev/null
@@ -1,253 +0,0 @@
-<html>
-<head>
- <title>Cross-extension-module dependencies</title>
-</head>
-<body>
-
-<img src="../../../c++boost.gif"
-     alt="c++boost.gif (8819 bytes)"
-     align="center"
-     width="277" height="86"> 
-
-</body>
-<hr>
-<h1>Cross-extension-module dependencies</h1>
-
-It is good programming practice to organize large projects as modules
-that interact with each other via well defined interfaces. With
-Boost.Python it is possible to reflect this organization at the C++
-level at the Python level. This is, each logical C++ module can be
-organized as a separate Python extension module.
-
-<p>
-At first sight this might seem natural and straightforward. However, it
-is a fairly complex problem to establish cross-extension-module
-dependencies while maintaining the same ease of use Boost.Python
-provides for classes that are wrapped in the same extension module. To
-a large extent this complexity can be hidden from the author of a
-Boost.Python extension module, but not entirely.
-
-<h1>The recipe</h1>
-
-Suppose there is an extension module that exposes certain instances of
-the C++ std::vector template library such that it can be used from
-Python in the following manner:
-
-<pre>
-import std_vector
-v = std_vector.double([1, 2, 3, 4])
-v.push_back(5)
-v.size()
-</pre>
-
-Suppose the std_vector module is done well and reflects all C++
-functions that are useful at the Python level, for all C++ built-in
-data types (std_vector.int, std_vector.long, etc.).
-
-<p>
-Suppose further that there is statistic module with a C++ class that
-has constructors or member functions that use or return a std::vector.
-For example:
-
-<pre>
-class xy {
-  private:
-    std::vector&lt;double&gt; m_x;
-    std::vector&lt;double&gt; m_y;
-  public:
-    xy(const std::vector&lt;double&gt;&amp; x, const std::vector&lt;double&gt;&amp; y) : m_x(x), m_y(y) {}
-    const std::vector&lt;double&gt;&amp; x() const { return m_x; }
-    const std::vector&lt;double&gt;&amp; y() const { return m_y; }
-    double correlation();
-}
-</pre>
-
-What is more natural then reusing the std_vector extension module to
-expose these constructors or functions to Python?
-
-<p>
-Unfortunately, what seems natural needs a little work in both the
-std_vector and the statistics module.
-
-<p>
-In the std_vector extension module, std::vector&lt;double&gt; needs to be
-exposed to Python with the x_class_builder&lt;&gt; template instead of the
-regular class_builder&lt;&gt;. For example:
-
-<pre>
-  x_class_builder&lt;std::vector&lt;double&gt; &gt; v_double(std_vector_module, &quot;double&quot;);
-</pre>
-
-In the extension module that wraps class xy we need to use
-the import_class_builder&lt;&gt; template:
-
-<pre>
-  import_class_builder&lt;std::vector&lt;double&gt; &gt; v_double(&quot;std_vector&quot;, &quot;double&quot;);
-</pre>
-
-That is all. All the properties that are defined for std_vector.double
-in the std_vector Boost.Python module will be available for the
-returned objects of xy.x() and xy.y(). Similarly, the constructor for
-xy will accept objects that were created by the std_vector module.
-
-<h1>Non-copyable types</h1>
-
-The x_class_builder&lt;T&gt; instantiates template functions that invoke the
-copy constructor of T. For a T that is non-copyable this will result in
-compile-time error messages. In such a case, another variety of the
-class_builder&lt;&gt;, the xptr_class_builder&lt;&gt; must be used.
-For example:
-
-<pre>
-xptr_class_builder&lt;store&gt; py_store(your_module, &quot;store&quot;);
-</pre>
-
-The corresponding import_class_builder&lt;&gt; does not need any special
-attention:
-
-<pre>
-import_class_builder&lt;store&gt; py_store(&quot;noncopyable_export&quot;, &quot;store&quot;);
-</pre>
-
-<h1>Python module search path</h1>
-
-The std_vector and statistics modules can now be used in the following
-way:
-
-<pre>
-import std_vector
-import statistics
-x = std_vector.double([1, 2, 3, 4])
-y = std_vector.double([2, 4, 6, 8])
-xy = statistics.xy(x, y)
-xy.correlation()
-</pre>
-
-In this example it is clear that Python has to be able to find both the
-std_vector and the statistics extension module. In other words, both
-extension modules need to be in the Python module search path
-(sys.path).
-
-<p>
-The situation is not always that obvious. Suppose the statistics
-module has a random function that returns a vector of random
-numbers with a given length:
-
-<pre>
-import statistics
-x = statistics.random(5)
-y = statistics.random(5)
-xy = statistics.xy(x, y)
-xy.correlation()
-</pre>
-
-A naive user will not easily anticipate that the std_vector module is
-used to pass the x and y vectors around. If the std_vector module is in
-the Python module search path, this form of ignorance is of no harm.
-On the contrary, we are glad that we do not have to bother the user
-with details like this.
-
-<p>
-If the std_vector module is not in the Python module search path, a
-Python exception will be raised:
-
-<pre>
-Traceback (innermost last):
-  File &quot;foo.py&quot;, line 2, in ?
-    x = statistics.random(5)
-ImportError: No module named std_vector
-</pre>
-
-As is the case with any system of a non-trivial complexity, it is
-important that the setup is consistent and complete.
-
-<h1>Two-way module dependencies</h1>
-
-Boost.Python supports two-way module dependencies. This is best
-illustrated by a simple example.
-
-<p>
-Suppose there is a module ivect that implements vectors of integers,
-and a similar module dvect that implements vectors of doubles. We want
-to be able do convert an integer vector to a double vector and vice
-versa. For example:
-
-<pre>
-import ivect
-iv = ivect.ivect((1,2,3,4,5))
-dv = iv.as_dvect()
-</pre>
-
-The last expression will implicitly import the dvect module in order to
-enable the conversion of the C++ representation of dvect to a Python
-object. The analogous is possible for a dvect:
-
-<pre>
-import dvect
-dv = dvect.dvect((1,2,3,4,5))
-iv = dv.as_ivect()
-</pre>
-
-Now the ivect module is imported implicitly.
-
-<p>
-Note that the two-way dependencies are possible because the
-dependencies are resolved only when needed. This is, the initialization
-of the ivect module does not rely on the dvect module, and vice versa.
-Only if as_dvect() or as_ivect() is actually invoked will the
-corresponding module be implicitly imported. This also means that, for
-example, the dvect module does not have to be available at all if
-as_dvect() is never used.
-
-<h1>Clarification of compile-time and link-time dependencies</h1>
-
-Boost.Python's support for resolving cross-module dependencies at
-runtime does not imply that compile-time dependencies are eliminated.
-For example, the statistics extension module in the example above will
-need to #include &lt;vector&gt;. This is immediately obvious from the
-definition of class xy.
-
-<p>
-If a library is wrapped that consists of both header files and compiled
-components (e.g. libdvect.a, dvect.lib, etc.), both the Boost.Python
-extension module with the x_class_wrapper&lt;&gt; and the module with the
-import_class_wrapper&lt;&gt; need to be linked against the object library.
-Ideally one would build a shared library (e.g.  libdvect.so, dvect.dll,
-etc.). However, this introduces the issue of getting the search path
-for the dynamic loading configured correctly. For small libraries it is
-therefore often more convenient to ignore the fact that the object
-files are loaded into memory more than once.
-
-<p>
-The main purpose of Boost.Python's support for resolving cross-module
-dependencies at runtime is to allow for a modular system layout. With
-this support it is straightforward to reflect C++ code organization at
-the Python level. Without the cross-module support, a multi-purpose
-module like std_vector would be impractical because the entire wrapper
-code would somehow have to be duplicated in all extension modules that
-use it, making them harder to maintain and harder to build.
-
-<p>
-Finally, there is an important psychological component. If a group of
-classes is lumped together with many others in a huge module, the
-authors will have difficulties in being identified with their work.
-The situation is much more transparent if the work is represented by
-a module with a recognizable name. This is not just a question of
-strong egos, but also of getting credit and funding.
-
-<h1>Why not use the x_class_builder universally?</h1>
-
-There is some overhead associated with the Boost.Python cross-module
-support. Depending on the platform, the code generated by
-x_class_builder&lt;&gt; is roughly 10%-20% larger than that generated by
-class_builder&lt;&gt;. For a large extension module with many wrapped
-classes, this could mean a significant difference. Therefore the
-general recommendation is to use x_class_wrapper&lt;&gt; only for classes
-that are likely to be used as function arguments or return values in
-other modules.
-
-<hr>
-<address>
-Author: Ralf W. Grosse-Kunstleve, March 2001
-</address>
-</html>

From 55321b87785ef71e51669bc562211dc534884032 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 9 Mar 2001 18:59:59 +0000
Subject: [PATCH 054/369] HTML 4.0 Strict fixes.

[SVN r9530]
---
 doc/pickle.html | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/doc/pickle.html b/doc/pickle.html
index ef3d8d0d..49f5c605 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -1,15 +1,15 @@
-<html>
-<head>
- <title>Boost.Python Pickle Support</title>
-</head>
-<body>
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+
+<title>Boost.Python Pickle Support</title>
+
+<div>
 
 <img src="../../../c++boost.gif"
      alt="c++boost.gif (8819 bytes)"
      align="center"
      width="277" height="86"> 
 
-</body>
 <hr>
 <h1>Boost.Python Pickle Support</h1>
 
@@ -28,15 +28,14 @@ can be written to a file.
 <p>
 The Boost Python Library supports the pickle module by emulating the
 interface implemented by Jim Fulton's ExtensionClass module that is
-included in the ZOPE distribution
-(<a href="http://www.zope.org/">http://www.zope.org/</a>).
+included in the
+<a href="http://www.zope.org/"
+>ZOPE</a>
+distribution.
 This interface is similar to that for regular Python classes as
-described in detail in the Python Library Reference for pickle:
-
-<blockquote>
-    <a href="http://www.python.org/doc/current/lib/module-pickle.html"
-            >http://www.python.org/doc/current/lib/module-pickle.html</a>
-</blockquote>
+described in detail in the
+<a href="http://www.python.org/doc/current/lib/module-pickle.html"
+>Python Library Reference for pickle.</a>
 
 <hr>
 <h1>The Boost.Python Pickle Interface</h1>
@@ -220,4 +219,4 @@ __getstate__ is defined and the instance's __dict__ is not empty.
 <address>
 Author: Ralf W. Grosse-Kunstleve, March 2001
 </address>
-</html>
+</div>

From 494f12090f4090d1678f7f2b5fb06130e9814fca Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 9 Mar 2001 19:02:12 +0000
Subject: [PATCH 055/369] Use only one <h1> (although the validator did not
 complain).

[SVN r9531]
---
 doc/pickle.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/pickle.html b/doc/pickle.html
index 49f5c605..3ec8c928 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -38,7 +38,7 @@ described in detail in the
 >Python Library Reference for pickle.</a>
 
 <hr>
-<h1>The Boost.Python Pickle Interface</h1>
+<h2>The Boost.Python Pickle Interface</h2>
 
 At the user level, the Boost.Python pickle interface involves three special
 methods:
@@ -93,7 +93,7 @@ returned by __getstate__ need not be a dictionary. The __getstate__ and
 __setstate__ methods can do what they want.
 
 <hr>
-<h1>Pitfalls and Safety Guards</h1>
+<h2>Pitfalls and Safety Guards</h2>
 
 In Boost.Python extension modules with many extension classes, providing
 complete pickle support for all classes would be a significant
@@ -202,7 +202,7 @@ __getstate__ is defined and the instance's __dict__ is not empty.
 </dl>
 
 <hr>
-<h1>Practical Advice</h1>
+<h2>Practical Advice</h2>
 
 <ul>
 <li>

From 585063f6e18a37e90febc4409595f99f8d35c3f8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 9 Mar 2001 20:04:56 +0000
Subject: [PATCH 056/369] Small enhancements.

[SVN r9532]
---
 doc/pickle.html | 136 +++++++++++++++++++++++++++---------------------
 1 file changed, 77 insertions(+), 59 deletions(-)

diff --git a/doc/pickle.html b/doc/pickle.html
index 3ec8c928..39cb07dc 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -45,81 +45,87 @@ methods:
 
 <dl>
 <dt>
-<strong>__getinitargs__</strong>
+<strong><tt>__getinitargs__</tt></strong>
 <dd>
-  When an instance of a Boost.Python extension class is pickled, the pickler
-  tests if the instance has a __getinitargs__ method. This method must
-  return a Python tuple. When the instance is restored by the
+  When an instance of a Boost.Python extension class is pickled, the
+  pickler tests if the instance has a <tt>__getinitargs__</tt> method.
+  This method must return a Python tuple (it is most convenient to use
+  a boost::python::tuple). When the instance is restored by the
   unpickler, the contents of this tuple are used as the arguments for
   the class constructor.
 
   <p>
-  If __getinitargs__ is not defined, the class constructor will be
-  called without arguments.
+  If <tt>__getinitargs__</tt> is not defined, the class constructor
+  will be called without arguments.
 
 <p>
 <dt>
-<strong>__getstate__</strong>
+<strong><tt>__getstate__</tt></strong>
 
 <dd>
-  When an instance of a Boost.Python extension class is pickled, the pickler
-  tests if the instance has a __getstate__ method. This method should
-  return a Python object representing the state of the instance.
+  When an instance of a Boost.Python extension class is pickled, the
+  pickler tests if the instance has a <tt>__getstate__</tt> method.
+  This method should return a Python object representing the state of
+  the instance.
 
   <p>
-  If __getstate__ is not defined, the instance's __dict__ is pickled
-  (if it is not empty).
+  If <tt>__getstate__</tt> is not defined, the instance's
+  <tt>__dict__</tt> is pickled (if it is not empty).
 
 <p>
 <dt>
-<strong>__setstate__</strong>
+<strong><tt>__setstate__</tt></strong>
 
 <dd>
   When an instance of a Boost.Python extension class is restored by the
   unpickler, it is first constructed using the result of
-  __getinitargs__ as arguments (see above). Subsequently the unpickler
-  tests if the new instance has a __setstate__ method. If so, this
-  method is called with the result of __getstate__ (a Python object) as
-  the argument.
+  <tt>__getinitargs__</tt> as arguments (see above). Subsequently the
+  unpickler tests if the new instance has a <tt>__setstate__</tt>
+  method. If so, this method is called with the result of
+  <tt>__getstate__</tt> (a Python object) as the argument.
 
   <p>
-  If __setstate__ is not defined, the result of __getstate__ must be
-  a Python dictionary. The items of this dictionary are added to
-  the instance's __dict__.
+  If <tt>__setstate__</tt> is not defined, the result of
+  <tt>__getstate__</tt> must be a Python dictionary. The items of this
+  dictionary are added to the instance's <tt>__dict__</tt>.
+
 </dl>
 
-If both __getstate__ and __setstate__ are defined, the Python object
-returned by __getstate__ need not be a dictionary. The __getstate__ and
-__setstate__ methods can do what they want.
+If both <tt>__getstate__</tt> and <tt>__setstate__</tt> are defined,
+the Python object returned by <tt>__getstate__</tt> need not be a
+dictionary. The <tt>__getstate__</tt> and <tt>__setstate__</tt> methods
+can do what they want.
 
 <hr>
 <h2>Pitfalls and Safety Guards</h2>
 
-In Boost.Python extension modules with many extension classes, providing
-complete pickle support for all classes would be a significant
-overhead. In general complete pickle support should only be implemented
-for extension classes that will eventually be pickled. However, the
-author of a Boost.Python extension module might not anticipate correctly which
-classes need support for pickle. Unfortunately, the pickle protocol
-described above has two important pitfalls that the end user of a Boost.Python
-extension module might not be aware of:
+In Boost.Python extension modules with many extension classes,
+providing complete pickle support for all classes would be a
+significant overhead. In general complete pickle support should only be
+implemented for extension classes that will eventually be pickled.
+However, the author of a Boost.Python extension module might not
+anticipate correctly which classes need support for pickle.
+Unfortunately, the pickle protocol described above has two important
+pitfalls that the end user of a Boost.Python extension module might not
+be aware of:
 
 <dl>
 <dt>
 <strong>Pitfall 1:</strong>
-Both __getinitargs__ and __getstate__ are not defined.
+Both <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined.
 
 <dd>
   In this situation the unpickler calls the class constructor without
-  arguments and then adds the __dict__ that was pickled by default to
-  that of the new instance.
+  arguments and then adds the <tt>__dict__</tt> that was pickled by
+  default to that of the new instance.
 
   <p>
-  However, most C++ classes wrapped with Boost.Python will have member data
-  that are not restored correctly by this procedure. To alert the user
-  to this problem, a safety guard is provided. If both __getinitargs__
-  and __getstate__ are not defined, Boost.Python tests if the class has an
-  attribute __dict_defines_state__. An exception is raised if this
+  However, most C++ classes wrapped with Boost.Python will have member
+  data that are not restored correctly by this procedure. To alert the
+  user to this problem, a safety guard is provided. If both
+  <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined,
+  Boost.Python tests if the class has an attribute
+  <tt>__dict_defines_state__</tt>. An exception is raised if this
   attribute is not defined:
 
 <pre>
@@ -147,41 +153,44 @@ Both __getinitargs__ and __getstate__ are not defined.
 <p>
 <dt>
 <strong>Pitfall 2:</strong>
-__getstate__ is defined and the instance's __dict__ is not empty.
+<tt>__getstate__</tt> is defined and the instance's <tt>__dict__</tt> is not empty.
 
 <dd>
-  The author of a Boost.Python extension class might provide a __getstate__
-  method without considering the possibilities that:
+  The author of a Boost.Python extension class might provide a
+  <tt>__getstate__</tt> method without considering the possibilities
+  that:
 
   <p>
   <ul>
   <li>
-    his class is used as a base class. Most likely the __dict__ of
-    instances of the derived class needs to be pickled in order to
-    restore the instances correctly.
+    his class is used in Python as a base class. Most likely the
+    <tt>__dict__</tt> of instances of the derived class needs to be
+    pickled in order to restore the instances correctly.
 
   <p>
   <li>
-    the user adds items to the instance's __dict__ directly. Again,
-    the __dict__ of the instance then needs to be pickled.
+    the user adds items to the instance's <tt>__dict__</tt> directly.
+    Again, the <tt>__dict__</tt> of the instance then needs to be
+    pickled.
+
   </ul>
   <p>
 
   To alert the user to this highly unobvious problem, a safety guard is
-  provided. If __getstate__ is defined and the instance's __dict__ is
-  not empty, Boost.Python tests if the class has an attribute
-  __getstate_manages_dict__. An exception is raised if this attribute
-  is not defined:
+  provided. If <tt>__getstate__</tt> is defined and the instance's
+  <tt>__dict__</tt> is not empty, Boost.Python tests if the class has
+  an attribute <tt>__getstate_manages_dict__</tt>. An exception is
+  raised if this attribute is not defined:
 
 <pre>
     RuntimeError: Incomplete pickle support (__getstate_manages_dict__ not set)
 </pre>
 
   To resolve this problem, it should first be established that the
-  __getstate__ and __setstate__ methods manage the instances's __dict__
-  correctly. Note that this can be done both at the C++ and the Python
-  level. Finally, the safety guard should intentionally be overridden.
-  E.g. in C++:
+  <tt>__getstate__</tt> and <tt>__setstate__</tt> methods manage the
+  instances's <tt>__dict__</tt> correctly. Note that this can be done
+  both at the C++ and the Python level. Finally, the safety guard
+  should intentionally be overridden.  E.g. in C++:
 
 <pre>
     class_builder&lt;your_class&gt; py_your_class(your_module, "your_class");
@@ -206,15 +215,24 @@ __getstate__ is defined and the instance's __dict__ is not empty.
 
 <ul>
 <li>
-  Avoid using __getstate__ if the instance can also be reconstructed
-  by way of __getinitargs__. This automatically avoids Pitfall 2.
+  Avoid using <tt>__getstate__</tt> if the instance can also be
+  reconstructed by way of <tt>__getinitargs__</tt>. This automatically
+  avoids Pitfall 2.
 
 <p>
 <li>
-  If __getstate__ is required, include the instance's __dict__ in the
-  Python object that is returned.
+  If <tt>__getstate__</tt> is required, include the instance's
+  <tt>__dict__</tt> in the Python object that is returned.
+
 </ul>
 
+<hr>
+<h2>Example</h2>
+
+An example that shows how to provide pickle support is available in the
+<tt>boost/lib/python/example</tt> directory
+(<tt>getting_started3.cpp</tt>).
+
 <hr>
 <address>
 Author: Ralf W. Grosse-Kunstleve, March 2001

From f5416ebce07b914ed6fd83754f414e53bd2b5563 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 10 Mar 2001 00:36:03 +0000
Subject: [PATCH 057/369] Fixed some doc bugs and improved an example

[SVN r9533]
---
 doc/overriding.html | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/doc/overriding.html b/doc/overriding.html
index b29bf0e6..0fc7a2e6 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -142,6 +142,7 @@ hello_class.def(&amp;hello::greet, "greet", &amp;<b>hello_callback::default_gree
 <pre>
 struct baz {
     <strong>virtual</strong> int pure(int) = 0;
+    int calls_pure(int x) { return pure(x) + 1000; }
 };
 
 struct baz_callback {
@@ -154,7 +155,7 @@ BOOST_PYTHON_MODULE_INIT(foobar)
     {
        boost::python::module_builder foobar("foobar");
        boost::python::class_builder&lt;baz,baz_callback&gt; baz_class("baz");
-       baz_class.def(&amp;baz::pure, "pure");
+       baz_class.def(&amp;baz::calls_pure, "calls_pure");
     }
     catch(...)
     {
@@ -173,12 +174,18 @@ BOOST_PYTHON_MODULE_INIT(foobar)
 Traceback (innermost last):
   File "&lt;stdin&gt;", line 1, in ?
 AttributeError: pure
+&gt;&gt;&gt; x.calls_pure(1)
+Traceback (innermost last):
+  File "&lt;stdin&gt;", line 1, in ?
+AttributeError: pure
 &gt;&gt;&gt; class mumble(baz):
 ...    def pure(self, x): return x + 1
 ...
 &gt;&gt;&gt; y = mumble()
 &gt;&gt;&gt; y.pure(99)
 100
+&gt;&gt;&gt; y.calls_pure(99)
+1100
 </pre></blockquote>
 
 <a name="private"><h2>Private Non-Pure Virtual Functions</h2></a>
@@ -192,6 +199,7 @@ this limited way without breaking binary compatibility (though it will certainly
 break the <a
 href="http://cs.calvin.edu/c++/C++Standard-Nov97/basic.html#basic.def.odr">ODR</a>).
 
+<hr>
     <p>
       Next: <a href="overloading.html">Function Overloading</a>
       Previous: <a href="exporting_classes.html">Exporting Classes</a>

From 678fa006de24673b654fc057a165e79a2108a734 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 10 Mar 2001 08:23:37 +0000
Subject: [PATCH 058/369] Copyright notice & minor fixes.

[SVN r9536]
---
 doc/pickle.html | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/doc/pickle.html b/doc/pickle.html
index 39cb07dc..842112d3 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -8,7 +8,7 @@
 <img src="../../../c++boost.gif"
      alt="c++boost.gif (8819 bytes)"
      align="center"
-     width="277" height="86"> 
+     width="277" height="86">
 
 <hr>
 <h1>Boost.Python Pickle Support</h1>
@@ -229,12 +229,17 @@ Both <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined.
 <hr>
 <h2>Example</h2>
 
-An example that shows how to provide pickle support is available in the
+An example that shows how to configure pickle support is available in the
 <tt>boost/lib/python/example</tt> directory
 (<tt>getting_started3.cpp</tt>).
 
 <hr>
-<address>
-Author: Ralf W. Grosse-Kunstleve, March 2001
-</address>
+&copy; Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy,
+use, modify, sell and distribute this document is granted provided this
+copyright notice appears in all copies. This document is provided "as
+is" without express or implied warranty, and with no claim as to its
+suitability for any purpose.
+
+<p>
+Updated: March 10, 2001
 </div>

From 14acb1af8c1ef20c1a49ea1a2901e6b49817f2e2 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 10 Mar 2001 19:09:10 +0000
Subject: [PATCH 059/369] Fix bugs (m_self => self)

[SVN r9539]
---
 doc/overriding.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/overriding.html b/doc/overriding.html
index 0fc7a2e6..66c3610c 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -79,13 +79,13 @@ struct hello_callback : hello
 
     // Override greet to call back into Python
     std::string greet() const // <a href="#derived_4">4</a>
-        { return boost::python::callback&lt;std::string&gt;::call_method(m_self, "greet"); }
+        { return boost::python::callback&lt;std::string&gt;::call_method(self, "greet"); }
 
     // Supplies the default implementation of greet
     static std::string <a name= "default_implementation">default_greet</a>(const hello& self) const // <a href="#derived_5">5</a>
         { return self.hello::greet(); }
  private:
-    PyObject* m_self; // <a href="#derived_1">1</a>
+    PyObject* self; // <a href="#derived_1">1</a>
 };
 </pre></blockquote>
 

From 7dc8fab961c798a832c959096462f901c8ec48f7 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 11 Mar 2001 21:29:31 +0000
Subject: [PATCH 060/369] 11 Mar 01  std::string *MAY* include nulls (Alex
 Martelli)

[SVN r9544]
---
 src/conversions.cpp | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/conversions.cpp b/src/conversions.cpp
index 88e30048..9445c7f3 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -7,6 +7,7 @@
 //  producing this work.
 //
 // Revision History:
+// 11 Mar 01  std::string *MAY* include nulls (Alex Martelli)
 // 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
 // 03 Mar 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
 
@@ -149,7 +150,7 @@ int from_python(PyObject* p, boost::python::type<int> type)
 
 PyObject* to_python(unsigned int i)
 {
-	return integer_to_python(i);
+    return integer_to_python(i);
 }
 
 unsigned int from_python(PyObject* p, boost::python::type<unsigned int> type)
@@ -169,7 +170,7 @@ float from_python(PyObject* p, boost::python::type<float>)
 
 PyObject* to_python(unsigned short i)
 {
-	return integer_to_python(i);
+    return integer_to_python(i);
 }
 
 unsigned short from_python(PyObject* p, boost::python::type<unsigned short> type)
@@ -197,7 +198,7 @@ char from_python(PyObject* p, boost::python::type<char>)
 
 PyObject* to_python(unsigned char i)
 {
-	return integer_to_python(i);
+    return integer_to_python(i);
 }
 
 unsigned char from_python(PyObject* p, boost::python::type<unsigned char> type)
@@ -207,7 +208,7 @@ unsigned char from_python(PyObject* p, boost::python::type<unsigned char> type)
 
 PyObject* to_python(signed char i)
 {
-	return integer_to_python(i);
+    return integer_to_python(i);
 }
 
 signed char from_python(PyObject* p, boost::python::type<signed char> type)
@@ -243,12 +244,15 @@ const char* from_python(PyObject* p, boost::python::type<const char*>)
 
 PyObject* to_python(const std::string& s)
 {
-	return PyString_FromString(s.c_str());
+    return PyString_FromStringAndSize(s.data(), s.size());
 }
 
 std::string from_python(PyObject* p, boost::python::type<std::string>)
 {
-    return std::string(from_python(p, boost::python::type<const char*>()));
+    char* buffer = 0;
+    int length = 0;
+    int rc = PyString_AsStringAndSize(p, &buffer, &length);
+    return std::string(buffer, length);
 }
 
 bool from_python(PyObject* p, boost::python::type<bool>)

From ed34cd45f1da43539e40e8b9d51e360312c422c0 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Mon, 12 Mar 2001 19:32:40 +0000
Subject: [PATCH 061/369] Python 1.5.2 fixes

[SVN r9546]
---
 src/conversions.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/conversions.cpp b/src/conversions.cpp
index 9445c7f3..1bc923b1 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -7,6 +7,7 @@
 //  producing this work.
 //
 // Revision History:
+// 12 Mar 01  Python 1.5.2 fixes (Ralf W. Grosse-Kunstleve)
 // 11 Mar 01  std::string *MAY* include nulls (Alex Martelli)
 // 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
 // 03 Mar 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
@@ -249,10 +250,7 @@ PyObject* to_python(const std::string& s)
 
 std::string from_python(PyObject* p, boost::python::type<std::string>)
 {
-    char* buffer = 0;
-    int length = 0;
-    int rc = PyString_AsStringAndSize(p, &buffer, &length);
-    return std::string(buffer, length);
+    return std::string(PyString_AsString(p), PyString_Size(p));
 }
 
 bool from_python(PyObject* p, boost::python::type<bool>)

From ff04d9f03c85e173a0d6084d20ef3f2416b699c7 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Mon, 12 Mar 2001 19:34:14 +0000
Subject: [PATCH 062/369] Minute enhancement.

[SVN r9547]
---
 doc/overriding.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/overriding.html b/doc/overriding.html
index 66c3610c..af458d79 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -82,8 +82,8 @@ struct hello_callback : hello
         { return boost::python::callback&lt;std::string&gt;::call_method(self, "greet"); }
 
     // Supplies the default implementation of greet
-    static std::string <a name= "default_implementation">default_greet</a>(const hello& self) const // <a href="#derived_5">5</a>
-        { return self.hello::greet(); }
+    static std::string <a name= "default_implementation">default_greet</a>(const hello& self_) const // <a href="#derived_5">5</a>
+        { return self_.hello::greet(); }
  private:
     PyObject* self; // <a href="#derived_1">1</a>
 };

From 012b4025a48e056da251b58eb50c402079740894 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 13 Mar 2001 00:01:06 +0000
Subject: [PATCH 063/369] temp files before branching

[SVN r9549]
---
 example/pickle1.cpp     |  57 +++++++++++++++++++
 example/pickle2.cpp     |  80 ++++++++++++++++++++++++++
 example/pickle3.cpp     | 121 ++++++++++++++++++++++++++++++++++++++++
 example/test_pickle1.py |  31 ++++++++++
 example/test_pickle2.py |  45 +++++++++++++++
 example/test_pickle3.py |  38 +++++++++++++
 6 files changed, 372 insertions(+)
 create mode 100644 example/pickle1.cpp
 create mode 100644 example/pickle2.cpp
 create mode 100644 example/pickle3.cpp
 create mode 100644 example/test_pickle1.py
 create mode 100644 example/test_pickle2.py
 create mode 100644 example/test_pickle3.py

diff --git a/example/pickle1.cpp b/example/pickle1.cpp
new file mode 100644
index 00000000..2f786f69
--- /dev/null
+++ b/example/pickle1.cpp
@@ -0,0 +1,57 @@
+/*
+    This example shows how to make an Extension Class "pickleable".
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    private:
+      std::string country;
+      int secret_number;
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference();
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle1)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle1");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle2.cpp b/example/pickle2.cpp
new file mode 100644
index 00000000..c33776a0
--- /dev/null
+++ b/example/pickle2.cpp
@@ -0,0 +1,80 @@
+/*
+    This example shows how to make an Extension Class "pickleable".
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  void world_setstate(world& w, python::tuple state) {
+    if (state.size() != 1) {
+      PyErr_SetString(PyExc_ValueError,
+        "Unexpected argument in call to __setstate__.");
+      throw python::error_already_set();
+    }
+    int number = state[0].get<int>();
+    if (number != 42)
+      w.set_secret_number(number);
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle2)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle2");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def(world_getstate, "__getstate__");
+    world_class.def(world_setstate, "__setstate__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
new file mode 100644
index 00000000..19ddec43
--- /dev/null
+++ b/example/pickle3.cpp
@@ -0,0 +1,121 @@
+/*
+    This example shows how to make an Extension Class "pickleable".
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(python::tuple const & args,
+                             python::dictionary const & keywords);
+
+  PyObject* world_setstate(python::tuple const & args,
+                           python::dictionary const & keywords);
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle3)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle3");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def_raw(world_getstate, "__getstate__");
+    world_class.def_raw(world_setstate, "__setstate__");
+    world_class.getstate_manages_dict();
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+
+namespace {
+
+  python::ref world_getstate(python::tuple const & args,
+                             python::dictionary const & keywords)
+  {
+      if(args.size() != 1 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::argument_error();
+      }
+      const world& w = args[0].get<const world&>();
+      python::ref mydict(args[0].getattr("__dict__"));
+      python::tuple result(2);
+      // store the object's __dict__
+      result.set_item(0, mydict);
+      // store the internal state of the C++ object
+      result.set_item(1, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  PyObject* world_setstate(python::tuple const & args,
+                           python::dictionary const & keywords)
+  {
+      if(args.size() != 2 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::argument_error();
+      }
+      world& w = args[0].get<world&>();
+      python::ref mydict(args[0].getattr("__dict__"));
+      const python::tuple& state(args[1].get<python::tuple>());
+      if (state.size() != 2) {
+        PyErr_SetString(PyExc_ValueError,
+          "Unexpected argument in call to __setstate__.");
+        throw python::error_already_set();
+      }
+      // restore the object's __dict__
+      python::dictionary odict(mydict.get<python::dictionary>());
+      const python::dictionary& pdict(state[0].get<python::dictionary>());
+      python::list pkeys(pdict.keys());
+      for (int i = 0; i < pkeys.size(); i++) {
+        python::ref k(pkeys[i]);
+        //odict[k] = pdict[k]; // XXX memory leak!
+        odict[k] = pdict.get_item(k); // this does not leak.
+      }
+      // restore the internal state of the C++ object
+      int number = state[1].get<int>();
+      if (number != 42)
+        w.set_secret_number(number);
+      return python::detail::none();
+  }
+}
diff --git a/example/test_pickle1.py b/example/test_pickle1.py
new file mode 100644
index 00000000..05696d4a
--- /dev/null
+++ b/example/test_pickle1.py
@@ -0,0 +1,31 @@
+r'''>>> import pickle1
+    >>> import re
+    >>> import pickle
+    >>> pickle1.world.__module__
+    'pickle1'
+    >>> pickle1.world.__safe_for_unpickling__
+    1
+    >>> pickle1.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle1.world at [0-9a-fA-FxX]+>, \('Hello',\)\)",
+    ... repr(pickle1.world('Hello').__reduce__()))
+    >>>
+    >>> wd = pickle1.world('California')
+    >>> pstr = pickle.dumps(wd)
+    >>> wl = pickle.loads(pstr)
+    >>> print wd.greet()
+    Hello from California!
+    >>> print wl.greet()
+    Hello from California!
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle1
+    doctest.testmod(test_pickle1)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_pickle2.py b/example/test_pickle2.py
new file mode 100644
index 00000000..463befa6
--- /dev/null
+++ b/example/test_pickle2.py
@@ -0,0 +1,45 @@
+r'''>>> import pickle2
+    >>> import re
+    >>> import pickle
+    >>> pickle2.world.__module__
+    'pickle2'
+    >>> pickle2.world.__safe_for_unpickling__
+    1
+    >>> pickle2.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle2.world at [0-9a-fA-FxX]+>, \('Hello',\), \(0,\)\)",
+    ... repr(pickle2.world('Hello').__reduce__()))
+    >>>
+    >>> for number in (24, 42):
+    ...   wd = pickle2.world('California')
+    ...   wd.set_secret_number(number)
+    ...   pstr = pickle.dumps(wd)
+    ...   wl = pickle.loads(pstr)
+    ...   print wd.greet(), wd.get_secret_number()
+    ...   print wl.greet(), wl.get_secret_number()
+    Hello from California! 24
+    Hello from California! 24
+    Hello from California! 42
+    Hello from California! 0
+
+# Now show that the __dict__ is not taken care of.
+    >>> wd = pickle2.world('California')
+    >>> wd.x = 1
+    >>> wd.__dict__
+    {'x': 1}
+    >>> try: pstr = pickle.dumps(wd)
+    ... except RuntimeError, err: print err[0]
+    ...
+    Incomplete pickle support (__getstate_manages_dict__ not set)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle2
+    doctest.testmod(test_pickle2)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_pickle3.py b/example/test_pickle3.py
new file mode 100644
index 00000000..b964f1a2
--- /dev/null
+++ b/example/test_pickle3.py
@@ -0,0 +1,38 @@
+r'''>>> import pickle3
+    >>> import re
+    >>> import pickle
+    >>> pickle3.world.__module__
+    'pickle3'
+    >>> pickle3.world.__safe_for_unpickling__
+    1
+    >>> pickle3.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle3.world at [0-9a-fA-FxX]+>, \('Hello',\), \(\{\}, 0\)\)",
+    ... repr(pickle3.world('Hello').__reduce__()))
+    >>>
+    >>> for number in (24, 42):
+    ...   wd = pickle3.world('California')
+    ...   wd.set_secret_number(number)
+    ...   wd.x = 2 * number
+    ...   wd.y = 'y' * number
+    ...   wd.z = 3. * number
+    ...   pstr = pickle.dumps(wd)
+    ...   wl = pickle.loads(pstr)
+    ...   print wd.greet(), wd.get_secret_number(), wd.__dict__
+    ...   print wl.greet(), wl.get_secret_number(), wl.__dict__
+    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
+    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
+    Hello from California! 42 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
+    Hello from California! 0 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle3
+    doctest.testmod(test_pickle3)
+
+if __name__ == '__main__':
+    run()

From c979ab01af48fc814c42beb89f857d7db4e85068 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 13 Mar 2001 00:03:58 +0000
Subject: [PATCH 064/369] temp files removed after branching.

[SVN r9551]
---
 example/pickle1.cpp     |  57 -------------------
 example/pickle2.cpp     |  80 --------------------------
 example/pickle3.cpp     | 121 ----------------------------------------
 example/test_pickle1.py |  31 ----------
 example/test_pickle2.py |  45 ---------------
 example/test_pickle3.py |  38 -------------
 6 files changed, 372 deletions(-)
 delete mode 100644 example/pickle1.cpp
 delete mode 100644 example/pickle2.cpp
 delete mode 100644 example/pickle3.cpp
 delete mode 100644 example/test_pickle1.py
 delete mode 100644 example/test_pickle2.py
 delete mode 100644 example/test_pickle3.py

diff --git a/example/pickle1.cpp b/example/pickle1.cpp
deleted file mode 100644
index 2f786f69..00000000
--- a/example/pickle1.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-    This example shows how to make an Extension Class "pickleable".
-    For more information refer to boost/libs/python/doc/pickle.html.
- */
-
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    private:
-      std::string country;
-      int secret_number;
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-  };
-
-  // Support for pickle.
-  python::ref world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result.reference();
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(pickle1)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("pickle1");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/pickle2.cpp b/example/pickle2.cpp
deleted file mode 100644
index c33776a0..00000000
--- a/example/pickle2.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
-    This example shows how to make an Extension Class "pickleable".
-    For more information refer to boost/libs/python/doc/pickle.html.
- */
-
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-      void set_secret_number(int number) { secret_number = number; }
-      int get_secret_number() const { return secret_number; }
-    private:
-      std::string country;
-      int secret_number;
-  };
-
-  // Support for pickle.
-  python::ref world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  python::ref world_getstate(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_secret_number());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  void world_setstate(world& w, python::tuple state) {
-    if (state.size() != 1) {
-      PyErr_SetString(PyExc_ValueError,
-        "Unexpected argument in call to __setstate__.");
-      throw python::error_already_set();
-    }
-    int number = state[0].get<int>();
-    if (number != 42)
-      w.set_secret_number(number);
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(pickle2)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("pickle2");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-    world_class.def(&world::get_secret_number, "get_secret_number");
-    world_class.def(&world::set_secret_number, "set_secret_number");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-    world_class.def(world_getstate, "__getstate__");
-    world_class.def(world_setstate, "__setstate__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
deleted file mode 100644
index 19ddec43..00000000
--- a/example/pickle3.cpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
-    This example shows how to make an Extension Class "pickleable".
-    For more information refer to boost/libs/python/doc/pickle.html.
- */
-
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-      void set_secret_number(int number) { secret_number = number; }
-      int get_secret_number() const { return secret_number; }
-    private:
-      std::string country;
-      int secret_number;
-  };
-
-  // Support for pickle.
-  python::ref world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  python::ref world_getstate(python::tuple const & args,
-                             python::dictionary const & keywords);
-
-  PyObject* world_setstate(python::tuple const & args,
-                           python::dictionary const & keywords);
-}
-
-BOOST_PYTHON_MODULE_INIT(pickle3)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("pickle3");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-    world_class.def(&world::get_secret_number, "get_secret_number");
-    world_class.def(&world::set_secret_number, "set_secret_number");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-    world_class.def_raw(world_getstate, "__getstate__");
-    world_class.def_raw(world_setstate, "__setstate__");
-    world_class.getstate_manages_dict();
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
-
-namespace {
-
-  python::ref world_getstate(python::tuple const & args,
-                             python::dictionary const & keywords)
-  {
-      if(args.size() != 1 || keywords.size() != 0) {
-          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
-      }
-      const world& w = args[0].get<const world&>();
-      python::ref mydict(args[0].getattr("__dict__"));
-      python::tuple result(2);
-      // store the object's __dict__
-      result.set_item(0, mydict);
-      // store the internal state of the C++ object
-      result.set_item(1, w.get_secret_number());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  PyObject* world_setstate(python::tuple const & args,
-                           python::dictionary const & keywords)
-  {
-      if(args.size() != 2 || keywords.size() != 0) {
-          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
-      }
-      world& w = args[0].get<world&>();
-      python::ref mydict(args[0].getattr("__dict__"));
-      const python::tuple& state(args[1].get<python::tuple>());
-      if (state.size() != 2) {
-        PyErr_SetString(PyExc_ValueError,
-          "Unexpected argument in call to __setstate__.");
-        throw python::error_already_set();
-      }
-      // restore the object's __dict__
-      python::dictionary odict(mydict.get<python::dictionary>());
-      const python::dictionary& pdict(state[0].get<python::dictionary>());
-      python::list pkeys(pdict.keys());
-      for (int i = 0; i < pkeys.size(); i++) {
-        python::ref k(pkeys[i]);
-        //odict[k] = pdict[k]; // XXX memory leak!
-        odict[k] = pdict.get_item(k); // this does not leak.
-      }
-      // restore the internal state of the C++ object
-      int number = state[1].get<int>();
-      if (number != 42)
-        w.set_secret_number(number);
-      return python::detail::none();
-  }
-}
diff --git a/example/test_pickle1.py b/example/test_pickle1.py
deleted file mode 100644
index 05696d4a..00000000
--- a/example/test_pickle1.py
+++ /dev/null
@@ -1,31 +0,0 @@
-r'''>>> import pickle1
-    >>> import re
-    >>> import pickle
-    >>> pickle1.world.__module__
-    'pickle1'
-    >>> pickle1.world.__safe_for_unpickling__
-    1
-    >>> pickle1.world.__reduce__()
-    'world'
-    >>> assert re.match(
-    ... "\(<extension class pickle1.world at [0-9a-fA-FxX]+>, \('Hello',\)\)",
-    ... repr(pickle1.world('Hello').__reduce__()))
-    >>>
-    >>> wd = pickle1.world('California')
-    >>> pstr = pickle.dumps(wd)
-    >>> wl = pickle.loads(pstr)
-    >>> print wd.greet()
-    Hello from California!
-    >>> print wl.greet()
-    Hello from California!
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_pickle1
-    doctest.testmod(test_pickle1)
-
-if __name__ == '__main__':
-    run()
diff --git a/example/test_pickle2.py b/example/test_pickle2.py
deleted file mode 100644
index 463befa6..00000000
--- a/example/test_pickle2.py
+++ /dev/null
@@ -1,45 +0,0 @@
-r'''>>> import pickle2
-    >>> import re
-    >>> import pickle
-    >>> pickle2.world.__module__
-    'pickle2'
-    >>> pickle2.world.__safe_for_unpickling__
-    1
-    >>> pickle2.world.__reduce__()
-    'world'
-    >>> assert re.match(
-    ... "\(<extension class pickle2.world at [0-9a-fA-FxX]+>, \('Hello',\), \(0,\)\)",
-    ... repr(pickle2.world('Hello').__reduce__()))
-    >>>
-    >>> for number in (24, 42):
-    ...   wd = pickle2.world('California')
-    ...   wd.set_secret_number(number)
-    ...   pstr = pickle.dumps(wd)
-    ...   wl = pickle.loads(pstr)
-    ...   print wd.greet(), wd.get_secret_number()
-    ...   print wl.greet(), wl.get_secret_number()
-    Hello from California! 24
-    Hello from California! 24
-    Hello from California! 42
-    Hello from California! 0
-
-# Now show that the __dict__ is not taken care of.
-    >>> wd = pickle2.world('California')
-    >>> wd.x = 1
-    >>> wd.__dict__
-    {'x': 1}
-    >>> try: pstr = pickle.dumps(wd)
-    ... except RuntimeError, err: print err[0]
-    ...
-    Incomplete pickle support (__getstate_manages_dict__ not set)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_pickle2
-    doctest.testmod(test_pickle2)
-
-if __name__ == '__main__':
-    run()
diff --git a/example/test_pickle3.py b/example/test_pickle3.py
deleted file mode 100644
index b964f1a2..00000000
--- a/example/test_pickle3.py
+++ /dev/null
@@ -1,38 +0,0 @@
-r'''>>> import pickle3
-    >>> import re
-    >>> import pickle
-    >>> pickle3.world.__module__
-    'pickle3'
-    >>> pickle3.world.__safe_for_unpickling__
-    1
-    >>> pickle3.world.__reduce__()
-    'world'
-    >>> assert re.match(
-    ... "\(<extension class pickle3.world at [0-9a-fA-FxX]+>, \('Hello',\), \(\{\}, 0\)\)",
-    ... repr(pickle3.world('Hello').__reduce__()))
-    >>>
-    >>> for number in (24, 42):
-    ...   wd = pickle3.world('California')
-    ...   wd.set_secret_number(number)
-    ...   wd.x = 2 * number
-    ...   wd.y = 'y' * number
-    ...   wd.z = 3. * number
-    ...   pstr = pickle.dumps(wd)
-    ...   wl = pickle.loads(pstr)
-    ...   print wd.greet(), wd.get_secret_number(), wd.__dict__
-    ...   print wl.greet(), wl.get_secret_number(), wl.__dict__
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 42 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 0 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_pickle3
-    doctest.testmod(test_pickle3)
-
-if __name__ == '__main__':
-    run()

From 60b91ac6780ee9c7594892185377cebbde95652b Mon Sep 17 00:00:00 2001
From: Beman Dawes <bdawes@acm.org>
Date: Wed, 14 Mar 2001 15:11:55 +0000
Subject: [PATCH 065/369] 1.21.1 run up, including new download instructions
 and fix broken hyperlinks

[SVN r9557]
---
 doc/building.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/building.html b/doc/building.html
index 6627bbe8..2a8c9cae 100644
--- a/doc/building.html
+++ b/doc/building.html
@@ -57,7 +57,7 @@
           special debugging version of the Python DLL. Since this debug DLL
           isn't supplied with the default Python installation for Windows,
           Boost.Python uses <tt><a href=
-          "../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
+          "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
           to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
           <tt>#include</tt>d.
 
@@ -77,7 +77,7 @@
 
           <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
           any source files <tt>#include &lt;<a href=
-          "../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
+          "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
           instead of the usual <tt>Python.h</tt>, or you will have link
           incompatibilities.<br>
           <br>

From c068a300f429a81a78c486579feda5418a8b22e8 Mon Sep 17 00:00:00 2001
From: Beman Dawes <bdawes@acm.org>
Date: Thu, 15 Mar 2001 16:05:25 +0000
Subject: [PATCH 066/369] template file is not longer needed, causes "broken
 links" messages

[SVN r9562]
---
 doc/template.html | 26 --------------------------
 1 file changed, 26 deletions(-)
 delete mode 100644 doc/template.html

diff --git a/doc/template.html b/doc/template.html
deleted file mode 100644
index 1d0cd7a4..00000000
--- a/doc/template.html
+++ /dev/null
@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      The Title Of This Page
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">The Title Of This
-        Page
-      </h1>
-      <p>
-      <p>
-         Prev: <a href="prev.html">Previous</a>
-         Next: <a href="next.html">Next</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
-        sell and distribute this document is granted provided this copyright
-        notice appears in all copies. This document is provided "as is" without
-        express or implied warranty, and with no claim as to its suitability
-        for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

From 13b2e072d25cc3b7e11471afd3b8098a26c458ec Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 16 Mar 2001 21:56:41 +0000
Subject: [PATCH 067/369] Remove const qualifications that will confuse VC++'s
 buggy brain

[SVN r9567]
---
 example/getting_started4.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/example/getting_started4.cpp b/example/getting_started4.cpp
index 199ef7a9..cf6c2ff2 100644
--- a/example/getting_started4.cpp
+++ b/example/getting_started4.cpp
@@ -55,7 +55,7 @@ namespace { // Avoid cluttering the global namespace.
 
   // Function returning a vector_double object to Python.
   //
-  std::vector<double> foo(const int n)
+  std::vector<double> foo(int n)
   {
     std::vector<double> vd(n);
     std::vector<double>::iterator vditer = vd.begin();
@@ -65,7 +65,7 @@ namespace { // Avoid cluttering the global namespace.
 
   // Same as foo(), but avoid copying on return.
   //
-  std::auto_ptr<std::vector<double> > bar(const int n)
+  std::auto_ptr<std::vector<double> > bar(int n)
   {
     std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
     std::vector<double>::iterator vditer = vdptr->begin();

From 098eadefe0f4849d762d227c7df27fc6b82abffc Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 20 Mar 2001 02:07:39 +0000
Subject: [PATCH 068/369] temp file before branching

[SVN r9599]
---
 include/boost/python/cross_module.hpp | 274 ++++++++++++++++++++++++++
 src/cross_module.cpp                  |  77 ++++++++
 2 files changed, 351 insertions(+)
 create mode 100644 include/boost/python/cross_module.hpp
 create mode 100644 src/cross_module.cpp

diff --git a/include/boost/python/cross_module.hpp b/include/boost/python/cross_module.hpp
new file mode 100644
index 00000000..a6c32889
--- /dev/null
+++ b/include/boost/python/cross_module.hpp
@@ -0,0 +1,274 @@
+#ifndef CROSS_MODULE_HPP
+# define CROSS_MODULE_HPP
+
+# include <boost/python/class_builder.hpp>
+
+namespace boost { namespace python {
+    struct import_error : error_already_set {};
+    struct export_error : error_already_set {};
+}}
+
+namespace boost { namespace python { namespace detail {
+
+// Concept: throw exception if api_major is changed
+//          show warning on stderr if api_minor is changed
+const int export_converters_api_major = 2;
+const int export_converters_api_minor = 1;
+extern const char* converters_attribute_name;
+void* import_converter_object(const std::string& module_name,
+                              const std::string& py_class_name,
+                              const std::string& attribute_name);
+void check_export_converters_api(const int importing_major,
+                                 const int importing_minor,
+                                 const int imported_major,
+                                 const int imported_minor);
+
+}}}
+
+// forward declaration
+namespace boost { namespace python { namespace detail {
+template <class T> class import_extension_class;
+}}}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+//QUESTIONMARK
+//  This class is a look-alike of class python_extension_class_converters.
+//  Is there a formal way to ensure that the siblings stay in sync?
+template <class T>
+class python_import_extension_class_converters
+{
+ public:
+
+    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>)
+    {
+        return python_import_extension_class_converters();
+    }
+
+    PyObject* to_python(const T& x) const
+    {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend T* from_python(PyObject* p, boost::python::type<T*>)
+    {
+        return boost::python::detail::import_extension_class<T>::get_converters()->T_pointer_from_python(p);
+    }
+
+    // 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::import_extension_class<T>::get_converters()->T_reference_from_python(p);
+    }
+
+    // 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 boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_reference_from_python(p);
+    }
+
+    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_value_from_python(p);
+    }
+
+    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_value_from_python(p);
+    }
+
+    friend PyObject* to_python(std::auto_ptr<T> x) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_reference_from_python(p);
+    }
+
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_value_from_python(p);
+    }
+
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_value_from_python(p);
+    }
+
+    friend PyObject* to_python(boost::shared_ptr<T> x) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+};
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+namespace boost { namespace python {
+
+BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
+
+// A pointer to this class is exported/imported via the Python API.
+// All functions are virtual. This is, what we really export/import
+// is essentially just a pointer to a vtbl.
+template <class T>
+struct export_converter_object_base
+{
+  virtual const int get_api_major() const {
+    return detail::export_converters_api_major; }
+  virtual const int get_api_minor() const {
+    return detail::export_converters_api_minor; }
+  virtual PyObject* to_python(const T& x) = 0;
+  virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
+  virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
+  virtual T* T_pointer_from_python(PyObject* obj) = 0;
+  virtual T& T_reference_from_python(PyObject* obj) = 0;
+  virtual std::auto_ptr<T>& auto_ptr_reference_from_python(PyObject* obj) = 0;
+  virtual std::auto_ptr<T> auto_ptr_value_from_python(PyObject* obj) = 0;
+  virtual boost::shared_ptr<T>& shared_ptr_reference_from_python(PyObject* obj) = 0;
+  virtual boost::shared_ptr<T> shared_ptr_value_from_python(PyObject* obj) = 0;
+};
+
+// Converters to be used if T is not copyable.
+template <class T>
+struct export_converter_object_noncopyable : export_converter_object_base<T>
+{
+  virtual PyObject* to_python(const T& x) {
+    PyErr_SetString(PyExc_RuntimeError,
+      "to_python(const T&) converter not exported");
+    throw import_error();
+  }
+  virtual PyObject* to_python(std::auto_ptr<T> x) {
+    return BOOST_PYTHON_CONVERSION::to_python(x);
+  }
+  virtual PyObject* to_python(boost::shared_ptr<T> x) {
+    return BOOST_PYTHON_CONVERSION::to_python(x);
+  }
+  virtual T* T_pointer_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T*>());
+  }
+  virtual T& T_reference_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T&>());
+  }
+  virtual std::auto_ptr<T>& auto_ptr_reference_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_reference(obj, boost::python::type<std::auto_ptr<T> >());
+  }
+  virtual std::auto_ptr<T> auto_ptr_value_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_value(obj, boost::python::type<std::auto_ptr<T> >());
+  }
+  virtual boost::shared_ptr<T>& shared_ptr_reference_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_reference(obj, boost::python::type<boost::shared_ptr<T> >());
+  }
+  virtual boost::shared_ptr<T> shared_ptr_value_from_python(PyObject* obj) {
+    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_value(obj, boost::python::type<boost::shared_ptr<T> >());
+  }
+};
+
+// The addditional to_python() converter that can be used if T is copyable.
+template <class T>
+struct export_converter_object : export_converter_object_noncopyable<T>
+{
+  virtual PyObject* to_python(const T& x) {
+    BOOST_PYTHON_CONVERSION::python_extension_class_converters<T> cv;
+    return cv.to_python(x);
+  }
+};
+
+namespace detail {
+
+//QUESTIONMARK
+//  A stripped-down, modified version of class extension_class.
+//  Would it make sense to establish a formal relationship
+//  between the two classes?
+template <class T>
+class import_extension_class
+    : public python_import_extension_class_converters<T>
+{
+ public:
+    inline import_extension_class(const char* module, const char* py_class) {
+      m_module = module;
+      m_py_class = py_class;
+    }
+
+    static boost::python::export_converter_object_base<T>* get_converters();
+
+  private:
+    static std::string m_module;
+    static std::string m_py_class;
+    static boost::python::export_converter_object_base<T>* imported_converters;
+};
+
+template <class T> std::string import_extension_class<T>::m_module;
+template <class T> std::string import_extension_class<T>::m_py_class;
+template <class T>
+boost::python::export_converter_object_base<T>*
+import_extension_class<T>::imported_converters = 0;
+
+template <class T>
+boost::python::export_converter_object_base<T>*
+import_extension_class<T>::get_converters() {
+  if (imported_converters == 0) {
+    void* cobject
+      = import_converter_object(m_module, m_py_class,
+                                converters_attribute_name);
+    imported_converters
+      = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
+    check_export_converters_api(
+      export_converters_api_major,
+      export_converters_api_minor,
+      imported_converters->get_api_major(),
+      imported_converters->get_api_minor());
+  }
+  return imported_converters;
+}
+
+}}} // namespace boost::python::detail
+
+namespace boost { namespace python {
+
+template <class T, class U>
+void export_converters(class_builder<T, U>& cb)
+{
+    static export_converter_object<T> export_cvts;
+    cb.add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      detail::converters_attribute_name);
+}
+
+template <class T, class U>
+void export_converters_noncopyable(class_builder<T, U>& cb)
+{
+    static export_converter_object_noncopyable<T> export_cvts;
+    cb.add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      detail::converters_attribute_name);
+}
+
+template <class T>
+class import_converters
+    : python_import_extension_class_converters<T>
+{
+ public:
+    import_converters(const char* module, const char* py_class)
+        : m_class(new detail::import_extension_class<T>(module, py_class))
+    { }
+ private:
+    //QUESTIONMARK
+    //reference<detail::import_extension_class<T> > m_class;
+    boost::shared_ptr<detail::import_extension_class<T> > m_class;
+};
+
+}} // namespace boost::python
+
+#endif // CROSS_MODULE_HPP
diff --git a/src/cross_module.cpp b/src/cross_module.cpp
new file mode 100644
index 00000000..c14acfda
--- /dev/null
+++ b/src/cross_module.cpp
@@ -0,0 +1,77 @@
+# include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+# include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
+# include <string.h> // MSVC6.0SP4 does not know std::strcmp
+
+namespace {
+
+  PyObject* get_module_dict(const char* module_name)
+  {
+      python::ref module_obj(PyImport_ImportModule((char*) module_name));
+      PyObject* module_dict = PyModule_GetDict(module_obj.get());
+      if (module_dict == 0) throw python::import_error();
+      return module_dict;
+  }
+}
+
+namespace boost { namespace python { namespace detail {
+
+const char* converters_attribute_name = "__converters__";
+
+void* import_converter_object(const std::string& module_name,
+                              const std::string& py_class_name,
+                              const std::string& attribute_name)
+{
+    static std::string err;
+    PyObject* module_dict = get_module_dict(const_cast<char*>(module_name.c_str()));
+    PyObject* py_class = PyDict_GetItemString(module_dict, const_cast<char*>(py_class_name.c_str()));
+    if (py_class == 0) {
+        err = std::string("module ") + module_name + " has no attribute " + py_class_name;
+        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+        throw python::import_error();
+    }
+    python::ref c_obj(PyObject_GetAttrString(py_class, const_cast<char*>(attribute_name.c_str())), ref::null_ok);
+    if (c_obj.get() == 0) {
+        err = std::string("object ") + module_name + "." + py_class_name
+              + " has no attribute " + attribute_name;
+        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+        throw python::import_error();
+    }
+    if (! PyCObject_Check(c_obj.get())) {
+        err = std::string("object ") + module_name + "." + py_class_name + "."
+              + attribute_name + " is not a PyCObject";
+        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+        throw python::import_error();
+    }
+    return PyCObject_AsVoidPtr(c_obj.get());
+}
+
+void check_export_converters_api(const int importing_major,
+                                 const int importing_minor,
+                                 const int imported_major,
+                                 const int imported_minor)
+{
+    if (importing_major != imported_major) {
+        // Python uses fprintf(stderr, ...) for API warnings.
+        fprintf(stderr,
+          "Fatal: export_converters_api mismatch:"
+          " Importing module = %d.%d"
+          " Imported module = %d.%d\n",
+          importing_major, importing_minor,
+          imported_major, imported_minor);
+        PyErr_SetString(PyExc_RuntimeError,
+          "Fatal: export_converters_api mismatch");
+        throw import_error();
+    }
+    if (importing_minor != imported_minor) {
+        // Python uses fprintf(stderr, ...) for API warnings.
+        fprintf(stderr,
+          "Warning: export_converters_api mismatch:"
+          " Importing module = %d.%d"
+          " Imported module = %d.%d\n",
+          importing_major, importing_minor,
+          imported_major, imported_minor);
+    }
+}
+
+}}} // namespace boost::python::detail

From db943b4109c71c61b7293bfcacb13becfe2d01db Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 20 Mar 2001 02:08:24 +0000
Subject: [PATCH 069/369] temp file removed after branching.

[SVN r9600]
---
 include/boost/python/cross_module.hpp | 274 --------------------------
 src/cross_module.cpp                  |  77 --------
 2 files changed, 351 deletions(-)
 delete mode 100644 include/boost/python/cross_module.hpp
 delete mode 100644 src/cross_module.cpp

diff --git a/include/boost/python/cross_module.hpp b/include/boost/python/cross_module.hpp
deleted file mode 100644
index a6c32889..00000000
--- a/include/boost/python/cross_module.hpp
+++ /dev/null
@@ -1,274 +0,0 @@
-#ifndef CROSS_MODULE_HPP
-# define CROSS_MODULE_HPP
-
-# include <boost/python/class_builder.hpp>
-
-namespace boost { namespace python {
-    struct import_error : error_already_set {};
-    struct export_error : error_already_set {};
-}}
-
-namespace boost { namespace python { namespace detail {
-
-// Concept: throw exception if api_major is changed
-//          show warning on stderr if api_minor is changed
-const int export_converters_api_major = 2;
-const int export_converters_api_minor = 1;
-extern const char* converters_attribute_name;
-void* import_converter_object(const std::string& module_name,
-                              const std::string& py_class_name,
-                              const std::string& attribute_name);
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor);
-
-}}}
-
-// forward declaration
-namespace boost { namespace python { namespace detail {
-template <class T> class import_extension_class;
-}}}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-//QUESTIONMARK
-//  This class is a look-alike of class python_extension_class_converters.
-//  Is there a formal way to ensure that the siblings stay in sync?
-template <class T>
-class python_import_extension_class_converters
-{
- public:
-
-    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>)
-    {
-        return python_import_extension_class_converters();
-    }
-
-    PyObject* to_python(const T& x) const
-    {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-
-    friend T* from_python(PyObject* p, boost::python::type<T*>)
-    {
-        return boost::python::detail::import_extension_class<T>::get_converters()->T_pointer_from_python(p);
-    }
-
-    // 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::import_extension_class<T>::get_converters()->T_reference_from_python(p);
-    }
-
-    // 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 boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_reference_from_python(p);
-    }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_value_from_python(p);
-    }
-
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->auto_ptr_value_from_python(p);
-    }
-
-    friend PyObject* to_python(std::auto_ptr<T> x) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_reference_from_python(p);
-    }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_value_from_python(p);
-    }
-
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->shared_ptr_value_from_python(p);
-    }
-
-    friend PyObject* to_python(boost::shared_ptr<T> x) {
-        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
-    }
-};
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
-
-// A pointer to this class is exported/imported via the Python API.
-// All functions are virtual. This is, what we really export/import
-// is essentially just a pointer to a vtbl.
-template <class T>
-struct export_converter_object_base
-{
-  virtual const int get_api_major() const {
-    return detail::export_converters_api_major; }
-  virtual const int get_api_minor() const {
-    return detail::export_converters_api_minor; }
-  virtual PyObject* to_python(const T& x) = 0;
-  virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
-  virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
-  virtual T* T_pointer_from_python(PyObject* obj) = 0;
-  virtual T& T_reference_from_python(PyObject* obj) = 0;
-  virtual std::auto_ptr<T>& auto_ptr_reference_from_python(PyObject* obj) = 0;
-  virtual std::auto_ptr<T> auto_ptr_value_from_python(PyObject* obj) = 0;
-  virtual boost::shared_ptr<T>& shared_ptr_reference_from_python(PyObject* obj) = 0;
-  virtual boost::shared_ptr<T> shared_ptr_value_from_python(PyObject* obj) = 0;
-};
-
-// Converters to be used if T is not copyable.
-template <class T>
-struct export_converter_object_noncopyable : export_converter_object_base<T>
-{
-  virtual PyObject* to_python(const T& x) {
-    PyErr_SetString(PyExc_RuntimeError,
-      "to_python(const T&) converter not exported");
-    throw import_error();
-  }
-  virtual PyObject* to_python(std::auto_ptr<T> x) {
-    return BOOST_PYTHON_CONVERSION::to_python(x);
-  }
-  virtual PyObject* to_python(boost::shared_ptr<T> x) {
-    return BOOST_PYTHON_CONVERSION::to_python(x);
-  }
-  virtual T* T_pointer_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T*>());
-  }
-  virtual T& T_reference_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::from_python(obj, boost::python::type<T&>());
-  }
-  virtual std::auto_ptr<T>& auto_ptr_reference_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_reference(obj, boost::python::type<std::auto_ptr<T> >());
-  }
-  virtual std::auto_ptr<T> auto_ptr_value_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_value(obj, boost::python::type<std::auto_ptr<T> >());
-  }
-  virtual boost::shared_ptr<T>& shared_ptr_reference_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_reference(obj, boost::python::type<boost::shared_ptr<T> >());
-  }
-  virtual boost::shared_ptr<T> shared_ptr_value_from_python(PyObject* obj) {
-    return BOOST_PYTHON_CONVERSION::python_extension_class_converters<T>::smart_ptr_value(obj, boost::python::type<boost::shared_ptr<T> >());
-  }
-};
-
-// The addditional to_python() converter that can be used if T is copyable.
-template <class T>
-struct export_converter_object : export_converter_object_noncopyable<T>
-{
-  virtual PyObject* to_python(const T& x) {
-    BOOST_PYTHON_CONVERSION::python_extension_class_converters<T> cv;
-    return cv.to_python(x);
-  }
-};
-
-namespace detail {
-
-//QUESTIONMARK
-//  A stripped-down, modified version of class extension_class.
-//  Would it make sense to establish a formal relationship
-//  between the two classes?
-template <class T>
-class import_extension_class
-    : public python_import_extension_class_converters<T>
-{
- public:
-    inline import_extension_class(const char* module, const char* py_class) {
-      m_module = module;
-      m_py_class = py_class;
-    }
-
-    static boost::python::export_converter_object_base<T>* get_converters();
-
-  private:
-    static std::string m_module;
-    static std::string m_py_class;
-    static boost::python::export_converter_object_base<T>* imported_converters;
-};
-
-template <class T> std::string import_extension_class<T>::m_module;
-template <class T> std::string import_extension_class<T>::m_py_class;
-template <class T>
-boost::python::export_converter_object_base<T>*
-import_extension_class<T>::imported_converters = 0;
-
-template <class T>
-boost::python::export_converter_object_base<T>*
-import_extension_class<T>::get_converters() {
-  if (imported_converters == 0) {
-    void* cobject
-      = import_converter_object(m_module, m_py_class,
-                                converters_attribute_name);
-    imported_converters
-      = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
-    check_export_converters_api(
-      export_converters_api_major,
-      export_converters_api_minor,
-      imported_converters->get_api_major(),
-      imported_converters->get_api_minor());
-  }
-  return imported_converters;
-}
-
-}}} // namespace boost::python::detail
-
-namespace boost { namespace python {
-
-template <class T, class U>
-void export_converters(class_builder<T, U>& cb)
-{
-    static export_converter_object<T> export_cvts;
-    cb.add(
-      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
-      detail::converters_attribute_name);
-}
-
-template <class T, class U>
-void export_converters_noncopyable(class_builder<T, U>& cb)
-{
-    static export_converter_object_noncopyable<T> export_cvts;
-    cb.add(
-      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
-      detail::converters_attribute_name);
-}
-
-template <class T>
-class import_converters
-    : python_import_extension_class_converters<T>
-{
- public:
-    import_converters(const char* module, const char* py_class)
-        : m_class(new detail::import_extension_class<T>(module, py_class))
-    { }
- private:
-    //QUESTIONMARK
-    //reference<detail::import_extension_class<T> > m_class;
-    boost::shared_ptr<detail::import_extension_class<T> > m_class;
-};
-
-}} // namespace boost::python
-
-#endif // CROSS_MODULE_HPP
diff --git a/src/cross_module.cpp b/src/cross_module.cpp
deleted file mode 100644
index c14acfda..00000000
--- a/src/cross_module.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-# include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-# include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
-# include <string.h> // MSVC6.0SP4 does not know std::strcmp
-
-namespace {
-
-  PyObject* get_module_dict(const char* module_name)
-  {
-      python::ref module_obj(PyImport_ImportModule((char*) module_name));
-      PyObject* module_dict = PyModule_GetDict(module_obj.get());
-      if (module_dict == 0) throw python::import_error();
-      return module_dict;
-  }
-}
-
-namespace boost { namespace python { namespace detail {
-
-const char* converters_attribute_name = "__converters__";
-
-void* import_converter_object(const std::string& module_name,
-                              const std::string& py_class_name,
-                              const std::string& attribute_name)
-{
-    static std::string err;
-    PyObject* module_dict = get_module_dict(const_cast<char*>(module_name.c_str()));
-    PyObject* py_class = PyDict_GetItemString(module_dict, const_cast<char*>(py_class_name.c_str()));
-    if (py_class == 0) {
-        err = std::string("module ") + module_name + " has no attribute " + py_class_name;
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    python::ref c_obj(PyObject_GetAttrString(py_class, const_cast<char*>(attribute_name.c_str())), ref::null_ok);
-    if (c_obj.get() == 0) {
-        err = std::string("object ") + module_name + "." + py_class_name
-              + " has no attribute " + attribute_name;
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    if (! PyCObject_Check(c_obj.get())) {
-        err = std::string("object ") + module_name + "." + py_class_name + "."
-              + attribute_name + " is not a PyCObject";
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    return PyCObject_AsVoidPtr(c_obj.get());
-}
-
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor)
-{
-    if (importing_major != imported_major) {
-        // Python uses fprintf(stderr, ...) for API warnings.
-        fprintf(stderr,
-          "Fatal: export_converters_api mismatch:"
-          " Importing module = %d.%d"
-          " Imported module = %d.%d\n",
-          importing_major, importing_minor,
-          imported_major, imported_minor);
-        PyErr_SetString(PyExc_RuntimeError,
-          "Fatal: export_converters_api mismatch");
-        throw import_error();
-    }
-    if (importing_minor != imported_minor) {
-        // Python uses fprintf(stderr, ...) for API warnings.
-        fprintf(stderr,
-          "Warning: export_converters_api mismatch:"
-          " Importing module = %d.%d"
-          " Imported module = %d.%d\n",
-          importing_major, importing_minor,
-          imported_major, imported_minor);
-    }
-}
-
-}}} // namespace boost::python::detail

From 1f45a846c64420b56fb9da13d963f97035a18525 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 20 Mar 2001 02:13:28 +0000
Subject: [PATCH 070/369] VC++ 6.0 fixes and misc. other modifications.

[SVN r9601]
---
 example/getting_started4.cpp | 9 ++++-----
 example/getting_started5.cpp | 2 +-
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/example/getting_started4.cpp b/example/getting_started4.cpp
index cf6c2ff2..fe6a3421 100644
--- a/example/getting_started4.cpp
+++ b/example/getting_started4.cpp
@@ -15,7 +15,7 @@ namespace { // Avoid cluttering the global namespace.
     vector_double_wrapper(PyObject* self)
       : std::vector<double>() {}
 
-    vector_double_wrapper(PyObject* self, const int n)
+    vector_double_wrapper(PyObject* self, int n)
       : std::vector<double>(n) {}
 
     vector_double_wrapper(PyObject* self, python::tuple tuple)
@@ -28,17 +28,16 @@ namespace { // Avoid cluttering the global namespace.
     }
   };
 
-  double getitem(const std::vector<double>& vd, const std::size_t key) {
+  double getitem(const std::vector<double>& vd, std::size_t key) {
     return vd[key];
   }
 
-  void setitem(std::vector<double>& vd, const std::size_t key,
-               const double &d) {
+  void setitem(std::vector<double>& vd, std::size_t key, double d) {
     std::vector<double>::iterator vditer = vd.begin();
     vditer[key] = d;
   }
 
-  void delitem(std::vector<double>& vd, const std::size_t key) {
+  void delitem(std::vector<double>& vd, std::size_t key) {
     std::vector<double>::iterator vditer = vd.begin();
     vd.erase(&vditer[key]);
   }
diff --git a/example/getting_started5.cpp b/example/getting_started5.cpp
index be033224..9e9e7c75 100644
--- a/example/getting_started5.cpp
+++ b/example/getting_started5.cpp
@@ -60,7 +60,7 @@ namespace { // Avoid cluttering the global namespace.
       std::vector<MillerIndex> VMIx;
     public:
       void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
-      MillerIndex get(const std::size_t i) const { return VMIx[i]; }
+      MillerIndex get(std::size_t i) const { return VMIx[i]; }
   };
 }
 

From 591eaeaafbaa53bce030c06af0198690886a915a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 20 Mar 2001 02:16:08 +0000
Subject: [PATCH 071/369] VC++ 6.0 makefile; filemgr.py used by all
 ralf_grosse_kunstleve makefiles.

[SVN r9602]
---
 build/filemgr.py | 122 ++++++++++++++++++++++++++++++++++++++++++++
 build/vc60.mak   | 129 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 251 insertions(+)
 create mode 100644 build/filemgr.py
 create mode 100644 build/vc60.mak

diff --git a/build/filemgr.py b/build/filemgr.py
new file mode 100644
index 00000000..51c87403
--- /dev/null
+++ b/build/filemgr.py
@@ -0,0 +1,122 @@
+bpl_src = "/libs/python/src"
+bpl_tst = "/libs/python/test"
+bpl_exa = "/libs/python/example"
+files = (
+bpl_src + "/classes.cpp",
+bpl_src + "/conversions.cpp",
+bpl_src + "/extension_class.cpp",
+bpl_src + "/functions.cpp",
+bpl_src + "/init_function.cpp",
+bpl_src + "/module_builder.cpp",
+bpl_src + "/objects.cpp",
+bpl_src + "/types.cpp",
+bpl_src + "/cross_module.cpp",
+bpl_tst + "/comprehensive.cpp",
+bpl_tst + "/comprehensive.hpp",
+bpl_tst + "/comprehensive.py",
+bpl_tst + "/doctest.py",
+bpl_exa + "/abstract.cpp",
+bpl_exa + "/getting_started1.cpp",
+bpl_exa + "/getting_started2.cpp",
+bpl_exa + "/getting_started3.cpp",
+bpl_exa + "/getting_started4.cpp",
+bpl_exa + "/getting_started5.cpp",
+bpl_exa + "/pickle1.cpp",
+bpl_exa + "/pickle2.cpp",
+bpl_exa + "/pickle3.cpp",
+bpl_exa + "/test_abstract.py",
+bpl_exa + "/test_getting_started1.py",
+bpl_exa + "/test_getting_started2.py",
+bpl_exa + "/test_getting_started3.py",
+bpl_exa + "/test_getting_started4.py",
+bpl_exa + "/test_getting_started5.py",
+bpl_exa + "/test_pickle1.py",
+bpl_exa + "/test_pickle2.py",
+bpl_exa + "/test_pickle3.py",
+bpl_exa + "/noncopyable.h",
+bpl_exa + "/noncopyable_export.cpp",
+bpl_exa + "/noncopyable_import.cpp",
+bpl_exa + "/tst_noncopyable.py",
+bpl_exa + "/ivect.h",
+bpl_exa + "/ivect.cpp",
+bpl_exa + "/dvect.h",
+bpl_exa + "/dvect.cpp",
+bpl_exa + "/tst_ivect.py",
+bpl_exa + "/tst_dvect.py",
+)
+
+defs = (
+"boost_python_test",
+"abstract",
+"getting_started1",
+"getting_started2",
+"getting_started3",
+"getting_started4",
+"getting_started5",
+"pickle1",
+"pickle2",
+"pickle3",
+"noncopyable_export",
+"noncopyable_import",
+"ivect",
+"dvect",
+)
+
+if (__name__ == "__main__"):
+
+  import sys, os, string
+
+  path = sys.argv[1]
+  mode = sys.argv[2]
+  if (not mode in ("softlinks", "unlink", "cp", "rm", "copy", "del")):
+    raise RuntimeError, \
+      "usage: python filemgr.py path <softlinks|unlink|cp|rm|copy|del>"
+
+  translation_table = string.maketrans("/", "\\")
+
+  if (mode == "copy"):
+    for fn in files:
+      fn = string.translate(fn, translation_table)
+      os.system("copy " + path + fn + " .")
+
+  elif (mode == "cp"):
+    for fn in files:
+      os.system("cp " + path + fn + " .")
+
+  elif (mode == "softlinks"):
+    for fn in files:
+      f = string.split(fn, "/")[-1]
+      if (os.access(f, os.F_OK)):
+        print "File exists: " + f
+      else:
+        os.system("ln -s " + path + os.sep + fn + " .")
+
+  elif (mode in ("rm", "del")):
+    for fn in files:
+      flds = string.split(fn, "/")
+      try: os.unlink(flds[-1])
+      except: pass
+
+  elif (mode == "unlink"):
+    for fn in files:
+      f = string.split(fn, "/")[-1]
+      if (os.system("test -e " + f) == 0):
+        if (os.system("test -L " + f) == 0):
+          try: os.unlink(f)
+          except: pass
+        else:
+          print "Not a softlink: " + f
+
+  if (mode in ("softlinks", "cp", "copy")):
+    for d in defs:
+      fn = d + ".def"
+      f = open(fn, "w")
+      f.write("EXPORTS\n")
+      f.write("\tinit" + d + "\n")
+      f.close()
+
+  if (mode in ("unlink", "rm", "del")):
+    for d in defs:
+      fn = d + ".def"
+      try: os.unlink(fn)
+      except: pass
diff --git a/build/vc60.mak b/build/vc60.mak
new file mode 100644
index 00000000..a05d04f4
--- /dev/null
+++ b/build/vc60.mak
@@ -0,0 +1,129 @@
+# Usage:
+#
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
+
+BOOST_WIN= "L:\boost"
+BOOST_UNIX= /net/cci/rwgk/boost
+
+PYEXE= "C:\Program files\Python\python.exe"
+PYINC= /I"C:\Program files\Python\include"
+PYLIB= "C:\Program files\Python\libs\python15.lib"
+
+STDOPTS= /nologo /MD /GR /GX /FD /Zm200
+WARNOPTS=
+
+CPP= cl.exe
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) /I$(BOOST_WIN) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS)
+
+LD= link.exe
+LDOPTS= /nologo /dll /incremental:no
+
+OBJ = classes.obj conversions.obj extension_class.obj functions.obj \
+      init_function.obj module_builder.obj \
+      objects.obj types.obj cross_module.obj
+
+.SUFFIXES: .obj .cpp
+
+all: libboost_python.a \
+     boost_python_test.pyd \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
+     getting_started4.pyd getting_started5.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd
+
+libboost_python.a: $(OBJ)
+
+boost_python_test.pyd: $(OBJ) comprehensive.obj
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.obj $(PYLIB) /export:initboost_python_test /out:"boost_python_test.pyd"
+
+abstract.pyd: $(OBJ) abstract.obj
+	$(LD) $(LDOPTS) $(OBJ) abstract.obj $(PYLIB) /export:initabstract /out:"abstract.pyd"
+
+getting_started1.pyd: $(OBJ) getting_started1.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.obj $(PYLIB) /export:initgetting_started1 /out:"getting_started1.pyd"
+
+getting_started2.pyd: $(OBJ) getting_started2.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB) /export:initgetting_started2 /out:"getting_started2.pyd"
+
+getting_started3.pyd: $(OBJ) getting_started3.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started3.obj $(PYLIB) /export:initgetting_started3 /out:"getting_started3.pyd"
+
+getting_started4.pyd: $(OBJ) getting_started4.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started4.obj $(PYLIB) /export:initgetting_started4 /out:"getting_started4.pyd"
+
+getting_started5.pyd: $(OBJ) getting_started5.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started5.obj $(PYLIB) /export:initgetting_started5 /out:"getting_started5.pyd"
+
+pickle1.pyd: $(OBJ) pickle1.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB) /export:initpickle1 /out:"pickle1.pyd"
+
+pickle2.pyd: $(OBJ) pickle2.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle2.obj $(PYLIB) /export:initpickle2 /out:"pickle2.pyd"
+
+pickle3.pyd: $(OBJ) pickle3.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle3.obj $(PYLIB) /export:initpickle3 /out:"pickle3.pyd"
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_export.obj $(PYLIB) /export:initnoncopyable_export /out:"noncopyable_export.pyd"
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_import.obj $(PYLIB) /export:initnoncopyable_import /out:"noncopyable_import.pyd"
+
+ivect.pyd: $(OBJ) ivect.obj
+	$(LD) $(LDOPTS) $(OBJ) ivect.obj $(PYLIB) /export:initivect /out:"ivect.pyd"
+
+dvect.pyd: $(OBJ) dvect.obj
+	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB) /export:initdvect /out:"dvect.pyd"
+
+.cpp.obj:
+	$(CPP) $(CPPOPTS) /c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py --broken-auto-ptr 
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_getting_started4.py
+	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+
+tst:
+	$(PYEXE) tst_noncopyable.py
+	$(PYEXE) tst_ivect.py
+	$(PYEXE) tst_dvect.py
+
+clean:
+	del *.obj
+	del *.lib
+	del *.exp
+	del *.idb
+	del *.pyd
+	del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	python $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	python $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del

From c4775a581edb6aaf6c7e9cde17c5e4a26be9f36d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 21 Mar 2001 01:05:30 +0000
Subject: [PATCH 072/369] temp files before branching

[SVN r9615]
---
 example/dvect_conversions.cpp | 51 +++++++++++++++++++++
 example/dvect_defs.cpp        | 13 ++++++
 example/ivect_conversions.cpp | 51 +++++++++++++++++++++
 example/ivect_defs.cpp        | 13 ++++++
 example/swap_iv_dv.sh         |  1 +
 example/tst_dvect1.py         | 23 ++++++++++
 example/tst_dvect2.py         | 85 +++++++++++++++++++++++++++++++++++
 example/tst_ivect1.py         | 23 ++++++++++
 example/tst_ivect2.py         | 85 +++++++++++++++++++++++++++++++++++
 9 files changed, 345 insertions(+)
 create mode 100644 example/dvect_conversions.cpp
 create mode 100644 example/dvect_defs.cpp
 create mode 100644 example/ivect_conversions.cpp
 create mode 100644 example/ivect_defs.cpp
 create mode 100644 example/swap_iv_dv.sh
 create mode 100644 example/tst_dvect1.py
 create mode 100644 example/tst_dvect2.py
 create mode 100644 example/tst_ivect1.py
 create mode 100644 example/tst_ivect2.py

diff --git a/example/dvect_conversions.cpp b/example/dvect_conversions.cpp
new file mode 100644
index 00000000..21527243
--- /dev/null
+++ b/example/dvect_conversions.cpp
@@ -0,0 +1,51 @@
+  // basics first: const reference converters
+  boost::python::tuple const_dvect_reference_as_tuple(const vects::dvect& dv)
+  {
+    return dv.as_tuple();
+  }
+
+  // to_python smart pointer conversions
+  std::auto_ptr<vects::dvect> dvect_as_auto_ptr(const vects::dvect& dv)
+  {
+    return std::auto_ptr<vects::dvect>(new vects::dvect(dv));
+  }
+  boost::shared_ptr<vects::dvect> dvect_as_shared_ptr(const vects::dvect& dv)
+  {
+    return boost::shared_ptr<vects::dvect>(new vects::dvect(dv));
+  }
+
+  // smart pointers passed by value
+  boost::python::ref auto_ptr_value_dvect_as_tuple(std::auto_ptr<vects::dvect> dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_value_dvect_as_tuple(boost::shared_ptr<vects::dvect> dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+
+  // smart pointers passed by reference
+  boost::python::ref auto_ptr_reference_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_reference_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+
+  // smart pointers passed by const reference
+  boost::python::ref auto_ptr_const_reference_dvect_as_tuple(const std::auto_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_const_reference_dvect_as_tuple(const boost::shared_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
diff --git a/example/dvect_defs.cpp b/example/dvect_defs.cpp
new file mode 100644
index 00000000..2739b219
--- /dev/null
+++ b/example/dvect_defs.cpp
@@ -0,0 +1,13 @@
+    this_module.def(dvect_as_auto_ptr, "dvect_as_auto_ptr");
+    this_module.def(dvect_as_shared_ptr, "dvect_as_shared_ptr");
+
+    this_module.def(const_dvect_reference_as_tuple, "const_dvect_reference_as_tuple");
+
+    this_module.def(auto_ptr_value_dvect_as_tuple, "auto_ptr_value_dvect_as_tuple");
+    this_module.def(shared_ptr_value_dvect_as_tuple, "shared_ptr_value_dvect_as_tuple");
+
+    this_module.def(auto_ptr_reference_dvect_as_tuple, "auto_ptr_reference_dvect_as_tuple");
+    this_module.def(shared_ptr_reference_dvect_as_tuple, "shared_ptr_reference_dvect_as_tuple");
+
+    this_module.def(auto_ptr_const_reference_dvect_as_tuple, "auto_ptr_const_reference_dvect_as_tuple");
+    this_module.def(shared_ptr_const_reference_dvect_as_tuple, "shared_ptr_const_reference_dvect_as_tuple");
diff --git a/example/ivect_conversions.cpp b/example/ivect_conversions.cpp
new file mode 100644
index 00000000..4f59573d
--- /dev/null
+++ b/example/ivect_conversions.cpp
@@ -0,0 +1,51 @@
+  // basics first: const reference converters
+  boost::python::tuple const_ivect_reference_as_tuple(const vects::ivect& iv)
+  {
+    return iv.as_tuple();
+  }
+
+  // to_python smart pointer conversions
+  std::auto_ptr<vects::ivect> ivect_as_auto_ptr(const vects::ivect& iv)
+  {
+    return std::auto_ptr<vects::ivect>(new vects::ivect(iv));
+  }
+  boost::shared_ptr<vects::ivect> ivect_as_shared_ptr(const vects::ivect& iv)
+  {
+    return boost::shared_ptr<vects::ivect>(new vects::ivect(iv));
+  }
+
+  // smart pointers passed by value
+  boost::python::ref auto_ptr_value_ivect_as_tuple(std::auto_ptr<vects::ivect> iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_value_ivect_as_tuple(boost::shared_ptr<vects::ivect> iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+
+  // smart pointers passed by reference
+  boost::python::ref auto_ptr_reference_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_reference_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+
+  // smart pointers passed by const reference
+  boost::python::ref auto_ptr_const_reference_ivect_as_tuple(const std::auto_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_const_reference_ivect_as_tuple(const boost::shared_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
diff --git a/example/ivect_defs.cpp b/example/ivect_defs.cpp
new file mode 100644
index 00000000..811c243d
--- /dev/null
+++ b/example/ivect_defs.cpp
@@ -0,0 +1,13 @@
+    this_module.def(ivect_as_auto_ptr, "ivect_as_auto_ptr");
+    this_module.def(ivect_as_shared_ptr, "ivect_as_shared_ptr");
+
+    this_module.def(const_ivect_reference_as_tuple, "const_ivect_reference_as_tuple");
+
+    this_module.def(auto_ptr_value_ivect_as_tuple, "auto_ptr_value_ivect_as_tuple");
+    this_module.def(shared_ptr_value_ivect_as_tuple, "shared_ptr_value_ivect_as_tuple");
+
+    this_module.def(auto_ptr_reference_ivect_as_tuple, "auto_ptr_reference_ivect_as_tuple");
+    this_module.def(shared_ptr_reference_ivect_as_tuple, "shared_ptr_reference_ivect_as_tuple");
+
+    this_module.def(auto_ptr_const_reference_ivect_as_tuple, "auto_ptr_const_reference_ivect_as_tuple");
+    this_module.def(shared_ptr_const_reference_ivect_as_tuple, "shared_ptr_const_reference_ivect_as_tuple");
diff --git a/example/swap_iv_dv.sh b/example/swap_iv_dv.sh
new file mode 100644
index 00000000..fc072bee
--- /dev/null
+++ b/example/swap_iv_dv.sh
@@ -0,0 +1 @@
+sed 's/iv/xv/g' $1 | sed 's/dv/iv/g' | sed 's/xv/dv/g'
diff --git a/example/tst_dvect1.py b/example/tst_dvect1.py
new file mode 100644
index 00000000..12c53739
--- /dev/null
+++ b/example/tst_dvect1.py
@@ -0,0 +1,23 @@
+def f():
+  import dvect
+  print dvect.dvect.__converters__
+  dv = dvect.dvect((1,2,3,4,5))
+  print dv
+  print dv.as_tuple()
+  iv = dv.as_ivect()
+  print iv
+  print iv.as_tuple()
+  print dvect.const_ivect_reference_as_tuple(iv)
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(aiv)
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(siv)
+  print aiv.as_tuple()
+  print siv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_dvect2.py b/example/tst_dvect2.py
new file mode 100644
index 00000000..868c107d
--- /dev/null
+++ b/example/tst_dvect2.py
@@ -0,0 +1,85 @@
+def f():
+  import dvect
+  import ivect
+  #
+  dv = dvect.dvect((1,2,3,4,5))
+  iv = dv.as_ivect()
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_value_ivect_as_tuple'
+  print ivect.auto_ptr_value_ivect_as_tuple(aiv)
+  print '2. auto_ptr_value_ivect_as_tuple'
+  print ivect.auto_ptr_value_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_value_dvect_as_tuple'
+  print ivect.auto_ptr_value_dvect_as_tuple(adv)
+  print '2. auto_ptr_value_dvect_as_tuple'
+  print ivect.auto_ptr_value_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_value_ivect_as_tuple'
+  print ivect.shared_ptr_value_ivect_as_tuple(siv)
+  print '2. shared_ptr_value_ivect_as_tuple'
+  print ivect.shared_ptr_value_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_value_dvect_as_tuple'
+  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
+  print '2. shared_ptr_value_dvect_as_tuple'
+  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_reference_ivect_as_tuple'
+  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_reference_ivect_as_tuple'
+  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_reference_dvect_as_tuple'
+  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_reference_dvect_as_tuple'
+  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_reference_ivect_as_tuple'
+  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_reference_ivect_as_tuple'
+  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_reference_dvect_as_tuple'
+  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_reference_dvect_as_tuple'
+  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_const_reference_ivect_as_tuple'
+  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_const_reference_ivect_as_tuple'
+  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_const_reference_dvect_as_tuple'
+  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_const_reference_dvect_as_tuple'
+  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_const_reference_ivect_as_tuple'
+  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_const_reference_ivect_as_tuple'
+  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_const_reference_dvect_as_tuple'
+  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_const_reference_dvect_as_tuple'
+  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_ivect1.py b/example/tst_ivect1.py
new file mode 100644
index 00000000..62d3ecf4
--- /dev/null
+++ b/example/tst_ivect1.py
@@ -0,0 +1,23 @@
+def f():
+  import ivect
+  print ivect.ivect.__converters__
+  iv = ivect.ivect((1,2,3,4,5))
+  print iv
+  print iv.as_tuple()
+  dv = iv.as_dvect()
+  print dv
+  print dv.as_tuple()
+  print ivect.const_dvect_reference_as_tuple(dv)
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(adv)
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(sdv)
+  print adv.as_tuple()
+  print sdv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_ivect2.py b/example/tst_ivect2.py
new file mode 100644
index 00000000..0db6903d
--- /dev/null
+++ b/example/tst_ivect2.py
@@ -0,0 +1,85 @@
+def f():
+  import ivect
+  import dvect
+  #
+  iv = ivect.ivect((1,2,3,4,5))
+  dv = iv.as_dvect()
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_value_dvect_as_tuple'
+  print dvect.auto_ptr_value_dvect_as_tuple(adv)
+  print '2. auto_ptr_value_dvect_as_tuple'
+  print dvect.auto_ptr_value_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_value_ivect_as_tuple'
+  print dvect.auto_ptr_value_ivect_as_tuple(aiv)
+  print '2. auto_ptr_value_ivect_as_tuple'
+  print dvect.auto_ptr_value_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_value_dvect_as_tuple'
+  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
+  print '2. shared_ptr_value_dvect_as_tuple'
+  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_value_ivect_as_tuple'
+  print dvect.shared_ptr_value_ivect_as_tuple(siv)
+  print '2. shared_ptr_value_ivect_as_tuple'
+  print dvect.shared_ptr_value_ivect_as_tuple(siv)
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_reference_dvect_as_tuple'
+  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_reference_dvect_as_tuple'
+  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_reference_ivect_as_tuple'
+  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_reference_ivect_as_tuple'
+  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_reference_dvect_as_tuple'
+  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_reference_dvect_as_tuple'
+  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_reference_ivect_as_tuple'
+  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_reference_ivect_as_tuple'
+  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_const_reference_dvect_as_tuple'
+  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_const_reference_dvect_as_tuple'
+  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_const_reference_ivect_as_tuple'
+  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_const_reference_ivect_as_tuple'
+  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_const_reference_dvect_as_tuple'
+  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_const_reference_dvect_as_tuple'
+  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_const_reference_ivect_as_tuple'
+  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_const_reference_ivect_as_tuple'
+  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()

From c7d7cec28190763156ebe44d950f830ffac07c77 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 21 Mar 2001 01:07:07 +0000
Subject: [PATCH 073/369] temp files removed after branching.

[SVN r9616]
---
 example/dvect_conversions.cpp | 51 ---------------------
 example/dvect_defs.cpp        | 13 ------
 example/ivect_conversions.cpp | 51 ---------------------
 example/ivect_defs.cpp        | 13 ------
 example/swap_iv_dv.sh         |  1 -
 example/tst_dvect1.py         | 23 ----------
 example/tst_dvect2.py         | 85 -----------------------------------
 example/tst_ivect1.py         | 23 ----------
 example/tst_ivect2.py         | 85 -----------------------------------
 9 files changed, 345 deletions(-)
 delete mode 100644 example/dvect_conversions.cpp
 delete mode 100644 example/dvect_defs.cpp
 delete mode 100644 example/ivect_conversions.cpp
 delete mode 100644 example/ivect_defs.cpp
 delete mode 100644 example/swap_iv_dv.sh
 delete mode 100644 example/tst_dvect1.py
 delete mode 100644 example/tst_dvect2.py
 delete mode 100644 example/tst_ivect1.py
 delete mode 100644 example/tst_ivect2.py

diff --git a/example/dvect_conversions.cpp b/example/dvect_conversions.cpp
deleted file mode 100644
index 21527243..00000000
--- a/example/dvect_conversions.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-  // basics first: const reference converters
-  boost::python::tuple const_dvect_reference_as_tuple(const vects::dvect& dv)
-  {
-    return dv.as_tuple();
-  }
-
-  // to_python smart pointer conversions
-  std::auto_ptr<vects::dvect> dvect_as_auto_ptr(const vects::dvect& dv)
-  {
-    return std::auto_ptr<vects::dvect>(new vects::dvect(dv));
-  }
-  boost::shared_ptr<vects::dvect> dvect_as_shared_ptr(const vects::dvect& dv)
-  {
-    return boost::shared_ptr<vects::dvect>(new vects::dvect(dv));
-  }
-
-  // smart pointers passed by value
-  boost::python::ref auto_ptr_value_dvect_as_tuple(std::auto_ptr<vects::dvect> dv)
-  {
-    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return dv->as_tuple().reference();
-  }
-  boost::python::ref shared_ptr_value_dvect_as_tuple(boost::shared_ptr<vects::dvect> dv)
-  {
-    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return dv->as_tuple().reference();
-  }
-
-  // smart pointers passed by reference
-  boost::python::ref auto_ptr_reference_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
-  {
-    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return dv->as_tuple().reference();
-  }
-  boost::python::ref shared_ptr_reference_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
-  {
-    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return dv->as_tuple().reference();
-  }
-
-  // smart pointers passed by const reference
-  boost::python::ref auto_ptr_const_reference_dvect_as_tuple(const std::auto_ptr<vects::dvect>& dv)
-  {
-    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return dv->as_tuple().reference();
-  }
-  boost::python::ref shared_ptr_const_reference_dvect_as_tuple(const boost::shared_ptr<vects::dvect>& dv)
-  {
-    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return dv->as_tuple().reference();
-  }
diff --git a/example/dvect_defs.cpp b/example/dvect_defs.cpp
deleted file mode 100644
index 2739b219..00000000
--- a/example/dvect_defs.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-    this_module.def(dvect_as_auto_ptr, "dvect_as_auto_ptr");
-    this_module.def(dvect_as_shared_ptr, "dvect_as_shared_ptr");
-
-    this_module.def(const_dvect_reference_as_tuple, "const_dvect_reference_as_tuple");
-
-    this_module.def(auto_ptr_value_dvect_as_tuple, "auto_ptr_value_dvect_as_tuple");
-    this_module.def(shared_ptr_value_dvect_as_tuple, "shared_ptr_value_dvect_as_tuple");
-
-    this_module.def(auto_ptr_reference_dvect_as_tuple, "auto_ptr_reference_dvect_as_tuple");
-    this_module.def(shared_ptr_reference_dvect_as_tuple, "shared_ptr_reference_dvect_as_tuple");
-
-    this_module.def(auto_ptr_const_reference_dvect_as_tuple, "auto_ptr_const_reference_dvect_as_tuple");
-    this_module.def(shared_ptr_const_reference_dvect_as_tuple, "shared_ptr_const_reference_dvect_as_tuple");
diff --git a/example/ivect_conversions.cpp b/example/ivect_conversions.cpp
deleted file mode 100644
index 4f59573d..00000000
--- a/example/ivect_conversions.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-  // basics first: const reference converters
-  boost::python::tuple const_ivect_reference_as_tuple(const vects::ivect& iv)
-  {
-    return iv.as_tuple();
-  }
-
-  // to_python smart pointer conversions
-  std::auto_ptr<vects::ivect> ivect_as_auto_ptr(const vects::ivect& iv)
-  {
-    return std::auto_ptr<vects::ivect>(new vects::ivect(iv));
-  }
-  boost::shared_ptr<vects::ivect> ivect_as_shared_ptr(const vects::ivect& iv)
-  {
-    return boost::shared_ptr<vects::ivect>(new vects::ivect(iv));
-  }
-
-  // smart pointers passed by value
-  boost::python::ref auto_ptr_value_ivect_as_tuple(std::auto_ptr<vects::ivect> iv)
-  {
-    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return iv->as_tuple().reference();
-  }
-  boost::python::ref shared_ptr_value_ivect_as_tuple(boost::shared_ptr<vects::ivect> iv)
-  {
-    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return iv->as_tuple().reference();
-  }
-
-  // smart pointers passed by reference
-  boost::python::ref auto_ptr_reference_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
-  {
-    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return iv->as_tuple().reference();
-  }
-  boost::python::ref shared_ptr_reference_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
-  {
-    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return iv->as_tuple().reference();
-  }
-
-  // smart pointers passed by const reference
-  boost::python::ref auto_ptr_const_reference_ivect_as_tuple(const std::auto_ptr<vects::ivect>& iv)
-  {
-    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return iv->as_tuple().reference();
-  }
-  boost::python::ref shared_ptr_const_reference_ivect_as_tuple(const boost::shared_ptr<vects::ivect>& iv)
-  {
-    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
-    return iv->as_tuple().reference();
-  }
diff --git a/example/ivect_defs.cpp b/example/ivect_defs.cpp
deleted file mode 100644
index 811c243d..00000000
--- a/example/ivect_defs.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-    this_module.def(ivect_as_auto_ptr, "ivect_as_auto_ptr");
-    this_module.def(ivect_as_shared_ptr, "ivect_as_shared_ptr");
-
-    this_module.def(const_ivect_reference_as_tuple, "const_ivect_reference_as_tuple");
-
-    this_module.def(auto_ptr_value_ivect_as_tuple, "auto_ptr_value_ivect_as_tuple");
-    this_module.def(shared_ptr_value_ivect_as_tuple, "shared_ptr_value_ivect_as_tuple");
-
-    this_module.def(auto_ptr_reference_ivect_as_tuple, "auto_ptr_reference_ivect_as_tuple");
-    this_module.def(shared_ptr_reference_ivect_as_tuple, "shared_ptr_reference_ivect_as_tuple");
-
-    this_module.def(auto_ptr_const_reference_ivect_as_tuple, "auto_ptr_const_reference_ivect_as_tuple");
-    this_module.def(shared_ptr_const_reference_ivect_as_tuple, "shared_ptr_const_reference_ivect_as_tuple");
diff --git a/example/swap_iv_dv.sh b/example/swap_iv_dv.sh
deleted file mode 100644
index fc072bee..00000000
--- a/example/swap_iv_dv.sh
+++ /dev/null
@@ -1 +0,0 @@
-sed 's/iv/xv/g' $1 | sed 's/dv/iv/g' | sed 's/xv/dv/g'
diff --git a/example/tst_dvect1.py b/example/tst_dvect1.py
deleted file mode 100644
index 12c53739..00000000
--- a/example/tst_dvect1.py
+++ /dev/null
@@ -1,23 +0,0 @@
-def f():
-  import dvect
-  print dvect.dvect.__converters__
-  dv = dvect.dvect((1,2,3,4,5))
-  print dv
-  print dv.as_tuple()
-  iv = dv.as_ivect()
-  print iv
-  print iv.as_tuple()
-  print dvect.const_ivect_reference_as_tuple(iv)
-  aiv = dvect.ivect_as_auto_ptr(iv)
-  print dvect.const_ivect_reference_as_tuple(aiv)
-  siv = dvect.ivect_as_shared_ptr(iv)
-  print dvect.const_ivect_reference_as_tuple(siv)
-  print aiv.as_tuple()
-  print siv.as_tuple()
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()
diff --git a/example/tst_dvect2.py b/example/tst_dvect2.py
deleted file mode 100644
index 868c107d..00000000
--- a/example/tst_dvect2.py
+++ /dev/null
@@ -1,85 +0,0 @@
-def f():
-  import dvect
-  import ivect
-  #
-  dv = dvect.dvect((1,2,3,4,5))
-  iv = dv.as_ivect()
-  #
-  aiv = dvect.ivect_as_auto_ptr(iv)
-  print '1. auto_ptr_value_ivect_as_tuple'
-  print ivect.auto_ptr_value_ivect_as_tuple(aiv)
-  print '2. auto_ptr_value_ivect_as_tuple'
-  print ivect.auto_ptr_value_ivect_as_tuple(aiv)
-  #
-  adv = dvect.dvect_as_auto_ptr(dv)
-  print '1. auto_ptr_value_dvect_as_tuple'
-  print ivect.auto_ptr_value_dvect_as_tuple(adv)
-  print '2. auto_ptr_value_dvect_as_tuple'
-  print ivect.auto_ptr_value_dvect_as_tuple(adv)
-  #
-  siv = dvect.ivect_as_shared_ptr(iv)
-  print '1. shared_ptr_value_ivect_as_tuple'
-  print ivect.shared_ptr_value_ivect_as_tuple(siv)
-  print '2. shared_ptr_value_ivect_as_tuple'
-  print ivect.shared_ptr_value_ivect_as_tuple(siv)
-  #
-  sdv = dvect.dvect_as_shared_ptr(dv)
-  print '1. shared_ptr_value_dvect_as_tuple'
-  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
-  print '2. shared_ptr_value_dvect_as_tuple'
-  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
-  #
-  aiv = dvect.ivect_as_auto_ptr(iv)
-  print '1. auto_ptr_reference_ivect_as_tuple'
-  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
-  print '2. auto_ptr_reference_ivect_as_tuple'
-  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
-  #
-  adv = dvect.dvect_as_auto_ptr(dv)
-  print '1. auto_ptr_reference_dvect_as_tuple'
-  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
-  print '2. auto_ptr_reference_dvect_as_tuple'
-  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
-  #
-  siv = dvect.ivect_as_shared_ptr(iv)
-  print '1. shared_ptr_reference_ivect_as_tuple'
-  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
-  print '2. shared_ptr_reference_ivect_as_tuple'
-  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
-  #
-  sdv = dvect.dvect_as_shared_ptr(dv)
-  print '1. shared_ptr_reference_dvect_as_tuple'
-  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
-  print '2. shared_ptr_reference_dvect_as_tuple'
-  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
-  #
-  aiv = dvect.ivect_as_auto_ptr(iv)
-  print '1. auto_ptr_const_reference_ivect_as_tuple'
-  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
-  print '2. auto_ptr_const_reference_ivect_as_tuple'
-  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
-  #
-  adv = dvect.dvect_as_auto_ptr(dv)
-  print '1. auto_ptr_const_reference_dvect_as_tuple'
-  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
-  print '2. auto_ptr_const_reference_dvect_as_tuple'
-  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
-  #
-  siv = dvect.ivect_as_shared_ptr(iv)
-  print '1. shared_ptr_const_reference_ivect_as_tuple'
-  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
-  print '2. shared_ptr_const_reference_ivect_as_tuple'
-  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
-  #
-  sdv = dvect.dvect_as_shared_ptr(dv)
-  print '1. shared_ptr_const_reference_dvect_as_tuple'
-  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
-  print '2. shared_ptr_const_reference_dvect_as_tuple'
-  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()
diff --git a/example/tst_ivect1.py b/example/tst_ivect1.py
deleted file mode 100644
index 62d3ecf4..00000000
--- a/example/tst_ivect1.py
+++ /dev/null
@@ -1,23 +0,0 @@
-def f():
-  import ivect
-  print ivect.ivect.__converters__
-  iv = ivect.ivect((1,2,3,4,5))
-  print iv
-  print iv.as_tuple()
-  dv = iv.as_dvect()
-  print dv
-  print dv.as_tuple()
-  print ivect.const_dvect_reference_as_tuple(dv)
-  adv = ivect.dvect_as_auto_ptr(dv)
-  print ivect.const_dvect_reference_as_tuple(adv)
-  sdv = ivect.dvect_as_shared_ptr(dv)
-  print ivect.const_dvect_reference_as_tuple(sdv)
-  print adv.as_tuple()
-  print sdv.as_tuple()
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()
diff --git a/example/tst_ivect2.py b/example/tst_ivect2.py
deleted file mode 100644
index 0db6903d..00000000
--- a/example/tst_ivect2.py
+++ /dev/null
@@ -1,85 +0,0 @@
-def f():
-  import ivect
-  import dvect
-  #
-  iv = ivect.ivect((1,2,3,4,5))
-  dv = iv.as_dvect()
-  #
-  adv = ivect.dvect_as_auto_ptr(dv)
-  print '1. auto_ptr_value_dvect_as_tuple'
-  print dvect.auto_ptr_value_dvect_as_tuple(adv)
-  print '2. auto_ptr_value_dvect_as_tuple'
-  print dvect.auto_ptr_value_dvect_as_tuple(adv)
-  #
-  aiv = ivect.ivect_as_auto_ptr(iv)
-  print '1. auto_ptr_value_ivect_as_tuple'
-  print dvect.auto_ptr_value_ivect_as_tuple(aiv)
-  print '2. auto_ptr_value_ivect_as_tuple'
-  print dvect.auto_ptr_value_ivect_as_tuple(aiv)
-  #
-  sdv = ivect.dvect_as_shared_ptr(dv)
-  print '1. shared_ptr_value_dvect_as_tuple'
-  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
-  print '2. shared_ptr_value_dvect_as_tuple'
-  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
-  #
-  siv = ivect.ivect_as_shared_ptr(iv)
-  print '1. shared_ptr_value_ivect_as_tuple'
-  print dvect.shared_ptr_value_ivect_as_tuple(siv)
-  print '2. shared_ptr_value_ivect_as_tuple'
-  print dvect.shared_ptr_value_ivect_as_tuple(siv)
-  #
-  adv = ivect.dvect_as_auto_ptr(dv)
-  print '1. auto_ptr_reference_dvect_as_tuple'
-  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
-  print '2. auto_ptr_reference_dvect_as_tuple'
-  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
-  #
-  aiv = ivect.ivect_as_auto_ptr(iv)
-  print '1. auto_ptr_reference_ivect_as_tuple'
-  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
-  print '2. auto_ptr_reference_ivect_as_tuple'
-  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
-  #
-  sdv = ivect.dvect_as_shared_ptr(dv)
-  print '1. shared_ptr_reference_dvect_as_tuple'
-  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
-  print '2. shared_ptr_reference_dvect_as_tuple'
-  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
-  #
-  siv = ivect.ivect_as_shared_ptr(iv)
-  print '1. shared_ptr_reference_ivect_as_tuple'
-  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
-  print '2. shared_ptr_reference_ivect_as_tuple'
-  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
-  #
-  adv = ivect.dvect_as_auto_ptr(dv)
-  print '1. auto_ptr_const_reference_dvect_as_tuple'
-  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
-  print '2. auto_ptr_const_reference_dvect_as_tuple'
-  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
-  #
-  aiv = ivect.ivect_as_auto_ptr(iv)
-  print '1. auto_ptr_const_reference_ivect_as_tuple'
-  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
-  print '2. auto_ptr_const_reference_ivect_as_tuple'
-  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
-  #
-  sdv = ivect.dvect_as_shared_ptr(dv)
-  print '1. shared_ptr_const_reference_dvect_as_tuple'
-  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
-  print '2. shared_ptr_const_reference_dvect_as_tuple'
-  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
-  #
-  siv = ivect.ivect_as_shared_ptr(iv)
-  print '1. shared_ptr_const_reference_ivect_as_tuple'
-  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
-  print '2. shared_ptr_const_reference_ivect_as_tuple'
-  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()

From 4ec0b61de5ec0f677bb4ad7d6d6948bf8cbd00c4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 21 Mar 2001 01:09:17 +0000
Subject: [PATCH 074/369] Now using BOOST_PYTHON_MODULE_INIT.

[SVN r9617]
---
 example/abstract.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/example/abstract.cpp b/example/abstract.cpp
index 41d34def..97e38c2e 100644
--- a/example/abstract.cpp
+++ b/example/abstract.cpp
@@ -21,9 +21,7 @@ struct Abstract_callback: Abstract
     PyObject * m_self;
 };
 
-extern "C"
-DL_EXPORT(void)
-initabstract()
+BOOST_PYTHON_MODULE_INIT(abstract)
 {
     boost::python::module_builder a("abstract");
 

From f610e31a87aafbad86576d99c51c6c5347ca5c66 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 21 Mar 2001 01:15:53 +0000
Subject: [PATCH 075/369] temp files removed after branching.

[SVN r9619]
---
 build/filemgr.py | 122 --------------------------------------------
 build/vc60.mak   | 129 -----------------------------------------------
 2 files changed, 251 deletions(-)
 delete mode 100644 build/filemgr.py
 delete mode 100644 build/vc60.mak

diff --git a/build/filemgr.py b/build/filemgr.py
deleted file mode 100644
index 51c87403..00000000
--- a/build/filemgr.py
+++ /dev/null
@@ -1,122 +0,0 @@
-bpl_src = "/libs/python/src"
-bpl_tst = "/libs/python/test"
-bpl_exa = "/libs/python/example"
-files = (
-bpl_src + "/classes.cpp",
-bpl_src + "/conversions.cpp",
-bpl_src + "/extension_class.cpp",
-bpl_src + "/functions.cpp",
-bpl_src + "/init_function.cpp",
-bpl_src + "/module_builder.cpp",
-bpl_src + "/objects.cpp",
-bpl_src + "/types.cpp",
-bpl_src + "/cross_module.cpp",
-bpl_tst + "/comprehensive.cpp",
-bpl_tst + "/comprehensive.hpp",
-bpl_tst + "/comprehensive.py",
-bpl_tst + "/doctest.py",
-bpl_exa + "/abstract.cpp",
-bpl_exa + "/getting_started1.cpp",
-bpl_exa + "/getting_started2.cpp",
-bpl_exa + "/getting_started3.cpp",
-bpl_exa + "/getting_started4.cpp",
-bpl_exa + "/getting_started5.cpp",
-bpl_exa + "/pickle1.cpp",
-bpl_exa + "/pickle2.cpp",
-bpl_exa + "/pickle3.cpp",
-bpl_exa + "/test_abstract.py",
-bpl_exa + "/test_getting_started1.py",
-bpl_exa + "/test_getting_started2.py",
-bpl_exa + "/test_getting_started3.py",
-bpl_exa + "/test_getting_started4.py",
-bpl_exa + "/test_getting_started5.py",
-bpl_exa + "/test_pickle1.py",
-bpl_exa + "/test_pickle2.py",
-bpl_exa + "/test_pickle3.py",
-bpl_exa + "/noncopyable.h",
-bpl_exa + "/noncopyable_export.cpp",
-bpl_exa + "/noncopyable_import.cpp",
-bpl_exa + "/tst_noncopyable.py",
-bpl_exa + "/ivect.h",
-bpl_exa + "/ivect.cpp",
-bpl_exa + "/dvect.h",
-bpl_exa + "/dvect.cpp",
-bpl_exa + "/tst_ivect.py",
-bpl_exa + "/tst_dvect.py",
-)
-
-defs = (
-"boost_python_test",
-"abstract",
-"getting_started1",
-"getting_started2",
-"getting_started3",
-"getting_started4",
-"getting_started5",
-"pickle1",
-"pickle2",
-"pickle3",
-"noncopyable_export",
-"noncopyable_import",
-"ivect",
-"dvect",
-)
-
-if (__name__ == "__main__"):
-
-  import sys, os, string
-
-  path = sys.argv[1]
-  mode = sys.argv[2]
-  if (not mode in ("softlinks", "unlink", "cp", "rm", "copy", "del")):
-    raise RuntimeError, \
-      "usage: python filemgr.py path <softlinks|unlink|cp|rm|copy|del>"
-
-  translation_table = string.maketrans("/", "\\")
-
-  if (mode == "copy"):
-    for fn in files:
-      fn = string.translate(fn, translation_table)
-      os.system("copy " + path + fn + " .")
-
-  elif (mode == "cp"):
-    for fn in files:
-      os.system("cp " + path + fn + " .")
-
-  elif (mode == "softlinks"):
-    for fn in files:
-      f = string.split(fn, "/")[-1]
-      if (os.access(f, os.F_OK)):
-        print "File exists: " + f
-      else:
-        os.system("ln -s " + path + os.sep + fn + " .")
-
-  elif (mode in ("rm", "del")):
-    for fn in files:
-      flds = string.split(fn, "/")
-      try: os.unlink(flds[-1])
-      except: pass
-
-  elif (mode == "unlink"):
-    for fn in files:
-      f = string.split(fn, "/")[-1]
-      if (os.system("test -e " + f) == 0):
-        if (os.system("test -L " + f) == 0):
-          try: os.unlink(f)
-          except: pass
-        else:
-          print "Not a softlink: " + f
-
-  if (mode in ("softlinks", "cp", "copy")):
-    for d in defs:
-      fn = d + ".def"
-      f = open(fn, "w")
-      f.write("EXPORTS\n")
-      f.write("\tinit" + d + "\n")
-      f.close()
-
-  if (mode in ("unlink", "rm", "del")):
-    for d in defs:
-      fn = d + ".def"
-      try: os.unlink(fn)
-      except: pass
diff --git a/build/vc60.mak b/build/vc60.mak
deleted file mode 100644
index a05d04f4..00000000
--- a/build/vc60.mak
+++ /dev/null
@@ -1,129 +0,0 @@
-# Usage:
-#
-#   make copy          Copy the sources and tests
-#   make               Compile all sources
-#   make test          Run doctest tests
-#   make clean         Remove all object files
-#   make del           Remove the sources and tests
-
-BOOST_WIN= "L:\boost"
-BOOST_UNIX= /net/cci/rwgk/boost
-
-PYEXE= "C:\Program files\Python\python.exe"
-PYINC= /I"C:\Program files\Python\include"
-PYLIB= "C:\Program files\Python\libs\python15.lib"
-
-STDOPTS= /nologo /MD /GR /GX /FD /Zm200
-WARNOPTS=
-
-CPP= cl.exe
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) /I$(BOOST_WIN) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS)
-
-LD= link.exe
-LDOPTS= /nologo /dll /incremental:no
-
-OBJ = classes.obj conversions.obj extension_class.obj functions.obj \
-      init_function.obj module_builder.obj \
-      objects.obj types.obj cross_module.obj
-
-.SUFFIXES: .obj .cpp
-
-all: libboost_python.a \
-     boost_python_test.pyd \
-     abstract.pyd \
-     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
-     getting_started4.pyd getting_started5.pyd \
-     pickle1.pyd pickle2.pyd pickle3.pyd \
-     noncopyable_export.pyd noncopyable_import.pyd \
-     ivect.pyd dvect.pyd
-
-libboost_python.a: $(OBJ)
-
-boost_python_test.pyd: $(OBJ) comprehensive.obj
-	$(LD) $(LDOPTS) $(OBJ) comprehensive.obj $(PYLIB) /export:initboost_python_test /out:"boost_python_test.pyd"
-
-abstract.pyd: $(OBJ) abstract.obj
-	$(LD) $(LDOPTS) $(OBJ) abstract.obj $(PYLIB) /export:initabstract /out:"abstract.pyd"
-
-getting_started1.pyd: $(OBJ) getting_started1.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started1.obj $(PYLIB) /export:initgetting_started1 /out:"getting_started1.pyd"
-
-getting_started2.pyd: $(OBJ) getting_started2.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB) /export:initgetting_started2 /out:"getting_started2.pyd"
-
-getting_started3.pyd: $(OBJ) getting_started3.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.obj $(PYLIB) /export:initgetting_started3 /out:"getting_started3.pyd"
-
-getting_started4.pyd: $(OBJ) getting_started4.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started4.obj $(PYLIB) /export:initgetting_started4 /out:"getting_started4.pyd"
-
-getting_started5.pyd: $(OBJ) getting_started5.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started5.obj $(PYLIB) /export:initgetting_started5 /out:"getting_started5.pyd"
-
-pickle1.pyd: $(OBJ) pickle1.obj
-	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB) /export:initpickle1 /out:"pickle1.pyd"
-
-pickle2.pyd: $(OBJ) pickle2.obj
-	$(LD) $(LDOPTS) $(OBJ) pickle2.obj $(PYLIB) /export:initpickle2 /out:"pickle2.pyd"
-
-pickle3.pyd: $(OBJ) pickle3.obj
-	$(LD) $(LDOPTS) $(OBJ) pickle3.obj $(PYLIB) /export:initpickle3 /out:"pickle3.pyd"
-
-noncopyable_export.pyd: $(OBJ) noncopyable_export.obj
-	$(LD) $(LDOPTS) $(OBJ) noncopyable_export.obj $(PYLIB) /export:initnoncopyable_export /out:"noncopyable_export.pyd"
-
-noncopyable_import.pyd: $(OBJ) noncopyable_import.obj
-	$(LD) $(LDOPTS) $(OBJ) noncopyable_import.obj $(PYLIB) /export:initnoncopyable_import /out:"noncopyable_import.pyd"
-
-ivect.pyd: $(OBJ) ivect.obj
-	$(LD) $(LDOPTS) $(OBJ) ivect.obj $(PYLIB) /export:initivect /out:"ivect.pyd"
-
-dvect.pyd: $(OBJ) dvect.obj
-	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB) /export:initdvect /out:"dvect.pyd"
-
-.cpp.obj:
-	$(CPP) $(CPPOPTS) /c $*.cpp
-
-test:
-	$(PYEXE) comprehensive.py --broken-auto-ptr 
-	$(PYEXE) test_abstract.py
-	$(PYEXE) test_getting_started1.py
-	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
-	$(PYEXE) test_pickle1.py
-	$(PYEXE) test_pickle2.py
-	$(PYEXE) test_pickle3.py
-
-tst:
-	$(PYEXE) tst_noncopyable.py
-	$(PYEXE) tst_ivect.py
-	$(PYEXE) tst_dvect.py
-
-clean:
-	del *.obj
-	del *.lib
-	del *.exp
-	del *.idb
-	del *.pyd
-	del *.pyc
-
-softlinks:
-	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
-
-unlink:
-	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
-
-cp:
-	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
-
-rm:
-	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
-
-copy:
-	python $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
-
-del:
-	python $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del

From 2a96c9f9eea85095c6c1ff889d3c264123e72945 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 21 Mar 2001 02:33:27 +0000
Subject: [PATCH 076/369] temp file before branching

[SVN r9621]
---
 example/do_it_yourself_converters.cpp     | 126 ++++++++++++++++++++++
 example/simple_vector.cpp                 | 101 +++++++++++++++++
 example/test_do_it_yourself_converters.py |  22 ++++
 example/test_simple_vector.py             |  35 ++++++
 4 files changed, 284 insertions(+)
 create mode 100644 example/do_it_yourself_converters.cpp
 create mode 100644 example/simple_vector.cpp
 create mode 100644 example/test_do_it_yourself_converters.py
 create mode 100644 example/test_simple_vector.py

diff --git a/example/do_it_yourself_converters.cpp b/example/do_it_yourself_converters.cpp
new file mode 100644
index 00000000..ad31f708
--- /dev/null
+++ b/example/do_it_yourself_converters.cpp
@@ -0,0 +1,126 @@
+/*
+   This example shows how to convert a class from and to native
+   Python objects, such as tuples.
+
+   We do not want to expose the helper class MillerIndex as an
+   Extension Class. However, in order to simplify the wrapper code,
+   we want to define from_python() and to_python() functions for
+   class MillerIndex.
+
+   Consider the alternatives:
+
+     - Expose MillerIndex as an Extension Class.
+         We need a constructor MillerIndex(python::tuple).
+         Python function calls become more complex:
+           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
+         We need a method such as MillerIndex().as_tuple().
+
+     - Define a wrapper function for each function that we
+       want to expose, e.g.:
+          void add(const IndexingSet& ixset, const python::tuple PyMIx)
+
+   The first alternative introduces a new type that the user has to
+   deal with. Other modules using Miller indices might organize them in
+   different ways, for example to increase runtime efficiency for
+   important procedures. This means, the user has to know how to
+   convert between the different kinds of Miller index representations.
+   This can quickly become a nuisance. Relying on native Python data
+   structures minimizes the number of special types the user has to
+   learn and convert. Of course, this argument is only valid for
+   small and relatively simply classes.
+
+   If there are many member functions with MillerIndex arguments, the
+   second alternative is impractical, and concentrating the conversion
+   mechanism in one central place is essential for code
+   maintainability.  An added benefit is that more convenient (smarter)
+   conversion functions can be provided without cluttering the rest of
+   the wrapper code.
+
+ */
+
+#include <string>
+#include <vector>
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // The helper class.
+  //
+  class MillerIndex {
+    public:
+      int v[3];
+  };
+
+  // The main class. Imagine that there are MANY member functions
+  // like add() and get().
+  //
+  class IndexingSet {
+    private:
+      std::vector<MillerIndex> VMIx;
+    public:
+      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
+      MillerIndex get(std::size_t i) const { return VMIx[i]; }
+  };
+}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+  // Convert a Python tuple to a MillerIndex object.
+  //
+  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
+  {
+    python::tuple tup
+      = python::tuple(python::ref(p, python::ref::increment_count));
+    if (tup.size() != 3) {
+      PyErr_SetString(PyExc_ValueError,
+        "expecting exactly 3 values in tuple.");
+      throw python::error_already_set();
+    }
+    MillerIndex result;
+    for (int i = 0; i < 3; i++)
+      result.v[i] = from_python(tup[i].get(), python::type<int>());
+    return result;
+  }
+
+  // Similar conversion for MillerIndex objects passed by value.
+  // Not actually used, but included to show the principle.
+  //
+  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
+  {
+    return from_python(p, python::type<const MillerIndex&>());
+  }
+
+  // Convert a MillerIndex object to a Python tuple.
+  //
+  PyObject* to_python(const MillerIndex& hkl)
+  {
+    python::tuple result(3);
+    for (int i = 0; i < 3; i++)
+      result.set_item(i, python::ref(to_python(hkl.v[i])));
+    return result.reference().release();
+  }
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("do_it_yourself_converters");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
+
+    // Add the __init__ function.
+    ixset_class.def(python::constructor<>());
+    // Add the member functions.
+    ixset_class.def(&IndexingSet::add, "add");
+    ixset_class.def(&IndexingSet::get, "get");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
new file mode 100644
index 00000000..f18f2cad
--- /dev/null
+++ b/example/simple_vector.cpp
@@ -0,0 +1,101 @@
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A wrapper is used to define additional constructors.
+  //
+  struct vector_double_wrapper: std::vector<double>
+  {
+    // Tell the compiler how to convert a base class object to
+    // this wrapper object.
+    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
+      : std::vector<double>(vd) {}
+
+    vector_double_wrapper(PyObject* self)
+      : std::vector<double>() {}
+
+    vector_double_wrapper(PyObject* self, int n)
+      : std::vector<double>(n) {}
+
+    vector_double_wrapper(PyObject* self, python::tuple tuple)
+      : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator vd = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          python::type<double>());
+    }
+  };
+
+  double getitem(const std::vector<double>& vd, std::size_t key) {
+    return vd[key];
+  }
+
+  void setitem(std::vector<double>& vd, std::size_t key, double d) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vditer[key] = d;
+  }
+
+  void delitem(std::vector<double>& vd, std::size_t key) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vd.erase(&vditer[key]);
+  }
+
+  // Convert vector_double to a regular Python tuple.
+  //
+  python::tuple as_tuple(const std::vector<double>& vd)
+  {
+    python::tuple t(vd.size());
+    for (int i = 0; i < vd.size(); i++) t.set_item(i,
+      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
+    return t;
+  }
+
+  // Function returning a vector_double object to Python.
+  //
+  std::vector<double> foo(int n)
+  {
+    std::vector<double> vd(n);
+    std::vector<double>::iterator vditer = vd.begin();
+    for (int i = 0; i < n; i++) vditer[i] = double(i);
+    return vd;
+  }
+
+  // Same as foo(), but avoid copying on return.
+  //
+  std::auto_ptr<std::vector<double> > bar(int n)
+  {
+    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
+    std::vector<double>::iterator vditer = vdptr->begin();
+    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
+    return vdptr;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(simple_vector)
+{
+  try
+  {
+    python::module_builder this_module("simple_vector");
+
+    python::class_builder<std::vector<double>, vector_double_wrapper>
+      vector_double(this_module, "vector_double");
+
+    vector_double.def(python::constructor<>());
+    vector_double.def(python::constructor<const int>());
+    vector_double.def(python::constructor<python::tuple>());
+    vector_double.def(&std::vector<double>::size, "__len__");
+    vector_double.def(getitem, "__getitem__");
+    vector_double.def(setitem, "__setitem__");
+    vector_double.def(delitem, "__delitem__");
+    vector_double.def(as_tuple, "as_tuple");
+
+    this_module.def(foo, "foo");
+    this_module.def(bar, "bar");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/test_do_it_yourself_converters.py b/example/test_do_it_yourself_converters.py
new file mode 100644
index 00000000..e256c614
--- /dev/null
+++ b/example/test_do_it_yourself_converters.py
@@ -0,0 +1,22 @@
+r'''>>> import do_it_yourself_converters
+    >>> ixset = do_it_yourself_converters.IndexingSet()
+    >>> ixset.add((1,2,3))
+    >>> ixset.add((4,5,6))
+    >>> ixset.add((7,8,9))
+    >>> print ixset.get(0)
+    (1, 2, 3)
+    >>> print ixset.get(1)
+    (4, 5, 6)
+    >>> print ixset.get(2)
+    (7, 8, 9)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_do_it_yourself_converters
+    doctest.testmod(test_do_it_yourself_converters)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_simple_vector.py b/example/test_simple_vector.py
new file mode 100644
index 00000000..a19e205b
--- /dev/null
+++ b/example/test_simple_vector.py
@@ -0,0 +1,35 @@
+r'''>>> import simple_vector
+    >>> v=simple_vector.vector_double()
+    >>> print v.as_tuple()
+    ()
+    >>> v=simple_vector.vector_double(5)
+    >>> print v.as_tuple()
+    (0.0, 0.0, 0.0, 0.0, 0.0)
+    >>> print len(v)
+    5
+    >>> v=simple_vector.vector_double((3,4,5))
+    >>> print v.as_tuple()
+    (3.0, 4.0, 5.0)
+    >>> print v[1]
+    4.0
+    >>> v[1] = 40
+    >>> print v.as_tuple()
+    (3.0, 40.0, 5.0)
+    >>> del v[1]
+    >>> print v.as_tuple()
+    (3.0, 5.0)
+    >>> print simple_vector.foo(11).as_tuple()
+    (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
+    >>> print simple_vector.bar(12).as_tuple()
+    (0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_simple_vector
+    doctest.testmod(test_simple_vector)
+
+if __name__ == '__main__':
+    run()

From 01bcd460dabfdd58d435dc020d0025ef3a23b914 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 21 Mar 2001 02:35:32 +0000
Subject: [PATCH 077/369] temp files removed after branching.

[SVN r9623]
---
 example/do_it_yourself_converters.cpp     | 126 ----------------------
 example/simple_vector.cpp                 | 101 -----------------
 example/test_do_it_yourself_converters.py |  22 ----
 example/test_simple_vector.py             |  35 ------
 4 files changed, 284 deletions(-)
 delete mode 100644 example/do_it_yourself_converters.cpp
 delete mode 100644 example/simple_vector.cpp
 delete mode 100644 example/test_do_it_yourself_converters.py
 delete mode 100644 example/test_simple_vector.py

diff --git a/example/do_it_yourself_converters.cpp b/example/do_it_yourself_converters.cpp
deleted file mode 100644
index ad31f708..00000000
--- a/example/do_it_yourself_converters.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-   This example shows how to convert a class from and to native
-   Python objects, such as tuples.
-
-   We do not want to expose the helper class MillerIndex as an
-   Extension Class. However, in order to simplify the wrapper code,
-   we want to define from_python() and to_python() functions for
-   class MillerIndex.
-
-   Consider the alternatives:
-
-     - Expose MillerIndex as an Extension Class.
-         We need a constructor MillerIndex(python::tuple).
-         Python function calls become more complex:
-           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
-         We need a method such as MillerIndex().as_tuple().
-
-     - Define a wrapper function for each function that we
-       want to expose, e.g.:
-          void add(const IndexingSet& ixset, const python::tuple PyMIx)
-
-   The first alternative introduces a new type that the user has to
-   deal with. Other modules using Miller indices might organize them in
-   different ways, for example to increase runtime efficiency for
-   important procedures. This means, the user has to know how to
-   convert between the different kinds of Miller index representations.
-   This can quickly become a nuisance. Relying on native Python data
-   structures minimizes the number of special types the user has to
-   learn and convert. Of course, this argument is only valid for
-   small and relatively simply classes.
-
-   If there are many member functions with MillerIndex arguments, the
-   second alternative is impractical, and concentrating the conversion
-   mechanism in one central place is essential for code
-   maintainability.  An added benefit is that more convenient (smarter)
-   conversion functions can be provided without cluttering the rest of
-   the wrapper code.
-
- */
-
-#include <string>
-#include <vector>
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // The helper class.
-  //
-  class MillerIndex {
-    public:
-      int v[3];
-  };
-
-  // The main class. Imagine that there are MANY member functions
-  // like add() and get().
-  //
-  class IndexingSet {
-    private:
-      std::vector<MillerIndex> VMIx;
-    public:
-      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
-      MillerIndex get(std::size_t i) const { return VMIx[i]; }
-  };
-}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-  // Convert a Python tuple to a MillerIndex object.
-  //
-  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
-  {
-    python::tuple tup
-      = python::tuple(python::ref(p, python::ref::increment_count));
-    if (tup.size() != 3) {
-      PyErr_SetString(PyExc_ValueError,
-        "expecting exactly 3 values in tuple.");
-      throw python::error_already_set();
-    }
-    MillerIndex result;
-    for (int i = 0; i < 3; i++)
-      result.v[i] = from_python(tup[i].get(), python::type<int>());
-    return result;
-  }
-
-  // Similar conversion for MillerIndex objects passed by value.
-  // Not actually used, but included to show the principle.
-  //
-  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
-  {
-    return from_python(p, python::type<const MillerIndex&>());
-  }
-
-  // Convert a MillerIndex object to a Python tuple.
-  //
-  PyObject* to_python(const MillerIndex& hkl)
-  {
-    python::tuple result(3);
-    for (int i = 0; i < 3; i++)
-      result.set_item(i, python::ref(to_python(hkl.v[i])));
-    return result.reference().release();
-  }
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("do_it_yourself_converters");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
-
-    // Add the __init__ function.
-    ixset_class.def(python::constructor<>());
-    // Add the member functions.
-    ixset_class.def(&IndexingSet::add, "add");
-    ixset_class.def(&IndexingSet::get, "get");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
deleted file mode 100644
index f18f2cad..00000000
--- a/example/simple_vector.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A wrapper is used to define additional constructors.
-  //
-  struct vector_double_wrapper: std::vector<double>
-  {
-    // Tell the compiler how to convert a base class object to
-    // this wrapper object.
-    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
-      : std::vector<double>(vd) {}
-
-    vector_double_wrapper(PyObject* self)
-      : std::vector<double>() {}
-
-    vector_double_wrapper(PyObject* self, int n)
-      : std::vector<double>(n) {}
-
-    vector_double_wrapper(PyObject* self, python::tuple tuple)
-      : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator vd = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          python::type<double>());
-    }
-  };
-
-  double getitem(const std::vector<double>& vd, std::size_t key) {
-    return vd[key];
-  }
-
-  void setitem(std::vector<double>& vd, std::size_t key, double d) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vditer[key] = d;
-  }
-
-  void delitem(std::vector<double>& vd, std::size_t key) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
-  }
-
-  // Convert vector_double to a regular Python tuple.
-  //
-  python::tuple as_tuple(const std::vector<double>& vd)
-  {
-    python::tuple t(vd.size());
-    for (int i = 0; i < vd.size(); i++) t.set_item(i,
-      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
-    return t;
-  }
-
-  // Function returning a vector_double object to Python.
-  //
-  std::vector<double> foo(int n)
-  {
-    std::vector<double> vd(n);
-    std::vector<double>::iterator vditer = vd.begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(i);
-    return vd;
-  }
-
-  // Same as foo(), but avoid copying on return.
-  //
-  std::auto_ptr<std::vector<double> > bar(int n)
-  {
-    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
-    std::vector<double>::iterator vditer = vdptr->begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
-    return vdptr;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(simple_vector)
-{
-  try
-  {
-    python::module_builder this_module("simple_vector");
-
-    python::class_builder<std::vector<double>, vector_double_wrapper>
-      vector_double(this_module, "vector_double");
-
-    vector_double.def(python::constructor<>());
-    vector_double.def(python::constructor<const int>());
-    vector_double.def(python::constructor<python::tuple>());
-    vector_double.def(&std::vector<double>::size, "__len__");
-    vector_double.def(getitem, "__getitem__");
-    vector_double.def(setitem, "__setitem__");
-    vector_double.def(delitem, "__delitem__");
-    vector_double.def(as_tuple, "as_tuple");
-
-    this_module.def(foo, "foo");
-    this_module.def(bar, "bar");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/test_do_it_yourself_converters.py b/example/test_do_it_yourself_converters.py
deleted file mode 100644
index e256c614..00000000
--- a/example/test_do_it_yourself_converters.py
+++ /dev/null
@@ -1,22 +0,0 @@
-r'''>>> import do_it_yourself_converters
-    >>> ixset = do_it_yourself_converters.IndexingSet()
-    >>> ixset.add((1,2,3))
-    >>> ixset.add((4,5,6))
-    >>> ixset.add((7,8,9))
-    >>> print ixset.get(0)
-    (1, 2, 3)
-    >>> print ixset.get(1)
-    (4, 5, 6)
-    >>> print ixset.get(2)
-    (7, 8, 9)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_do_it_yourself_converters
-    doctest.testmod(test_do_it_yourself_converters)
-
-if __name__ == '__main__':
-    run()
diff --git a/example/test_simple_vector.py b/example/test_simple_vector.py
deleted file mode 100644
index a19e205b..00000000
--- a/example/test_simple_vector.py
+++ /dev/null
@@ -1,35 +0,0 @@
-r'''>>> import simple_vector
-    >>> v=simple_vector.vector_double()
-    >>> print v.as_tuple()
-    ()
-    >>> v=simple_vector.vector_double(5)
-    >>> print v.as_tuple()
-    (0.0, 0.0, 0.0, 0.0, 0.0)
-    >>> print len(v)
-    5
-    >>> v=simple_vector.vector_double((3,4,5))
-    >>> print v.as_tuple()
-    (3.0, 4.0, 5.0)
-    >>> print v[1]
-    4.0
-    >>> v[1] = 40
-    >>> print v.as_tuple()
-    (3.0, 40.0, 5.0)
-    >>> del v[1]
-    >>> print v.as_tuple()
-    (3.0, 5.0)
-    >>> print simple_vector.foo(11).as_tuple()
-    (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
-    >>> print simple_vector.bar(12).as_tuple()
-    (0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_simple_vector
-    doctest.testmod(test_simple_vector)
-
-if __name__ == '__main__':
-    run()

From 5a40cec1edd9ee8ca1f8396f1c0ffd230c53822c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sun, 1 Apr 2001 13:47:25 +0000
Subject: [PATCH 078/369] temp file before branching

[SVN r9689]
---
 build/irix_CC.mak | 167 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 build/irix_CC.mak

diff --git a/build/irix_CC.mak b/build/irix_CC.mak
new file mode 100644
index 00000000..91eb819e
--- /dev/null
+++ b/build/irix_CC.mak
@@ -0,0 +1,167 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Set the BOOST pathname below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+
+BOOST= /net/cci/rwgk/boost
+
+#PYEXE= /usr/bin/python
+#PYINC= -I/usr/include/python1.5
+PYEXE= /usr/local/Python-1.5.2/bin/python
+PYINC= -I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE= /usr/local/Python-2.0/bin/python
+#PYINC= -I/usr/local/Python-2.0/include/python2.0
+STLPORTINC= -I/net/cci/xp/C++_C_headers
+
+STDOPTS=
+WARNOPTS= -woff 1001,1234,1682
+
+CPP= CC -LANG:std -n32 -mips4
+CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+         $(STDOPTS) $(WARNOPTS) -g
+MAKEDEP= -M
+
+LD= CC -LANG:std -n32 -mips4
+LDOPTS= -shared -all
+
+OBJ = classes.o conversions.o extension_class.o functions.o \
+      init_function.o module_builder.o \
+      objects.o types.o cross_module.o
+DEPOBJ= $(OBJ) \
+        comprehensive.o \
+        abstract.o \
+        getting_started1.o getting_started2.o getting_started3.o \
+        simple_vector.o \
+        do_it_yourself_converters.o \
+        pickle1.o pickle2.o pickle3.o \
+        noncopyable_export.o noncopyable_import.o \
+        ivect.o dvect.o
+
+.SUFFIXES: .o .cpp
+
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so getting_started3.so \
+     simple_vector.so \
+     do_it_yourself_converters.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so
+
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
+	$(CPP) -ar -all -o libboost_python.a $(OBJ)
+
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+getting_started3.so: $(OBJ) getting_started3.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
+
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
+
+do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+
+tst:
+	$(PYEXE) tst_noncopyable.py
+	$(PYEXE) tst_ivect1.py
+	$(PYEXE) tst_dvect1.py
+	$(PYEXE) tst_ivect2.py
+	$(PYEXE) tst_dvect2.py
+
+clean:
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
+	rm -f comprehensive.o boost_python_test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f getting_started3.o getting_started3.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
+	rm -f so_locations *.pyc
+	rm -rf ii_files
+
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+

From 69e69a77d866b19cfe05298ffc580371d7d58983 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sun, 1 Apr 2001 13:49:05 +0000
Subject: [PATCH 079/369] temp file removed after branching.

[SVN r9691]
---
 build/irix_CC.mak | 167 ----------------------------------------------
 1 file changed, 167 deletions(-)
 delete mode 100644 build/irix_CC.mak

diff --git a/build/irix_CC.mak b/build/irix_CC.mak
deleted file mode 100644
index 91eb819e..00000000
--- a/build/irix_CC.mak
+++ /dev/null
@@ -1,167 +0,0 @@
-# Usage:
-#
-#   Create a new empty directory anywhere (preferably not in the boost tree).
-#   Copy this Makefile to that new directory and rename it to "Makefile"
-#   Set the BOOST pathname below.
-#
-#   make softlinks     Create softlinks to source code and tests
-#   make               Compile all sources
-#   make test          Run doctest tests
-#   make clean         Remove all object files
-#   make unlink        Remove softlinks
-
-BOOST= /net/cci/rwgk/boost
-
-#PYEXE= /usr/bin/python
-#PYINC= -I/usr/include/python1.5
-PYEXE= /usr/local/Python-1.5.2/bin/python
-PYINC= -I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE= /usr/local/Python-2.0/bin/python
-#PYINC= -I/usr/local/Python-2.0/include/python2.0
-STLPORTINC= -I/net/cci/xp/C++_C_headers
-
-STDOPTS=
-WARNOPTS= -woff 1001,1234,1682
-
-CPP= CC -LANG:std -n32 -mips4
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS) -g
-MAKEDEP= -M
-
-LD= CC -LANG:std -n32 -mips4
-LDOPTS= -shared -all
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o cross_module.o
-DEPOBJ= $(OBJ) \
-        comprehensive.o \
-        abstract.o \
-        getting_started1.o getting_started2.o getting_started3.o \
-        simple_vector.o \
-        do_it_yourself_converters.o \
-        pickle1.o pickle2.o pickle3.o \
-        noncopyable_export.o noncopyable_import.o \
-        ivect.o dvect.o
-
-.SUFFIXES: .o .cpp
-
-all: libboost_python.a \
-     boost_python_test.so \
-     abstract.so \
-     getting_started1.so getting_started2.so getting_started3.so \
-     simple_vector.so \
-     do_it_yourself_converters.so \
-     pickle1.so pickle2.so pickle3.so \
-     noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
-
-libboost_python.a: $(OBJ)
-	rm -f libboost_python.a
-	$(CPP) -ar -all -o libboost_python.a $(OBJ)
-
-boost_python_test.so: $(OBJ) comprehensive.o
-	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
-
-abstract.so: $(OBJ) abstract.o
-	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
-
-getting_started1.so: $(OBJ) getting_started1.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
-
-getting_started2.so: $(OBJ) getting_started2.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
-
-getting_started3.so: $(OBJ) getting_started3.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
-
-simple_vector.so: $(OBJ) simple_vector.o
-	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
-
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
-
-pickle1.so: $(OBJ) pickle1.o
-	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
-
-pickle2.so: $(OBJ) pickle2.o
-	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
-
-pickle3.so: $(OBJ) pickle3.o
-	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
-
-noncopyable_export.so: $(OBJ) noncopyable_export.o
-	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
-          noncopyable_export.o -o noncopyable_export.so
-
-noncopyable_import.so: $(OBJ) noncopyable_import.o
-	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
-          noncopyable_import.o -o noncopyable_import.so
-
-ivect.so: $(OBJ) ivect.o
-	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
-
-dvect.so: $(OBJ) dvect.o
-	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
-
-.cpp.o:
-	$(CPP) $(CPPOPTS) -c $*.cpp
-
-test:
-	$(PYEXE) comprehensive.py
-	$(PYEXE) test_abstract.py
-	$(PYEXE) test_getting_started1.py
-	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.py
-	$(PYEXE) test_pickle1.py
-	$(PYEXE) test_pickle2.py
-	$(PYEXE) test_pickle3.py
-
-tst:
-	$(PYEXE) tst_noncopyable.py
-	$(PYEXE) tst_ivect1.py
-	$(PYEXE) tst_dvect1.py
-	$(PYEXE) tst_ivect2.py
-	$(PYEXE) tst_dvect2.py
-
-clean:
-	rm -f $(OBJ) libboost_python.a libboost_python.a.input
-	rm -f comprehensive.o boost_python_test.so
-	rm -f abstract.o abstract.so
-	rm -f getting_started1.o getting_started1.so
-	rm -f getting_started2.o getting_started2.so
-	rm -f getting_started3.o getting_started3.so
-	rm -f simple_vector.o simple_vector.so
-	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
-	rm -f pickle1.o pickle1.so
-	rm -f pickle2.o pickle2.so
-	rm -f pickle3.o pickle3.so
-	rm -f noncopyable_export.o noncopyable_export.so
-	rm -f noncopyable_import.o noncopyable_import.so
-	rm -f ivect.o ivect.so
-	rm -f dvect.o dvect.so
-	rm -f so_locations *.pyc
-	rm -rf ii_files
-
-softlinks:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
-
-unlink:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
-
-cp:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
-
-rm:
-	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
-
-depend:
-	@ cat Makefile.nodepend; \
-          for obj in $(DEPOBJ); \
-          do \
-            bn=`echo "$$obj" | cut -d. -f1`; \
-            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
-          done
-

From 748c118ea82c167f3b352023ac906d25ca5aa464 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 5 Apr 2001 17:46:24 +0000
Subject: [PATCH 080/369] added: from_python std::string type checking

[SVN r9727]
---
 src/conversions.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/conversions.cpp b/src/conversions.cpp
index 1bc923b1..4bfe2011 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -7,6 +7,7 @@
 //  producing this work.
 //
 // Revision History:
+// 05 Apr 01  added: from_python std::string type checking (rwgk)
 // 12 Mar 01  Python 1.5.2 fixes (Ralf W. Grosse-Kunstleve)
 // 11 Mar 01  std::string *MAY* include nulls (Alex Martelli)
 // 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
@@ -250,6 +251,10 @@ PyObject* to_python(const std::string& s)
 
 std::string from_python(PyObject* p, boost::python::type<std::string>)
 {
+    if (! PyString_Check(p)) {
+        PyErr_SetString(PyExc_TypeError, "expected a string");
+        throw boost::python::argument_error();
+    }
     return std::string(PyString_AsString(p), PyString_Size(p));
 }
 

From 9ee563b86415bc9f86cad7404cdf06296e2349fb Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 18:51:17 +0000
Subject: [PATCH 081/369] Comment added with reference to cross_module.hpp

[SVN r9812]
---
 include/boost/python/detail/extension_class.hpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 125f1eed..5c8e720a 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -10,6 +10,7 @@
 //  gen_extclass.python
 
 //  Revision History:
+//  17 Apr 01  Comment added with reference to cross_module.hpp (R.W. Grosse-Kunstleve)
 //  05 Mar 01  Fixed a bug which prevented auto_ptr values from being converted
 //             to_python (Dave Abrahams)
 
@@ -166,6 +167,14 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 // 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>.
+//
+// A look-alike of this class in root/boost/python/cross_module.hpp
+// is used for the implementation of the cross-module support
+// (export_converters and import_converters). If from_python
+// and to_python converters are added or removed from the class
+// below, the class python_import_extension_class_converters has
+// to be modified accordingly.
+//
 template <class T, class U = boost::python::detail::held_instance<T> >
 class python_extension_class_converters
 {

From 533a0057641283e3ff949c8a0383a77a394e0caa Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 18:53:38 +0000
Subject: [PATCH 082/369] moved from branch ralf_grosse_kunstleve to trunk

[SVN r9813]
---
 include/boost/python/cross_module.hpp | 322 ++++++++++++++++++++++++++
 src/cross_module.cpp                  |  87 +++++++
 2 files changed, 409 insertions(+)
 create mode 100644 include/boost/python/cross_module.hpp
 create mode 100644 src/cross_module.cpp

diff --git a/include/boost/python/cross_module.hpp b/include/boost/python/cross_module.hpp
new file mode 100644
index 00000000..7c1fe507
--- /dev/null
+++ b/include/boost/python/cross_module.hpp
@@ -0,0 +1,322 @@
+/* (C) Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy, use,
+   modify, sell and distribute this software is granted provided this
+   copyright notice appears in all copies. This software is provided
+   "as is" without express or implied warranty, and with no claim as to
+   its suitability for any purpose.
+
+   Revision History:
+     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
+*/
+
+/* Implementation of Boost.Python cross-module support.
+   See root/libs/python/doc/cross_module.html for details.
+*/
+
+#ifndef CROSS_MODULE_HPP
+# define CROSS_MODULE_HPP
+
+# include <boost/python/class_builder.hpp>
+
+namespace boost { namespace python {
+    struct import_error : error_already_set {};
+    struct export_error : error_already_set {};
+}}
+
+namespace boost { namespace python { namespace detail {
+
+// Concept: throw exception if api_major is changed
+//          show warning on stderr if api_minor is changed
+const int export_converters_api_major = 4;
+const int export_converters_api_minor = 1;
+extern const char* converters_attribute_name;
+void* import_converter_object(const std::string& module_name,
+                              const std::string& py_class_name,
+                              const std::string& attribute_name);
+void check_export_converters_api(const int importing_major,
+                                 const int importing_minor,
+                                 const int imported_major,
+                                 const int imported_minor);
+
+}}}
+
+// forward declaration
+namespace boost { namespace python { namespace detail {
+template <class T> class import_extension_class;
+}}}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+/* This class template is instantiated by import_converters<T>.
+   This class is a look-alike of class python_extension_class_converters.
+   The converters in this class are wrappers that call converters
+   imported from another module.
+   To ensure that the dynamic loader resolves all symbols in the
+   intended way, the signature of all friend functions is changed with
+   respect to the original functions in class
+   python_extension_class_converters by adding an arbitrary additional
+   parameter with a default value, in this case "bool sig = false".
+   See also: comments for class export_converter_object_base below.
+ */
+template <class T>
+class python_import_extension_class_converters
+{
+ public:
+
+    friend python_import_extension_class_converters py_extension_class_converters(boost::python::type<T>, bool sig = false) {
+        return python_import_extension_class_converters();
+    }
+
+    PyObject* to_python(const T& x) const {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend T* from_python(PyObject* p, boost::python::type<T*> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Ts(p, t);
+    }
+    friend const T* from_python(PyObject* p, boost::python::type<const T*> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTs(p, t);
+    }
+    friend const T* from_python(PyObject* p, boost::python::type<const T*const&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTscr(p, t);
+    }
+    friend T* from_python(PyObject* p, boost::python::type<T* const&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tscr(p, t);
+    }
+    friend T& from_python(PyObject* p, boost::python::type<T&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_Tr(p, t);
+    }
+    friend const T& from_python(PyObject* p, boost::python::type<const T&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_cTr(p, t);
+    }
+    friend const T& from_python(PyObject* p, boost::python::type<T> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_T(p, t);
+    }
+
+    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aTr(p, t);
+    }
+    friend std::auto_ptr<T> from_python(PyObject* p, boost::python::type<std::auto_ptr<T> > t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_aT(p, t);
+    }
+    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_caTr(p, t);
+    }
+    friend PyObject* to_python(std::auto_ptr<T> x, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+
+    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sTr(p, t);
+    }
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> > t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_sT(p, t);
+    }
+    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->from_python_csTr(p, t);
+    }
+    friend PyObject* to_python(boost::shared_ptr<T> x, bool sig = false) {
+        return boost::python::detail::import_extension_class<T>::get_converters()->to_python(x);
+    }
+};
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+namespace boost { namespace python {
+
+BOOST_PYTHON_IMPORT_CONVERSION(python_import_extension_class_converters);
+
+/* This class template is instantiated by export_converters().
+   A pointer to this class is exported/imported via the Python API.
+   Using the Python API ensures maximum portability.
+   All member functions are virtual. This is, what we export/import
+   is essentially just a pointer to a vtbl.
+   To work around a deficiency of Visual C++ 6.0, the name of each
+   from_python() member functions is made unique by appending a few
+   characters (derived in a ad-hoc manner from the corresponding type).
+ */
+template <class T>
+struct export_converter_object_base
+{
+    virtual int get_api_major() const { return detail::export_converters_api_major; }
+    virtual int get_api_minor() const { return detail::export_converters_api_minor; }
+
+    virtual PyObject* to_python(const T& x) = 0;
+
+    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) = 0;
+    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) = 0;
+    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) = 0;
+    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) = 0;
+    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) = 0;
+    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) = 0;
+    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) = 0;
+
+    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) = 0;
+    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) = 0;
+    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) = 0;
+    virtual PyObject* to_python(std::auto_ptr<T> x) = 0;
+
+    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) = 0;
+    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) = 0;
+    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) = 0;
+    virtual PyObject* to_python(boost::shared_ptr<T> x) = 0;
+};
+
+// Converters to be used if T is not copyable.
+template <class T>
+struct export_converter_object_noncopyable : export_converter_object_base<T>
+{
+    virtual PyObject* to_python(const T& x) {
+        PyErr_SetString(PyExc_RuntimeError,
+          "to_python(const T&) converter not exported");
+        throw import_error();
+    }
+
+    virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T* from_python_cTs(PyObject* p, boost::python::type<const T*> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T* from_python_cTscr(PyObject* p, boost::python::type<const T*const&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual T* from_python_Tscr(PyObject* p, boost::python::type<T* const&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual T& from_python_Tr(PyObject* p, boost::python::type<T&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T& from_python_cTr(PyObject* p, boost::python::type<const T&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const T& from_python_T(PyObject* p, boost::python::type<T> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+
+    virtual std::auto_ptr<T>& from_python_aTr(PyObject* p, boost::python::type<std::auto_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual std::auto_ptr<T> from_python_aT(PyObject* p, boost::python::type<std::auto_ptr<T> > t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const std::auto_ptr<T>& from_python_caTr(PyObject* p, boost::python::type<const std::auto_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual PyObject* to_python(std::auto_ptr<T> x) {
+        return BOOST_PYTHON_CONVERSION::to_python(x);
+    }
+
+    virtual boost::shared_ptr<T>& from_python_sTr(PyObject* p, boost::python::type<boost::shared_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const boost::shared_ptr<T>& from_python_sT(PyObject* p, boost::python::type<boost::shared_ptr<T> > t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual const boost::shared_ptr<T>& from_python_csTr(PyObject* p, boost::python::type<const boost::shared_ptr<T>&> t) {
+        return BOOST_PYTHON_CONVERSION::from_python(p, t);
+    }
+    virtual PyObject* to_python(boost::shared_ptr<T> x) {
+        return BOOST_PYTHON_CONVERSION::to_python(x);
+    }
+};
+
+// The addditional to_python() converter that can be used if T is copyable.
+template <class T>
+struct export_converter_object : export_converter_object_noncopyable<T>
+{
+    virtual PyObject* to_python(const T& x) {
+        return BOOST_PYTHON_CONVERSION::py_extension_class_converters(boost::python::type<T>()).to_python(x);
+    }
+};
+
+namespace detail {
+
+/* This class template is instantiated by import_converters<T>.
+   Its purpose is to import the converter_object via the Python API.
+   The actual import is only done once. The pointer to the
+   imported converter object is kept in the static data member
+   imported_converters.
+ */
+template <class T>
+class import_extension_class
+    : public python_import_extension_class_converters<T>
+{
+ public:
+    inline import_extension_class(const char* module, const char* py_class) {
+      m_module = module;
+      m_py_class = py_class;
+    }
+
+    static boost::python::export_converter_object_base<T>* get_converters();
+
+  private:
+    static std::string m_module;
+    static std::string m_py_class;
+    static boost::python::export_converter_object_base<T>* imported_converters;
+};
+
+template <class T> std::string import_extension_class<T>::m_module;
+template <class T> std::string import_extension_class<T>::m_py_class;
+template <class T>
+boost::python::export_converter_object_base<T>*
+import_extension_class<T>::imported_converters = 0;
+
+template <class T>
+boost::python::export_converter_object_base<T>*
+import_extension_class<T>::get_converters() {
+  if (imported_converters == 0) {
+    void* cobject
+      = import_converter_object(m_module, m_py_class,
+                                converters_attribute_name);
+    imported_converters
+      = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
+    check_export_converters_api(
+      export_converters_api_major,
+      export_converters_api_minor,
+      imported_converters->get_api_major(),
+      imported_converters->get_api_minor());
+  }
+  return imported_converters;
+}
+
+}}} // namespace boost::python::detail
+
+namespace boost { namespace python {
+
+// Implementation of export_converters().
+template <class T, class U>
+void export_converters(class_builder<T, U>& cb)
+{
+    static export_converter_object<T> export_cvts;
+    cb.add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      detail::converters_attribute_name);
+}
+
+// Implementation of export_converters_noncopyable().
+template <class T, class U>
+void export_converters_noncopyable(class_builder<T, U>& cb)
+{
+    static export_converter_object_noncopyable<T> export_cvts;
+    cb.add(
+      ref(PyCObject_FromVoidPtr(reinterpret_cast<void*>(&export_cvts), NULL)),
+      detail::converters_attribute_name);
+}
+
+// Implementation of import_converters<T>.
+template <class T>
+class import_converters
+    : python_import_extension_class_converters<T> // Works around MSVC6.x/GCC2.95.2 bug described
+                                                  // at the bottom of class_builder.hpp.
+{
+ public:
+    import_converters(const char* module, const char* py_class)
+        : m_class(new detail::import_extension_class<T>(module, py_class))
+    { }
+ private:
+    boost::shared_ptr<detail::import_extension_class<T> > m_class;
+};
+
+}} // namespace boost::python
+
+#endif // CROSS_MODULE_HPP
diff --git a/src/cross_module.cpp b/src/cross_module.cpp
new file mode 100644
index 00000000..ea5a08de
--- /dev/null
+++ b/src/cross_module.cpp
@@ -0,0 +1,87 @@
+/* (C) Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy, use,
+   modify, sell and distribute this software is granted provided this
+   copyright notice appears in all copies. This software is provided
+   "as is" without express or implied warranty, and with no claim as to
+   its suitability for any purpose.
+
+   Revision History:
+     17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
+*/
+
+# include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+# include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
+# include <string.h> // MSVC6.0SP4 does not know std::strcmp
+
+namespace {
+
+  PyObject* get_module_dict(const char* module_name)
+  {
+      python::ref module_obj(PyImport_ImportModule((char*) module_name));
+      PyObject* module_dict = PyModule_GetDict(module_obj.get());
+      if (module_dict == 0) throw python::import_error();
+      return module_dict;
+  }
+}
+
+namespace boost { namespace python { namespace detail {
+
+const char* converters_attribute_name = "__converters__";
+
+void* import_converter_object(const std::string& module_name,
+                              const std::string& py_class_name,
+                              const std::string& attribute_name)
+{
+    static std::string err;
+    PyObject* module_dict = get_module_dict(const_cast<char*>(module_name.c_str()));
+    PyObject* py_class = PyDict_GetItemString(module_dict, const_cast<char*>(py_class_name.c_str()));
+    if (py_class == 0) {
+        err = std::string("module ") + module_name + " has no attribute " + py_class_name;
+        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+        throw python::import_error();
+    }
+    python::ref c_obj(PyObject_GetAttrString(py_class, const_cast<char*>(attribute_name.c_str())), ref::null_ok);
+    if (c_obj.get() == 0) {
+        err = std::string("object ") + module_name + "." + py_class_name
+              + " has no attribute " + attribute_name;
+        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+        throw python::import_error();
+    }
+    if (! PyCObject_Check(c_obj.get())) {
+        err = std::string("object ") + module_name + "." + py_class_name + "."
+              + attribute_name + " is not a PyCObject";
+        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+        throw python::import_error();
+    }
+    return PyCObject_AsVoidPtr(c_obj.get());
+}
+
+void check_export_converters_api(const int importing_major,
+                                 const int importing_minor,
+                                 const int imported_major,
+                                 const int imported_minor)
+{
+    if (importing_major != imported_major) {
+        // Python uses fprintf(stderr, ...) for API warnings.
+        fprintf(stderr,
+          "Fatal: export_converters_api mismatch:"
+          " Importing module = %d.%d"
+          " Imported module = %d.%d\n",
+          importing_major, importing_minor,
+          imported_major, imported_minor);
+        PyErr_SetString(PyExc_RuntimeError,
+          "Fatal: export_converters_api mismatch");
+        throw import_error();
+    }
+    if (importing_minor != imported_minor) {
+        // Python uses fprintf(stderr, ...) for API warnings.
+        fprintf(stderr,
+          "Warning: export_converters_api mismatch:"
+          " Importing module = %d.%d"
+          " Imported module = %d.%d\n",
+          importing_major, importing_minor,
+          imported_major, imported_minor);
+    }
+}
+
+}}} // namespace boost::python::detail

From 907033f725317d2c8cd7a1e00dc6d6b5ee2a321c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:00:43 +0000
Subject: [PATCH 083/369] Obsolete files removed.

[SVN r9814]
---
 example/getting_started3.cpp     | 120 -----------------------------
 example/getting_started4.cpp     | 101 -------------------------
 example/getting_started5.cpp     | 126 -------------------------------
 example/test_getting_started3.py |  56 --------------
 example/test_getting_started4.py |  35 ---------
 example/test_getting_started5.py |  22 ------
 6 files changed, 460 deletions(-)
 delete mode 100644 example/getting_started3.cpp
 delete mode 100644 example/getting_started4.cpp
 delete mode 100644 example/getting_started5.cpp
 delete mode 100644 example/test_getting_started3.py
 delete mode 100644 example/test_getting_started4.py
 delete mode 100644 example/test_getting_started5.py

diff --git a/example/getting_started3.cpp b/example/getting_started3.cpp
deleted file mode 100644
index 799f5cac..00000000
--- a/example/getting_started3.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-    This example shows how to make an Extension Class "pickleable".
-
-    Python's pickle module implements a basic but powerful algorithm
-    for "pickling" (a.k.a. serializing, marshalling or flattening)
-    nearly arbitrary Python objects.
-
-    The user can influence how an Extension Class instance is pickled
-    by defining three special methods: __getinitargs__(),
-    __getstate__(), and __setstate(). This interface is similar to
-    that for regular Python classes as described in detail in the
-    Python Library Reference for pickle:
-
-    http://www.python.org/doc/current/lib/module-pickle.html
-
-    When an Extension Class instance is pickled, __getinitargs__() is
-    called, if implemented. This method should return a tuple
-    containing the arguments to be passed to the class constructor when
-    the object is restored.
-
-    If there is no __getstate__() method, the instance's __dict__ is
-    pickled if it is not empty. If __getstate__() is defined, it should
-    return an object representing the state of the instance.
-
-    If there is no __setstate__() method, __getstate__() must return a
-    dictionary. When the instance is restored, the items in this dictionary
-    are added to the instance's __dict__.
-
-    If the Extension Class defines __setstate__(), the pickle loader
-    calls it with the result of __getstate__() as arguments. In this
-    case, the state object need not be a dictionary.  The
-    __getstate__() and __setstate__() methods can do what they want.
-
-    If both __getinitargs__() and __getstate__() are defined, the
-    instance is restored by first calling the constructor with
-    the result of __getinitargs__() as argument. After the instance
-    is reconstructed, the __dict__ is updated or __setstate__() is
-    called if implemented.
-
-    The mechanism described here is an exact replication of that one
-    implemented by Jim Fulton's ExtensionClass (included in Zope 2.2.2).
- */
-
-#include <iostream>
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    private:
-      std::string country;
-      int secret_number;
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-      void set_secret_number(int number) { secret_number = number; }
-      int get_secret_number() const { return secret_number; }
-  };
-
-  // Support for pickle.
-  python::tuple world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result;
-  }
-
-  python::tuple world_getstate(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_secret_number());
-      return result;
-  }
-
-  void world_setstate(world& w, python::tuple state) {
-    if (state.size() != 1) {
-      PyErr_SetString(PyExc_ValueError,
-        "Unexpected argument in call to __setstate__.");
-      throw python::error_already_set();
-    }
-    int number = BOOST_PYTHON_CONVERSION::from_python(state[0].get(),
-      python::type<int>());
-    if (number != 42)
-      w.set_secret_number(number);
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(getting_started3)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("getting_started3");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-    world_class.def(&world::get_secret_number, "get_secret_number");
-    world_class.def(&world::set_secret_number, "set_secret_number");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-    world_class.def(world_getstate, "__getstate__");
-    world_class.def(world_setstate, "__setstate__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/getting_started4.cpp b/example/getting_started4.cpp
deleted file mode 100644
index fe6a3421..00000000
--- a/example/getting_started4.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A wrapper is used to define additional constructors.
-  //
-  struct vector_double_wrapper: std::vector<double>
-  {
-    // Tell the compiler how to convert a base class object to
-    // this wrapper object.
-    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
-      : std::vector<double>(vd) {}
-
-    vector_double_wrapper(PyObject* self)
-      : std::vector<double>() {}
-
-    vector_double_wrapper(PyObject* self, int n)
-      : std::vector<double>(n) {}
-
-    vector_double_wrapper(PyObject* self, python::tuple tuple)
-      : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator vd = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          python::type<double>());
-    }
-  };
-
-  double getitem(const std::vector<double>& vd, std::size_t key) {
-    return vd[key];
-  }
-
-  void setitem(std::vector<double>& vd, std::size_t key, double d) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vditer[key] = d;
-  }
-
-  void delitem(std::vector<double>& vd, std::size_t key) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
-  }
-
-  // Convert vector_double to a regular Python tuple.
-  //
-  python::tuple as_tuple(const std::vector<double>& vd)
-  {
-    python::tuple t(vd.size());
-    for (int i = 0; i < vd.size(); i++) t.set_item(i,
-      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
-    return t;
-  }
-
-  // Function returning a vector_double object to Python.
-  //
-  std::vector<double> foo(int n)
-  {
-    std::vector<double> vd(n);
-    std::vector<double>::iterator vditer = vd.begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(i);
-    return vd;
-  }
-
-  // Same as foo(), but avoid copying on return.
-  //
-  std::auto_ptr<std::vector<double> > bar(int n)
-  {
-    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
-    std::vector<double>::iterator vditer = vdptr->begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
-    return vdptr;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(getting_started4)
-{
-  try
-  {
-    python::module_builder this_module("getting_started4");
-
-    python::class_builder<std::vector<double>, vector_double_wrapper>
-      vector_double(this_module, "vector_double");
-
-    vector_double.def(python::constructor<>());
-    vector_double.def(python::constructor<const int>());
-    vector_double.def(python::constructor<python::tuple>());
-    vector_double.def(&std::vector<double>::size, "__len__");
-    vector_double.def(getitem, "__getitem__");
-    vector_double.def(setitem, "__setitem__");
-    vector_double.def(delitem, "__delitem__");
-    vector_double.def(as_tuple, "as_tuple");
-
-    this_module.def(foo, "foo");
-    this_module.def(bar, "bar");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/getting_started5.cpp b/example/getting_started5.cpp
deleted file mode 100644
index 9e9e7c75..00000000
--- a/example/getting_started5.cpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-   This example shows how to convert a class from and to native
-   Python objects, such as tuples.
-
-   We do not want to expose the helper class MillerIndex as an
-   Extension Class. However, in order to simplify the wrapper code,
-   we want to define from_python() and to_python() functions for
-   class MillerIndex.
-
-   Consider the alternatives:
-
-     - Expose MillerIndex as an Extension Class.
-         We need a constructor MillerIndex(python::tuple).
-         Python function calls become more complex:
-           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
-         We need a method such as MillerIndex().as_tuple().
-
-     - Define a wrapper function for each function that we
-       want to expose, e.g.:
-          void add(const IndexingSet& ixset, const python::tuple PyMIx)
-
-   The first alternative introduces a new type that the user has to
-   deal with. Other modules using Miller indices might organize them in
-   different ways, for example to increase runtime efficiency for
-   important procedures. This means, the user has to know how to
-   convert between the different kinds of Miller index representations.
-   This can quickly become a nuisance. Relying on native Python data
-   structures minimizes the number of special types the user has to
-   learn and convert. Of course, this argument is only valid for
-   small and relatively simply classes.
-
-   If there are many member functions with MillerIndex arguments, the
-   second alternative is impractical, and concentrating the conversion
-   mechanism in one central place is essential for code
-   maintainability.  An added benefit is that more convenient (smarter)
-   conversion functions can be provided without cluttering the rest of
-   the wrapper code.
-
- */
-
-#include <string>
-#include <vector>
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // The helper class.
-  //
-  class MillerIndex {
-    public:
-      int v[3];
-  };
-
-  // The main class. Imagine that there are MANY member functions
-  // like add() and get().
-  //
-  class IndexingSet {
-    private:
-      std::vector<MillerIndex> VMIx;
-    public:
-      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
-      MillerIndex get(std::size_t i) const { return VMIx[i]; }
-  };
-}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-  // Convert a Python tuple to a MillerIndex object.
-  //
-  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
-  {
-    python::tuple tup
-      = python::tuple(python::ref(p, python::ref::increment_count));
-    if (tup.size() != 3) {
-      PyErr_SetString(PyExc_ValueError,
-        "expecting exactly 3 values in tuple.");
-      throw python::error_already_set();
-    }
-    MillerIndex result;
-    for (int i = 0; i < 3; i++)
-      result.v[i] = from_python(tup[i].get(), python::type<int>());
-    return result;
-  }
-
-  // Similar conversion for MillerIndex objects passed by value.
-  // Not actually used, but included to show the principle.
-  //
-  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
-  {
-    return from_python(p, python::type<const MillerIndex&>());
-  }
-
-  // Convert a MillerIndex object to a Python tuple.
-  //
-  PyObject* to_python(const MillerIndex& hkl)
-  {
-    python::tuple result(3);
-    for (int i = 0; i < 3; i++)
-      result.set_item(i, python::ref(to_python(hkl.v[i])));
-    return result.reference().release();
-  }
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-BOOST_PYTHON_MODULE_INIT(getting_started5)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("getting_started5");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
-
-    // Add the __init__ function.
-    ixset_class.def(python::constructor<>());
-    // Add the member functions.
-    ixset_class.def(&IndexingSet::add, "add");
-    ixset_class.def(&IndexingSet::get, "get");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/test_getting_started3.py b/example/test_getting_started3.py
deleted file mode 100644
index d62cf5a2..00000000
--- a/example/test_getting_started3.py
+++ /dev/null
@@ -1,56 +0,0 @@
-r'''>>> import getting_started3
-    >>> import re
-    >>> import pickle
-    >>> getting_started3.world.__module__
-    'getting_started3'
-    >>> getting_started3.world.__safe_for_unpickling__
-    1
-    >>> getting_started3.world.__reduce__()
-    'world'
-    >>> assert re.match(
-    ... "\(<extension class getting_started3.world at [0-9a-fA-FxX]+>, \('Hello',\), \(0,\)\)",
-    ... repr(getting_started3.world('Hello').__reduce__()))
-    >>>
-    >>> for number in (24, 42):
-    ...   wd = getting_started3.world('California')
-    ...   wd.set_secret_number(number)
-    ...   pstr = pickle.dumps(wd)
-    ...   print pstr
-    ...   wl = pickle.loads(pstr)
-    ...   print wd.greet(), wd.get_secret_number()
-    ...   print wl.greet(), wl.get_secret_number()
-    cgetting_started3
-    world
-    p0
-    (S'California'
-    p1
-    tp2
-    R(I24
-    tp3
-    bp4
-    .
-    Hello from California! 24
-    Hello from California! 24
-    cgetting_started3
-    world
-    p0
-    (S'California'
-    p1
-    tp2
-    R(I42
-    tp3
-    bp4
-    .
-    Hello from California! 42
-    Hello from California! 0
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_getting_started3
-    doctest.testmod(test_getting_started3)
-
-if __name__ == '__main__':
-    run()
diff --git a/example/test_getting_started4.py b/example/test_getting_started4.py
deleted file mode 100644
index 82b5c794..00000000
--- a/example/test_getting_started4.py
+++ /dev/null
@@ -1,35 +0,0 @@
-r'''>>> import getting_started4
-    >>> v=getting_started4.vector_double()
-    >>> print v.as_tuple()
-    ()
-    >>> v=getting_started4.vector_double(5)
-    >>> print v.as_tuple()
-    (0.0, 0.0, 0.0, 0.0, 0.0)
-    >>> print len(v)
-    5
-    >>> v=getting_started4.vector_double((3,4,5))
-    >>> print v.as_tuple()
-    (3.0, 4.0, 5.0)
-    >>> print v[1]
-    4.0
-    >>> v[1] = 40
-    >>> print v.as_tuple()
-    (3.0, 40.0, 5.0)
-    >>> del v[1]
-    >>> print v.as_tuple()
-    (3.0, 5.0)
-    >>> print getting_started4.foo(11).as_tuple()
-    (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
-    >>> print getting_started4.bar(12).as_tuple()
-    (0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_getting_started4
-    doctest.testmod(test_getting_started4)
-
-if __name__ == '__main__':
-    run()
diff --git a/example/test_getting_started5.py b/example/test_getting_started5.py
deleted file mode 100644
index 8eeba1e2..00000000
--- a/example/test_getting_started5.py
+++ /dev/null
@@ -1,22 +0,0 @@
-r'''>>> import getting_started5
-    >>> ixset = getting_started5.IndexingSet()
-    >>> ixset.add((1,2,3))
-    >>> ixset.add((4,5,6))
-    >>> ixset.add((7,8,9))
-    >>> print ixset.get(0)
-    (1, 2, 3)
-    >>> print ixset.get(1)
-    (4, 5, 6)
-    >>> print ixset.get(2)
-    (7, 8, 9)
-'''
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_getting_started5
-    doctest.testmod(test_getting_started5)
-
-if __name__ == '__main__':
-    run()

From dc520c6c32a4b0485d583d3ecc11e24df77a3eb7 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:04:16 +0000
Subject: [PATCH 084/369] Author included

[SVN r9815]
---
 example/getting_started1.cpp | 2 ++
 example/getting_started2.cpp | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/example/getting_started1.cpp b/example/getting_started1.cpp
index 7a8e9087..c6a77723 100644
--- a/example/getting_started1.cpp
+++ b/example/getting_started1.cpp
@@ -1,3 +1,5 @@
+// Example by Ralf W. Grosse-Kunstleve
+
 #include <string>
 
 namespace { // Avoid cluttering the global namespace.
diff --git a/example/getting_started2.cpp b/example/getting_started2.cpp
index 72b04105..9121b1a0 100644
--- a/example/getting_started2.cpp
+++ b/example/getting_started2.cpp
@@ -1,3 +1,5 @@
+// Example by Ralf W. Grosse-Kunstleve
+
 #include <iostream>
 #include <string>
 

From 8158a509c92eeb0c8917ed7aca6276529ddad1e8 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:20:31 +0000
Subject: [PATCH 085/369] moved from branch ralf_grosse_kunstleve to trunk

[SVN r9816]
---
 example/do_it_yourself_converters.cpp     | 128 ++++++++++++++++++
 example/dvect.cpp                         |  45 +++++++
 example/dvect.h                           |  32 +++++
 example/dvect_conversions.cpp             |  51 ++++++++
 example/dvect_defs.cpp                    |  13 ++
 example/ivect.cpp                         |  45 +++++++
 example/noncopyable.h                     |  14 ++
 example/noncopyable_export.cpp            |  25 ++++
 example/noncopyable_import.cpp            |  42 ++++++
 example/pickle1.cpp                       |  64 +++++++++
 example/pickle2.cpp                       | 100 +++++++++++++++
 example/pickle3.cpp                       | 150 ++++++++++++++++++++++
 example/simple_vector.cpp                 | 103 +++++++++++++++
 example/test_do_it_yourself_converters.py |  22 ++++
 example/test_pickle1.py                   |  31 +++++
 example/test_pickle2.py                   |  45 +++++++
 example/test_pickle3.py                   |  38 ++++++
 example/test_simple_vector.py             |  35 +++++
 18 files changed, 983 insertions(+)
 create mode 100644 example/do_it_yourself_converters.cpp
 create mode 100644 example/dvect.cpp
 create mode 100644 example/dvect.h
 create mode 100644 example/dvect_conversions.cpp
 create mode 100644 example/dvect_defs.cpp
 create mode 100644 example/ivect.cpp
 create mode 100644 example/noncopyable.h
 create mode 100644 example/noncopyable_export.cpp
 create mode 100644 example/noncopyable_import.cpp
 create mode 100644 example/pickle1.cpp
 create mode 100644 example/pickle2.cpp
 create mode 100644 example/pickle3.cpp
 create mode 100644 example/simple_vector.cpp
 create mode 100644 example/test_do_it_yourself_converters.py
 create mode 100644 example/test_pickle1.py
 create mode 100644 example/test_pickle2.py
 create mode 100644 example/test_pickle3.py
 create mode 100644 example/test_simple_vector.py

diff --git a/example/do_it_yourself_converters.cpp b/example/do_it_yourself_converters.cpp
new file mode 100644
index 00000000..6d2d2d6a
--- /dev/null
+++ b/example/do_it_yourself_converters.cpp
@@ -0,0 +1,128 @@
+// Example by Ralf W. Grosse-Kunstleve
+/*
+
+   This example shows how to convert a class from and to native
+   Python objects, such as tuples.
+
+   We do not want to expose the helper class MillerIndex as an
+   Extension Class. However, in order to simplify the wrapper code,
+   we want to define from_python() and to_python() functions for
+   class MillerIndex.
+
+   Consider the alternatives:
+
+     - Expose MillerIndex as an Extension Class.
+         We need a constructor MillerIndex(python::tuple).
+         Python function calls become more complex:
+           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
+         We need a method such as MillerIndex().as_tuple().
+
+     - Define a wrapper function for each function that we
+       want to expose, e.g.:
+          void add(const IndexingSet& ixset, const python::tuple PyMIx)
+
+   The first alternative introduces a new type that the user has to
+   deal with. Other modules using Miller indices might organize them in
+   different ways, for example to increase runtime efficiency for
+   important procedures. This means, the user has to know how to
+   convert between the different kinds of Miller index representations.
+   This can quickly become a nuisance. Relying on native Python data
+   structures minimizes the number of special types the user has to
+   learn and convert. Of course, this argument is only valid for
+   small and relatively simply classes.
+
+   If there are many member functions with MillerIndex arguments, the
+   second alternative is impractical, and concentrating the conversion
+   mechanism in one central place is essential for code
+   maintainability.  An added benefit is that more convenient (smarter)
+   conversion functions can be provided without cluttering the rest of
+   the wrapper code.
+
+ */
+
+#include <string>
+#include <vector>
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // The helper class.
+  //
+  class MillerIndex {
+    public:
+      int v[3];
+  };
+
+  // The main class. Imagine that there are MANY member functions
+  // like add() and get().
+  //
+  class IndexingSet {
+    private:
+      std::vector<MillerIndex> VMIx;
+    public:
+      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
+      MillerIndex get(std::size_t i) const { return VMIx[i]; }
+  };
+}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+  // Convert a Python tuple to a MillerIndex object.
+  //
+  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
+  {
+    python::tuple tup
+      = python::tuple(python::ref(p, python::ref::increment_count));
+    if (tup.size() != 3) {
+      PyErr_SetString(PyExc_ValueError,
+        "expecting exactly 3 values in tuple.");
+      throw python::error_already_set();
+    }
+    MillerIndex result;
+    for (int i = 0; i < 3; i++)
+      result.v[i] = from_python(tup[i].get(), python::type<int>());
+    return result;
+  }
+
+  // Similar conversion for MillerIndex objects passed by value.
+  // Not actually used, but included to show the principle.
+  //
+  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
+  {
+    return from_python(p, python::type<const MillerIndex&>());
+  }
+
+  // Convert a MillerIndex object to a Python tuple.
+  //
+  PyObject* to_python(const MillerIndex& hkl)
+  {
+    python::tuple result(3);
+    for (int i = 0; i < 3; i++)
+      result.set_item(i, python::ref(to_python(hkl.v[i])));
+    return result.reference().release();
+  }
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("do_it_yourself_converters");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
+
+    // Add the __init__ function.
+    ixset_class.def(python::constructor<>());
+    // Add the member functions.
+    ixset_class.def(&IndexingSet::add, "add");
+    ixset_class.def(&IndexingSet::get, "get");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/dvect.cpp b/example/dvect.cpp
new file mode 100644
index 00000000..da6b35a3
--- /dev/null
+++ b/example/dvect.cpp
@@ -0,0 +1,45 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include "dvect.h"
+#include "ivect.h"
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+namespace {
+
+# include "dvect_conversions.cpp"
+# include "ivect_conversions.cpp"
+
+  vects::ivect dvect_as_ivect(const vects::dvect& dv)
+  {
+    vects::ivect iv(dv.size());
+    vects::ivect::iterator iviter = iv.begin();
+    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
+    return iv;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(dvect)
+{
+  try
+  {
+    python::module_builder this_module("dvect");
+
+    python::class_builder<vects::dvect> dvect_class(this_module, "dvect");
+    python::export_converters(dvect_class);
+
+    python::import_converters<vects::ivect> ivect_converters("ivect", "ivect");
+
+    dvect_class.def(python::constructor<python::tuple>());
+    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
+    dvect_class.def(dvect_as_ivect, "as_ivect");
+
+# include "dvect_defs.cpp"
+# include "ivect_defs.cpp"
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/dvect.h b/example/dvect.h
new file mode 100644
index 00000000..8ffe7b50
--- /dev/null
+++ b/example/dvect.h
@@ -0,0 +1,32 @@
+#ifndef DVECT_H
+#define DVECT_H
+
+#include <vector>
+#include <boost/python/class_builder.hpp>
+
+namespace vects {
+
+  struct dvect : public std::vector<double>
+  {
+    dvect() : std::vector<double>() {}
+    dvect(size_t n) : std::vector<double>(n) {}
+    dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator v_it = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<double>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (int i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+  };
+}
+
+#endif // DVECT_H
diff --git a/example/dvect_conversions.cpp b/example/dvect_conversions.cpp
new file mode 100644
index 00000000..21527243
--- /dev/null
+++ b/example/dvect_conversions.cpp
@@ -0,0 +1,51 @@
+  // basics first: const reference converters
+  boost::python::tuple const_dvect_reference_as_tuple(const vects::dvect& dv)
+  {
+    return dv.as_tuple();
+  }
+
+  // to_python smart pointer conversions
+  std::auto_ptr<vects::dvect> dvect_as_auto_ptr(const vects::dvect& dv)
+  {
+    return std::auto_ptr<vects::dvect>(new vects::dvect(dv));
+  }
+  boost::shared_ptr<vects::dvect> dvect_as_shared_ptr(const vects::dvect& dv)
+  {
+    return boost::shared_ptr<vects::dvect>(new vects::dvect(dv));
+  }
+
+  // smart pointers passed by value
+  boost::python::ref auto_ptr_value_dvect_as_tuple(std::auto_ptr<vects::dvect> dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_value_dvect_as_tuple(boost::shared_ptr<vects::dvect> dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+
+  // smart pointers passed by reference
+  boost::python::ref auto_ptr_reference_dvect_as_tuple(std::auto_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_reference_dvect_as_tuple(boost::shared_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+
+  // smart pointers passed by const reference
+  boost::python::ref auto_ptr_const_reference_dvect_as_tuple(const std::auto_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_const_reference_dvect_as_tuple(const boost::shared_ptr<vects::dvect>& dv)
+  {
+    if (dv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return dv->as_tuple().reference();
+  }
diff --git a/example/dvect_defs.cpp b/example/dvect_defs.cpp
new file mode 100644
index 00000000..2739b219
--- /dev/null
+++ b/example/dvect_defs.cpp
@@ -0,0 +1,13 @@
+    this_module.def(dvect_as_auto_ptr, "dvect_as_auto_ptr");
+    this_module.def(dvect_as_shared_ptr, "dvect_as_shared_ptr");
+
+    this_module.def(const_dvect_reference_as_tuple, "const_dvect_reference_as_tuple");
+
+    this_module.def(auto_ptr_value_dvect_as_tuple, "auto_ptr_value_dvect_as_tuple");
+    this_module.def(shared_ptr_value_dvect_as_tuple, "shared_ptr_value_dvect_as_tuple");
+
+    this_module.def(auto_ptr_reference_dvect_as_tuple, "auto_ptr_reference_dvect_as_tuple");
+    this_module.def(shared_ptr_reference_dvect_as_tuple, "shared_ptr_reference_dvect_as_tuple");
+
+    this_module.def(auto_ptr_const_reference_dvect_as_tuple, "auto_ptr_const_reference_dvect_as_tuple");
+    this_module.def(shared_ptr_const_reference_dvect_as_tuple, "shared_ptr_const_reference_dvect_as_tuple");
diff --git a/example/ivect.cpp b/example/ivect.cpp
new file mode 100644
index 00000000..db1c0ec3
--- /dev/null
+++ b/example/ivect.cpp
@@ -0,0 +1,45 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include "dvect.h"
+#include "ivect.h"
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+namespace {
+
+# include "dvect_conversions.cpp"
+# include "ivect_conversions.cpp"
+
+  vects::dvect ivect_as_dvect(const vects::ivect& iv)
+  {
+    vects::dvect dv(iv.size());
+    vects::dvect::iterator dviter = dv.begin();
+    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
+    return dv;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(ivect)
+{
+  try
+  {
+    python::module_builder this_module("ivect");
+
+    python::class_builder<vects::ivect> ivect_class(this_module, "ivect");
+    python::export_converters(ivect_class);
+
+    python::import_converters<vects::dvect> dvect_converters("dvect", "dvect");
+
+    ivect_class.def(python::constructor<python::tuple>());
+    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
+    ivect_class.def(ivect_as_dvect, "as_dvect");
+
+# include "dvect_defs.cpp"
+# include "ivect_defs.cpp"
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/noncopyable.h b/example/noncopyable.h
new file mode 100644
index 00000000..de7b3672
--- /dev/null
+++ b/example/noncopyable.h
@@ -0,0 +1,14 @@
+#ifndef NONCOPYABLE_H
+#define NONCOPYABLE_H
+
+class store
+{
+  private:
+    store(const store&) { } // Disable the copy constructor.
+    int number;
+  public:
+    store(const int i) : number(i) { }
+    int recall() const { return number; }
+};
+
+#endif // NONCOPYABLE_H
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
new file mode 100644
index 00000000..794b1200
--- /dev/null
+++ b/example/noncopyable_export.cpp
@@ -0,0 +1,25 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+BOOST_PYTHON_MODULE_INIT(noncopyable_export)
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_export");
+
+    python::class_builder<store> store_class(this_module, "store");
+    python::export_converters_noncopyable(store_class);
+
+    store_class.def(python::constructor<int>());
+    store_class.def(&store::recall, "recall");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
new file mode 100644
index 00000000..ea2477be
--- /dev/null
+++ b/example/noncopyable_import.cpp
@@ -0,0 +1,42 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A function with store objects as both input and output parameters.
+  // Because the copy constructor is disabled, we cannot pass a store
+  // object by value. Instead, we pass a smart pointer.
+  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
+  {
+    int sum = s1.recall() + s2.recall();
+    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
+    return ss;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(noncopyable_import)
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_import");
+
+    python::import_converters<store>
+      dvect_converters("noncopyable_export", "store");
+
+    // Imagine all the additional classes with member functions
+    // that have store objects as input and output parameters.
+    // Lots and lots of them.
+    // However, to keep this example simple, we only define a
+    // module-level function.
+    this_module.def(add_stores, "add_stores");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle1.cpp b/example/pickle1.cpp
new file mode 100644
index 00000000..cdd78989
--- /dev/null
+++ b/example/pickle1.cpp
@@ -0,0 +1,64 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below can be fully restored by passing the
+    appropriate argument to the constructor. Therefore it is sufficient
+    to define the pickle interface method __getinitargs__.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    private:
+      std::string country;
+      int secret_number;
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference();
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle1)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle1");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle2.cpp b/example/pickle2.cpp
new file mode 100644
index 00000000..d6aa3201
--- /dev/null
+++ b/example/pickle2.cpp
@@ -0,0 +1,100 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below contains member data (secret_number) that
+    cannot be restored by any of the constructors. Therefore it is
+    necessary to provide the __getstate__/__setstate__ pair of pickle
+    interface methods.
+
+    For simplicity, the __dict__ is not included in the result of
+    __getstate__. This is not generally recommended, but a valid
+    approach if it is anticipated that the object's __dict__ will
+    always be empty. Note that safety guard are provided to catch the
+    cases where this assumption is not true.
+
+    pickle3.cpp shows how to include the object's __dict__ in the
+    result of __getstate__.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+
+  using BOOST_PYTHON_CONVERSION::from_python;
+
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  void world_setstate(world& w, python::tuple state) {
+    if (state.size() != 1) {
+      PyErr_SetString(PyExc_ValueError,
+        "Unexpected argument in call to __setstate__.");
+      throw python::error_already_set();
+    }
+    int number = from_python(state[0].get(), python::type<int>());
+    if (number != 42)
+      w.set_secret_number(number);
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle2)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle2");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def(world_getstate, "__getstate__");
+    world_class.def(world_setstate, "__setstate__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
new file mode 100644
index 00000000..bfa7dc54
--- /dev/null
+++ b/example/pickle3.cpp
@@ -0,0 +1,150 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below contains member data (secret_number) that
+    cannot be restored by any of the constructors. Therefore it is
+    necessary to provide the __getstate__/__setstate__ pair of pickle
+    interface methods.
+
+    The object's __dict__ is included in the result of __getstate__.
+    This requires more code (compare with pickle2.cpp), but is
+    unavoidable if the object's __dict__ is not always empty.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace boost { namespace python {
+
+  ref getattr(PyObject* o, const std::string& attr_name) {
+    return ref(PyObject_GetAttrString(o, const_cast<char*>(attr_name.c_str())));
+  }
+  ref getattr(const ref& r, const std::string& attr_name) {
+    return getattr(r.get(), attr_name);
+  }
+
+}}
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(python::tuple const & args,
+                             python::dictionary const & keywords);
+
+  PyObject* world_setstate(python::tuple const & args,
+                           python::dictionary const & keywords);
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle3)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle3");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def_raw(world_getstate, "__getstate__");
+    world_class.def_raw(world_setstate, "__setstate__");
+    world_class.getstate_manages_dict();
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+
+namespace {
+
+  using BOOST_PYTHON_CONVERSION::from_python;
+  using boost::python::type;
+  using boost::python::ref;
+  using boost::python::tuple;
+  using boost::python::list;
+  using boost::python::dictionary;
+  using boost::python::getattr;
+
+  ref world_getstate(tuple const & args, dictionary const & keywords)
+  {
+      if(args.size() != 1 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::argument_error();
+      }
+      const world& w = from_python(args[0].get(), type<const world&>());
+      ref mydict = getattr(args[0], "__dict__");
+      tuple result(2);
+      // store the object's __dict__
+      result.set_item(0, mydict);
+      // store the internal state of the C++ object
+      result.set_item(1, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  PyObject* world_setstate(tuple const & args, dictionary const & keywords)
+  {
+      if(args.size() != 2 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::argument_error();
+      }
+      world& w = from_python(args[0].get(), type<world&>());
+      ref mydict = getattr(args[0], "__dict__");
+      tuple state = from_python(args[1].get(), type<tuple>());
+      if (state.size() != 2) {
+        PyErr_SetString(PyExc_ValueError,
+          "Unexpected argument in call to __setstate__.");
+        throw python::error_already_set();
+      }
+      // restore the object's __dict__
+      dictionary odict = from_python(mydict.get(), type<dictionary>());
+      const dictionary& pdict = from_python(state[0].get(), type<const dictionary&>());
+      list pkeys(pdict.keys());
+      for (int i = 0; i < pkeys.size(); i++) {
+        ref k(pkeys[i]);
+        //odict[k] = pdict[k]; // XXX memory leak!
+        odict[k] = pdict.get_item(k); // this does not leak.
+      }
+      // restore the internal state of the C++ object
+      int number = from_python(state[1].get(), type<int>());
+      if (number != 42)
+        w.set_secret_number(number);
+      return python::detail::none();
+  }
+}
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
new file mode 100644
index 00000000..5ac0767b
--- /dev/null
+++ b/example/simple_vector.cpp
@@ -0,0 +1,103 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A wrapper is used to define additional constructors.
+  //
+  struct vector_double_wrapper: std::vector<double>
+  {
+    // Tell the compiler how to convert a base class object to
+    // this wrapper object.
+    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
+      : std::vector<double>(vd) {}
+
+    vector_double_wrapper(PyObject* self)
+      : std::vector<double>() {}
+
+    vector_double_wrapper(PyObject* self, int n)
+      : std::vector<double>(n) {}
+
+    vector_double_wrapper(PyObject* self, python::tuple tuple)
+      : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator vd = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          python::type<double>());
+    }
+  };
+
+  double getitem(const std::vector<double>& vd, std::size_t key) {
+    return vd[key];
+  }
+
+  void setitem(std::vector<double>& vd, std::size_t key, double d) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vditer[key] = d;
+  }
+
+  void delitem(std::vector<double>& vd, std::size_t key) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vd.erase(&vditer[key]);
+  }
+
+  // Convert vector_double to a regular Python tuple.
+  //
+  python::tuple as_tuple(const std::vector<double>& vd)
+  {
+    python::tuple t(vd.size());
+    for (int i = 0; i < vd.size(); i++) t.set_item(i,
+      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
+    return t;
+  }
+
+  // Function returning a vector_double object to Python.
+  //
+  std::vector<double> foo(int n)
+  {
+    std::vector<double> vd(n);
+    std::vector<double>::iterator vditer = vd.begin();
+    for (int i = 0; i < n; i++) vditer[i] = double(i);
+    return vd;
+  }
+
+  // Same as foo(), but avoid copying on return.
+  //
+  std::auto_ptr<std::vector<double> > bar(int n)
+  {
+    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
+    std::vector<double>::iterator vditer = vdptr->begin();
+    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
+    return vdptr;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(simple_vector)
+{
+  try
+  {
+    python::module_builder this_module("simple_vector");
+
+    python::class_builder<std::vector<double>, vector_double_wrapper>
+      vector_double(this_module, "vector_double");
+
+    vector_double.def(python::constructor<>());
+    vector_double.def(python::constructor<const int>());
+    vector_double.def(python::constructor<python::tuple>());
+    vector_double.def(&std::vector<double>::size, "__len__");
+    vector_double.def(getitem, "__getitem__");
+    vector_double.def(setitem, "__setitem__");
+    vector_double.def(delitem, "__delitem__");
+    vector_double.def(as_tuple, "as_tuple");
+
+    this_module.def(foo, "foo");
+    this_module.def(bar, "bar");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/test_do_it_yourself_converters.py b/example/test_do_it_yourself_converters.py
new file mode 100644
index 00000000..e256c614
--- /dev/null
+++ b/example/test_do_it_yourself_converters.py
@@ -0,0 +1,22 @@
+r'''>>> import do_it_yourself_converters
+    >>> ixset = do_it_yourself_converters.IndexingSet()
+    >>> ixset.add((1,2,3))
+    >>> ixset.add((4,5,6))
+    >>> ixset.add((7,8,9))
+    >>> print ixset.get(0)
+    (1, 2, 3)
+    >>> print ixset.get(1)
+    (4, 5, 6)
+    >>> print ixset.get(2)
+    (7, 8, 9)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_do_it_yourself_converters
+    doctest.testmod(test_do_it_yourself_converters)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_pickle1.py b/example/test_pickle1.py
new file mode 100644
index 00000000..05696d4a
--- /dev/null
+++ b/example/test_pickle1.py
@@ -0,0 +1,31 @@
+r'''>>> import pickle1
+    >>> import re
+    >>> import pickle
+    >>> pickle1.world.__module__
+    'pickle1'
+    >>> pickle1.world.__safe_for_unpickling__
+    1
+    >>> pickle1.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle1.world at [0-9a-fA-FxX]+>, \('Hello',\)\)",
+    ... repr(pickle1.world('Hello').__reduce__()))
+    >>>
+    >>> wd = pickle1.world('California')
+    >>> pstr = pickle.dumps(wd)
+    >>> wl = pickle.loads(pstr)
+    >>> print wd.greet()
+    Hello from California!
+    >>> print wl.greet()
+    Hello from California!
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle1
+    doctest.testmod(test_pickle1)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_pickle2.py b/example/test_pickle2.py
new file mode 100644
index 00000000..463befa6
--- /dev/null
+++ b/example/test_pickle2.py
@@ -0,0 +1,45 @@
+r'''>>> import pickle2
+    >>> import re
+    >>> import pickle
+    >>> pickle2.world.__module__
+    'pickle2'
+    >>> pickle2.world.__safe_for_unpickling__
+    1
+    >>> pickle2.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle2.world at [0-9a-fA-FxX]+>, \('Hello',\), \(0,\)\)",
+    ... repr(pickle2.world('Hello').__reduce__()))
+    >>>
+    >>> for number in (24, 42):
+    ...   wd = pickle2.world('California')
+    ...   wd.set_secret_number(number)
+    ...   pstr = pickle.dumps(wd)
+    ...   wl = pickle.loads(pstr)
+    ...   print wd.greet(), wd.get_secret_number()
+    ...   print wl.greet(), wl.get_secret_number()
+    Hello from California! 24
+    Hello from California! 24
+    Hello from California! 42
+    Hello from California! 0
+
+# Now show that the __dict__ is not taken care of.
+    >>> wd = pickle2.world('California')
+    >>> wd.x = 1
+    >>> wd.__dict__
+    {'x': 1}
+    >>> try: pstr = pickle.dumps(wd)
+    ... except RuntimeError, err: print err[0]
+    ...
+    Incomplete pickle support (__getstate_manages_dict__ not set)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle2
+    doctest.testmod(test_pickle2)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_pickle3.py b/example/test_pickle3.py
new file mode 100644
index 00000000..b964f1a2
--- /dev/null
+++ b/example/test_pickle3.py
@@ -0,0 +1,38 @@
+r'''>>> import pickle3
+    >>> import re
+    >>> import pickle
+    >>> pickle3.world.__module__
+    'pickle3'
+    >>> pickle3.world.__safe_for_unpickling__
+    1
+    >>> pickle3.world.__reduce__()
+    'world'
+    >>> assert re.match(
+    ... "\(<extension class pickle3.world at [0-9a-fA-FxX]+>, \('Hello',\), \(\{\}, 0\)\)",
+    ... repr(pickle3.world('Hello').__reduce__()))
+    >>>
+    >>> for number in (24, 42):
+    ...   wd = pickle3.world('California')
+    ...   wd.set_secret_number(number)
+    ...   wd.x = 2 * number
+    ...   wd.y = 'y' * number
+    ...   wd.z = 3. * number
+    ...   pstr = pickle.dumps(wd)
+    ...   wl = pickle.loads(pstr)
+    ...   print wd.greet(), wd.get_secret_number(), wd.__dict__
+    ...   print wl.greet(), wl.get_secret_number(), wl.__dict__
+    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
+    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
+    Hello from California! 42 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
+    Hello from California! 0 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_pickle3
+    doctest.testmod(test_pickle3)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/test_simple_vector.py b/example/test_simple_vector.py
new file mode 100644
index 00000000..a19e205b
--- /dev/null
+++ b/example/test_simple_vector.py
@@ -0,0 +1,35 @@
+r'''>>> import simple_vector
+    >>> v=simple_vector.vector_double()
+    >>> print v.as_tuple()
+    ()
+    >>> v=simple_vector.vector_double(5)
+    >>> print v.as_tuple()
+    (0.0, 0.0, 0.0, 0.0, 0.0)
+    >>> print len(v)
+    5
+    >>> v=simple_vector.vector_double((3,4,5))
+    >>> print v.as_tuple()
+    (3.0, 4.0, 5.0)
+    >>> print v[1]
+    4.0
+    >>> v[1] = 40
+    >>> print v.as_tuple()
+    (3.0, 40.0, 5.0)
+    >>> del v[1]
+    >>> print v.as_tuple()
+    (3.0, 5.0)
+    >>> print simple_vector.foo(11).as_tuple()
+    (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
+    >>> print simple_vector.bar(12).as_tuple()
+    (0.0, 10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 100.0, 110.0)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_simple_vector
+    doctest.testmod(test_simple_vector)
+
+if __name__ == '__main__':
+    run()

From ef7c4379572ef0f9758a4c1c5add34616a8c0757 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:31:00 +0000
Subject: [PATCH 086/369] moved from branch ralf_grosse_kunstleve to trunk

[SVN r9817]
---
 example/ivect.h               |  32 ++++++++
 example/ivect_conversions.cpp |  51 +++++++++++++
 example/ivect_defs.cpp        |  13 ++++
 example/test_cross_module.py  | 139 ++++++++++++++++++++++++++++++++++
 example/tst_dvect1.py         |  20 +++++
 example/tst_dvect2.py         |  98 ++++++++++++++++++++++++
 example/tst_ivect1.py         |  20 +++++
 example/tst_ivect2.py         |  98 ++++++++++++++++++++++++
 example/tst_noncopyable.py    |  16 ++++
 9 files changed, 487 insertions(+)
 create mode 100644 example/ivect.h
 create mode 100644 example/ivect_conversions.cpp
 create mode 100644 example/ivect_defs.cpp
 create mode 100644 example/test_cross_module.py
 create mode 100644 example/tst_dvect1.py
 create mode 100644 example/tst_dvect2.py
 create mode 100644 example/tst_ivect1.py
 create mode 100644 example/tst_ivect2.py
 create mode 100644 example/tst_noncopyable.py

diff --git a/example/ivect.h b/example/ivect.h
new file mode 100644
index 00000000..a0187307
--- /dev/null
+++ b/example/ivect.h
@@ -0,0 +1,32 @@
+#ifndef IVECT_H
+#define IVECT_H
+
+#include <vector>
+#include <boost/python/class_builder.hpp>
+
+namespace vects {
+
+  struct ivect : public std::vector<int>
+  {
+    ivect() : std::vector<int>() {}
+    ivect(size_t n) : std::vector<int>(n) {}
+    ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
+    {
+      std::vector<int>::iterator v_it = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<int>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (int i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+  };
+}
+
+#endif // IVECT_H
diff --git a/example/ivect_conversions.cpp b/example/ivect_conversions.cpp
new file mode 100644
index 00000000..4f59573d
--- /dev/null
+++ b/example/ivect_conversions.cpp
@@ -0,0 +1,51 @@
+  // basics first: const reference converters
+  boost::python::tuple const_ivect_reference_as_tuple(const vects::ivect& iv)
+  {
+    return iv.as_tuple();
+  }
+
+  // to_python smart pointer conversions
+  std::auto_ptr<vects::ivect> ivect_as_auto_ptr(const vects::ivect& iv)
+  {
+    return std::auto_ptr<vects::ivect>(new vects::ivect(iv));
+  }
+  boost::shared_ptr<vects::ivect> ivect_as_shared_ptr(const vects::ivect& iv)
+  {
+    return boost::shared_ptr<vects::ivect>(new vects::ivect(iv));
+  }
+
+  // smart pointers passed by value
+  boost::python::ref auto_ptr_value_ivect_as_tuple(std::auto_ptr<vects::ivect> iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_value_ivect_as_tuple(boost::shared_ptr<vects::ivect> iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+
+  // smart pointers passed by reference
+  boost::python::ref auto_ptr_reference_ivect_as_tuple(std::auto_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_reference_ivect_as_tuple(boost::shared_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+
+  // smart pointers passed by const reference
+  boost::python::ref auto_ptr_const_reference_ivect_as_tuple(const std::auto_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
+  boost::python::ref shared_ptr_const_reference_ivect_as_tuple(const boost::shared_ptr<vects::ivect>& iv)
+  {
+    if (iv.get() == 0) return boost::python::ref(Py_None, boost::python::ref::increment_count);
+    return iv->as_tuple().reference();
+  }
diff --git a/example/ivect_defs.cpp b/example/ivect_defs.cpp
new file mode 100644
index 00000000..811c243d
--- /dev/null
+++ b/example/ivect_defs.cpp
@@ -0,0 +1,13 @@
+    this_module.def(ivect_as_auto_ptr, "ivect_as_auto_ptr");
+    this_module.def(ivect_as_shared_ptr, "ivect_as_shared_ptr");
+
+    this_module.def(const_ivect_reference_as_tuple, "const_ivect_reference_as_tuple");
+
+    this_module.def(auto_ptr_value_ivect_as_tuple, "auto_ptr_value_ivect_as_tuple");
+    this_module.def(shared_ptr_value_ivect_as_tuple, "shared_ptr_value_ivect_as_tuple");
+
+    this_module.def(auto_ptr_reference_ivect_as_tuple, "auto_ptr_reference_ivect_as_tuple");
+    this_module.def(shared_ptr_reference_ivect_as_tuple, "shared_ptr_reference_ivect_as_tuple");
+
+    this_module.def(auto_ptr_const_reference_ivect_as_tuple, "auto_ptr_const_reference_ivect_as_tuple");
+    this_module.def(shared_ptr_const_reference_ivect_as_tuple, "shared_ptr_const_reference_ivect_as_tuple");
diff --git a/example/test_cross_module.py b/example/test_cross_module.py
new file mode 100644
index 00000000..81057f23
--- /dev/null
+++ b/example/test_cross_module.py
@@ -0,0 +1,139 @@
+r'''>>> import tst_noncopyable
+    >>> tst_noncopyable.f()
+    1
+    2
+    3
+    >>> import tst_dvect1
+    >>> tst_dvect1.f()
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    (1, 2, 3, 4, 5)
+    >>> import tst_ivect1
+    >>> tst_ivect1.f()
+    (1, 2, 3, 4, 5)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    >>> import sys
+    >>> if ("--broken-auto-ptr" in sys.argv):
+    ...   broken_auto_ptr = 1
+    ... else:
+    ...   broken_auto_ptr = 0
+    >>> import tst_dvect2
+    >>> tst_dvect2.f(broken_auto_ptr)
+    1. auto_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_value_ivect_as_tuple
+    None
+    1. auto_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_value_dvect_as_tuple
+    None
+    1. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    >>> import tst_ivect2
+    >>> tst_ivect2.f(broken_auto_ptr)
+    1. auto_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_value_dvect_as_tuple
+    None
+    1. auto_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_value_ivect_as_tuple
+    None
+    1. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_value_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_value_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. auto_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. auto_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    1. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    2. shared_ptr_const_reference_dvect_as_tuple
+    (1.0, 2.0, 3.0, 4.0, 5.0)
+    1. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+    2. shared_ptr_const_reference_ivect_as_tuple
+    (1, 2, 3, 4, 5)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_cross_module
+    doctest.testmod(test_cross_module)
+
+if __name__ == '__main__':
+    run()
diff --git a/example/tst_dvect1.py b/example/tst_dvect1.py
new file mode 100644
index 00000000..22315528
--- /dev/null
+++ b/example/tst_dvect1.py
@@ -0,0 +1,20 @@
+def f():
+  import dvect
+  dv = dvect.dvect((1,2,3,4,5))
+  print dv.as_tuple()
+  iv = dv.as_ivect()
+  print iv.as_tuple()
+  print dvect.const_ivect_reference_as_tuple(iv)
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(aiv)
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(siv)
+  print aiv.as_tuple()
+  print siv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_dvect2.py b/example/tst_dvect2.py
new file mode 100644
index 00000000..539e0b88
--- /dev/null
+++ b/example/tst_dvect2.py
@@ -0,0 +1,98 @@
+def f(broken_auto_ptr):
+  import dvect
+  import ivect
+  #
+  dv = dvect.dvect((1,2,3,4,5))
+  iv = dv.as_ivect()
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_value_ivect_as_tuple'
+  print ivect.auto_ptr_value_ivect_as_tuple(aiv)
+  print '2. auto_ptr_value_ivect_as_tuple'
+  if (not broken_auto_ptr):
+    print ivect.auto_ptr_value_ivect_as_tuple(aiv)
+  else:
+    print None
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_value_dvect_as_tuple'
+  print ivect.auto_ptr_value_dvect_as_tuple(adv)
+  print '2. auto_ptr_value_dvect_as_tuple'
+  if (not broken_auto_ptr):
+    print ivect.auto_ptr_value_dvect_as_tuple(adv)
+  else:
+    print None
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_value_ivect_as_tuple'
+  print ivect.shared_ptr_value_ivect_as_tuple(siv)
+  print '2. shared_ptr_value_ivect_as_tuple'
+  print ivect.shared_ptr_value_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_value_dvect_as_tuple'
+  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
+  print '2. shared_ptr_value_dvect_as_tuple'
+  print ivect.shared_ptr_value_dvect_as_tuple(sdv)
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_reference_ivect_as_tuple'
+  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_reference_ivect_as_tuple'
+  print ivect.auto_ptr_reference_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_reference_dvect_as_tuple'
+  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_reference_dvect_as_tuple'
+  print ivect.auto_ptr_reference_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_reference_ivect_as_tuple'
+  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_reference_ivect_as_tuple'
+  print ivect.shared_ptr_reference_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_reference_dvect_as_tuple'
+  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_reference_dvect_as_tuple'
+  print ivect.shared_ptr_reference_dvect_as_tuple(sdv)
+  #
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_const_reference_ivect_as_tuple'
+  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_const_reference_ivect_as_tuple'
+  print ivect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  #
+  adv = dvect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_const_reference_dvect_as_tuple'
+  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_const_reference_dvect_as_tuple'
+  print ivect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  #
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_const_reference_ivect_as_tuple'
+  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_const_reference_ivect_as_tuple'
+  print ivect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  #
+  sdv = dvect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_const_reference_dvect_as_tuple'
+  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_const_reference_dvect_as_tuple'
+  print ivect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+
+if (__name__ == "__main__"):
+  import sys, string
+  broken_auto_ptr = 0
+  n = 1
+  if (len(sys.argv) > 1):
+    if (sys.argv[1] == "--broken-auto-ptr"):
+      broken_auto_ptr = 1
+      if (len(sys.argv) > 2):
+        n = string.atoi(sys.argv[2])
+    else:
+      n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f(broken_auto_ptr)
diff --git a/example/tst_ivect1.py b/example/tst_ivect1.py
new file mode 100644
index 00000000..7369fdbf
--- /dev/null
+++ b/example/tst_ivect1.py
@@ -0,0 +1,20 @@
+def f():
+  import ivect
+  iv = ivect.ivect((1,2,3,4,5))
+  print iv.as_tuple()
+  dv = iv.as_dvect()
+  print dv.as_tuple()
+  print ivect.const_dvect_reference_as_tuple(dv)
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(adv)
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(sdv)
+  print adv.as_tuple()
+  print sdv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_ivect2.py b/example/tst_ivect2.py
new file mode 100644
index 00000000..6ffd2826
--- /dev/null
+++ b/example/tst_ivect2.py
@@ -0,0 +1,98 @@
+def f(broken_auto_ptr):
+  import ivect
+  import dvect
+  #
+  iv = ivect.ivect((1,2,3,4,5))
+  dv = iv.as_dvect()
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_value_dvect_as_tuple'
+  print dvect.auto_ptr_value_dvect_as_tuple(adv)
+  print '2. auto_ptr_value_dvect_as_tuple'
+  if (not broken_auto_ptr):
+    print dvect.auto_ptr_value_dvect_as_tuple(adv)
+  else:
+    print None
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_value_ivect_as_tuple'
+  print dvect.auto_ptr_value_ivect_as_tuple(aiv)
+  print '2. auto_ptr_value_ivect_as_tuple'
+  if (not broken_auto_ptr):
+    print dvect.auto_ptr_value_ivect_as_tuple(aiv)
+  else:
+    print None
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_value_dvect_as_tuple'
+  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
+  print '2. shared_ptr_value_dvect_as_tuple'
+  print dvect.shared_ptr_value_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_value_ivect_as_tuple'
+  print dvect.shared_ptr_value_ivect_as_tuple(siv)
+  print '2. shared_ptr_value_ivect_as_tuple'
+  print dvect.shared_ptr_value_ivect_as_tuple(siv)
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_reference_dvect_as_tuple'
+  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_reference_dvect_as_tuple'
+  print dvect.auto_ptr_reference_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_reference_ivect_as_tuple'
+  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_reference_ivect_as_tuple'
+  print dvect.auto_ptr_reference_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_reference_dvect_as_tuple'
+  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_reference_dvect_as_tuple'
+  print dvect.shared_ptr_reference_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_reference_ivect_as_tuple'
+  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_reference_ivect_as_tuple'
+  print dvect.shared_ptr_reference_ivect_as_tuple(siv)
+  #
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print '1. auto_ptr_const_reference_dvect_as_tuple'
+  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  print '2. auto_ptr_const_reference_dvect_as_tuple'
+  print dvect.auto_ptr_const_reference_dvect_as_tuple(adv)
+  #
+  aiv = ivect.ivect_as_auto_ptr(iv)
+  print '1. auto_ptr_const_reference_ivect_as_tuple'
+  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  print '2. auto_ptr_const_reference_ivect_as_tuple'
+  print dvect.auto_ptr_const_reference_ivect_as_tuple(aiv)
+  #
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print '1. shared_ptr_const_reference_dvect_as_tuple'
+  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  print '2. shared_ptr_const_reference_dvect_as_tuple'
+  print dvect.shared_ptr_const_reference_dvect_as_tuple(sdv)
+  #
+  siv = ivect.ivect_as_shared_ptr(iv)
+  print '1. shared_ptr_const_reference_ivect_as_tuple'
+  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
+  print '2. shared_ptr_const_reference_ivect_as_tuple'
+  print dvect.shared_ptr_const_reference_ivect_as_tuple(siv)
+
+if (__name__ == "__main__"):
+  import sys, string
+  broken_auto_ptr = 0
+  n = 1
+  if (len(sys.argv) > 1):
+    if (sys.argv[1] == "--broken-auto-ptr"):
+      broken_auto_ptr = 1
+      if (len(sys.argv) > 2):
+        n = string.atoi(sys.argv[2])
+    else:
+      n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f(broken_auto_ptr)
diff --git a/example/tst_noncopyable.py b/example/tst_noncopyable.py
new file mode 100644
index 00000000..155910a5
--- /dev/null
+++ b/example/tst_noncopyable.py
@@ -0,0 +1,16 @@
+def f():
+  import noncopyable_export
+  import noncopyable_import
+  s1 = noncopyable_export.store(1)
+  print s1.recall()
+  s2 = noncopyable_export.store(2)
+  print s2.recall()
+  s3 = noncopyable_import.add_stores(s1, s2)
+  print s3.recall()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()

From b5a86a904507dff5777e8aa49b471808a11a5988 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:38:20 +0000
Subject: [PATCH 087/369] cross_module mods

[SVN r9819]
---
 build/como.mak | 11 +++++++----
 build/gcc.mak  | 36 +++++++++++++++++++++++++-----------
 2 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/build/como.mak b/build/como.mak
index 581eefea..8f05e309 100644
--- a/build/como.mak
+++ b/build/como.mak
@@ -1,10 +1,12 @@
 # Revision History:
+# 17 Apr 01  include cross-module support, compile getting_started1 (R.W. Grosse-Kunstleve) UNTESTED!
 # 06 Mar 01  Fixed typo in use of "PYTHON_LIB" (Dave Abrahams)
 # 04 Mar 01  Changed library name to libboost_python.a (David Abrahams)
 
 LIBSRC = \
     classes.cpp \
     conversions.cpp \
+    cross_module.cpp \
     extension_class.cpp \
     functions.cpp \
     init_function.cpp \
@@ -34,11 +36,12 @@ endif
             | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
                 [ -s $@ ] || rm -f $@
 
-example1: example1.o libboost_python.a
-	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYTHON_LIB) example1.o -L. -lboost_python
-	python ../example/test_example1.py
+getting_started1: getting_started1.o libboost_python.a
+	como-dyn-link -o ../example/getting_started1.$(MODULE_EXTENSION) $(PYTHON_LIB) getting_started1.o -L. -lboost_python
+	ln -s ../test/doctest.py ../example
+	python ../example/test_getting_started1.py
 
-example1.o: ../example/example1.cpp
+getting_started1.o: ../example/getting_started1.cpp
 	como --pic $(INC) -o $*.o -c $<
 
 clean:
diff --git a/build/gcc.mak b/build/gcc.mak
index f71185e0..ce718f2b 100644
--- a/build/gcc.mak
+++ b/build/gcc.mak
@@ -1,5 +1,7 @@
 #  Revision History
 
+#  17 Apr 01 include cross-module support, compile getting_started1 (R.W. Grosse-Kunstleve)
+#  17 Apr 01 build shared library (patch provided by Dan Nuffer)
 #  04 Mar 01 Changed library name to libboost_python.a, various cleanups,
 #            attempted Cygwin compatibility. Still needs testing on Linux
 #            (David Abrahams)
@@ -8,6 +10,7 @@
 LIBSRC = \
     classes.cpp \
     conversions.cpp \
+    cross_module.cpp \
     extension_class.cpp \
     functions.cpp \
     init_function.cpp \
@@ -18,7 +21,7 @@ LIBSRC = \
 LIBOBJ = $(LIBSRC:.cpp=.o)
 OBJ = $(LIBOBJ)
 
-PYTHON_INC=$(ROOT)/usr/local/include/python2.0
+LIBNAME = libboost_python
 # libpython2.0.dll
 
 ifeq "$(OS)" "Windows_NT"
@@ -26,13 +29,18 @@ ROOT=c:/cygnus
 INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -I$(PYTHON_INC)
 MODULE_EXTENSION=dll
 PYTHON_LIB=c:/cygnus/usr/local/lib/python2.0/config/libpython2.0.dll.a
+SHARED_LIB = $(LIBNAME).dll
 else
-INC = -I$(PYTHON_INC)
+PYTHON_INC=$(ROOT)/usr/local/Python-2.0/include/python2.0
+BOOST_INC=../../..
+INC = -I$(BOOST_INC) -I$(PYTHON_INC)
 MODULE_EXTENSION=so
+VERSION=1
+SHARED_LIB = $(LIBNAME).so.$(VERSION)
 endif
 
 %.o: ../src/%.cpp
-	g++ -fPIC -Wall -W $(INC) -o $*.o -c $<
+	g++ -fPIC -Wall -W $(INC) $(CXXFLAGS) -o $*.o -c $<
 
 %.d: ../src/%.cpp
 	@echo creating $@
@@ -43,7 +51,9 @@ endif
 
 PYTHON = python
 
-test: comprehensive.o libboost_python.a
+all: test $(SHARED_LIB) getting_started1
+
+test: comprehensive.o $(LIBNAME).a $(SHARED_LIB)
 	g++ $(CXXFLAGS) -shared -o ../test/boost_python_test.$(MODULE_EXTENSION) comprehensive.o -L. -lboost_python  $(PYTHON_LIB)
 	$(PYTHON) ../test/comprehensive.py
 
@@ -51,20 +61,24 @@ comprehensive.o: ../test/comprehensive.cpp
 	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
 
 
-example1: example1.o libboost_python.a
-	g++ $(CXXFLAGS) -shared -o ../example/hellomodule.$(MODULE_EXTENSION) example1.o -L. -lboost_python  $(PYTHON_LIB)
-	$(PYTHON) ../example/test_example1.py
+getting_started1: getting_started1.o $(LIBNAME).a
+	g++ $(CXXFLAGS) -shared -o ../example/getting_started1.$(MODULE_EXTENSION) getting_started1.o -L. -lboost_python  $(PYTHON_LIB)
+	ln -s ../test/doctest.py ../example
+	$(PYTHON) ../example/test_getting_started1.py
 
-example1.o: ../example/example1.cpp
+getting_started1.o: ../example/getting_started1.cpp
 	g++ $(CXXFLAGS) --template-depth-32 -fPIC -Wall -W $(INC) -o $*.o -c $<
 
 
 clean:
 	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
 
-libboost_python.a: $(LIBOBJ)
-	rm -f libboost_python.a
-	ar cq libboost_python.a $(LIBOBJ)
+$(LIBNAME).a: $(LIBOBJ)
+	rm -f $@
+	ar cqs $@ $(LIBOBJ)
+
+$(SHARED_LIB): $(LIBOBJ)
+	g++ $(CXXFLAGS) -shared -o $@ -Wl,--soname=$(LIBNAME).$(MODULE_EXTENSION)
 
 DEP = $(OBJ:.o=.d)
 

From 0c954dde270cb59e7a6093aee5ce36eb8fd7de55 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:42:35 +0000
Subject: [PATCH 088/369] moved from branch ralf_grosse_kunstleve to trunk

[SVN r9820]
---
 build/filemgr.py    | 135 ++++++++++++++++++++++++
 build/irix_CC.mak   | 165 ++++++++++++++++++++++++++++++
 build/linux_gcc.mak | 191 +++++++++++++++++-----------------
 build/mingw32.mak   | 242 +++++++++++++++++++++-----------------------
 build/tru64_cxx.mak | 186 ++++++++++++++++++----------------
 build/vc60.mak      | 133 ++++++++++++++++++++++++
 6 files changed, 740 insertions(+), 312 deletions(-)
 create mode 100644 build/filemgr.py
 create mode 100644 build/irix_CC.mak
 create mode 100644 build/vc60.mak

diff --git a/build/filemgr.py b/build/filemgr.py
new file mode 100644
index 00000000..fa674f18
--- /dev/null
+++ b/build/filemgr.py
@@ -0,0 +1,135 @@
+# Revision history:
+#   12 Apr 01 use os.path, shutil
+#   Initial version: R.W. Grosse-Kunstleve
+
+bpl_src = "/libs/python/src"
+bpl_tst = "/libs/python/test"
+bpl_exa = "/libs/python/example"
+files = (
+bpl_src + "/classes.cpp",
+bpl_src + "/conversions.cpp",
+bpl_src + "/extension_class.cpp",
+bpl_src + "/functions.cpp",
+bpl_src + "/init_function.cpp",
+bpl_src + "/module_builder.cpp",
+bpl_src + "/objects.cpp",
+bpl_src + "/types.cpp",
+bpl_src + "/cross_module.cpp",
+bpl_tst + "/comprehensive.cpp",
+bpl_tst + "/comprehensive.hpp",
+bpl_tst + "/comprehensive.py",
+bpl_tst + "/doctest.py",
+bpl_exa + "/abstract.cpp",
+bpl_exa + "/getting_started1.cpp",
+bpl_exa + "/getting_started2.cpp",
+bpl_exa + "/getting_started3.cpp",
+bpl_exa + "/simple_vector.cpp",
+bpl_exa + "/do_it_yourself_converters.cpp",
+bpl_exa + "/pickle1.cpp",
+bpl_exa + "/pickle2.cpp",
+bpl_exa + "/pickle3.cpp",
+bpl_exa + "/test_abstract.py",
+bpl_exa + "/test_getting_started1.py",
+bpl_exa + "/test_getting_started2.py",
+bpl_exa + "/test_getting_started3.py",
+bpl_exa + "/test_simple_vector.py",
+bpl_exa + "/test_do_it_yourself_converters.py",
+bpl_exa + "/test_pickle1.py",
+bpl_exa + "/test_pickle2.py",
+bpl_exa + "/test_pickle3.py",
+bpl_exa + "/noncopyable.h",
+bpl_exa + "/noncopyable_export.cpp",
+bpl_exa + "/noncopyable_import.cpp",
+bpl_exa + "/dvect.h",
+bpl_exa + "/dvect.cpp",
+bpl_exa + "/dvect_conversions.cpp",
+bpl_exa + "/dvect_defs.cpp",
+bpl_exa + "/ivect.h",
+bpl_exa + "/ivect.cpp",
+bpl_exa + "/ivect_conversions.cpp",
+bpl_exa + "/ivect_defs.cpp",
+bpl_exa + "/tst_noncopyable.py",
+bpl_exa + "/tst_dvect1.py",
+bpl_exa + "/tst_dvect2.py",
+bpl_exa + "/tst_ivect1.py",
+bpl_exa + "/tst_ivect2.py",
+bpl_exa + "/test_cross_module.py",
+)
+
+defs = (
+"boost_python_test",
+"abstract",
+"getting_started1",
+"getting_started2",
+"getting_started3",
+"simple_vector",
+"do_it_yourself_converters",
+"pickle1",
+"pickle2",
+"pickle3",
+"noncopyable_export",
+"noncopyable_import",
+"ivect",
+"dvect",
+)
+
+if (__name__ == "__main__"):
+
+  import sys, os, shutil
+
+  path = sys.argv[1]
+  mode = sys.argv[2]
+  if (not mode in ("softlinks", "unlink", "cp", "rm", "copy", "del")):
+    raise RuntimeError, \
+      "usage: python filemgr.py path <softlinks|unlink|cp|rm|copy|del>"
+
+  if (mode in ("cp", "copy")):
+    for fn in files:
+      f = os.path.basename(fn)
+      print "Copying: " + f
+      shutil.copy(path + fn, ".")
+
+  elif (mode == "softlinks"):
+    for fn in files:
+      f = os.path.basename(fn)
+      if (os.path.exists(f)):
+        print "File exists: " + f
+      else:
+        print "Linking: " + f
+        os.symlink(path + fn, f)
+
+  elif (mode in ("rm", "del")):
+    for fn in files:
+      f = os.path.basename(fn)
+      if (os.path.exists(f)):
+        print "Removing: " + f
+        try: os.unlink(f)
+        except: pass
+
+  elif (mode == "unlink"):
+    for fn in files:
+      f = os.path.basename(fn)
+      if (os.path.exists(f)):
+        if (os.path.islink(f)):
+          print "Unlinking: " + f
+          try: os.unlink(f)
+          except: pass
+        else:
+          print "Not a softlink: " + f
+
+  if (mode in ("softlinks", "cp", "copy")):
+    for d in defs:
+      fn = d + ".def"
+      print "Creating: " + fn
+      f = open(fn, "w")
+      f.write("EXPORTS\n")
+      f.write("\tinit" + d + "\n")
+      f.close()
+
+  if (mode in ("unlink", "rm", "del")):
+    for d in defs:
+      fn = d + ".def"
+      if (os.path.exists(fn)):
+        print "Removing: " + fn
+        try: os.unlink(fn)
+        except: pass
diff --git a/build/irix_CC.mak b/build/irix_CC.mak
new file mode 100644
index 00000000..88d374d8
--- /dev/null
+++ b/build/irix_CC.mak
@@ -0,0 +1,165 @@
+# Usage:
+#
+#   Create a new empty directory anywhere (preferably not in the boost tree).
+#   Copy this Makefile to that new directory and rename it to "Makefile"
+#   Adjust the pathnames below.
+#
+#   make softlinks     Create softlinks to source code and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make unlink        Remove softlinks
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
+
+PYEXE=/usr/local/Python-1.5.2/bin/python
+PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE=/usr/local/Python-2.0/bin/python
+#PYINC=-I/usr/local/Python-2.0/include/python2.0
+STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
+
+STDOPTS=
+WARNOPTS=-woff 1001,1234,1682
+OPTOPTS=-g
+
+CPP=CC -LANG:std -n32 -mips4
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-M
+
+LD=CC -LANG:std -n32 -mips4
+LDOPTS=-shared
+
+OBJ=classes.o conversions.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+DEPOBJ=$(OBJ) \
+       comprehensive.o \
+       abstract.o \
+       getting_started1.o getting_started2.o getting_started3.o \
+       simple_vector.o \
+       do_it_yourself_converters.o \
+       pickle1.o pickle2.o pickle3.o \
+       noncopyable_export.o noncopyable_import.o \
+       ivect.o dvect.o
+
+.SUFFIXES: .o .cpp
+
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
+     getting_started1.so getting_started2.so getting_started3.so \
+     simple_vector.so \
+     do_it_yourself_converters.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so
+
+libboost_python.a: $(OBJ)
+	rm -f libboost_python.a
+	$(CPP) -ar -o libboost_python.a $(OBJ)
+
+boost_python_test.so: $(OBJ) comprehensive.o
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.o -o boost_python_test.so -lm
+
+abstract.so: $(OBJ) abstract.o
+	$(LD) $(LDOPTS) $(OBJ) abstract.o -o abstract.so
+
+getting_started1.so: $(OBJ) getting_started1.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.o -o getting_started1.so
+
+getting_started2.so: $(OBJ) getting_started2.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
+
+getting_started3.so: $(OBJ) getting_started3.o
+	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
+
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
+
+do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
+
+.cpp.o:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+
+clean:
+	rm -f $(OBJ) libboost_python.a libboost_python.a.input
+	rm -f comprehensive.o boost_python_test.so
+	rm -f abstract.o abstract.so
+	rm -f getting_started1.o getting_started1.so
+	rm -f getting_started2.o getting_started2.so
+	rm -f getting_started3.o getting_started3.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
+	rm -f so_locations *.pyc
+	rm -rf ii_files
+
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
+
+depend:
+	@ cat Makefile.nodepend; \
+          for obj in $(DEPOBJ); \
+          do \
+            bn=`echo "$$obj" | cut -d. -f1`; \
+            $(CPP) $(CPPOPTS) $(MAKEDEP) "$$bn".cpp; \
+          done
+
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index a07bb5da..9be8f1cb 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -2,110 +2,64 @@
 #
 #   Create a new empty directory anywhere (preferably not in the boost tree).
 #   Copy this Makefile to that new directory and rename it to "Makefile"
-#   Set the BOOST pathname below.
+#   Adjust the pathnames below.
 #
 #   make softlinks     Create softlinks to source code and tests
 #   make               Compile all sources
 #   make test          Run doctest tests
 #   make clean         Remove all object files
 #   make unlink        Remove softlinks
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
 
-BOOST= /net/cci/rwgk/boost
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
 
-PYEXE= /usr/local/Python-1.5.2/bin/python
-PYINC= -I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE= /usr/local/Python-2.0/bin/python
-#PYINC= -I/usr/local/Python-2.0/include/python2.0
-#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
-#STLPORTOPTS= \
-# -D__USE_STD_IOSTREAM \
-# -D__STL_NO_SGI_IOSTREAMS \
-# -D__STL_USE_NATIVE_STRING \
-# -D__STL_NO_NEW_C_HEADERS \
-# -D_RWSTD_COMPILE_INSTANTIATE=1
-#STLPORTINC= -I/usr/local/STLport-4.1b4/stlport
-#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
-#STLPORTINC= -I/net/cci/xp/C++_C_headers
+PYEXE=/usr/bin/python
+PYINC=-I/usr/include/python1.5
+#PYEXE=/usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE=/usr/local/Python-2.0/bin/python
+#PYINC=-I/usr/local/Python-2.0/include/python2.0
 
-STDOPTS= -ftemplate-depth-21
+STDOPTS=-ftemplate-depth-21
 WARNOPTS=
-# use -msg_display_number to obtain integer tags for -msg_disable
+OPTOPTS=-g
 
-CPP= g++
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS) -g
-MAKEDEP= -M
+CPP=g++
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-M
 
-LD= g++
-LDOPTS= -shared
+LD=g++
+LDOPTS=-shared
 
-#HIDDEN= -hidden
-
-BPL_SRC = $(BOOST)/libs/python/src
-BPL_TST = $(BOOST)/libs/python/test
-BPL_EXA = $(BOOST)/libs/python/example
-SOFTLINKS = \
-$(BPL_SRC)/classes.cpp \
-$(BPL_SRC)/conversions.cpp \
-$(BPL_SRC)/extension_class.cpp \
-$(BPL_SRC)/functions.cpp \
-$(BPL_SRC)/init_function.cpp \
-$(BPL_SRC)/module_builder.cpp \
-$(BPL_SRC)/objects.cpp \
-$(BPL_SRC)/types.cpp \
-$(BPL_TST)/comprehensive.cpp \
-$(BPL_TST)/comprehensive.hpp \
-$(BPL_TST)/comprehensive.py \
-$(BPL_TST)/doctest.py \
-$(BPL_EXA)/abstract.cpp \
-$(BPL_EXA)/getting_started1.cpp \
-$(BPL_EXA)/getting_started2.cpp \
-$(BPL_EXA)/getting_started3.cpp \
-$(BPL_EXA)/getting_started4.cpp \
-$(BPL_EXA)/getting_started5.cpp \
-$(BPL_EXA)/test_abstract.py \
-$(BPL_EXA)/test_getting_started1.py \
-$(BPL_EXA)/test_getting_started2.py \
-$(BPL_EXA)/test_getting_started3.py \
-$(BPL_EXA)/test_getting_started4.py \
-$(BPL_EXA)/test_getting_started5.py
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o
-DEPOBJ= $(OBJ) comprehensive.o abstract.o \
-        getting_started1.o getting_started2.o getting_started3.o \
-        getting_started4.o getting_started5.o
+OBJ=classes.o conversions.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+DEPOBJ=$(OBJ) \
+       comprehensive.o \
+       abstract.o \
+       getting_started1.o getting_started2.o getting_started3.o \
+       simple_vector.o \
+       do_it_yourself_converters.o \
+       pickle1.o pickle2.o pickle3.o \
+       noncopyable_export.o noncopyable_import.o \
+       ivect.o dvect.o
 
 .SUFFIXES: .o .cpp
 
-all: libboost_python.a boost_python_test.so abstract.so \
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
      getting_started1.so getting_started2.so getting_started3.so \
-     getting_started4.so getting_started5.so
-
-softlinks:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ ! -e "$$bn" ]; then \
-              echo "ln -s $$pn ."; \
-	      ln -s "$$pn" .; \
-            else \
-              echo "info: no softlink created (file exists): $$bn"; \
-	    fi; \
-	  done
-
-unlink:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ -L "$$bn" ]; then \
-              echo "rm $$bn"; \
-              rm "$$bn"; \
-            elif [ -e "$$bn" ]; then \
-              echo "info: not a softlink: $$bn"; \
-	    fi; \
-	  done
+     simple_vector.so \
+     do_it_yourself_converters.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -126,11 +80,34 @@ getting_started2.so: $(OBJ) getting_started2.o
 getting_started3.so: $(OBJ) getting_started3.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
 
-getting_started4.so: $(OBJ) getting_started4.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.so
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-getting_started5.so: $(OBJ) getting_started5.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.so
+do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
 
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
@@ -141,8 +118,12 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
 
 clean:
 	rm -f $(OBJ) libboost_python.a libboost_python.a.input
@@ -151,10 +132,28 @@ clean:
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
 	rm -f getting_started3.o getting_started3.so
-	rm -f getting_started4.o getting_started4.so
-	rm -f getting_started5.o getting_started5.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
 	rm -f so_locations *.pyc
-	rm -rf cxx_repository
+
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
 
 depend:
 	@ cat Makefile.nodepend; \
diff --git a/build/mingw32.mak b/build/mingw32.mak
index 014af132..98a26735 100644
--- a/build/mingw32.mak
+++ b/build/mingw32.mak
@@ -1,18 +1,14 @@
 # Usage:
 #
-#   Create a new empty directory anywhere (preferably not in the boost tree).
-#   Copy this Makefile to that new directory and rename it to "Makefile"
-#   Set the BOOST_* pathnames below.
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
 #
-#   The idea is that the build directory is on a Unix filesystem that
-#   is mounted on a PC using SAMBA. Use this makefile under both Unix
-#   and Windows:
-#
-#   Unix: make softlinks     Create softlinks to source code and tests
-#   Win:  make               Compile all sources
-#   Win:  make test          Run doctest tests
-#   Unix: make clean         Remove all object files
-#   Unix: make unlink        Remove softlinks
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
 
 # To install mingw32, follow instructions at:
 #   http://starship.python.net/crew/kernr/mingw32/Notes.html
@@ -31,117 +27,49 @@
 # Could this be fixed with compiler options?
 # -fhuge-objects looks interesting, but requires recompiling the C++ library.
 #                (what exactly does that mean?)
-# -fvtable-thunks eliminates the compiler warning,
-# but "import boost_python_test" still causes a crash.
+# -fvtable-thunks eliminates the compiler warning, but
+#                 "import boost_python_test" still causes a crash.
 
-BOOST_UNIX= /net/cci/rwgk/boost
-BOOST_WIN= "L:\boost"
+ROOT=L:
+BOOST_WIN="$(ROOT)\boost"
+BOOST_UNIX=$(HOME)/boost
 
-PYEXE= "C:\Program files\Python\python.exe"
-PYINC= -I"C:\usr\include\python1.5"
-PYLIB= "C:\usr\lib\libpython15.a"
+PYEXE="C:\Program files\Python\python.exe"
+PYINC=-I"C:\usr\include\python1.5"
+PYLIB="C:\usr\lib\libpython15.a"
 
-STDOPTS= -ftemplate-depth-21
+STDOPTS=-ftemplate-depth-21
 WARNOPTS=
+OPTOPTS=-g
 
-CPP= g++
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS) -g
+CPP=g++
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
 
-LD= g++
-LDOPTS= -shared
+LD=g++
+LDOPTS=-shared
 
-BPL_SRC = $(BOOST_UNIX)/libs/python/src
-BPL_TST = $(BOOST_UNIX)/libs/python/test
-BPL_EXA = $(BOOST_UNIX)/libs/python/example
-SOFTLINKS = \
-$(BPL_SRC)/classes.cpp \
-$(BPL_SRC)/conversions.cpp \
-$(BPL_SRC)/extension_class.cpp \
-$(BPL_SRC)/functions.cpp \
-$(BPL_SRC)/init_function.cpp \
-$(BPL_SRC)/module_builder.cpp \
-$(BPL_SRC)/objects.cpp \
-$(BPL_SRC)/types.cpp \
-$(BPL_TST)/comprehensive.cpp \
-$(BPL_TST)/comprehensive.hpp \
-$(BPL_TST)/comprehensive.py \
-$(BPL_TST)/doctest.py \
-$(BPL_EXA)/abstract.cpp \
-$(BPL_EXA)/getting_started1.cpp \
-$(BPL_EXA)/getting_started2.cpp \
-$(BPL_EXA)/getting_started3.cpp \
-$(BPL_EXA)/getting_started4.cpp \
-$(BPL_EXA)/getting_started5.cpp \
-$(BPL_EXA)/passing_char.cpp \
-$(BPL_EXA)/test_abstract.py \
-$(BPL_EXA)/test_getting_started1.py \
-$(BPL_EXA)/test_getting_started2.py \
-$(BPL_EXA)/test_getting_started3.py \
-$(BPL_EXA)/test_getting_started4.py \
-$(BPL_EXA)/test_getting_started5.py
-
-DEFS= \
-boost_python_test \
-abstract \
-getting_started1 \
-getting_started2 \
-getting_started3 \
-getting_started4 \
-getting_started5
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o
+OBJ=classes.o conversions.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
 
 .SUFFIXES: .o .cpp
 
-all: libboost_python.a boost_python_test.pyd abstract.pyd \
+all: libboost_python.a \
+     abstract.pyd \
      getting_started1.pyd getting_started2.pyd getting_started3.pyd \
-     getting_started4.pyd getting_started5.pyd
-
-softlinks: defs
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ ! -e "$$bn" ]; then \
-              echo "ln -s $$pn ."; \
-	      ln -s "$$pn" .; \
-            else \
-              echo "info: no softlink created (file exists): $$bn"; \
-	    fi; \
-	  done
-
-unlink: rmdefs
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ -L "$$bn" ]; then \
-              echo "rm $$bn"; \
-              rm "$$bn"; \
-            elif [ -e "$$bn" ]; then \
-              echo "info: not a softlink: $$bn"; \
-	    fi; \
-	  done
-
-defs:
-	@ for def in $(DEFS); \
-	  do \
-            echo "EXPORTS\n\tinit$$def" > $$def.def; \
-	  done
-
-rmdefs:
-	@ for def in $(DEFS); \
-	  do \
-            rm $$def.def; \
-	  done
+     simple_vector.pyd \
+     do_it_yourself_converters.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd
 
 libboost_python.a: $(OBJ)
 	del libboost_python.a
 	ar r libboost_python.a $(OBJ)
 
-DLLWRAPOPTS= -s --driver-name g++ -s
-             --entry _DllMainCRTStartup@12 --target=i386-mingw32
+DLLWRAPOPTS=-s --driver-name g++ -s \
+            --entry _DllMainCRTStartup@12 --target=i386-mingw32
 
 boost_python_test.pyd: $(OBJ) comprehensive.o
 	dllwrap $(DLLWRAPOPTS) \
@@ -173,38 +101,96 @@ getting_started3.pyd: $(OBJ) getting_started3.o
           --def getting_started3.def \
           $(OBJ) getting_started3.o $(PYLIB)
 
-getting_started4.pyd: $(OBJ) getting_started4.o
+simple_vector.pyd: $(OBJ) simple_vector.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname getting_started4.pyd \
-          --def getting_started4.def \
-          $(OBJ) getting_started4.o $(PYLIB)
+          --dllname simple_vector.pyd \
+          --def simple_vector.def \
+          $(OBJ) simple_vector.o $(PYLIB)
 
-getting_started5.pyd: $(OBJ) getting_started5.o
+do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname getting_started5.pyd \
-          --def getting_started5.def \
-          $(OBJ) getting_started5.o $(PYLIB)
+          --dllname do_it_yourself_converters.pyd \
+          --def do_it_yourself_converters.def \
+          $(OBJ) do_it_yourself_converters.o $(PYLIB)
+
+pickle1.pyd: $(OBJ) pickle1.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname pickle1.pyd \
+          --def pickle1.def \
+          $(OBJ) pickle1.o $(PYLIB)
+
+pickle2.pyd: $(OBJ) pickle2.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname pickle2.pyd \
+          --def pickle2.def \
+          $(OBJ) pickle2.o $(PYLIB)
+
+pickle3.pyd: $(OBJ) pickle3.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname pickle3.pyd \
+          --def pickle3.def \
+          $(OBJ) pickle3.o $(PYLIB)
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname noncopyable_export.pyd \
+          --def noncopyable_export.def \
+          $(OBJ) noncopyable_export.o $(PYLIB)
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname noncopyable_import.pyd \
+          --def noncopyable_import.def \
+          $(OBJ) noncopyable_import.o $(PYLIB)
+
+ivect.pyd: $(OBJ) ivect.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname ivect.pyd \
+          --def ivect.def \
+          $(OBJ) ivect.o $(PYLIB)
+
+dvect.pyd: $(OBJ) dvect.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname dvect.pyd \
+          --def dvect.def \
+          $(OBJ) dvect.o $(PYLIB)
 
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
 
 test:
-	$(PYEXE) comprehensive.py
+#	$(PYEXE) comprehensive.py
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
 
 clean:
-	rm -f $(OBJ) libboost_python.a libboost_python.a.input
-	rm -f comprehensive.o boost_python_test.pyd
-	rm -f abstract.o abstract.pyd
-	rm -f getting_started1.o getting_started1.pyd
-	rm -f getting_started2.o getting_started2.pyd
-	rm -f getting_started3.o getting_started3.pyd
-	rm -f getting_started4.o getting_started4.pyd
-	rm -f getting_started5.o getting_started5.pyd
-	rm -f so_locations *.pyc
-	rm -rf cxx_repository
+	del *.o
+	del *.a
+	del *.pyd
+	del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index 3fd584b7..41f7a554 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -2,110 +2,74 @@
 #
 #   Create a new empty directory anywhere (preferably not in the boost tree).
 #   Copy this Makefile to that new directory and rename it to "Makefile"
-#   Set the BOOST pathname below.
+#   Adjust the pathnames below.
 #
 #   make softlinks     Create softlinks to source code and tests
 #   make               Compile all sources
 #   make test          Run doctest tests
 #   make clean         Remove all object files
 #   make unlink        Remove softlinks
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
 
-BOOST= /net/cci/rwgk/boost
+ROOT=$(HOME)
+BOOST=$(ROOT)/boost
 
-PYEXE= /usr/local/Python-1.5.2/bin/python
-PYINC= -I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE= /usr/local/Python-2.0/bin/python
-#PYINC= -I/usr/local/Python-2.0/include/python2.0
-#STLPORTINC= -I/usr/local/STLport-4.1b3/stlport
+PYEXE=/usr/local/Python-1.5.2/bin/python
+PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+#PYEXE=/usr/local/Python-2.0/bin/python
+#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
+#STLPORTINC=-I/usr/local/STLport-4.1b4/stlport
 #STLPORTOPTS= \
 # -D__USE_STD_IOSTREAM \
 # -D__STL_NO_SGI_IOSTREAMS \
 # -D__STL_USE_NATIVE_STRING \
 # -D__STL_NO_NEW_C_HEADERS \
 # -D_RWSTD_COMPILE_INSTANTIATE=1
-#STLPORTINC= -I/usr/local/STLport-4.1b4/stlport
-#STLPORTOPTS= -D__NO_USE_STD_IOSTREAM -D__STL_NO_SGI_IOSTREAMS
-STLPORTINC= -I/net/cci/xp/C++_C_headers
+STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
-STDOPTS= -std strict_ansi
-WARNOPTS= -msg_disable 186,450,1115
+STDOPTS=-std strict_ansi
 # use -msg_display_number to obtain integer tags for -msg_disable
+WARNOPTS=-msg_disable 186,450,1115
+OPTOPTS=-g
 
-CPP= cxx
-CPPOPTS= $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
-         $(STDOPTS) $(WARNOPTS) -g
-MAKEDEP= -Em
+CPP=cxx
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+MAKEDEP=-Em
 
-LD= cxx
-LDOPTS= -shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
+LD=cxx
+LDOPTS=-shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
 
-#HIDDEN= -hidden
+#HIDDEN=-hidden
 
-BPL_SRC = $(BOOST)/libs/python/src
-BPL_TST = $(BOOST)/libs/python/test
-BPL_EXA = $(BOOST)/libs/python/example
-SOFTLINKS = \
-$(BPL_SRC)/classes.cpp \
-$(BPL_SRC)/conversions.cpp \
-$(BPL_SRC)/extension_class.cpp \
-$(BPL_SRC)/functions.cpp \
-$(BPL_SRC)/init_function.cpp \
-$(BPL_SRC)/module_builder.cpp \
-$(BPL_SRC)/objects.cpp \
-$(BPL_SRC)/types.cpp \
-$(BPL_TST)/comprehensive.cpp \
-$(BPL_TST)/comprehensive.hpp \
-$(BPL_TST)/comprehensive.py \
-$(BPL_TST)/doctest.py \
-$(BPL_EXA)/abstract.cpp \
-$(BPL_EXA)/getting_started1.cpp \
-$(BPL_EXA)/getting_started2.cpp \
-$(BPL_EXA)/getting_started3.cpp \
-$(BPL_EXA)/getting_started4.cpp \
-$(BPL_EXA)/getting_started5.cpp \
-$(BPL_EXA)/test_abstract.py \
-$(BPL_EXA)/test_getting_started1.py \
-$(BPL_EXA)/test_getting_started2.py \
-$(BPL_EXA)/test_getting_started3.py \
-$(BPL_EXA)/test_getting_started4.py \
-$(BPL_EXA)/test_getting_started5.py
-
-OBJ = classes.o conversions.o extension_class.o functions.o \
-      init_function.o module_builder.o \
-      objects.o types.o
-DEPOBJ= $(OBJ) comprehensive.o abstract.o \
-        getting_started1.o getting_started2.o getting_started3.o \
-        getting_started4.o getting_started5.o
+OBJ=classes.o conversions.o extension_class.o functions.o \
+    init_function.o module_builder.o \
+    objects.o types.o cross_module.o
+DEPOBJ=$(OBJ) \
+       comprehensive.o \
+       abstract.o \
+       getting_started1.o getting_started2.o getting_started3.o \
+       simple_vector.o \
+       do_it_yourself_converters.o \
+       pickle1.o pickle2.o pickle3.o \
+       noncopyable_export.o noncopyable_import.o \
+       ivect.o dvect.o
 
 .SUFFIXES: .o .cpp
 
-all: libboost_python.a boost_python_test.so abstract.so \
+all: libboost_python.a \
+     boost_python_test.so \
+     abstract.so \
      getting_started1.so getting_started2.so getting_started3.so \
-     getting_started4.so getting_started5.so
-
-softlinks:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ ! -e "$$bn" ]; then \
-              echo "ln -s $$pn ."; \
-	      ln -s "$$pn" .; \
-            else \
-              echo "info: no softlink created (file exists): $$bn"; \
-	    fi; \
-	  done
-
-unlink:
-	@ for pn in $(SOFTLINKS); \
-	  do \
-            bn=`basename "$$pn"`; \
-	    if [ -L "$$bn" ]; then \
-              echo "rm $$bn"; \
-              rm "$$bn"; \
-            elif [ -e "$$bn" ]; then \
-              echo "info: not a softlink: $$bn"; \
-	    fi; \
-	  done
+     simple_vector.so \
+     do_it_yourself_converters.so \
+     pickle1.so pickle2.so pickle3.so \
+     noncopyable_export.so noncopyable_import.so \
+     ivect.so dvect.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -130,11 +94,34 @@ getting_started2.so: $(OBJ) getting_started2.o
 getting_started3.so: $(OBJ) getting_started3.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
 
-getting_started4.so: $(OBJ) getting_started4.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started4.o -o getting_started4.so
+simple_vector.so: $(OBJ) simple_vector.o
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-getting_started5.so: $(OBJ) getting_started5.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started5.o -o getting_started5.so
+do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+
+pickle1.so: $(OBJ) pickle1.o
+	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
+
+pickle2.so: $(OBJ) pickle2.o
+	$(LD) $(LDOPTS) $(OBJ) pickle2.o -o pickle2.so
+
+pickle3.so: $(OBJ) pickle3.o
+	$(LD) $(LDOPTS) $(OBJ) pickle3.o -o pickle3.so
+
+noncopyable_export.so: $(OBJ) noncopyable_export.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_export.o -o noncopyable_export.so
+
+noncopyable_import.so: $(OBJ) noncopyable_import.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) \
+          noncopyable_import.o -o noncopyable_import.so
+
+ivect.so: $(OBJ) ivect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) ivect.o -o ivect.so
+
+dvect.so: $(OBJ) dvect.o
+	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
 
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
@@ -145,8 +132,12 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_getting_started3.py
-	$(PYEXE) test_getting_started4.py
-	$(PYEXE) test_getting_started5.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
 
 clean:
 	rm -f $(OBJ) libboost_python.a libboost_python.a.input
@@ -155,11 +146,30 @@ clean:
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
 	rm -f getting_started3.o getting_started3.so
-	rm -f getting_started4.o getting_started4.so
-	rm -f getting_started5.o getting_started5.so
+	rm -f simple_vector.o simple_vector.so
+	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f pickle1.o pickle1.so
+	rm -f pickle2.o pickle2.so
+	rm -f pickle3.o pickle3.so
+	rm -f noncopyable_export.o noncopyable_export.so
+	rm -f noncopyable_import.o noncopyable_import.so
+	rm -f ivect.o ivect.so
+	rm -f dvect.o dvect.so
 	rm -f so_locations *.pyc
 	rm -rf cxx_repository
 
+softlinks:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) softlinks
+
+unlink:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) unlink
+
+cp:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) cp
+
+rm:
+	$(PYEXE) $(BOOST)/libs/python/build/filemgr.py $(BOOST) rm
+
 depend:
 	@ cat Makefile.nodepend; \
           for obj in $(DEPOBJ); \
diff --git a/build/vc60.mak b/build/vc60.mak
new file mode 100644
index 00000000..64e0b9df
--- /dev/null
+++ b/build/vc60.mak
@@ -0,0 +1,133 @@
+# Usage:
+#
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
+#
+# Revision history:
+#   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
+#   Initial version: R.W. Grosse-Kunstleve
+
+ROOT=L:
+BOOST_WIN="$(ROOT)\boost"
+BOOST_UNIX=$(HOME)/boost
+
+PYEXE="C:\Program files\Python\python.exe"
+PYINC=/I"C:\Program files\Python\include"
+PYLIB="C:\Program files\Python\libs\python15.lib"
+
+STDOPTS=/nologo /MD /GR /GX /Zm200
+WARNOPTS=
+OPTOPTS=
+
+CPP=cl.exe
+CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) /I$(BOOST_WIN) $(PYINC) \
+        $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
+
+LD=link.exe
+LDOPTS=/nologo /dll /incremental:no
+
+OBJ=classes.obj conversions.obj extension_class.obj functions.obj \
+    init_function.obj module_builder.obj \
+    objects.obj types.obj cross_module.obj
+
+.SUFFIXES: .obj .cpp
+
+all: boost_python.lib \
+     boost_python_test.pyd \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
+     simple_vector.pyd \
+     do_it_yourself_converters.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd
+
+boost_python.lib: $(OBJ)
+	$(LD) -lib /nologo /out:boost_python.lib $(OBJ)
+
+boost_python_test.pyd: $(OBJ) comprehensive.obj
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.obj $(PYLIB) /export:initboost_python_test /out:"boost_python_test.pyd"
+
+abstract.pyd: $(OBJ) abstract.obj
+	$(LD) $(LDOPTS) $(OBJ) abstract.obj $(PYLIB) /export:initabstract /out:"abstract.pyd"
+
+getting_started1.pyd: $(OBJ) getting_started1.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.obj $(PYLIB) /export:initgetting_started1 /out:"getting_started1.pyd"
+
+getting_started2.pyd: $(OBJ) getting_started2.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB) /export:initgetting_started2 /out:"getting_started2.pyd"
+
+getting_started3.pyd: $(OBJ) getting_started3.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started3.obj $(PYLIB) /export:initgetting_started3 /out:"getting_started3.pyd"
+
+simple_vector.pyd: $(OBJ) simple_vector.obj
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB) /export:initsimple_vector /out:"simple_vector.pyd"
+
+do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.obj
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.obj $(PYLIB) /export:initdo_it_yourself_converters /out:"do_it_yourself_converters.pyd"
+
+pickle1.pyd: $(OBJ) pickle1.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB) /export:initpickle1 /out:"pickle1.pyd"
+
+pickle2.pyd: $(OBJ) pickle2.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle2.obj $(PYLIB) /export:initpickle2 /out:"pickle2.pyd"
+
+pickle3.pyd: $(OBJ) pickle3.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle3.obj $(PYLIB) /export:initpickle3 /out:"pickle3.pyd"
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_export.obj $(PYLIB) /export:initnoncopyable_export /out:"noncopyable_export.pyd"
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_import.obj $(PYLIB) /export:initnoncopyable_import /out:"noncopyable_import.pyd"
+
+ivect.pyd: $(OBJ) ivect.obj
+	$(LD) $(LDOPTS) $(OBJ) ivect.obj $(PYLIB) /export:initivect /out:"ivect.pyd"
+
+dvect.pyd: $(OBJ) dvect.obj
+	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB) /export:initdvect /out:"dvect.pyd"
+
+.cpp.obj:
+	$(CPP) $(CPPOPTS) /c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py --broken-auto-ptr 
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_getting_started3.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py --broken-auto-ptr
+
+clean:
+	del *.obj
+	del *.lib
+	del *.exp
+	del *.idb
+	del *.pyd
+	del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del

From fde432601aae5fc1ca29e1ba10b763622af6ab76 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:46:15 +0000
Subject: [PATCH 089/369] workaround for irix_CC problem.

[SVN r9821]
---
 test/comprehensive.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 7699b01f..aa2d9886 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -15,6 +15,10 @@
 #include <math.h>  // for pow()
 #include <boost/rational.hpp>
 
+#if defined(sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+inline double pow(int x, int y) { return pow(static_cast<double>(x), y); }
+#endif
+
 namespace bpl_test {
 
 FooCallback::FooCallback(PyObject* self, int x)

From fa7b6591cf72da6d1d14d90dcb4b702cf9d325af Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:49:42 +0000
Subject: [PATCH 090/369] moved from branch ralf_grosse_kunstleve to trunk (was
 cross_module_dependencies.html)

[SVN r9822]
---
 doc/cross_module.html | 336 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 336 insertions(+)
 create mode 100644 doc/cross_module.html

diff --git a/doc/cross_module.html b/doc/cross_module.html
new file mode 100644
index 00000000..08c39bfe
--- /dev/null
+++ b/doc/cross_module.html
@@ -0,0 +1,336 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+
+<title>Cross-extension-module dependencies</title>
+
+<div>
+
+<img src="../../../c++boost.gif"
+     alt="c++boost.gif (8819 bytes)"
+     align="center"
+     width="277" height="86">
+
+<hr>
+<h1>Cross-extension-module dependencies</h1>
+
+It is good programming practice to organize large projects as modules
+that interact with each other via well defined interfaces. With
+Boost.Python it is possible to reflect this organization at the C++
+level at the Python level. This is, each logical C++ module can be
+organized as a separate Python extension module.
+
+<p>
+At first sight this might seem natural and straightforward. However, it
+is a fairly complex problem to establish cross-extension-module
+dependencies while maintaining the same ease of use Boost.Python
+provides for classes that are wrapped in the same extension module. To
+a large extent this complexity can be hidden from the author of a
+Boost.Python extension module, but not entirely.
+
+<hr>
+<h2>The recipe</h2>
+
+Suppose there is an extension module that exposes certain instances of
+the C++ <tt>std::vector</tt> template library such that it can be used
+from Python in the following manner:
+
+<pre>
+import std_vector
+v = std_vector.double([1, 2, 3, 4])
+v.push_back(5)
+v.size()
+</pre>
+
+Suppose the <tt>std_vector</tt> module is done well and reflects all
+C++ functions that are useful at the Python level, for all C++ built-in
+data types (<tt>std_vector.int</tt>, <tt>std_vector.long</tt>, etc.).
+
+<p>
+Suppose further that there is statistic module with a C++ class that
+has constructors or member functions that use or return a
+<tt>std::vector</tt>.  For example:
+
+<pre>
+class xy {
+  public:
+    xy(const std::vector&lt;double&gt;&amp; x, const std::vector&lt;double&gt;&amp; y) : m_x(x), m_y(y) {}
+    const std::vector&lt;double&gt;&amp; x() const { return m_x; }
+    const std::vector&lt;double&gt;&amp; y() const { return m_y; }
+    double correlation();
+  private:
+    std::vector&lt;double&gt; m_x;
+    std::vector&lt;double&gt; m_y;
+}
+</pre>
+
+What is more natural than reusing the <tt>std_vector</tt> extension
+module to expose these constructors or functions to Python?
+
+<p>
+Unfortunately, what seems natural needs a little work in both the
+<tt>std_vector</tt> and the <tt>statistics</tt> module.
+
+<p>
+In the <tt>std_vector</tt> extension module,
+<tt>std::vector&lt;double&gt;</tt> is exposed to Python in the usual
+way with the <tt>class_builder&lt;&gt;</tt> template.  To also enable the
+automatic conversion of <tt>std::vector&lt;double&gt;</tt> function
+arguments or return values in other Boost.Python C++ modules, the
+converters that convert a <tt>std::vector&lt;double&gt;</tt> C++ object
+to a Python object and vice versa (i.e. the <tt>to_python()</tt> and
+<tt>from_python()</tt> template functions) have to be exported. For
+example:
+
+<pre>
+  #include &lt;boost/python/cross_module.hpp&gt;
+  //...
+  class_builder&lt;std::vector&lt;double&gt; &gt; v_double(std_vector_module, &quot;double&quot;);
+  export_converters(v_double);
+</pre>
+
+In the extension module that wraps <tt>class xy</tt> we can now import
+these converters with the <tt>import_converters&lt;&gt;</tt> template.
+For example:
+
+<pre>
+  #include &lt;boost/python/cross_module.hpp&gt;
+  //...
+  import_converters&lt;std::vector&lt;double&gt; &gt; v_double_converters(&quot;std_vector&quot;, &quot;double&quot;);
+</pre>
+
+That is all. All the attributes that are defined for
+<tt>std_vector.double</tt> in the <tt>std_vector</tt> Boost.Python
+module will be available for the returned objects of <tt>xy.x()</tt>
+and <tt>xy.y()</tt>.  Similarly, the constructor for <tt>xy</tt> will
+accept objects that were created by the <tt>std_vector</tt>module.
+
+<hr>
+<h2>Placement of <tt>import_converters&lt;&gt;</tt> template instantiations</h2>
+
+<tt>import_converts&lt;&gt;</tt> can be viewed as a drop-in replacement
+for <tt>class_wrapper&lt;&gt;</tt>, and the recommendations for the
+placement of <tt>class_wrapper&lt;&gt;</tt> template instantiations
+also apply to to <tt>import_converts&lt;&gt;</tt>. In particular, it is
+important that an instantiation of <tt>class_wrapper&lt;&gt;</tt> is
+visible to any code which wraps a C++ function with a <tt>T</tt>,
+<tt>T*</tt>, const <tt>T&amp;</tt>, etc. parameter or return value.
+Therefore you may want to group all <tt>class_wrapper&lt;&gt;</tt> and
+<tt>import_converts&lt;&gt;</tt> instantiations at the top of your
+module's init function, then <tt>def()</tt> the member functions later
+to avoid problems with inter-class dependencies.
+
+<hr>
+<h2>Non-copyable types</h2>
+
+<tt>export_converters()</tt> instantiates C++ template functions that
+invoke the copy constructor of the wrapped type. For a type that is
+non-copyable this will result in compile-time error messages. In such a
+case, <tt>export_converters_noncopyable()</tt> can be used to export
+the converters that do not involve the copy constructor of the wrapped
+type.  For example:
+
+<pre>
+class_builder&lt;store&gt; py_store(your_module, &quot;store&quot;);
+export_converters_noncopyable(py_store);
+</pre>
+
+The corresponding <tt>import_converters&lt;&gt;</tt> statement does not
+need any special attention:
+
+<pre>
+import_converters&lt;store&gt; py_store(&quot;noncopyable_export&quot;, &quot;store&quot;);
+</pre>
+
+<hr>
+<h2>Python module search path</h2>
+
+The <tt>std_vector</tt> and <tt>statistics</tt> modules can now be used
+in the following way:
+
+<pre>
+import std_vector
+import statistics
+x = std_vector.double([1, 2, 3, 4])
+y = std_vector.double([2, 4, 6, 8])
+xy = statistics.xy(x, y)
+xy.correlation()
+</pre>
+
+In this example it is clear that Python has to be able to find both the
+<tt>std_vector</tt> and the <tt>statistics</tt> extension module. In
+other words, both extension modules need to be in the Python module
+search path (<tt>sys.path</tt>).
+
+<p>
+The situation is not always this obvious. Suppose the
+<tt>statistics</tt> module has a <tt>random()</tt> function that
+returns a vector of random numbers with a given length:
+
+<pre>
+import statistics
+x = statistics.random(5)
+y = statistics.random(5)
+xy = statistics.xy(x, y)
+xy.correlation()
+</pre>
+
+A naive user will not easily anticipate that the <tt>std_vector</tt>
+module is used to pass the <tt>x</tt> and <tt>y</tt> vectors around. If
+the <tt>std_vector</tt> module is in the Python module search path,
+this form of ignorance is of no harm.  On the contrary, we are glad
+that we do not have to bother the user with details like this.
+
+<p>
+If the <tt>std_vector</tt> module is not in the Python module search
+path, a Python exception will be raised:
+
+<pre>
+Traceback (innermost last):
+  File &quot;foo.py&quot;, line 2, in ?
+    x = statistics.random(5)
+ImportError: No module named std_vector
+</pre>
+
+As is the case with any system of a non-trivial complexity, it is
+important that the setup is consistent and complete.
+
+<hr>
+<h2>Two-way module dependencies</h2>
+
+Boost.Python supports two-way module dependencies. This is best
+illustrated by a simple example.
+
+<p>
+Suppose there is a module <tt>ivect</tt> that implements vectors of
+integers, and a similar module <tt>dvect</tt> that implements vectors
+of doubles. We want to be able do convert an integer vector to a double
+vector and vice versa. For example:
+
+<pre>
+import ivect
+iv = ivect.ivect((1,2,3,4,5))
+dv = iv.as_dvect()
+</pre>
+
+The last expression will implicitly import the <tt>dvect</tt> module in
+order to enable the conversion of the C++ representation of
+<tt>dvect</tt> to a Python object. The analogous is possible for a
+<tt>dvect</tt>:
+
+<pre>
+import dvect
+dv = dvect.dvect((1,2,3,4,5))
+iv = dv.as_ivect()
+</pre>
+
+Now the <tt>ivect</tt> module is imported implicitly.
+
+<p>
+Note that the two-way dependencies are possible because the
+dependencies are resolved only when needed. This is, the initialization
+of the <tt>ivect</tt> module does not rely on the <tt>dvect</tt>
+module, and vice versa.  Only if <tt>as_dvect()</tt> or
+<tt>as_ivect()</tt> is actually invoked will the corresponding module
+be implicitly imported. This also means that, for example, the
+<tt>dvect</tt> module does not have to be available at all if
+<tt>as_dvect()</tt> is never used.
+
+<hr>
+<h2>Clarification of compile-time and link-time dependencies</h2>
+
+Boost.Python's support for resolving cross-module dependencies at
+runtime does not imply that compile-time dependencies are eliminated.
+For example, the statistics extension module in the example above will
+need to <tt>#include &lt;vector&gt;</tt>. This is immediately obvious
+from the definition of <tt>class xy</tt>.
+
+<p>
+If a library is wrapped that consists of both header files and compiled
+components (e.g. <tt>libdvect.a</tt>, <tt>dvect.lib</tt>, etc.), both
+the Boost.Python extension module with the
+<tt>export_converters()</tt> statement and the module with the
+<tt>import_converters&lt;&gt;</tt> statement need to be linked against
+the object library.  Ideally one would build a shared library (e.g.
+<tt>libdvect.so</tt>, <tt>dvect.dll</tt>, etc.). However, this
+introduces the issue of having to configure the search path for the
+dynamic loading correctly. For small libraries it is therefore often
+more convenient to ignore the fact that the object files are loaded
+into memory more than once.
+
+<hr>
+<h2>Summary of motivation for cross-module support</h2>
+
+The main purpose of Boost.Python's cross-module support is to allow for
+a modular system layout. With this support it is straightforward to
+reflect C++ code organization at the Python level. Without the
+cross-module support, a multi-purpose module like <tt>std_vector</tt>
+would be impractical because the entire wrapper code would somehow have
+to be duplicated in all extension modules that use it, making them
+harder to maintain and harder to build.
+
+<p>
+Another motivation for the cross-module support is that two extension
+modules that wrap the same class cannot both be imported into Python.
+For example, if there are two modules <tt>A</tt> and <tt>B</tt> that
+both wrap a given <tt>class X</tt>, this will work:
+
+<pre>
+import A
+x = A.X()
+</pre>
+
+This will also work:
+
+<pre>
+import B
+x = B.X()
+</pre>
+
+However, this will fail:
+
+<pre>
+import A
+import B
+python: /net/cci/rwgk/boost/boost/python/detail/extension_class.hpp:866:
+static void boost::python::detail::class_registry&lt;X&gt;::register_class(boost::python::detail::extension_class_base *):
+Assertion `static_class_object == 0' failed.
+Abort
+</pre>
+
+A good solution is to wrap <tt>class X</tt> only once. Depending on the
+situation, this could be done by module <tt>A</tt> or <tt>B</tt>, or an
+additional small extension module that only wraps and exports
+<tt>class X</tt>.
+
+<p>
+Finally, there can be important psychological or political reasons for
+using the cross-module support. If a group of classes is lumped
+together with many others in a huge module, the authors will have
+difficulties in being identified with their work. The situation is
+much more transparent if the work is represented by a module with a
+recognizable name. This is not just a question of strong egos, but also
+of getting credit and funding.
+
+<hr>
+<h2>Why not use <tt>export_converters()</tt> universally?</h2>
+
+There is some overhead associated with the Boost.Python cross-module
+support. Depending on the platform, the size of the code generated by
+<tt>export_converters()</tt> is roughly 10%-20% of that generated
+by <tt>class_builder&lt;&gt;</tt>. For a large extension module with
+many wrapped classes, this could mean a significant difference.
+Therefore the general recommendation is to use
+<tt>export_converters()</tt> only for classes that are likely to
+be used as function arguments or return values in other modules.
+
+<hr>
+&copy; Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy,
+use, modify, sell and distribute this document is granted provided this
+copyright notice appears in all copies. This document is provided "as
+is" without express or implied warranty, and with no claim as to its
+suitability for any purpose.
+
+<p>
+Updated: April 2001
+
+</div>

From 38ac4fe84938e5a211d54b20fb912c1969f34aa3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:51:30 +0000
Subject: [PATCH 091/369] cross-module mods

[SVN r9823]
---
 doc/index.html | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/index.html b/doc/index.html
index c6e0722e..5ec32a6b 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -134,6 +134,8 @@ among others.
 
       <li><a href="pickle.html">Pickle Support</a>
 
+      <li><a href="cross_module.html">Cross-Extension-Module Dependencies</a>
+
       <li><a href="enums.html">Wrapping Enums</a>
 
       <li><a href="pointers.html">Pointers and Smart Pointers</a>

From 62b90206e842edce572c4ac10af9f9716a4f9173 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:52:44 +0000
Subject: [PATCH 092/369] More organized presentation.

[SVN r9824]
---
 doc/building.html | 279 +++++++++++++++++++++++++---------------------
 1 file changed, 151 insertions(+), 128 deletions(-)

diff --git a/doc/building.html b/doc/building.html
index 2a8c9cae..f9458c42 100644
--- a/doc/building.html
+++ b/doc/building.html
@@ -5,153 +5,176 @@
     <title>Building an Extension Module</title>
 
     <div>
-      <h1><img width="277" height="86" id="_x0000_i1025" align="center" src=
+      <h1><img width="277" height="86" align="center" src=
       "../../../c++boost.gif" alt="c++boost.gif (8819 bytes)">Building an
       Extension Module</h1>
 
       <p>The build process for Boost is currently undergoing some evolution,
       and, it is to be hoped, improvement. The following facts may help:
 
+      <hr>
+      Makefiles for various platforms and a Visual Studio project
+      reside in the Boost subdirectory <tt>libs/python/build</tt>.
+      Build targets include:
+
       <ul>
-        <li>
-          Makefiles for various platforms reside in the Boost subdirectory
-          <tt>libs/python/build</tt>: 
+        <li>The <tt>boost_python</tt> library for static linking with your
+        extension module. On the various Unices, this library will be
+        called <tt>libboost_python.a</tt>. When using Visual C++, the
+        library will be called <tt>boost_python.lib</tt>.
 
-          <ul>
-            <li><a href="../build/como.mak">como.mak</a> (Comeau C++ on Linux)
+        <p>
+        <li>A comprehensive test of Boost.Python features. This test builds
+        a Boost.Python extension module, then runs Python to import the
+        module, and runs a series of tests on it using <tt><a href=
+        "../test/doctest.py">doctest</a></tt>. Source code for the module
+        and tests is available in the Boost subdirectory
+        <tt>libs/python/test</tt>.
 
-            <li><a href="../build/linux_gcc.mak">linux_gcc.mak</a> (GCC on
-            Linux/Unix)
+        <p>
+        <li>Various examples from the Boost subdirectory
+        <tt>libs/python/example</tt>.
+        All these examples include a doctest modeled
+        on the comprehensive test above.
 
-            <li><a href="../build/gcc.mak">gcc.mak</a> (older makefile for GCC
-            on Linux/Unix. Deprecated.)
-
-            <li><a href="../build/mingw32.mak">mingw32.mak</a>
-            (highly-specialized makefile for mingw32 (Win32-targeted) GCC. Read
-            the header comment).
-
-            <li><a href="../build/tru64_cxx.mak">tru64_cxx.mak</a> (Compaq
-            Alpha).
-          </ul>
-          <br>
-
-        <li>
-          A project workspace for Microsoft Visual Studio is provided at <tt><a
-          href="../build/build.dsw">libs/python/build/build.dsw</a></tt>. The
-          include paths for this project may need to be changed for your
-          installation. They currently assume that python has been installed at
-          <tt>c:\tools\python</tt>. Three configurations of all targets are
-          supported: 
-
-          <ul>
-            <li>Release (optimization, <tt>-DNDEBUG</tt>)
-
-            <li>Debug (no optimization <tt>-D_DEBUG</tt>)
-
-            <li>DebugPython (no optimization, <tt>-D_DEBUG
-            -DBOOST_DEBUG_PYTHON</tt>)
-          </ul>
-
-          <p>When extension modules are built with Visual C++ using
-          <tt>-D_DEBUG</tt>, Python defaults to <i>force</i> linking with a
-          special debugging version of the Python DLL. Since this debug DLL
-          isn't supplied with the default Python installation for Windows,
-          Boost.Python uses <tt><a href=
-          "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
-          to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
-          <tt>#include</tt>d.
-
-          <p>If you want the extra runtime checks available with the debugging
-          version of the library, <tt>#define BOOST_DEBUG_PYTHON</tt> to
-          re-enable library forcing, and link with the DebugPython version of
-          <tt>boost_python.lib</tt>. You'll need to get the debugging version
-          of the Python executable (<tt>python_d.exe</tt>) and DLL
-          (<tt>python20_d.dll</tt> or <tt>python15_d.dll</tt>). The Python
-          sources include project files for building these. If you <a href=
-          "http://www.python.org">download</a> them, change the name of the
-          top-level directory to <tt>src</tt>, and install it under
-          <tt>c:\tools\python</tt>, the workspace supplied by Boost.Python will
-          be able to use it without modification. Just open
-          <tt>c:\tools\python\src\pcbuild\pcbuild.dsw</tt> and invoke "build
-          all" to generate all the debugging targets.
-
-          <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
-          any source files <tt>#include &lt;<a href=
-          "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
-          instead of the usual <tt>Python.h</tt>, or you will have link
-          incompatibilities.<br>
-          <br>
-
-
-        <li>
-          The makefiles and Visual Studio project can all build at least the
-          following: 
-
-          <ul>
-            <li>The <tt>boost_python</tt> library for static linking with your
-            extension module. On the various Unices, this library will be
-            called <tt>libboost_python.a</tt>. On Win32 platforms, the library
-            will be called <tt>boost_python.lib</tt>.
-
-            <li>A comprehensive test of Boost.Python features. This test builds
-            a Boost.Python extension module, then runs Python to import the
-            module, and runs a series of tests on it using <tt><a href=
-            "../test/doctest.py">doctest</a></tt>. Source code for the module
-            and tests is available in the Boost subdirectory
-            <tt>libs/python/test</tt>.<br>
-
-
-            <li>Various examples from the Boost subdirectory
-            <tt>libs/python/example</tt>. Which examples are built currently
-            depends on the platform. The most up-to-date examples are
-            <tt>getting_started</tt><i>n</i><tt>.cpp</tt> from <a href=
-            "http://cci.lbl.gov/staff/ralf_grosse-kunstleve.html">Ralf W.
-            Grosse-Kunstleve</a>. All these examples include a doctest modeled
-            on the comprehensive test above.<br>
-            <br>
-
-          </ul>
-
-        <li>
-          If your platform isn't directly supported, you can build a static
-          library from the following source files (in the Boost subdirectory
-          <tt>libs/python/src</tt>), or compile them directly and link the
-          resulting objects into your extension module: 
-
-          <ul>
-            <li><a href=
-            "../../../libs/python/src/extension_class.cpp">extension_class.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/functions.cpp">functions.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/init_function.cpp">init_function.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/module_builder.cpp">module_builder.cpp</a>
-
-            <li><a href="../../../libs/python/src/types.cpp">types.cpp</a>
-
-            <li><a href="../../../libs/python/src/objects.cpp">objects.cpp</a>
-
-            <li><a href=
-            "../../../libs/python/src/conversions.cpp">conversions.cpp</a>
-
-            <li><a href="../../../libs/python/src/classes.cpp">classes.cpp</a>
-          </ul>
       </ul>
 
-      <p>Next: <a href="enums.html">Wrapping Enums</a> Previous: <a href=
+      <hr>
+      There is a group of makefiles with support for simultaneous
+      compilation on multiple platforms and a consistent set of
+      features that build the <tt>boost_python</tt> library for static
+      linking, the comprehensive test, and all examples in
+      <tt>libs/python/example</tt>:
+
+      <ul>
+        <li><a href="../build/vc60.mak">vc60.mak</a>:
+        Visual C++ 6.0 Service Pack 4
+
+        <li><a href="../build/mingw32.mak">mingw32.mak</a>:
+        mingw32 (Win32-targeted) gcc 2.95.2
+
+        <li><a href="../build/linux_gcc.mak">linux_gcc.mak</a>:
+        gcc 2.95.2 on Linux/Unix
+
+        <li><a href="../build/tru64_cxx.mak">tru64_cxx.mak</a>:
+        Compaq Alpha using the Compaq cxx compiler
+
+        <li><a href="../build/irix_CC.mak">irix_CC.mak</a>:
+        Silicon Graphics IRIX 6.5 CC compiler
+
+      </ul>
+      <a href="http://cctbx.sourceforge.net/page_installation_adv.html#installation_boost_python"
+      >Usage of these makefiles is described here.</a>
+
+      <hr>
+      There is another group of makefiles for GNU make.
+      These makefiles are less redundant than the makefiles
+      in the group above,
+      but the list of compilation targets is not as complete
+      and there is no support for simultaneous compilation
+      on multiple platforms.
+
+      <ul>
+        <li><a href="../build/como.mak">como.mak</a>:
+        Comeau C++ on Linux
+
+        <li><a href="../build/gcc.mak">gcc.mak</a>:
+        GCC on Linux/Unix.
+
+      </ul>
+
+      <hr>
+      A project workspace for Microsoft Visual Studio is provided at <tt><a
+      href="../build/build.dsw">libs/python/build/build.dsw</a></tt>. The
+      include paths for this project may need to be changed for your
+      installation. They currently assume that python has been installed at
+      <tt>c:\tools\python</tt>. Three configurations of all targets are
+      supported:
+
+      <ul>
+        <li>Release (optimization, <tt>-DNDEBUG</tt>)
+
+        <li>Debug (no optimization <tt>-D_DEBUG</tt>)
+
+        <li>DebugPython (no optimization, <tt>-D_DEBUG
+        -DBOOST_DEBUG_PYTHON</tt>)
+      </ul>
+
+      <p>When extension modules are built with Visual C++ using
+      <tt>-D_DEBUG</tt>, Python defaults to <i>force</i> linking with a
+      special debugging version of the Python DLL. Since this debug DLL
+      isn't supplied with the default Python installation for Windows,
+      Boost.Python uses <tt><a href=
+      "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a></tt>
+      to temporarily undefine <tt>_DEBUG</tt> when <tt>Python.h</tt> is
+      <tt>#include</tt>d.
+
+      <p>If you want the extra runtime checks available with the debugging
+      version of the library, <tt>#define BOOST_DEBUG_PYTHON</tt> to
+      re-enable library forcing, and link with the DebugPython version of
+      <tt>boost_python.lib</tt>. You'll need to get the debugging version
+      of the Python executable (<tt>python_d.exe</tt>) and DLL
+      (<tt>python20_d.dll</tt> or <tt>python15_d.dll</tt>). The Python
+      sources include project files for building these. If you <a href=
+      "http://www.python.org">download</a> them, change the name of the
+      top-level directory to <tt>src</tt>, and install it under
+      <tt>c:\tools\python</tt>, the workspace supplied by Boost.Python will
+      be able to use it without modification. Just open
+      <tt>c:\tools\python\src\pcbuild\pcbuild.dsw</tt> and invoke "build
+      all" to generate all the debugging targets.
+
+      <p>If you do not <tt>#define BOOST_DEBUG_PYTHON</tt>, be sure that
+      any source files <tt>#include &lt;<a href=
+          "../../../boost/python/detail/wrap_python.hpp">boost/python/detail/wrap_python.hpp</a>&gt;</tt>
+      instead of the usual <tt>Python.h</tt>, or you will have link
+      incompatibilities.<br>
+
+      <hr>
+      If your platform isn't directly supported, you can build a static
+      library from the following source files (in the Boost subdirectory
+      <tt>libs/python/src</tt>), or compile them directly and link the
+      resulting objects into your extension module:
+
+      <ul>
+        <li><a href=
+        "../../../libs/python/src/classes.cpp">classes.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/conversions.cpp">conversions.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/cross_module.cpp">cross_module.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/extension_class.cpp">extension_class.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/functions.cpp">functions.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/init_function.cpp">init_function.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/module_builder.cpp">module_builder.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/objects.cpp">objects.cpp</a>
+
+        <li><a href=
+        "../../../libs/python/src/types.cpp">types.cpp</a>
+      </ul>
+
+      <hr>
+      Next: <a href="enums.html">Wrapping Enums</a> Previous: <a href=
       "under-the-hood.html">A Peek Under the Hood</a> Up: <a href=
       "index.html">Top</a>
 
+      <hr>
       <p>&copy; Copyright David Abrahams 2000. Permission to copy, use, modify,
       sell and distribute this document is granted provided this copyright
       notice appears in all copies. This document is provided ``as is'' without
       express or implied warranty, and with no claim as to its suitability for
       any purpose.
 
-      <p>Updated: Mar 6, 2001
+      <p>Updated: Apr 17, 2001 (R.W. Grosse-Kunstleve)
     </div>
-

From ad4b0fff565fb36c827f20357de54255dc365d3d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 19:55:11 +0000
Subject: [PATCH 093/369] moved from branch ralf_grosse_kunstleve to trunk

[SVN r9825]
---
 doc/pickle.html | 37 ++++++++++++++++++++++++++++++++-----
 1 file changed, 32 insertions(+), 5 deletions(-)

diff --git a/doc/pickle.html b/doc/pickle.html
index 842112d3..994a78ab 100644
--- a/doc/pickle.html
+++ b/doc/pickle.html
@@ -227,11 +227,38 @@ Both <tt>__getinitargs__</tt> and <tt>__getstate__</tt> are not defined.
 </ul>
 
 <hr>
-<h2>Example</h2>
+<h2>Examples</h2>
 
-An example that shows how to configure pickle support is available in the
-<tt>boost/lib/python/example</tt> directory
-(<tt>getting_started3.cpp</tt>).
+There are three files in <tt>boost/libs/python/example</tt> that
+show how so provide pickle support.
+
+<h3><a href="../example/pickle1.cpp"><tt>pickle1.cpp</tt></a></h3>
+
+    The C++ class in this example can be fully restored by passing the
+    appropriate argument to the constructor. Therefore it is sufficient
+    to define the pickle interface method <tt>__getinitargs__</tt>.
+
+<h3><a href="../example/pickle2.cpp"><tt>pickle2.cpp</tt></a></h3>
+
+    The C++ class in this example contains member data that cannot be
+    restored by any of the constructors. Therefore it is necessary to
+    provide the <tt>__getstate__</tt>/<tt>__setstate__</tt> pair of
+    pickle interface methods.
+
+    <p>
+    For simplicity, the <tt>__dict__</tt> is not included in the result
+    of <tt>__getstate__</tt>. This is not generally recommended, but a
+    valid approach if it is anticipated that the object's
+    <tt>__dict__</tt> will always be empty. Note that the safety guards
+    will catch the cases where this assumption is violated.
+
+<h3><a href="../example/pickle3.cpp"><tt>pickle3.cpp</tt></a></h3>
+
+    This example is similar to <a
+    href="../example/pickle2.cpp"><tt>pickle2.cpp</tt></a>. However, the
+    object's <tt>__dict__</tt> is included in the result of
+    <tt>__getstate__</tt>.  This requires more code but is unavoidable
+    if the object's <tt>__dict__</tt> is not always empty.
 
 <hr>
 &copy; Copyright Ralf W. Grosse-Kunstleve 2001. Permission to copy,
@@ -241,5 +268,5 @@ is" without express or implied warranty, and with no claim as to its
 suitability for any purpose.
 
 <p>
-Updated: March 10, 2001
+Updated: March 21, 2001
 </div>

From da83f20a283d943ed9fa42317109d3d0c3af14ec Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 20:02:20 +0000
Subject: [PATCH 094/369] stray getting_started3 references removed.

[SVN r9826]
---
 build/filemgr.py    | 3 ---
 build/irix_CC.mak   | 9 ++-------
 build/linux_gcc.mak | 9 ++-------
 build/mingw32.mak   | 9 +--------
 build/tru64_cxx.mak | 9 ++-------
 build/vc60.mak      | 6 +-----
 6 files changed, 8 insertions(+), 37 deletions(-)

diff --git a/build/filemgr.py b/build/filemgr.py
index fa674f18..d8310f6d 100644
--- a/build/filemgr.py
+++ b/build/filemgr.py
@@ -22,7 +22,6 @@ bpl_tst + "/doctest.py",
 bpl_exa + "/abstract.cpp",
 bpl_exa + "/getting_started1.cpp",
 bpl_exa + "/getting_started2.cpp",
-bpl_exa + "/getting_started3.cpp",
 bpl_exa + "/simple_vector.cpp",
 bpl_exa + "/do_it_yourself_converters.cpp",
 bpl_exa + "/pickle1.cpp",
@@ -31,7 +30,6 @@ bpl_exa + "/pickle3.cpp",
 bpl_exa + "/test_abstract.py",
 bpl_exa + "/test_getting_started1.py",
 bpl_exa + "/test_getting_started2.py",
-bpl_exa + "/test_getting_started3.py",
 bpl_exa + "/test_simple_vector.py",
 bpl_exa + "/test_do_it_yourself_converters.py",
 bpl_exa + "/test_pickle1.py",
@@ -61,7 +59,6 @@ defs = (
 "abstract",
 "getting_started1",
 "getting_started2",
-"getting_started3",
 "simple_vector",
 "do_it_yourself_converters",
 "pickle1",
diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index 88d374d8..5894ff51 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -41,7 +41,7 @@ OBJ=classes.o conversions.o extension_class.o functions.o \
 DEPOBJ=$(OBJ) \
        comprehensive.o \
        abstract.o \
-       getting_started1.o getting_started2.o getting_started3.o \
+       getting_started1.o getting_started2.o \
        simple_vector.o \
        do_it_yourself_converters.o \
        pickle1.o pickle2.o pickle3.o \
@@ -53,7 +53,7 @@ DEPOBJ=$(OBJ) \
 all: libboost_python.a \
      boost_python_test.so \
      abstract.so \
-     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started1.so getting_started2.so \
      simple_vector.so \
      do_it_yourself_converters.so \
      pickle1.so pickle2.so pickle3.so \
@@ -76,9 +76,6 @@ getting_started1.so: $(OBJ) getting_started1.o
 getting_started2.so: $(OBJ) getting_started2.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
 
-getting_started3.so: $(OBJ) getting_started3.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
-
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
@@ -116,7 +113,6 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_converters.py
 	$(PYEXE) test_pickle1.py
@@ -130,7 +126,6 @@ clean:
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
-	rm -f getting_started3.o getting_started3.so
 	rm -f simple_vector.o simple_vector.so
 	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
 	rm -f pickle1.o pickle1.so
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index 9be8f1cb..9cd2b5de 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -42,7 +42,7 @@ OBJ=classes.o conversions.o extension_class.o functions.o \
 DEPOBJ=$(OBJ) \
        comprehensive.o \
        abstract.o \
-       getting_started1.o getting_started2.o getting_started3.o \
+       getting_started1.o getting_started2.o \
        simple_vector.o \
        do_it_yourself_converters.o \
        pickle1.o pickle2.o pickle3.o \
@@ -54,7 +54,7 @@ DEPOBJ=$(OBJ) \
 all: libboost_python.a \
      boost_python_test.so \
      abstract.so \
-     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started1.so getting_started2.so \
      simple_vector.so \
      do_it_yourself_converters.so \
      pickle1.so pickle2.so pickle3.so \
@@ -77,9 +77,6 @@ getting_started1.so: $(OBJ) getting_started1.o
 getting_started2.so: $(OBJ) getting_started2.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
 
-getting_started3.so: $(OBJ) getting_started3.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
-
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
@@ -117,7 +114,6 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_converters.py
 	$(PYEXE) test_pickle1.py
@@ -131,7 +127,6 @@ clean:
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
-	rm -f getting_started3.o getting_started3.so
 	rm -f simple_vector.o simple_vector.so
 	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
 	rm -f pickle1.o pickle1.so
diff --git a/build/mingw32.mak b/build/mingw32.mak
index 98a26735..0a16f332 100644
--- a/build/mingw32.mak
+++ b/build/mingw32.mak
@@ -57,7 +57,7 @@ OBJ=classes.o conversions.o extension_class.o functions.o \
 
 all: libboost_python.a \
      abstract.pyd \
-     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
+     getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
      do_it_yourself_converters.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
@@ -95,12 +95,6 @@ getting_started2.pyd: $(OBJ) getting_started2.o
           --def getting_started2.def \
           $(OBJ) getting_started2.o $(PYLIB)
 
-getting_started3.pyd: $(OBJ) getting_started3.o
-	dllwrap $(DLLWRAPOPTS) \
-          --dllname getting_started3.pyd \
-          --def getting_started3.def \
-          $(OBJ) getting_started3.o $(PYLIB)
-
 simple_vector.pyd: $(OBJ) simple_vector.o
 	dllwrap $(DLLWRAPOPTS) \
           --dllname simple_vector.pyd \
@@ -163,7 +157,6 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_converters.py
 	$(PYEXE) test_pickle1.py
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index 41f7a554..21a8126e 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -52,7 +52,7 @@ OBJ=classes.o conversions.o extension_class.o functions.o \
 DEPOBJ=$(OBJ) \
        comprehensive.o \
        abstract.o \
-       getting_started1.o getting_started2.o getting_started3.o \
+       getting_started1.o getting_started2.o \
        simple_vector.o \
        do_it_yourself_converters.o \
        pickle1.o pickle2.o pickle3.o \
@@ -64,7 +64,7 @@ DEPOBJ=$(OBJ) \
 all: libboost_python.a \
      boost_python_test.so \
      abstract.so \
-     getting_started1.so getting_started2.so getting_started3.so \
+     getting_started1.so getting_started2.so \
      simple_vector.so \
      do_it_yourself_converters.so \
      pickle1.so pickle2.so pickle3.so \
@@ -91,9 +91,6 @@ getting_started1.so: $(OBJ) getting_started1.o
 getting_started2.so: $(OBJ) getting_started2.o
 	$(LD) $(LDOPTS) $(OBJ) getting_started2.o -o getting_started2.so
 
-getting_started3.so: $(OBJ) getting_started3.o
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.o -o getting_started3.so
-
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
@@ -131,7 +128,6 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_converters.py
 	$(PYEXE) test_pickle1.py
@@ -145,7 +141,6 @@ clean:
 	rm -f abstract.o abstract.so
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
-	rm -f getting_started3.o getting_started3.so
 	rm -f simple_vector.o simple_vector.so
 	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
 	rm -f pickle1.o pickle1.so
diff --git a/build/vc60.mak b/build/vc60.mak
index 64e0b9df..f0016075 100644
--- a/build/vc60.mak
+++ b/build/vc60.mak
@@ -38,7 +38,7 @@ OBJ=classes.obj conversions.obj extension_class.obj functions.obj \
 all: boost_python.lib \
      boost_python_test.pyd \
      abstract.pyd \
-     getting_started1.pyd getting_started2.pyd getting_started3.pyd \
+     getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
      do_it_yourself_converters.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
@@ -60,9 +60,6 @@ getting_started1.pyd: $(OBJ) getting_started1.obj
 getting_started2.pyd: $(OBJ) getting_started2.obj
 	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB) /export:initgetting_started2 /out:"getting_started2.pyd"
 
-getting_started3.pyd: $(OBJ) getting_started3.obj
-	$(LD) $(LDOPTS) $(OBJ) getting_started3.obj $(PYLIB) /export:initgetting_started3 /out:"getting_started3.pyd"
-
 simple_vector.pyd: $(OBJ) simple_vector.obj
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB) /export:initsimple_vector /out:"simple_vector.pyd"
 
@@ -98,7 +95,6 @@ test:
 	$(PYEXE) test_abstract.py
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
-	$(PYEXE) test_getting_started3.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_converters.py
 	$(PYEXE) test_pickle1.py

From c3215d0ba5b3b75e2e6f42e37b5e8ad592fb57c3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 17 Apr 2001 21:30:05 +0000
Subject: [PATCH 095/369] enhancement

[SVN r9827]
---
 example/README | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/example/README b/example/README
index 34b50d61..35d822d5 100644
--- a/example/README
+++ b/example/README
@@ -1,6 +1,24 @@
 To get started with the Boost Python Library, use the examples
-getting_started?.cpp and abstract.cpp.
+getting_started1.cpp and getting_started2.cpp.
+
+Examples for providing pickle support can be found in:
+  pickle1.cpp
+  pickle2.cpp
+  pickle3.cpp
+See also: libs/python/doc/pickle.html
+
+Other advanced concepts are introduced by:
+  abstract.cpp
+  simple_vector.cpp
+  do_it_yourself_converters.cpp
+
+Examples for the cross-module support are provided by:
+  noncopyable_export.cpp
+  noncopyable_import.cpp
+  dvect.cpp
+  ivect.cpp
+See also: libs/python/doc/cross_module.html
 
 The files example1.cpp and rwgk1.cpp are obsolete. They are only
-included because the makefiles in the build directory still refer to
-them. This will be fixed later.
+included because the Visual Studio project in the build directory still
+refers to them.

From ebb0145256b4247bf270d6442b669773153d487c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 18 Apr 2001 01:23:50 +0000
Subject: [PATCH 096/369] trying to clean cvs attic mess...

[SVN r9828]
---
 example/simple_vector.cpp | 103 --------------------------------------
 1 file changed, 103 deletions(-)
 delete mode 100644 example/simple_vector.cpp

diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
deleted file mode 100644
index 5ac0767b..00000000
--- a/example/simple_vector.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A wrapper is used to define additional constructors.
-  //
-  struct vector_double_wrapper: std::vector<double>
-  {
-    // Tell the compiler how to convert a base class object to
-    // this wrapper object.
-    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
-      : std::vector<double>(vd) {}
-
-    vector_double_wrapper(PyObject* self)
-      : std::vector<double>() {}
-
-    vector_double_wrapper(PyObject* self, int n)
-      : std::vector<double>(n) {}
-
-    vector_double_wrapper(PyObject* self, python::tuple tuple)
-      : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator vd = begin();
-      for (int i = 0; i < tuple.size(); i++)
-        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
-          python::type<double>());
-    }
-  };
-
-  double getitem(const std::vector<double>& vd, std::size_t key) {
-    return vd[key];
-  }
-
-  void setitem(std::vector<double>& vd, std::size_t key, double d) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vditer[key] = d;
-  }
-
-  void delitem(std::vector<double>& vd, std::size_t key) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
-  }
-
-  // Convert vector_double to a regular Python tuple.
-  //
-  python::tuple as_tuple(const std::vector<double>& vd)
-  {
-    python::tuple t(vd.size());
-    for (int i = 0; i < vd.size(); i++) t.set_item(i,
-      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
-    return t;
-  }
-
-  // Function returning a vector_double object to Python.
-  //
-  std::vector<double> foo(int n)
-  {
-    std::vector<double> vd(n);
-    std::vector<double>::iterator vditer = vd.begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(i);
-    return vd;
-  }
-
-  // Same as foo(), but avoid copying on return.
-  //
-  std::auto_ptr<std::vector<double> > bar(int n)
-  {
-    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
-    std::vector<double>::iterator vditer = vdptr->begin();
-    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
-    return vdptr;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(simple_vector)
-{
-  try
-  {
-    python::module_builder this_module("simple_vector");
-
-    python::class_builder<std::vector<double>, vector_double_wrapper>
-      vector_double(this_module, "vector_double");
-
-    vector_double.def(python::constructor<>());
-    vector_double.def(python::constructor<const int>());
-    vector_double.def(python::constructor<python::tuple>());
-    vector_double.def(&std::vector<double>::size, "__len__");
-    vector_double.def(getitem, "__getitem__");
-    vector_double.def(setitem, "__setitem__");
-    vector_double.def(delitem, "__delitem__");
-    vector_double.def(as_tuple, "as_tuple");
-
-    this_module.def(foo, "foo");
-    this_module.def(bar, "bar");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}

From 22024e7c1f8b7f8d2b92ad9ea0f2ce9307451e94 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 18 Apr 2001 01:24:34 +0000
Subject: [PATCH 097/369] trying to clean cvs attic mess...

[SVN r9829]
---
 example/simple_vector.cpp | 103 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 example/simple_vector.cpp

diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
new file mode 100644
index 00000000..5ac0767b
--- /dev/null
+++ b/example/simple_vector.cpp
@@ -0,0 +1,103 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A wrapper is used to define additional constructors.
+  //
+  struct vector_double_wrapper: std::vector<double>
+  {
+    // Tell the compiler how to convert a base class object to
+    // this wrapper object.
+    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
+      : std::vector<double>(vd) {}
+
+    vector_double_wrapper(PyObject* self)
+      : std::vector<double>() {}
+
+    vector_double_wrapper(PyObject* self, int n)
+      : std::vector<double>(n) {}
+
+    vector_double_wrapper(PyObject* self, python::tuple tuple)
+      : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator vd = begin();
+      for (int i = 0; i < tuple.size(); i++)
+        vd[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          python::type<double>());
+    }
+  };
+
+  double getitem(const std::vector<double>& vd, std::size_t key) {
+    return vd[key];
+  }
+
+  void setitem(std::vector<double>& vd, std::size_t key, double d) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vditer[key] = d;
+  }
+
+  void delitem(std::vector<double>& vd, std::size_t key) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vd.erase(&vditer[key]);
+  }
+
+  // Convert vector_double to a regular Python tuple.
+  //
+  python::tuple as_tuple(const std::vector<double>& vd)
+  {
+    python::tuple t(vd.size());
+    for (int i = 0; i < vd.size(); i++) t.set_item(i,
+      python::ref(BOOST_PYTHON_CONVERSION::to_python(vd[i])));
+    return t;
+  }
+
+  // Function returning a vector_double object to Python.
+  //
+  std::vector<double> foo(int n)
+  {
+    std::vector<double> vd(n);
+    std::vector<double>::iterator vditer = vd.begin();
+    for (int i = 0; i < n; i++) vditer[i] = double(i);
+    return vd;
+  }
+
+  // Same as foo(), but avoid copying on return.
+  //
+  std::auto_ptr<std::vector<double> > bar(int n)
+  {
+    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
+    std::vector<double>::iterator vditer = vdptr->begin();
+    for (int i = 0; i < n; i++) vditer[i] = double(10 * i);
+    return vdptr;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(simple_vector)
+{
+  try
+  {
+    python::module_builder this_module("simple_vector");
+
+    python::class_builder<std::vector<double>, vector_double_wrapper>
+      vector_double(this_module, "vector_double");
+
+    vector_double.def(python::constructor<>());
+    vector_double.def(python::constructor<const int>());
+    vector_double.def(python::constructor<python::tuple>());
+    vector_double.def(&std::vector<double>::size, "__len__");
+    vector_double.def(getitem, "__getitem__");
+    vector_double.def(setitem, "__setitem__");
+    vector_double.def(delitem, "__delitem__");
+    vector_double.def(as_tuple, "as_tuple");
+
+    this_module.def(foo, "foo");
+    this_module.def(bar, "bar");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}

From dc462cdc1f1fd22a97a69eda4b2a3cc97bb8bd7a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 18 Apr 2001 01:27:51 +0000
Subject: [PATCH 098/369] cleaning up cvs attic mess

[SVN r9830]
---
 example/do_it_yourself_converters.cpp | 128 ----------------------
 example/dvect.cpp                     |  45 --------
 example/ivect.cpp                     |  45 --------
 example/noncopyable_export.cpp        |  25 -----
 example/noncopyable_import.cpp        |  42 --------
 example/pickle1.cpp                   |  64 -----------
 example/pickle2.cpp                   | 100 -----------------
 example/pickle3.cpp                   | 150 --------------------------
 example/tst_dvect1.py                 |  20 ----
 example/tst_ivect1.py                 |  20 ----
 example/tst_noncopyable.py            |  16 ---
 11 files changed, 655 deletions(-)
 delete mode 100644 example/do_it_yourself_converters.cpp
 delete mode 100644 example/dvect.cpp
 delete mode 100644 example/ivect.cpp
 delete mode 100644 example/noncopyable_export.cpp
 delete mode 100644 example/noncopyable_import.cpp
 delete mode 100644 example/pickle1.cpp
 delete mode 100644 example/pickle2.cpp
 delete mode 100644 example/pickle3.cpp
 delete mode 100644 example/tst_dvect1.py
 delete mode 100644 example/tst_ivect1.py
 delete mode 100644 example/tst_noncopyable.py

diff --git a/example/do_it_yourself_converters.cpp b/example/do_it_yourself_converters.cpp
deleted file mode 100644
index 6d2d2d6a..00000000
--- a/example/do_it_yourself_converters.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-/*
-
-   This example shows how to convert a class from and to native
-   Python objects, such as tuples.
-
-   We do not want to expose the helper class MillerIndex as an
-   Extension Class. However, in order to simplify the wrapper code,
-   we want to define from_python() and to_python() functions for
-   class MillerIndex.
-
-   Consider the alternatives:
-
-     - Expose MillerIndex as an Extension Class.
-         We need a constructor MillerIndex(python::tuple).
-         Python function calls become more complex:
-           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
-         We need a method such as MillerIndex().as_tuple().
-
-     - Define a wrapper function for each function that we
-       want to expose, e.g.:
-          void add(const IndexingSet& ixset, const python::tuple PyMIx)
-
-   The first alternative introduces a new type that the user has to
-   deal with. Other modules using Miller indices might organize them in
-   different ways, for example to increase runtime efficiency for
-   important procedures. This means, the user has to know how to
-   convert between the different kinds of Miller index representations.
-   This can quickly become a nuisance. Relying on native Python data
-   structures minimizes the number of special types the user has to
-   learn and convert. Of course, this argument is only valid for
-   small and relatively simply classes.
-
-   If there are many member functions with MillerIndex arguments, the
-   second alternative is impractical, and concentrating the conversion
-   mechanism in one central place is essential for code
-   maintainability.  An added benefit is that more convenient (smarter)
-   conversion functions can be provided without cluttering the rest of
-   the wrapper code.
-
- */
-
-#include <string>
-#include <vector>
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // The helper class.
-  //
-  class MillerIndex {
-    public:
-      int v[3];
-  };
-
-  // The main class. Imagine that there are MANY member functions
-  // like add() and get().
-  //
-  class IndexingSet {
-    private:
-      std::vector<MillerIndex> VMIx;
-    public:
-      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
-      MillerIndex get(std::size_t i) const { return VMIx[i]; }
-  };
-}
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-  // Convert a Python tuple to a MillerIndex object.
-  //
-  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
-  {
-    python::tuple tup
-      = python::tuple(python::ref(p, python::ref::increment_count));
-    if (tup.size() != 3) {
-      PyErr_SetString(PyExc_ValueError,
-        "expecting exactly 3 values in tuple.");
-      throw python::error_already_set();
-    }
-    MillerIndex result;
-    for (int i = 0; i < 3; i++)
-      result.v[i] = from_python(tup[i].get(), python::type<int>());
-    return result;
-  }
-
-  // Similar conversion for MillerIndex objects passed by value.
-  // Not actually used, but included to show the principle.
-  //
-  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
-  {
-    return from_python(p, python::type<const MillerIndex&>());
-  }
-
-  // Convert a MillerIndex object to a Python tuple.
-  //
-  PyObject* to_python(const MillerIndex& hkl)
-  {
-    python::tuple result(3);
-    for (int i = 0; i < 3; i++)
-      result.set_item(i, python::ref(to_python(hkl.v[i])));
-    return result.reference().release();
-  }
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("do_it_yourself_converters");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
-
-    // Add the __init__ function.
-    ixset_class.def(python::constructor<>());
-    // Add the member functions.
-    ixset_class.def(&IndexingSet::add, "add");
-    ixset_class.def(&IndexingSet::get, "get");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/dvect.cpp b/example/dvect.cpp
deleted file mode 100644
index da6b35a3..00000000
--- a/example/dvect.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-// See root/libs/python/doc/cross_module.html for an introduction.
-
-#include "dvect.h"
-#include "ivect.h"
-#include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-
-namespace {
-
-# include "dvect_conversions.cpp"
-# include "ivect_conversions.cpp"
-
-  vects::ivect dvect_as_ivect(const vects::dvect& dv)
-  {
-    vects::ivect iv(dv.size());
-    vects::ivect::iterator iviter = iv.begin();
-    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
-    return iv;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(dvect)
-{
-  try
-  {
-    python::module_builder this_module("dvect");
-
-    python::class_builder<vects::dvect> dvect_class(this_module, "dvect");
-    python::export_converters(dvect_class);
-
-    python::import_converters<vects::ivect> ivect_converters("ivect", "ivect");
-
-    dvect_class.def(python::constructor<python::tuple>());
-    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
-    dvect_class.def(dvect_as_ivect, "as_ivect");
-
-# include "dvect_defs.cpp"
-# include "ivect_defs.cpp"
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/ivect.cpp b/example/ivect.cpp
deleted file mode 100644
index db1c0ec3..00000000
--- a/example/ivect.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-// See root/libs/python/doc/cross_module.html for an introduction.
-
-#include "dvect.h"
-#include "ivect.h"
-#include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-
-namespace {
-
-# include "dvect_conversions.cpp"
-# include "ivect_conversions.cpp"
-
-  vects::dvect ivect_as_dvect(const vects::ivect& iv)
-  {
-    vects::dvect dv(iv.size());
-    vects::dvect::iterator dviter = dv.begin();
-    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
-    return dv;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(ivect)
-{
-  try
-  {
-    python::module_builder this_module("ivect");
-
-    python::class_builder<vects::ivect> ivect_class(this_module, "ivect");
-    python::export_converters(ivect_class);
-
-    python::import_converters<vects::dvect> dvect_converters("dvect", "dvect");
-
-    ivect_class.def(python::constructor<python::tuple>());
-    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
-    ivect_class.def(ivect_as_dvect, "as_dvect");
-
-# include "dvect_defs.cpp"
-# include "ivect_defs.cpp"
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
deleted file mode 100644
index 794b1200..00000000
--- a/example/noncopyable_export.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-// See root/libs/python/doc/cross_module.html for an introduction.
-
-#include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-
-#include "noncopyable.h"
-
-BOOST_PYTHON_MODULE_INIT(noncopyable_export)
-{
-  try
-  {
-    python::module_builder this_module("noncopyable_export");
-
-    python::class_builder<store> store_class(this_module, "store");
-    python::export_converters_noncopyable(store_class);
-
-    store_class.def(python::constructor<int>());
-    store_class.def(&store::recall, "recall");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
deleted file mode 100644
index ea2477be..00000000
--- a/example/noncopyable_import.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-// See root/libs/python/doc/cross_module.html for an introduction.
-
-#include <boost/python/cross_module.hpp>
-namespace python = boost::python;
-
-#include "noncopyable.h"
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A function with store objects as both input and output parameters.
-  // Because the copy constructor is disabled, we cannot pass a store
-  // object by value. Instead, we pass a smart pointer.
-  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
-  {
-    int sum = s1.recall() + s2.recall();
-    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
-    return ss;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(noncopyable_import)
-{
-  try
-  {
-    python::module_builder this_module("noncopyable_import");
-
-    python::import_converters<store>
-      dvect_converters("noncopyable_export", "store");
-
-    // Imagine all the additional classes with member functions
-    // that have store objects as input and output parameters.
-    // Lots and lots of them.
-    // However, to keep this example simple, we only define a
-    // module-level function.
-    this_module.def(add_stores, "add_stores");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/pickle1.cpp b/example/pickle1.cpp
deleted file mode 100644
index cdd78989..00000000
--- a/example/pickle1.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-
-/*
-    This example shows how to make an Extension Class "pickleable".
-
-    The world class below can be fully restored by passing the
-    appropriate argument to the constructor. Therefore it is sufficient
-    to define the pickle interface method __getinitargs__.
-
-    For more information refer to boost/libs/python/doc/pickle.html.
- */
-
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    private:
-      std::string country;
-      int secret_number;
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-  };
-
-  // Support for pickle.
-  python::ref world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result.reference();
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(pickle1)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("pickle1");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/pickle2.cpp b/example/pickle2.cpp
deleted file mode 100644
index d6aa3201..00000000
--- a/example/pickle2.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-
-/*
-    This example shows how to make an Extension Class "pickleable".
-
-    The world class below contains member data (secret_number) that
-    cannot be restored by any of the constructors. Therefore it is
-    necessary to provide the __getstate__/__setstate__ pair of pickle
-    interface methods.
-
-    For simplicity, the __dict__ is not included in the result of
-    __getstate__. This is not generally recommended, but a valid
-    approach if it is anticipated that the object's __dict__ will
-    always be empty. Note that safety guard are provided to catch the
-    cases where this assumption is not true.
-
-    pickle3.cpp shows how to include the object's __dict__ in the
-    result of __getstate__.
-
-    For more information refer to boost/libs/python/doc/pickle.html.
- */
-
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-      void set_secret_number(int number) { secret_number = number; }
-      int get_secret_number() const { return secret_number; }
-    private:
-      std::string country;
-      int secret_number;
-  };
-
-  // Support for pickle.
-
-  using BOOST_PYTHON_CONVERSION::from_python;
-
-  python::ref world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  python::ref world_getstate(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_secret_number());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  void world_setstate(world& w, python::tuple state) {
-    if (state.size() != 1) {
-      PyErr_SetString(PyExc_ValueError,
-        "Unexpected argument in call to __setstate__.");
-      throw python::error_already_set();
-    }
-    int number = from_python(state[0].get(), python::type<int>());
-    if (number != 42)
-      w.set_secret_number(number);
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(pickle2)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("pickle2");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-    world_class.def(&world::get_secret_number, "get_secret_number");
-    world_class.def(&world::set_secret_number, "set_secret_number");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-    world_class.def(world_getstate, "__getstate__");
-    world_class.def(world_setstate, "__setstate__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
deleted file mode 100644
index bfa7dc54..00000000
--- a/example/pickle3.cpp
+++ /dev/null
@@ -1,150 +0,0 @@
-// Example by Ralf W. Grosse-Kunstleve
-
-/*
-    This example shows how to make an Extension Class "pickleable".
-
-    The world class below contains member data (secret_number) that
-    cannot be restored by any of the constructors. Therefore it is
-    necessary to provide the __getstate__/__setstate__ pair of pickle
-    interface methods.
-
-    The object's __dict__ is included in the result of __getstate__.
-    This requires more code (compare with pickle2.cpp), but is
-    unavoidable if the object's __dict__ is not always empty.
-
-    For more information refer to boost/libs/python/doc/pickle.html.
- */
-
-#include <string>
-
-#include <boost/python/class_builder.hpp>
-namespace python = boost::python;
-
-namespace boost { namespace python {
-
-  ref getattr(PyObject* o, const std::string& attr_name) {
-    return ref(PyObject_GetAttrString(o, const_cast<char*>(attr_name.c_str())));
-  }
-  ref getattr(const ref& r, const std::string& attr_name) {
-    return getattr(r.get(), attr_name);
-  }
-
-}}
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    public:
-      world(const std::string& country) : secret_number(0) {
-        this->country = country;
-      }
-      std::string greet() const { return "Hello from " + country + "!"; }
-      std::string get_country() const { return country; }
-      void set_secret_number(int number) { secret_number = number; }
-      int get_secret_number() const { return secret_number; }
-    private:
-      std::string country;
-      int secret_number;
-  };
-
-  // Support for pickle.
-  python::ref world_getinitargs(const world& w) {
-      python::tuple result(1);
-      result.set_item(0, w.get_country());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  python::ref world_getstate(python::tuple const & args,
-                             python::dictionary const & keywords);
-
-  PyObject* world_setstate(python::tuple const & args,
-                           python::dictionary const & keywords);
-}
-
-BOOST_PYTHON_MODULE_INIT(pickle3)
-{
-  try
-  {
-    // Create an object representing this extension module.
-    python::module_builder this_module("pickle3");
-
-    // Create the Python type object for our extension class.
-    python::class_builder<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(python::constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-    world_class.def(&world::get_secret_number, "get_secret_number");
-    world_class.def(&world::set_secret_number, "set_secret_number");
-
-    // Support for pickle.
-    world_class.def(world_getinitargs, "__getinitargs__");
-    world_class.def_raw(world_getstate, "__getstate__");
-    world_class.def_raw(world_setstate, "__setstate__");
-    world_class.getstate_manages_dict();
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
-}
-
-namespace {
-
-  using BOOST_PYTHON_CONVERSION::from_python;
-  using boost::python::type;
-  using boost::python::ref;
-  using boost::python::tuple;
-  using boost::python::list;
-  using boost::python::dictionary;
-  using boost::python::getattr;
-
-  ref world_getstate(tuple const & args, dictionary const & keywords)
-  {
-      if(args.size() != 1 || keywords.size() != 0) {
-          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
-      }
-      const world& w = from_python(args[0].get(), type<const world&>());
-      ref mydict = getattr(args[0], "__dict__");
-      tuple result(2);
-      // store the object's __dict__
-      result.set_item(0, mydict);
-      // store the internal state of the C++ object
-      result.set_item(1, w.get_secret_number());
-      return result.reference(); // returning the reference avoids the copying.
-  }
-
-  PyObject* world_setstate(tuple const & args, dictionary const & keywords)
-  {
-      if(args.size() != 2 || keywords.size() != 0) {
-          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
-      }
-      world& w = from_python(args[0].get(), type<world&>());
-      ref mydict = getattr(args[0], "__dict__");
-      tuple state = from_python(args[1].get(), type<tuple>());
-      if (state.size() != 2) {
-        PyErr_SetString(PyExc_ValueError,
-          "Unexpected argument in call to __setstate__.");
-        throw python::error_already_set();
-      }
-      // restore the object's __dict__
-      dictionary odict = from_python(mydict.get(), type<dictionary>());
-      const dictionary& pdict = from_python(state[0].get(), type<const dictionary&>());
-      list pkeys(pdict.keys());
-      for (int i = 0; i < pkeys.size(); i++) {
-        ref k(pkeys[i]);
-        //odict[k] = pdict[k]; // XXX memory leak!
-        odict[k] = pdict.get_item(k); // this does not leak.
-      }
-      // restore the internal state of the C++ object
-      int number = from_python(state[1].get(), type<int>());
-      if (number != 42)
-        w.set_secret_number(number);
-      return python::detail::none();
-  }
-}
diff --git a/example/tst_dvect1.py b/example/tst_dvect1.py
deleted file mode 100644
index 22315528..00000000
--- a/example/tst_dvect1.py
+++ /dev/null
@@ -1,20 +0,0 @@
-def f():
-  import dvect
-  dv = dvect.dvect((1,2,3,4,5))
-  print dv.as_tuple()
-  iv = dv.as_ivect()
-  print iv.as_tuple()
-  print dvect.const_ivect_reference_as_tuple(iv)
-  aiv = dvect.ivect_as_auto_ptr(iv)
-  print dvect.const_ivect_reference_as_tuple(aiv)
-  siv = dvect.ivect_as_shared_ptr(iv)
-  print dvect.const_ivect_reference_as_tuple(siv)
-  print aiv.as_tuple()
-  print siv.as_tuple()
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()
diff --git a/example/tst_ivect1.py b/example/tst_ivect1.py
deleted file mode 100644
index 7369fdbf..00000000
--- a/example/tst_ivect1.py
+++ /dev/null
@@ -1,20 +0,0 @@
-def f():
-  import ivect
-  iv = ivect.ivect((1,2,3,4,5))
-  print iv.as_tuple()
-  dv = iv.as_dvect()
-  print dv.as_tuple()
-  print ivect.const_dvect_reference_as_tuple(dv)
-  adv = ivect.dvect_as_auto_ptr(dv)
-  print ivect.const_dvect_reference_as_tuple(adv)
-  sdv = ivect.dvect_as_shared_ptr(dv)
-  print ivect.const_dvect_reference_as_tuple(sdv)
-  print adv.as_tuple()
-  print sdv.as_tuple()
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()
diff --git a/example/tst_noncopyable.py b/example/tst_noncopyable.py
deleted file mode 100644
index 155910a5..00000000
--- a/example/tst_noncopyable.py
+++ /dev/null
@@ -1,16 +0,0 @@
-def f():
-  import noncopyable_export
-  import noncopyable_import
-  s1 = noncopyable_export.store(1)
-  print s1.recall()
-  s2 = noncopyable_export.store(2)
-  print s2.recall()
-  s3 = noncopyable_import.add_stores(s1, s2)
-  print s3.recall()
-
-if (__name__ == "__main__"):
-  import sys, string
-  n = 1
-  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
-  for i in xrange(n):
-    f()

From cbff11296bcbf7c486019db142cc9ba46560b20a Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 18 Apr 2001 01:29:23 +0000
Subject: [PATCH 099/369] cleaning up cvs attic mess

[SVN r9831]
---
 example/do_it_yourself_converters.cpp | 128 ++++++++++++++++++++++
 example/dvect.cpp                     |  45 ++++++++
 example/ivect.cpp                     |  45 ++++++++
 example/noncopyable_export.cpp        |  25 +++++
 example/noncopyable_import.cpp        |  42 ++++++++
 example/pickle1.cpp                   |  64 +++++++++++
 example/pickle2.cpp                   | 100 +++++++++++++++++
 example/pickle3.cpp                   | 150 ++++++++++++++++++++++++++
 example/tst_dvect1.py                 |  20 ++++
 example/tst_ivect1.py                 |  20 ++++
 example/tst_noncopyable.py            |  16 +++
 11 files changed, 655 insertions(+)
 create mode 100644 example/do_it_yourself_converters.cpp
 create mode 100644 example/dvect.cpp
 create mode 100644 example/ivect.cpp
 create mode 100644 example/noncopyable_export.cpp
 create mode 100644 example/noncopyable_import.cpp
 create mode 100644 example/pickle1.cpp
 create mode 100644 example/pickle2.cpp
 create mode 100644 example/pickle3.cpp
 create mode 100644 example/tst_dvect1.py
 create mode 100644 example/tst_ivect1.py
 create mode 100644 example/tst_noncopyable.py

diff --git a/example/do_it_yourself_converters.cpp b/example/do_it_yourself_converters.cpp
new file mode 100644
index 00000000..6d2d2d6a
--- /dev/null
+++ b/example/do_it_yourself_converters.cpp
@@ -0,0 +1,128 @@
+// Example by Ralf W. Grosse-Kunstleve
+/*
+
+   This example shows how to convert a class from and to native
+   Python objects, such as tuples.
+
+   We do not want to expose the helper class MillerIndex as an
+   Extension Class. However, in order to simplify the wrapper code,
+   we want to define from_python() and to_python() functions for
+   class MillerIndex.
+
+   Consider the alternatives:
+
+     - Expose MillerIndex as an Extension Class.
+         We need a constructor MillerIndex(python::tuple).
+         Python function calls become more complex:
+           foo(MillerIndex((1,2,3)) instead of foo((1,2,3))
+         We need a method such as MillerIndex().as_tuple().
+
+     - Define a wrapper function for each function that we
+       want to expose, e.g.:
+          void add(const IndexingSet& ixset, const python::tuple PyMIx)
+
+   The first alternative introduces a new type that the user has to
+   deal with. Other modules using Miller indices might organize them in
+   different ways, for example to increase runtime efficiency for
+   important procedures. This means, the user has to know how to
+   convert between the different kinds of Miller index representations.
+   This can quickly become a nuisance. Relying on native Python data
+   structures minimizes the number of special types the user has to
+   learn and convert. Of course, this argument is only valid for
+   small and relatively simply classes.
+
+   If there are many member functions with MillerIndex arguments, the
+   second alternative is impractical, and concentrating the conversion
+   mechanism in one central place is essential for code
+   maintainability.  An added benefit is that more convenient (smarter)
+   conversion functions can be provided without cluttering the rest of
+   the wrapper code.
+
+ */
+
+#include <string>
+#include <vector>
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // The helper class.
+  //
+  class MillerIndex {
+    public:
+      int v[3];
+  };
+
+  // The main class. Imagine that there are MANY member functions
+  // like add() and get().
+  //
+  class IndexingSet {
+    private:
+      std::vector<MillerIndex> VMIx;
+    public:
+      void add(const MillerIndex& MIx) { VMIx.push_back(MIx); }
+      MillerIndex get(std::size_t i) const { return VMIx[i]; }
+  };
+}
+
+BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+
+  // Convert a Python tuple to a MillerIndex object.
+  //
+  MillerIndex from_python(PyObject* p, python::type<const MillerIndex&>)
+  {
+    python::tuple tup
+      = python::tuple(python::ref(p, python::ref::increment_count));
+    if (tup.size() != 3) {
+      PyErr_SetString(PyExc_ValueError,
+        "expecting exactly 3 values in tuple.");
+      throw python::error_already_set();
+    }
+    MillerIndex result;
+    for (int i = 0; i < 3; i++)
+      result.v[i] = from_python(tup[i].get(), python::type<int>());
+    return result;
+  }
+
+  // Similar conversion for MillerIndex objects passed by value.
+  // Not actually used, but included to show the principle.
+  //
+  MillerIndex from_python(PyObject* p, python::type<MillerIndex>)
+  {
+    return from_python(p, python::type<const MillerIndex&>());
+  }
+
+  // Convert a MillerIndex object to a Python tuple.
+  //
+  PyObject* to_python(const MillerIndex& hkl)
+  {
+    python::tuple result(3);
+    for (int i = 0; i < 3; i++)
+      result.set_item(i, python::ref(to_python(hkl.v[i])));
+    return result.reference().release();
+  }
+
+BOOST_PYTHON_END_CONVERSION_NAMESPACE
+
+BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("do_it_yourself_converters");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
+
+    // Add the __init__ function.
+    ixset_class.def(python::constructor<>());
+    // Add the member functions.
+    ixset_class.def(&IndexingSet::add, "add");
+    ixset_class.def(&IndexingSet::get, "get");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/dvect.cpp b/example/dvect.cpp
new file mode 100644
index 00000000..da6b35a3
--- /dev/null
+++ b/example/dvect.cpp
@@ -0,0 +1,45 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include "dvect.h"
+#include "ivect.h"
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+namespace {
+
+# include "dvect_conversions.cpp"
+# include "ivect_conversions.cpp"
+
+  vects::ivect dvect_as_ivect(const vects::dvect& dv)
+  {
+    vects::ivect iv(dv.size());
+    vects::ivect::iterator iviter = iv.begin();
+    for (int i = 0; i < dv.size(); i++) iviter[i] = static_cast<int>(dv[i]);
+    return iv;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(dvect)
+{
+  try
+  {
+    python::module_builder this_module("dvect");
+
+    python::class_builder<vects::dvect> dvect_class(this_module, "dvect");
+    python::export_converters(dvect_class);
+
+    python::import_converters<vects::ivect> ivect_converters("ivect", "ivect");
+
+    dvect_class.def(python::constructor<python::tuple>());
+    dvect_class.def(&vects::dvect::as_tuple, "as_tuple");
+    dvect_class.def(dvect_as_ivect, "as_ivect");
+
+# include "dvect_defs.cpp"
+# include "ivect_defs.cpp"
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/ivect.cpp b/example/ivect.cpp
new file mode 100644
index 00000000..db1c0ec3
--- /dev/null
+++ b/example/ivect.cpp
@@ -0,0 +1,45 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include "dvect.h"
+#include "ivect.h"
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+namespace {
+
+# include "dvect_conversions.cpp"
+# include "ivect_conversions.cpp"
+
+  vects::dvect ivect_as_dvect(const vects::ivect& iv)
+  {
+    vects::dvect dv(iv.size());
+    vects::dvect::iterator dviter = dv.begin();
+    for (int i = 0; i < iv.size(); i++) dviter[i] = static_cast<double>(iv[i]);
+    return dv;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(ivect)
+{
+  try
+  {
+    python::module_builder this_module("ivect");
+
+    python::class_builder<vects::ivect> ivect_class(this_module, "ivect");
+    python::export_converters(ivect_class);
+
+    python::import_converters<vects::dvect> dvect_converters("dvect", "dvect");
+
+    ivect_class.def(python::constructor<python::tuple>());
+    ivect_class.def(&vects::ivect::as_tuple, "as_tuple");
+    ivect_class.def(ivect_as_dvect, "as_dvect");
+
+# include "dvect_defs.cpp"
+# include "ivect_defs.cpp"
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
new file mode 100644
index 00000000..794b1200
--- /dev/null
+++ b/example/noncopyable_export.cpp
@@ -0,0 +1,25 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+BOOST_PYTHON_MODULE_INIT(noncopyable_export)
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_export");
+
+    python::class_builder<store> store_class(this_module, "store");
+    python::export_converters_noncopyable(store_class);
+
+    store_class.def(python::constructor<int>());
+    store_class.def(&store::recall, "recall");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
new file mode 100644
index 00000000..ea2477be
--- /dev/null
+++ b/example/noncopyable_import.cpp
@@ -0,0 +1,42 @@
+// Example by Ralf W. Grosse-Kunstleve
+// See root/libs/python/doc/cross_module.html for an introduction.
+
+#include <boost/python/cross_module.hpp>
+namespace python = boost::python;
+
+#include "noncopyable.h"
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A function with store objects as both input and output parameters.
+  // Because the copy constructor is disabled, we cannot pass a store
+  // object by value. Instead, we pass a smart pointer.
+  std::auto_ptr<store> add_stores(const store& s1, const store& s2)
+  {
+    int sum = s1.recall() + s2.recall();
+    std::auto_ptr<store> ss = std::auto_ptr<store>(new store(sum));
+    return ss;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(noncopyable_import)
+{
+  try
+  {
+    python::module_builder this_module("noncopyable_import");
+
+    python::import_converters<store>
+      dvect_converters("noncopyable_export", "store");
+
+    // Imagine all the additional classes with member functions
+    // that have store objects as input and output parameters.
+    // Lots and lots of them.
+    // However, to keep this example simple, we only define a
+    // module-level function.
+    this_module.def(add_stores, "add_stores");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle1.cpp b/example/pickle1.cpp
new file mode 100644
index 00000000..cdd78989
--- /dev/null
+++ b/example/pickle1.cpp
@@ -0,0 +1,64 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below can be fully restored by passing the
+    appropriate argument to the constructor. Therefore it is sufficient
+    to define the pickle interface method __getinitargs__.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    private:
+      std::string country;
+      int secret_number;
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference();
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle1)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle1");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle2.cpp b/example/pickle2.cpp
new file mode 100644
index 00000000..d6aa3201
--- /dev/null
+++ b/example/pickle2.cpp
@@ -0,0 +1,100 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below contains member data (secret_number) that
+    cannot be restored by any of the constructors. Therefore it is
+    necessary to provide the __getstate__/__setstate__ pair of pickle
+    interface methods.
+
+    For simplicity, the __dict__ is not included in the result of
+    __getstate__. This is not generally recommended, but a valid
+    approach if it is anticipated that the object's __dict__ will
+    always be empty. Note that safety guard are provided to catch the
+    cases where this assumption is not true.
+
+    pickle3.cpp shows how to include the object's __dict__ in the
+    result of __getstate__.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+
+  using BOOST_PYTHON_CONVERSION::from_python;
+
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  void world_setstate(world& w, python::tuple state) {
+    if (state.size() != 1) {
+      PyErr_SetString(PyExc_ValueError,
+        "Unexpected argument in call to __setstate__.");
+      throw python::error_already_set();
+    }
+    int number = from_python(state[0].get(), python::type<int>());
+    if (number != 42)
+      w.set_secret_number(number);
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle2)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle2");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def(world_getstate, "__getstate__");
+    world_class.def(world_setstate, "__setstate__");
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
new file mode 100644
index 00000000..bfa7dc54
--- /dev/null
+++ b/example/pickle3.cpp
@@ -0,0 +1,150 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how to make an Extension Class "pickleable".
+
+    The world class below contains member data (secret_number) that
+    cannot be restored by any of the constructors. Therefore it is
+    necessary to provide the __getstate__/__setstate__ pair of pickle
+    interface methods.
+
+    The object's __dict__ is included in the result of __getstate__.
+    This requires more code (compare with pickle2.cpp), but is
+    unavoidable if the object's __dict__ is not always empty.
+
+    For more information refer to boost/libs/python/doc/pickle.html.
+ */
+
+#include <string>
+
+#include <boost/python/class_builder.hpp>
+namespace python = boost::python;
+
+namespace boost { namespace python {
+
+  ref getattr(PyObject* o, const std::string& attr_name) {
+    return ref(PyObject_GetAttrString(o, const_cast<char*>(attr_name.c_str())));
+  }
+  ref getattr(const ref& r, const std::string& attr_name) {
+    return getattr(r.get(), attr_name);
+  }
+
+}}
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    public:
+      world(const std::string& country) : secret_number(0) {
+        this->country = country;
+      }
+      std::string greet() const { return "Hello from " + country + "!"; }
+      std::string get_country() const { return country; }
+      void set_secret_number(int number) { secret_number = number; }
+      int get_secret_number() const { return secret_number; }
+    private:
+      std::string country;
+      int secret_number;
+  };
+
+  // Support for pickle.
+  python::ref world_getinitargs(const world& w) {
+      python::tuple result(1);
+      result.set_item(0, w.get_country());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  python::ref world_getstate(python::tuple const & args,
+                             python::dictionary const & keywords);
+
+  PyObject* world_setstate(python::tuple const & args,
+                           python::dictionary const & keywords);
+}
+
+BOOST_PYTHON_MODULE_INIT(pickle3)
+{
+  try
+  {
+    // Create an object representing this extension module.
+    python::module_builder this_module("pickle3");
+
+    // Create the Python type object for our extension class.
+    python::class_builder<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(python::constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+    world_class.def(&world::get_secret_number, "get_secret_number");
+    world_class.def(&world::set_secret_number, "set_secret_number");
+
+    // Support for pickle.
+    world_class.def(world_getinitargs, "__getinitargs__");
+    world_class.def_raw(world_getstate, "__getstate__");
+    world_class.def_raw(world_setstate, "__setstate__");
+    world_class.getstate_manages_dict();
+  }
+  catch(...)
+  {
+    python::handle_exception(); // Deal with the exception for Python
+  }
+}
+
+namespace {
+
+  using BOOST_PYTHON_CONVERSION::from_python;
+  using boost::python::type;
+  using boost::python::ref;
+  using boost::python::tuple;
+  using boost::python::list;
+  using boost::python::dictionary;
+  using boost::python::getattr;
+
+  ref world_getstate(tuple const & args, dictionary const & keywords)
+  {
+      if(args.size() != 1 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::argument_error();
+      }
+      const world& w = from_python(args[0].get(), type<const world&>());
+      ref mydict = getattr(args[0], "__dict__");
+      tuple result(2);
+      // store the object's __dict__
+      result.set_item(0, mydict);
+      // store the internal state of the C++ object
+      result.set_item(1, w.get_secret_number());
+      return result.reference(); // returning the reference avoids the copying.
+  }
+
+  PyObject* world_setstate(tuple const & args, dictionary const & keywords)
+  {
+      if(args.size() != 2 || keywords.size() != 0) {
+          PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
+          throw boost::python::argument_error();
+      }
+      world& w = from_python(args[0].get(), type<world&>());
+      ref mydict = getattr(args[0], "__dict__");
+      tuple state = from_python(args[1].get(), type<tuple>());
+      if (state.size() != 2) {
+        PyErr_SetString(PyExc_ValueError,
+          "Unexpected argument in call to __setstate__.");
+        throw python::error_already_set();
+      }
+      // restore the object's __dict__
+      dictionary odict = from_python(mydict.get(), type<dictionary>());
+      const dictionary& pdict = from_python(state[0].get(), type<const dictionary&>());
+      list pkeys(pdict.keys());
+      for (int i = 0; i < pkeys.size(); i++) {
+        ref k(pkeys[i]);
+        //odict[k] = pdict[k]; // XXX memory leak!
+        odict[k] = pdict.get_item(k); // this does not leak.
+      }
+      // restore the internal state of the C++ object
+      int number = from_python(state[1].get(), type<int>());
+      if (number != 42)
+        w.set_secret_number(number);
+      return python::detail::none();
+  }
+}
diff --git a/example/tst_dvect1.py b/example/tst_dvect1.py
new file mode 100644
index 00000000..22315528
--- /dev/null
+++ b/example/tst_dvect1.py
@@ -0,0 +1,20 @@
+def f():
+  import dvect
+  dv = dvect.dvect((1,2,3,4,5))
+  print dv.as_tuple()
+  iv = dv.as_ivect()
+  print iv.as_tuple()
+  print dvect.const_ivect_reference_as_tuple(iv)
+  aiv = dvect.ivect_as_auto_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(aiv)
+  siv = dvect.ivect_as_shared_ptr(iv)
+  print dvect.const_ivect_reference_as_tuple(siv)
+  print aiv.as_tuple()
+  print siv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_ivect1.py b/example/tst_ivect1.py
new file mode 100644
index 00000000..7369fdbf
--- /dev/null
+++ b/example/tst_ivect1.py
@@ -0,0 +1,20 @@
+def f():
+  import ivect
+  iv = ivect.ivect((1,2,3,4,5))
+  print iv.as_tuple()
+  dv = iv.as_dvect()
+  print dv.as_tuple()
+  print ivect.const_dvect_reference_as_tuple(dv)
+  adv = ivect.dvect_as_auto_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(adv)
+  sdv = ivect.dvect_as_shared_ptr(dv)
+  print ivect.const_dvect_reference_as_tuple(sdv)
+  print adv.as_tuple()
+  print sdv.as_tuple()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()
diff --git a/example/tst_noncopyable.py b/example/tst_noncopyable.py
new file mode 100644
index 00000000..155910a5
--- /dev/null
+++ b/example/tst_noncopyable.py
@@ -0,0 +1,16 @@
+def f():
+  import noncopyable_export
+  import noncopyable_import
+  s1 = noncopyable_export.store(1)
+  print s1.recall()
+  s2 = noncopyable_export.store(2)
+  print s2.recall()
+  s3 = noncopyable_import.add_stores(s1, s2)
+  print s3.recall()
+
+if (__name__ == "__main__"):
+  import sys, string
+  n = 1
+  if (len(sys.argv) > 1): n = string.atoi(sys.argv[1])
+  for i in xrange(n):
+    f()

From 349b9bb2bf2f5dbc9b2365752b4d516d4ed62147 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 18 Apr 2001 19:13:11 +0000
Subject: [PATCH 100/369] use reserved symbol for detecting sgi

[SVN r9835]
---
 test/comprehensive.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index aa2d9886..410bd243 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -15,7 +15,7 @@
 #include <math.h>  // for pow()
 #include <boost/rational.hpp>
 
-#if defined(sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
 inline double pow(int x, int y) { return pow(static_cast<double>(x), y); }
 #endif
 

From fb8d9edfdfda1999bffd73c3e3dcb9cd626a039b Mon Sep 17 00:00:00 2001
From: Beman Dawes <bdawes@acm.org>
Date: Wed, 25 Apr 2001 00:24:50 +0000
Subject: [PATCH 101/369] Change all eGroups references to YahooGroups

[SVN r9979]
---
 doc/index.html | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/doc/index.html b/doc/index.html
index 5ec32a6b..f636e7a8 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -1,6 +1,5 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
 "http://www.w3.org/TR/REC-html40/strict.dtd">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
     <title>
       The Boost Python Library (Boost.Python)
     </title>
@@ -154,7 +153,7 @@ among others.
 
     <p>
        Questions should be directed to <a href= 
-      "http://www.egroups.com/list/boost">the boost mailing list</a>.
+      "http://www.yahoogroups.com/list/boost">the boost mailing list</a>.
 
     <p>
        &copy; Copyright David Abrahams 2001. Permission to copy, use, modify,

From 00b4f09e8abc953f106663bf316bad837af4ec82 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 5 May 2001 01:06:33 +0000
Subject: [PATCH 102/369] Check indices passed to __getitem__, __setitem__,
 __delitem__

[SVN r10009]
---
 build/irix_CC.mak             | 2 +-
 example/simple_vector.cpp     | 8 ++++++++
 example/test_simple_vector.py | 5 +++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index 5894ff51..0436ef8a 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -24,7 +24,7 @@ PYINC=-I/usr/local/Python-1.5.2/include/python1.5
 STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
 STDOPTS=
-WARNOPTS=-woff 1001,1234,1682
+WARNOPTS=-woff 1001,1183,1234,1682
 OPTOPTS=-g
 
 CPP=CC -LANG:std -n32 -mips4
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
index 5ac0767b..8f30121b 100644
--- a/example/simple_vector.cpp
+++ b/example/simple_vector.cpp
@@ -30,16 +30,24 @@ namespace { // Avoid cluttering the global namespace.
     }
   };
 
+  void raise_vector_IndexError() {
+    PyErr_SetString(PyExc_IndexError, "IndexError: vector index out of range");
+    throw python::error_already_set();
+  }
+
   double getitem(const std::vector<double>& vd, std::size_t key) {
+    if (key < 0 || key >= vd.size()) raise_vector_IndexError();
     return vd[key];
   }
 
   void setitem(std::vector<double>& vd, std::size_t key, double d) {
+    if (key < 0 || key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
     vditer[key] = d;
   }
 
   void delitem(std::vector<double>& vd, std::size_t key) {
+    if (key < 0 || key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
     vd.erase(&vditer[key]);
   }
diff --git a/example/test_simple_vector.py b/example/test_simple_vector.py
index a19e205b..ca38d715 100644
--- a/example/test_simple_vector.py
+++ b/example/test_simple_vector.py
@@ -15,6 +15,11 @@ r'''>>> import simple_vector
     >>> v[1] = 40
     >>> print v.as_tuple()
     (3.0, 40.0, 5.0)
+    >>> for e in v:
+    ...   print e
+    3.0
+    40.0
+    5.0
     >>> del v[1]
     >>> print v.as_tuple()
     (3.0, 5.0)

From 25320cd0e02bb14b058fa51fc2e2bc6e29000435 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Mon, 14 May 2001 21:43:34 +0000
Subject: [PATCH 103/369] Removed: unnecessary key < 0 test.

[SVN r10113]
---
 build/irix_CC.mak         | 2 +-
 example/simple_vector.cpp | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index 0436ef8a..5894ff51 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -24,7 +24,7 @@ PYINC=-I/usr/local/Python-1.5.2/include/python1.5
 STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
 STDOPTS=
-WARNOPTS=-woff 1001,1183,1234,1682
+WARNOPTS=-woff 1001,1234,1682
 OPTOPTS=-g
 
 CPP=CC -LANG:std -n32 -mips4
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
index 8f30121b..2b3aa290 100644
--- a/example/simple_vector.cpp
+++ b/example/simple_vector.cpp
@@ -31,23 +31,23 @@ namespace { // Avoid cluttering the global namespace.
   };
 
   void raise_vector_IndexError() {
-    PyErr_SetString(PyExc_IndexError, "IndexError: vector index out of range");
+    PyErr_SetString(PyExc_IndexError, "vector index out of range");
     throw python::error_already_set();
   }
 
   double getitem(const std::vector<double>& vd, std::size_t key) {
-    if (key < 0 || key >= vd.size()) raise_vector_IndexError();
+    if (key >= vd.size()) raise_vector_IndexError();
     return vd[key];
   }
 
   void setitem(std::vector<double>& vd, std::size_t key, double d) {
-    if (key < 0 || key >= vd.size()) raise_vector_IndexError();
+    if (key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
     vditer[key] = d;
   }
 
   void delitem(std::vector<double>& vd, std::size_t key) {
-    if (key < 0 || key >= vd.size()) raise_vector_IndexError();
+    if (key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
     vd.erase(&vditer[key]);
   }

From d04f613c419c0b726d6f5d28b5e48d9ee3dff4e4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 18 May 2001 15:12:30 +0000
Subject: [PATCH 104/369] Fix up internal links

[SVN r10122]
---
 doc/overriding.html | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/overriding.html b/doc/overriding.html
index af458d79..02665be5 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -47,17 +47,17 @@ class hello
   <code>PyObject*</code> argument. The initial argument should be stored in the <tt>self</tt> data
   member described above. 
 
-  <li>If the class being wrapped is ever returned <i>by
+  <li><a name="derived_3">If</a> the class being wrapped is ever returned <i>by
   value</i> from a wrapped function, be sure you do the same for the
   <tt>T</tt>'s copy constructor: you'll need a constructor taking arguments
   <tt>(PyObject*,&nbsp;const&nbsp;T&amp;)</tt>.
 
-  <li><a name="derived_3">An</a> implementation of each virtual function you may
+  <li><a name="derived_4">An</a> implementation of each virtual function you may
   wish to override in Python which uses
   <tt>callback&lt</tt><i>return-type</i><tt>&gt;::call_method(self,&nbsp;&quot;</tt><i>name</i><tt>&quot;,&nbsp;</tt><i>args...</i><tt>)</tt> to call
   the Python override.
 
-  <li><a name="derived_4">For</a> each non-pure virtual function meant to be
+  <li><a name="derived_5">For</a> each non-pure virtual function meant to be
   overridable from Python, a static member function (or a free function) taking
   a reference or pointer to the <tt>T</tt> as the first parameter and which
   forwards any additional parameters neccessary to the <i>default</i>
@@ -211,5 +211,5 @@ href="http://cs.calvin.edu/c++/C++Standard-Nov97/basic.html#basic.def.odr">ODR</
       express or implied warranty, and with no claim as to its suitability for
       any purpose.
     <p>
-      Updated: Mar 6, 2001
+      Updated: Mar 21, 2001
 

From 188597ecaf2968d6811d0272dc4cbc09e8d77023 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 24 May 2001 08:28:46 +0000
Subject: [PATCH 105/369] fixes tested with vc60, tru64cxx, irixCC, gcc2952

[SVN r10208]
---
 include/boost/python/callback.hpp      | 440 ++++++++++++-------------
 include/boost/python/caller.hpp        |  68 ++--
 include/boost/python/detail/config.hpp |  23 +-
 3 files changed, 264 insertions(+), 267 deletions(-)

diff --git a/include/boost/python/callback.hpp b/include/boost/python/callback.hpp
index 7240b5b7..b9e850c6 100644
--- a/include/boost/python/callback.hpp
+++ b/include/boost/python/callback.hpp
@@ -46,7 +46,7 @@ struct callback
     template <class A1>
     static R call_method(PyObject* self, const char* name, const A1& a1)
     {
-        ref p1(to_python(a1));
+        ref p1(to_python(search_namespace, a1));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(O)"),
                                      p1.get()));
@@ -57,7 +57,7 @@ struct callback
     template <class A1>
     static R call(PyObject* self, const A1& a1)
     {
-        ref p1(to_python(a1));
+        ref p1(to_python(search_namespace, a1));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
                                        p1.get()));
         detail::callback_adjust_refcount(result.get(), type<R>());
@@ -67,8 +67,8 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OO)"),
                                      p1.get(),
@@ -80,8 +80,8 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
                                        p1.get(),
                                        p2.get()));
@@ -92,9 +92,9 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOO)"),
                                      p1.get(),
@@ -107,9 +107,9 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -121,10 +121,10 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOO)"),
                                      p1.get(),
@@ -138,10 +138,10 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -154,11 +154,11 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOO)"),
                                      p1.get(),
@@ -173,11 +173,11 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -191,12 +191,12 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOO)"),
                                      p1.get(),
@@ -212,12 +212,12 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -232,13 +232,13 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOO)"),
                                      p1.get(),
@@ -255,13 +255,13 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -277,14 +277,14 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOO)"),
                                      p1.get(),
@@ -302,14 +302,14 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -326,15 +326,15 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOO)"),
                                      p1.get(),
@@ -353,15 +353,15 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -379,16 +379,16 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
+        ref p10(to_python(search_namespace, a10));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOOO)"),
                                      p1.get(),
@@ -408,16 +408,16 @@ struct callback
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
+        ref p10(to_python(search_namespace, a10));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -455,7 +455,7 @@ struct callback<void>
     template <class A1>
     static void call_method(PyObject* self, const char* name, const A1& a1)
     {
-        ref p1(to_python(a1));
+        ref p1(to_python(search_namespace, a1));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(O)"),
                                      p1.get()));
@@ -464,7 +464,7 @@ struct callback<void>
     template <class A1>
     static void call(PyObject* self, const A1& a1)
     {
-        ref p1(to_python(a1));
+        ref p1(to_python(search_namespace, a1));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
                                        p1.get()));
     }
@@ -472,8 +472,8 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OO)"),
                                      p1.get(),
@@ -483,8 +483,8 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
                                        p1.get(),
                                        p2.get()));
@@ -493,9 +493,9 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOO)"),
                                      p1.get(),
@@ -506,9 +506,9 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -518,10 +518,10 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOO)"),
                                      p1.get(),
@@ -533,10 +533,10 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -547,11 +547,11 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOO)"),
                                      p1.get(),
@@ -564,11 +564,11 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -580,12 +580,12 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOO)"),
                                      p1.get(),
@@ -599,12 +599,12 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -617,13 +617,13 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOO)"),
                                      p1.get(),
@@ -638,13 +638,13 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -658,14 +658,14 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOO)"),
                                      p1.get(),
@@ -681,14 +681,14 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -703,15 +703,15 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOO)"),
                                      p1.get(),
@@ -728,15 +728,15 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
@@ -752,16 +752,16 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
+        ref p10(to_python(search_namespace, a10));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(OOOOOOOOOO)"),
                                      p1.get(),
@@ -779,16 +779,16 @@ struct callback<void>
     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 p1(to_python(search_namespace, a1));
+        ref p2(to_python(search_namespace, a2));
+        ref p3(to_python(search_namespace, a3));
+        ref p4(to_python(search_namespace, a4));
+        ref p5(to_python(search_namespace, a5));
+        ref p6(to_python(search_namespace, a6));
+        ref p7(to_python(search_namespace, a7));
+        ref p8(to_python(search_namespace, a8));
+        ref p9(to_python(search_namespace, a9));
+        ref p10(to_python(search_namespace, a10));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
                                        p1.get(),
                                        p2.get(),
diff --git a/include/boost/python/caller.hpp b/include/boost/python/caller.hpp
index 35b2d618..86820233 100644
--- a/include/boost/python/caller.hpp
+++ b/include/boost/python/caller.hpp
@@ -30,7 +30,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)());
+        return to_python(search_namespace, (target.*pmf)());
     }
 
     template <class T, class A1>
@@ -40,7 +40,7 @@ struct caller
         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>())));
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>())));
     }
 
     template <class T, class A1, class A2>
@@ -51,7 +51,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>())));
     }
 
@@ -64,7 +64,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>())));
     }
@@ -79,7 +79,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>())));
@@ -96,7 +96,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -115,7 +115,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -136,7 +136,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -159,7 +159,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -184,7 +184,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -211,7 +211,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -230,7 +230,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python((target.*pmf)());
+        return to_python(search_namespace, (target.*pmf)());
     }
 
     template <class T, class A1>
@@ -240,7 +240,7 @@ struct caller
         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>())));
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>())));
     }
 
     template <class T, class A1, class A2>
@@ -251,7 +251,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>())));
     }
 
@@ -264,7 +264,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>())));
     }
@@ -279,7 +279,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>())));
@@ -296,7 +296,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -315,7 +315,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -336,7 +336,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -359,7 +359,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -384,7 +384,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -411,7 +411,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -427,7 +427,7 @@ struct caller
     static PyObject* call(R (*f)(), PyObject* args, PyObject* /* keywords */ ) {
         if (!PyArg_ParseTuple(args, const_cast<char*>("")))
             return 0;
-        return to_python(f());
+        return to_python(search_namespace, f());
     }
 
     template <class A1>
@@ -435,7 +435,7 @@ struct caller
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
             return 0;
-        return to_python(f(from_python(a1, type<A1>())));
+        return to_python(search_namespace, f(from_python(a1, type<A1>())));
     }
 
     template <class A1, class A2>
@@ -444,7 +444,7 @@ struct caller
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
             return 0;
-        return to_python(f(from_python(a1, type<A1>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>())));
     }
 
@@ -455,7 +455,7 @@ struct caller
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
             return 0;
-        return to_python(f(from_python(a1, type<A1>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>())));
     }
@@ -468,7 +468,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>())));
@@ -483,7 +483,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -500,7 +500,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -519,7 +519,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -540,7 +540,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -563,7 +563,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -588,7 +588,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -615,7 +615,7 @@ struct caller
         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>()),
+        return to_python(search_namespace, f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 9792695e..348bcc39 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -15,19 +15,6 @@
 # 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
@@ -37,6 +24,16 @@
 
 # endif
 
+# if defined(BOOST_PYTHON_USE_FRIEND_KOENIG_LOOKUP)
+// for compilers that support Koenig lookup
+#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
+#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::python
+# else
+// for compilers that do not support Koenig lookup for friend functions
+#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
+#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
+# 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.

From 294254efbb4539e93fb86249e7c92a5377191b88 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 24 May 2001 08:43:56 +0000
Subject: [PATCH 106/369] Fix accident: restore main version.

[SVN r10209]
---
 include/boost/python/callback.hpp | 440 +++++++++++++++---------------
 include/boost/python/caller.hpp   |  68 ++---
 2 files changed, 254 insertions(+), 254 deletions(-)

diff --git a/include/boost/python/callback.hpp b/include/boost/python/callback.hpp
index b9e850c6..7240b5b7 100644
--- a/include/boost/python/callback.hpp
+++ b/include/boost/python/callback.hpp
@@ -46,7 +46,7 @@ struct callback
     template <class A1>
     static R call_method(PyObject* self, const char* name, const A1& a1)
     {
-        ref p1(to_python(search_namespace, a1));
+        ref p1(to_python(a1));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(O)"),
                                      p1.get()));
@@ -57,7 +57,7 @@ struct callback
     template <class A1>
     static R call(PyObject* self, const A1& a1)
     {
-        ref p1(to_python(search_namespace, 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>());
@@ -67,8 +67,8 @@ struct callback
     template <class A1, class A2>
     static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
     {
-        ref p1(to_python(search_namespace, a1));
-        ref p2(to_python(search_namespace, 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(),
@@ -80,8 +80,8 @@ struct callback
     template <class A1, class A2>
     static R call(PyObject* self, const A1& a1, const A2& a2)
     {
-        ref p1(to_python(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
                                        p1.get(),
                                        p2.get()));
@@ -92,9 +92,9 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, 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(),
@@ -107,9 +107,9 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, 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(),
@@ -121,10 +121,10 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, 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(),
@@ -138,10 +138,10 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, 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(),
@@ -154,11 +154,11 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, 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(),
@@ -173,11 +173,11 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, 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(),
@@ -191,12 +191,12 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, 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(),
@@ -212,12 +212,12 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, 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(),
@@ -232,13 +232,13 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, 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(),
@@ -255,13 +255,13 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, 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(),
@@ -277,14 +277,14 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, 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(),
@@ -302,14 +302,14 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, 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(),
@@ -326,15 +326,15 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, 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(),
@@ -353,15 +353,15 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, 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(),
@@ -379,16 +379,16 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, a9));
-        ref p10(to_python(search_namespace, 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(),
@@ -408,16 +408,16 @@ struct callback
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, a9));
-        ref p10(to_python(search_namespace, 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(),
@@ -455,7 +455,7 @@ struct callback<void>
     template <class A1>
     static void call_method(PyObject* self, const char* name, const A1& a1)
     {
-        ref p1(to_python(search_namespace, a1));
+        ref p1(to_python(a1));
         ref result(PyEval_CallMethod(self, const_cast<char*>(name),
                                      const_cast<char*>("(O)"),
                                      p1.get()));
@@ -464,7 +464,7 @@ struct callback<void>
     template <class A1>
     static void call(PyObject* self, const A1& a1)
     {
-        ref p1(to_python(search_namespace, a1));
+        ref p1(to_python(a1));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
                                        p1.get()));
     }
@@ -472,8 +472,8 @@ struct callback<void>
     template <class A1, class A2>
     static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
     {
-        ref p1(to_python(search_namespace, a1));
-        ref p2(to_python(search_namespace, 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(),
@@ -483,8 +483,8 @@ struct callback<void>
     template <class A1, class A2>
     static void call(PyObject* self, const A1& a1, const A2& a2)
     {
-        ref p1(to_python(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
+        ref p1(to_python(a1));
+        ref p2(to_python(a2));
         ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
                                        p1.get(),
                                        p2.get()));
@@ -493,9 +493,9 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, 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(),
@@ -506,9 +506,9 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, 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(),
@@ -518,10 +518,10 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, 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(),
@@ -533,10 +533,10 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, 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(),
@@ -547,11 +547,11 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, 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(),
@@ -564,11 +564,11 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, 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(),
@@ -580,12 +580,12 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, 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(),
@@ -599,12 +599,12 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, 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(),
@@ -617,13 +617,13 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, 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(),
@@ -638,13 +638,13 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, 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(),
@@ -658,14 +658,14 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, 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(),
@@ -681,14 +681,14 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, 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(),
@@ -703,15 +703,15 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, 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(),
@@ -728,15 +728,15 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, 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(),
@@ -752,16 +752,16 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, a9));
-        ref p10(to_python(search_namespace, 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(),
@@ -779,16 +779,16 @@ struct callback<void>
     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(search_namespace, a1));
-        ref p2(to_python(search_namespace, a2));
-        ref p3(to_python(search_namespace, a3));
-        ref p4(to_python(search_namespace, a4));
-        ref p5(to_python(search_namespace, a5));
-        ref p6(to_python(search_namespace, a6));
-        ref p7(to_python(search_namespace, a7));
-        ref p8(to_python(search_namespace, a8));
-        ref p9(to_python(search_namespace, a9));
-        ref p10(to_python(search_namespace, 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(),
diff --git a/include/boost/python/caller.hpp b/include/boost/python/caller.hpp
index 86820233..35b2d618 100644
--- a/include/boost/python/caller.hpp
+++ b/include/boost/python/caller.hpp
@@ -30,7 +30,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)());
+        return to_python((target.*pmf)());
     }
 
     template <class T, class A1>
@@ -40,7 +40,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>())));
+        return to_python((target.*pmf)(from_python(a1, type<A1>())));
     }
 
     template <class T, class A1, class A2>
@@ -51,7 +51,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>())));
     }
 
@@ -64,7 +64,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>())));
     }
@@ -79,7 +79,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>())));
@@ -96,7 +96,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -115,7 +115,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -136,7 +136,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -159,7 +159,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -184,7 +184,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -211,7 +211,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -230,7 +230,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)());
+        return to_python((target.*pmf)());
     }
 
     template <class T, class A1>
@@ -240,7 +240,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &a1))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>())));
+        return to_python((target.*pmf)(from_python(a1, type<A1>())));
     }
 
     template <class T, class A1, class A2>
@@ -251,7 +251,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &self, &a1, &a2))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>())));
     }
 
@@ -264,7 +264,7 @@ struct caller
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &self, &a1, &a2, &a3))
             return 0;
         T& target = from_python(self, type<T&>());
-        return to_python(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        return to_python((target.*pmf)(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>())));
     }
@@ -279,7 +279,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>())));
@@ -296,7 +296,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -315,7 +315,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -336,7 +336,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -359,7 +359,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -384,7 +384,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -411,7 +411,7 @@ struct caller
         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(search_namespace, (target.*pmf)(from_python(a1, type<A1>()),
+        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>()),
@@ -427,7 +427,7 @@ struct caller
     static PyObject* call(R (*f)(), PyObject* args, PyObject* /* keywords */ ) {
         if (!PyArg_ParseTuple(args, const_cast<char*>("")))
             return 0;
-        return to_python(search_namespace, f());
+        return to_python(f());
     }
 
     template <class A1>
@@ -435,7 +435,7 @@ struct caller
         PyObject* a1;
         if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>())));
+        return to_python(f(from_python(a1, type<A1>())));
     }
 
     template <class A1, class A2>
@@ -444,7 +444,7 @@ struct caller
         PyObject* a2;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>())));
     }
 
@@ -455,7 +455,7 @@ struct caller
         PyObject* a3;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>())));
     }
@@ -468,7 +468,7 @@ struct caller
         PyObject* a4;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>())));
@@ -483,7 +483,7 @@ struct caller
         PyObject* a5;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -500,7 +500,7 @@ struct caller
         PyObject* a6;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -519,7 +519,7 @@ struct caller
         PyObject* a7;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -540,7 +540,7 @@ struct caller
         PyObject* a8;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -563,7 +563,7 @@ struct caller
         PyObject* a9;
         if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
             return 0;
-        return to_python(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -588,7 +588,7 @@ struct caller
         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(search_namespace, f(from_python(a1, type<A1>()),
+        return to_python(f(from_python(a1, type<A1>()),
                         from_python(a2, type<A2>()),
                         from_python(a3, type<A3>()),
                         from_python(a4, type<A4>()),
@@ -615,7 +615,7 @@ struct caller
         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(search_namespace, f(from_python(a1, type<A1>()),
+        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 66da2339d4abfa1820d6a0320fc6f98e1bc92a5e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 24 May 2001 08:51:05 +0000
Subject: [PATCH 107/369] Fix accident: restore main version.

[SVN r10210]
---
 include/boost/python/detail/config.hpp | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 348bcc39..9792695e 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -15,6 +15,19 @@
 # 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
@@ -24,16 +37,6 @@
 
 # endif
 
-# if defined(BOOST_PYTHON_USE_FRIEND_KOENIG_LOOKUP)
-// for compilers that support Koenig lookup
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::python
-# else
-// for compilers that do not support Koenig lookup for friend functions
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
-# 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.

From 29a855813d307864ee96d5f45f63582d24d846ca Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 28 May 2001 20:14:25 +0000
Subject: [PATCH 108/369] fixed typo

[SVN r10240]
---
 doc/pointers.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/pointers.html b/doc/pointers.html
index fdbee797..00f7bb41 100644
--- a/doc/pointers.html
+++ b/doc/pointers.html
@@ -85,7 +85,7 @@ code before the last Python reference to it disappears:
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   PyObject* to_python(Foo* p)
   {
-      return boost::python::python_extension_class_converters&ltFoo&gt::ptr_to_python(p);
+      return boost::python::python_extension_class_converters&lt;Foo&gt::ptr_to_python(p);
   }
 
   PyObject* to_python(const Foo* p)

From 7a71cea92a4ecbc59a4072b8d083f2fb9680942e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 18 Jun 2001 12:11:46 +0000
Subject: [PATCH 109/369] updated ILU links thanks to Scott Langley

[SVN r10355]
---
 doc/comparisons.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/comparisons.html b/doc/comparisons.html
index 6f082d51..57cec744 100644
--- a/doc/comparisons.html
+++ b/doc/comparisons.html
@@ -112,10 +112,10 @@ that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
       <h2>ILU</h2>
       <p>
         <a
-        href="http://www.cl.cam.ac.uk/Research/Rainbow/projects/origami/ilu-1.8-manual">ILU</a>
+        href="ftp://ftp.parc.xerox.com/pub/ilu/ilu.html">ILU</a>
         is a very ambitious project which tries to describe a module's interface
         (types and functions) in terms of an <a
-        href="http://www.cl.cam.ac.uk/Research/Rainbow/projects/origami/ilu-1.8-manual/manual_2.html">Interface
+        href="ftp://ftp.parc.xerox.com/pub/ilu/2.0b1/manual-html/manual_2.html">Interface
         Specification Language</a> (ISL) so that it can be uniformly interfaced
         to a wide range of computer languages, including Common Lisp, C++, C,
         Modula-3, and Python. ILU can parse the ISL to generate a C++ language

From 91f0728b5598b144df3a87f236f6512c5dae459d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 21 Jun 2001 20:46:26 +0000
Subject: [PATCH 110/369] Minor fix, thanks to Jens Maurer.

[SVN r10377]
---
 example/simple_vector.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
index 2b3aa290..3499c8f7 100644
--- a/example/simple_vector.cpp
+++ b/example/simple_vector.cpp
@@ -49,7 +49,7 @@ namespace { // Avoid cluttering the global namespace.
   void delitem(std::vector<double>& vd, std::size_t key) {
     if (key >= vd.size()) raise_vector_IndexError();
     std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
+    vd.erase(vditer + key);
   }
 
   // Convert vector_double to a regular Python tuple.

From 8b88e9f7272e8d0041deaca23b017193615cb849 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 21 Jun 2001 20:49:41 +0000
Subject: [PATCH 111/369] define changed to enable Silicon Graphics gcc
 compilation.

[SVN r10378]
---
 test/comprehensive.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 410bd243..427ed2d8 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -15,7 +15,9 @@
 #include <math.h>  // for pow()
 #include <boost/rational.hpp>
 
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+#if defined(__sgi) \
+    && (   (defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730) \
+        && !defined(__GNUC__))
 inline double pow(int x, int y) { return pow(static_cast<double>(x), y); }
 #endif
 

From 7c33a46a76dc7174317644e90e0aabfd52718b59 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 21 Jun 2001 23:38:42 +0000
Subject: [PATCH 112/369] A small fix for Borland

[SVN r10389]
---
 src/classes.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/classes.cpp b/src/classes.cpp
index c609eeef..8755bb34 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -203,7 +203,8 @@ namespace detail {
       }
       if (!BOOST_CSTD_::strcmp(name, "__reduce__"))
       {
-          ref target(as_object(this), ref::increment_count);
+          PyObject* self = as_object(this);
+          ref target(self, ref::increment_count);
           return bound_function::create(target, global_class_reduce());
       }
       
@@ -808,7 +809,7 @@ namespace detail {
   // Enable the special handler for methods of the given name, if any.
   void enable_named_method(boost::python::detail::class_base* type_obj, const char* name)
   {
-      const std::size_t num_enablers = sizeof(enablers) / sizeof(enablers[0]);
+      const std::size_t num_enablers = PY_ARRAY_LENGTH(enablers);
 
       // Make sure this ends with "__" since we'll only compare the head of the
       // string.  This is done to make the __getattr__<name>__/__setattr__<name>__

From 1364b97b881185c8ea231c146679fbce172532b1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 21 Jun 2001 23:39:30 +0000
Subject: [PATCH 113/369] A small Borland fix

[SVN r10390]
---
 include/boost/python/detail/init_function.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/init_function.hpp b/include/boost/python/detail/init_function.hpp
index f4b24fa6..c0c50272 100644
--- a/include/boost/python/detail/init_function.hpp
+++ b/include/boost/python/detail/init_function.hpp
@@ -73,7 +73,8 @@ namespace detail {
   struct parameter_traits
   {
    private:
-      typedef const_ref_selector<boost::is_reference<T>::value> selector;
+      enum { is_ref = boost::is_reference<T>::value };
+      typedef const_ref_selector<is_ref> selector;
    public:
       typedef typename selector::template const_ref<T>::type const_reference;
   };

From 081150b477dfbd5dce9d3a7faaa0d12fce9380e9 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 21 Jun 2001 23:40:04 +0000
Subject: [PATCH 114/369] Quick Borland fix

[SVN r10391]
---
 include/boost/python/detail/types.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/boost/python/detail/types.hpp b/include/boost/python/detail/types.hpp
index ee33ce04..5f0c8f97 100644
--- a/include/boost/python/detail/types.hpp
+++ b/include/boost/python/detail/types.hpp
@@ -375,8 +375,12 @@ PyObject* reprable<Base>::instance_repr(PyObject* obj) const
 
 // This macro gets the length of an array as a compile-time constant, and will
 // fail to compile if the parameter is a pointer.
+#ifdef __BORLANDC__ // smart implementation doesn't work for borland; maybe someone knows a workaround?
+# define PY_ARRAY_LENGTH(a) (sizeof(a) / sizeof((a)[0]))
+#else
 # define PY_ARRAY_LENGTH(a) \
         (sizeof(::boost::python::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
+#endif
 
   template<typename T>
   inline void countof_validate(T* const, T* const*);

From 88372000b5b4348610e4e5440de4e9a8d4b5f29d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 22 Jun 2001 00:49:58 +0000
Subject: [PATCH 115/369] fixes due to Jens Maurer (merged from branch
 boost_python_friend_fixes)

[SVN r10395]
---
 build/linux_gcc.mak | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index 9cd2b5de..5971ca61 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -17,14 +17,14 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=/usr/bin/python
+PYEXE=PYTHONPATH=. /usr/bin/python
 PYINC=-I/usr/include/python1.5
 #PYEXE=/usr/local/Python-1.5.2/bin/python
 #PYINC=-I/usr/local/Python-1.5.2/include/python1.5
 #PYEXE=/usr/local/Python-2.0/bin/python
 #PYINC=-I/usr/local/Python-2.0/include/python2.0
 
-STDOPTS=-ftemplate-depth-21
+STDOPTS=-fPIC -ftemplate-depth-21
 WARNOPTS=
 OPTOPTS=-g
 
@@ -33,7 +33,7 @@ CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST) $(PYINC) \
         $(STDOPTS) $(WARNOPTS) $(OPTOPTS)
 MAKEDEP=-M
 
-LD=g++
+LD=$(CPP)
 LDOPTS=-shared
 
 OBJ=classes.o conversions.o extension_class.o functions.o \

From 4328ae1d8d86607807d5e649d4e0d9135a4d07bf Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 22 Jun 2001 22:36:00 +0000
Subject: [PATCH 116/369] Updates for Boost.Build

[SVN r10403]
---
 example/test_abstract.py                  | 5 +++--
 example/test_cross_module.py              | 5 +++--
 example/test_do_it_yourself_converters.py | 5 +++--
 example/test_example1.py                  | 5 +++--
 example/test_getting_started1.py          | 5 +++--
 example/test_getting_started2.py          | 6 ++++--
 example/test_pickle1.py                   | 6 ++++--
 example/test_pickle2.py                   | 6 ++++--
 example/test_pickle3.py                   | 5 +++--
 example/test_rwgk1.py                     | 6 ++++--
 example/test_simple_vector.py             | 6 ++++--
 test/comprehensive.py                     | 4 ++--
 12 files changed, 40 insertions(+), 24 deletions(-)

diff --git a/example/test_abstract.py b/example/test_abstract.py
index dda8aaa7..a48aff1b 100644
--- a/example/test_abstract.py
+++ b/example/test_abstract.py
@@ -17,7 +17,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_abstract
-    doctest.testmod(test_abstract)
+    return doctest.testmod(test_abstract)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
diff --git a/example/test_cross_module.py b/example/test_cross_module.py
index 81057f23..86c1be0e 100644
--- a/example/test_cross_module.py
+++ b/example/test_cross_module.py
@@ -133,7 +133,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_cross_module
-    doctest.testmod(test_cross_module)
+    return doctest.testmod(test_cross_module)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run())
diff --git a/example/test_do_it_yourself_converters.py b/example/test_do_it_yourself_converters.py
index e256c614..17240750 100644
--- a/example/test_do_it_yourself_converters.py
+++ b/example/test_do_it_yourself_converters.py
@@ -16,7 +16,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_do_it_yourself_converters
-    doctest.testmod(test_do_it_yourself_converters)
+    return doctest.testmod(test_do_it_yourself_converters)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
diff --git a/example/test_example1.py b/example/test_example1.py
index 0e3a9a18..3a30cb5b 100644
--- a/example/test_example1.py
+++ b/example/test_example1.py
@@ -44,7 +44,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_example1
-    doctest.testmod(test_example1)
+    return doctest.testmod(test_example1)
     
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
diff --git a/example/test_getting_started1.py b/example/test_getting_started1.py
index 7daf65af..cd8fb59e 100644
--- a/example/test_getting_started1.py
+++ b/example/test_getting_started1.py
@@ -11,7 +11,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_getting_started1
-    doctest.testmod(test_getting_started1)
+    return doctest.testmod(test_getting_started1)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
diff --git a/example/test_getting_started2.py b/example/test_getting_started2.py
index 49cf765d..ccfaa4f1 100644
--- a/example/test_getting_started2.py
+++ b/example/test_getting_started2.py
@@ -23,7 +23,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_getting_started2
-    doctest.testmod(test_getting_started2)
+    return doctest.testmod(test_getting_started2)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+
diff --git a/example/test_pickle1.py b/example/test_pickle1.py
index 05696d4a..48c76a5f 100644
--- a/example/test_pickle1.py
+++ b/example/test_pickle1.py
@@ -25,7 +25,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_pickle1
-    doctest.testmod(test_pickle1)
+    return doctest.testmod(test_pickle1)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+
diff --git a/example/test_pickle2.py b/example/test_pickle2.py
index 463befa6..bafa9875 100644
--- a/example/test_pickle2.py
+++ b/example/test_pickle2.py
@@ -39,7 +39,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_pickle2
-    doctest.testmod(test_pickle2)
+    return doctest.testmod(test_pickle2)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+
diff --git a/example/test_pickle3.py b/example/test_pickle3.py
index b964f1a2..36da735d 100644
--- a/example/test_pickle3.py
+++ b/example/test_pickle3.py
@@ -32,7 +32,8 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_pickle3
-    doctest.testmod(test_pickle3)
+    return doctest.testmod(test_pickle3)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
diff --git a/example/test_rwgk1.py b/example/test_rwgk1.py
index 87298875..631eea3e 100644
--- a/example/test_rwgk1.py
+++ b/example/test_rwgk1.py
@@ -11,7 +11,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_rwgk1
-    doctest.testmod(test_rwgk1)
+    return doctest.testmod(test_rwgk1)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+
diff --git a/example/test_simple_vector.py b/example/test_simple_vector.py
index ca38d715..c6a2cd59 100644
--- a/example/test_simple_vector.py
+++ b/example/test_simple_vector.py
@@ -34,7 +34,9 @@ def run(args = None):
         import sys
         sys.argv = args
     import doctest, test_simple_vector
-    doctest.testmod(test_simple_vector)
+    return doctest.testmod(test_simple_vector)
 
 if __name__ == '__main__':
-    run()
+    import sys
+    sys.exit(run()[0])
+
diff --git a/test/comprehensive.py b/test/comprehensive.py
index c1424d25..06a191af 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -1188,7 +1188,7 @@ def run(args = None):
     if args is not None:
         sys.argv = args
     import doctest, comprehensive
-    doctest.testmod(comprehensive)
+    return doctest.testmod(comprehensive)
     
 if __name__ == '__main__':
-    run()
+    sys.exit(run()[0])

From ff2b37f6e374d6c9b594747ffa1eaa267b9ca952 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 29 Jun 2001 03:57:34 +0000
Subject: [PATCH 117/369] Fix so it compiles with Cygwin

[SVN r10480]
---
 include/boost/python/detail/config.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 9792695e..b6075368 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -57,7 +57,7 @@
 #  define BOOST_CSTD_ std
 # endif
 
-#ifdef _WIN32
+#if defined(_WIN32) || defined(__CYGWIN__)
 # define BOOST_PYTHON_MODULE_INIT(name) extern "C" __declspec(dllexport) void init##name()
 #else
 # define BOOST_PYTHON_MODULE_INIT(name) extern "C" void init##name()

From a32dedd16c8998faad1aa7cd31f57de4d4e5ecee Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 29 Jun 2001 20:30:58 +0000
Subject: [PATCH 118/369] updates for Python2.1

[SVN r10485]
---
 test/comprehensive.py | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/test/comprehensive.py b/test/comprehensive.py
index 06a191af..013fae96 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -19,10 +19,13 @@ Load up the extension module
 Automatic checking of the number and type of arguments. Foo's constructor takes
 a single long parameter. 
 
-    >>> ext = Foo()
-    Traceback (innermost last):
-      File "<stdin>", line 1, in ?
-    TypeError: function requires exactly 1 argument; 0 given
+    >>> try:
+    ...     ext = Foo()
+    ... except TypeError, err:
+    ...     assert re.match(r'function .* exactly 1 argument;? \(?0 given\)?',
+    ...                     str(err))
+    ... else:
+    ...     print 'no exception'
 
     >>> try: ext = Foo('foo')
     ... except TypeError, err:
@@ -1014,9 +1017,12 @@ test inheritB2
     -2
     >>> str(i)
     '2'
-    >>> j = i/i
-    Traceback (innermost last):
-    TypeError: bad operand type(s) for /
+    >>> try: j = i/i
+    ... except TypeError, err:
+    ...     assert re.match(r'(bad|unsupported) operand type\(s\) for /',
+    ...                     str(err))
+    ... else: print 'no exception'
+    
     >>> j = abs(i)
     Traceback (innermost last):
     TypeError: bad operand type for abs()

From 884b59a0b308f448b63f856ea6b56af7a99106c5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 2 Jul 2001 00:16:28 +0000
Subject: [PATCH 119/369] Added JIT debugging hooks

[SVN r10507]
---
 example/dvect.cpp              | 11 +++++++++++
 example/ivect.cpp              | 11 +++++++++++
 example/noncopyable_export.cpp | 10 ++++++++++
 example/noncopyable_import.cpp | 10 ++++++++++
 4 files changed, 42 insertions(+)

diff --git a/example/dvect.cpp b/example/dvect.cpp
index da6b35a3..4d109c96 100644
--- a/example/dvect.cpp
+++ b/example/dvect.cpp
@@ -20,6 +20,16 @@ namespace {
   }
 }
 
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
 BOOST_PYTHON_MODULE_INIT(dvect)
 {
   try
@@ -43,3 +53,4 @@ BOOST_PYTHON_MODULE_INIT(dvect)
     python::handle_exception(); // Deal with the exception for Python
   }
 }
+
diff --git a/example/ivect.cpp b/example/ivect.cpp
index db1c0ec3..848d693e 100644
--- a/example/ivect.cpp
+++ b/example/ivect.cpp
@@ -20,6 +20,16 @@ namespace {
   }
 }
 
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
 BOOST_PYTHON_MODULE_INIT(ivect)
 {
   try
@@ -43,3 +53,4 @@ BOOST_PYTHON_MODULE_INIT(ivect)
     python::handle_exception(); // Deal with the exception for Python
   }
 }
+
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
index 794b1200..b118abb8 100644
--- a/example/noncopyable_export.cpp
+++ b/example/noncopyable_export.cpp
@@ -6,6 +6,16 @@ namespace python = boost::python;
 
 #include "noncopyable.h"
 
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
 BOOST_PYTHON_MODULE_INIT(noncopyable_export)
 {
   try
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
index ea2477be..66c6457d 100644
--- a/example/noncopyable_import.cpp
+++ b/example/noncopyable_import.cpp
@@ -19,6 +19,16 @@ namespace { // Avoid cluttering the global namespace.
   }
 }
 
+# ifdef BOOST_MSVC // fixes for JIT debugging
+#  include <windows.h>
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
+    = _set_se_translator(structured_exception_translator);
+# endif
+
 BOOST_PYTHON_MODULE_INIT(noncopyable_import)
 {
   try

From e504c3cd466326b11d40c363a67c89e356049db5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 2 Jul 2001 00:16:53 +0000
Subject: [PATCH 120/369] Made it a little more immune to command-line argument
 ordering

[SVN r10508]
---
 example/tst_dvect2.py | 20 +++++++++++++-------
 example/tst_ivect2.py | 20 +++++++++++++-------
 2 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/example/tst_dvect2.py b/example/tst_dvect2.py
index 539e0b88..2e72bf8b 100644
--- a/example/tst_dvect2.py
+++ b/example/tst_dvect2.py
@@ -87,12 +87,18 @@ if (__name__ == "__main__"):
   import sys, string
   broken_auto_ptr = 0
   n = 1
-  if (len(sys.argv) > 1):
-    if (sys.argv[1] == "--broken-auto-ptr"):
-      broken_auto_ptr = 1
-      if (len(sys.argv) > 2):
-        n = string.atoi(sys.argv[2])
-    else:
-      n = string.atoi(sys.argv[1])
+  
+  if len(sys.argv) > 1:
+      argv = []
+      
+      for x in sys.argv:
+        if x != '--broken_auto_ptr':
+          argv.append(x)
+      broken_auto_ptr = argv != sys.argv
+      sys.argv = argv
+
+      if len(sys.argv) > 1:
+        n = string.atoi(sys.argv[1])
+        
   for i in xrange(n):
     f(broken_auto_ptr)
diff --git a/example/tst_ivect2.py b/example/tst_ivect2.py
index 6ffd2826..e7607151 100644
--- a/example/tst_ivect2.py
+++ b/example/tst_ivect2.py
@@ -87,12 +87,18 @@ if (__name__ == "__main__"):
   import sys, string
   broken_auto_ptr = 0
   n = 1
-  if (len(sys.argv) > 1):
-    if (sys.argv[1] == "--broken-auto-ptr"):
-      broken_auto_ptr = 1
-      if (len(sys.argv) > 2):
-        n = string.atoi(sys.argv[2])
-    else:
-      n = string.atoi(sys.argv[1])
+
+  if len(sys.argv) > 1:
+      argv = []
+      
+      for x in sys.argv:
+        if x != '--broken_auto_ptr':
+          argv.append(x)
+      broken_auto_ptr = argv != sys.argv
+      sys.argv = argv
+
+      if len(sys.argv) > 1:
+        n = string.atoi(sys.argv[1])
+        
   for i in xrange(n):
     f(broken_auto_ptr)

From 76c6adf1cfe57835c6fa264296820739cd1ef7b6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 3 Jul 2001 12:43:12 +0000
Subject: [PATCH 121/369] --broken_auto_ptr -> --broken-auto-ptr

[SVN r10511]
---
 example/tst_dvect2.py | 2 +-
 example/tst_ivect2.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/example/tst_dvect2.py b/example/tst_dvect2.py
index 2e72bf8b..90d381a7 100644
--- a/example/tst_dvect2.py
+++ b/example/tst_dvect2.py
@@ -92,7 +92,7 @@ if (__name__ == "__main__"):
       argv = []
       
       for x in sys.argv:
-        if x != '--broken_auto_ptr':
+        if x != '--broken-auto-ptr':
           argv.append(x)
       broken_auto_ptr = argv != sys.argv
       sys.argv = argv
diff --git a/example/tst_ivect2.py b/example/tst_ivect2.py
index e7607151..a9e6aeef 100644
--- a/example/tst_ivect2.py
+++ b/example/tst_ivect2.py
@@ -92,7 +92,7 @@ if (__name__ == "__main__"):
       argv = []
       
       for x in sys.argv:
-        if x != '--broken_auto_ptr':
+        if x != '--broken-auto-ptr':
           argv.append(x)
       broken_auto_ptr = argv != sys.argv
       sys.argv = argv

From 606898f5691a641a695d806941ad7c08d0a204f6 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 6 Jul 2001 07:31:39 +0000
Subject: [PATCH 122/369] tiny trivial fix.

[SVN r10547]
---
 example/test_cross_module.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/test_cross_module.py b/example/test_cross_module.py
index 86c1be0e..c5e2bef6 100644
--- a/example/test_cross_module.py
+++ b/example/test_cross_module.py
@@ -137,4 +137,4 @@ def run(args = None):
 
 if __name__ == '__main__':
     import sys
-    sys.exit(run())
+    sys.exit(run()[0])

From 8ad7d06ec6fd2bce16011e5d3a0b7ade321f98ee Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 8 Jul 2001 22:30:12 +0000
Subject: [PATCH 123/369] fixed &gt -> &gt;

[SVN r10571]
---
 doc/pointers.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/pointers.html b/doc/pointers.html
index 00f7bb41..9085e152 100644
--- a/doc/pointers.html
+++ b/doc/pointers.html
@@ -85,7 +85,7 @@ code before the last Python reference to it disappears:
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   PyObject* to_python(Foo* p)
   {
-      return boost::python::python_extension_class_converters&lt;Foo&gt::ptr_to_python(p);
+      return boost::python::python_extension_class_converters&lt;Foo&gt;::ptr_to_python(p);
   }
 
   PyObject* to_python(const Foo* p)

From 819db1524fe330793593ea4efea395f20068381a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 9 Jul 2001 23:45:09 +0000
Subject: [PATCH 124/369] Integrate fix from Peter.Bienstman@rug.ac.be

[SVN r10574]
---
 doc/enums.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/enums.html b/doc/enums.html
index 32d61447..c58ca34d 100644
--- a/doc/enums.html
+++ b/doc/enums.html
@@ -91,8 +91,8 @@ initialization. These bind the corresponding enum values to the appropriate
 names so they can be used from Python:
 
 <blockquote><pre>
-mymodule.add(boost::python::to_python(enum_value_1), "enum_value_1");
-mymodule.add(boost::python::to_python(enum_value_2), "enum_value_2");
+mymodule.add(boost::python::make_ref(enum_value_1), "enum_value_1");
+mymodule.add(boost::python::make_ref(enum_value_2), "enum_value_2");
 ...
 </pre></blockquote>
 

From 26aa8b69f96b7537652ba8b41e5ba10214e7a6dd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 10 Jul 2001 17:57:06 +0000
Subject: [PATCH 125/369] Integrate fix from Peter.Bienstman@rug.ac.be

[SVN r10584]
---
 doc/pointers.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/pointers.html b/doc/pointers.html
index 9085e152..11cfd8d9 100644
--- a/doc/pointers.html
+++ b/doc/pointers.html
@@ -85,7 +85,7 @@ code before the last Python reference to it disappears:
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
   PyObject* to_python(Foo* p)
   {
-      return boost::python::python_extension_class_converters&lt;Foo&gt;::ptr_to_python(p);
+      return boost::python::python_extension_class_converters&lt;Foo&gt;::smart_ptr_to_python(p);
   }
 
   PyObject* to_python(const Foo* p)

From 4f41a10fef7761fc571212659afa4639bf5816d4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 11 Jul 2001 11:53:46 +0000
Subject: [PATCH 126/369] fixed a comment

[SVN r10588]
---
 include/boost/python/detail/base_object.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/detail/base_object.hpp b/include/boost/python/detail/base_object.hpp
index bf0faa7b..95a2805c 100644
--- a/include/boost/python/detail/base_object.hpp
+++ b/include/boost/python/detail/base_object.hpp
@@ -39,7 +39,7 @@ typedef base_object<PyTypeObject> python_type;
 
 
 //
-// class_t template member function implementations 
+// base_object member function implementations 
 //
 template <class python_type>
 base_object<python_type>::base_object(PyTypeObject* type_obj)

From 24509a21d4fca7d6ae0a8f1250508af5f45a1b38 Mon Sep 17 00:00:00 2001
From: Beman Dawes <bdawes@acm.org>
Date: Thu, 12 Jul 2001 15:31:15 +0000
Subject: [PATCH 127/369] Change absolute URL's to relative

[SVN r10594]
---
 doc/under-the-hood.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/under-the-hood.html b/doc/under-the-hood.html
index 733f0f54..e2a0ce2b 100644
--- a/doc/under-the-hood.html
+++ b/doc/under-the-hood.html
@@ -36,7 +36,7 @@
       template defines a whole raft of these conversions (for <code>T, T*,
       T&amp;, std::auto_ptr&lt;T&gt;</code>, etc.), using the same inline
       friend function technique employed by <a href= 
-      "http://www.boost.org/libs/utility/operators.htm">the boost operators
+      "file:///c:/boost/site/libs/utility/operators.htm">the boost operators
       library</a>.
     <p>
       Because the <code>to_python</code> and <code>from_python</code> functions

From 08eb28f7b825de12a84f8e0eeb86309ba4d5c26d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 22 Jul 2001 17:03:15 +0000
Subject: [PATCH 128/369] move to main trunk

[SVN r10690]
---
 build/Jamfile | 248 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 248 insertions(+)
 create mode 100644 build/Jamfile

diff --git a/build/Jamfile b/build/Jamfile
new file mode 100644
index 00000000..fa31efc4
--- /dev/null
+++ b/build/Jamfile
@@ -0,0 +1,248 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+# Boost.Python build and test Jamfile
+#
+# Declares the following targets:
+#   1. libboost_python, a static link library to be linked with all
+#      Boost.Python modules
+#
+#   2. pairs of test targets of the form <name>.test and <name>.run
+#      <name>.test runs the test when it is out-of-date, and the "all" target
+#      depends on it so that it it is built by default. <name>.run runs
+#      a test unconditionally, and can be used to force a test to run.. Each
+#      test target builds one or more Boost.Python modules and runs a Python
+#      script to test them. The test names are:
+#
+#      from ../test
+#
+#         comprehensive         - a comprehensive test of Boost.Python features
+#
+#      from ../example:
+#         abstract              -
+#         getting_started1      -
+#         getting_started2      -
+#         simple_vector         -
+#         do_it_yourself_converters -
+#         pickle1               -
+#         pickle2               -
+#         pickle3               -
+#
+#         dvect1                -
+#         dvect2                -
+#         ivect1                -
+#         ivect2                -
+#         noncopyable           -
+#
+# subproject-specific environment/command-line variables:
+#
+# PYTHON_TEST_ARGS      - specifies arguments to be passed to test scripts on
+#                         the command line. "-v" can be useful if you want to
+#                         see the output of successful tests.
+#
+# PYTHON_VECT_ITERATIONS - specifies the number of test iterations to use for
+#                          the dvect and ivect tests above.
+
+
+# declare the location of this subproject relative to the root
+subproject libs/python/build ;
+
+# Do some OS-specific setup
+if $(NT)
+{
+    PYTHON_ROOT ?= c:/tools/python ;
+    PYTHON_INCLUDES ?= <include>$(PYTHON_ROOT)/include <gcc><*><include>/usr/include/python2.1 ;
+    PYTHON_LIBS ?= c:/cygnus/lib/python2.1/config/libpython2.1.dll.a ;
+    PYTHON_LIB_PATH = $(PYTHON_ROOT)/libs ;
+
+    # common properties required for compiling any Python module.
+    PYTHON_PROPERTIES ?=
+        <gcc><*><define>SIZEOF_LONG=4
+        <gcc><*><define>USE_DL_IMPORT
+                        
+        # if you don't request multithreading, you can't get the DLL runtime,
+        # which is needed for the python modules to  work right                
+        <msvc><*><threading>multi
+        ;
+                        
+    SHELL_SET ?= "set " ;
+    SHELL_EXPORT ?= ; # shell variables are exported by default
+}
+else if $(UNIX)
+{
+    PYTHON_INCLUDES ?= <include>/usr/include/python1.5 ;
+    PYTHON_LIBS ?= /usr/lib/python1.5/config/libpython1.5.a ;
+    SHELL_SET ?= "" ;
+    SHELL_EXPORT ?= "export " ;
+}
+
+#######################
+
+#
+# Declare the boost python static link library
+#
+
+# standard include requirements for anything using Boost.Python
+BOOST_PYTHON_INCLUDES = <include>$(BOOST_ROOT) $(PYTHON_INCLUDES) ;
+
+# Base names of the source files for libboost_python
+CPP_SOURCES =
+    classes conversions extension_class functions 
+    init_function module_builder objects types cross_module ;
+
+lib libboost_python : ../src/$(CPP_SOURCES).cpp
+    # requirements
+    : $(BOOST_PYTHON_INCLUDES)
+    <shared-linkable>true
+    $(PYTHON_PROPERTIES) ;
+    
+#######################
+
+# boost-python name : sources : requirements : default-BUILD
+#
+# Declare a boost python module. Return a list of the DLL files generated.
+rule boost-python
+{
+    # declare a DLL; add the boost python library to sources
+     dll $(<) : <lib>libboost_python $(>)
+            
+            # Requirements
+            : $(3) # caller-specified requirements
+            
+                # standard requirements
+                $(BOOST_PYTHON_INCLUDES)
+                <msvc><*><library-path>$(PYTHON_LIB_PATH)
+                <gcc><*><library-file>$(PYTHON_LIBS)
+                $(PYTHON_PROPERTIES)
+                
+        : $(4) ;                      # pass on the default-BUILD, if any
+}
+
+#######################
+
+# boost-python-test target : python-script sources : requirements : local-build : args
+#
+# declare two python module tests: $(<).test which builds when out-of-date, and
+# $(<).run which builds unconditionally.
+rule boost-python-test
+{
+    # tell Jam that the python script is relative to this directory
+    SEARCH on $(>[1]) = $(SEARCH_SOURCE) ;
+    
+    # required command-line args can be specified in argument 5
+    # The user can add additional arguments in PYTHON_TEST_ARGS.
+    local gPYTHON_TEST_ARGS = $(5) $(PYTHON_TEST_ARGS) ;
+    
+    # declare the two subsidiary tests.
+    declare-local-target $(<:S=.test) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_TEST ;
+    declare-local-target $(<:S=.run) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_RUNTEST ;
+}
+
+# how do we invoke python?
+PYTHON ?= python ;
+
+# special rules for two new target types: PYTHON_TEST and PYTHON_RUNTEST.
+# These are identical except that PYTHON_TEST runs the test when out-of-date, and
+# PYTHON_RUNTEST runs the test unconditionally. These are used by boost-python-test.
+SUFPYTHON_TEST = .test ;
+gGENERATOR_FUNCTION(PYTHON_TEST) = python-test-target ;
+rule python-test-target # test-target : sources : 
+{
+    python-test-aux $(<) : $(>) ;
+    Clean clean : $(<) ; # remove the test-target as part of any clean operation
+    type-DEPENDS test : $(<) ;
+    MakeLocate $(<) : $(LOCATE_TARGET) ;
+}
+actions python-test-target
+{
+    $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
+    $(SHELL_EXPORT)PYTHONPATH
+    $(PYTHON) "$(>)" $(ARGS) > "$(<)"
+}
+
+SUFPYTHON_RUNTEST = .run ;
+gGENERATOR_FUNCTION(PYTHON_RUNTEST) = python-runtest-target ;
+rule python-runtest-target # test-target : sources : 
+{
+    python-test-aux $(<) : $(>) ;
+    NOTFILE $(<) ;
+    ALWAYS $(<) ;
+}
+actions python-runtest-target
+{
+    $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
+    $(SHELL_EXPORT)PYTHONPATH
+    $(PYTHON) "$(>)" $(ARGS)
+}
+
+rule python-test-aux # target : sources
+{
+    DEPENDS $(<) : $(>) ;
+
+    ARGS on $(<) += $(gPYTHON_TEST_ARGS) ;
+    
+    # Some tests need an extra command-line arg if built with
+    # msvc. Checking the target grist is a cheap way to
+    # find out. 
+    switch $(<)
+    {
+        case <*\\\\msvc\\\\*>* : ARGS on $(<) += --broken-auto-ptr ;
+    }
+
+    # compute the PYTHONPATH environment variable that will allow the test to
+    # find all of the modules on which it depends.
+    PYTHONPATH on $(<) = [ join
+        $(gLOCATE($(>[1])))                     # location of python test file
+        $(gRUN_PATH($(<)))                      # location of module dependencies
+        [ join-path $(TOP) libs python test ]   # location of doctest
+        $(PYTHONPATH)                           # base PYTHONPATH from environment
+        : $(SPLITPATH) ] ;                      # platform path separator
+}
+
+############# comprehensive module and test ###########
+boost-python boost_python_test : ../test/comprehensive.cpp ;
+boost-python-test comprehensive : [ join-path $(DOTDOT) test comprehensive.py ] <lib>boost_python_test ;
+
+############# simple tests from ../example ############
+
+rule boost-python-example-test
+{
+    boost-python $(<) : ../example/$(<).cpp ;
+    boost-python-test $(<) : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<) ;
+}
+
+
+boost-python-example-test abstract ;
+boost-python-example-test getting_started1 ;
+boost-python-example-test getting_started2 ;
+boost-python-example-test simple_vector ;
+boost-python-example-test do_it_yourself_converters ;
+boost-python-example-test pickle1 ;
+boost-python-example-test pickle2 ;
+boost-python-example-test pickle3 ;
+
+
+boost-python ivect : ../example/ivect.cpp ;
+boost-python dvect : ../example/dvect.cpp ;
+boost-python noncopyable_export : ../example/noncopyable_export.cpp ;
+boost-python noncopyable_import : ../example/noncopyable_import.cpp ;
+
+############## cross-module tests from ../example ##########
+
+# A simple rule to build a test which depends on multiple modules in the PYTHONPATH
+rule boost-python-multi-example-test # test-name : python-file libs
+{
+    boost-python-test $(<) : ../example/tst_$(<).py <lib>$(>) : : : $(PYTHON_VECT_ITERATIONS) ;
+}
+PYTHON_VECT_ITERATIONS ?= 10 ;
+
+boost-python-multi-example-test dvect1 : ivect dvect ;
+boost-python-multi-example-test dvect2 : ivect dvect ;
+
+boost-python-multi-example-test ivect1 : ivect dvect ;
+boost-python-multi-example-test ivect2 : ivect dvect ;
+
+boost-python-multi-example-test noncopyable : noncopyable_import noncopyable_export ;
+

From 3c6a8d718fc5a7d198e1b089016b733eaaee4469 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 23 Jul 2001 03:34:37 +0000
Subject: [PATCH 129/369] build system update

[SVN r10695]
---
 build/Jamfile | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index fa31efc4..314b1440 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -61,10 +61,7 @@ if $(NT)
     PYTHON_PROPERTIES ?=
         <gcc><*><define>SIZEOF_LONG=4
         <gcc><*><define>USE_DL_IMPORT
-                        
-        # if you don't request multithreading, you can't get the DLL runtime,
-        # which is needed for the python modules to  work right                
-        <msvc><*><threading>multi
+        <runtime-link>dynamic
         ;
                         
     SHELL_SET ?= "set " ;

From f2e34d4836eab58dfd123b1aba294f5ed1d799fe Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 30 Jul 2001 13:31:23 +0000
Subject: [PATCH 130/369] MSVC doesn't like boost::dereferencable<T> unless T
 has a default constructor, so operator-> must be defined by hand

[SVN r10720]
---
 include/boost/python/detail/cast.hpp | 7 ++++++-
 include/boost/python/reference.hpp   | 9 ++++++---
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/detail/cast.hpp b/include/boost/python/detail/cast.hpp
index a6f2f046..e047c0b3 100644
--- a/include/boost/python/detail/cast.hpp
+++ b/include/boost/python/detail/cast.hpp
@@ -51,7 +51,7 @@ inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>
 // 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*>
+struct downcast
 {
     downcast(PyObject* p)
         : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((T*)0, p)))
@@ -70,6 +70,11 @@ struct downcast : boost::dereferenceable<downcast<T>, T*>
         {}
     
     operator T*() const { return m_p; }
+
+    // MSVC doesn't like boost::dereferencable unless T has a default
+    // constructor, so operator-> must be defined by hand :(
+    T* operator->() const { return &**this; }
+    
     T* get() const { return m_p; }
     T& operator*() const { return *m_p; }
  private:
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
index c633b9d7..a1585099 100644
--- a/include/boost/python/reference.hpp
+++ b/include/boost/python/reference.hpp
@@ -20,7 +20,7 @@
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-template <class T, class Value, class Base>
+template <class T, class Value, class Base = boost::detail::empty_base>
 struct py_ptr_conversions : Base
 {
     inline friend T from_python(PyObject* x, boost::python::type<const T&>)
@@ -42,8 +42,7 @@ 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 py_ptr_conversions<reference<T>, T>
 {
 public:
     typedef T value_type;
@@ -117,6 +116,10 @@ public:
 	
 	T& operator*() const { return *m_p; }
     
+    // MSVC doesn't like boost::dereferencable unless T has a default
+    // constructor, so operator-> must be defined by hand :(
+    T* operator->() const { return &**this; } 
+    
 	T* get() const { return m_p; }
 
 	T* release()

From f1ae502b1f9b3c7a55782557774b4fb77171b32c Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 31 Jul 2001 07:12:14 +0000
Subject: [PATCH 131/369] Merged from branch boost_python_richcmp.

[SVN r10728]
---
 build/filemgr.py                              |  10 +
 build/irix_CC.mak                             |  25 ++-
 build/linux_gcc.mak                           |  25 ++-
 build/mingw32.mak                             |  34 +++-
 build/tru64_cxx.mak                           |  25 ++-
 build/vc60.mak                                |  30 ++-
 doc/richcmp.html                              | 106 +++++++++++
 doc/special.html                              |  59 +++++-
 example/pickle3.cpp                           |   4 +-
 example/richcmp1.cpp                          |  87 +++++++++
 example/richcmp2.cpp                          |  65 +++++++
 example/richcmp3.cpp                          | 178 ++++++++++++++++++
 example/test_pickle3.py                       |  12 +-
 example/test_richcmp1.py                      |  40 ++++
 example/test_richcmp2.py                      |  41 ++++
 example/test_richcmp3.py                      |  77 ++++++++
 example/vector_wrapper.h                      | 117 ++++++++++++
 include/boost/python/classes.hpp              |  52 +++++
 .../boost/python/detail/extension_class.hpp   |  12 ++
 include/boost/python/detail/types.hpp         |  10 +-
 include/boost/python/operators.hpp            |  14 +-
 src/classes.cpp                               |  36 ++++
 src/gen_extclass.py                           |  21 +++
 src/gen_init_function.py                      |   3 +-
 src/types.cpp                                 |  70 ++++++-
 test/comprehensive.py                         |   8 +-
 26 files changed, 1110 insertions(+), 51 deletions(-)
 create mode 100644 doc/richcmp.html
 create mode 100644 example/richcmp1.cpp
 create mode 100644 example/richcmp2.cpp
 create mode 100644 example/richcmp3.cpp
 create mode 100644 example/test_richcmp1.py
 create mode 100644 example/test_richcmp2.py
 create mode 100644 example/test_richcmp3.py
 create mode 100644 example/vector_wrapper.h

diff --git a/build/filemgr.py b/build/filemgr.py
index d8310f6d..5e32460e 100644
--- a/build/filemgr.py
+++ b/build/filemgr.py
@@ -52,6 +52,13 @@ bpl_exa + "/tst_dvect2.py",
 bpl_exa + "/tst_ivect1.py",
 bpl_exa + "/tst_ivect2.py",
 bpl_exa + "/test_cross_module.py",
+bpl_exa + "/vector_wrapper.h",
+bpl_exa + "/richcmp1.cpp",
+bpl_exa + "/richcmp2.cpp",
+bpl_exa + "/richcmp3.cpp",
+bpl_exa + "/test_richcmp1.py",
+bpl_exa + "/test_richcmp2.py",
+bpl_exa + "/test_richcmp3.py",
 )
 
 defs = (
@@ -68,6 +75,9 @@ defs = (
 "noncopyable_import",
 "ivect",
 "dvect",
+"richcmp1",
+"richcmp2",
+"richcmp3",
 )
 
 if (__name__ == "__main__"):
diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index 5894ff51..1fbe3388 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -19,8 +19,8 @@ BOOST=$(ROOT)/boost
 
 PYEXE=/usr/local/Python-1.5.2/bin/python
 PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#PYEXE=/usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
 STDOPTS=
@@ -46,7 +46,8 @@ DEPOBJ=$(OBJ) \
        do_it_yourself_converters.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
-       ivect.o dvect.o
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
 
 .SUFFIXES: .o .cpp
 
@@ -58,7 +59,8 @@ all: libboost_python.a \
      do_it_yourself_converters.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -105,6 +107,15 @@ ivect.so: $(OBJ) ivect.o
 dvect.so: $(OBJ) dvect.o
 	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
 
+richcmp1.so: $(OBJ) richcmp1.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.o -o richcmp1.so
+
+richcmp2.so: $(OBJ) richcmp2.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.o -o richcmp2.so
+
+richcmp3.so: $(OBJ) richcmp3.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.o -o richcmp3.so
+
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
 
@@ -119,6 +130,9 @@ test:
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
 	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
 
 clean:
 	rm -f $(OBJ) libboost_python.a libboost_python.a.input
@@ -135,6 +149,9 @@ clean:
 	rm -f noncopyable_import.o noncopyable_import.so
 	rm -f ivect.o ivect.so
 	rm -f dvect.o dvect.so
+	rm -f richcmp1.o richcmp1.so
+	rm -f richcmp2.o richcmp2.so
+	rm -f richcmp3.o richcmp3.so
 	rm -f so_locations *.pyc
 	rm -rf ii_files
 
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index 5971ca61..3fe407a0 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -21,8 +21,8 @@ PYEXE=PYTHONPATH=. /usr/bin/python
 PYINC=-I/usr/include/python1.5
 #PYEXE=/usr/local/Python-1.5.2/bin/python
 #PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#PYEXE=/usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 
 STDOPTS=-fPIC -ftemplate-depth-21
 WARNOPTS=
@@ -47,7 +47,8 @@ DEPOBJ=$(OBJ) \
        do_it_yourself_converters.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
-       ivect.o dvect.o
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
 
 .SUFFIXES: .o .cpp
 
@@ -59,7 +60,8 @@ all: libboost_python.a \
      do_it_yourself_converters.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -106,6 +108,15 @@ ivect.so: $(OBJ) ivect.o
 dvect.so: $(OBJ) dvect.o
 	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
 
+richcmp1.so: $(OBJ) richcmp1.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.o -o richcmp1.so
+
+richcmp2.so: $(OBJ) richcmp2.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.o -o richcmp2.so
+
+richcmp3.so: $(OBJ) richcmp3.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.o -o richcmp3.so
+
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
 
@@ -120,6 +131,9 @@ test:
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
 	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
 
 clean:
 	rm -f $(OBJ) libboost_python.a libboost_python.a.input
@@ -136,6 +150,9 @@ clean:
 	rm -f noncopyable_import.o noncopyable_import.so
 	rm -f ivect.o ivect.so
 	rm -f dvect.o dvect.so
+	rm -f richcmp1.o richcmp1.so
+	rm -f richcmp2.o richcmp2.so
+	rm -f richcmp3.o richcmp3.so
 	rm -f so_locations *.pyc
 
 softlinks:
diff --git a/build/mingw32.mak b/build/mingw32.mak
index 0a16f332..6f192ce2 100644
--- a/build/mingw32.mak
+++ b/build/mingw32.mak
@@ -62,10 +62,11 @@ all: libboost_python.a \
      do_it_yourself_converters.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
-     ivect.pyd dvect.pyd
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
 
 libboost_python.a: $(OBJ)
-	del libboost_python.a
+	-del libboost_python.a
 	ar r libboost_python.a $(OBJ)
 
 DLLWRAPOPTS=-s --driver-name g++ -s \
@@ -149,6 +150,24 @@ dvect.pyd: $(OBJ) dvect.o
           --def dvect.def \
           $(OBJ) dvect.o $(PYLIB)
 
+richcmp1.pyd: $(OBJ) richcmp1.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname richcmp1.pyd \
+          --def richcmp1.def \
+          $(OBJ) richcmp1.o $(PYLIB)
+
+richcmp2.pyd: $(OBJ) richcmp2.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname richcmp2.pyd \
+          --def richcmp2.def \
+          $(OBJ) richcmp2.o $(PYLIB)
+
+richcmp3.pyd: $(OBJ) richcmp3.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname richcmp3.pyd \
+          --def richcmp3.def \
+          $(OBJ) richcmp3.o $(PYLIB)
+
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
 
@@ -163,12 +182,15 @@ test:
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
 	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
 
 clean:
-	del *.o
-	del *.a
-	del *.pyd
-	del *.pyc
+	-del *.o
+	-del *.a
+	-del *.pyd
+	-del *.pyc
 
 softlinks:
 	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index 21a8126e..8f3d3abf 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -19,8 +19,8 @@ BOOST=$(ROOT)/boost
 
 PYEXE=/usr/local/Python-1.5.2/bin/python
 PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.0/bin/python
-#PYINC=-I/usr/local/Python-2.0/include/python2.0
+#PYEXE=/usr/local/Python-2.1/bin/python
+#PYINC=-I/usr/local/Python-2.1/include/python2.1
 #STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
 #STLPORTINC=-I/usr/local/STLport-4.1b4/stlport
 #STLPORTOPTS= \
@@ -57,7 +57,8 @@ DEPOBJ=$(OBJ) \
        do_it_yourself_converters.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
-       ivect.o dvect.o
+       ivect.o dvect.o \
+       richcmp1.o richcmp2.o richcmp3.o
 
 .SUFFIXES: .o .cpp
 
@@ -69,7 +70,8 @@ all: libboost_python.a \
      do_it_yourself_converters.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
-     ivect.so dvect.so
+     ivect.so dvect.so \
+     richcmp1.so richcmp2.so richcmp3.so
 
 libboost_python.a: $(OBJ)
 	rm -f libboost_python.a
@@ -120,6 +122,15 @@ ivect.so: $(OBJ) ivect.o
 dvect.so: $(OBJ) dvect.o
 	$(LD) $(LDOPTS) $(OBJ) $(HIDDEN) dvect.o -o dvect.so
 
+richcmp1.so: $(OBJ) richcmp1.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.o -o richcmp1.so
+
+richcmp2.so: $(OBJ) richcmp2.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.o -o richcmp2.so
+
+richcmp3.so: $(OBJ) richcmp3.o
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.o -o richcmp3.so
+
 .cpp.o:
 	$(CPP) $(CPPOPTS) -c $*.cpp
 
@@ -134,6 +145,9 @@ test:
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
 	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
 
 clean:
 	rm -f $(OBJ) libboost_python.a libboost_python.a.input
@@ -150,6 +164,9 @@ clean:
 	rm -f noncopyable_import.o noncopyable_import.so
 	rm -f ivect.o ivect.so
 	rm -f dvect.o dvect.so
+	rm -f richcmp1.o richcmp1.so
+	rm -f richcmp2.o richcmp2.so
+	rm -f richcmp3.o richcmp3.so
 	rm -f so_locations *.pyc
 	rm -rf cxx_repository
 
diff --git a/build/vc60.mak b/build/vc60.mak
index f0016075..f545015b 100644
--- a/build/vc60.mak
+++ b/build/vc60.mak
@@ -17,6 +17,9 @@ BOOST_UNIX=$(HOME)/boost
 PYEXE="C:\Program files\Python\python.exe"
 PYINC=/I"C:\Program files\Python\include"
 PYLIB="C:\Program files\Python\libs\python15.lib"
+#PYEXE="C:\Python21\python.exe"
+#PYINC=/I"C:\Python21\include"
+#PYLIB="C:\Python21\libs\python21.lib"
 
 STDOPTS=/nologo /MD /GR /GX /Zm200
 WARNOPTS=
@@ -43,7 +46,8 @@ all: boost_python.lib \
      do_it_yourself_converters.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
-     ivect.pyd dvect.pyd
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
 
 boost_python.lib: $(OBJ)
 	$(LD) -lib /nologo /out:boost_python.lib $(OBJ)
@@ -87,6 +91,15 @@ ivect.pyd: $(OBJ) ivect.obj
 dvect.pyd: $(OBJ) dvect.obj
 	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB) /export:initdvect /out:"dvect.pyd"
 
+richcmp1.pyd: $(OBJ) richcmp1.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.obj $(PYLIB) /export:initrichcmp1 /out:"richcmp1.pyd"
+
+richcmp2.pyd: $(OBJ) richcmp2.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.obj $(PYLIB) /export:initrichcmp2 /out:"richcmp2.pyd"
+
+richcmp3.pyd: $(OBJ) richcmp3.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.obj $(PYLIB) /export:initrichcmp3 /out:"richcmp3.pyd"
+
 .cpp.obj:
 	$(CPP) $(CPPOPTS) /c $*.cpp
 
@@ -101,14 +114,17 @@ test:
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
 	$(PYEXE) test_cross_module.py --broken-auto-ptr
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
 
 clean:
-	del *.obj
-	del *.lib
-	del *.exp
-	del *.idb
-	del *.pyd
-	del *.pyc
+	-del *.obj
+	-del *.lib
+	-del *.exp
+	-del *.idb
+	-del *.pyd
+	-del *.pyc
 
 softlinks:
 	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
diff --git a/doc/richcmp.html b/doc/richcmp.html
new file mode 100644
index 00000000..d9ab7044
--- /dev/null
+++ b/doc/richcmp.html
@@ -0,0 +1,106 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
+"http://www.w3.org/TR/REC-html40/strict.dtd">
+
+<title>Rich Comparisons</title>
+
+<div>
+
+<img src="../../../c++boost.gif"
+     alt="c++boost.gif (8819 bytes)"
+     align="center"
+     width="277" height="86">
+
+<hr>
+<h1>Rich Comparisons</h1>
+
+<hr>
+In Python versions up to and including Python 2.0, support for
+implementing comparisons on user-defined classes and extension types
+was quite simple. Classes could implement a <tt>__cmp__</tt> method
+that was given two instances of a class as arguments, and could only
+return <tt>0</tt> if they were equal or <tt>+1</tt> or <tt>-1</tt> if
+they were not. The method could not raise an exception or return
+anything other than an integer value.
+In Python 2.1, <b>Rich Comparisons</b> were added (see
+<a href="http://python.sourceforge.net/peps/pep-0207.html">PEP 207</a>).
+Python classes can now individually overload each of the &lt;, &lt;=,
+&gt;, &gt;=, ==, and != operations.
+
+<p>
+For more detailed information, search for "rich comparison"
+<a href="http://www.python.org/doc/current/ref/customization.html"
+>here</a>.
+
+<p>
+Boost.Python supports both automatic overloading and manual overloading
+of the Rich Comparison operators. The <b>compile-time</b> support is
+independent of the Python version that is used when compiling
+Boost.Python extension modules. That is, <tt>op_lt</tt> for example can
+always be used, and the C++ <tt>operator&lt;</tt> will always be bound
+to the Python method <tt>__lt__</tt>. However, the <b>run-time</b>
+behavior will depend on the Python version.
+
+<p>
+With Python versions before 2.1, the Rich Comparison operators will not
+be called by Python when any of the six comparison operators
+(<tt>&lt;</tt>, <tt>&lt;=</tt>, <tt>==</tt>, <tt>!=</tt>,
+<tt>&gt;</tt>, <tt>&gt;=</tt>) is used in an expression. The only way
+to access the corresponding methods is to call them explicitly, e.g.
+<tt>a.__lt__(b)</tt>. Only with Python versions 2.1 or higher will
+expressions like <tt>a &lt; b</tt> work as expected.
+
+<p>
+To support Rich Comparisions, the Python C API was modified between
+Python versions 2.0 and 2.1. A new slot was introduced in the
+<tt>PyTypeObject</tt> structure: <tt>tp_richcompare</tt>. For backwards
+compatibility, a flag (<tt>Py_TPFLAGS_HAVE_RICHCOMPARE</tt>) has to be
+set to signal to the Python interpreter that Rich Comparisions are
+supported by a particular type.
+There is only one flag for all the six comparison operators.
+When any of the six operators is wrapped automatically or
+manually, Boost.Python will set this flag. Attempts to use comparison
+operators at the Python level that are not defined at the C++ level
+will then lead to an <tt>AttributeError</tt> when the Python 2.1
+(or higher) interpreter tries, e.g., <tt>a.__lt__(b)</tt>. That
+is, in general all six operators should be supplied. Automatically
+wrapped operators and manually wrapped operators can be mixed. For
+example:<pre>
+    boost::python::class_builder&lt;code&gt; py_code(this_module, "code");
+
+    py_code.def(boost::python::constructor&lt;&gt;());
+    py_code.def(boost::python::constructor&lt;int&gt;());
+    py_code.def(boost::python::operators&lt;(  boost::python::op_eq
+                                          | boost::python::op_ne)&gt;());
+    py_code.def(NotImplemented, "__lt__");
+    py_code.def(NotImplemented, "__le__");
+    py_code.def(NotImplemented, "__gt__");
+    py_code.def(NotImplemented, "__ge__");
+</pre>
+
+<tt>NotImplemented</tt> is a simple free function that (currently) has
+to be provided by the user. For example:<pre>
+  boost::python::ref
+  NotImplemented(const code&amp;, const code&amp;) {
+    return
+    boost::python::ref(Py_NotImplemented, boost::python::ref::increment_count);
+  }
+</pre>
+
+See also:
+<ul>
+<li><a href="../example/richcmp1.cpp"><tt>../example/richcmp1.cpp</tt></a>
+<li><a href="../example/richcmp2.cpp"><tt>../example/richcmp2.cpp</tt></a>
+<li><a href="../example/richcmp3.cpp"><tt>../example/richcmp3.cpp</tt></a>
+</ul>
+
+<hr>
+&copy; Copyright Nicholas K. Sauter &amp; Ralf W. Grosse-Kunstleve 2001.
+Permission to copy, use, modify, sell and distribute this document is
+granted provided this copyright notice appears in all copies. This
+document is provided "as is" without express or implied warranty, and
+with no claim as to its suitability for any purpose.
+
+<p>
+Updated: July 2001
+
+</div>
diff --git a/doc/special.html b/doc/special.html
index 0caa1924..46ca0791 100644
--- a/doc/special.html
+++ b/doc/special.html
@@ -60,13 +60,27 @@
           <b><tt class='method'>__str__</tt></b>(<i>self</i>)
         <dd>
           Create a string representation which is suitable for printing.
+        <dt>
+          <b><tt class='method'>__lt__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__le__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__eq__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__ne__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__gt__</tt></b>(<i>self, other</i>)
+        <dt>
+          <b><tt class='method'>__ge__</tt></b>(<i>self, other</i>)
+        <dd>
+	  Rich Comparison methods.
+          New in Python 2.1.
+          See <a href="richcmp.html">Rich Comparisons</a>.
         <dt>
           <b><tt class='method'>__cmp__</tt></b>(<i>self, other</i>)
         <dd>
-          Three-way compare function, used to implement comparison operators
-          (&lt; etc.) Should return a negative integer if <code> self < other
-          </code> , zero if <code> self == other </code> , a positive integer if
-          <code> self > other </code>.
+	  Three-way compare function.
+          See <a href="richcmp.html">Rich Comparisons</a>.
         <dt>
           <b><tt class='method'>__hash__</tt></b>(<i>self</i>)
         <dd>
@@ -544,17 +558,42 @@ Note that "__rrpow__" is an extension not present in plain Python.
             <code>__cmp__, __rcmp__</code>
           <td>
             <code>cmp(left, right)</code><br>
-             <code>left &lt; right</code><br>
-             <code>left &lt;= right</code><br>
-             <code>left &gt; right</code><br>
-             <code>left &gt;= right</code><br>
-             <code>left == right</code><br>
-             <code>left != right</code>
+            <br>See <a href="richcmp.html">Rich Comparisons</a>.
           <td>
             <code>op_cmp</code>
           <td>
             <code>cpp_left &lt; cpp_right </code>
         <br><code>cpp_right &lt; cpp_left</code>
+        <tr>
+          <td>
+                <code>__lt__</code>
+            <br><code>__le__</code>
+            <br><code>__eq__</code>
+            <br><code>__ne__</code>
+            <br><code>__gt__</code>
+            <br><code>__ge__</code>
+          <td>
+                <code>left &lt; right</code>
+            <br><code>left &lt;= right</code>
+            <br><code>left == right</code>
+            <br><code>left != right</code>
+            <br><code>left &gt; right</code>
+            <br><code>left &gt;= right</code>
+            <br>See <a href="richcmp.html">Rich Comparisons</a>
+          <td>
+                <code>op_lt</code>
+            <br><code>op_le</code>
+            <br><code>op_eq</code>
+            <br><code>op_ne</code>
+            <br><code>op_gt</code>
+            <br><code>op_ge</code>
+          <td>
+                <code>cpp_left &lt; cpp_right </code>
+            <br><code>cpp_left &lt;= cpp_right </code>
+            <br><code>cpp_left == cpp_right </code>
+            <br><code>cpp_left != cpp_right </code>
+            <br><code>cpp_left &gt; cpp_right </code>
+            <br><code>cpp_left &gt;= cpp_right </code>
 
         <tr>
           <td>
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
index bfa7dc54..cb598ae6 100644
--- a/example/pickle3.cpp
+++ b/example/pickle3.cpp
@@ -106,7 +106,7 @@ namespace {
   {
       if(args.size() != 1 || keywords.size() != 0) {
           PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
+          throw boost::python::error_already_set();
       }
       const world& w = from_python(args[0].get(), type<const world&>());
       ref mydict = getattr(args[0], "__dict__");
@@ -122,7 +122,7 @@ namespace {
   {
       if(args.size() != 2 || keywords.size() != 0) {
           PyErr_SetString(PyExc_TypeError, "wrong number of arguments");
-          throw boost::python::argument_error();
+          throw boost::python::error_already_set();
       }
       world& w = from_python(args[0].get(), type<world&>());
       ref mydict = getattr(args[0], "__dict__");
diff --git a/example/richcmp1.cpp b/example/richcmp1.cpp
new file mode 100644
index 00000000..4dd74e1b
--- /dev/null
+++ b/example/richcmp1.cpp
@@ -0,0 +1,87 @@
+// Example by Ralf W. Grosse-Kunstleve & Nicholas K. Sauter
+// This example shows how to use rich comparisons for a vector type.
+// It also shows how to template the entire wrapping of a std::vector.
+// See vector_wrapper.h.
+
+#include <boost/python/class_builder.hpp>
+#include "vector_wrapper.h"
+
+namespace vects {
+
+  struct dvect : public std::vector<double>
+  {
+    dvect() : std::vector<double>() {}
+    dvect(size_t n) : std::vector<double>(n) {}
+    dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator v_it = begin();
+      for (std::size_t i = 0; i < tuple.size(); i++)
+        v_it[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+          boost::python::type<double>());
+    }
+
+    boost::python::tuple as_tuple() const
+    {
+      boost::python::tuple t(size());
+      for (std::size_t i = 0; i < size(); i++)
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python((*this)[i])));
+      return t;
+    }
+
+#   define DVECT_BINARY_OPERATORS(oper) \
+    friend std::vector<bool> \
+    operator##oper(const dvect& lhs, const dvect& rhs) \
+    { \
+      if (lhs.size() != rhs.size()) { \
+        PyErr_SetString(PyExc_ValueError, "vectors have different sizes"); \
+        throw boost::python::error_already_set(); \
+      } \
+      std::vector<bool> result(lhs.size()); \
+      for (std::size_t i=0; i<lhs.size(); i++) { \
+        result[i] = (lhs[i] ##oper rhs[i]); \
+      } \
+      return result; \
+    }
+    DVECT_BINARY_OPERATORS(<)
+    DVECT_BINARY_OPERATORS(<=)
+    DVECT_BINARY_OPERATORS(==)
+    DVECT_BINARY_OPERATORS(!=)
+    DVECT_BINARY_OPERATORS(>)
+    DVECT_BINARY_OPERATORS(>=)
+#   undef VECTOR_BINARY_OPERATORS
+  };
+
+} // namespace <anonymous>
+
+
+namespace {
+
+  void init_module(boost::python::module_builder& this_module)
+  {
+    (void) example::wrap_vector(this_module, "vector_of_bool", bool());
+
+    boost::python::class_builder<vects::dvect> py_dvect(this_module, "dvect");
+
+    py_dvect.def(boost::python::constructor<boost::python::tuple>());
+    py_dvect.def(&vects::dvect::as_tuple, "as_tuple");
+
+    const long
+    comp_operators = (  boost::python::op_lt | boost::python::op_le
+                      | boost::python::op_eq | boost::python::op_ne
+                      | boost::python::op_gt | boost::python::op_ge);
+    py_dvect.def(boost::python::operators<comp_operators>());
+  }
+
+} // namespace <anonymous>
+
+BOOST_PYTHON_MODULE_INIT(richcmp1)
+{
+  try {
+    boost::python::module_builder this_module("richcmp1");
+    // The actual work is done in a separate function in order
+    // to suppress a bogus VC60 warning.
+    init_module(this_module);
+  }
+  catch (...) { boost::python::handle_exception(); }
+}
diff --git a/example/richcmp2.cpp b/example/richcmp2.cpp
new file mode 100644
index 00000000..213852b3
--- /dev/null
+++ b/example/richcmp2.cpp
@@ -0,0 +1,65 @@
+// Example by Ralf W. Grosse-Kunstleve
+// This example shows how to use rich comparisons for a type that
+// does not support all six operators (<, <=, ==, !=, >, >=).
+// To keep the example simple, we are using a "code" type does
+// not really require rich comparisons. __cmp__ would be sufficient.
+// However, with a more complicated type the main point of this
+// example would be in danger of getting lost.
+
+#include <boost/python/class_builder.hpp>
+
+namespace {
+
+  // suppose operator< and operator> are not meaningful for code
+  class code {
+    public:
+      code(int c = 0) : m_code(c) {}
+      inline friend bool operator==(const code& lhs, const code& rhs) {
+        return lhs.m_code == rhs.m_code;
+      }
+      inline friend bool operator!=(const code& lhs, const code& rhs) {
+        return lhs.m_code != rhs.m_code;
+      }
+    private:
+      int m_code;
+  };
+
+#if PYTHON_API_VERSION >= 1010
+  boost::python::ref
+  NotImplemented(const code&, const code&) {
+    return
+    boost::python::ref(Py_NotImplemented, boost::python::ref::increment_count);
+  }
+#endif
+}
+
+namespace {
+
+  void init_module(boost::python::module_builder& this_module)
+  {
+    boost::python::class_builder<code> py_code(this_module, "code");
+
+    py_code.def(boost::python::constructor<>());
+    py_code.def(boost::python::constructor<int>());
+    py_code.def(boost::python::operators<(  boost::python::op_eq
+                                          | boost::python::op_ne)>());
+#if PYTHON_API_VERSION >= 1010
+    py_code.def(NotImplemented, "__lt__");
+    py_code.def(NotImplemented, "__le__");
+    py_code.def(NotImplemented, "__gt__");
+    py_code.def(NotImplemented, "__ge__");
+#endif
+  }
+
+} // namespace <anonymous>
+
+BOOST_PYTHON_MODULE_INIT(richcmp2)
+{
+  try {
+    boost::python::module_builder this_module("richcmp2");
+    // The actual work is done in a separate function in order
+    // to suppress a bogus VC60 warning.
+    init_module(this_module);
+  }
+  catch (...) { boost::python::handle_exception(); }
+}
diff --git a/example/richcmp3.cpp b/example/richcmp3.cpp
new file mode 100644
index 00000000..169e7f00
--- /dev/null
+++ b/example/richcmp3.cpp
@@ -0,0 +1,178 @@
+// Example by Ralf W. Grosse-Kunstleve & Nicholas K. Sauter.
+// Comprehensive operator overloading for two vector types and scalars.
+
+#include <boost/python/class_builder.hpp>
+#include "vector_wrapper.h"
+#include "dvect.h"
+#include "ivect.h"
+
+#define VECT_VECT_OPERATORS(result_type, vect_type1, oper, vect_type2) \
+namespace vects { \
+  result_type \
+  operator##oper (const vect_type1& lhs, const vect_type2& rhs) { \
+    if (lhs.size() != rhs.size()) { \
+      PyErr_SetString(PyExc_ValueError, "vectors have different sizes"); \
+      throw boost::python::error_already_set(); \
+    } \
+    result_type result(lhs.size()); \
+    for (std::size_t i=0; i<lhs.size(); i++) { \
+      result[i] = (lhs[i] ##oper rhs[i]); \
+    } \
+    return result; \
+  } \
+}
+
+#define VECT_SCALAR_OPERATORS(result_type, vect_type, oper, scalar_type) \
+namespace vects { \
+  result_type \
+  operator##oper (const vect_type& lhs, const scalar_type& rhs) { \
+    result_type result(lhs.size()); \
+    for (std::size_t i=0; i<lhs.size(); i++) { \
+      result[i] = (lhs[i] ##oper rhs ); \
+    } \
+    return result; \
+  } \
+}
+
+#define SCALAR_VECT_OPERATORS(result_type, scalar_type, oper, vect_type) \
+namespace vects { \
+  result_type \
+  operator##oper (const scalar_type& lhs, const vect_type& rhs) { \
+    result_type result(rhs.size()); \
+    for (std::size_t i=0; i<rhs.size(); i++) { \
+      result[i] = (lhs ##oper rhs[i]); \
+    } \
+    return result; \
+  } \
+}
+
+#define MATH_VECT_VECT_OPERATORS(result_type, vect_type1, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, +, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, -, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, *, vect_type2) \
+  VECT_VECT_OPERATORS(result_type, vect_type1, /, vect_type2)
+
+#define COMP_VECT_VECT_OPERATORS(vect_type1, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, <,  vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, <=, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, ==, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, !=, vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, >,  vect_type2) \
+  VECT_VECT_OPERATORS(std::vector<bool>, vect_type1, >=, vect_type2)
+
+#define MATH_VECT_SCALAR_OPERATORS(result_type, vect_type, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, +, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, -, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, *, scalar_type) \
+  VECT_SCALAR_OPERATORS(result_type, vect_type, /, scalar_type)
+
+#define COMP_VECT_SCALAR_OPERATORS(vect_type, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, <,  scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, <=, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, ==, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, !=, scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, >,  scalar_type) \
+  VECT_SCALAR_OPERATORS(std::vector<bool>, vect_type, >=, scalar_type)
+
+#define MATH_SCALAR_VECT_OPERATORS(result_type, scalar_type, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, +, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, -, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, *, vect_type) \
+  SCALAR_VECT_OPERATORS(result_type, scalar_type, /, vect_type)
+
+MATH_VECT_VECT_OPERATORS(dvect, dvect, dvect)
+COMP_VECT_VECT_OPERATORS(       dvect, dvect)
+MATH_VECT_SCALAR_OPERATORS(dvect, dvect, double)
+COMP_VECT_SCALAR_OPERATORS(       dvect, double)
+MATH_SCALAR_VECT_OPERATORS(dvect, double, dvect)
+// comparison operators not needed since Python uses reflection
+
+MATH_VECT_VECT_OPERATORS(ivect, ivect, ivect)
+COMP_VECT_VECT_OPERATORS(       ivect, ivect)
+MATH_VECT_SCALAR_OPERATORS(ivect, ivect, int)
+COMP_VECT_SCALAR_OPERATORS(       ivect, int)
+MATH_SCALAR_VECT_OPERATORS(ivect, int, ivect)
+// comparison operators not needed since Python uses reflection
+
+MATH_VECT_VECT_OPERATORS(dvect, dvect, ivect)
+COMP_VECT_VECT_OPERATORS(       dvect, ivect)
+MATH_VECT_VECT_OPERATORS(dvect, ivect, dvect)
+COMP_VECT_VECT_OPERATORS(       ivect, dvect)
+
+#undef VECT_VECT_OPERATORS
+#undef SCALAR_VECT_OPERATORS
+#undef VECT_SCALAR_OPERATORS
+#undef MATH_VECT_VECT_OPERATORS
+#undef COMP_VECT_VECT_OPERATORS
+#undef MATH_VECT_SCALAR_OPERATORS
+#undef COMP_VECT_SCALAR_OPERATORS
+#undef MATH_SCALAR_VECT_OPERATORS
+
+namespace {
+
+  void init_module(boost::python::module_builder& this_module)
+  {
+    (void) example::wrap_vector(this_module, "vector_of_bool", bool());
+
+    const long
+    math_operators (  boost::python::op_mul | boost::python::op_add
+                    | boost::python::op_div | boost::python::op_sub);
+    const long
+    comp_operators = (  boost::python::op_lt | boost::python::op_le
+                      | boost::python::op_eq | boost::python::op_ne
+                      | boost::python::op_gt | boost::python::op_ge);
+
+    boost::python::class_builder<vects::dvect>
+      dvect_class(this_module, "dvect");
+    boost::python::class_builder<vects::ivect>
+      ivect_class(this_module, "ivect");
+
+    dvect_class.def(boost::python::constructor<boost::python::tuple>());
+    dvect_class.def(&vects::dvect::as_tuple,"as_tuple");
+
+    dvect_class.def(boost::python::operators<math_operators>());
+    dvect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<double>() );
+    dvect_class.def(boost::python::operators<math_operators>(),
+      boost::python::left_operand<double>() );
+    dvect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<vects::ivect>() );
+
+    dvect_class.def(boost::python::operators<comp_operators>());
+    dvect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<double>() );
+    // left_operand not needed since Python uses reflection
+    dvect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<vects::ivect>() );
+
+    ivect_class.def(boost::python::constructor<boost::python::tuple>());
+    ivect_class.def(&vects::ivect::as_tuple,"as_tuple");
+
+    ivect_class.def(boost::python::operators<math_operators>());
+    ivect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<int>() );
+    ivect_class.def(boost::python::operators<math_operators>(),
+      boost::python::left_operand<int>() );
+    ivect_class.def(boost::python::operators<math_operators>(),
+      boost::python::right_operand<vects::dvect>() );
+
+    ivect_class.def(boost::python::operators<comp_operators>());
+    ivect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<int>() );
+    // left_operand not needed since Python uses reflection
+    ivect_class.def(boost::python::operators<comp_operators>(),
+      boost::python::right_operand<vects::dvect>() );
+  }
+
+} // namespace <anonymous>
+
+BOOST_PYTHON_MODULE_INIT(richcmp3)
+{
+  try {
+    boost::python::module_builder this_module("richcmp3");
+    // The actual work is done in a separate function in order
+    // to suppress a bogus VC60 warning.
+    init_module(this_module);
+  }
+  catch (...) { boost::python::handle_exception(); }
+}
diff --git a/example/test_pickle3.py b/example/test_pickle3.py
index 36da735d..6ac83b18 100644
--- a/example/test_pickle3.py
+++ b/example/test_pickle3.py
@@ -19,12 +19,12 @@ r'''>>> import pickle3
     ...   wd.z = 3. * number
     ...   pstr = pickle.dumps(wd)
     ...   wl = pickle.loads(pstr)
-    ...   print wd.greet(), wd.get_secret_number(), wd.__dict__
-    ...   print wl.greet(), wl.get_secret_number(), wl.__dict__
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 24 {'z': 72.0, 'x': 48, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 42 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
-    Hello from California! 0 {'z': 126.0, 'x': 84, 'y': 'yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'}
+    ...   print wd.greet(), wd.get_secret_number(), wd.x, wd.y, wd.z
+    ...   print wl.greet(), wl.get_secret_number(), wl.x, wl.y, wl.z
+    Hello from California! 24 48 yyyyyyyyyyyyyyyyyyyyyyyy 72.0
+    Hello from California! 24 48 yyyyyyyyyyyyyyyyyyyyyyyy 72.0
+    Hello from California! 42 84 yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy 126.0
+    Hello from California! 0 84 yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy 126.0
 '''
 
 def run(args = None):
diff --git a/example/test_richcmp1.py b/example/test_richcmp1.py
new file mode 100644
index 00000000..d25fcc9c
--- /dev/null
+++ b/example/test_richcmp1.py
@@ -0,0 +1,40 @@
+r'''>>> import richcmp1
+    >>> d1 = richcmp1.dvect((0, 1, 3, 3, 6, 7))
+    >>> d2 = richcmp1.dvect((1, 2, 3, 4, 5, 6))
+    >>> print d1.as_tuple()
+    (0.0, 1.0, 3.0, 3.0, 6.0, 7.0)
+    >>> print d2.as_tuple()
+    (1.0, 2.0, 3.0, 4.0, 5.0, 6.0)
+    >>> print (d1 < d2).as_tuple()
+    (1, 1, 0, 1, 0, 0)
+    >>> print (d1 <= d2).as_tuple()
+    (1, 1, 1, 1, 0, 0)
+    >>> print (d1 == d2).as_tuple()
+    (0, 0, 1, 0, 0, 0)
+    >>> print (d1 != d2).as_tuple()
+    (1, 1, 0, 1, 1, 1)
+    >>> print (d1 > d2).as_tuple()
+    (0, 0, 0, 0, 1, 1)
+    >>> print (d1 >= d2).as_tuple()
+    (0, 0, 1, 0, 1, 1)
+    >>> try: d1 == richcmp1.dvect((1, 2, 3, 4, 5))
+    ... except ValueError, e: print str(e)
+    ...
+    vectors have different sizes
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_richcmp1
+    return doctest.testmod(test_richcmp1)
+
+if __name__ == '__main__':
+    import sys
+    if (    hasattr(sys, 'version_info')
+        and (   (sys.version_info[0] == 2 and sys.version_info[1] >= 1)
+             or sys.version_info[0] > 2)):
+      sys.exit(run()[0])
+    else:
+      print "Python version 2.1 or higher required. Test skipped."
diff --git a/example/test_richcmp2.py b/example/test_richcmp2.py
new file mode 100644
index 00000000..859928c3
--- /dev/null
+++ b/example/test_richcmp2.py
@@ -0,0 +1,41 @@
+r'''>>> import richcmp2
+    >>> c1 = richcmp2.code(1)
+    >>> c2 = richcmp2.code(2)
+    >>> c3 = richcmp2.code(2)
+    >>> print c1 == c2
+    0
+    >>> print c1 != c2
+    1
+    >>> print c2 == c3
+    1
+    >>> print c2 != c3
+    0
+    >>> print c1 < c2
+    1
+    >>> print c1 <= c2
+    1
+    >>> print c1 == c2
+    0
+    >>> print c1 != c2
+    1
+    >>> print c1 > c2
+    0
+    >>> print c1 >= c2
+    0
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_richcmp1
+    return doctest.testmod(test_richcmp1)
+
+if __name__ == '__main__':
+    import sys
+    if (    hasattr(sys, 'version_info')
+        and (   (sys.version_info[0] == 2 and sys.version_info[1] >= 1)
+             or sys.version_info[0] > 2)):
+      sys.exit(run()[0])
+    else:
+      print "Python version 2.1 or higher required. Test skipped."
diff --git a/example/test_richcmp3.py b/example/test_richcmp3.py
new file mode 100644
index 00000000..a769af17
--- /dev/null
+++ b/example/test_richcmp3.py
@@ -0,0 +1,77 @@
+r'''>>> import richcmp3
+    >>>
+    >>> iv = richcmp3.ivect((1,2,3,4,5))
+    >>> print iv.as_tuple()
+    (1, 2, 3, 4, 5)
+    >>> dv = richcmp3.dvect((2,-2,3,8,-5))
+    >>> print dv.as_tuple()
+    (2.0, -2.0, 3.0, 8.0, -5.0)
+    >>>
+    >>> print (iv+dv).as_tuple()
+    (3.0, 0.0, 6.0, 12.0, 0.0)
+    >>> print (iv+3).as_tuple()
+    (4, 5, 6, 7, 8)
+    >>> print (3+iv).as_tuple()
+    (4, 5, 6, 7, 8)
+    >>>
+    >>> print "vect vs. vect Comparisons:"
+    vect vs. vect Comparisons:
+    >>> print (iv < dv).as_tuple()
+    (1, 0, 0, 1, 0)
+    >>> print (iv <= dv).as_tuple()
+    (1, 0, 1, 1, 0)
+    >>> print (iv == dv).as_tuple()
+    (0, 0, 1, 0, 0)
+    >>> print (iv != dv).as_tuple()
+    (1, 1, 0, 1, 1)
+    >>> print (iv > dv).as_tuple()
+    (0, 1, 0, 0, 1)
+    >>> print (iv >= dv).as_tuple()
+    (0, 1, 1, 0, 1)
+    >>>
+    >>> print "vect vs. scalar Comparisons:"
+    vect vs. scalar Comparisons:
+    >>> print (iv < 3).as_tuple()
+    (1, 1, 0, 0, 0)
+    >>> print (iv <= 3).as_tuple()
+    (1, 1, 1, 0, 0)
+    >>> print (iv == 3).as_tuple()
+    (0, 0, 1, 0, 0)
+    >>> print (iv != 3).as_tuple()
+    (1, 1, 0, 1, 1)
+    >>> print (iv > 3).as_tuple()
+    (0, 0, 0, 1, 1)
+    >>> print (iv >= 3).as_tuple()
+    (0, 0, 1, 1, 1)
+    >>>
+    >>> print "scalar  vs. vect Comparisons:"
+    scalar  vs. vect Comparisons:
+    >>> print (3 < iv).as_tuple()
+    (0, 0, 0, 1, 1)
+    >>> print (3 <= iv).as_tuple()
+    (0, 0, 1, 1, 1)
+    >>> print (3 == iv).as_tuple()
+    (0, 0, 1, 0, 0)
+    >>> print (3 != iv).as_tuple()
+    (1, 1, 0, 1, 1)
+    >>> print (3 > iv).as_tuple()
+    (1, 1, 0, 0, 0)
+    >>> print (3 >= iv).as_tuple()
+    (1, 1, 1, 0, 0)
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_richcmp3
+    return doctest.testmod(test_richcmp3)
+
+if __name__ == '__main__':
+    import sys
+    if (    hasattr(sys, 'version_info')
+        and (   (sys.version_info[0] == 2 and sys.version_info[1] >= 1)
+             or sys.version_info[0] > 2)):
+      sys.exit(run()[0])
+    else:
+      print "Python version 2.1 or higher required. Test skipped."
diff --git a/example/vector_wrapper.h b/example/vector_wrapper.h
new file mode 100644
index 00000000..d5bd7215
--- /dev/null
+++ b/example/vector_wrapper.h
@@ -0,0 +1,117 @@
+// Based on wrapVector.hh by Mike Owen and Jeff Johnson.
+// http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/spheral/src/src/BPLWraps/CXXWraps/
+
+#ifndef BOOST_PYTHON_EXAMPLE_VECTOR_WRAPPER_H
+#define BOOST_PYTHON_EXAMPLE_VECTOR_WRAPPER_H
+
+#include <boost/python/class_builder.hpp>
+
+namespace example {
+
+  // A wrapper is used to define additional constructors. This wrapper
+  // is templated on the template parameter for its corresponding vector.
+  template <typename T>
+  struct vector_wrapper: std::vector<T>
+  {
+    // Tell the compiler how to convert a base class object to
+    // this wrapper object.
+    vector_wrapper(PyObject*,
+                  const std::vector<T>& vec):
+      std::vector<T>(vec) {}
+
+    vector_wrapper(PyObject* self):
+      std::vector<T>() {}
+
+    vector_wrapper(PyObject* self,
+                   std::size_t n):
+      std::vector<T>(n) {}
+
+    vector_wrapper(PyObject* self,
+                   boost::python::tuple tuple):
+      std::vector<T>(tuple.size())
+    {
+      std::vector<T>::iterator vec = begin();
+      for (std::size_t i = 0; i < tuple.size(); i++)
+        vec[i] = BOOST_PYTHON_CONVERSION::from_python(tuple[i].get(),
+                                            boost::python::type<T>());
+    }
+  };
+
+  void raise_vector_IndexError() {
+    PyErr_SetString(PyExc_IndexError, "vector index out of range");
+    throw boost::python::error_already_set();
+  }
+
+  template <typename T>
+  struct vector_access
+  {
+    static
+    T
+    getitem(const std::vector<T>& vec,
+            std::size_t key)
+    {
+      if (key >= vec.size()) raise_vector_IndexError();
+      return vec[key];
+    }
+
+    static
+    void
+    setitem(std::vector<T>& vec,
+            std::size_t key,
+            const T &value)
+    {
+      if (key >= vec.size()) raise_vector_IndexError();
+      vec[key] = value;
+    }
+
+    static
+    void
+    delitem(std::vector<T>& vec,
+            std::size_t key)
+    {
+      if (key >= vec.size()) raise_vector_IndexError();
+      vec.erase(vec.begin() + key);
+    }
+
+    // Convert vector<T> to a regular Python tuple.
+    static
+    boost::python::tuple
+    as_tuple(const std::vector<T>& vec)
+    {
+      // Create a python type of size vec.size().
+      boost::python::tuple t(vec.size());
+      for (std::size_t i = 0; i < vec.size(); i++) {
+        t.set_item(i,
+          boost::python::ref(BOOST_PYTHON_CONVERSION::to_python(vec[i])));
+      }
+      return t;
+    }
+  };
+
+  // This function will build a vector<T> and add it to the given
+  // module with the given name.
+  template <typename T>
+  boost::python::class_builder<std::vector<T>, vector_wrapper<T> >
+  wrap_vector(boost::python::module_builder& module,
+              const std::string& vector_name,
+              const T&)
+  {
+    // Add the vector<T> to the module.
+    boost::python::class_builder<std::vector<T>, vector_wrapper<T> >
+    py_vector(module, vector_name.c_str());
+
+    // Define constructors and methods for the vector<T>.
+    py_vector.def(boost::python::constructor<>());
+    py_vector.def(boost::python::constructor<std::size_t>());
+    py_vector.def(boost::python::constructor<boost::python::tuple>());
+    py_vector.def(&std::vector<T>::size, "__len__");
+    py_vector.def(&vector_access<T>::getitem, "__getitem__");
+    py_vector.def(&vector_access<T>::setitem, "__setitem__");
+    py_vector.def(&vector_access<T>::delitem, "__delitem__");
+    py_vector.def(&vector_access<T>::as_tuple, "as_tuple");
+
+    return py_vector;
+  }
+}
+
+#endif // BOOST_PYTHON_EXAMPLE_VECTOR_WRAPPER_H
diff --git a/include/boost/python/classes.hpp b/include/boost/python/classes.hpp
index d38fbba5..2d69e81e 100644
--- a/include/boost/python/classes.hpp
+++ b/include/boost/python/classes.hpp
@@ -70,6 +70,14 @@ class instance
     PyObject* oct();
     PyObject* hex();
 
+    // Rich comparisons
+    PyObject* lt(PyObject* other);
+    PyObject* le(PyObject* other);
+    PyObject* eq(PyObject* other);
+    PyObject* ne(PyObject* other);
+    PyObject* gt(PyObject* other);
+    PyObject* ge(PyObject* other);
+
  private: // noncopyable, without the size bloat
     instance(const instance&);
     void operator=(const instance&);
@@ -169,6 +177,14 @@ class class_t
     PyObject* instance_number_float(PyObject*) const;
     PyObject* instance_number_oct(PyObject*) const;
     PyObject* instance_number_hex(PyObject*) const;
+
+ private: // Implement rich comparisons
+    PyObject* instance_lt(PyObject*, PyObject*) const;
+    PyObject* instance_le(PyObject*, PyObject*) const;
+    PyObject* instance_eq(PyObject*, PyObject*) const;
+    PyObject* instance_ne(PyObject*, PyObject*) const;
+    PyObject* instance_gt(PyObject*, PyObject*) const;
+    PyObject* instance_ge(PyObject*, PyObject*) const;
     
  private: // Miscellaneous "special" methods
     PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const;
@@ -477,6 +493,42 @@ PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
     return downcast<T>(obj)->hex();
 }
 
+template <class T>
+PyObject* class_t<T>::instance_lt(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->lt(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_le(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->le(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_eq(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->eq(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_ne(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->ne(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_gt(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->gt(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_ge(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->ge(other);
+}
+
 namespace detail {
   inline dictionary& class_base::dict()
   {
diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 5c8e720a..d871ad6e 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -616,6 +616,12 @@ class extension_class
         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_op<(which & op_gt)>::template args<Operand>::add(this);
+        choose_op<(which & op_ge)>::template args<Operand>::add(this);
+        choose_op<(which & op_lt)>::template args<Operand>::add(this);
+        choose_op<(which & op_le)>::template args<Operand>::add(this);
+        choose_op<(which & op_eq)>::template args<Operand>::add(this);
+        choose_op<(which & op_ne)>::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);
@@ -645,6 +651,12 @@ class extension_class
         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);
+        choose_op<(which & op_gt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ge)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_lt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_le)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_eq)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ne)>::template args<Left,Right>::add(this);
     }
     
     template <long which, class Left, class Right>
diff --git a/include/boost/python/detail/types.hpp b/include/boost/python/detail/types.hpp
index 5f0c8f97..2d0d0f6b 100644
--- a/include/boost/python/detail/types.hpp
+++ b/include/boost/python/detail/types.hpp
@@ -45,7 +45,7 @@ class type_object_base : public python_type
 
  public:
     enum capability {
-        hash, call, str, getattr, setattr, compare, repr,
+        hash, call, str, getattr, setattr, compare, repr, richcompare,
 
         mapping_length, mapping_subscript, mapping_ass_subscript,
         
@@ -115,6 +115,14 @@ class type_object_base : public python_type
     virtual PyObject* instance_number_float(PyObject*) const;
     virtual PyObject* instance_number_oct(PyObject*) const;
     virtual PyObject* instance_number_hex(PyObject*) const;
+
+ public: // Callbacks for rich comparisons
+    virtual PyObject* instance_lt(PyObject*, PyObject*) const;
+    virtual PyObject* instance_le(PyObject*, PyObject*) const;
+    virtual PyObject* instance_eq(PyObject*, PyObject*) const;
+    virtual PyObject* instance_ne(PyObject*, PyObject*) const;
+    virtual PyObject* instance_gt(PyObject*, PyObject*) const;
+    virtual PyObject* instance_ge(PyObject*, PyObject*) const;
 };
 
 template <class T>
diff --git a/include/boost/python/operators.hpp b/include/boost/python/operators.hpp
index da88ec6c..52e52eee 100644
--- a/include/boost/python/operators.hpp
+++ b/include/boost/python/operators.hpp
@@ -65,7 +65,13 @@ enum operator_id
     op_long = 0x20000, 
     op_float = 0x40000, 
     op_str = 0x80000,
-    op_cmp = 0x100000 
+    op_cmp = 0x100000,
+    op_gt = 0x200000,
+    op_ge = 0x400000,
+    op_lt = 0x800000,
+    op_le = 0x1000000,
+    op_eq = 0x2000000,
+    op_ne = 0x4000000
 };
 
 // Wrap the operators given by "which". Usage:
@@ -301,6 +307,12 @@ namespace detail
   PY_DEFINE_BINARY_OPERATORS(and, &);
   PY_DEFINE_BINARY_OPERATORS(xor, ^);
   PY_DEFINE_BINARY_OPERATORS(or, |);
+  PY_DEFINE_BINARY_OPERATORS(gt, >);
+  PY_DEFINE_BINARY_OPERATORS(ge, >=);
+  PY_DEFINE_BINARY_OPERATORS(lt, <);
+  PY_DEFINE_BINARY_OPERATORS(le, <=);
+  PY_DEFINE_BINARY_OPERATORS(eq, ==);
+  PY_DEFINE_BINARY_OPERATORS(ne, !=);
 
   PY_DEFINE_UNARY_OPERATORS(neg, -);
   PY_DEFINE_UNARY_OPERATORS(pos, +);
diff --git a/src/classes.cpp b/src/classes.cpp
index 8755bb34..a44c3c0a 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -736,6 +736,36 @@ PyObject* instance::hex()
     return callback<PyObject*>::call_method(this, "__hex__");
 }
 
+PyObject* instance::lt(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__lt__", other);
+}
+
+PyObject* instance::le(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__le__", other);
+}
+
+PyObject* instance::eq(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__eq__", other);
+}
+
+PyObject* instance::ne(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ne__", other);
+}
+
+PyObject* instance::gt(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__gt__", other);
+}
+
+PyObject* instance::ge(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ge__", other);
+}
+
 namespace {
   struct named_capability
   {
@@ -747,6 +777,12 @@ namespace {
   {
       { "__hash__", detail::type_object_base::hash },
       { "__cmp__", detail::type_object_base::compare },
+      { "__gt__", detail::type_object_base::richcompare },
+      { "__ge__", detail::type_object_base::richcompare },
+      { "__lt__", detail::type_object_base::richcompare },
+      { "__le__", detail::type_object_base::richcompare },
+      { "__eq__", detail::type_object_base::richcompare },
+      { "__ne__", detail::type_object_base::richcompare },
       { "__repr__", detail::type_object_base::repr },
       { "__str__", detail::type_object_base::str },
       { "__call__", detail::type_object_base::call },
diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index 8de8a1ae..57189a7d 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -15,6 +15,7 @@ def gen_extclass(args):
 //  gen_extclass.python
 
 //  Revision History:
+//  17 Apr 01  Comment added with reference to cross_module.hpp (R.W. Grosse-Kunstleve)
 //  05 Mar 01  Fixed a bug which prevented auto_ptr values from being converted
 //             to_python (Dave Abrahams)
 
@@ -171,6 +172,14 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 // 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>.
+//
+// A look-alike of this class in root/boost/python/cross_module.hpp
+// is used for the implementation of the cross-module support
+// (export_converters and import_converters). If from_python
+// and to_python converters are added or removed from the class
+// below, the class python_import_extension_class_converters has
+// to be modified accordingly.
+//
 template <class T, class U = boost::python::detail::held_instance<T> >
 class python_extension_class_converters
 {
@@ -607,6 +616,12 @@ class extension_class
         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_op<(which & op_gt)>::template args<Operand>::add(this);
+        choose_op<(which & op_ge)>::template args<Operand>::add(this);
+        choose_op<(which & op_lt)>::template args<Operand>::add(this);
+        choose_op<(which & op_le)>::template args<Operand>::add(this);
+        choose_op<(which & op_eq)>::template args<Operand>::add(this);
+        choose_op<(which & op_ne)>::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);
@@ -636,6 +651,12 @@ class extension_class
         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);
+        choose_op<(which & op_gt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ge)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_lt)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_le)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_eq)>::template args<Left,Right>::add(this);
+        choose_op<(which & op_ne)>::template args<Left,Right>::add(this);
     }
     
     template <long which, class Left, class Right>
diff --git a/src/gen_init_function.py b/src/gen_init_function.py
index 69935230..80a9c199 100644
--- a/src/gen_init_function.py
+++ b/src/gen_init_function.py
@@ -79,7 +79,8 @@ namespace detail {
   struct parameter_traits
   {
    private:
-      typedef const_ref_selector<boost::is_reference<T>::value> selector;
+      enum { is_ref = boost::is_reference<T>::value };
+      typedef const_ref_selector<is_ref> selector;
    public:
       typedef typename selector::template const_ref<T>::type const_reference;
   };
diff --git a/src/types.cpp b/src/types.cpp
index 7ba5840b..f8cf1ea6 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -159,6 +159,28 @@ static PyObject* do_instance_repr(PyObject* obj)
     return call(obj, &type_object_base::instance_repr);
 }
 
+static PyObject* do_instance_richcompare(PyObject* obj, PyObject* other, int d)
+{
+#if PYTHON_API_VERSION >= 1010
+    switch(d)
+    {
+        case Py_LT: 
+          return call(obj, &type_object_base::instance_lt, other);
+        case Py_LE: 
+          return call(obj, &type_object_base::instance_le, other);
+        case Py_EQ: 
+          return call(obj, &type_object_base::instance_eq, other);
+        case Py_NE: 
+          return call(obj, &type_object_base::instance_ne, other);
+        case Py_GT: 
+          return call(obj, &type_object_base::instance_gt, other);
+        case Py_GE: 
+          return call(obj, &type_object_base::instance_ge, other);
+    }
+#endif
+    return 0;
+}
+
 static int do_instance_compare(PyObject* obj, PyObject* other)
 {
     return call(obj, &type_object_base::instance_compare, other);
@@ -406,7 +428,7 @@ namespace
 bool add_capability_general(type_object_base::capability capability, PyTypeObject* dest)
 {
     assert(dest != 0);
-    
+
     switch(capability)
     {
         ENABLE_GENERAL_CAPABILITY(hash);
@@ -435,6 +457,20 @@ void create_method_table_if_null(T*& table)
     }
 }
 
+bool add_capability_richcompare(type_object_base::capability capability, PyTypeObject* dest)
+{
+    assert(dest != 0);
+    if (capability == type_object_base::richcompare) {
+#if PYTHON_API_VERSION >= 1010
+      dest->tp_richcompare = &do_instance_richcompare;
+      dest->tp_flags |= Py_TPFLAGS_HAVE_RICHCOMPARE;
+#endif
+      return true;
+    }
+    
+    return false;
+}
+
 #define ENABLE_MAPPING_CAPABILITY(field) \
     case type_object_base::mapping_##field: \
         create_method_table_if_null(dest); \
@@ -548,6 +584,8 @@ namespace detail  {
   {
     if(add_capability_general(capability, dest_))
         return;
+    if(add_capability_richcompare(capability, dest_))
+        return;
     if(add_capability_mapping(capability, dest_->tp_as_mapping))
         return;
     if(add_capability_sequence(capability, dest_->tp_as_sequence))
@@ -975,6 +1013,36 @@ PyObject* type_object_base::instance_number_hex(PyObject*) const
     return unimplemented("instance_number_hex");
 }
 
+PyObject* type_object_base::instance_lt(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_lt");
+}
+
+PyObject* type_object_base::instance_le(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_le");
+}
+
+PyObject* type_object_base::instance_eq(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_eq");
+}
+
+PyObject* type_object_base::instance_ne(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_ne");
+}
+
+PyObject* type_object_base::instance_gt(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_gt");
+}
+
+PyObject* type_object_base::instance_ge(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_ge");
+}
+
 }} // namespace boost::python
 
 #ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
diff --git a/test/comprehensive.py b/test/comprehensive.py
index 013fae96..db4f8b73 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -422,7 +422,7 @@ Some simple overloading tests:
     >>> try: r = Range('yikes')
     ... except TypeError, e:
     ...     assert re.match(
-    ... 'No overloaded functions match [(]Range, string[)]\. Candidates are:\n.*\n.*',
+    ... 'No overloaded functions match [(]Range, str[a-z]*[)]\. Candidates are:\n.*\n.*',
     ...  str(e))
     ... else: print 'no exception'
     
@@ -632,7 +632,7 @@ Testing overloaded free functions
     15
     >>> try: overloaded(1, 'foo')
     ... except TypeError, err:
-    ...     assert re.match("No overloaded functions match \(int, string\)\. Candidates are:",
+    ...     assert re.match("No overloaded functions match \(int, str[a-z]*\)\. Candidates are:",
     ...                     str(err))
     ... else:
     ...     print 'no exception'
@@ -662,7 +662,7 @@ Testing overloaded constructors
     5
     >>> try: over = OverloadTest(1, 'foo')
     ... except TypeError, err:
-    ...     assert re.match("No overloaded functions match \(OverloadTest, int, string\)\. Candidates are:",
+    ...     assert re.match("No overloaded functions match \(OverloadTest, int, str[a-z]*\)\. Candidates are:",
     ...                     str(err))
     ... else:
     ...     print 'no exception'
@@ -684,7 +684,7 @@ Testing overloaded methods
     5
     >>> try: over.overloaded(1,'foo')
     ... except TypeError, err:
-    ...     assert re.match("No overloaded functions match \(OverloadTest, int, string\)\. Candidates are:",
+    ...     assert re.match("No overloaded functions match \(OverloadTest, int, str[a-z]*\)\. Candidates are:",
     ...                     str(err))
     ... else:
     ...     print 'no exception'

From 801cae13ac53968a3f65556d855ea84f08835999 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 31 Jul 2001 07:39:05 +0000
Subject: [PATCH 132/369] Macintosh mods: do_it_yourself_converters ->
 do_it_yourself_convts

[SVN r10729]
---
 build/Jamfile                                        |  4 ++--
 build/filemgr.py                                     |  6 +++---
 build/irix_CC.mak                                    | 12 ++++++------
 build/linux_gcc.mak                                  | 12 ++++++------
 build/mingw32.mak                                    | 12 ++++++------
 build/tru64_cxx.mak                                  | 12 ++++++------
 build/vc60.mak                                       |  8 ++++----
 example/README                                       |  2 +-
 ...self_converters.cpp => do_it_yourself_convts.cpp} |  4 ++--
 ...f_converters.py => test_do_it_yourself_convts.py} |  8 ++++----
 10 files changed, 40 insertions(+), 40 deletions(-)
 rename example/{do_it_yourself_converters.cpp => do_it_yourself_convts.cpp} (97%)
 rename example/{test_do_it_yourself_converters.py => test_do_it_yourself_convts.py} (63%)

diff --git a/build/Jamfile b/build/Jamfile
index 314b1440..562aca1e 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -25,7 +25,7 @@
 #         getting_started1      -
 #         getting_started2      -
 #         simple_vector         -
-#         do_it_yourself_converters -
+#         do_it_yourself_convts -
 #         pickle1               -
 #         pickle2               -
 #         pickle3               -
@@ -215,7 +215,7 @@ boost-python-example-test abstract ;
 boost-python-example-test getting_started1 ;
 boost-python-example-test getting_started2 ;
 boost-python-example-test simple_vector ;
-boost-python-example-test do_it_yourself_converters ;
+boost-python-example-test do_it_yourself_convts ;
 boost-python-example-test pickle1 ;
 boost-python-example-test pickle2 ;
 boost-python-example-test pickle3 ;
diff --git a/build/filemgr.py b/build/filemgr.py
index 5e32460e..2ff163f0 100644
--- a/build/filemgr.py
+++ b/build/filemgr.py
@@ -23,7 +23,7 @@ bpl_exa + "/abstract.cpp",
 bpl_exa + "/getting_started1.cpp",
 bpl_exa + "/getting_started2.cpp",
 bpl_exa + "/simple_vector.cpp",
-bpl_exa + "/do_it_yourself_converters.cpp",
+bpl_exa + "/do_it_yourself_convts.cpp",
 bpl_exa + "/pickle1.cpp",
 bpl_exa + "/pickle2.cpp",
 bpl_exa + "/pickle3.cpp",
@@ -31,7 +31,7 @@ bpl_exa + "/test_abstract.py",
 bpl_exa + "/test_getting_started1.py",
 bpl_exa + "/test_getting_started2.py",
 bpl_exa + "/test_simple_vector.py",
-bpl_exa + "/test_do_it_yourself_converters.py",
+bpl_exa + "/test_do_it_yourself_convts.py",
 bpl_exa + "/test_pickle1.py",
 bpl_exa + "/test_pickle2.py",
 bpl_exa + "/test_pickle3.py",
@@ -67,7 +67,7 @@ defs = (
 "getting_started1",
 "getting_started2",
 "simple_vector",
-"do_it_yourself_converters",
+"do_it_yourself_convts",
 "pickle1",
 "pickle2",
 "pickle3",
diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index 1fbe3388..6e465b98 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -43,7 +43,7 @@ DEPOBJ=$(OBJ) \
        abstract.o \
        getting_started1.o getting_started2.o \
        simple_vector.o \
-       do_it_yourself_converters.o \
+       do_it_yourself_convts.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
        ivect.o dvect.o \
@@ -56,7 +56,7 @@ all: libboost_python.a \
      abstract.so \
      getting_started1.so getting_started2.so \
      simple_vector.so \
-     do_it_yourself_converters.so \
+     do_it_yourself_convts.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
      ivect.so dvect.so \
@@ -81,8 +81,8 @@ getting_started2.so: $(OBJ) getting_started2.o
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
 
 pickle1.so: $(OBJ) pickle1.o
 	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
@@ -125,7 +125,7 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_do_it_yourself_convts.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
@@ -141,7 +141,7 @@ clean:
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
 	rm -f simple_vector.o simple_vector.so
-	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
 	rm -f pickle1.o pickle1.so
 	rm -f pickle2.o pickle2.so
 	rm -f pickle3.o pickle3.so
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index 3fe407a0..2c977473 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -44,7 +44,7 @@ DEPOBJ=$(OBJ) \
        abstract.o \
        getting_started1.o getting_started2.o \
        simple_vector.o \
-       do_it_yourself_converters.o \
+       do_it_yourself_convts.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
        ivect.o dvect.o \
@@ -57,7 +57,7 @@ all: libboost_python.a \
      abstract.so \
      getting_started1.so getting_started2.so \
      simple_vector.so \
-     do_it_yourself_converters.so \
+     do_it_yourself_convts.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
      ivect.so dvect.so \
@@ -82,8 +82,8 @@ getting_started2.so: $(OBJ) getting_started2.o
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
 
 pickle1.so: $(OBJ) pickle1.o
 	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
@@ -126,7 +126,7 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_do_it_yourself_convts.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
@@ -142,7 +142,7 @@ clean:
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
 	rm -f simple_vector.o simple_vector.so
-	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
 	rm -f pickle1.o pickle1.so
 	rm -f pickle2.o pickle2.so
 	rm -f pickle3.o pickle3.so
diff --git a/build/mingw32.mak b/build/mingw32.mak
index 6f192ce2..e966f48a 100644
--- a/build/mingw32.mak
+++ b/build/mingw32.mak
@@ -59,7 +59,7 @@ all: libboost_python.a \
      abstract.pyd \
      getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
-     do_it_yourself_converters.pyd \
+     do_it_yourself_convts.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
      ivect.pyd dvect.pyd \
@@ -102,11 +102,11 @@ simple_vector.pyd: $(OBJ) simple_vector.o
           --def simple_vector.def \
           $(OBJ) simple_vector.o $(PYLIB)
 
-do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.o
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.o
 	dllwrap $(DLLWRAPOPTS) \
-          --dllname do_it_yourself_converters.pyd \
-          --def do_it_yourself_converters.def \
-          $(OBJ) do_it_yourself_converters.o $(PYLIB)
+          --dllname do_it_yourself_convts.pyd \
+          --def do_it_yourself_convts.def \
+          $(OBJ) do_it_yourself_convts.o $(PYLIB)
 
 pickle1.pyd: $(OBJ) pickle1.o
 	dllwrap $(DLLWRAPOPTS) \
@@ -177,7 +177,7 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_do_it_yourself_convts.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index 8f3d3abf..fba2bfe1 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -54,7 +54,7 @@ DEPOBJ=$(OBJ) \
        abstract.o \
        getting_started1.o getting_started2.o \
        simple_vector.o \
-       do_it_yourself_converters.o \
+       do_it_yourself_convts.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
        ivect.o dvect.o \
@@ -67,7 +67,7 @@ all: libboost_python.a \
      abstract.so \
      getting_started1.so getting_started2.so \
      simple_vector.so \
-     do_it_yourself_converters.so \
+     do_it_yourself_convts.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
      ivect.so dvect.so \
@@ -96,8 +96,8 @@ getting_started2.so: $(OBJ) getting_started2.o
 simple_vector.so: $(OBJ) simple_vector.o
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.o -o simple_vector.so
 
-do_it_yourself_converters.so: $(OBJ) do_it_yourself_converters.o
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.o -o do_it_yourself_converters.so
+do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
 
 pickle1.so: $(OBJ) pickle1.o
 	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
@@ -140,7 +140,7 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_do_it_yourself_convts.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
@@ -156,7 +156,7 @@ clean:
 	rm -f getting_started1.o getting_started1.so
 	rm -f getting_started2.o getting_started2.so
 	rm -f simple_vector.o simple_vector.so
-	rm -f do_it_yourself_converters.o do_it_yourself_converters.so
+	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
 	rm -f pickle1.o pickle1.so
 	rm -f pickle2.o pickle2.so
 	rm -f pickle3.o pickle3.so
diff --git a/build/vc60.mak b/build/vc60.mak
index f545015b..ae655c14 100644
--- a/build/vc60.mak
+++ b/build/vc60.mak
@@ -43,7 +43,7 @@ all: boost_python.lib \
      abstract.pyd \
      getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
-     do_it_yourself_converters.pyd \
+     do_it_yourself_convts.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
      ivect.pyd dvect.pyd \
@@ -67,8 +67,8 @@ getting_started2.pyd: $(OBJ) getting_started2.obj
 simple_vector.pyd: $(OBJ) simple_vector.obj
 	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB) /export:initsimple_vector /out:"simple_vector.pyd"
 
-do_it_yourself_converters.pyd: $(OBJ) do_it_yourself_converters.obj
-	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_converters.obj $(PYLIB) /export:initdo_it_yourself_converters /out:"do_it_yourself_converters.pyd"
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.obj
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.obj $(PYLIB) /export:initdo_it_yourself_convts /out:"do_it_yourself_convts.pyd"
 
 pickle1.pyd: $(OBJ) pickle1.obj
 	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB) /export:initpickle1 /out:"pickle1.pyd"
@@ -109,7 +109,7 @@ test:
 	$(PYEXE) test_getting_started1.py
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
-	$(PYEXE) test_do_it_yourself_converters.py
+	$(PYEXE) test_do_it_yourself_convts.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
diff --git a/example/README b/example/README
index 35d822d5..817facd0 100644
--- a/example/README
+++ b/example/README
@@ -10,7 +10,7 @@ See also: libs/python/doc/pickle.html
 Other advanced concepts are introduced by:
   abstract.cpp
   simple_vector.cpp
-  do_it_yourself_converters.cpp
+  do_it_yourself_convts.cpp
 
 Examples for the cross-module support are provided by:
   noncopyable_export.cpp
diff --git a/example/do_it_yourself_converters.cpp b/example/do_it_yourself_convts.cpp
similarity index 97%
rename from example/do_it_yourself_converters.cpp
rename to example/do_it_yourself_convts.cpp
index 6d2d2d6a..4d9c1c89 100644
--- a/example/do_it_yourself_converters.cpp
+++ b/example/do_it_yourself_convts.cpp
@@ -105,12 +105,12 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
-BOOST_PYTHON_MODULE_INIT(do_it_yourself_converters)
+BOOST_PYTHON_MODULE_INIT(do_it_yourself_convts)
 {
   try
   {
     // Create an object representing this extension module.
-    python::module_builder this_module("do_it_yourself_converters");
+    python::module_builder this_module("do_it_yourself_convts");
 
     // Create the Python type object for our extension class.
     python::class_builder<IndexingSet> ixset_class(this_module, "IndexingSet");
diff --git a/example/test_do_it_yourself_converters.py b/example/test_do_it_yourself_convts.py
similarity index 63%
rename from example/test_do_it_yourself_converters.py
rename to example/test_do_it_yourself_convts.py
index 17240750..6f5fa5a0 100644
--- a/example/test_do_it_yourself_converters.py
+++ b/example/test_do_it_yourself_convts.py
@@ -1,5 +1,5 @@
-r'''>>> import do_it_yourself_converters
-    >>> ixset = do_it_yourself_converters.IndexingSet()
+r'''>>> import do_it_yourself_convts
+    >>> ixset = do_it_yourself_convts.IndexingSet()
     >>> ixset.add((1,2,3))
     >>> ixset.add((4,5,6))
     >>> ixset.add((7,8,9))
@@ -15,8 +15,8 @@ def run(args = None):
     if args is not None:
         import sys
         sys.argv = args
-    import doctest, test_do_it_yourself_converters
-    return doctest.testmod(test_do_it_yourself_converters)
+    import doctest, test_do_it_yourself_convts
+    return doctest.testmod(test_do_it_yourself_convts)
 
 if __name__ == '__main__':
     import sys

From f646975c3668bdb05376b3a14b62f59cd96c1b0e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 31 Jul 2001 08:10:05 +0000
Subject: [PATCH 133/369] convert int/double to complex

[SVN r10730]
---
 include/boost/python/conversions.hpp |  5 +++++
 test/comprehensive.py                | 12 ++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index 47f80989..cf753e2d 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -7,6 +7,7 @@
 //  producing this work.
 //
 // Revision History:
+// 31 Jul 01  convert int/double to complex (Peter Bienstman)
 // 04 Mar 01  Fixed std::complex<> stuff to work with MSVC (David Abrahams)
 // 03 Mar 01  added: converters for [plain] char and std::complex
 //            (Ralf W. Grosse-Kunstleve)
@@ -93,6 +94,10 @@ namespace detail {
   template <class T>
   std::complex<T> complex_from_python(PyObject* p, boost::python::type<T>)
   {
+      if (PyInt_Check(p)) return std::complex<T>(PyInt_AS_LONG(p));
+      if (PyLong_Check(p)) return std::complex<T>(PyLong_AsDouble(p));
+      if (PyFloat_Check(p)) return std::complex<T>(PyFloat_AS_DOUBLE(p));
+
       expect_complex(p);
 
       return std::complex<T>(
diff --git a/test/comprehensive.py b/test/comprehensive.py
index db4f8b73..4ff34b48 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -1175,6 +1175,18 @@ test methodologies for wrapping functions that return a pointer
     '2.94'
     >>> '%.3g' % (dreal(c))
     '6.35'
+    >>> '%.3g' % (dreal(3))
+    '3'
+    >>> '%.3g' % (dreal(3L))
+    '3'
+    >>> '%.3g' % (dreal(3.))
+    '3'
+    >>> '%.3g' % (freal(3))
+    '3'
+    >>> '%.3g' % (freal(3L))
+    '3'
+    >>> '%.3g' % (freal(3.))
+    '3'
 
 '''
 #'

From 9f3cda0ac35cc752ab6928d8f7c8f7f1101eeef5 Mon Sep 17 00:00:00 2001
From: Darin Adler <darin@bentspoon.com>
Date: Tue, 7 Aug 2001 17:22:02 +0000
Subject: [PATCH 134/369] Spell things consistently. Add some bits of Mac stuff
 to the tests. Use std::size_t where needed.

[SVN r10800]
---
 example/dvect.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/dvect.h b/example/dvect.h
index 8ffe7b50..d059f04d 100644
--- a/example/dvect.h
+++ b/example/dvect.h
@@ -9,7 +9,7 @@ namespace vects {
   struct dvect : public std::vector<double>
   {
     dvect() : std::vector<double>() {}
-    dvect(size_t n) : std::vector<double>(n) {}
+    dvect(std::size_t n) : std::vector<double>(n) {}
     dvect(boost::python::tuple tuple) : std::vector<double>(tuple.size())
     {
       std::vector<double>::iterator v_it = begin();

From 6e6ae18aabefe93b2a8561effaa54877f5da983e Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 15 Aug 2001 19:15:57 +0000
Subject: [PATCH 135/369] Missing "std::" added (std::size_t)

[SVN r10872]
---
 example/ivect.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/ivect.h b/example/ivect.h
index a0187307..b8d52246 100644
--- a/example/ivect.h
+++ b/example/ivect.h
@@ -9,7 +9,7 @@ namespace vects {
   struct ivect : public std::vector<int>
   {
     ivect() : std::vector<int>() {}
-    ivect(size_t n) : std::vector<int>(n) {}
+    ivect(std::size_t n) : std::vector<int>(n) {}
     ivect(boost::python::tuple tuple) : std::vector<int>(tuple.size())
     {
       std::vector<int>::iterator v_it = begin();

From 37b6e2232147e655aadf79d0fbaa99d628abae5f Mon Sep 17 00:00:00 2001
From: Beman Dawes <bdawes@acm.org>
Date: Mon, 20 Aug 2001 13:04:43 +0000
Subject: [PATCH 136/369] Misc; mostly fix links to hard disk locations

[SVN r10902]
---
 doc/under-the-hood.html | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/doc/under-the-hood.html b/doc/under-the-hood.html
index e2a0ce2b..ee0ecdfb 100644
--- a/doc/under-the-hood.html
+++ b/doc/under-the-hood.html
@@ -35,8 +35,7 @@
       "example1.html#world_class"><code>extension_class&lt;T&gt;</code></a>
       template defines a whole raft of these conversions (for <code>T, T*,
       T&amp;, std::auto_ptr&lt;T&gt;</code>, etc.), using the same inline
-      friend function technique employed by <a href= 
-      "file:///c:/boost/site/libs/utility/operators.htm">the boost operators
+      friend function technique employed by <a href="../../utility/operators.htm">the boost operators
       library</a>.
     <p>
       Because the <code>to_python</code> and <code>from_python</code> functions

From c7f1c5e29cb6437cff63601ac0f7f6751cdf41af Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 28 Aug 2001 02:02:27 +0000
Subject: [PATCH 137/369] New example: nested.cpp

[SVN r10946]
---
 build/filemgr.py       |  3 +++
 build/irix_CC.mak      |  7 +++++++
 build/linux_gcc.mak    |  7 +++++++
 build/mingw32.mak      | 13 ++++++++++++-
 build/tru64_cxx.mak    |  7 +++++++
 build/vc60.mak         |  7 ++++++-
 example/nested.cpp     | 44 ++++++++++++++++++++++++++++++++++++++++++
 example/test_nested.py | 23 ++++++++++++++++++++++
 8 files changed, 109 insertions(+), 2 deletions(-)
 create mode 100644 example/nested.cpp
 create mode 100644 example/test_nested.py

diff --git a/build/filemgr.py b/build/filemgr.py
index 2ff163f0..99f4ca30 100644
--- a/build/filemgr.py
+++ b/build/filemgr.py
@@ -24,6 +24,7 @@ bpl_exa + "/getting_started1.cpp",
 bpl_exa + "/getting_started2.cpp",
 bpl_exa + "/simple_vector.cpp",
 bpl_exa + "/do_it_yourself_convts.cpp",
+bpl_exa + "/nested.cpp",
 bpl_exa + "/pickle1.cpp",
 bpl_exa + "/pickle2.cpp",
 bpl_exa + "/pickle3.cpp",
@@ -32,6 +33,7 @@ bpl_exa + "/test_getting_started1.py",
 bpl_exa + "/test_getting_started2.py",
 bpl_exa + "/test_simple_vector.py",
 bpl_exa + "/test_do_it_yourself_convts.py",
+bpl_exa + "/test_nested.py",
 bpl_exa + "/test_pickle1.py",
 bpl_exa + "/test_pickle2.py",
 bpl_exa + "/test_pickle3.py",
@@ -68,6 +70,7 @@ defs = (
 "getting_started2",
 "simple_vector",
 "do_it_yourself_convts",
+"nested",
 "pickle1",
 "pickle2",
 "pickle3",
diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index 6e465b98..e3a97781 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -44,6 +44,7 @@ DEPOBJ=$(OBJ) \
        getting_started1.o getting_started2.o \
        simple_vector.o \
        do_it_yourself_convts.o \
+       nested.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
        ivect.o dvect.o \
@@ -57,6 +58,7 @@ all: libboost_python.a \
      getting_started1.so getting_started2.so \
      simple_vector.so \
      do_it_yourself_convts.so \
+     nested.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
      ivect.so dvect.so \
@@ -84,6 +86,9 @@ simple_vector.so: $(OBJ) simple_vector.o
 do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
 	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
 
+nested.so: $(OBJ) nested.o
+	$(LD) $(LDOPTS) $(OBJ) nested.o -o nested.so
+
 pickle1.so: $(OBJ) pickle1.o
 	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
 
@@ -126,6 +131,7 @@ test:
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
@@ -142,6 +148,7 @@ clean:
 	rm -f getting_started2.o getting_started2.so
 	rm -f simple_vector.o simple_vector.so
 	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
+	rm -f nested.o nested.so
 	rm -f pickle1.o pickle1.so
 	rm -f pickle2.o pickle2.so
 	rm -f pickle3.o pickle3.so
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index 2c977473..64d61bab 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -45,6 +45,7 @@ DEPOBJ=$(OBJ) \
        getting_started1.o getting_started2.o \
        simple_vector.o \
        do_it_yourself_convts.o \
+       nested.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
        ivect.o dvect.o \
@@ -58,6 +59,7 @@ all: libboost_python.a \
      getting_started1.so getting_started2.so \
      simple_vector.so \
      do_it_yourself_convts.so \
+     nested.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
      ivect.so dvect.so \
@@ -85,6 +87,9 @@ simple_vector.so: $(OBJ) simple_vector.o
 do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
 	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
 
+nested.so: $(OBJ) nested.o
+	$(LD) $(LDOPTS) $(OBJ) nested.o -o nested.so
+
 pickle1.so: $(OBJ) pickle1.o
 	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
 
@@ -127,6 +132,7 @@ test:
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
@@ -143,6 +149,7 @@ clean:
 	rm -f getting_started2.o getting_started2.so
 	rm -f simple_vector.o simple_vector.so
 	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
+	rm -f nested.o nested.so
 	rm -f pickle1.o pickle1.so
 	rm -f pickle2.o pickle2.so
 	rm -f pickle3.o pickle3.so
diff --git a/build/mingw32.mak b/build/mingw32.mak
index e966f48a..bf590409 100644
--- a/build/mingw32.mak
+++ b/build/mingw32.mak
@@ -30,13 +30,16 @@
 # -fvtable-thunks eliminates the compiler warning, but
 #                 "import boost_python_test" still causes a crash.
 
-ROOT=L:
+ROOT=R:
 BOOST_WIN="$(ROOT)\boost"
 BOOST_UNIX=$(HOME)/boost
 
 PYEXE="C:\Program files\Python\python.exe"
 PYINC=-I"C:\usr\include\python1.5"
 PYLIB="C:\usr\lib\libpython15.a"
+#PYEXE="C:\Python21\python.exe"
+#PYINC=-I"C:\usr\include\python2.1"
+#PYLIB="C:\usr\lib\libpython21.a"
 
 STDOPTS=-ftemplate-depth-21
 WARNOPTS=
@@ -60,6 +63,7 @@ all: libboost_python.a \
      getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
      do_it_yourself_convts.pyd \
+     nested.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
      ivect.pyd dvect.pyd \
@@ -108,6 +112,12 @@ do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.o
           --def do_it_yourself_convts.def \
           $(OBJ) do_it_yourself_convts.o $(PYLIB)
 
+nested.pyd: $(OBJ) nested.o
+	dllwrap $(DLLWRAPOPTS) \
+          --dllname nested.pyd \
+          --def nested.def \
+          $(OBJ) nested.o $(PYLIB)
+
 pickle1.pyd: $(OBJ) pickle1.o
 	dllwrap $(DLLWRAPOPTS) \
           --dllname pickle1.pyd \
@@ -178,6 +188,7 @@ test:
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index fba2bfe1..d06f3372 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -55,6 +55,7 @@ DEPOBJ=$(OBJ) \
        getting_started1.o getting_started2.o \
        simple_vector.o \
        do_it_yourself_convts.o \
+       nested.o \
        pickle1.o pickle2.o pickle3.o \
        noncopyable_export.o noncopyable_import.o \
        ivect.o dvect.o \
@@ -68,6 +69,7 @@ all: libboost_python.a \
      getting_started1.so getting_started2.so \
      simple_vector.so \
      do_it_yourself_convts.so \
+     nested.so \
      pickle1.so pickle2.so pickle3.so \
      noncopyable_export.so noncopyable_import.so \
      ivect.so dvect.so \
@@ -99,6 +101,9 @@ simple_vector.so: $(OBJ) simple_vector.o
 do_it_yourself_convts.so: $(OBJ) do_it_yourself_convts.o
 	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.o -o do_it_yourself_convts.so
 
+nested.so: $(OBJ) nested.o
+	$(LD) $(LDOPTS) $(OBJ) nested.o -o nested.so
+
 pickle1.so: $(OBJ) pickle1.o
 	$(LD) $(LDOPTS) $(OBJ) pickle1.o -o pickle1.so
 
@@ -141,6 +146,7 @@ test:
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
@@ -157,6 +163,7 @@ clean:
 	rm -f getting_started2.o getting_started2.so
 	rm -f simple_vector.o simple_vector.so
 	rm -f do_it_yourself_convts.o do_it_yourself_convts.so
+	rm -f nested.o nested.so
 	rm -f pickle1.o pickle1.so
 	rm -f pickle2.o pickle2.so
 	rm -f pickle3.o pickle3.so
diff --git a/build/vc60.mak b/build/vc60.mak
index ae655c14..a348de54 100644
--- a/build/vc60.mak
+++ b/build/vc60.mak
@@ -10,7 +10,7 @@
 #   12 Apr 01 new macro ROOT to simplify configuration (R.W. Grosse-Kunstleve)
 #   Initial version: R.W. Grosse-Kunstleve
 
-ROOT=L:
+ROOT=R:
 BOOST_WIN="$(ROOT)\boost"
 BOOST_UNIX=$(HOME)/boost
 
@@ -44,6 +44,7 @@ all: boost_python.lib \
      getting_started1.pyd getting_started2.pyd \
      simple_vector.pyd \
      do_it_yourself_convts.pyd \
+     nested.pyd \
      pickle1.pyd pickle2.pyd pickle3.pyd \
      noncopyable_export.pyd noncopyable_import.pyd \
      ivect.pyd dvect.pyd \
@@ -70,6 +71,9 @@ simple_vector.pyd: $(OBJ) simple_vector.obj
 do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.obj
 	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.obj $(PYLIB) /export:initdo_it_yourself_convts /out:"do_it_yourself_convts.pyd"
 
+nested.pyd: $(OBJ) nested.obj
+	$(LD) $(LDOPTS) $(OBJ) nested.obj $(PYLIB) /export:initnested /out:"nested.pyd"
+
 pickle1.pyd: $(OBJ) pickle1.obj
 	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB) /export:initpickle1 /out:"pickle1.pyd"
 
@@ -110,6 +114,7 @@ test:
 	$(PYEXE) test_getting_started2.py
 	$(PYEXE) test_simple_vector.py
 	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
 	$(PYEXE) test_pickle1.py
 	$(PYEXE) test_pickle2.py
 	$(PYEXE) test_pickle3.py
diff --git a/example/nested.cpp b/example/nested.cpp
new file mode 100644
index 00000000..543754f7
--- /dev/null
+++ b/example/nested.cpp
@@ -0,0 +1,44 @@
+// Example by Ralf W. Grosse-Kunstleve
+
+/*
+    This example shows how convert a nested Python tuple.
+ */
+
+#include <boost/python/class_builder.hpp>
+#include <stdio.h>
+
+namespace {
+
+  boost::python::list
+  show_nested_tuples(boost::python::tuple outer)
+  {
+    boost::python::list result;
+    for (int i = 0; i < outer.size(); i++) {
+      boost::python::tuple inner(
+        BOOST_PYTHON_CONVERSION::from_python(outer[i].get(),
+        boost::python::type<boost::python::tuple>()));
+      for (int j = 0; j < inner.size(); j++) {
+        double x = BOOST_PYTHON_CONVERSION::from_python(inner[j].get(),
+          boost::python::type<double>());
+        char buf[128];
+        sprintf(buf, "(%d,%d) %.6g", i, j, x);
+        result.append(BOOST_PYTHON_CONVERSION::to_python(std::string(buf)));
+      }
+    }
+    return result;
+  }
+
+}
+
+BOOST_PYTHON_MODULE_INIT(nested)
+{
+  try
+  {
+    boost::python::module_builder this_module("nested");
+    this_module.def(show_nested_tuples, "show_nested_tuples");
+  }
+  catch(...)
+  {
+    boost::python::handle_exception();
+  }
+}
diff --git a/example/test_nested.py b/example/test_nested.py
new file mode 100644
index 00000000..e9abbf0f
--- /dev/null
+++ b/example/test_nested.py
@@ -0,0 +1,23 @@
+r'''>>> import nested
+    >>> s = nested.show_nested_tuples(((1,2,3), (4,5,6,7)))
+    >>> for l in s:
+    ...   print l
+    (0,0) 1
+    (0,1) 2
+    (0,2) 3
+    (1,0) 4
+    (1,1) 5
+    (1,2) 6
+    (1,3) 7
+'''
+
+def run(args = None):
+    if args is not None:
+        import sys
+        sys.argv = args
+    import doctest, test_nested
+    return doctest.testmod(test_nested)
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(run()[0])

From e552607c95cf513a8f3e1f3c1ce123c909356fd1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 22 Sep 2001 17:51:10 +0000
Subject: [PATCH 138/369] const-ified list::size() and slice_proxy::size()

[SVN r11212]
---
 include/boost/python/objects.hpp | 4 ++--
 src/objects.cpp                  | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/objects.hpp b/include/boost/python/objects.hpp
index 34052e1f..3b1a9094 100644
--- a/include/boost/python/objects.hpp
+++ b/include/boost/python/objects.hpp
@@ -101,7 +101,7 @@ class list : public object
     explicit list(std::size_t sz = 0);
     static PyTypeObject* type_obj();
     static bool accepts(ref p);
-    std::size_t size();
+    std::size_t size() const;
     ref operator[](std::size_t pos) const;
     proxy operator[](std::size_t pos);
     ref get_item(std::size_t pos) const;
@@ -283,7 +283,7 @@ struct list::slice_proxy
     const list& operator=(const list& rhs);
     operator ref() const;
     operator list() const;
-    std::size_t size();
+    std::size_t size() const;
     ref operator[](std::size_t pos) const;
  private:
     friend class list;
diff --git a/src/objects.cpp b/src/objects.cpp
index cc46b2ba..125a1eb8 100644
--- a/src/objects.cpp
+++ b/src/objects.cpp
@@ -362,7 +362,7 @@ bool list::accepts(ref p)
     return PyList_Check(p.get());
 }
 
-std::size_t list::size()
+std::size_t list::size() const
 {
     return PyList_Size(get());
 }
@@ -467,7 +467,7 @@ list::slice_proxy::operator list() const
     return list(this->operator ref());
 }
 
-std::size_t list::slice_proxy::size()
+std::size_t list::slice_proxy::size() const
 {
     return this->operator list().size();
 }

From e63451a9e7a545b7cac02e5756bd46e717251f0d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 6 Oct 2001 18:19:15 +0000
Subject: [PATCH 139/369] regex, threads, and python will all build from the
 top level. If you build the 'test' target from the top level, it will run all
 regressions.

Jamfile:
  subincludes for thread, python libs, and status for regression tests

Jamrules:
  Use the new path-global rule to establish BOOST_ROOT correctly for all subprojects

libs/regex/build/Jamfile
  Take advantage of correct BOOST_ROOT setting

libs/python/build/Jamfile
  Search for python executable; don't try to build anything if it can't be found.
  don't build tests by default
  improved comments, organization, and naming.

status/Jamfile
  Fixed references to config test files
  Failed tests now leave their stdout results in <testname>.error instead of removing it
  No test targets are dependencies of 'all' anymore
  Added comments
  Reorganized

tools/build/Jambase
  Meant to check this in long ago.

tools/build/allyourbase.jam
  Fixed SHELL_EXPORT setting, added SHELL_SET
  removed 'test' from the dependencies of 'all'; tests no longer run by default.
  Fixed the direction of slashes for Windows when ALL_LOCATE_TARGET is used.
  Added path-global rule for declaring path variables which may be relative
  rule in-invocation-subdir returns true if the current subproject is the one
     from which Jam was invoked
  rule protect-subdir is now used to protect subproject variables
  rule tokens-to-simple-path converts path tokens to a simplified path.

tools/build/boost-base.jam
  Fixed bugs

tools/build/jam_src/makedebugjam.bat
  Fixed a bug which prevented a final debug build

tools/build/jam_src/search.c
  Fixed a bug of mine which caused LOCATE to be ignored (!).


[SVN r11348]
---
 build/Jamfile | 136 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 88 insertions(+), 48 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index 562aca1e..d597d055 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -5,13 +5,16 @@
 #
 # Boost.Python build and test Jamfile
 #
+# To run all tests quietly: jam test
+# To run all tests with verbose output: jam -sPYTHON_TEST_ARGS=-v test
+#
 # Declares the following targets:
 #   1. libboost_python, a static link library to be linked with all
 #      Boost.Python modules
 #
 #   2. pairs of test targets of the form <name>.test and <name>.run
-#      <name>.test runs the test when it is out-of-date, and the "all" target
-#      depends on it so that it it is built by default. <name>.run runs
+#      <name>.test runs the test when it is out-of-date, and the "test"
+#      pseudotarget depends on it. <name>.run runs
 #      a test unconditionally, and can be used to force a test to run.. Each
 #      test target builds one or more Boost.Python modules and runs a Python
 #      script to test them. The test names are:
@@ -38,6 +41,12 @@
 #
 # subproject-specific environment/command-line variables:
 #
+# PYTHON                - How to invoke the Python interpreter. Defaults to "python"
+#
+# PYTHON_ROOT           - Windows only: where Python is installed. Defaults to "c:/tools/python"
+#
+# PYTHON_VERSION        - Version of Python. Defaults to "2.1" on Windows, "1.5" on Unix
+#
 # PYTHON_TEST_ARGS      - specifies arguments to be passed to test scripts on
 #                         the command line. "-v" can be useful if you want to
 #                         see the output of successful tests.
@@ -49,12 +58,21 @@
 # declare the location of this subproject relative to the root
 subproject libs/python/build ;
 
+# grab variables from command-line or environment.
+local PYTHON_VERSION = $(PYTHON_VERSION) ;
+local PYTHON_ROOT = $(PYTHON_ROOT) ;
+local PYTHON_INCLUDES = $(PYTHON_INCLUDES) ;
+local PYTHON_LIBS = $(PYTHON_LIBS) ;
+local PYTHON_LIB_PATH = $(PYTHON_LIB_PATH) ;
+local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) ;
+
 # Do some OS-specific setup
 if $(NT)
 {
+    PYTHON_VERSION ?= 2.1 ;
     PYTHON_ROOT ?= c:/tools/python ;
-    PYTHON_INCLUDES ?= <include>$(PYTHON_ROOT)/include <gcc><*><include>/usr/include/python2.1 ;
-    PYTHON_LIBS ?= c:/cygnus/lib/python2.1/config/libpython2.1.dll.a ;
+    PYTHON_INCLUDES ?= <include>$(PYTHON_ROOT)/include <gcc><*><include>/usr/include/python$(PYTHON_VERSION) ;
+    PYTHON_LIBS ?= c:/cygnus/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).dll.a ;
     PYTHON_LIB_PATH = $(PYTHON_ROOT)/libs ;
 
     # common properties required for compiling any Python module.
@@ -64,17 +82,20 @@ if $(NT)
         <runtime-link>dynamic
         ;
                         
-    SHELL_SET ?= "set " ;
-    SHELL_EXPORT ?= ; # shell variables are exported by default
 }
 else if $(UNIX)
 {
-    PYTHON_INCLUDES ?= <include>/usr/include/python1.5 ;
-    PYTHON_LIBS ?= /usr/lib/python1.5/config/libpython1.5.a ;
-    SHELL_SET ?= "" ;
-    SHELL_EXPORT ?= "export " ;
+    PYTHON_VERSION ?= 1.5 ;
+    PYTHON_INCLUDES ?= <include>/usr/include/python$(PYTHON_VERSION) ;
+    PYTHON_LIBS ?= /usr/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).a ;
 }
 
+# how do we invoke python?
+local PYTHON = $(PYTHON) ;
+PYTHON ?= python ;
+PYTHON = [ FAppendSuffix $(PYTHON:G=<executable-grist>) : $(SUFEXE) ] ;
+SEARCH on $(PYTHON) = $(PATH) ;
+
 #######################
 
 #
@@ -82,10 +103,10 @@ else if $(UNIX)
 #
 
 # standard include requirements for anything using Boost.Python
-BOOST_PYTHON_INCLUDES = <include>$(BOOST_ROOT) $(PYTHON_INCLUDES) ;
+local BOOST_PYTHON_INCLUDES = <include>$(BOOST_ROOT) $(PYTHON_INCLUDES) ;
 
 # Base names of the source files for libboost_python
-CPP_SOURCES =
+local CPP_SOURCES =
     classes conversions extension_class functions 
     init_function module_builder objects types cross_module ;
 
@@ -117,13 +138,25 @@ rule boost-python
         : $(4) ;                      # pass on the default-BUILD, if any
 }
 
+# boost-python-test name : sources : requirements : default-BUILD
+#
+# Just like boost-python, but the result becomes part of the test pseudotarget
+# instead of being built by 'all'
+rule boost-python-test
+{
+    type-DEPENDS test : $(<) ;
+    
+    local gSUPPRESS_FAKE_TARGETS = true ;
+    boost-python $(1) : $(2) : $(3) : $(4) ;
+}
+
 #######################
 
-# boost-python-test target : python-script sources : requirements : local-build : args
+# boost-python-runtest target : python-script sources : requirements : local-build : args
 #
 # declare two python module tests: $(<).test which builds when out-of-date, and
 # $(<).run which builds unconditionally.
-rule boost-python-test
+rule boost-python-runtest
 {
     # tell Jam that the python script is relative to this directory
     SEARCH on $(>[1]) = $(SEARCH_SOURCE) ;
@@ -131,28 +164,25 @@ rule boost-python-test
     # required command-line args can be specified in argument 5
     # The user can add additional arguments in PYTHON_TEST_ARGS.
     local gPYTHON_TEST_ARGS = $(5) $(PYTHON_TEST_ARGS) ;
-    
+
     # declare the two subsidiary tests.
     declare-local-target $(<:S=.test) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_TEST ;
     declare-local-target $(<:S=.run) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_RUNTEST ;
 }
 
-# how do we invoke python?
-PYTHON ?= python ;
-
 # special rules for two new target types: PYTHON_TEST and PYTHON_RUNTEST.
 # These are identical except that PYTHON_TEST runs the test when out-of-date, and
-# PYTHON_RUNTEST runs the test unconditionally. These are used by boost-python-test.
+# PYTHON_RUNTEST runs the test unconditionally. These are used by boost-python-runtest.
 SUFPYTHON_TEST = .test ;
 gGENERATOR_FUNCTION(PYTHON_TEST) = python-test-target ;
 rule python-test-target # test-target : sources : 
 {
-    python-test-aux $(<) : $(>) ;
+    python-runtest-aux $(<) : $(>) ;
     Clean clean : $(<) ; # remove the test-target as part of any clean operation
     type-DEPENDS test : $(<) ;
     MakeLocate $(<) : $(LOCATE_TARGET) ;
 }
-actions python-test-target
+actions python-test-target bind PYTHON
 {
     $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
     $(SHELL_EXPORT)PYTHONPATH
@@ -163,18 +193,18 @@ SUFPYTHON_RUNTEST = .run ;
 gGENERATOR_FUNCTION(PYTHON_RUNTEST) = python-runtest-target ;
 rule python-runtest-target # test-target : sources : 
 {
-    python-test-aux $(<) : $(>) ;
+    python-runtest-aux $(<) : $(>) ;
     NOTFILE $(<) ;
     ALWAYS $(<) ;
 }
-actions python-runtest-target
+actions python-runtest-target bind PYTHON
 {
     $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
     $(SHELL_EXPORT)PYTHONPATH
     $(PYTHON) "$(>)" $(ARGS)
 }
 
-rule python-test-aux # target : sources
+rule python-runtest-aux # target : sources
 {
     DEPENDS $(<) : $(>) ;
 
@@ -196,50 +226,60 @@ rule python-test-aux # target : sources
         [ join-path $(TOP) libs python test ]   # location of doctest
         $(PYTHONPATH)                           # base PYTHONPATH from environment
         : $(SPLITPATH) ] ;                      # platform path separator
+
+    PYTHON on $(<) = $(PYTHON) ;
+    DEPENDS $(<) : $(PYTHON) ;
 }
 
 ############# comprehensive module and test ###########
-boost-python boost_python_test : ../test/comprehensive.cpp ;
-boost-python-test comprehensive : [ join-path $(DOTDOT) test comprehensive.py ] <lib>boost_python_test ;
+boost-python-test boost_python_test : ../test/comprehensive.cpp ;
+
+boost-python-runtest comprehensive
+         : [ join-path $(DOTDOT) test comprehensive.py ]
+           <lib>boost_python_test ;
 
 ############# simple tests from ../example ############
 
-rule boost-python-example-test
+rule boost-python-example-runtest
 {
-    boost-python $(<) : ../example/$(<).cpp ;
-    boost-python-test $(<) : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<) ;
+    boost-python-test $(<) : ../example/$(<).cpp ;
+    boost-python-runtest $(<) : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<) ;
 }
 
 
-boost-python-example-test abstract ;
-boost-python-example-test getting_started1 ;
-boost-python-example-test getting_started2 ;
-boost-python-example-test simple_vector ;
-boost-python-example-test do_it_yourself_convts ;
-boost-python-example-test pickle1 ;
-boost-python-example-test pickle2 ;
-boost-python-example-test pickle3 ;
+boost-python-example-runtest abstract ;
+boost-python-example-runtest getting_started1 ;
+boost-python-example-runtest getting_started2 ;
+boost-python-example-runtest simple_vector ;
+boost-python-example-runtest do_it_yourself_convts ;
+boost-python-example-runtest pickle1 ;
+boost-python-example-runtest pickle2 ;
+boost-python-example-runtest pickle3 ;
 
 
-boost-python ivect : ../example/ivect.cpp ;
-boost-python dvect : ../example/dvect.cpp ;
-boost-python noncopyable_export : ../example/noncopyable_export.cpp ;
-boost-python noncopyable_import : ../example/noncopyable_import.cpp ;
+boost-python-test ivect : ../example/ivect.cpp ;
+boost-python-test dvect : ../example/dvect.cpp ;
+boost-python-test noncopyable_export : ../example/noncopyable_export.cpp ;
+boost-python-test noncopyable_import : ../example/noncopyable_import.cpp ;
 
 ############## cross-module tests from ../example ##########
 
 # A simple rule to build a test which depends on multiple modules in the PYTHONPATH
-rule boost-python-multi-example-test # test-name : python-file libs
+rule boost-python-multi-example-runtest # test-name : python-file libs
 {
-    boost-python-test $(<) : ../example/tst_$(<).py <lib>$(>) : : : $(PYTHON_VECT_ITERATIONS) ;
+    boost-python-runtest $(<)
+        : ../example/tst_$(<).py <lib>$(>)
+        : : : $(PYTHON_VECT_ITERATIONS) ;
 }
+
 PYTHON_VECT_ITERATIONS ?= 10 ;
 
-boost-python-multi-example-test dvect1 : ivect dvect ;
-boost-python-multi-example-test dvect2 : ivect dvect ;
+boost-python-multi-example-runtest dvect1 : ivect dvect ;
+boost-python-multi-example-runtest dvect2 : ivect dvect ;
 
-boost-python-multi-example-test ivect1 : ivect dvect ;
-boost-python-multi-example-test ivect2 : ivect dvect ;
+boost-python-multi-example-runtest ivect1 : ivect dvect ;
+boost-python-multi-example-runtest ivect2 : ivect dvect ;
 
-boost-python-multi-example-test noncopyable : noncopyable_import noncopyable_export ;
+boost-python-multi-example-runtest
+        noncopyable : noncopyable_import noncopyable_export ;
 

From a245bdbc2adcb44463b80b7a0d3f3003a3ec3b6e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 31 Oct 2001 19:14:07 +0000
Subject: [PATCH 140/369] Modified Files:   boost/python/detail:    
 base_object.hpp - Changed template parameter to MixedCase     cast.hpp -     
   Killed off unused downcast_traits<>     functions.hpp -   Added commentary

  libs/python/src
    functions.cpp, types.cpp -   Added comments

  tools/build
    TODO.txt - updated
    allyourbase.jam -           fixed a nasty typo which caused all kinds of bugs
    boost-base.jam -            changes to support the use of command files
    intel-win32-tools.jam -
         A feeble attempt at allowing intel to work without prior tool setup. More work needed
    msvc-tools.jam -            A first cut at command file support

  tools/build/jam_src
    jam.h -                     Fixed MAXLINE for NT


[SVN r11489]
---
 include/boost/python/detail/base_object.hpp | 14 +++++++-------
 include/boost/python/detail/cast.hpp        | 16 ++++------------
 include/boost/python/detail/functions.hpp   |  9 +++++++--
 src/functions.cpp                           |  7 +++++++
 src/types.cpp                               |  9 +++++++++
 5 files changed, 34 insertions(+), 21 deletions(-)

diff --git a/include/boost/python/detail/base_object.hpp b/include/boost/python/detail/base_object.hpp
index 95a2805c..cf6bb528 100644
--- a/include/boost/python/detail/base_object.hpp
+++ b/include/boost/python/detail/base_object.hpp
@@ -21,10 +21,10 @@ 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
+template <class PythonType>
+struct base_object : PythonType
 {
-    typedef python_type base_python_type;
+    typedef PythonType base_python_type;
 
     // Initializes type and reference count. All other fields of base_python_type are 0
     base_object(PyTypeObject* type_obj);
@@ -41,8 +41,8 @@ typedef base_object<PyTypeObject> python_type;
 //
 // base_object member function implementations 
 //
-template <class python_type>
-base_object<python_type>::base_object(PyTypeObject* type_obj)
+template <class PythonType>
+base_object<PythonType>::base_object(PyTypeObject* type_obj)
 {
     base_python_type* bp = this;
 #if !defined(_MSC_VER) || defined(__STLPORT)
@@ -53,8 +53,8 @@ base_object<python_type>::base_object(PyTypeObject* type_obj)
     PyObject_INIT(bp, type_obj);
 }
 
-template <class python_type>
-inline base_object<python_type>::~base_object()
+template <class PythonType>
+inline base_object<PythonType>::~base_object()
 {
     Py_DECREF(ob_type);
 }
diff --git a/include/boost/python/detail/cast.hpp b/include/boost/python/detail/cast.hpp
index e047c0b3..67fe7b34 100644
--- a/include/boost/python/detail/cast.hpp
+++ b/include/boost/python/detail/cast.hpp
@@ -15,14 +15,6 @@
 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);
@@ -54,19 +46,19 @@ template <class T>
 struct downcast
 {
     downcast(PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((T*)0, p)))
+        : m_p(static_cast<T*>(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)))
+        : m_p(static_cast<T*>(detail::as_base_object((const T*)0, p)))
         {}
     
     downcast(PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
+        : m_p(static_cast<T*>(p))
         {}
     
     downcast(const PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
+        : m_p(static_cast<T*>(p))
         {}
     
     operator T*() const { return m_p; }
diff --git a/include/boost/python/detail/functions.hpp b/include/boost/python/detail/functions.hpp
index 055255e7..16b8e16d 100644
--- a/include/boost/python/detail/functions.hpp
+++ b/include/boost/python/detail/functions.hpp
@@ -46,7 +46,7 @@ class function : public python_object
  private:
     struct type_object;
  private:
-    reference<function> m_overloads;
+    reference<function> m_overloads; // A linked list of the function overloads
 };
 
 // wrapped_function_pointer<> --
@@ -66,7 +66,12 @@ struct wrapped_function_pointer : function
 
  private:
 	PyObject* do_call(PyObject* args, PyObject* keywords) const
-        { return caller<R>::call(m_pf, args, keywords); }
+        {
+            // This is where the boundary between the uniform Python function
+            // interface and the statically-checked C++ function interface is
+            // crossed.
+            return caller<R>::call(m_pf, args, keywords);
+        }
     
     const char* description() const
         { return typeid(F).name(); }
diff --git a/src/functions.cpp b/src/functions.cpp
index 71b59136..a04e2e51 100644
--- a/src/functions.cpp
+++ b/src/functions.cpp
@@ -61,6 +61,8 @@ function::function()
 
 PyObject* function::call(PyObject* args, PyObject* keywords) const
 {
+    // Traverse the linked list of function overloads until we find one that
+    // matches.
     for (const function* f = this; f != 0; f = f->m_overloads.get())
     {
         PyErr_Clear();
@@ -75,9 +77,14 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
         }
     }
 
+    // If we get here, no overloads matched the arguments
+
+    // Allow the single-function error-reporting to take effect unless there was
+    // an overload
     if (m_overloads.get() == 0)
         return 0;
 
+    // Synthesize a more-explicit error message
     PyErr_Clear();
     string message("No overloaded functions match (");
     tuple arguments(ref(args, ref::increment_count));
diff --git a/src/types.cpp b/src/types.cpp
index f8cf1ea6..add0ebf0 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -24,6 +24,11 @@ namespace {
 
   using detail::type_object_base;
 
+  // Define a family of forwarding functions that can be calle from a
+  // PyTypeObject's slots. These functions dispatch through a (virtual) member
+  // function pointer in the type_object_base, and handle exceptions in a
+  // uniform way, preventing us from having to rewrite the dispatching code over
+  // and over.
   PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*) const)
   {
       try
@@ -154,6 +159,10 @@ namespace {
 
 extern "C" {
 
+//
+// These functions actually go into the type object's slots, and dispatch to the
+// "call" wrappers defined above.
+//
 static PyObject* do_instance_repr(PyObject* obj)
 {
     return call(obj, &type_object_base::instance_repr);

From 6cb4b790b9b328d99e8691704c2393fc96a6d703 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Thu, 1 Nov 2001 23:28:54 +0000
Subject: [PATCH 141/369] Python 2.2 pickle problems fixed.

[SVN r11521]
---
 test/comprehensive.py | 34 +++++++++++++++++++---------------
 1 file changed, 19 insertions(+), 15 deletions(-)

diff --git a/test/comprehensive.py b/test/comprehensive.py
index 4ff34b48..2ac0704a 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -8,14 +8,11 @@ r'''
 //  producing this work.
 
 //  Revision History:
+//  2001 Nov 01 Python 2.2 pickle problems fixed (rwgk)
 //  04 Mar 01 Changed name of extension module so it would work with DebugPython,
 //            fixed exception message checking to work with Python 2.0
 //            (Dave Abrahams)
 
-Load up the extension module
-
-    >>> from boost_python_test import *
-
 Automatic checking of the number and type of arguments. Foo's constructor takes
 a single long parameter. 
 
@@ -274,19 +271,12 @@ Pickle safety measures:
     ... except RuntimeError, err: print err[0]
     ... 
     Incomplete pickle support (__dict_defines_state__ not set)
-    >>> class myrational(Rational):
-    ...   __dict_defines_state__ = 1 # this is a lie but good enough for testing.
-    ...             
     >>> r=myrational(3, 4)
     >>> r
     Rational(3, 4)
     >>> s=pickle.dumps(r)
+    >>> u=pickle.loads(s)
 
-    >>> class myworld(world):
-    ...   def __init__(self):
-    ...     world.__init__(self, 'anywhere')
-    ...     self.x = 1
-    ... 
     >>> w = myworld()
     >>> w.greet()
     'Hello from anywhere!'
@@ -297,9 +287,6 @@ Pickle safety measures:
     ... 
     Incomplete pickle support (__getstate_manages_dict__ not set)
 
-    >>> class myunsafeworld(myworld):
-    ...   __getstate_manages_dict__ = 1 # this is a lie but good enough for testing.
-    ... 
     >>> w = myunsafeworld()
     >>> w.greet()
     'Hello from anywhere!'
@@ -1191,6 +1178,23 @@ test methodologies for wrapping functions that return a pointer
 '''
 #'
 
+from boost_python_test import *
+
+# pickle requires these derived classes to be
+# at the global scope of the module
+
+class myrational(Rational):
+  __dict_defines_state__ = 1 # this is a lie but good enough for testing.
+
+class myworld(world):
+  def __init__(self):
+    world.__init__(self, 'anywhere')
+    self.x = 1
+
+class myunsafeworld(myworld):
+  __getstate_manages_dict__ = 1 # this is a lie but good enough for testing.
+
+
 def assert_integer_expected(err):
   """Handle a common error report which appears differently in Python 1.5.x and 2.0"""
   assert isinstance(err, TypeError)

From b4a1a6c688d37d831fb7229feeb9f8c14a6015a4 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 2 Nov 2001 01:24:59 +0000
Subject: [PATCH 142/369] PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python

[SVN r11523]
---
 build/irix_CC.mak   | 4 ++--
 build/linux_gcc.mak | 4 ++--
 build/tru64_cxx.mak | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index e3a97781..ec387746 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -17,9 +17,9 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=/usr/local/Python-1.5.2/bin/python
+PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.1/bin/python
+#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
 #PYINC=-I/usr/local/Python-2.1/include/python2.1
 STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index 64d61bab..ef643991 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -19,9 +19,9 @@ BOOST=$(ROOT)/boost
 
 PYEXE=PYTHONPATH=. /usr/bin/python
 PYINC=-I/usr/include/python1.5
-#PYEXE=/usr/local/Python-1.5.2/bin/python
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 #PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.1/bin/python
+#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
 #PYINC=-I/usr/local/Python-2.1/include/python2.1
 
 STDOPTS=-fPIC -ftemplate-depth-21
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index d06f3372..f996a0c1 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -17,9 +17,9 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=/usr/local/Python-1.5.2/bin/python
+PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=/usr/local/Python-2.1/bin/python
+#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
 #PYINC=-I/usr/local/Python-2.1/include/python2.1
 #STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
 #STLPORTINC=-I/usr/local/STLport-4.1b4/stlport

From b211f8a096c8902442fb5e655ed01928816d5909 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 10 Nov 2001 22:16:01 +0000
Subject: [PATCH 143/369] Modified Files: 	index.htm - fixed reference to
 CVS repository 	libs/python/build/Jamfile - first stab at metrowerks
 Pro7 support 	status/Jamfile - added RUN_ALL_TESTS variables to force tests
 to run 	tools/build/boost-build.jam - fix BOOST_BUILD_INSTALLATION
 setting 	tools/build/metrowerks-tools.jam - command file support 
 tools/build/msvc-tools.jam - permanent command file support 
 tools/build/intel-win32-tools.jam - made it an extension of msvc-tools.jam 
 tools/build/gcc-tools.jam  - made FINDLIBS change submitted by Toon Knapen 
 tools/build/jam_src/variable.c - changed command-line/env. variable 	
 			interpretation so that 				
 surrounding them with quotes causes 					no
 breaking at spaces.

These files were converted from tabs to spaces:

	boost/python/conversions.hpp
	boost/python/reference.hpp boost/python/detail/base_object.hpp
	boost/python/detail/functions.hpp
	boost/python/detail/wrap_python.hpp libs/python/test/comprehensive.cpp
	tools/build/boost-base.jam
	tools/build/como-tools.jam


[SVN r11652]
---
 build/Jamfile                               |  1 +
 include/boost/python/conversions.hpp        | 22 ++---
 include/boost/python/detail/base_object.hpp |  2 +-
 include/boost/python/detail/functions.hpp   | 30 +++----
 include/boost/python/detail/wrap_python.hpp |  6 +-
 include/boost/python/reference.hpp          | 98 ++++++++++-----------
 test/comprehensive.cpp                      |  2 +-
 7 files changed, 83 insertions(+), 78 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index d597d055..eeb38d64 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -132,6 +132,7 @@ rule boost-python
                 # standard requirements
                 $(BOOST_PYTHON_INCLUDES)
                 <msvc><*><library-path>$(PYTHON_LIB_PATH)
+                <metrowerks><*><library-file>$(PYTHON_LIB_PATH)/python22.lib
                 <gcc><*><library-file>$(PYTHON_LIBS)
                 $(PYTHON_PROPERTIES)
                 
diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index cf753e2d..c1a7d390 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -74,17 +74,17 @@ inline void xdecref_impl(PyObject* p) { Py_XDECREF(p); }
 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));
+    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));
+    char* const raw_p = reinterpret_cast<char*>(p);
+    char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
+    xdecref_impl(reinterpret_cast<PyObject*>(p_base));
 }
 
 namespace detail {
@@ -294,22 +294,22 @@ inline PyObject* to_python(float f)
 
 inline PyObject* to_python(long l)
 {
-	return PyInt_FromLong(l);
+    return PyInt_FromLong(l);
 }
 
 inline PyObject* to_python(int x)
 {
-	return PyInt_FromLong(x);
+    return PyInt_FromLong(x);
 }
 
 inline PyObject* to_python(short x)
 {
-	return PyInt_FromLong(x);
+    return PyInt_FromLong(x);
 }
 
 inline PyObject* to_python(bool b)
 {
-	return PyInt_FromLong(b);
+    return PyInt_FromLong(b);
 }
 
 inline PyObject* to_python(void)
@@ -319,7 +319,7 @@ inline PyObject* to_python(void)
 
 inline PyObject* to_python(const char* s)
 {
-	return PyString_FromString(s);
+    return PyString_FromString(s);
 }
 
 inline std::string from_python(PyObject* p, boost::python::type<const std::string&>)
diff --git a/include/boost/python/detail/base_object.hpp b/include/boost/python/detail/base_object.hpp
index cf6bb528..19715876 100644
--- a/include/boost/python/detail/base_object.hpp
+++ b/include/boost/python/detail/base_object.hpp
@@ -48,7 +48,7 @@ base_object<PythonType>::base_object(PyTypeObject* type_obj)
 #if !defined(_MSC_VER) || defined(__STLPORT)
     std::
 #endif
-		memset(bp, 0, sizeof(base_python_type));
+        memset(bp, 0, sizeof(base_python_type));
     Py_INCREF(type_obj);
     PyObject_INIT(bp, type_obj);
 }
diff --git a/include/boost/python/detail/functions.hpp b/include/boost/python/detail/functions.hpp
index 16b8e16d..eff05d65 100644
--- a/include/boost/python/detail/functions.hpp
+++ b/include/boost/python/detail/functions.hpp
@@ -59,13 +59,13 @@ class function : public python_object
 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)
+    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
+    PyObject* do_call(PyObject* args, PyObject* keywords) const
         {
             // This is where the boundary between the uniform Python function
             // interface and the statically-checked C++ function interface is
@@ -77,7 +77,7 @@ struct wrapped_function_pointer : function
         { return typeid(F).name(); }
     
  private:
-	const ptr_fun m_pf;
+    const ptr_fun m_pf;
 };
 
 // raw_arguments_function
@@ -87,13 +87,13 @@ struct wrapped_function_pointer : function
 template <class Ret, class Args, class Keywords>
 struct raw_arguments_function : function
 {
-	typedef Ret (*ptr_fun)(Args, Keywords); 
-	
-	raw_arguments_function(ptr_fun pf)
+    typedef Ret (*ptr_fun)(Args, Keywords); 
+    
+    raw_arguments_function(ptr_fun pf)
         : m_pf(pf) {}
 
  private:
-	PyObject* do_call(PyObject* args, PyObject* keywords) const
+    PyObject* do_call(PyObject* args, PyObject* keywords) const
     { 
         ref dict(keywords ? 
                  ref(keywords, ref::increment_count) :
@@ -108,7 +108,7 @@ struct raw_arguments_function : function
         { return typeid(ptr_fun).name(); }
     
  private:
-	const ptr_fun m_pf;
+    const ptr_fun m_pf;
 };
 
 // virtual_function<> --
@@ -127,19 +127,19 @@ template <class T, class R, class V, class D>
 class virtual_function : public function
 {
  public:
-	virtual_function(V virtual_function_ptr, D default_implementation)
+    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;
+    PyObject* do_call(PyObject* args, PyObject* keywords) const;
     
     const char* description() const
         { return typeid(V).name(); }
     
  private:
-	const V m_virtual_function_ptr;
+    const V m_virtual_function_ptr;
     const D m_default_implementation;
 };
 
@@ -160,7 +160,7 @@ 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);
+    return new_wrapped_function_aux(return_value(pmf), pmf);
 }
 
 template <class R, class Args, class keywords>
@@ -220,7 +220,7 @@ class bound_function : public python_object
  private: // data members for allocation/deallocation optimization
     bound_function* m_free_list_link;
 
-	static bound_function* free_list;
+    static bound_function* free_list;
 };
 
 // Special functions designed to access data members of a wrapped C++ object.
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index b7a47513..373bbde4 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -90,5 +90,9 @@ typedef int pid_t;
 
 #if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
 # define PyObject_INIT(op, typeobj) \
-	( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+        ( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
+#endif
+
+#ifdef __MWERKS__
+# pragma warn_possunwant off
 #endif
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
index a1585099..4eb9ad51 100644
--- a/include/boost/python/reference.hpp
+++ b/include/boost/python/reference.hpp
@@ -42,31 +42,31 @@ BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
 
 template <class T>
 class reference
-	: public py_ptr_conversions<reference<T>, T>
+    : public py_ptr_conversions<reference<T>, T>
 {
 public:
     typedef T value_type;
     
-	reference(const reference& rhs)
-		: m_p(rhs.m_p)
-	{
-		Py_XINCREF(object());
-	}
+    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());
-	}
+    template <class T2>
+    reference(const reference<T2>& rhs)
+        : m_p(rhs.object())
+    {
+        Py_XINCREF(object());
+    }
 #endif
 
-	reference() : m_p(0) {}
+    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 increment_count_t { increment_count };
 
     enum allow_null { null_ok };
     
@@ -77,7 +77,7 @@ public:
     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) {}
@@ -85,49 +85,49 @@ public:
     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;
-	}
+    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& 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; }
+    ~reference()
+    {
+        Py_XDECREF(m_p);
+    }
+    
+    T& operator*() const { return *m_p; }
     
     // MSVC doesn't like boost::dereferencable unless T has a default
     // constructor, so operator-> must be defined by hand :(
     T* operator->() const { return &**this; } 
     
-	T* get() const { return m_p; }
+    T* get() const { return m_p; }
 
-	T* release()
-	{
-		T* p = m_p;
-		m_p = 0;
-		return p;
-	}
+    T* release()
+    {
+        T* p = m_p;
+        m_p = 0;
+        return p;
+    }
 
     void reset()
         { Py_XDECREF(m_p); m_p = 0; }
@@ -139,7 +139,7 @@ public:
     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;}
@@ -147,11 +147,11 @@ public:
     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;
@@ -160,7 +160,7 @@ private:
     inline PyObject* object() const
         { return as_object(m_p); }
 
-	T* m_p;
+    T* m_p;
 };
 
 typedef reference<PyObject> ref;
diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 427ed2d8..3571183e 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -157,7 +157,7 @@ int IntPairPythonClass::getattr(const IntPair& p, const std::string& s)
         PyErr_SetString(PyExc_AttributeError, s.c_str());
         throw boost::python::error_already_set();
     }
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2400
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2405
     return 0;
 #endif
 }

From e38bc7cbcecc62e206ca9354cb09aa8beab21d89 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 17:26:11 +0000
Subject: [PATCH 144/369] Pro7 compatibility

[SVN r11677]
---
 include/boost/python/cross_module.hpp           | 3 +++
 include/boost/python/detail/extension_class.hpp | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/include/boost/python/cross_module.hpp b/include/boost/python/cross_module.hpp
index 7c1fe507..dd1c47d2 100644
--- a/include/boost/python/cross_module.hpp
+++ b/include/boost/python/cross_module.hpp
@@ -169,6 +169,9 @@ struct export_converter_object_noncopyable : export_converter_object_base<T>
         PyErr_SetString(PyExc_RuntimeError,
           "to_python(const T&) converter not exported");
         throw import_error();
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+        return 0;
+#endif
     }
 
     virtual T* from_python_Ts(PyObject* p, boost::python::type<T*> t) {
diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index d871ad6e..f7be9afb 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -233,6 +233,9 @@ class python_extension_class_converters
         }
         boost::python::detail::report_missing_instance_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
         throw boost::python::argument_error();
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+        return 0;
+#endif
     }
 
     // Convert to T*
@@ -261,6 +264,9 @@ class python_extension_class_converters
         }
         boost::python::detail::report_missing_ptr_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
         throw boost::python::argument_error();
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+        return *(PtrType*)0;
+#endif
     }
 
     // Extract from obj a reference to the PtrType object which is holding a

From e7904fa67a1fa41a8fc535b3fd911c13b8596ae1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 17:32:08 +0000
Subject: [PATCH 145/369] add _d targets for debugging

[SVN r11678]
---
 build/Jamfile | 37 ++++++++++++++++++++++++++++++++-----
 1 file changed, 32 insertions(+), 5 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index eeb38d64..a76f372a 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -73,12 +73,13 @@ if $(NT)
     PYTHON_ROOT ?= c:/tools/python ;
     PYTHON_INCLUDES ?= <include>$(PYTHON_ROOT)/include <gcc><*><include>/usr/include/python$(PYTHON_VERSION) ;
     PYTHON_LIBS ?= c:/cygnus/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).dll.a ;
-    PYTHON_LIB_PATH = $(PYTHON_ROOT)/libs ;
+    PYTHON_LIB_PATH ?= $(PYTHON_ROOT)/libs ;
 
     # common properties required for compiling any Python module.
     PYTHON_PROPERTIES ?=
         <gcc><*><define>SIZEOF_LONG=4
         <gcc><*><define>USE_DL_IMPORT
+        <debug><define>_DEBUG
         <runtime-link>dynamic
         ;
                         
@@ -90,6 +91,10 @@ else if $(UNIX)
     PYTHON_LIBS ?= /usr/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).a ;
 }
 
+local PYTHON_VERSION_NODOT
+        = [ SUBST $(PYTHON_VERSION) ([0-9]*)\.([0-9]*) $1$2 ]
+      ;
+
 # how do we invoke python?
 local PYTHON = $(PYTHON) ;
 PYTHON ?= python ;
@@ -107,14 +112,22 @@ local BOOST_PYTHON_INCLUDES = <include>$(BOOST_ROOT) $(PYTHON_INCLUDES) ;
 
 # Base names of the source files for libboost_python
 local CPP_SOURCES =
-    classes conversions extension_class functions 
-    init_function module_builder objects types cross_module ;
+    types classes conversions extension_class functions 
+    init_function module_builder objects  cross_module ;
 
 lib libboost_python : ../src/$(CPP_SOURCES).cpp
     # requirements
     : $(BOOST_PYTHON_INCLUDES)
     <shared-linkable>true
     $(PYTHON_PROPERTIES) ;
+
+lib libboost_python_d : ../src/$(CPP_SOURCES).cpp
+    # requirements
+    : $(BOOST_PYTHON_INCLUDES)
+    <shared-linkable>true
+    $(PYTHON_PROPERTIES)
+    <define>BOOST_DEBUG_PYTHON
+    ;
     
 #######################
 
@@ -123,8 +136,14 @@ lib libboost_python : ../src/$(CPP_SOURCES).cpp
 # Declare a boost python module. Return a list of the DLL files generated.
 rule boost-python
 {
+    local debug ;
+    if ( <define>BOOST_DEBUG_PYTHON in $(3) ) || ( debug-python in $(BUILD) )
+    {
+        debug = _d ;
+    }
+    
     # declare a DLL; add the boost python library to sources
-     dll $(<) : <lib>libboost_python $(>)
+    dll $(<) : <lib>libboost_python$(debug) $(>)
             
             # Requirements
             : $(3) # caller-specified requirements
@@ -132,7 +151,7 @@ rule boost-python
                 # standard requirements
                 $(BOOST_PYTHON_INCLUDES)
                 <msvc><*><library-path>$(PYTHON_LIB_PATH)
-                <metrowerks><*><library-file>$(PYTHON_LIB_PATH)/python22.lib
+                <metrowerks><*><library-file>$(PYTHON_LIB_PATH)/python$(PYTHON_VERSION_NODOT)$(debug).lib
                 <gcc><*><library-file>$(PYTHON_LIBS)
                 $(PYTHON_PROPERTIES)
                 
@@ -146,9 +165,12 @@ rule boost-python
 rule boost-python-test
 {
     type-DEPENDS test : $(<) ;
+    type-DEPENDS test_d : $(<)_d ;
+    NOTFILE test_d ;
     
     local gSUPPRESS_FAKE_TARGETS = true ;
     boost-python $(1) : $(2) : $(3) : $(4) ;
+    boost-python $(1)_d : $(2) : $(3) <define>BOOST_DEBUG_PYTHON : $(4) ;
 }
 
 #######################
@@ -239,12 +261,17 @@ boost-python-runtest comprehensive
          : [ join-path $(DOTDOT) test comprehensive.py ]
            <lib>boost_python_test ;
 
+boost-python-runtest comprehensive_d
+         : [ join-path $(DOTDOT) test comprehensive.py ]
+           <lib>boost_python_test_d ;
+
 ############# simple tests from ../example ############
 
 rule boost-python-example-runtest
 {
     boost-python-test $(<) : ../example/$(<).cpp ;
     boost-python-runtest $(<) : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<) ;
+    boost-python-runtest $(<)_d : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<)_d ;
 }
 
 

From b7e10592272d61e90ca7c129109fa3576225aaba Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 17:35:18 +0000
Subject: [PATCH 146/369] initial checkin

[SVN r11679]
---
 include/boost/python/detail/void_adaptor.hpp | 39 ++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 include/boost/python/detail/void_adaptor.hpp

diff --git a/include/boost/python/detail/void_adaptor.hpp b/include/boost/python/detail/void_adaptor.hpp
new file mode 100644
index 00000000..c2ecc2b0
--- /dev/null
+++ b/include/boost/python/detail/void_adaptor.hpp
@@ -0,0 +1,39 @@
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+
+#ifndef VOID_ADAPTOR_DWA20011112_HPP
+# define VOID_ADAPTOR_DWA20011112_HPP
+
+namespace boost { namespace python { namespace detail {
+
+  extern PyObject arbitrary_object;
+
+  template <class T>
+  struct void_adaptor
+  {
+      typedef PyObject* result_type;
+      
+      void_adaptor(T const& f)
+          : m_f(f)
+      {}
+          
+      PyObject* operator()() const
+      {
+          m_f();
+          return &arbitrary_object;
+      }
+   private:
+      T m_f;
+  };
+
+  template <class T>
+  void_adaptor<T> make_void_adaptor(T const& f)
+  {
+      return void_adaptor<T>(f);
+  }
+}}} // namespace boost::python::detail
+
+#endif // VOID_ADAPTOR_DWA20011112_HPP
+

From 634d0848c894bcb3309209e62640105b6bab70c1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 17:37:07 +0000
Subject: [PATCH 147/369] got rid of the "rethrow error reporting" mechanism

[SVN r11680]
---
 src/conversions.cpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/conversions.cpp b/src/conversions.cpp
index 4bfe2011..c986f57b 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -14,6 +14,7 @@
 // 03 Mar 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
 
 #include <boost/python/conversions.hpp>
+#include <boost/python/detail/void_adaptor.hpp>
 #include <typeinfo>
 #include <exception>
 #ifndef BOOST_NO_LIMITS
@@ -23,15 +24,11 @@
 namespace boost { namespace python {
 
 // IMPORTANT: this function may only be called from within a catch block!
-void handle_exception()
+PyObject* handle_exception_impl(object_functor_base const& f)
 {
-    try {
-        // re-toss the current exception so we can find out what type it is.
-        // NOTE: a heinous bug in MSVC6 causes exception objects re-thrown in
-        // this way to be double-destroyed. Thus, you must only use objects that
-        // can tolerate double-destruction with that compiler. Metrowerks
-        // Codewarrior doesn't suffer from this problem.
-        throw;
+    try
+    {
+        return f();
     }
     catch(const boost::python::error_already_set&)
     {
@@ -49,6 +46,13 @@ void handle_exception()
     {
         PyErr_SetString(PyExc_RuntimeError, "unidentifiable C++ exception");
     }
+    return 0;
+}
+
+void handle_exception(void (*f)())
+{
+    handle_exception(
+        boost::python::detail::make_void_adaptor(f));
 }
 
 namespace detail {
@@ -116,7 +120,7 @@ T integer_from_python(PyObject* p, boost::python::type<T>)
         PyErr_SetString(PyExc_ValueError, buffer);
         throw boost::python::argument_error();
     }
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2400
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
     return 0; // Not smart enough to know that the catch clause always rethrows
 #endif
 }

From 6e7f1bc257f596090c0a8a01b9126beaad9c38df Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 17:41:17 +0000
Subject: [PATCH 148/369] Pro7 compatibility

[SVN r11681]
---
 src/gen_extclass.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index 57189a7d..b794dc2c 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -238,6 +238,9 @@ class python_extension_class_converters
         }
         boost::python::detail::report_missing_instance_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
         throw boost::python::argument_error();
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+        return 0;
+#endif
     }
 
     // Convert to T*
@@ -266,6 +269,10 @@ class python_extension_class_converters
         }
         boost::python::detail::report_missing_ptr_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
         throw boost::python::argument_error();
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+        PtrType x;
+        return x;
+#endif
     }
 
     // Extract from obj a reference to the PtrType object which is holding a

From aad05325a6e1426c508c68e126281cbf86edc759 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 19:50:35 +0000
Subject: [PATCH 149/369] Pro7 compatibility use the new "no-rethrow" way of
 handling exceptions.

[SVN r11682]
---
 test/comprehensive.cpp | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 3571183e..8eaac025 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -157,7 +157,7 @@ int IntPairPythonClass::getattr(const IntPair& p, const std::string& s)
         PyErr_SetString(PyExc_AttributeError, s.c_str());
         throw boost::python::error_already_set();
     }
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2405
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
     return 0;
 #endif
 }
@@ -1139,12 +1139,7 @@ void init_module()
 
 BOOST_PYTHON_MODULE_INIT(boost_python_test)
 {
-    try {
-        bpl_test::init_module();
-    }
-    catch(...) {
-        boost::python::handle_exception();
-    } // Need a way to report other errors here
+    boost::python::handle_exception((void (*)())bpl_test::init_module);
 }
 
 CompareIntPairPythonClass::CompareIntPairPythonClass(boost::python::module_builder& m)

From 5bec0d2d9817638ad63e4d6fa6ac40bd39e420b4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 20:06:18 +0000
Subject: [PATCH 150/369] fixes for intel

[SVN r11690]
---
 build/Jamfile | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/build/Jamfile b/build/Jamfile
index a76f372a..c4b9a9c3 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -151,6 +151,7 @@ rule boost-python
                 # standard requirements
                 $(BOOST_PYTHON_INCLUDES)
                 <msvc><*><library-path>$(PYTHON_LIB_PATH)
+                <intel-win32><*><library-path>$(PYTHON_LIB_PATH)
                 <metrowerks><*><library-file>$(PYTHON_LIB_PATH)/python$(PYTHON_VERSION_NODOT)$(debug).lib
                 <gcc><*><library-file>$(PYTHON_LIBS)
                 $(PYTHON_PROPERTIES)
@@ -239,6 +240,7 @@ rule python-runtest-aux # target : sources
     switch $(<)
     {
         case <*\\\\msvc\\\\*>* : ARGS on $(<) += --broken-auto-ptr ;
+        case <*\\\\intel-win32\\\\*>* : ARGS on $(<) += --broken-auto-ptr ;
     }
 
     # compute the PYTHONPATH environment variable that will allow the test to

From 7d6ff83760235f9cb23db61716c44635a6dfbd99 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 20:07:38 +0000
Subject: [PATCH 151/369] use the new "no-rethrow" way of handling exceptions.

[SVN r11691]
---
 include/boost/python/errors.hpp | 39 ++++++++++++++++++++++++++++++++-
 src/extension_class.cpp         | 16 +++++++++-----
 2 files changed, 48 insertions(+), 7 deletions(-)

diff --git a/include/boost/python/errors.hpp b/include/boost/python/errors.hpp
index a1cdbbb0..66f15587 100644
--- a/include/boost/python/errors.hpp
+++ b/include/boost/python/errors.hpp
@@ -9,13 +9,50 @@
 #ifndef ERRORS_DWA052500_H_
 # define ERRORS_DWA052500_H_
 
+# include <boost/python/detail/wrap_python.hpp>
+
 namespace boost { namespace python {
 
 struct error_already_set {};
 struct argument_error : error_already_set {};
 
+struct object_functor_base
+{
+    typedef PyObject* result_type;
+    virtual PyObject* operator()() const = 0;
+ private:
+    static void* operator new(std::size_t); // don't allow dynamic allocation
+    void operator delete(void*); 
+    void operator delete(void*, size_t); 
+};
+
+template <class T>
+struct object_functor : object_functor_base
+{
+    object_functor(T const& f)
+        : m_f(f)
+    {
+    }
+    
+    PyObject* operator()() const
+    {
+        return m_f();
+    }
+ private:
+    T const& m_f;
+};
+
+
 // Handles exceptions caught just before returning to Python code.
-void handle_exception();
+PyObject* handle_exception_impl(object_functor_base const& f);
+
+template <class T>
+PyObject* handle_exception(T const& f)
+{
+    return handle_exception_impl(object_functor<T>(f));
+}
+
+void handle_exception(void (*)());
 
 template <class T>
 T* expect_non_null(T* x)
diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index f71976b9..3815a19c 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -10,8 +10,9 @@
 // 04 Mar 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
 #include <boost/python/detail/extension_class.hpp>
-#include <cstring>
 #include <boost/utility.hpp>
+#include <boost/bind.hpp>
+#include <cstring>
 
 namespace boost { namespace python {
 namespace detail {
@@ -484,16 +485,19 @@ void operator_dispatcher_dealloc(PyObject* self)
 int operator_dispatcher_coerce(PyObject** l, PyObject** r)
 {
     Py_INCREF(*l);
-    try
+    PyObject* new_r = handle_exception(
+        bind(operator_dispatcher::create,
+                    ref(*r, ref::increment_count),
+                    ref()));
+    if (new_r)
     {
-        *r = operator_dispatcher::create(ref(*r, ref::increment_count), ref());
+        *r = new_r;
+        return 0;
     }
-    catch(...)
+    else
     {
-        handle_exception();
         return -1;
     }
-    return 0;
 }
 
 

From 76768120d404e7ee532daecc8f5470736e5ad003 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 14 Nov 2001 20:36:14 +0000
Subject: [PATCH 152/369] use the new "no-rethrow" way of handling exceptions.

[SVN r11692]
---
 src/types.cpp | 256 ++++++++++++++++++++++++++++----------------------
 1 file changed, 143 insertions(+), 113 deletions(-)

diff --git a/src/types.cpp b/src/types.cpp
index add0ebf0..2e738c35 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -8,15 +8,18 @@
 
 #include <boost/python/detail/types.hpp>
 #include <boost/python/reference.hpp> // for handle_exception()
+#include <boost/python/conversions.hpp>
 #include <boost/python/module_builder.hpp>
 #include <boost/python/detail/none.hpp>
+#include <boost/python/detail/void_adaptor.hpp>
 #include <cstring>
 #include <vector>
 #include <cstddef>
 #include <stdexcept>
 #include <boost/smart_ptr.hpp>
 #include <boost/python/objects.hpp>
-#include <boost/type_traits.hpp>
+#include <boost/type_traits/alignment_traits.hpp>
+#include <boost/bind.hpp>
 
 namespace boost { namespace python {
 
@@ -24,139 +27,169 @@ namespace {
 
   using detail::type_object_base;
 
-  // Define a family of forwarding functions that can be calle from a
+  // Define a family of forwarding functions that can be called from a
   // PyTypeObject's slots. These functions dispatch through a (virtual) member
   // function pointer in the type_object_base, and handle exceptions in a
   // uniform way, preventing us from having to rewrite the dispatching code over
   // and over.
-  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*) const)
+
+
+  // Given a function object f with signature
+  //
+  //    PyObject* f(PyTypeObject*,PyObject*)
+  //
+  // calls f inside of handle_exception, and returns the result. If an exception
+  // is thrown by f, returns 0.
+  template <class F>
+  PyObject* obj_call(PyObject* obj, F const& f)
   {
-      try
-      {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return 0;
-      }
+      return handle_exception(
+          boost::bind<PyObject*>(f, static_cast<type_object_base*>(obj->ob_type), obj));
   }
 
-  // Naming this differently allows us to use it for functions returning long on
-  // compilers without partial ordering
-  template <class R>
-  R int_call(PyObject* obj, R (type_object_base::*f)(PyObject*) const)
+
+  // int_converter<T>/value_holder<T>
+  //
+  // A simple function object which converts its argument to a PyObject*. We
+  // need this because handle_exception needs to return a PyObject*, even if the
+  // function being called is supposed to return int. It has two parts...
+
+  // holds the value actually returned by the underlying function
+  template <class T>
+  struct value_holder : PyObject
   {
-      try
+      value_holder() : is_set(false), value(-1) {}
+
+      // Tricky constructor allows us to grab the result even if rhs == 0.
+      explicit value_holder(value_holder const* rhs)
+          : is_set(rhs ? rhs->is_set : false), value(rhs ? rhs->value : -1) {}
+
+      // true if the function object was ever called (false if an exception occurred)
+      bool is_set;
+
+      // The returned value
+      T value;
+  };
+
+  // The function object
+  template <class R>
+  struct int_converter
+  {
+      typedef PyObject* result_type;
+      
+      PyObject* operator()(R const& x)
       {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return -1;
+          m_holder.is_set = true;
+          m_holder.value = x;
+          return &m_holder; // returns
       }
+
+      value_holder<R> m_holder;
+  };
+
+  // Call the given int-returning function object inside of handle_exception,
+  // returning a value_holder. F is a function object with "signature"
+  //
+  //     R F(PyTypeObject*, PyObject*)
+  //
+  // where R is an integer type.
+  template <class R, class F>
+  typename value_holder<R> int_call_holder(PyObject* obj, F f)
+  {
+      return value_holder<R>(
+          
+          // The int_converter object containing the value_holder is valid
+          // through the life of the full-expression, so we can construct from
+          // the pointer
+          static_cast<value_holder<R>*>(
+              handle_exception(
+
+                  boost::bind<PyObject*>(
+                      // Add an int_converter back-end to f
+                      int_converter<R>()
+                      // Bind the object's type and the object itself into f
+                      , boost::bind<R>(f, static_cast<type_object_base*>(obj->ob_type), obj)
+                      )
+                  
+                  )
+              )
+          );
+  }
+
+  // Just like int_call_holder (above), but returns the integer directly. If F
+  // throws an exception, returns -1
+  template <class R, class F>
+  R int_call(PyObject* obj, F f)
+  {
+      value_holder<R> const v(int_call_holder<R>(obj, f));
+      return v.value;
+  }
+
+  // Implemented in terms of obj_call, above
+  PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*) const)
+  {
+      return obj_call(obj, bind(f, _1, _2));
   }
 
   // Implemented in terms of int_call, above
   int call(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
   {
-      return int_call(obj, f);
+      return int_call<int>(obj, bind(f, _1, _2));
   }
 
   template <class A1>
   PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*, A1) const, A1 a1)
   {
-      try
-      {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return 0;
-      }
+      return obj_call(obj, bind(f, _1, _2, a1));
   }
 
   template <class A1>
   int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1) const, A1 a1)
   {
-      try
-      {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return -1;
-      }
+      return int_call<int>(obj, bind(f, _1, _2, a1));
   }
 
   template <class A1, class A2>
   PyObject* call(PyObject* obj, PyObject* (type_object_base::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
   {
-      try
-      {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1, a2);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return 0;
-      }
+      return obj_call(obj, bind(f, _1, _2, a1, a2));
   }
 
   template <class A1, class A2>
   int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2)
   {
-      try
-      {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1, a2);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return -1;
-      }
+      return int_call<int>(obj, bind(f, _1, _2, a1, a2));
   }
 
   template <class A1, class A2, class A3>
   int call(PyObject* obj, int (type_object_base::*f)(PyObject*, A1, A2, A3) const, A1 a1, A2 a2, A3 a3)
   {
-      try
-      {
-          return (static_cast<type_object_base*>(obj->ob_type)->*f)(obj, a1, a2, a3);
-      }
-      catch(...)
-      {
-          handle_exception();
-          return -1;
-      }
+      return int_call<int>(obj, bind(f, _1, _2, a1, a2, a3));
   }
 
   int call_length_function(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
   {
-      try
+      value_holder<int> const r(int_call_holder<int>(obj, bind(f, _1, _2)));
+      
+      if (!r.is_set)
       {
-          const int outcome =
-              (static_cast<type_object_base*>(obj->ob_type)->*f)(obj);
-
-          if (outcome < 0)
-          {
-              PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0");
-              return -1;
-          }
-          return outcome;
-      }
-      catch(...)
-      {
-          handle_exception();
           return -1;
       }
-  }
+      
+      const int outcome = r.value;
+      if (outcome >= 0)
+          return outcome;
 
+      PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0");
+      return -1;
+  }
 }  // anonymous namespace
 
+namespace detail {
+  // needed by void_adaptor (see void_adaptor.hpp)
+  PyObject arbitrary_object;
+}
+
 extern "C" {
 
 //
@@ -202,7 +235,7 @@ static PyObject* do_instance_str(PyObject* obj)
 
 static long do_instance_hash(PyObject* obj)
 {
-    return int_call(obj, &type_object_base::instance_hash);
+    return int_call<long>(obj, bind(&type_object_base::instance_hash, _1, _2));
 }
     
 static PyObject* do_instance_call(PyObject* obj, PyObject* args, PyObject* keywords)
@@ -212,15 +245,16 @@ static PyObject* do_instance_call(PyObject* obj, PyObject* args, PyObject* keywo
 
 static void do_instance_dealloc(PyObject* obj)
 {
-    try
-    {
-        static_cast<type_object_base*>(obj->ob_type)
-            ->instance_dealloc(obj);
-    }
-    catch(...)
+    PyObject* success = handle_exception(
+        // translate the void return value of instance_dealloc into a PyObject*
+        // that can indicate no error.
+        detail::make_void_adaptor(
+            bind(&type_object_base::instance_dealloc
+                       , static_cast<type_object_base*>(obj->ob_type)
+                       , obj)));
+    if (!success)
     {
         assert(!"exception during destruction!");
-        handle_exception();
     }
 }
 
@@ -253,28 +287,22 @@ static PyObject* do_instance_mp_subscript(PyObject* obj, PyObject* index)
 
 static PyObject* do_instance_sq_item(PyObject* obj, int index)
 {
-    try
+    // This is an extension to standard class behavior. If sequence_length
+    // is implemented and n >= sequence_length(), raise an IndexError. That
+    // keeps users from having to worry about raising it themselves
+    const PyTypeObject* const type = obj->ob_type;
+    if (type->tp_as_sequence != 0 && type->tp_as_sequence->sq_length != 0
+        && index >= type->tp_as_sequence->sq_length(obj))
     {
-        const PyTypeObject* const type = obj->ob_type;
-        
-        // This is an extension to standard class behavior. If sequence_length
-        // is implemented and n >= sequence_length(), raise an IndexError. That
-        // keeps users from having to worry about raising it themselves
-        if (type->tp_as_sequence != 0 && type->tp_as_sequence->sq_length != 0
-            && index >= type->tp_as_sequence->sq_length(obj))
-        {
-            PyErr_SetString(PyExc_IndexError, type->tp_name);
-            return 0;
-        }
-    
-        return static_cast<type_object_base*>(obj->ob_type)
-            ->instance_sequence_item(obj, index);
-    }
-    catch(...)
-    {
-        handle_exception();
+        PyErr_SetString(PyExc_IndexError, type->tp_name);
         return 0;
     }
+
+    return handle_exception(
+        bind(&type_object_base::instance_sequence_item
+             , static_cast<type_object_base*>(obj->ob_type)
+             , obj
+             , index));
 }
 
 static int do_instance_mp_ass_subscript(PyObject* obj, PyObject* index, PyObject* value)
@@ -397,7 +425,10 @@ static PyObject* do_instance_nb_or(PyObject* obj, PyObject* other)
 
 static int do_instance_nb_coerce(PyObject**obj, PyObject**other)
 {
-    return call(*obj, &type_object_base::instance_number_coerce, obj, other);
+    // no call() overload for this oddball function, so we'll do it manually
+    return int_call<int>(
+        *obj, bind(
+            &type_object_base::instance_number_coerce, _1, _2, obj, other));
 }
 static PyObject* do_instance_nb_int(PyObject* obj)
 {
@@ -1171,4 +1202,3 @@ int main()
 }
 
 #endif
-

From e6efa6e13e046dd7c412c92e4103085cc4098a98 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 15 Nov 2001 00:51:33 +0000
Subject: [PATCH 153/369] Fix minor gcc bug

[SVN r11704]
---
 src/types.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/types.cpp b/src/types.cpp
index 2e738c35..3367dba8 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -94,7 +94,7 @@ namespace {
   //
   // where R is an integer type.
   template <class R, class F>
-  typename value_holder<R> int_call_holder(PyObject* obj, F f)
+  value_holder<R> int_call_holder(PyObject* obj, F f)
   {
       return value_holder<R>(
           

From 0dbb780a2f8b6e52100a201ff10e41ac9fa5db57 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 15 Nov 2001 05:29:22 +0000
Subject: [PATCH 154/369] * Updated to new handle_exception() idiom for
 boost::python * Made Cygwin archiving reliable, even when the user supplies a
 path with backslashes

----------------------------------------------------------------------

Modified Files:
	tools/build/gcc-tools.jam tools/build/new/boost-build.jam
	boost/python/detail/config.hpp libs/python/build/Jamfile
	libs/python/example/do_it_yourself_convts.cpp
	libs/python/example/dvect.cpp libs/python/example/example1.cpp
	libs/python/example/getting_started1.cpp
	libs/python/example/getting_started2.cpp
	libs/python/example/ivect.cpp libs/python/example/nested.cpp
	libs/python/example/noncopyable_export.cpp
	libs/python/example/noncopyable_import.cpp
	libs/python/example/pickle1.cpp
	libs/python/example/pickle2.cpp
	libs/python/example/pickle3.cpp
	libs/python/example/richcmp1.cpp
	libs/python/example/richcmp2.cpp
	libs/python/example/richcmp3.cpp libs/python/example/rwgk1.cpp
	libs/python/example/simple_vector.cpp
	libs/python/test/comprehensive.cpp
Added Files:
	libs/python/example/rwgk2.cpp libs/python/example/rwgk3.cpp
----------------------------------------------------------------------


[SVN r11705]
---
 build/Jamfile                          |   7 +-
 example/do_it_yourself_convts.cpp      |   7 --
 example/dvect.cpp                      |   8 --
 example/example1.cpp                   |  33 +++-----
 example/getting_started1.cpp           |   7 --
 example/getting_started2.cpp           |   7 --
 example/ivect.cpp                      |   7 --
 example/nested.cpp                     |   7 --
 example/noncopyable_export.cpp         |   7 --
 example/noncopyable_import.cpp         |   7 --
 example/pickle1.cpp                    |   7 --
 example/pickle2.cpp                    |   7 --
 example/pickle3.cpp                    |   7 --
 example/richcmp1.cpp                   |   3 -
 example/richcmp2.cpp                   |   3 -
 example/richcmp3.cpp                   |   3 -
 example/rwgk1.cpp                      |  19 +----
 example/rwgk2.cpp                      |  50 ++++++++++++
 example/rwgk3.cpp                      | 101 +++++++++++++++++++++++++
 example/simple_vector.cpp              |   7 --
 include/boost/python/detail/config.hpp |   4 +-
 test/comprehensive.cpp                 |   7 +-
 22 files changed, 171 insertions(+), 144 deletions(-)
 create mode 100644 example/rwgk2.cpp
 create mode 100644 example/rwgk3.cpp

diff --git a/build/Jamfile b/build/Jamfile
index c4b9a9c3..05efd4a1 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -136,7 +136,7 @@ lib libboost_python_d : ../src/$(CPP_SOURCES).cpp
 # Declare a boost python module. Return a list of the DLL files generated.
 rule boost-python
 {
-    local debug ;
+    local debug = "" ;
     if ( <define>BOOST_DEBUG_PYTHON in $(3) ) || ( debug-python in $(BUILD) )
     {
         debug = _d ;
@@ -203,7 +203,9 @@ rule python-test-target # test-target : sources :
 {
     python-runtest-aux $(<) : $(>) ;
     Clean clean : $(<) ; # remove the test-target as part of any clean operation
-    type-DEPENDS test : $(<) ;
+    local debug = [ SUBST $(<:B) (_d)$ $1 ] ;
+    debug ?= "" ;
+    type-DEPENDS test$(debug) : $(<) ;
     MakeLocate $(<) : $(LOCATE_TARGET) ;
 }
 actions python-test-target bind PYTHON
@@ -249,6 +251,7 @@ rule python-runtest-aux # target : sources
         $(gLOCATE($(>[1])))                     # location of python test file
         $(gRUN_PATH($(<)))                      # location of module dependencies
         [ join-path $(TOP) libs python test ]   # location of doctest
+        $(>:D)                                  # directory of python driver file(s)
         $(PYTHONPATH)                           # base PYTHONPATH from environment
         : $(SPLITPATH) ] ;                      # platform path separator
 
diff --git a/example/do_it_yourself_convts.cpp b/example/do_it_yourself_convts.cpp
index 4d9c1c89..01be6ef6 100644
--- a/example/do_it_yourself_convts.cpp
+++ b/example/do_it_yourself_convts.cpp
@@ -107,8 +107,6 @@ BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 BOOST_PYTHON_MODULE_INIT(do_it_yourself_convts)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("do_it_yourself_convts");
 
@@ -120,9 +118,4 @@ BOOST_PYTHON_MODULE_INIT(do_it_yourself_convts)
     // Add the member functions.
     ixset_class.def(&IndexingSet::add, "add");
     ixset_class.def(&IndexingSet::get, "get");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/dvect.cpp b/example/dvect.cpp
index 4d109c96..fa1506fe 100644
--- a/example/dvect.cpp
+++ b/example/dvect.cpp
@@ -32,8 +32,6 @@ extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
 
 BOOST_PYTHON_MODULE_INIT(dvect)
 {
-  try
-  {
     python::module_builder this_module("dvect");
 
     python::class_builder<vects::dvect> dvect_class(this_module, "dvect");
@@ -47,10 +45,4 @@ BOOST_PYTHON_MODULE_INIT(dvect)
 
 # include "dvect_defs.cpp"
 # include "ivect_defs.cpp"
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
-
diff --git a/example/example1.cpp b/example/example1.cpp
index 467ac0dc..7bc5a1b7 100644
--- a/example/example1.cpp
+++ b/example/example1.cpp
@@ -16,32 +16,21 @@ namespace hello {
 
 // Python requires an exported function called init<module-name> in every
 // extension module. This is where we build the module contents.
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void inithello()
+BOOST_PYTHON_MODULE_INIT(hello)
 {
-    try
-    {
-       // create an object representing this extension module
-       boost::python::module_builder hello("hello");
+    // create an object representing this extension module
+    boost::python::module_builder hello("hello");
 
-       // Create the Python type object for our extension class
-       boost::python::class_builder<hello::world> world_class(hello, "world");
+    // Create the Python type object for our extension class
+    boost::python::class_builder<hello::world> world_class(hello, "world");
 
-       // Add the __init__ function
-       world_class.def(boost::python::constructor<int>());
-       // Add a regular member function
-       world_class.def(&hello::world::get, "get");
+    // Add the __init__ function
+    world_class.def(boost::python::constructor<int>());
+    // Add a regular member function
+    world_class.def(&hello::world::get, "get");
 
-       // Add a regular function to the module
-       hello.def(hello::length, "length");
-    }
-    catch(...)
-    {
-       boost::python::handle_exception();    // Deal with the exception for Python
-    }
+    // Add a regular function to the module
+    hello.def(hello::length, "length");
 }
 
 // Win32 DLL boilerplate
diff --git a/example/getting_started1.cpp b/example/getting_started1.cpp
index c6a77723..2f180633 100644
--- a/example/getting_started1.cpp
+++ b/example/getting_started1.cpp
@@ -16,17 +16,10 @@ namespace python = boost::python;
 // extension module. This is where we build the module contents.
 BOOST_PYTHON_MODULE_INIT(getting_started1)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("getting_started1");
 
     // Add regular functions to the module.
     this_module.def(greet, "greet");
     this_module.def(square, "square");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/getting_started2.cpp b/example/getting_started2.cpp
index 9121b1a0..04fbcc29 100644
--- a/example/getting_started2.cpp
+++ b/example/getting_started2.cpp
@@ -26,8 +26,6 @@ namespace python = boost::python;
 
 BOOST_PYTHON_MODULE_INIT(getting_started2)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("getting_started2");
 
@@ -44,9 +42,4 @@ BOOST_PYTHON_MODULE_INIT(getting_started2)
 
     // Even better, invite() can also be made a member of hello_class!!!
     hello_class.def(invite, "invite");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/ivect.cpp b/example/ivect.cpp
index 848d693e..35662b10 100644
--- a/example/ivect.cpp
+++ b/example/ivect.cpp
@@ -32,8 +32,6 @@ extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
 
 BOOST_PYTHON_MODULE_INIT(ivect)
 {
-  try
-  {
     python::module_builder this_module("ivect");
 
     python::class_builder<vects::ivect> ivect_class(this_module, "ivect");
@@ -47,10 +45,5 @@ BOOST_PYTHON_MODULE_INIT(ivect)
 
 # include "dvect_defs.cpp"
 # include "ivect_defs.cpp"
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
 
diff --git a/example/nested.cpp b/example/nested.cpp
index 543754f7..a5632d16 100644
--- a/example/nested.cpp
+++ b/example/nested.cpp
@@ -32,13 +32,6 @@ namespace {
 
 BOOST_PYTHON_MODULE_INIT(nested)
 {
-  try
-  {
     boost::python::module_builder this_module("nested");
     this_module.def(show_nested_tuples, "show_nested_tuples");
-  }
-  catch(...)
-  {
-    boost::python::handle_exception();
-  }
 }
diff --git a/example/noncopyable_export.cpp b/example/noncopyable_export.cpp
index b118abb8..3a81db75 100644
--- a/example/noncopyable_export.cpp
+++ b/example/noncopyable_export.cpp
@@ -18,8 +18,6 @@ extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
 
 BOOST_PYTHON_MODULE_INIT(noncopyable_export)
 {
-  try
-  {
     python::module_builder this_module("noncopyable_export");
 
     python::class_builder<store> store_class(this_module, "store");
@@ -27,9 +25,4 @@ BOOST_PYTHON_MODULE_INIT(noncopyable_export)
 
     store_class.def(python::constructor<int>());
     store_class.def(&store::recall, "recall");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/noncopyable_import.cpp b/example/noncopyable_import.cpp
index 66c6457d..d4227642 100644
--- a/example/noncopyable_import.cpp
+++ b/example/noncopyable_import.cpp
@@ -31,8 +31,6 @@ extern "C" void (*old_translator)(unsigned int, EXCEPTION_POINTERS*)
 
 BOOST_PYTHON_MODULE_INIT(noncopyable_import)
 {
-  try
-  {
     python::module_builder this_module("noncopyable_import");
 
     python::import_converters<store>
@@ -44,9 +42,4 @@ BOOST_PYTHON_MODULE_INIT(noncopyable_import)
     // However, to keep this example simple, we only define a
     // module-level function.
     this_module.def(add_stores, "add_stores");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/pickle1.cpp b/example/pickle1.cpp
index cdd78989..af041e72 100644
--- a/example/pickle1.cpp
+++ b/example/pickle1.cpp
@@ -41,8 +41,6 @@ namespace { // Avoid cluttering the global namespace.
 
 BOOST_PYTHON_MODULE_INIT(pickle1)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("pickle1");
 
@@ -56,9 +54,4 @@ BOOST_PYTHON_MODULE_INIT(pickle1)
 
     // Support for pickle.
     world_class.def(world_getinitargs, "__getinitargs__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/pickle2.cpp b/example/pickle2.cpp
index d6aa3201..576180ee 100644
--- a/example/pickle2.cpp
+++ b/example/pickle2.cpp
@@ -73,8 +73,6 @@ namespace { // Avoid cluttering the global namespace.
 
 BOOST_PYTHON_MODULE_INIT(pickle2)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("pickle2");
 
@@ -92,9 +90,4 @@ BOOST_PYTHON_MODULE_INIT(pickle2)
     world_class.def(world_getinitargs, "__getinitargs__");
     world_class.def(world_getstate, "__getstate__");
     world_class.def(world_setstate, "__setstate__");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/example/pickle3.cpp b/example/pickle3.cpp
index cb598ae6..664bed0b 100644
--- a/example/pickle3.cpp
+++ b/example/pickle3.cpp
@@ -65,8 +65,6 @@ namespace { // Avoid cluttering the global namespace.
 
 BOOST_PYTHON_MODULE_INIT(pickle3)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("pickle3");
 
@@ -85,11 +83,6 @@ BOOST_PYTHON_MODULE_INIT(pickle3)
     world_class.def_raw(world_getstate, "__getstate__");
     world_class.def_raw(world_setstate, "__setstate__");
     world_class.getstate_manages_dict();
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
 
 namespace {
diff --git a/example/richcmp1.cpp b/example/richcmp1.cpp
index 4dd74e1b..f59aae65 100644
--- a/example/richcmp1.cpp
+++ b/example/richcmp1.cpp
@@ -77,11 +77,8 @@ namespace {
 
 BOOST_PYTHON_MODULE_INIT(richcmp1)
 {
-  try {
     boost::python::module_builder this_module("richcmp1");
     // The actual work is done in a separate function in order
     // to suppress a bogus VC60 warning.
     init_module(this_module);
-  }
-  catch (...) { boost::python::handle_exception(); }
 }
diff --git a/example/richcmp2.cpp b/example/richcmp2.cpp
index 213852b3..993c6800 100644
--- a/example/richcmp2.cpp
+++ b/example/richcmp2.cpp
@@ -55,11 +55,8 @@ namespace {
 
 BOOST_PYTHON_MODULE_INIT(richcmp2)
 {
-  try {
     boost::python::module_builder this_module("richcmp2");
     // The actual work is done in a separate function in order
     // to suppress a bogus VC60 warning.
     init_module(this_module);
-  }
-  catch (...) { boost::python::handle_exception(); }
 }
diff --git a/example/richcmp3.cpp b/example/richcmp3.cpp
index 169e7f00..4be48fee 100644
--- a/example/richcmp3.cpp
+++ b/example/richcmp3.cpp
@@ -168,11 +168,8 @@ namespace {
 
 BOOST_PYTHON_MODULE_INIT(richcmp3)
 {
-  try {
     boost::python::module_builder this_module("richcmp3");
     // The actual work is done in a separate function in order
     // to suppress a bogus VC60 warning.
     init_module(this_module);
-  }
-  catch (...) { boost::python::handle_exception(); }
 }
diff --git a/example/rwgk1.cpp b/example/rwgk1.cpp
index b21ae4d1..ca8bd22f 100644
--- a/example/rwgk1.cpp
+++ b/example/rwgk1.cpp
@@ -13,29 +13,12 @@ namespace python = boost::python;
 
 // Python requires an exported function called init<module-name> in every
 // extension module. This is where we build the module contents.
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void initrwgk1()
+BOOST_PYTHON_MODULE_INIT(rwgk1)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("rwgk1");
 
     // Add regular functions to the module.
     this_module.def(greet, "greet");
     this_module.def(square, "square");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
-
-// Win32 DLL boilerplate
-#if defined(_WIN32)
-#include <windows.h>
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
-#endif // _WIN32
diff --git a/example/rwgk2.cpp b/example/rwgk2.cpp
new file mode 100644
index 00000000..35dce88f
--- /dev/null
+++ b/example/rwgk2.cpp
@@ -0,0 +1,50 @@
+#include <iostream>
+#include <string>
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A friendly class.
+  class world
+  {
+    private:
+      std::string country;
+    public:
+      world(const std::string& country) { this->country = country; }
+      std::string greet() const { return "Hello from " + country + "!"; }
+  };
+
+  // A function taking a world object as an argument.
+  std::string invite(const world& w) {
+    return w.greet() + " Please come soon!";
+  }
+}
+
+#include <py_cpp/class_wrapper.h>
+
+// Python requires an exported function called init<module-name> in every
+// extension module. This is where we build the module contents.
+BOOST_PYTHON_MODULE_INIT(example2)
+{
+    // Create an object representing this extension module.
+    py::Module this_module("example2");
+
+    // Create the Python type object for our extension class.
+    py::ClassWrapper<world> world_class(this_module, "world");
+
+    // Add the __init__ function.
+    world_class.def(py::Constructor<std::string>());
+    // Add a regular member function.
+    world_class.def(&world::greet, "greet");
+
+    // Add invite() as a regular function to the module.
+    this_module.def(invite, "invite");
+
+    // Even better, invite() can also be made a member of world_class!!!
+    world_class.def(invite, "invite");
+}
+
+// Win32 DLL boilerplate
+#if defined(_WIN32)
+#include <windows.h>
+extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
+#endif // _WIN32
diff --git a/example/rwgk3.cpp b/example/rwgk3.cpp
new file mode 100644
index 00000000..df17b28e
--- /dev/null
+++ b/example/rwgk3.cpp
@@ -0,0 +1,101 @@
+#include <py_cpp/class_wrapper.h>
+#include <py_cpp/objects.h>
+
+#define rangei(n)          for (int i = 0; i < n; i++)
+
+namespace { // Avoid cluttering the global namespace.
+
+  // A wrapper is used to define additional constructors.
+  //
+  struct vector_double_wrapper: std::vector<double>
+  {
+    // Tell the compiler how to convert a base class object to
+    // this wrapper object.
+    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
+      : std::vector<double>(vd) {}
+
+    vector_double_wrapper(PyObject* self)
+      : std::vector<double>() {}
+
+    vector_double_wrapper(PyObject* self, const int n)
+      : std::vector<double>(n) {}
+
+    vector_double_wrapper(PyObject* self, py::Tuple tuple)
+      : std::vector<double>(tuple.size())
+    {
+      std::vector<double>::iterator vd = begin();
+      rangei(tuple.size())
+        vd[i] = from_python(tuple[i].get(), py::Type<double>()); // GCC BUG
+    }
+  };
+
+  double getitem(const std::vector<double>& vd, const std::size_t key) {
+    return vd[key];
+  }
+
+  void setitem(std::vector<double>& vd, const std::size_t key,
+               const double &d) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vditer[key] = d;
+  }
+
+  void delitem(std::vector<double>& vd, const std::size_t key) {
+    std::vector<double>::iterator vditer = vd.begin();
+    vd.erase(&vditer[key]);
+  }
+
+  // Convert vector_double to a regular Python tuple.
+  //
+  py::Tuple as_tuple(const std::vector<double>& vd)
+  {
+    py::Tuple t(vd.size());
+    rangei(vd.size()) t.set_item(i, py::Ptr(py::to_python(vd[i]))); // GCC BUG
+    return t;
+  }
+
+  // Function returning a vector_double object to Python.
+  //
+  std::vector<double> foo(const int n)
+  {
+    std::vector<double> vd(n);
+    std::vector<double>::iterator vditer = vd.begin();
+    rangei(n) vditer[i] = double(i);
+    return vd;
+  }
+
+  // Same as foo(), but avoid copying on return.
+  //
+  std::auto_ptr<std::vector<double> > bar(const int n)
+  {
+    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
+    std::vector<double>::iterator vditer = vdptr->begin();
+    rangei(n) vditer[i] = double(10 * i);
+    return vdptr;
+  }
+}
+
+BOOST_PYTHON_MODULE_INIT(example3)
+{
+    py::Module this_module("example3");
+
+    py::ClassWrapper<std::vector<double>, vector_double_wrapper>
+      vector_double(this_module, "vector_double");
+
+    vector_double.def(py::Constructor<>());
+    vector_double.def(py::Constructor<const int>());
+    vector_double.def(py::Constructor<py::Tuple>());
+    vector_double.def(&std::vector<double>::size, "__len__");
+    vector_double.def(getitem, "__getitem__");
+    vector_double.def(setitem, "__setitem__");
+    vector_double.def(delitem, "__delitem__");
+    vector_double.def(as_tuple, "as_tuple");
+
+    this_module.def(foo, "foo");
+    this_module.def(bar, "bar");
+}
+
+// Win32 DLL boilerplate
+#if defined(_WIN32)
+#include <windows.h>
+extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
+#endif // _WIN32
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
index 3499c8f7..8c7ee0ce 100644
--- a/example/simple_vector.cpp
+++ b/example/simple_vector.cpp
@@ -85,8 +85,6 @@ namespace { // Avoid cluttering the global namespace.
 
 BOOST_PYTHON_MODULE_INIT(simple_vector)
 {
-  try
-  {
     python::module_builder this_module("simple_vector");
 
     python::class_builder<std::vector<double>, vector_double_wrapper>
@@ -103,9 +101,4 @@ BOOST_PYTHON_MODULE_INIT(simple_vector)
 
     this_module.def(foo, "foo");
     this_module.def(bar, "bar");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index b6075368..f814aba0 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -58,9 +58,9 @@
 # endif
 
 #if defined(_WIN32) || defined(__CYGWIN__)
-# define BOOST_PYTHON_MODULE_INIT(name) extern "C" __declspec(dllexport) void init##name()
+# define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" __declspec(dllexport) void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
 #else
-# define BOOST_PYTHON_MODULE_INIT(name) extern "C" void init##name()
+# define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
 #endif
 
 #endif // CONFIG_DWA052200_H_
diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 8eaac025..7cd7e0ce 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -1128,7 +1128,7 @@ PyObject* raw(const boost::python::tuple& args, const boost::python::dictionary&
     return BOOST_PYTHON_CONVERSION::to_python(first->i_ + second + third + fourth);
 }
 
-void init_module()
+BOOST_PYTHON_MODULE_INIT(boost_python_test)
 {
     boost::python::module_builder boost_python_test("boost_python_test");
     init_module(boost_python_test);
@@ -1137,11 +1137,6 @@ void init_module()
     boost_python_test.add(new boost::python::meta_class<boost::python::instance>);
 }
 
-BOOST_PYTHON_MODULE_INIT(boost_python_test)
-{
-    boost::python::handle_exception((void (*)())bpl_test::init_module);
-}
-
 CompareIntPairPythonClass::CompareIntPairPythonClass(boost::python::module_builder& m)
     : boost::python::class_builder<CompareIntPair>(m, "CompareIntPair")
 {

From 6a6084ed0ecf81134527ac066d629127a249d312 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 2 Dec 2001 17:43:45 +0000
Subject: [PATCH 155/369] Metrowerks needs BOOST_NO_STD_LOCALE in config to be
 able to compile regex regex test Jamfile updates so that some tests will
 actually run warning suppression for condition.cpp

unit-test rule now accepts input files
updated metrowerks and borland to properly set up path for running tests

----------------------------------------------------------------------
Modified Files:
	boost/config/compiler/metrowerks.hpp
	libs/python/src/gen_function.py libs/regex/test/Jamfile
 Tag: thread-initial
	libs/thread/src/condition.cpp
 No tag
	tools/build/boost-base.jam tools/build/borland-tools.jam
	tools/build/metrowerks-tools.jam
----------------------------------------------------------------------


[SVN r11853]
---
 src/gen_function.py | 106 ++++++++++++++++++++++++++++++++------------
 1 file changed, 78 insertions(+), 28 deletions(-)

diff --git a/src/gen_function.py b/src/gen_function.py
index bebbc818..ac24ac18 100644
--- a/src/gen_function.py
+++ b/src/gen_function.py
@@ -12,15 +12,31 @@ def _find(s, sub, start=0, end=None):
     else:
         return pos
 
-def _gen_common_key(key, n, args):
+def _raise_no_argument(key, n, args):
+    raise IndexError(str(key) + " extra arg(s) not passed to gen_function")
+    
+def _gen_common_key(key, n, args, fill = _raise_no_argument):
+    # import sys
+    # print >> sys.stderr, "_gen_common_key(", repr(key), ",", repr(n), ',', repr(args), ',', fill, ')'
+    # sys.stderr.flush()
     if len(key) > 0 and key in '123456789':
-        return str(args[int(key) - 1])
-    elif key == 'x':
-        return str(n)
+        index = int(key) - 1;
+        
+        if index >= len(args):
+            return fill(key, n, args)
+
+        arg = args[index]
+        if callable(arg):
+            return str(arg(key, n, args))
+        else:
+            return str(arg)
+    elif key in ('x','n','-','+'):
+        return str(n + {'-':-1,'+':+1,'x':0,'n':0}[key])
     else:
         return key
 
-def _gen_arg(template, n, args, delimiter = '%'):
+def _gen_arg(template, n, args, delimiter = '%', fill = _raise_no_argument):
+    
     result = ''
     i = 0
     while i < len(template): # until the template is consumed
@@ -33,13 +49,13 @@ def _gen_arg(template, n, args, delimiter = '%'):
         key = template[start - 1 : start] # the key character. If there were no
                                           # delimiters left, key will be empty
 
-        if key == 'n':
+        if 0 and key == 'n':
             result = result + `n`
-        else:
-            result = result + _gen_common_key(key, n, args)
+        else: 
+            result = result + _gen_common_key(key, n, args, fill)
 
         i = start
-        
+
     return result
 
 def gen_function(template, n, *args, **keywords):
@@ -52,19 +68,46 @@ def gen_function(template, n, *args, **keywords):
     
     Sections of the template between '%{', '%}' pairs are ommitted if n == 0.
     
-    %n is transformed into the string representation of 1..n for each repetition
-    of n.
+    %n is transformed into the string representation of 1..n for each
+    repetition within %(...%). Elsewhere, %n is transformed into the
+    string representation of n
+
+    %- is transformed into the string representation of 0..n-1 for
+    each repetition within %(...%). Elsewhere, %- is transformed into the
+    string representation of n-1.
+
+    %+ is transformed into the string representation of 2..n+1 for
+    each repetition within %(...%). Elsewhere, %- is transformed into the
+    string representation of n+1.
+
+    %x is always transformed into the string representation of n
+
+    %z, where z is a digit, selects the corresponding additional
+    argument. If that argument is callable, it is called with three
+    arguments:
+        key  - the string representation of 'z'
+        n    - the iteration number
+        args - a tuple consisting of all the additional arguments to
+               this function
+    otherwise, the selected argument is converted to a string representation
 
-    %x, where x is a digit, is transformed into the corresponding additional
-    argument.
 
     for example,
     
-    >>> gen_function('%1 abc(%(int a%n%:, %));%{ // all args are ints%}', 2, 'void')
-    'void abc(int a1, int a2); // all args are ints'
+    >>> gen_function('%1 abc%x(%(int a%n%:, %));%{ // all args are ints%}', 2, 'void')
+    'void abc2(int a1, int a2); // all args are ints'
+    
     >>> gen_function('%1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, 'x')
     'x abc();'
         
+    >>> gen_function('%1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, lambda key, n, args: 'abcd'[n])
+    'a abc();'
+        
+    >>> gen_function('%2 %1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, 'x', fill = lambda key, n, args: 'const')
+    'const x abc();'
+
+    >>> gen_function('abc%[k%:v%]', 0, fill = lambda key, n, args, value = None: '<' + key + ',' + value + '>')
+    'abc<k,v>'
 
     >>> template = '''    template <class T%(, class A%n%)>
     ...     static PyObject* call( %1(T::*pmf)(%(A%n%:, %))%2, PyObject* args, PyObject* /* keywords */ ) {
@@ -123,6 +166,7 @@ def gen_function(template, n, *args, **keywords):
         }
 """
     delimiter = keywords.get('delimiter', '%')
+    fill = keywords.get('fill', _raise_no_argument);
     result = ''
     i = 0
     while i < len(template): # until the template is consumed
@@ -135,7 +179,7 @@ def gen_function(template, n, *args, **keywords):
         key = template[start - 1 : start] # the key character. If there were no
                                           # delimiters left, key will be empty
 
-        pairs = { '(':')', '{':'}' }
+        pairs = { '(':')', '{':'}', '[':']' }
         
         if key in pairs.keys():
             end = string.find(template, delimiter + pairs[key], start)
@@ -146,23 +190,27 @@ def gen_function(template, n, *args, **keywords):
                 if n > 0:
                     result = result + gen_function(template[start:end], n, args, delimiter)
             else:
-                separator_pos = _find(template, delimiter + ':', start, end)
-                separator = template[separator_pos+2 : end]
-
-                for x in range(1, n + 1):
-                    result = result + _gen_arg(template[start:separator_pos], x, args,
-                                               delimiter)
-                    if x != n:
-                        result = result + separator
+                separator_pos = _find(template, delimiter + ':',
+                                      start, end)
+                remainder = template[separator_pos+2 : end]
+                
+                if key == '(':
+                    for x in range(1, n + 1):
+                        result = result + _gen_arg(template[start:separator_pos], x, args,
+                                                   delimiter)
+                        if x != n:
+                            result = result + remainder
+                else:
+                    result = result + fill(template[start:separator_pos], n, args, value = remainder)
                 
         else:
-            result = result + _gen_common_key(key, n, args)
+            result = result + _gen_common_key(key, n, args, fill)
             
         i = delimiter_pos + 2
         
     return result
 
-def gen_functions(template, n, *args):
+def gen_functions(template, n, *args, **keywords):
     r"""gen_functions(template, n, [args...]) -> string
 
     Call gen_function repeatedly with from 0..n and the given optional
@@ -174,11 +222,13 @@ def gen_functions(template, n, *args):
     void abc(int a1, int a2); // all args are ints
     
     """
+    fill = keywords.get('fill', _raise_no_argument);
     result = ''
     for x in range(n + 1):
-        result = result + apply(gen_function, (template, x) + args)
+        result = result + apply(gen_function, (template, x) + args, keywords)
     return result
 
 if __name__ == '__main__':
     import doctest
-    doctest.testmod()
+    import sys
+    doctest.testmod(sys.modules.get(__name__))

From ccfd4acbda8bbe980ff24c52608bd6ff7e8234a9 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 13 Dec 2001 18:17:38 +0000
Subject: [PATCH 156/369] factored out python.jam

[SVN r12041]
---
 build/Jamfile | 220 +++++---------------------------------------------
 1 file changed, 22 insertions(+), 198 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index 05efd4a1..c56bf47c 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -54,52 +54,18 @@
 # PYTHON_VECT_ITERATIONS - specifies the number of test iterations to use for
 #                          the dvect and ivect tests above.
 
-
 # declare the location of this subproject relative to the root
 subproject libs/python/build ;
 
-# grab variables from command-line or environment.
-local PYTHON_VERSION = $(PYTHON_VERSION) ;
-local PYTHON_ROOT = $(PYTHON_ROOT) ;
-local PYTHON_INCLUDES = $(PYTHON_INCLUDES) ;
-local PYTHON_LIBS = $(PYTHON_LIBS) ;
-local PYTHON_LIB_PATH = $(PYTHON_LIB_PATH) ;
-local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) ;
+# bring in the rules for python
+SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
+include <module@>python.jam ;
 
-# Do some OS-specific setup
-if $(NT)
+#######################
+local rule bpl-test ( test-name : sources + )
 {
-    PYTHON_VERSION ?= 2.1 ;
-    PYTHON_ROOT ?= c:/tools/python ;
-    PYTHON_INCLUDES ?= <include>$(PYTHON_ROOT)/include <gcc><*><include>/usr/include/python$(PYTHON_VERSION) ;
-    PYTHON_LIBS ?= c:/cygnus/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).dll.a ;
-    PYTHON_LIB_PATH ?= $(PYTHON_ROOT)/libs ;
-
-    # common properties required for compiling any Python module.
-    PYTHON_PROPERTIES ?=
-        <gcc><*><define>SIZEOF_LONG=4
-        <gcc><*><define>USE_DL_IMPORT
-        <debug><define>_DEBUG
-        <runtime-link>dynamic
-        ;
-                        
+    boost-python-test $(test-name) : $(sources) <lib>libboost_python ;
 }
-else if $(UNIX)
-{
-    PYTHON_VERSION ?= 1.5 ;
-    PYTHON_INCLUDES ?= <include>/usr/include/python$(PYTHON_VERSION) ;
-    PYTHON_LIBS ?= /usr/lib/python$(PYTHON_VERSION)/config/libpython$(PYTHON_VERSION).a ;
-}
-
-local PYTHON_VERSION_NODOT
-        = [ SUBST $(PYTHON_VERSION) ([0-9]*)\.([0-9]*) $1$2 ]
-      ;
-
-# how do we invoke python?
-local PYTHON = $(PYTHON) ;
-PYTHON ?= python ;
-PYTHON = [ FAppendSuffix $(PYTHON:G=<executable-grist>) : $(SUFEXE) ] ;
-SEARCH on $(PYTHON) = $(PATH) ;
 
 #######################
 
@@ -107,9 +73,6 @@ SEARCH on $(PYTHON) = $(PATH) ;
 # Declare the boost python static link library
 #
 
-# standard include requirements for anything using Boost.Python
-local BOOST_PYTHON_INCLUDES = <include>$(BOOST_ROOT) $(PYTHON_INCLUDES) ;
-
 # Base names of the source files for libboost_python
 local CPP_SOURCES =
     types classes conversions extension_class functions 
@@ -121,162 +84,23 @@ lib libboost_python : ../src/$(CPP_SOURCES).cpp
     <shared-linkable>true
     $(PYTHON_PROPERTIES) ;
 
-lib libboost_python_d : ../src/$(CPP_SOURCES).cpp
-    # requirements
-    : $(BOOST_PYTHON_INCLUDES)
-    <shared-linkable>true
-    $(PYTHON_PROPERTIES)
-    <define>BOOST_DEBUG_PYTHON
-    ;
     
-#######################
-
-# boost-python name : sources : requirements : default-BUILD
-#
-# Declare a boost python module. Return a list of the DLL files generated.
-rule boost-python
-{
-    local debug = "" ;
-    if ( <define>BOOST_DEBUG_PYTHON in $(3) ) || ( debug-python in $(BUILD) )
-    {
-        debug = _d ;
-    }
-    
-    # declare a DLL; add the boost python library to sources
-    dll $(<) : <lib>libboost_python$(debug) $(>)
-            
-            # Requirements
-            : $(3) # caller-specified requirements
-            
-                # standard requirements
-                $(BOOST_PYTHON_INCLUDES)
-                <msvc><*><library-path>$(PYTHON_LIB_PATH)
-                <intel-win32><*><library-path>$(PYTHON_LIB_PATH)
-                <metrowerks><*><library-file>$(PYTHON_LIB_PATH)/python$(PYTHON_VERSION_NODOT)$(debug).lib
-                <gcc><*><library-file>$(PYTHON_LIBS)
-                $(PYTHON_PROPERTIES)
-                
-        : $(4) ;                      # pass on the default-BUILD, if any
-}
-
-# boost-python-test name : sources : requirements : default-BUILD
-#
-# Just like boost-python, but the result becomes part of the test pseudotarget
-# instead of being built by 'all'
-rule boost-python-test
-{
-    type-DEPENDS test : $(<) ;
-    type-DEPENDS test_d : $(<)_d ;
-    NOTFILE test_d ;
-    
-    local gSUPPRESS_FAKE_TARGETS = true ;
-    boost-python $(1) : $(2) : $(3) : $(4) ;
-    boost-python $(1)_d : $(2) : $(3) <define>BOOST_DEBUG_PYTHON : $(4) ;
-}
-
-#######################
-
-# boost-python-runtest target : python-script sources : requirements : local-build : args
-#
-# declare two python module tests: $(<).test which builds when out-of-date, and
-# $(<).run which builds unconditionally.
-rule boost-python-runtest
-{
-    # tell Jam that the python script is relative to this directory
-    SEARCH on $(>[1]) = $(SEARCH_SOURCE) ;
-    
-    # required command-line args can be specified in argument 5
-    # The user can add additional arguments in PYTHON_TEST_ARGS.
-    local gPYTHON_TEST_ARGS = $(5) $(PYTHON_TEST_ARGS) ;
-
-    # declare the two subsidiary tests.
-    declare-local-target $(<:S=.test) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_TEST ;
-    declare-local-target $(<:S=.run) : $(>) : $(PYTHON_PROPERTIES) : $(4) : PYTHON_RUNTEST ;
-}
-
-# special rules for two new target types: PYTHON_TEST and PYTHON_RUNTEST.
-# These are identical except that PYTHON_TEST runs the test when out-of-date, and
-# PYTHON_RUNTEST runs the test unconditionally. These are used by boost-python-runtest.
-SUFPYTHON_TEST = .test ;
-gGENERATOR_FUNCTION(PYTHON_TEST) = python-test-target ;
-rule python-test-target # test-target : sources : 
-{
-    python-runtest-aux $(<) : $(>) ;
-    Clean clean : $(<) ; # remove the test-target as part of any clean operation
-    local debug = [ SUBST $(<:B) (_d)$ $1 ] ;
-    debug ?= "" ;
-    type-DEPENDS test$(debug) : $(<) ;
-    MakeLocate $(<) : $(LOCATE_TARGET) ;
-}
-actions python-test-target bind PYTHON
-{
-    $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
-    $(SHELL_EXPORT)PYTHONPATH
-    $(PYTHON) "$(>)" $(ARGS) > "$(<)"
-}
-
-SUFPYTHON_RUNTEST = .run ;
-gGENERATOR_FUNCTION(PYTHON_RUNTEST) = python-runtest-target ;
-rule python-runtest-target # test-target : sources : 
-{
-    python-runtest-aux $(<) : $(>) ;
-    NOTFILE $(<) ;
-    ALWAYS $(<) ;
-}
-actions python-runtest-target bind PYTHON
-{
-    $(SHELL_SET)PYTHONPATH=$(PYTHONPATH)
-    $(SHELL_EXPORT)PYTHONPATH
-    $(PYTHON) "$(>)" $(ARGS)
-}
-
-rule python-runtest-aux # target : sources
-{
-    DEPENDS $(<) : $(>) ;
-
-    ARGS on $(<) += $(gPYTHON_TEST_ARGS) ;
-    
-    # Some tests need an extra command-line arg if built with
-    # msvc. Checking the target grist is a cheap way to
-    # find out. 
-    switch $(<)
-    {
-        case <*\\\\msvc\\\\*>* : ARGS on $(<) += --broken-auto-ptr ;
-        case <*\\\\intel-win32\\\\*>* : ARGS on $(<) += --broken-auto-ptr ;
-    }
-
-    # compute the PYTHONPATH environment variable that will allow the test to
-    # find all of the modules on which it depends.
-    PYTHONPATH on $(<) = [ join
-        $(gLOCATE($(>[1])))                     # location of python test file
-        $(gRUN_PATH($(<)))                      # location of module dependencies
-        [ join-path $(TOP) libs python test ]   # location of doctest
-        $(>:D)                                  # directory of python driver file(s)
-        $(PYTHONPATH)                           # base PYTHONPATH from environment
-        : $(SPLITPATH) ] ;                      # platform path separator
-
-    PYTHON on $(<) = $(PYTHON) ;
-    DEPENDS $(<) : $(PYTHON) ;
-}
-
 ############# comprehensive module and test ###########
-boost-python-test boost_python_test : ../test/comprehensive.cpp ;
+bpl-test boost_python_test
+      : ../test/comprehensive.cpp ;
 
 boost-python-runtest comprehensive
-         : [ join-path $(DOTDOT) test comprehensive.py ]
-           <lib>boost_python_test ;
-
-boost-python-runtest comprehensive_d
-         : [ join-path $(DOTDOT) test comprehensive.py ]
-           <lib>boost_python_test_d ;
+         : ../test/comprehensive.py <lib>boost_python_test <lib>libboost_python ;
 
 ############# simple tests from ../example ############
 
-rule boost-python-example-runtest
+local rule boost-python-example-runtest ( name )
 {
-    boost-python-test $(<) : ../example/$(<).cpp ;
-    boost-python-runtest $(<) : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<) ;
-    boost-python-runtest $(<)_d : [ join-path $(DOTDOT) example test_$(<).py ] <lib>$(<)_d ;
+    bpl-test $(name)
+      : ../example/$(name).cpp ;
+    
+    boost-python-runtest $(name)
+      : ../example/test_$(name).py <lib>$(name) ;
 }
 
 
@@ -290,18 +114,18 @@ boost-python-example-runtest pickle2 ;
 boost-python-example-runtest pickle3 ;
 
 
-boost-python-test ivect : ../example/ivect.cpp ;
-boost-python-test dvect : ../example/dvect.cpp ;
-boost-python-test noncopyable_export : ../example/noncopyable_export.cpp ;
-boost-python-test noncopyable_import : ../example/noncopyable_import.cpp ;
+bpl-test ivect : ../example/ivect.cpp ;
+bpl-test dvect : ../example/dvect.cpp ;
+bpl-test noncopyable_export : ../example/noncopyable_export.cpp ;
+bpl-test noncopyable_import : ../example/noncopyable_import.cpp ;
 
 ############## cross-module tests from ../example ##########
 
 # A simple rule to build a test which depends on multiple modules in the PYTHONPATH
-rule boost-python-multi-example-runtest # test-name : python-file libs
+local rule boost-python-multi-example-runtest ( test-name : modules + )
 {
-    boost-python-runtest $(<)
-        : ../example/tst_$(<).py <lib>$(>)
+    boost-python-runtest $(test-name)
+        : ../example/tst_$(test-name).py <lib>$(modules) <lib>libboost_python
         : : : $(PYTHON_VECT_ITERATIONS) ;
 }
 

From d05cc7ccec6ceb8cf3153de04fa789e4d0e5b2f4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 13 Dec 2001 18:18:52 +0000
Subject: [PATCH 157/369] integrating scott snyder's changes

[SVN r12042]
---
 doc/special.html | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/doc/special.html b/doc/special.html
index 46ca0791..a72ec671 100644
--- a/doc/special.html
+++ b/doc/special.html
@@ -287,6 +287,35 @@ bignum_class.def(&amp;rmod,  "__rmod__");
         found first (be it ``<code>int</code>`` or ``<code>float</code>'') will be
         used for either of the two types.
 
+<h3><a name="inplace">Inplace Operators</a></h3>
+<p>
+        Boost.Python can also be used to expose inplace numeric operations
+        (i.e., <code>+=</code> and so forth).  These operators must be wrapped
+        manually, as described in the previous section.  For example, suppose
+        the class BigNum has an <code>operator+=</code>:
+
+<blockquote><pre>
+BigNum& operator+= (BigNum const&amp; right);
+</pre></blockquote>
+
+      This can be exposed by first writing a wrapper function:
+
+<blockquote><pre>
+BigNum& iadd (BigNum&amp; self, const BigNum&amp; right)
+{
+  return self += right;
+}
+</pre></blockquote>
+
+      and then exposing the wrapper with
+
+<blockquote><pre>
+bignum_class.def(&amp;iadd, "__iadd__");
+</pre></blockquote>
+
+
+
+
 <h3><a name="coercion">Coercion</a></h3>
 
 

From 2f6e3cc09d5b588ecbca99879260c63d36eb2042 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 13 Dec 2001 18:22:03 +0000
Subject: [PATCH 158/369] Integrating scott snyder's inplace operator
 improvements

[SVN r12043]
---
 src/types.cpp          | 149 ++++++++++++++++++++++++++++++++++++++++-
 test/comprehensive.cpp |  48 ++++++++++++-
 2 files changed, 194 insertions(+), 3 deletions(-)

diff --git a/src/types.cpp b/src/types.cpp
index 3367dba8..fe108225 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -455,6 +455,61 @@ static PyObject* do_instance_nb_hex(PyObject* obj)
     return call(obj, &type_object_base::instance_number_hex);
 }
 
+static PyObject* do_instance_nb_inplace_add(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_add, other);
+}
+
+static PyObject* do_instance_nb_inplace_subtract(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_subtract, other);
+}
+
+static PyObject* do_instance_nb_inplace_multiply(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_multiply, other);
+}
+
+static PyObject* do_instance_nb_inplace_divide(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_divide, other);
+}
+
+static PyObject* do_instance_nb_inplace_remainder(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_remainder, other);
+}
+
+static PyObject* do_instance_nb_inplace_power(PyObject* obj, PyObject* exponent, PyObject* modulus)
+{
+    return call(obj, &type_object_base::instance_number_inplace_power, exponent, modulus);
+}
+
+static PyObject* do_instance_nb_inplace_lshift(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_lshift, other);
+}
+
+static PyObject* do_instance_nb_inplace_rshift(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_rshift, other);
+}
+
+static PyObject* do_instance_nb_inplace_and(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_and, other);
+}
+
+static PyObject* do_instance_nb_inplace_or(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_or, other);
+}
+
+static PyObject* do_instance_nb_inplace_xor(PyObject* obj, PyObject* other)
+{
+    return call(obj, &type_object_base::instance_number_inplace_xor, other);
+}
+
 } // extern "C"
 
 namespace
@@ -511,6 +566,41 @@ bool add_capability_richcompare(type_object_base::capability capability, PyTypeO
     return false;
 }
 
+#if PYTHON_API_VERSION >= 1010
+# define ENABLE_INPLACE_CAPABILITY1 \
+        dest->tp_flags |= Py_TPFLAGS_HAVE_INPLACEOPS;
+#else
+# define ENABLE_INPLACE_CAPABILITY1
+#endif
+#define ENABLE_INPLACE_CAPABILITY(field) \
+    case type_object_base::number_##field: \
+        create_method_table_if_null(dest->tp_as_number); \
+        dest->tp_as_number->nb_##field = &do_instance_nb_##field; \
+        detail::shared_pod_manager::replace_if_equal(dest->tp_as_number); \
+        ENABLE_INPLACE_CAPABILITY1 \
+        return true
+
+bool add_capability_inplace(type_object_base::capability capability, PyTypeObject* dest)
+{
+    assert(dest != 0);
+    switch (capability)
+    {
+        ENABLE_INPLACE_CAPABILITY (inplace_add);
+        ENABLE_INPLACE_CAPABILITY (inplace_subtract);
+        ENABLE_INPLACE_CAPABILITY (inplace_multiply);
+        ENABLE_INPLACE_CAPABILITY (inplace_divide);
+        ENABLE_INPLACE_CAPABILITY (inplace_remainder);
+        ENABLE_INPLACE_CAPABILITY (inplace_power);
+        ENABLE_INPLACE_CAPABILITY (inplace_lshift);
+        ENABLE_INPLACE_CAPABILITY (inplace_rshift);
+        ENABLE_INPLACE_CAPABILITY (inplace_and);
+        ENABLE_INPLACE_CAPABILITY (inplace_or);
+        ENABLE_INPLACE_CAPABILITY (inplace_xor);
+        default:
+            return false;
+    }
+}
+
 #define ENABLE_MAPPING_CAPABILITY(field) \
     case type_object_base::mapping_##field: \
         create_method_table_if_null(dest); \
@@ -626,6 +716,8 @@ namespace detail  {
         return;
     if(add_capability_richcompare(capability, dest_))
         return;
+    if(add_capability_inplace(capability, dest_))
+        return;
     if(add_capability_mapping(capability, dest_->tp_as_mapping))
         return;
     if(add_capability_sequence(capability, dest_->tp_as_sequence))
@@ -970,7 +1062,7 @@ PyObject* type_object_base::instance_number_divmod(PyObject*, PyObject*) const
 
 PyObject* type_object_base::instance_number_power(PyObject*, PyObject*, PyObject*) const
 {
-    return unimplemented("instance_number_divmod");
+    return unimplemented("instance_number_power");
 }
 
 PyObject* type_object_base::instance_number_negative(PyObject*) const
@@ -1053,6 +1145,61 @@ PyObject* type_object_base::instance_number_hex(PyObject*) const
     return unimplemented("instance_number_hex");
 }
 
+PyObject* type_object_base::instance_number_inplace_add(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_add");
+}
+
+PyObject* type_object_base::instance_number_inplace_subtract(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_subtract");
+}
+
+PyObject* type_object_base::instance_number_inplace_multiply(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_multiply");
+}
+
+PyObject* type_object_base::instance_number_inplace_divide(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_divide");
+}
+
+PyObject* type_object_base::instance_number_inplace_remainder(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_remainder");
+}
+
+PyObject* type_object_base::instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_power");
+}
+
+PyObject* type_object_base::instance_number_inplace_lshift(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_lshift");
+}
+
+PyObject* type_object_base::instance_number_inplace_rshift(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_rshift");
+}
+
+PyObject* type_object_base::instance_number_inplace_and(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_and");
+}
+
+PyObject* type_object_base::instance_number_inplace_or(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_or");
+}
+
+PyObject* type_object_base::instance_number_inplace_xor(PyObject*, PyObject*) const
+{
+    return unimplemented("instance_number_inplace_xor");
+}
+
 PyObject* type_object_base::instance_lt(PyObject*, PyObject*) const
 {
     return unimplemented("instance_lt");
diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 7cd7e0ce..61f56407 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -667,7 +667,7 @@ int total_Ints = 0;
 
 struct Int
 {
-    explicit Int(int i) : i_(i) {
+    explicit Int(int i) : i_(i), j_(0) {
 #ifndef NDEBUG
         ++total_Ints;
 #endif
@@ -675,12 +675,29 @@ struct Int
     
 #ifndef NDEBUG
     ~Int() { --total_Ints; }
-    Int(const Int& rhs) : i_(rhs.i_) { ++total_Ints; }
+    Int(const Int& rhs) : i_(rhs.i_), j_(rhs.j_) { ++total_Ints; }
 #endif
     
     int i() const { return i_; }
+    int j() const { return j_; }
     
     int i_;
+    int j_;
+
+    Int& operator +=(Int const& r) { ++j_; i_ += r.i_; return *this; }
+    Int& operator -=(Int const& r) { ++j_; i_ -= r.i_; return *this; }
+    Int& operator *=(Int const& r) { ++j_; i_ *= r.i_; return *this; }
+    Int& operator /=(Int const& r) { ++j_; i_ /= r.i_; return *this; }
+    Int& operator %=(Int const& r) { ++j_; i_ %= r.i_; return *this; }
+    Int& ipow (Int const& r) { ++j_; 
+                               int o=i_;
+                               for (int k=1; k<r.i_; k++) i_ *= o;
+                               return *this; }
+    Int& operator <<=(Int const& r) { ++j_; i_ <<= r.i_; return *this; }
+    Int& operator >>=(Int const& r) { ++j_; i_ >>= r.i_; return *this; }
+    Int& operator &=(Int const& r) { ++j_; i_ &= r.i_; return *this; }
+    Int& operator |=(Int const& r) { ++j_; i_ |= r.i_; return *this; }
+    Int& operator ^=(Int const& r) { ++j_; i_ ^= r.i_; return *this; }
 };
 
 Int operator+(Int const & l, Int const & r) { return Int(l.i_ + r.i_); }
@@ -868,6 +885,19 @@ namespace bpl_test {
   double freal(const std::complex<float>& c) { return c.real(); }
   double fimag(std::complex<float> c) { return c.imag(); }
 
+  // Wrappers for inplace operators.
+  Int& int_iadd(Int& self, const Int& r) { self += r; return self; }
+  Int& int_isub(Int& self, const Int& r) { self -= r; return self; }
+  Int& int_imul(Int& self, const Int& r) { self *= r; return self; }
+  Int& int_idiv(Int& self, const Int& r) { self /= r; return self; }
+  Int& int_imod(Int& self, const Int& r) { self %= r; return self; }
+  Int& int_ipow(Int& self, const Int& r) { self.ipow (r); return self; }
+  Int& int_ilshift(Int& self, const Int& r) { self <<= r; return self; }
+  Int& int_irshift(Int& self, const Int& r) { self >>= r; return self; }
+  Int& int_iand(Int& self, const Int& r) { self &= r; return self; }
+  Int& int_ior(Int& self, const Int& r) { self |= r; return self; }
+  Int& int_ixor(Int& self, const Int& r) { self ^= r; return self; }
+
 /************************************************************/
 /*                                                          */
 /*                       init the module                    */
@@ -1042,6 +1072,7 @@ void init_module(boost::python::module_builder& m)
     boost::python::class_builder<Int> int_class(m, "Int");
     int_class.def(boost::python::constructor<int>());
     int_class.def(&Int::i, "i");
+    int_class.def(&Int::j, "j");
 
     // wrap homogeneous operators
     int_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub | boost::python::op_neg | 
@@ -1061,6 +1092,19 @@ void init_module(boost::python::module_builder& m)
                   boost::python::left_operand<int const & >());
     // export non-operator function as heterogeneous reverse-argument operator
     int_class.def(&rmul, "__rmul__");
+
+    // inplace operators.
+    int_class.def(&int_iadd, "__iadd__");
+    int_class.def(&int_isub, "__isub__");
+    int_class.def(&int_imul, "__imul__");
+    int_class.def(&int_idiv, "__idiv__");
+    int_class.def(&int_imod, "__imod__");
+    int_class.def(&int_ipow, "__ipow__");
+    int_class.def(&int_ilshift, "__ilshift__");
+    int_class.def(&int_irshift, "__irshift__");
+    int_class.def(&int_iand, "__iand__");
+    int_class.def(&int_ior, "__ior__");
+    int_class.def(&int_ixor, "__ixor__");
     
 
     boost::python::class_builder<EnumOwner> enum_owner(m, "EnumOwner");

From 160451b210d12071f378d8c0e13c2297dcb3ca19 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 13 Dec 2001 18:23:10 +0000
Subject: [PATCH 159/369] Integrating scott snyder's inplace operator
 improvements Fixed Python 2.2 incompatibility

[SVN r12044]
---
 test/comprehensive.py | 64 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 56 insertions(+), 8 deletions(-)

diff --git a/test/comprehensive.py b/test/comprehensive.py
index 2ac0704a..b4ae5679 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -318,26 +318,37 @@ Special member attributes. Tests courtesy of Barry Scott <barry@scottb.demon.co.
     ...         'Docs for DerivedFromBase.fred'
     ...         pass
 
-    >>> df = DerivedFromFoo()
-    >>> dir(df)
-    []
     >>> dir(DerivedFromFoo)
     ['__del__', '__doc__', '__init__', '__module__', 'fred']
+    
+    >>> df = DerivedFromFoo()
     >>> df.__dict__
     {}
-
     >>> df.fred.__doc__
     'Docs for DerivedFromFoo.fred'
+    
     >>> db = DerivedFromBase()
-    >>> dir(db)
-    []
-    >>> dir(DerivedFromBase)
-    ['__doc__', '__module__', 'fred', 'i_am_derived_from_base']
     >>> db.__dict__
     {}
     >>> db.fred.__doc__
     'Docs for DerivedFromBase.fred'
 
+    >>> import sys
+    >>> if sys.version_info[0] < 2 or ( sys.version_info[0] == 2 and
+    ...                                 sys.version_info[1] < 2 ):
+    ...     assert dir(df) == []
+    ...     assert dir(db) == []
+    ...     assert dir(DerivedFromBase) == [
+    ...             '__doc__', '__module__', 'fred', 'i_am_derived_from_base']
+    ... else:
+    ...     assert dir(df) == [
+    ...         '__del__', '__doc__', '__init__', '__module__', 'add_len',
+    ...         'call_add_len', 'call_pure', 'fred', 'mumble', 'set']
+    ...     assert dir(db) == ['__doc__', '__module__', 'fred'
+    ...                       , 'i_am_base', 'i_am_derived_from_base']
+    ...     assert dir(DerivedFromBase) == [
+    ...          '__doc__', '__module__', 'fred', 'i_am_base', 'i_am_derived_from_base']
+    
 Special member functions in action
     >>> del df
     Deleting DerivedFromFoo
@@ -1058,6 +1069,43 @@ test inheritB2
     Traceback (innermost last):
     TypeError: bad operand type(s) for pow()
 
+    >>> ii = Int(1)
+    >>> ii += Int(2)
+    >>> ii.i()
+    3
+    >>> ii -= Int(1)
+    >>> ii.i()
+    2
+    >>> ii *= Int(3)
+    >>> ii.i()
+    6
+    >>> ii /= Int(2)
+    >>> ii.i()
+    3
+    >>> ii <<= Int(2)
+    >>> ii.i()
+    12
+    >>> ii >>= Int(1)
+    >>> ii.i()
+    6
+    >>> ii &= Int(5)
+    >>> ii.i()
+    4
+    >>> ii |= Int(9)
+    >>> ii.i()
+    13
+    >>> ii ^= Int(7)
+    >>> ii.i()
+    10
+    >>> ii %= Int(4)
+    >>> ii.i()
+    2
+    >>> ii **= Int(3)
+    >>> ii.i()
+    8
+    >>> ii.j()
+    11
+
 Test operator export to a subclass
 
     # force method table sharing

From a365fa610936a312fdc9602c01afefb5f12cbb59 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 13 Dec 2001 19:43:35 +0000
Subject: [PATCH 160/369] many fixes

[SVN r12054]
---
 include/boost/python/classes.hpp            |  91 +++++++++++
 include/boost/python/detail/types.hpp       |  18 ++-
 include/boost/python/detail/wrap_python.hpp |  20 ++-
 src/classes.cpp                             |  69 ++++++++
 src/gen_arg_tuple_size.py                   | 132 +++++++++++++++
 src/gen_function.py                         | 171 ++++++++++----------
 6 files changed, 414 insertions(+), 87 deletions(-)
 create mode 100644 src/gen_arg_tuple_size.py

diff --git a/include/boost/python/classes.hpp b/include/boost/python/classes.hpp
index 2d69e81e..f88f1000 100644
--- a/include/boost/python/classes.hpp
+++ b/include/boost/python/classes.hpp
@@ -78,6 +78,19 @@ class instance
     PyObject* gt(PyObject* other);
     PyObject* ge(PyObject* other);
 
+    // Inplace operations.
+    PyObject* inplace_add(PyObject* other);
+    PyObject* inplace_subtract(PyObject* other);
+    PyObject* inplace_multiply(PyObject* other);
+    PyObject* inplace_divide(PyObject* other);
+    PyObject* inplace_remainder(PyObject* other);
+    PyObject* inplace_power(PyObject* exponent, PyObject* modulus);
+    PyObject* inplace_lshift(PyObject* other);
+    PyObject* inplace_rshift(PyObject* other);
+    PyObject* inplace_and(PyObject* other);
+    PyObject* inplace_or(PyObject* other);
+    PyObject* inplace_xor(PyObject* other);
+
  private: // noncopyable, without the size bloat
     instance(const instance&);
     void operator=(const instance&);
@@ -178,6 +191,18 @@ class class_t
     PyObject* instance_number_oct(PyObject*) const;
     PyObject* instance_number_hex(PyObject*) const;
 
+    PyObject* instance_number_inplace_add(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_subtract(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_multiply(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_divide(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_remainder(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_lshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_rshift(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_and(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_or(PyObject*, PyObject*) const;
+    PyObject* instance_number_inplace_xor(PyObject*, PyObject*) const;
+
  private: // Implement rich comparisons
     PyObject* instance_lt(PyObject*, PyObject*) const;
     PyObject* instance_le(PyObject*, PyObject*) const;
@@ -493,6 +518,72 @@ PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
     return downcast<T>(obj)->hex();
 }
 
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_add(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_add(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_subtract(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_subtract(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_multiply(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_multiply(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_divide(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_divide(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_remainder(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_remainder(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
+{
+    return downcast<T>(obj)->inplace_power(exponent, modulus);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_lshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_lshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_rshift(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_rshift(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_and(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_and(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_or(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_or(other);
+}
+
+template <class T>
+PyObject* class_t<T>::instance_number_inplace_xor(PyObject* obj, PyObject* other) const
+{
+    return downcast<T>(obj)->inplace_xor(other);
+}
+
 template <class T>
 PyObject* class_t<T>::instance_lt(PyObject* obj, PyObject* other) const
 {
diff --git a/include/boost/python/detail/types.hpp b/include/boost/python/detail/types.hpp
index 2d0d0f6b..954e0213 100644
--- a/include/boost/python/detail/types.hpp
+++ b/include/boost/python/detail/types.hpp
@@ -57,7 +57,11 @@ class type_object_base : public python_type
         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
+        number_hex, number_inplace_add, number_inplace_subtract,
+        number_inplace_multiply, number_inplace_divide,
+        number_inplace_remainder, number_inplace_power,
+        number_inplace_lshift, number_inplace_rshift,
+        number_inplace_and, number_inplace_or, number_inplace_xor
     };
     
     void enable(capability);
@@ -116,6 +120,18 @@ class type_object_base : public python_type
     virtual PyObject* instance_number_oct(PyObject*) const;
     virtual PyObject* instance_number_hex(PyObject*) const;
 
+    virtual PyObject* instance_number_inplace_add(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_subtract(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_multiply(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_divide(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_remainder(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_power(PyObject*, PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_lshift(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_rshift(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_and(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_or(PyObject*, PyObject*) const;
+    virtual PyObject* instance_number_inplace_xor(PyObject*, PyObject*) const;
+
  public: // Callbacks for rich comparisons
     virtual PyObject* instance_lt(PyObject*, PyObject*) const;
     virtual PyObject* instance_le(PyObject*, PyObject*) const;
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index 373bbde4..1ad88ab6 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -35,12 +35,13 @@
 // than MSVC on Win32
 //
 #if defined(_WIN32)
-# ifdef __GNUC__
-
+# if defined(__GNUC__) && defined(__CYGWIN__)
+#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
 typedef int pid_t;
-#  define WORD_BIT 32
-#  define hypot _hypot
-#  include <stdio.h>
+#   define WORD_BIT 32
+#   define hypot _hypot
+#   include <stdio.h>
+#  endif 
 #  if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
 #   define HAVE_CLOCK
 #   define HAVE_STRFTIME
@@ -71,6 +72,13 @@ typedef int pid_t;
 #   define _MSC_VER 900
 #  endif
 
+#  include <pyconfig.h>
+#  undef hypot // undo the evil #define left by Python.
+
+# elif defined(__BORLANDC__)
+#  include <pyconfig.h>
+#  undef HAVE_HYPOT
+#  define HAVE_HYPOT 1
 # elif defined(_MSC_VER)
 #  include <limits> // prevents Python.h from defining LONGLONG_MAX, LONGLONG_MIN, and ULONGLONG_MAX
 # endif
@@ -95,4 +103,6 @@ typedef int pid_t;
 
 #ifdef __MWERKS__
 # pragma warn_possunwant off
+#elif _MSC_VER
+# pragma warning(disable:4786)
 #endif
diff --git a/src/classes.cpp b/src/classes.cpp
index a44c3c0a..75f8a01a 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -766,6 +766,64 @@ PyObject* instance::ge(PyObject* other)
     return callback<PyObject*>::call_method(this, "__ge__", other);
 }
 
+PyObject* instance::inplace_add(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__iadd__", other);
+}
+
+PyObject* instance::inplace_subtract(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__isub__", other);
+}
+
+PyObject* instance::inplace_multiply(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__imul__", other);
+}
+
+PyObject* instance::inplace_divide(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__idiv__", other);
+}
+
+PyObject* instance::inplace_remainder(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__imod__", other);
+}
+
+PyObject* instance::inplace_power(PyObject* exponent, PyObject* modulus)
+{
+    if (modulus == Py_None)
+        return callback<PyObject*>::call_method(this, "__ipow__", exponent);
+    else
+        return callback<PyObject*>::call_method(this, "__ipow__", exponent, modulus);
+}
+
+PyObject* instance::inplace_lshift(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ilshift__", other);
+}
+
+PyObject* instance::inplace_rshift(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__irshift__", other);
+}
+
+PyObject* instance::inplace_and(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__iand__", other);
+}
+
+PyObject* instance::inplace_or(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ior__", other);
+}
+
+PyObject* instance::inplace_xor(PyObject* other)
+{
+    return callback<PyObject*>::call_method(this, "__ixor__", other);
+}
+
 namespace {
   struct named_capability
   {
@@ -783,6 +841,17 @@ namespace {
       { "__le__", detail::type_object_base::richcompare },
       { "__eq__", detail::type_object_base::richcompare },
       { "__ne__", detail::type_object_base::richcompare },
+      { "__iadd__", detail::type_object_base::number_inplace_add },
+      { "__isub__", detail::type_object_base::number_inplace_subtract },
+      { "__imul__", detail::type_object_base::number_inplace_multiply },
+      { "__idiv__", detail::type_object_base::number_inplace_divide },
+      { "__imod__", detail::type_object_base::number_inplace_remainder },
+      { "__ipow__", detail::type_object_base::number_inplace_power },
+      { "__ilshift__", detail::type_object_base::number_inplace_lshift },
+      { "__irshift__", detail::type_object_base::number_inplace_rshift },
+      { "__iand__", detail::type_object_base::number_inplace_and },
+      { "__ixor__", detail::type_object_base::number_inplace_xor },
+      { "__ior__", detail::type_object_base::number_inplace_or },
       { "__repr__", detail::type_object_base::repr },
       { "__str__", detail::type_object_base::str },
       { "__call__", detail::type_object_base::call },
diff --git a/src/gen_arg_tuple_size.py b/src/gen_arg_tuple_size.py
new file mode 100644
index 00000000..68e379cb
--- /dev/null
+++ b/src/gen_arg_tuple_size.py
@@ -0,0 +1,132 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+#  This work was funded in part by Lawrence Berkeley National Labs
+
+from gen_function import *
+import string
+
+header = '''//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for %d-argument member functions and %d-argument free
+//  functions by gen_arg_tuple_size.python
+'''
+
+_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
+
+def gen_arg_tuple_size(member_function_args, free_function_args = None):
+    if free_function_args is None:
+        free_function_args = member_function_args + 1
+
+    return_none = ''';
+        return detail::none();'''
+    
+    return (header % (member_function_args, free_function_args)
+            + '''
+#ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
+# define ARG_TUPLE_SIZE_DWA20011201_HPP
+
+namespace boost { namespace python { namespace detail {
+
+// Computes (at compile-time) the number of elements that a Python
+// argument tuple must have in order to be passed to a wrapped C++
+// (member) function of the given type.
+template <class F> struct arg_tuple_size;
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
+
+'''
+            + gen_functions(
+'''template <class R%(, class A%+%)>
+struct arg_tuple_size<R (*)(%(A%+%:, %))>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = %n);
+};
+
+''', free_function_args)
+
+            + '\n'
+            + gen_functions(
+'''template <class R, class A0%(, class A%+%)>
+struct arg_tuple_size<R (A0::*)(%(A%+%:, %))%1>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = %+);
+};
+
+''', member_function_args, '')
+            +
+'''# else
+
+// We will use the "sizeof() trick" to work around the lack of
+// partial specialization in MSVC6 and its broken-ness in borland.
+// See http://opensource.adobe.com  or
+// http://groups.yahoo.com/group/boost/message/5441 for
+// more examples
+
+// This little package is used to transmit the number of arguments
+// from the helper functions below to the sizeof() expression below.
+// Because we can never have an array of fewer than 1 element, we
+// add 1 to n and then subtract 1 from the result of sizeof() below.
+template <int n>
+struct char_array
+{
+    char elements[n+1];
+};
+
+// The following helper functions are never actually called, since
+// they are only used within a sizeof() expression, but the type of
+// their return value is used to discriminate between various free
+// and member function pointers at compile-time.
+
+'''
+            + gen_functions(
+'''template <class R%(, class A%+%)>
+char_array<%n> arg_tuple_size_helper(R (*)(%(A%+%:, %)));
+
+''', free_function_args)
+            
+            + reduce(lambda x,y: x+'\n'+y
+                   , map(
+        lambda cv: gen_functions(
+'''template <class R, class A0%(, class A%+%)>
+char_array<%+> arg_tuple_size_helper(R (A0::*)(%(A%+%:, %))%1);
+
+''', member_function_args, cv)
+        , _cv_qualifiers))
+            + '''
+template <class F>
+struct arg_tuple_size
+{
+    // The sizeof() magic happens here
+    BOOST_STATIC_CONSTANT(std::size_t, value
+      = sizeof(arg_tuple_size_helper(F(0)).elements) - 1);
+};
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+}}} // namespace boost::python::detail
+
+#endif // ARG_TUPLE_SIZE_DWA20011201_HPP
+''')
+            
+if __name__ == '__main__':
+    import sys
+
+    if len(sys.argv) == 1:
+        member_function_args = 5
+        free_function_args = 6
+    else:
+        member_function_args = int(sys.argv[1])
+        if len(sys.argv) > 2:
+            free_function_args = int(sys.argv[2])
+        else:
+            free_function_args = member_function_args
+
+    print gen_arg_tuple_size(member_function_args, free_function_args)
+
+
diff --git a/src/gen_function.py b/src/gen_function.py
index ac24ac18..dba53c3b 100644
--- a/src/gen_function.py
+++ b/src/gen_function.py
@@ -1,3 +1,60 @@
+r"""
+>>> template = '''    template <class T%(, class A%+%)>
+...     static PyObject* call( %1(T::*pmf)(%(A%+%:, %))%2, PyObject* args, PyObject* ) {
+...         PyObject* self;
+... %(        PyObject* a%+;
+... %)        if (!PyArg_ParseTuple(args, const_cast<char*>("O%(O%)"), &self%(, &a%+%)))
+...             return 0;
+...         T& target = from_python(self, type<T&>());
+...         %3to_python((target.*pmf)(%(
+...                 from_python(a%+, type<A%+>())%:,%)
+...                 ));%4
+...     }'''
+
+>>> print gen_function(template, 0, 'R ', '', 'return ', '')
+    template <class T>
+    static PyObject* call( R (T::*pmf)(), PyObject* args, PyObject* ) {
+        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)(
+                ));
+    }
+
+>>> print gen_function(template, 2, 'R ', '', 'return ', '')    
+    template <class T, class A1, class A2>
+    static PyObject* call( R (T::*pmf)(A1, A2), PyObject* args, PyObject* ) {
+        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>())
+                ));
+    }
+
+>>> print gen_function(template, 3, 'void ', ' const', '', '\n'+8*' ' + 'return none();')
+    template <class T, class A1, class A2, class A3>
+    static PyObject* call( void (T::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* ) {
+        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&>());
+        to_python((target.*pmf)(
+                from_python(a1, type<A1>()),
+                from_python(a2, type<A2>()),
+                from_python(a3, type<A3>())
+                ));
+        return none();
+    }
+"""
 import string
 
 def _find(s, sub, start=0, end=None):
@@ -35,19 +92,19 @@ def _gen_common_key(key, n, args, fill = _raise_no_argument):
     else:
         return key
 
-def _gen_arg(template, n, args, delimiter = '%', fill = _raise_no_argument):
+def _gen_arg(template, n, args, fill = _raise_no_argument):
     
     result = ''
     i = 0
     while i < len(template): # until the template is consumed
-        # consume everything up to the first delimiter
-        delimiter_pos = _find(template, delimiter, i)
+        # consume everything up to the first '%'
+        delimiter_pos = _find(template, '%', i)
         result = result + template[i:delimiter_pos]
         
-        # The start position of whatever comes after the delimiter+key
+        # The start position of whatever comes after the '%'+key
         start = delimiter_pos + 2
         key = template[start - 1 : start] # the key character. If there were no
-                                          # delimiters left, key will be empty
+                                          # '%'s left, key will be empty
 
         if 0 and key == 'n':
             result = result + `n`
@@ -64,7 +121,7 @@ def gen_function(template, n, *args, **keywords):
     Generate a function declaration based on the given template.
     
     Sections of the template between '%(', '%)' pairs are repeated n times. If '%:'
-    appears in the middle, it denotes the beginning of a delimiter.
+    appears in the middle, it denotes the beginning of a '%'.
     
     Sections of the template between '%{', '%}' pairs are ommitted if n == 0.
     
@@ -95,7 +152,7 @@ def gen_function(template, n, *args, **keywords):
     for example,
     
     >>> gen_function('%1 abc%x(%(int a%n%:, %));%{ // all args are ints%}', 2, 'void')
-    'void abc2(int a1, int a2); // all args are ints'
+    'void abc2(int a0, int a1); // all args are ints'
     
     >>> gen_function('%1 abc(%(int a%n%:, %));%{ // all args are ints%}', 0, 'x')
     'x abc();'
@@ -109,102 +166,54 @@ def gen_function(template, n, *args, **keywords):
     >>> gen_function('abc%[k%:v%]', 0, fill = lambda key, n, args, value = None: '<' + key + ',' + value + '>')
     'abc<k,v>'
 
-    >>> template = '''    template <class T%(, class A%n%)>
-    ...     static PyObject* call( %1(T::*pmf)(%(A%n%:, %))%2, PyObject* args, PyObject* /* keywords */ ) {
-    ...         PyObject* self;
-    ... %(        PyObject* a%n;
-    ... %)        if (!PyArg_ParseTuple(args, const_cast<char*>("O%(O%)"), &self%(, &a%n%)))
-    ...             return 0;
-    ...         T& target = from_python(self, type<T&>());
-    ...         %3to_python((target.*pmf)(%(
-    ...                 from_python(a%n, type<A%n>())%:,%)
-    ...                 ));%4
-    ...     }'''
-    
-    >>> print gen_function(template, 0, 'R ', '', 'return ', '')
-        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)(
-                    ));
-        }
-    
-    >>> print gen_function(template, 2, 'R ', '', 'return ', '')    
-        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>())
-                    ));
-        }
-        
-    >>> print gen_function(template, 3, 'void ', ' const', '', '\n'+8*' ' + 'return 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&>());
-            to_python((target.*pmf)(
-                    from_python(a1, type<A1>()),
-                    from_python(a2, type<A2>()),
-                    from_python(a3, type<A3>())
-                    ));
-            return none();
-        }
 """
-    delimiter = keywords.get('delimiter', '%')
+    expand = (lambda s, n = n:
+              apply(gen_function, (s, n) + args, keywords))
+    
     fill = keywords.get('fill', _raise_no_argument);
     result = ''
     i = 0
     while i < len(template): # until the template is consumed
-        # consume everything up to the first delimiter
-        delimiter_pos = _find(template, delimiter, i)
+        # consume everything up to the first '%'
+        delimiter_pos = _find(template, '%', i)
         result = result + template[i:delimiter_pos]
         
-        # The start position of whatever comes after the delimiter+key            
+        # The start position of whatever comes after the '%'+key            
         start = delimiter_pos + 2
         key = template[start - 1 : start] # the key character. If there were no
-                                          # delimiters left, key will be empty
+                                          # '%'s left, key will be empty
 
         pairs = { '(':')', '{':'}', '[':']' }
         
         if key in pairs.keys():
-            end = string.find(template, delimiter + pairs[key], start)
-            assert end >= 0, "Matching '" + delimiter + pairs[key] +"' not found!"
+            end = string.find(template, '%' + pairs[key], start)
+            assert end >= 0, "Matching '" + '%' + pairs[key] +"' not found!"
             delimiter_pos = end
 
             if key == '{':
                 if n > 0:
-                    result = result + gen_function(template[start:end], n, args, delimiter)
+                    result = result + expand(template[start:end])
             else:
-                separator_pos = _find(template, delimiter + ':',
-                                      start, end)
+                separator_pos = _find(template, '%:', start, end)
                 remainder = template[separator_pos+2 : end]
                 
                 if key == '(':
-                    for x in range(1, n + 1):
-                        result = result + _gen_arg(template[start:separator_pos], x, args,
-                                                   delimiter)
-                        if x != n:
-                            result = result + remainder
+                    for x in range(n):
+                        
+                        iteration = expand(
+                            template[start:separator_pos], x)
+                        
+                        result = result + expand(iteration, x)
+
+                        if x != n - 1:
+                            result = result + expand(remainder, x)
                 else:
-                    result = result + fill(template[start:separator_pos], n, args, value = remainder)
+                    function_result = fill(
+                        template[start:separator_pos], n, args, value = remainder)
+                    result = result + expand(function_result)
                 
         else:
-            result = result + _gen_common_key(key, n, args, fill)
+            result = result + expand(_gen_common_key(key, n, args, fill))
             
         i = delimiter_pos + 2
         
@@ -218,8 +227,8 @@ def gen_functions(template, n, *args, **keywords):
 
     >>> print gen_functions('%1 abc(%(int a%n%:, %));%{ // all args are ints%}\n', 2, 'void'),
     void abc();
-    void abc(int a1); // all args are ints
-    void abc(int a1, int a2); // all args are ints
+    void abc(int a0); // all args are ints
+    void abc(int a0, int a1); // all args are ints
     
     """
     fill = keywords.get('fill', _raise_no_argument);

From c6fd3c47a4633221b41213ffb9f2249ee3f76b99 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 15 Dec 2001 04:57:18 +0000
Subject: [PATCH 161/369] Makefile and example setup batch file for Win32
 Metrowerks Codewarrior 7.

[SVN r12063]
---
 build/win32_mwcc.mak       | 149 +++++++++++++++++++++++++++++++++++++
 build/win32_mwcc_setup.bat |   2 +
 2 files changed, 151 insertions(+)
 create mode 100755 build/win32_mwcc.mak
 create mode 100755 build/win32_mwcc_setup.bat

diff --git a/build/win32_mwcc.mak b/build/win32_mwcc.mak
new file mode 100755
index 00000000..ac054c07
--- /dev/null
+++ b/build/win32_mwcc.mak
@@ -0,0 +1,149 @@
+# Usage:
+#
+#   make copy          Copy the sources and tests
+#   make               Compile all sources
+#   make test          Run doctest tests
+#   make clean         Remove all object files
+#   make del           Remove the sources and tests
+#
+# Revision history:
+#   14 Dec 01 derived from vc60.mak (R.W. Grosse-Kunstleve)
+
+ROOT=R:
+BOOST_WIN="$(ROOT)\boostdev"
+BOOST_UNIX=$(HOME)/boost
+
+#PYEXE="C:\Program files\Python\python.exe"
+#PYINC=-I"C:\Program files\Python\include"
+#PYLIB="C:\Program files\Python\libs\python15.lib"
+PYEXE="C:\Python21\python.exe"
+PYINC=-I"C:\Python21\include"
+PYLIB="C:\Python21\libs\python21.lib"
+
+STDOPTS=-gccinc -prefix UseDLLPrefix.h
+WARNOPTS=-warn on,nounusedexpr,nounused
+OPTOPTS=-O
+
+CPP=mwcc
+CPPOPTS=$(STDOPTS) $(WARNOPTS) $(OPTOPTS) \
+        $(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC)
+
+LD=mwld
+LDOPTS=-export dllexport -shared
+
+OBJ=classes.obj conversions.obj extension_class.obj functions.obj \
+    init_function.obj module_builder.obj \
+    objects.obj types.obj cross_module.obj
+
+.SUFFIXES: .obj .cpp
+
+all: libboost_python.lib \
+     boost_python_test.pyd \
+     abstract.pyd \
+     getting_started1.pyd getting_started2.pyd \
+     simple_vector.pyd \
+     do_it_yourself_convts.pyd \
+     nested.pyd \
+     pickle1.pyd pickle2.pyd pickle3.pyd \
+     noncopyable_export.pyd noncopyable_import.pyd \
+     ivect.pyd dvect.pyd \
+     richcmp1.pyd richcmp2.pyd richcmp3.pyd
+
+libboost_python.lib: $(OBJ)
+	$(LD) -library -o libboost_python.lib $(OBJ)
+
+boost_python_test.pyd: $(OBJ) comprehensive.obj
+	$(LD) $(LDOPTS) $(OBJ) comprehensive.obj $(PYLIB) -o boost_python_test.pyd
+
+abstract.pyd: $(OBJ) abstract.obj
+	$(LD) $(LDOPTS) $(OBJ) abstract.obj $(PYLIB)  -o abstract.pyd
+
+getting_started1.pyd: $(OBJ) getting_started1.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started1.obj $(PYLIB)  -o getting_started1.pyd
+
+getting_started2.pyd: $(OBJ) getting_started2.obj
+	$(LD) $(LDOPTS) $(OBJ) getting_started2.obj $(PYLIB)  -o getting_started2.pyd
+
+simple_vector.pyd: $(OBJ) simple_vector.obj
+	$(LD) $(LDOPTS) $(OBJ) simple_vector.obj $(PYLIB)  -o simple_vector.pyd
+
+do_it_yourself_convts.pyd: $(OBJ) do_it_yourself_convts.obj
+	$(LD) $(LDOPTS) $(OBJ) do_it_yourself_convts.obj $(PYLIB)  -o do_it_yourself_convts.pyd
+
+nested.pyd: $(OBJ) nested.obj
+	$(LD) $(LDOPTS) $(OBJ) nested.obj $(PYLIB)  -o nested.pyd
+
+pickle1.pyd: $(OBJ) pickle1.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle1.obj $(PYLIB)  -o pickle1.pyd
+
+pickle2.pyd: $(OBJ) pickle2.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle2.obj $(PYLIB)  -o pickle2.pyd
+
+pickle3.pyd: $(OBJ) pickle3.obj
+	$(LD) $(LDOPTS) $(OBJ) pickle3.obj $(PYLIB)  -o pickle3.pyd
+
+noncopyable_export.pyd: $(OBJ) noncopyable_export.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_export.obj $(PYLIB)  -o noncopyable_export.pyd
+
+noncopyable_import.pyd: $(OBJ) noncopyable_import.obj
+	$(LD) $(LDOPTS) $(OBJ) noncopyable_import.obj $(PYLIB)  -o noncopyable_import.pyd
+
+ivect.pyd: $(OBJ) ivect.obj
+	$(LD) $(LDOPTS) $(OBJ) ivect.obj $(PYLIB)  -o ivect.pyd
+
+dvect.pyd: $(OBJ) dvect.obj
+	$(LD) $(LDOPTS) $(OBJ) dvect.obj $(PYLIB)  -o dvect.pyd
+
+richcmp1.pyd: $(OBJ) richcmp1.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp1.obj $(PYLIB)  -o richcmp1.pyd
+
+richcmp2.pyd: $(OBJ) richcmp2.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp2.obj $(PYLIB)  -o richcmp2.pyd
+
+richcmp3.pyd: $(OBJ) richcmp3.obj
+	$(LD) $(LDOPTS) $(OBJ) richcmp3.obj $(PYLIB)  -o richcmp3.pyd
+
+.cpp.obj:
+	$(CPP) $(CPPOPTS) -c $*.cpp
+
+test:
+	$(PYEXE) comprehensive.py
+	$(PYEXE) test_abstract.py
+	$(PYEXE) test_getting_started1.py
+	$(PYEXE) test_getting_started2.py
+	$(PYEXE) test_simple_vector.py
+	$(PYEXE) test_do_it_yourself_convts.py
+	$(PYEXE) test_nested.py
+	$(PYEXE) test_pickle1.py
+	$(PYEXE) test_pickle2.py
+	$(PYEXE) test_pickle3.py
+	$(PYEXE) test_cross_module.py
+	$(PYEXE) test_richcmp1.py
+	$(PYEXE) test_richcmp2.py
+	$(PYEXE) test_richcmp3.py
+
+clean:
+	-del *.obj
+	-del *.lib
+	-del *.exp
+	-del *.idb
+	-del *.pyd
+	-del *.pyc
+
+softlinks:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) softlinks
+
+unlink:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) unlink
+
+cp:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) cp
+
+rm:
+	python $(BOOST_UNIX)/libs/python/build/filemgr.py $(BOOST_UNIX) rm
+
+copy:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) copy
+
+del:
+	$(PYEXE) $(BOOST_WIN)\libs\python\build\filemgr.py $(BOOST_WIN) del
diff --git a/build/win32_mwcc_setup.bat b/build/win32_mwcc_setup.bat
new file mode 100755
index 00000000..d42a60cf
--- /dev/null
+++ b/build/win32_mwcc_setup.bat
@@ -0,0 +1,2 @@
+"c:\program files\metrowerks\codewarrior\other metrowerks tools\command line tools\cwenv.bat"
+set MWWinx86LibraryFiles=MSL_All-DLL_x86.lib;gdi32.lib;user32.lib;kernel32.lib 

From 3a86a69964fb3d53f7672861c4ac7d160ae78342 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 15 Dec 2001 04:59:11 +0000
Subject: [PATCH 162/369] Restore Python <2.2 compatibility (config.h,
 pyconfig.h).

[SVN r12064]
---
 include/boost/python/detail/wrap_python.hpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index 1ad88ab6..b6e23b66 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -72,11 +72,19 @@ typedef int pid_t;
 #   define _MSC_VER 900
 #  endif
 
-#  include <pyconfig.h>
+#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
+#   include <config.h>
+#  else
+#   include <pyconfig.h>
+#  endif
 #  undef hypot // undo the evil #define left by Python.
 
 # elif defined(__BORLANDC__)
-#  include <pyconfig.h>
+#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
+#   include <config.h>
+#  else
+#   include <pyconfig.h>
+#  endif
 #  undef HAVE_HYPOT
 #  define HAVE_HYPOT 1
 # elif defined(_MSC_VER)

From 5134fb2ec18a96bd9735c39873b0ba670627f1e2 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 15 Dec 2001 22:59:48 +0000
Subject: [PATCH 163/369] scott snyder's fixes to maintain 1.5.2 compatibility

[SVN r12065]
---
 src/types.cpp         | 10 ++----
 test/comprehensive.py | 84 +++++++++++++++++++++++--------------------
 2 files changed, 49 insertions(+), 45 deletions(-)

diff --git a/src/types.cpp b/src/types.cpp
index fe108225..c7e1f167 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -566,18 +566,12 @@ bool add_capability_richcompare(type_object_base::capability capability, PyTypeO
     return false;
 }
 
-#if PYTHON_API_VERSION >= 1010
-# define ENABLE_INPLACE_CAPABILITY1 \
-        dest->tp_flags |= Py_TPFLAGS_HAVE_INPLACEOPS;
-#else
-# define ENABLE_INPLACE_CAPABILITY1
-#endif
 #define ENABLE_INPLACE_CAPABILITY(field) \
     case type_object_base::number_##field: \
         create_method_table_if_null(dest->tp_as_number); \
         dest->tp_as_number->nb_##field = &do_instance_nb_##field; \
         detail::shared_pod_manager::replace_if_equal(dest->tp_as_number); \
-        ENABLE_INPLACE_CAPABILITY1 \
+        dest->tp_flags |= Py_TPFLAGS_HAVE_INPLACEOPS; \
         return true
 
 bool add_capability_inplace(type_object_base::capability capability, PyTypeObject* dest)
@@ -585,6 +579,7 @@ bool add_capability_inplace(type_object_base::capability capability, PyTypeObjec
     assert(dest != 0);
     switch (capability)
     {
+#if PYTHON_API_VERSION >= 1010
         ENABLE_INPLACE_CAPABILITY (inplace_add);
         ENABLE_INPLACE_CAPABILITY (inplace_subtract);
         ENABLE_INPLACE_CAPABILITY (inplace_multiply);
@@ -596,6 +591,7 @@ bool add_capability_inplace(type_object_base::capability capability, PyTypeObjec
         ENABLE_INPLACE_CAPABILITY (inplace_and);
         ENABLE_INPLACE_CAPABILITY (inplace_or);
         ENABLE_INPLACE_CAPABILITY (inplace_xor);
+#endif
         default:
             return false;
     }
diff --git a/test/comprehensive.py b/test/comprehensive.py
index b4ae5679..c49a4add 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -334,7 +334,8 @@ Special member attributes. Tests courtesy of Barry Scott <barry@scottb.demon.co.
     'Docs for DerivedFromBase.fred'
 
     >>> import sys
-    >>> if sys.version_info[0] < 2 or ( sys.version_info[0] == 2 and
+    >>> if not sys.__dict__.has_key('version_info') or \
+    ...    sys.version_info[0] < 2 or ( sys.version_info[0] == 2 and
     ...                                 sys.version_info[1] < 2 ):
     ...     assert dir(df) == []
     ...     assert dir(db) == []
@@ -1069,43 +1070,6 @@ test inheritB2
     Traceback (innermost last):
     TypeError: bad operand type(s) for pow()
 
-    >>> ii = Int(1)
-    >>> ii += Int(2)
-    >>> ii.i()
-    3
-    >>> ii -= Int(1)
-    >>> ii.i()
-    2
-    >>> ii *= Int(3)
-    >>> ii.i()
-    6
-    >>> ii /= Int(2)
-    >>> ii.i()
-    3
-    >>> ii <<= Int(2)
-    >>> ii.i()
-    12
-    >>> ii >>= Int(1)
-    >>> ii.i()
-    6
-    >>> ii &= Int(5)
-    >>> ii.i()
-    4
-    >>> ii |= Int(9)
-    >>> ii.i()
-    13
-    >>> ii ^= Int(7)
-    >>> ii.i()
-    10
-    >>> ii %= Int(4)
-    >>> ii.i()
-    2
-    >>> ii **= Int(3)
-    >>> ii.i()
-    8
-    >>> ii.j()
-    11
-
 Test operator export to a subclass
 
     # force method table sharing
@@ -1226,6 +1190,50 @@ test methodologies for wrapping functions that return a pointer
 '''
 #'
 
+__test__ = {}
+import sys
+
+# Inplace ops only exist in python 2.1 or later.
+if sys.hexversion >= 0x02010000:
+    __test__['inplacetests'] = r'''
+    >>> ii = Int(1)
+    >>> ii += Int(2)
+    >>> ii.i()
+    3
+    >>> ii -= Int(1)
+    >>> ii.i()
+    2
+    >>> ii *= Int(3)
+    >>> ii.i()
+    6
+    >>> ii /= Int(2)
+    >>> ii.i()
+    3
+    >>> ii <<= Int(2)
+    >>> ii.i()
+    12
+    >>> ii >>= Int(1)
+    >>> ii.i()
+    6
+    >>> ii &= Int(5)
+    >>> ii.i()
+    4
+    >>> ii |= Int(9)
+    >>> ii.i()
+    13
+    >>> ii ^= Int(7)
+    >>> ii.i()
+    10
+    >>> ii %= Int(4)
+    >>> ii.i()
+    2
+    >>> ii **= Int(3)
+    >>> ii.i()
+    8
+    >>> ii.j()
+    11
+'''
+
 from boost_python_test import *
 
 # pickle requires these derived classes to be

From f9e6933840ffe0af5049eae3dcb73633ec8cce33 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sun, 16 Dec 2001 06:00:03 +0000
Subject: [PATCH 164/369] Use "call", otherwise the "set" command is not
 executed.

[SVN r12066]
---
 build/win32_mwcc_setup.bat | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build/win32_mwcc_setup.bat b/build/win32_mwcc_setup.bat
index d42a60cf..30f84be8 100755
--- a/build/win32_mwcc_setup.bat
+++ b/build/win32_mwcc_setup.bat
@@ -1,2 +1,2 @@
-"c:\program files\metrowerks\codewarrior\other metrowerks tools\command line tools\cwenv.bat"
-set MWWinx86LibraryFiles=MSL_All-DLL_x86.lib;gdi32.lib;user32.lib;kernel32.lib 
+call "c:\program files\metrowerks\codewarrior\other metrowerks tools\command line tools\cwenv.bat"
+set MWWinx86LibraryFiles=MSL_All-DLL_x86.lib;gdi32.lib;user32.lib;kernel32.lib

From e65ca4ccac7bfa510f10d011d85502c108b1b64d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 16 Dec 2001 17:58:23 +0000
Subject: [PATCH 165/369] Python 1.5 compatibility fixes

[SVN r12072]
---
 test/comprehensive.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 61f56407..d25b131a 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -1093,6 +1093,7 @@ void init_module(boost::python::module_builder& m)
     // export non-operator function as heterogeneous reverse-argument operator
     int_class.def(&rmul, "__rmul__");
 
+#if PYTHON_API_VERSION >= 1010
     // inplace operators.
     int_class.def(&int_iadd, "__iadd__");
     int_class.def(&int_isub, "__isub__");
@@ -1105,6 +1106,7 @@ void init_module(boost::python::module_builder& m)
     int_class.def(&int_iand, "__iand__");
     int_class.def(&int_ior, "__ior__");
     int_class.def(&int_ixor, "__ixor__");
+#endif
     
 
     boost::python::class_builder<EnumOwner> enum_owner(m, "EnumOwner");

From bed2c8a371b2e181c5215604629abb641b9751df Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 16 Dec 2001 18:20:26 +0000
Subject: [PATCH 166/369] no message

[SVN r12076]
---
 include/boost/python/detail/config.hpp      | 12 +++++++-----
 include/boost/python/detail/wrap_python.hpp |  8 +++++---
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index f814aba0..ff22e78e 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -57,10 +57,12 @@
 #  define BOOST_CSTD_ std
 # endif
 
-#if defined(_WIN32) || defined(__CYGWIN__)
-# define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" __declspec(dllexport) void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
-#else
-# define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
-#endif
+# ifndef BOOST_PYTHON_MODULE_INIT
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" __declspec(dllexport) void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
+#  else
+#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
+#  endif
+# endif 
 
 #endif // CONFIG_DWA052200_H_
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index b6e23b66..34a9c2b5 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -72,7 +72,7 @@ typedef int pid_t;
 #   define _MSC_VER 900
 #  endif
 
-#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
+#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2
 #   include <config.h>
 #  else
 #   include <pyconfig.h>
@@ -80,7 +80,7 @@ typedef int pid_t;
 #  undef hypot // undo the evil #define left by Python.
 
 # elif defined(__BORLANDC__)
-#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
+#  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 2
 #   include <config.h>
 #  else
 #   include <pyconfig.h>
@@ -88,7 +88,9 @@ typedef int pid_t;
 #  undef HAVE_HYPOT
 #  define HAVE_HYPOT 1
 # elif defined(_MSC_VER)
-#  include <limits> // prevents Python.h from defining LONGLONG_MAX, LONGLONG_MIN, and ULONGLONG_MAX
+#  ifdef __cplusplus
+#   include <limits> // prevents Python.h from defining LONGLONG_MAX, LONGLONG_MIN, and ULONGLONG_MAX
+#  endif 
 # endif
 
 #endif // _WIN32

From 291c36df05902fd1d73cd6131ba42c17f592b4fe Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 17 Dec 2001 05:49:24 +0000
Subject: [PATCH 167/369] Integrated Scott Snyder's nested class patch

[SVN r12080]
---
 doc/exporting_classes.html             |  6 ++++++
 include/boost/python/class_builder.hpp | 16 ++++++++++++++++
 test/comprehensive.cpp                 | 20 ++++++++++++++++++++
 test/comprehensive.hpp                 |  4 ++++
 test/comprehensive.py                  | 10 +++++++++-
 5 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/doc/exporting_classes.html b/doc/exporting_classes.html
index e5932e70..61c5ef88 100644
--- a/doc/exporting_classes.html
+++ b/doc/exporting_classes.html
@@ -98,6 +98,12 @@ Notes:<ul>
 
 <li>Any function added to a class whose initial argument matches the class (or
 any base) will act like a member function in Python.
+
+<li>To define a nested class, just pass the enclosing
+<tt>class_builder</tt> (instead of a <tt>module_builder</tt>) as the
+first argument to the nested <tt>class_builder</tt>'s constructor.
+
+
 </ul>
       <p>
          We can even make a subclass of <code>hello.world</code>:
diff --git a/include/boost/python/class_builder.hpp b/include/boost/python/class_builder.hpp
index 4a9ec1b2..fe2a7b74 100644
--- a/include/boost/python/class_builder.hpp
+++ b/include/boost/python/class_builder.hpp
@@ -25,6 +25,22 @@ class class_builder
         module.add(ref(as_object(m_class.get()), ref::increment_count), name);
     }
     
+  template <class OtherT, class OtherU>
+    class_builder(class_builder<OtherT, OtherU>& cls, const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        cls.add(ref(as_object(m_class.get()), ref::increment_count), name);
+    }
+    
+  template <class OtherT, class OtherU>
+    class_builder(detail::extension_class<OtherT, OtherU>* cls,
+                  const char* name)
+        : m_class(new detail::extension_class<T, U>(name))
+    {
+        cls->set_attribute(name,
+                           ref(as_object(m_class.get()), ref::increment_count));
+    }
+    
     ~class_builder()
     {}
 
diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index d25b131a..6c7cc4d3 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -67,6 +67,16 @@ Foo::PythonClass::PythonClass(boost::python::module_builder& m)
     def(&Foo::add_len, "add_len", &FooCallback::default_add_len);
     
     // Since pure() is pure virtual, we are leaving it undefined.
+
+    // And the nested classes.
+    boost::python::class_builder<Foo::Foo_A> foo_a(*this, "Foo_A");
+    foo_a.def(boost::python::constructor<>());
+    foo_a.def(&Foo::Foo_A::mumble, "mumble");
+
+    boost::python::class_builder<Foo::Foo_B> foo_b(get_extension_class(),
+                                                   "Foo_B");
+    foo_b.def(boost::python::constructor<>());
+    foo_b.def(&Foo::Foo_B::mumble, "mumble");
 }
 
 BarPythonClass::BarPythonClass(boost::python::module_builder& m)
@@ -223,6 +233,16 @@ const char* Foo::mumble()
     return "mumble";
 }
 
+const char* Foo::Foo_A::mumble()
+{
+    return "mumble a";
+}
+
+const char* Foo::Foo_B::mumble()
+{
+    return "mumble b";
+}
+
 void Foo::set(long x)
 {
     m_x = x;
diff --git a/test/comprehensive.hpp b/test/comprehensive.hpp
index ed90f061..deb68a88 100644
--- a/test/comprehensive.hpp
+++ b/test/comprehensive.hpp
@@ -42,6 +42,10 @@ class Foo                // prohibit copying, proving that it doesn't choke
     std::string call_pure();                    // call a pure virtual fuction
     int call_add_len(const char* s) const;      // virtual function with a default implementation
 
+    // A couple nested classs.
+    struct Foo_A { const char* mumble(); };
+    struct Foo_B { const char* mumble(); };
+
  private:
     // by default, sum the held value and the length of s
     virtual int add_len(const char* s) const;
diff --git a/test/comprehensive.py b/test/comprehensive.py
index c49a4add..7d0bec79 100644
--- a/test/comprehensive.py
+++ b/test/comprehensive.py
@@ -230,6 +230,14 @@ Polymorphism also works:
     >>> baz.get_foo_value(polymorphic_foo)
     1000
 
+Simple nested class test:
+    >>> foo_a = Foo.Foo_A()
+    >>> foo_a.mumble()
+    'mumble a'
+    >>> foo_b = Foo.Foo_B()
+    >>> foo_b.mumble()
+    'mumble b'
+
 Pickling tests:
 
     >>> world.__module__
@@ -343,7 +351,7 @@ Special member attributes. Tests courtesy of Barry Scott <barry@scottb.demon.co.
     ...             '__doc__', '__module__', 'fred', 'i_am_derived_from_base']
     ... else:
     ...     assert dir(df) == [
-    ...         '__del__', '__doc__', '__init__', '__module__', 'add_len',
+    ...         'Foo_A', 'Foo_B', '__del__', '__doc__', '__init__', '__module__', 'add_len',
     ...         'call_add_len', 'call_pure', 'fred', 'mumble', 'set']
     ...     assert dir(db) == ['__doc__', '__module__', 'fred'
     ...                       , 'i_am_base', 'i_am_derived_from_base']

From 1a13387012a008aba8fbee3fcc5374ea0b9323f6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 17 Dec 2001 16:59:54 +0000
Subject: [PATCH 168/369] Integrating Andreas Zieringer's shared library
 implementation.

Modified Files:
	classes.hpp conversions.hpp cross_module.hpp errors.hpp
	module_builder.hpp objects.hpp operators.hpp detail/config.hpp
	detail/extension_class.hpp detail/functions.hpp
	detail/init_function.hpp detail/signatures.hpp
	detail/singleton.hpp detail/types.hpp detail/void_adaptor.hpp


[SVN r12083]
---
 include/boost/python/detail/config.hpp        | 64 +++++++++++++++++++
 .../boost/python/detail/extension_class.hpp   | 22 +++----
 include/boost/python/detail/functions.hpp     |  4 +-
 include/boost/python/detail/init_function.hpp |  2 +-
 include/boost/python/detail/signatures.hpp    |  2 +-
 include/boost/python/detail/singleton.hpp     |  2 +-
 include/boost/python/detail/types.hpp         |  6 +-
 include/boost/python/detail/void_adaptor.hpp  |  2 +-
 8 files changed, 84 insertions(+), 20 deletions(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index ff22e78e..0fc1093a 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -65,4 +65,68 @@
 #  endif
 # endif 
 
+/*****************************************************************************
+ *
+ *  Set up dll import/export options:
+ *
+ ****************************************************************************/
+
+// backwards compatibility:
+#ifdef BOOST_RE_STATIC_LIB
+#  define BOOST_PYTHON_STATIC_LINK
+#endif
+
+#if defined(BOOST_MSVC) && defined(_DLL)
+#  define BOOST_PYTHON_HAS_DLL_RUNTIME
+#endif
+
+#if defined(__BORLANDC__) && defined(_RTLDLL)
+#  define BOOST_PYTHON_HAS_DLL_RUNTIME
+#endif
+
+#if defined(__ICL) && defined(_DLL)
+#  define BOOST_PYTHON_HAS_DLL_RUNTIME
+#endif
+
+#if defined(BOOST_PYTHON_HAS_DLL_RUNTIME) && !defined(BOOST_PYTHON_STATIC_LINK)
+#  if defined(BOOST_PYTHON_SOURCE)
+#     define BOOST_PYTHON_DECL __declspec(dllexport)
+#     define BOOST_PYTHON_BUILD_DLL
+#  else
+#     define BOOST_PYTHON_DECL __declspec(dllimport)
+#  endif
+#endif
+
+#ifndef BOOST_PYTHON_DECL
+#  define BOOST_PYTHON_DECL
+#endif
+
+#if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_PYTHON_NO_LIB) && !defined(BOOST_PYTHON_SOURCE)
+#  include <boost/python/detail/python_library_include.hpp>
+#endif
+
+// Borland C++ Fix/error check:
+#if defined(__BORLANDC__)
+#  if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551)
+      // problems with std::basic_string and dll RTL:
+#     if defined(_RTLDLL) && defined(_RWSTD_COMPILE_INSTANTIATE)
+#        ifdef BOOST_PYTHON_BUILD_DLL
+#           error _RWSTD_COMPILE_INSTANTIATE must not be defined when building regex++ as a DLL
+#        else
+#           pragma warn defining _RWSTD_COMPILE_INSTANTIATE when linking to the DLL version of the RTL may produce memory corruption problems in std::basic_string, as a result of separate versions of basic_string's static data in the RTL and you're exe/dll: be warned!!
+#        endif
+#     endif
+#     ifndef _RTLDLL
+         // this is harmless for a staic link:
+#        define _RWSTD_COMPILE_INSTANTIATE
+#     endif
+#  endif
+   //
+   // VCL support:
+   // if we're building a console app then there can't be any VCL (can there?)
+#  if !defined(__CONSOLE__) && !defined(_NO_VCL)
+#     define BOOST_PYTHON_USE_VCL
+#  endif
+#endif
+
 #endif // CONFIG_DWA052200_H_
diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index f7be9afb..00f9b6b4 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -52,12 +52,12 @@ template <class Specified> struct operand_select;
   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&);
+BOOST_PYTHON_DECL meta_class<extension_instance>* extension_meta_class();
+BOOST_PYTHON_DECL extension_instance* get_extension_instance(PyObject* p);
+BOOST_PYTHON_DECL void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
+BOOST_PYTHON_DECL void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
+BOOST_PYTHON_DECL void report_missing_class_object(const std::type_info&);
+BOOST_PYTHON_DECL void report_released_smart_pointer(const std::type_info&);
     
 template <class T>
 T* check_non_null(T* p)
@@ -71,7 +71,7 @@ template <class Held> class held_instance;
 
 typedef void* (*conversion_function_ptr)(void*);
 
-struct base_class_info
+struct BOOST_PYTHON_DECL base_class_info
 {
     base_class_info(extension_class_base* t, conversion_function_ptr f)
         :class_object(t), convert(f)
@@ -85,7 +85,7 @@ typedef base_class_info derived_class_info;
 
 struct add_operator_base;
 
-class extension_class_base : public class_t<extension_instance>
+class BOOST_PYTHON_DECL extension_class_base : public class_t<extension_instance>
 {
  public:
     extension_class_base(const char* name);
@@ -378,7 +378,7 @@ namespace detail {
 
 template <class T> class instance_holder;
 
-class read_only_setattr_function : public function
+class BOOST_PYTHON_DECL read_only_setattr_function : public function
 {
  public:
     read_only_setattr_function(const char* name);
@@ -725,7 +725,7 @@ public:
 
 // Abstract base class for all obj holders. Base for template class
 // instance_holder<>, below.
-class instance_holder_base
+class BOOST_PYTHON_DECL instance_holder_base
 {
 public:
     virtual ~instance_holder_base() {}
@@ -813,7 +813,7 @@ class instance_ptr_holder : public instance_holder<HeldType>
     PtrType m_ptr;
 };
 
-class extension_instance : public instance
+class BOOST_PYTHON_DECL extension_instance : public instance
 {
  public:
     extension_instance(PyTypeObject* class_);
diff --git a/include/boost/python/detail/functions.hpp b/include/boost/python/detail/functions.hpp
index eff05d65..486d73f9 100644
--- a/include/boost/python/detail/functions.hpp
+++ b/include/boost/python/detail/functions.hpp
@@ -29,7 +29,7 @@ class extension_instance;
 // function --
 //      the common base class for all overloadable function and method objects
 //      supplied by the library.
-class function : public python_object
+class BOOST_PYTHON_DECL function : public python_object
 {
  public:
     function();
@@ -201,7 +201,7 @@ inline function* new_virtual_function(
 // 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
+class BOOST_PYTHON_DECL bound_function : public python_object
 {
  public:
     static bound_function* create(const ref& target, const ref& fn);
diff --git a/include/boost/python/detail/init_function.hpp b/include/boost/python/detail/init_function.hpp
index c0c50272..69df703d 100644
--- a/include/boost/python/detail/init_function.hpp
+++ b/include/boost/python/detail/init_function.hpp
@@ -230,7 +230,7 @@ struct init_function
     }
 };
 
-class init : public function
+class BOOST_PYTHON_DECL init : public function
 {
 private: // override function hook
     PyObject* do_call(PyObject* args, PyObject* keywords) const;
diff --git a/include/boost/python/detail/signatures.hpp b/include/boost/python/detail/signatures.hpp
index 2be75b52..e216f688 100644
--- a/include/boost/python/detail/signatures.hpp
+++ b/include/boost/python/detail/signatures.hpp
@@ -17,7 +17,7 @@ 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 {};
+struct BOOST_PYTHON_DECL void_t {};
 }
 
 // An envelope in which type information can be delivered for the purposes
diff --git a/include/boost/python/detail/singleton.hpp b/include/boost/python/detail/singleton.hpp
index 07d794ac..3e7d91af 100644
--- a/include/boost/python/detail/singleton.hpp
+++ b/include/boost/python/detail/singleton.hpp
@@ -13,7 +13,7 @@
 
 namespace boost { namespace python { namespace detail {
 
-struct empty {};
+struct BOOST_PYTHON_DECL empty {};
 template <class Derived, class Base = empty>
 struct singleton : Base
 {
diff --git a/include/boost/python/detail/types.hpp b/include/boost/python/detail/types.hpp
index 954e0213..f4e62f88 100644
--- a/include/boost/python/detail/types.hpp
+++ b/include/boost/python/detail/types.hpp
@@ -37,7 +37,7 @@ namespace detail {
 
 class instance_holder_base;
 
-class type_object_base : public python_type
+class BOOST_PYTHON_DECL type_object_base : public python_type
 {
  public:
     explicit type_object_base(PyTypeObject* type_type);
@@ -327,7 +327,7 @@ PyObject* reprable<Base>::instance_repr(PyObject* obj) const
   // 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
+  class BOOST_PYTHON_DECL shared_pod_manager
   {
       typedef std::pair<char*, std::size_t> holder;
       typedef std::vector<holder> storage;
@@ -394,7 +394,7 @@ PyObject* reprable<Base>::instance_repr(PyObject* obj) const
   };
 
 
-  void add_capability(type_object_base::capability capability, 
+  BOOST_PYTHON_DECL 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
diff --git a/include/boost/python/detail/void_adaptor.hpp b/include/boost/python/detail/void_adaptor.hpp
index c2ecc2b0..3d60e4bf 100644
--- a/include/boost/python/detail/void_adaptor.hpp
+++ b/include/boost/python/detail/void_adaptor.hpp
@@ -8,7 +8,7 @@
 
 namespace boost { namespace python { namespace detail {
 
-  extern PyObject arbitrary_object;
+  BOOST_PYTHON_DECL extern PyObject arbitrary_object;
 
   template <class T>
   struct void_adaptor

From d4b215a66b1e2c6f18df61ae2e5d79ce66a146f0 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 17 Dec 2001 17:00:53 +0000
Subject: [PATCH 169/369] Integrating Andreas Zieringer's shared lib changes

Modified Files:
	build/Jamfile build/win32_mwcc_setup.bat src/classes.cpp
	src/conversions.cpp src/cross_module.cpp
	src/extension_class.cpp src/functions.cpp
	src/init_function.cpp src/module_builder.cpp src/objects.cpp
	src/types.cpp


[SVN r12084]
---
 build/Jamfile           | 8 +++++++-
 src/classes.cpp         | 2 ++
 src/conversions.cpp     | 2 ++
 src/cross_module.cpp    | 2 ++
 src/extension_class.cpp | 2 ++
 src/functions.cpp       | 2 ++
 src/init_function.cpp   | 2 ++
 src/module_builder.cpp  | 2 ++
 src/objects.cpp         | 2 ++
 src/types.cpp           | 2 ++
 10 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/build/Jamfile b/build/Jamfile
index c56bf47c..78d1e84a 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -84,7 +84,13 @@ lib libboost_python : ../src/$(CPP_SOURCES).cpp
     <shared-linkable>true
     $(PYTHON_PROPERTIES) ;
 
-    
+dll libboost_python$(SUFDLL[1]) : ../src/$(CPP_SOURCES).cpp
+	# requirements
+	: $(BOOST_PYTHON_INCLUDES)
+	<shared-linkable>true
+	<define>BOOST_RE_BUILD_DLL=1
+	$(PYTHON_PROPERTIES) ;
+
 ############# comprehensive module and test ###########
 bpl-test boost_python_test
       : ../test/comprehensive.cpp ;
diff --git a/src/classes.cpp b/src/classes.cpp
index 75f8a01a..c721ef5c 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -11,6 +11,8 @@
 // 03 Mar 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
 // 03 Mar 01  bug fix: use bound_function::create() (instead of new bound_function)
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/classes.hpp>
 #include <boost/python/detail/functions.hpp>
 #include <boost/python/detail/singleton.hpp>
diff --git a/src/conversions.cpp b/src/conversions.cpp
index c986f57b..f1534dd9 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -13,6 +13,8 @@
 // 04 Mar 01  std::complex<> fixes for MSVC (Dave Abrahams)
 // 03 Mar 01  added: converters for [plain] char (Ralf W. Grosse-Kunstleve)
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/conversions.hpp>
 #include <boost/python/detail/void_adaptor.hpp>
 #include <typeinfo>
diff --git a/src/cross_module.cpp b/src/cross_module.cpp
index ea5a08de..5949be4d 100644
--- a/src/cross_module.cpp
+++ b/src/cross_module.cpp
@@ -8,6 +8,8 @@
      17 Apr 01 merged into boost CVS trunk (Ralf W. Grosse-Kunstleve)
 */
 
+#define BOOST_PYTHON_SOURCE
+
 # include <boost/python/cross_module.hpp>
 namespace python = boost::python;
 # include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index 3815a19c..e9183c82 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -9,6 +9,8 @@
 // Revision History:
 // 04 Mar 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/detail/extension_class.hpp>
 #include <boost/utility.hpp>
 #include <boost/bind.hpp>
diff --git a/src/functions.cpp b/src/functions.cpp
index a04e2e51..ecbacf4e 100644
--- a/src/functions.cpp
+++ b/src/functions.cpp
@@ -9,6 +9,8 @@
 // Revision History:
 // Mar 01 01  Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams)
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/detail/functions.hpp>
 #include <boost/python/detail/types.hpp>
 #include <boost/python/detail/singleton.hpp>
diff --git a/src/init_function.cpp b/src/init_function.cpp
index 1667724c..1ebfa501 100644
--- a/src/init_function.cpp
+++ b/src/init_function.cpp
@@ -6,6 +6,8 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/detail/init_function.hpp>
 #include <boost/python/objects.hpp>
 #include <boost/python/detail/extension_class.hpp>
diff --git a/src/module_builder.cpp b/src/module_builder.cpp
index 57eec75f..bd04a89c 100644
--- a/src/module_builder.cpp
+++ b/src/module_builder.cpp
@@ -6,6 +6,8 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/module_builder.hpp>
 
 namespace boost { namespace python {
diff --git a/src/objects.cpp b/src/objects.cpp
index 125a1eb8..70257388 100644
--- a/src/objects.cpp
+++ b/src/objects.cpp
@@ -8,6 +8,8 @@
 
 // TODO: Move inline implementations from objects.cpp here
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/objects.hpp>
 #include <boost/python/detail/none.hpp>
 
diff --git a/src/types.cpp b/src/types.cpp
index c7e1f167..f411aa42 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -6,6 +6,8 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/detail/types.hpp>
 #include <boost/python/reference.hpp> // for handle_exception()
 #include <boost/python/conversions.hpp>

From 460f3aebe9a68918fae1e328b85712cbea91ce3a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 17 Dec 2001 17:24:41 +0000
Subject: [PATCH 170/369] inital checkin

[SVN r12086]
---
 .../python/detail/python_library_include.hpp  | 182 ++++++++++++++++++
 1 file changed, 182 insertions(+)
 create mode 100644 include/boost/python/detail/python_library_include.hpp

diff --git a/include/boost/python/detail/python_library_include.hpp b/include/boost/python/detail/python_library_include.hpp
new file mode 100644
index 00000000..903f02be
--- /dev/null
+++ b/include/boost/python/detail/python_library_include.hpp
@@ -0,0 +1,182 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_libary_include.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers.
+  *                Note this is an internal header file included
+  *                by regex.hpp, do not include on its own.
+  */
+
+
+#ifndef BOOST_REGEX_LIBRARY_INCLUDE_HPP
+#define BOOST_REGEX_LIBRARY_INCLUDE_HPP
+#ifndef BOOST_REGEX_NO_LIB
+
+#if defined(BOOST_MSVC) && !defined(BOOST_REGEX_BUILD_DLL)
+#ifdef __SGI_STL_PORT
+   #ifdef _DLL
+      // All these are multithreaded:
+      #if defined(_DEBUG) && defined(__STL_DEBUG)
+         #pragma comment(lib, "vc6-stlport-re300ddl.lib")
+      #elif defined(_DEBUG)
+         #pragma comment(lib, "vc6-stlport-re300dl.lib")
+      #elif defined(BOOST_REGEX_STATIC_LINK)
+         // static regex lib, dll runtime
+         #pragma comment(lib, "vc6-stlport-re300ls.lib")
+      #else // DEBUG
+         #pragma comment(lib, "vc6-stlport-re300l.lib")
+      #endif // _DEBUG
+   #else // _DLL
+      #ifdef _MT
+         #if defined(_DEBUG) && defined(__STL_DEBUG)
+            #pragma comment(lib, "vc6-stlport-re300ddm.lib")
+         #elif defined(_DEBUG)
+            #pragma comment(lib, "vc6-stlport-re300dm.lib")
+         #else //_DEBUG
+            #pragma comment(lib, "vc6-stlport-re300m.lib")
+         #endif //_DEBUG
+      #else //_MT
+         // STLPort does not support single threaded builds:
+         #error STLPort does not support single threaded builds
+      #endif //_MT
+   #endif //_DLL
+#elif _MSC_VER < 1300
+   #ifdef _DLL
+      // All these are multithreaded:
+      #ifdef _DEBUG
+         #pragma comment(lib, "vc6-re300dl.lib")
+      #elif defined(BOOST_REGEX_STATIC_LINK)
+         // static regex lib, dll runtime
+         #pragma comment(lib, "vc6-re300ls.lib")
+      #else // DEBUG
+         #pragma comment(lib, "vc6-re300l.lib")
+      #endif // _DEBUG
+   #else // _DLL
+      #ifdef _MT
+         #ifdef _DEBUG
+            #pragma comment(lib, "vc6-re300dm.lib")
+         #else //_DEBUG
+            #pragma comment(lib, "vc6-re300m.lib")
+         #endif //_DEBUG
+      #else //_MT
+         #ifdef _DEBUG
+            #pragma comment(lib, "vc6-re300d.lib")
+         #else //_DEBUG
+            #pragma comment(lib, "vc6-re300.lib")
+         #endif //_DEBUG
+      #endif //_MT
+   #endif //_DLL
+#else
+   #ifdef _DLL
+      // All these are multithreaded:
+      #ifdef _DEBUG
+         #pragma comment(lib, "vc7-re300dl.lib")
+      #elif defined(BOOST_REGEX_STATIC_LINK)
+         // static regex lib, dll runtime
+         #pragma comment(lib, "vc7-re300ls.lib")
+      #else // DEBUG
+         #pragma comment(lib, "vc7-re300l.lib")
+      #endif // _DEBUG
+   #else // _DLL
+      #ifdef _MT
+         #ifdef _DEBUG
+            #pragma comment(lib, "vc7-re300dm.lib")
+         #else //_DEBUG
+            #pragma comment(lib, "vc7-re300m.lib")
+         #endif //_DEBUG
+      #else //_MT
+         #ifdef _DEBUG
+            #pragma comment(lib, "vc7-re300d.lib")
+         #else //_DEBUG
+            #pragma comment(lib, "vc7-re300.lib")
+         #endif //_DEBUG
+      #endif //_MT
+   #endif //_DLL
+#endif // __SGI_STL_PORT
+#endif //BOOST_MSVC
+
+
+#if defined(__BORLANDC__) && !defined(BOOST_REGEX_BUILD_DLL)
+   
+   #if __BORLANDC__ < 0x550
+   
+   #ifdef BOOST_REGEX_USE_VCL
+   
+      #ifdef _RTLDLL
+         #pragma comment(lib, "bcb4re300lv.lib")
+      #else
+         #pragma comment(lib, "bcb4re300v.lib")
+      #endif
+   
+   #else // VCL
+   
+   #ifdef _RTLDLL
+      #ifdef __MT__
+         #pragma comment(lib, "bcb4re300lm.lib")
+      #else // __MT__
+         #pragma comment(lib, "bcb4re300l.lib")
+      #endif // __MT__
+   #else //_RTLDLL
+      #ifdef __MT__
+         #pragma comment(lib, "bcb4re300m.lib")
+      #else // __MT__
+         #pragma comment(lib, "bcb4re300.lib")
+      #endif // __MT__
+   #endif // _RTLDLL
+   
+   #endif // VCL
+   
+   #else // C++ Builder 5:
+
+   #ifdef BOOST_REGEX_USE_VCL
+   
+      #ifdef _RTLDLL
+         #pragma comment(lib, "bcb5re300lv.lib")
+      #else
+         #pragma comment(lib, "bcb5re300v.lib")
+      #endif
+   
+   #else // VCL
+   
+   #ifdef _RTLDLL
+      #ifdef __MT__
+         #pragma comment(lib, "bcb5re300lm.lib")
+      #else // __MT__
+         #pragma comment(lib, "bcb5re300l.lib")
+      #endif // __MT__
+   #else //_RTLDLL
+      #ifdef __MT__
+         #pragma comment(lib, "bcb5re300m.lib")
+      #else // __MT__
+         #pragma comment(lib, "bcb5re300.lib")
+      #endif // __MT__
+   #endif // _RTLDLL
+   
+   #endif // VCL
+   
+   #endif   
+   
+#endif //__BORLANDC__
+
+#endif //BOOST_REGEX_NO_LIB
+
+#endif // BOOST_REGEX_LIBRARY_INCLUDE_HPP
+
+
+
+

From c494649ddef5160217f8a2aa5ba3134130e136c9 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 18 Dec 2001 21:00:07 +0000
Subject: [PATCH 171/369] fix a bug with instance::power reported by Scott
 Snyder.

[SVN r12119]
---
 src/classes.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/classes.cpp b/src/classes.cpp
index c721ef5c..f51d1a2f 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -11,8 +11,6 @@
 // 03 Mar 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
 // 03 Mar 01  bug fix: use bound_function::create() (instead of new bound_function)
 
-#define BOOST_PYTHON_SOURCE
-
 #include <boost/python/classes.hpp>
 #include <boost/python/detail/functions.hpp>
 #include <boost/python/detail/singleton.hpp>
@@ -645,7 +643,7 @@ PyObject* instance::divmod(PyObject* other)
 
 PyObject* instance::power(PyObject* exponent, PyObject* modulus)
 {
-    if (as_object(modulus->ob_type) == Py_None)
+    if (as_object(modulus) == Py_None)
         return callback<PyObject*>::call_method(this, "__pow__", exponent);
     else
         return callback<PyObject*>::call_method(this, "__pow__", exponent, modulus);

From 1f78c7408592a4ce634bc7268c5a910b6e0c6b05 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 24 Dec 2001 19:27:39 +0000
Subject: [PATCH 172/369] fixes

[SVN r12146]
---
 Jamfile                                       |  39 +
 build/Jamfile                                 |  22 +-
 doc/new-conversions.html                      | 326 +++++++
 doc/new-conversions.txt                       | 111 +++
 example/simple_vector.cpp                     |   2 +-
 include/boost/python/call.hpp                 | 210 +++++
 include/boost/python/classes.hpp              |   6 +-
 include/boost/python/conversions.hpp          |  53 +-
 include/boost/python/convert.hpp              |  84 ++
 include/boost/python/converter/body.hpp       |  68 ++
 include/boost/python/converter/class.hpp      |  56 ++
 include/boost/python/converter/handle.hpp     |  91 ++
 .../boost/python/converter/registration.hpp   |  83 ++
 include/boost/python/converter/registry.hpp   |  74 ++
 include/boost/python/converter/source.hpp     |  80 ++
 .../boost/python/converter/source_holder.hpp  |  24 +
 include/boost/python/converter/target.hpp     | 173 ++++
 include/boost/python/converter/type_id.hpp    | 200 +++++
 include/boost/python/converter/unwrap.hpp     | 192 ++++
 include/boost/python/converter/unwrapper.hpp  |  53 ++
 .../boost/python/converter/unwrapper_base.hpp |  25 +
 include/boost/python/converter/wrap.hpp       | 145 +++
 include/boost/python/converter/wrapper.hpp    |  69 ++
 include/boost/python/cross_module.hpp         | 110 +--
 .../boost/python/detail/arg_tuple_size.hpp    | 233 +++++
 include/boost/python/detail/base_object.hpp   |   6 +-
 include/boost/python/detail/call_object.hpp   |  66 ++
 include/boost/python/detail/caller.hpp        |  27 +
 include/boost/python/detail/config.hpp        |  18 +-
 .../python/detail/python_library_include.hpp  |   1 +
 include/boost/python/detail/returning.hpp     | 846 ++++++++++++++++++
 include/boost/python/detail/types.hpp         |   4 -
 include/boost/python/detail/void_adaptor.hpp  |   2 +-
 include/boost/python/detail/wrap_python.hpp   |  46 +-
 include/boost/python/errors.hpp               |  42 +-
 include/boost/python/export.hpp               |  20 +
 include/boost/python/make_function.hpp        |  40 +
 include/boost/python/module.hpp               |  12 +
 include/boost/python/module_builder.hpp       |  39 +-
 include/boost/python/object/class.hpp         | 103 +++
 .../boost/python/object/class_unwrapper.hpp   |  40 +
 include/boost/python/object/construct.hpp     |  24 +
 include/boost/python/object/forward.hpp       |  33 +
 include/boost/python/object/function.hpp      |  36 +
 include/boost/python/object/make_holder.hpp   | 124 +++
 include/boost/python/object/value_holder.hpp  |  80 ++
 include/boost/python/objects.hpp              | 223 +++--
 include/boost/python/operators.hpp            |   2 +-
 src/classes.cpp                               |   4 +-
 src/conversions.cpp                           |  99 +-
 src/converter/body.cpp                        |  18 +
 src/converter/handle.cpp                      |  35 +
 src/converter/registry.cpp                    | 177 ++++
 src/converter/type_id.cpp                     |  67 ++
 src/converter/unwrap.cpp                      |  35 +
 src/converter/unwrapper.cpp                   |  24 +
 src/converter/wrapper.cpp                     |  30 +
 src/cross_module.cpp                          | 117 +--
 src/errors.cpp                                |  68 ++
 src/extension_class.cpp                       |  25 +-
 src/gen_call.py                               |  82 ++
 src/gen_returning.py                          | 191 ++++
 src/module_builder.cpp                        |  16 +-
 src/object/class.cpp                          | 165 ++++
 src/object/function.cpp                       |  95 ++
 src/objects.cpp                               | 126 +--
 src/types.cpp                                 | 126 +--
 test/complicated.hpp                          |  39 +
 test/m1.cpp                                   | 281 ++++++
 test/m2.cpp                                   | 197 ++++
 test/module_tail.cpp                          |  39 +
 test/newtest.py                               |  95 ++
 test/simple_type.hpp                          |  14 +
 73 files changed, 5947 insertions(+), 581 deletions(-)
 create mode 100644 Jamfile
 create mode 100644 doc/new-conversions.html
 create mode 100644 doc/new-conversions.txt
 create mode 100644 include/boost/python/call.hpp
 create mode 100644 include/boost/python/convert.hpp
 create mode 100644 include/boost/python/converter/body.hpp
 create mode 100644 include/boost/python/converter/class.hpp
 create mode 100644 include/boost/python/converter/handle.hpp
 create mode 100644 include/boost/python/converter/registration.hpp
 create mode 100644 include/boost/python/converter/registry.hpp
 create mode 100644 include/boost/python/converter/source.hpp
 create mode 100644 include/boost/python/converter/source_holder.hpp
 create mode 100644 include/boost/python/converter/target.hpp
 create mode 100644 include/boost/python/converter/type_id.hpp
 create mode 100644 include/boost/python/converter/unwrap.hpp
 create mode 100644 include/boost/python/converter/unwrapper.hpp
 create mode 100644 include/boost/python/converter/unwrapper_base.hpp
 create mode 100644 include/boost/python/converter/wrap.hpp
 create mode 100644 include/boost/python/converter/wrapper.hpp
 create mode 100644 include/boost/python/detail/arg_tuple_size.hpp
 create mode 100644 include/boost/python/detail/call_object.hpp
 create mode 100644 include/boost/python/detail/caller.hpp
 create mode 100644 include/boost/python/detail/returning.hpp
 create mode 100644 include/boost/python/export.hpp
 create mode 100644 include/boost/python/make_function.hpp
 create mode 100644 include/boost/python/module.hpp
 create mode 100644 include/boost/python/object/class.hpp
 create mode 100644 include/boost/python/object/class_unwrapper.hpp
 create mode 100644 include/boost/python/object/construct.hpp
 create mode 100644 include/boost/python/object/forward.hpp
 create mode 100644 include/boost/python/object/function.hpp
 create mode 100644 include/boost/python/object/make_holder.hpp
 create mode 100644 include/boost/python/object/value_holder.hpp
 create mode 100644 src/converter/body.cpp
 create mode 100644 src/converter/handle.cpp
 create mode 100644 src/converter/registry.cpp
 create mode 100644 src/converter/type_id.cpp
 create mode 100644 src/converter/unwrap.cpp
 create mode 100644 src/converter/unwrapper.cpp
 create mode 100644 src/converter/wrapper.cpp
 create mode 100644 src/errors.cpp
 create mode 100644 src/gen_call.py
 create mode 100644 src/gen_returning.py
 create mode 100644 src/object/class.cpp
 create mode 100644 src/object/function.cpp
 create mode 100644 test/complicated.hpp
 create mode 100644 test/m1.cpp
 create mode 100644 test/m2.cpp
 create mode 100644 test/module_tail.cpp
 create mode 100644 test/newtest.py
 create mode 100644 test/simple_type.hpp

diff --git a/Jamfile b/Jamfile
new file mode 100644
index 00000000..18372684
--- /dev/null
+++ b/Jamfile
@@ -0,0 +1,39 @@
+subproject libs/python ;
+
+# bring in the rules for python
+SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
+include <module@>python.jam ;
+
+PYTHON_PROPERTIES 
+  += <metrowerks><*><cxxflags>"-inline deferred" 
+  <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
+    <define>BOOST_PYTHON_DYNAMIC_LIB
+  ;
+
+
+dll bpl
+  : 
+  src/converter/body.cpp
+  src/converter/handle.cpp
+  src/converter/registry.cpp
+  src/converter/wrapper.cpp
+  src/converter/unwrap.cpp
+  src/converter/unwrapper.cpp
+  src/converter/type_id.cpp
+  src/object/class.cpp
+  src/object/function.cpp
+  src/errors.cpp
+  :
+  $(PYTHON_PROPERTIES)
+    <define>BOOST_PYTHON_SOURCE
+  ;
+
+extension m1 : test/m1.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
+    : 
+    : debug-python ;
+
+extension m2 : test/m2.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
+      : 
+      : debug-python ;
+
+boost-python-runtest try : test/newtest.py <lib>m1 <lib>m2 : : debug-python ;
\ No newline at end of file
diff --git a/build/Jamfile b/build/Jamfile
index 78d1e84a..7fd8c285 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -61,6 +61,8 @@ subproject libs/python/build ;
 SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
 include <module@>python.jam ;
 
+local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) <define>BOOST_PYTHON_DYNAMIC_LIB ;
+
 #######################
 local rule bpl-test ( test-name : sources + )
 {
@@ -75,21 +77,27 @@ local rule bpl-test ( test-name : sources + )
 
 # Base names of the source files for libboost_python
 local CPP_SOURCES =
-    types classes conversions extension_class functions 
-    init_function module_builder objects  cross_module ;
+  types classes conversions extension_class functions 
+  init_function module_builder objects cross_module errors
+  ;
 
-lib libboost_python : ../src/$(CPP_SOURCES).cpp
+lib libboost_python_static : ../src/$(CPP_SOURCES).cpp
     # requirements
     : $(BOOST_PYTHON_INCLUDES)
     <shared-linkable>true
+      <define>BOOST_PYTHON_STATIC_LIB=1
     $(PYTHON_PROPERTIES) ;
 
-dll libboost_python$(SUFDLL[1]) : ../src/$(CPP_SOURCES).cpp
+dll libboost_python
+  # $(SUFDLL[1])
+    : ../src/$(CPP_SOURCES).cpp
 	# requirements
-	: $(BOOST_PYTHON_INCLUDES)
+      : $(BOOST_PYTHON_INCLUDES)
 	<shared-linkable>true
-	<define>BOOST_RE_BUILD_DLL=1
-	$(PYTHON_PROPERTIES) ;
+        <runtime-link>dynamic
+        <define>BOOST_PYTHON_HAS_DLL_RUNTIME=1
+	$(PYTHON_PROPERTIES)
+          ;
 
 ############# comprehensive module and test ###########
 bpl-test boost_python_test
diff --git a/doc/new-conversions.html b/doc/new-conversions.html
new file mode 100644
index 00000000..cd8a5b19
--- /dev/null
+++ b/doc/new-conversions.html
@@ -0,0 +1,326 @@
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<title>A New Type Conversion Mechanism for Boost.Python</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<p><img border="0" src="../../../c++boost.gif" width="277" height="86"
+alt="boost logo"></p>
+
+<h1>A New Type Conversion Mechanism for Boost.Python</h1>
+
+<p>By <a href="../../../people/dave_abrahams.htm">David Abrahams</a>.
+
+<h2>Introduction</h2>
+
+This document describes a redesign of the mechanism for automatically
+converting objects between C++ and Python. The current implementation
+uses two functions for any type <tt>T</tt>:
+
+<blockquote><pre>
+U from_python(PyObject*, type&lt;T&gt;);
+void to_python(V);
+</pre></blockquote>
+
+where U is convertible to T and T is convertible to V. These functions
+are at the heart of C++/Python interoperability in Boost.Python, so
+why would we want to change them? There are many reasons:
+
+<h3>Bugs</h3>
+<p>Firstly, the current mechanism relies on a common C++ compiler
+bug. This is not just embarrassing: as compilers get to be more
+conformant, the library stops working. The issue, in detail, is the
+use of inline friend functions in templates to generate
+conversions. It is a very powerful, and legal technique as long as
+it's used correctly:
+
+<blockquote><pre>
+template &lt;class Derived&gt;
+struct add_some_functions
+{
+     friend <i>return-type</i> some_function1(..., Derived <i>cv-*-&amp;-opt</i>, ...);
+     friend <i>return-type</i> some_function2(..., Derived <i>cv-*-&amp;-opt</i>, ...);
+};
+
+template &lt;class T&gt;
+struct some_template : add_some_functions&lt;some_template&lt;T&gt; &gt;
+{
+};
+</pre></blockquote>
+
+The <tt>add_some_functions</tt> template generates free functions
+which operate on <tt>Derived</tt>, or on related types. Strictly
+speaking the related types are not just cv-qualified <tt>Derived</tt>
+values, pointers and/or references. Section 3.4.2 in the standard
+describes exactly which types you must use as parameters to these
+functions if you want the functions to be found
+(there is also a less-technical description in section 11.5.1 of
+C++PL3 <a href="#ref_1">[1]</a>). Suffice it to say that
+with the current design, the <tt>from_python</tt> and
+<tt>to_python</tt> functions are not supposed to be callable under any
+conditions!
+
+<h3>Compilation and Linking Time</h3>
+
+The conversion functions generated for each wrapped class using the
+above technique are not function templates, but regular functions. The
+upshot is that they must <i>all</i> be generated regardless of whether
+they are actually used. Generating all of those functions can slow
+down module compilation, and resolving the references can slow down
+linking.
+
+<h3>Efficiency</h3>
+
+The conversion functions are primarily used in (member) function
+wrappers to convert the arguments and return values. Being functions,
+converters have no interface which allows us to ask &quot;will the
+conversion succeed?&quot; without calling the function. Since the
+return value of the function must be the object to be passed as an
+argument, Boost.Python currently uses C++ exception-handling to detect
+an unsuccessful conversion. It's not a particularly good use of
+exception-handling, since the failure is not handled very far from
+where it occurred. More importantly, it means that C++ exceptions are
+thrown during overload resolution as we seek an overload that matches
+the arguments passed. Depending on the implementation, this approach
+can result in significant slowdowns.
+
+<p>It is also unclear that the current library generates a minimal
+amount of code for any type conversion. Many of the conversion
+functions are nontrivial, and partly because of compiler limitations,
+they are declared <tt>inline</tt>. Also, we could have done a better
+job separating the type-specific conversion code from the code which
+is type-independent.
+
+<h3>Cross-module Support</h3>
+
+The current strategy requires every module to contain the definition
+of conversions it uses. In general, a new module can never supply
+conversion code which is used by another module. Ralf Grosse-Kunstleve
+designed a clever system which imports conversions directly from one
+library into another using some explicit declarations, but it has some
+disadvantages also:
+
+<ol>
+<li>The system Ullrich Koethe designed for implicit conversion between
+wrapped classes related through inheritance does not currently work if
+the classes are defined in separate modules.
+
+<li>The writer of the importing module is required to know the name of
+the module supplying the imported conversions.
+
+<li>There can be only one way to extract any given C++ type from a
+Python object in a given module.
+</ol>
+
+The first item might be addressed by moving Boost.Python into a shared
+library, but the other two cannot. Ralf turned the limitation in item
+two into a feature: the required module is loaded implicitly when a
+conversion it defines is invoked. We will probably want to provide
+that functionality anyway, but it's not clear that we should require
+the declaration of all such conversions. The final item is a more
+serious limitation. If, for example, new numeric types are defined in
+separate modules, and these types can all be converted to
+<tt>double</tt>s, we have to choose just one conversion method.
+
+<h3>Ease-of-use</h3>
+
+One persistent source of confusion for users of Boost.Python has been
+the fact that conversions for a class are not be visible at
+compile-time until the declaration of that class has been seen. When
+the user tries to expose a (member) function operating on or returning
+an instance of the class in question, compilation fails...even though
+the user goes on to expose the class in the same translation unit!
+
+<p>
+The new system lifts all compile-time checks for the existence of
+particular type conversions and replaces them with runtime checks, in
+true Pythonic style. While this might seem cavalier, the compile-time
+checks are actually not much use in the current system if many classes
+are wrapped in separate modules, since the checks are based only on
+the user's declaration that the conversions exist.
+
+<h2>The New Design</h2>
+
+<h3>Motivation</h3>
+
+The new design was heavily influenced by a desire to generate as
+little code as possible in extension modules. Some of Boost.Python's
+clients are enormous projects where link time is proportional to the
+amount of object code, and there are many Python extension modules. As
+such, we try to keep type-specific conversion code out of modules
+other than the one the converters are defined in, and rely as much as
+possible on centralized control through a shared library.
+
+<h3>The Basics</h3>
+
+The library contains a <tt>registry</tt> which maps runtime type
+identifiers (actually an extension of <tt>std::type_info</tt> which
+preserves references and constness) to entries containing type
+converters. An <tt>entry</tt> can contain only one converter from C++ to Python
+(<tt>wrapper</tt>), but many converters from Python to C++
+(<tt>unwrapper</tt>s). <font color="#ff0000">What should happen if
+multiple modules try to register wrappers for the same type?</font>. Wrappers
+and unwrappers are known as <tt>body</tt> objects, and are accessed
+by the user and the library (in its function-wrapping code) through
+corresponding <tt>handle</tt> (<tt>wrap&lt;T&gt;</tt> and
+<tt>unwrap&lt;T&gt;</tt>) objects. The <tt>handle</tt> objects are
+extremely lightweight, and delegate <i>all</i> of their operations to
+the corresponding <tt>body</tt>.
+
+<p>
+When a <tt>handle</tt> object is constructed, it accesses the
+registry to find a corresponding <tt>body</tt> that can convert the
+handle's constructor argument. Actually the registry record for any
+type
+<tt>T</tt>used in a module is looked up only once and stored in a
+static <tt>registration&lt;T&gt;</tt> object for efficiency. For
+example, if the handle is an <tt>unwrap&lt;Foo&amp;&gt;</tt> object,
+the <tt>entry</tt> for <tt>Foo&amp;</tt> is looked up in the
+<tt>registry</tt>, and each <tt>unwrapper</tt> it contains is queried
+to determine if it can convert the
+<tt>PyObject*</tt> with which the <tt>unwrap</tt> was constructed. If
+a body object which can perform the conversion is found, a pointer to
+it is stored in the handle. A body object may at any point store
+additional data in the handle to speed up the conversion process.
+
+<p>
+Now that the handle has been constructed, the user can ask it whether
+the conversion can be performed. All handles can be tested as though
+they were convertible to <tt>bool</tt>; a <tt>true</tt> value
+indicates success. If the user forges ahead and tries to do the
+conversion without checking when no conversion is possible, an
+exception will be thrown as usual. The conversion itself is performed
+by the body object. 
+
+<h3>Handling complex conversions</h3>
+
+<p>Some conversions may require a dynamic allocation. For example,
+when a Python tuple is converted to a <tt>std::vector&lt;double&gt;
+const&amp;</tt>, we need some storage into which to construct the
+vector so that a reference to it can be formed. Furthermore, multiple
+conversions of the same type may need to be &quot;active&quot;
+simultaneously, so we can't keep a single copy of the storage
+anywhere. We could keep the storage in the <tt>body</tt> object, and
+have the body clone itself in case the storage is used, but in that
+case the storage in the body which lives in the registry is never
+used. If the storage was actually an object of the target type (the
+safest way in C++), we'd have to find a way to construct one for the
+body in the registry, since it may not have a default constructor.
+
+<p>
+The most obvious way out of this quagmire is to allocate the object using a
+<i>new-expression</i>, and store a pointer to it in the handle. Since
+the <tt>body</tt> object knows everything about the data it needs to
+allocate (if any), it is also given responsibility for destroying that
+data. When the <tt>handle</tt> is destroyed it asks the <tt>body</tt>
+object to tear down any data it may have stored there. In many ways,
+you can think of the <tt>body</tt> as a &quot;dynamically-determined
+vtable&quot; for the handle.
+
+<h3>Eliminating Redundancy</h3>
+
+If you look at the current Boost.Python code, you'll see that there
+are an enormous number of conversion functions generated for each
+wrapped class. For a given class <tt>T</tt>, functions are generated
+to extract the following types <tt>from_python</tt>:
+
+<blockquote><pre>
+T*
+T const*
+T const* const&amp;
+T* const&amp;
+T&amp;
+T const&amp;
+T
+std::auto_ptr&lt;T&gt;&amp;
+std::auto_ptr&lt;T&gt;
+std::auto_ptr&lt;T&gt; const&amp;
+boost::shared_ptr&lt;T&gt;&amp;
+boost::shared_ptr&lt;T&gt;
+boost::shared_ptr&lt;T&gt; const&amp;
+</pre></blockquote>
+
+Most of these are implemented in terms of just a few conversions, and
+<t>if you're lucky</t>, they will be inlined and cause no extra
+overhead. In the new system, however, a significant amount of data
+will be associated with each type that needs to be converted. We
+certainly don't want to register a separate unwrapper object for all
+of the above types.
+
+<p>Fortunately, much of the redundancy can be eliminated. For example,
+if we generate an unwrapper for <tt>T&</tt>, we don't need an
+unwrapper for <tt>T const&</tt> or <tt>T</tt>. Accordingly, the user's
+request to wrap/unwrap a given type is translated at compile-time into
+a request which helps to eliminate redundancy. The rules used to
+<tt>unwrap</tt> a type are:
+
+<ol>
+<li> Treat built-in types specially: when unwrapping a value or
+   constant reference to one of these, use a value for the target
+   type. It will bind to a const reference if neccessary, and more
+   importantly, avoids having to dynamically allocate room for
+   an lvalue of types which can be cheaply copied.
+<li>
+ Reduce everything else to a reference to an un-cv-qualified type
+   where possible. Since cv-qualification is lost on Python
+   anyway, there's no point in trying to convert to a
+   <tt>const&amp;</tt>. <font color="#ff0000">What about conversions
+   to values like the tuple-&gt;vector example above? It seems to me
+   that we don't want to make a <tt>vector&lt;double&gt;&amp;</tt>
+   (non-const) converter available for that case. We may need to
+   rethink this slightly.</font>
+</ol>
+
+<p>To handle the problem described above in item 2, we modify the
+procedure slightly. To unwrap any non-scalar <tt>T</tt>, we seek an
+unwrapper for <tt>add_reference&lt;T&gt;::type</tt>. Unwrappers for
+<tt>T&nbsp;const&amp;</tt> always return <tt>T&amp;</tt>, and are
+registered under both <tt>T&nbsp;&amp;</tt> and
+<tt>T&nbsp;const&amp;</tt>.
+
+<p>For compilers not supporting partial specialization, unwrappers for
+<tt>T&nbsp;const&amp;</tt> must return <tt>T&nbsp;const&amp;</tt>
+(since constness can't be stripped), but a separate unwrapper object
+need to be registered for <tt>T&nbsp;&amp;</tt> and
+<tt>T&nbsp;const&amp;</tt> anyway, for the same reasons.
+
+<font color="#ff0000">We may want to make it possible to compile as
+though partial specialization were unavailable even on compilers where
+it is available, in case modules could be compiled by different
+compilers with compatible ABIs (e.g. Intel C++ and MSVC6).</font>
+
+<h3>Efficient Argument Conversion</h3>
+
+Since type conversions are primarily used in function wrappers, an
+optimization is provided for the case where a group of conversions are
+used together. Each <tt>handle</tt> class has a corresponding
+&quot;<tt>_more</tt>&quot; class which does the same job, but has a
+trivial destructor. Instead of asking each &quot;<tt>_more</tt>&quot;
+handle to destroy its own body, it is linked into an endogenous list
+managed by the first (ordinary) handle. The <tt>wrap</tt> and
+<tt>unwrap</tt> destructors are responsible for traversing that list
+and asking each <tt>body</tt> class to tear down its
+<tt>handle</tt>. This mechanism is also used to determine if all of
+the argument/return-value conversions can succeed with a single
+function call in the function wrapping code. <font color="#ff0000">We
+might need to handle return values in a separate step for Python
+callbacks, since the availablility of a conversion won't be known
+until the result object is retrieved.</font>
+
+<br>
+<hr>
+<h2>References</h2>
+
+<p><a name="ref_1">[1]</a>B. Stroustrup, The C++ Programming Language
+Special Edition Addison-Wesley, ISBN 0-201-70073-5.
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %B %Y" startspan -->19 December 2001<!--webbot bot="Timestamp" endspan i-checksum="31283" --></p>
+<p>© Copyright David Abrahams, 2001</p>
+
+</body>
+
+</html>
diff --git a/doc/new-conversions.txt b/doc/new-conversions.txt
new file mode 100644
index 00000000..1540e199
--- /dev/null
+++ b/doc/new-conversions.txt
@@ -0,0 +1,111 @@
+This hierarchy contains converter handle classes.
+
+
+                +-------------+
+                | noncopyable |
+                +-------------+
+                      ^
+                      |            A common base class used so that
+             +--------+--------+   conversions can be linked into a
+             | conversion_base |   chain for efficient argument
+             +-----------------+   conversion
+                      ^
+                      |
+            +---------+-----------+
+            |                     |
++-----------+----+         +------+-------+  only used for
+| unwrap_more<T> |         | wrap_more<T> |  chaining, and don't manage any
++----------------+         +--------------+  resources.
+         ^                         ^
+         |                         |
+   +-----+-----+           +-------+-+  These converters are what users
+   | unwrap<T> |           | wrap<T> |  actually touch, but they do so
+   +-----------+           +---------+  through a type generator which
+                                        minimizes the number of converters
+                                        that must be generated, so they
+
+
+Each unwrap<T>, unwrap_more<T>, wrap<T>, wrap_more<T> converter holds
+a reference to an appropriate converter object
+
+This hierarchy contains converter body classes
+
+                                          Exposes use/release which
+                                          are needed in case the converter
+                           +-----------+  in the registry needs to be
+                           | converter |  cloned. That occurs when a
+                           +-----------+  unwrap target type is not
+                                 ^        contained within the Python object.
+                                 |
+              +------------------+-----+
+              |                        |
+     +--------+-------+ Exposes        |
+     | unwrapper_base | convertible()  |
+     +----------------+                |
+              ^                        |
+              |                        |
+     +--------+----+             +-----+-----+
+     | unwrapper<T>|             | wrapper<T>|
+     +-------------+             +-----------+
+ Exposes T convert(PyObject*)    Exposes PyObject* convert(T)
+
+
+unwrap:
+
+    constructed with a PyObject*, whose reference count is
+    incremented.
+
+    find the registry entry for the target type
+
+    look in the collection of converters for one which claims to be
+    able to convert the PyObject to the target type.
+
+    stick a pointer to the unwrapper in the unwrap object
+
+    when unwrap is queried for convertibility, it checks to see
+    if it has a pointer to an unwrapper.
+
+    on conversion, the unwrapper is asked to allocate an
+    implementation if the unwrap object isn't already holding
+    one. The unwrap object "takes ownership" of the unwrapper's
+    implementation. No memory allocation will actually take place
+    unless this is a value conversion.
+
+    on destruction, the unwrapper is asked to free any implementation
+    held by the unwrap object. No memory deallocation actually
+    takes place unless this is a value conversion
+
+    on destruction, the reference count on the held PyObject is
+    decremented.
+
+    We need to make sure that by default, you can't instantiate
+    callback<> for reference and pointer return types: although the
+    unwrappers may exist, they may convert by-value, which would cause
+    the referent to be destroyed upon return.
+
+wrap:
+
+    find the registry entry for the source type
+
+    see if there is a converter. If found, stick a pointer to it in
+    the wrap object.
+
+    when queried for convertibility, it checks to see if it has a
+    pointer to a converter.
+
+    on conversion, a reference to the target PyObject is held by the
+    converter. Generally, the PyObject will have been created by the
+    converter, but in certain cases it may be a pre-existing object,
+    whose reference count will have been incremented.
+
+    when a wrap<T> x is used to return from a C++ function,
+    x.release() is returned so that x no longer holds a reference to
+    the PyObject when destroyed.
+
+    Otherwise, on destruction, any PyObject still held has its
+    reference-count decremented.
+
+
+When a converter is created by the user, the appropriate element must
+be added to the registry; when it is destroyed, it must be removed
+from the registry.
diff --git a/example/simple_vector.cpp b/example/simple_vector.cpp
index 8c7ee0ce..e0f9e85e 100644
--- a/example/simple_vector.cpp
+++ b/example/simple_vector.cpp
@@ -91,7 +91,7 @@ BOOST_PYTHON_MODULE_INIT(simple_vector)
       vector_double(this_module, "vector_double");
 
     vector_double.def(python::constructor<>());
-    vector_double.def(python::constructor<const int>());
+    vector_double.def(python::constructor<int>());
     vector_double.def(python::constructor<python::tuple>());
     vector_double.def(&std::vector<double>::size, "__len__");
     vector_double.def(getitem, "__getitem__");
diff --git a/include/boost/python/call.hpp b/include/boost/python/call.hpp
new file mode 100644
index 00000000..bdda879d
--- /dev/null
+++ b/include/boost/python/call.hpp
@@ -0,0 +1,210 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for 5-argument member functions and 6-argument free
+//  functions by gen_call.py
+
+#ifndef CALL_DWA20011214_HPP
+# define CALL_DWA20011214_HPP
+
+# include <boost/python/detail/returning.hpp>
+
+namespace boost { namespace python { 
+
+template <class R>
+PyObject* call(R (*f)(), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0>
+PyObject* call(R (*f)(A0), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1>
+PyObject* call(R (*f)(A0, A1), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2>
+PyObject* call(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+PyObject* call(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+PyObject* call(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+PyObject* call(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+// Member functions
+template <class R, class A0>
+PyObject* call(R (A0::*f)(), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1>
+PyObject* call(R (A0::*f)(A1), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2>
+PyObject* call(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+PyObject* call(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0>
+PyObject* call(R (A0::*f)() const, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1>
+PyObject* call(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2>
+PyObject* call(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+PyObject* call(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0>
+PyObject* call(R (A0::*f)() volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1>
+PyObject* call(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2>
+PyObject* call(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+PyObject* call(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0>
+PyObject* call(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1>
+PyObject* call(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2>
+PyObject* call(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+PyObject* call(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+
+}} // namespace boost::python
+
+#endif // CALL_DWA20011214_HPP
+
diff --git a/include/boost/python/classes.hpp b/include/boost/python/classes.hpp
index f88f1000..548a57db 100644
--- a/include/boost/python/classes.hpp
+++ b/include/boost/python/classes.hpp
@@ -20,7 +20,7 @@
 namespace boost { namespace python {
 
 // A simple type which acts something like a built-in Python class obj.
-class instance
+class BOOST_PYTHON_DECL instance
     : public boost::python::detail::python_object
 {
  public:
@@ -105,7 +105,7 @@ class instance
 template <class T> class meta_class;
 
 namespace detail {
-  class class_base : public type_object_base
+  class BOOST_PYTHON_DECL class_base : public type_object_base
   {
    public:
       class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space);
@@ -344,7 +344,7 @@ int class_t<T>::instance_mapping_ass_subscript(PyObject* obj, PyObject* key, PyO
     return 0;
 }
 
-void adjust_slice_indices(PyObject* obj, int& start, int& finish);
+void BOOST_PYTHON_DECL adjust_slice_indices(PyObject* obj, int& start, int& finish);
 
 template <class T>
 PyObject* class_t<T>::instance_sequence_slice(PyObject* obj, int start, int finish) const
diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index c1a7d390..aa07547f 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -122,61 +122,68 @@ BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 // Converters
 //
 PyObject* to_python(long);
-long from_python(PyObject* p, boost::python::type<long>);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(unsigned long);
+BOOST_PYTHON_DECL unsigned long from_python(PyObject* p, boost::python::type<unsigned long>);
 unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>);
 
 PyObject* to_python(int);
-int from_python(PyObject*, boost::python::type<int>);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(unsigned int);
+BOOST_PYTHON_DECL unsigned int from_python(PyObject*, boost::python::type<unsigned int>);
 unsigned int from_python(PyObject*, boost::python::type<const unsigned int&>);
 
 PyObject* to_python(short);
-short from_python(PyObject*, boost::python::type<short>);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(unsigned short);
+BOOST_PYTHON_DECL unsigned short from_python(PyObject*, boost::python::type<unsigned short>);
 unsigned short from_python(PyObject*, boost::python::type<const unsigned short&>);
 
-PyObject* to_python(char);
-char from_python(PyObject*, boost::python::type<char>);
+BOOST_PYTHON_DECL PyObject* to_python(char);
+BOOST_PYTHON_DECL char from_python(PyObject*, boost::python::type<char>);
 char from_python(PyObject*, boost::python::type<const char&>);
 
-PyObject* to_python(signed char);
-signed char from_python(PyObject*, boost::python::type<signed char>);
+BOOST_PYTHON_DECL PyObject* to_python(signed char);
+BOOST_PYTHON_DECL signed char from_python(PyObject*, boost::python::type<signed char>);
 signed char from_python(PyObject*, boost::python::type<const signed char&>);
 
-PyObject* to_python(unsigned char);
-unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
+BOOST_PYTHON_DECL PyObject* to_python(unsigned char);
+BOOST_PYTHON_DECL unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
 unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
 
+# ifndef BOOST_MSVC6_OR_EARLIER
 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>);
+# else
+BOOST_PYTHON_DECL PyObject* to_python(float);
+BOOST_PYTHON_DECL float from_python(PyObject*, boost::python::type<float>);
+BOOST_PYTHON_DECL PyObject* to_python(double);
+BOOST_PYTHON_DECL double from_python(PyObject*, boost::python::type<double>);
+# endif 
+float from_python(PyObject*, boost::python::type<const float&>);
+    
 double from_python(PyObject*, boost::python::type<const double&>);
     
 PyObject* to_python(bool);
-bool from_python(PyObject*, boost::python::type<bool>);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(void);
+BOOST_PYTHON_DECL void from_python(PyObject*, boost::python::type<void>);
 
 PyObject* to_python(const char* s);
-const char* from_python(PyObject*, boost::python::type<const char*>);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(const std::string& s);
+BOOST_PYTHON_DECL std::string from_python(PyObject*, boost::python::type<std::string>);
 std::string from_python(PyObject*, boost::python::type<const std::string&>);
 
 inline PyObject* to_python(const std::complex<float>& x)
diff --git a/include/boost/python/convert.hpp b/include/boost/python/convert.hpp
new file mode 100644
index 00000000..5614bd3b
--- /dev/null
+++ b/include/boost/python/convert.hpp
@@ -0,0 +1,84 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CONVERT_DWA20011129_HPP
+# define CONVERT_DWA20011129_HPP
+
+# include <boost/python/converter/target.hpp>
+# include <boost/python/converter/source.hpp>
+# include <boost/python/converter/wrap.hpp>
+# include <boost/python/converter/unwrap.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class T>
+  struct converter_gen
+  {
+      typedef T value_type;
+      typedef typename converter::source<value_type>::type source_t;
+      typedef converter::wrap_<source_t> wrap_t;
+      typedef converter::wrap_more_<source_t> wrap_more_t;
+
+      typedef typename converter::target<value_type>::type target_t;
+      typedef converter::unwrap_<target_t> unwrap_t;
+      typedef converter::unwrap_more_<target_t> unwrap_more_t;
+  };
+}
+
+template <class T>
+struct wrap : detail::converter_gen<T>::wrap_t
+{
+    typedef typename detail::converter_gen<T>::wrap_t base_t;
+    typedef typename detail::converter_gen<T>::source_t source_t;
+};
+
+template <class T>
+struct wrap_more : detail::converter_gen<T>::wrap_more_t
+{
+    typedef typename detail::converter_gen<T>::wrap_more_t base_t;
+    typedef typename detail::converter_gen<T>::source_t source_t;
+    wrap_more(converter::handle& prev);
+};
+
+template <class T>
+struct unwrap : detail::converter_gen<T>::unwrap_t
+{
+    typedef typename detail::converter_gen<T>::unwrap_t base_t;
+    unwrap(PyObject*);
+};
+
+template <class T>
+struct unwrap_more : detail::converter_gen<T>::unwrap_more_t
+{
+    typedef typename detail::converter_gen<T>::unwrap_more_t base_t;
+    unwrap_more(PyObject*, converter::handle& prev);
+};
+
+//
+// implementations
+//
+template <class T>
+inline wrap_more<T>::wrap_more(converter::handle& prev)
+    : base_t(prev)
+{
+}
+
+template <class T>
+inline unwrap<T>::unwrap(PyObject* source)
+    : base_t(source)
+{
+}
+
+template <class T>
+inline unwrap_more<T>::unwrap_more(PyObject* source, converter::handle& prev)
+    : base_t(source, prev)
+{
+}
+
+}} // namespace boost::python
+
+#endif // CONVERT_DWA20011129_HPP
diff --git a/include/boost/python/converter/body.hpp b/include/boost/python/converter/body.hpp
new file mode 100644
index 00000000..c8d932a0
--- /dev/null
+++ b/include/boost/python/converter/body.hpp
@@ -0,0 +1,68 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef BODY_DWA2001127_HPP
+# define BODY_DWA2001127_HPP
+# include <boost/config.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/export.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_EXPORT handle;
+
+namespace registry
+{
+  class entry;
+}
+
+struct BOOST_PYTHON_EXPORT body
+{
+ public:
+    body(type_id_t key);
+    virtual ~body() {}
+
+    // default implementation is a no-op
+    virtual void destroy_handle(handle*) const;
+
+    type_id_t key() const;
+
+ protected:
+    // true iff the registry is still alive
+    bool can_unregister() const;
+    
+ private:
+    // called when the registry is destroyed, to prevent it from being
+    // unregistered.
+    void do_not_unregister();
+    friend class registry::entry;
+    
+ private:
+    type_id_t m_key;
+    bool m_can_unregister;
+};
+
+//
+// implementations
+//
+inline body::body(type_id_t key)
+    : m_key(key)
+    , m_can_unregister(true)
+{
+}
+
+inline type_id_t body::key() const
+{
+    return m_key;
+}
+
+inline bool body::can_unregister() const
+{
+    return m_can_unregister;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // BODY_DWA2001127_HPP
diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
new file mode 100644
index 00000000..305ec448
--- /dev/null
+++ b/include/boost/python/converter/class.hpp
@@ -0,0 +1,56 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_DWA20011215_HPP
+# define CLASS_DWA20011215_HPP
+
+# include <boost/python/object/class.hpp>
+# include <boost/python/converter/unwrapper.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct class_unwrapper_base
+{
+    class_unwrapper_base(type_id_t sought_type);
+    void*
+};
+
+template <class T>
+struct class_unwrapper
+{
+    struct ref_unwrapper : unwrapper<T&>
+    {
+        bool convertible(PyObject* p) const
+        {
+            return p->ob_type == &SimpleType;
+        }
+    
+        simple const& convert(PyObject* p, void*&) const
+        {
+            return static_cast<SimpleObject*>(p)->x;
+        }
+        
+    };
+    
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    struct const_ref_unwrapper : unwrapper<T const&>
+    {
+        bool convertible(PyObject* p) const
+        {
+            return p->ob_type == &SimpleType;
+        }
+    
+        simple const& convert(PyObject* p, void*&) const
+        {
+            return static_cast<SimpleObject*>(p)->x;
+        }
+        
+    };
+# endif 
+};
+
+}}} // namespace boost::python::converter
+
+#endif // CLASS_DWA20011215_HPP
diff --git a/include/boost/python/converter/handle.hpp b/include/boost/python/converter/handle.hpp
new file mode 100644
index 00000000..16a50b38
--- /dev/null
+++ b/include/boost/python/converter/handle.hpp
@@ -0,0 +1,91 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef HANDLE_DWA20011130_HPP
+# define HANDLE_DWA20011130_HPP
+# include <boost/python/export.hpp>
+# include <boost/utility.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/export.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_EXPORT body;
+
+// The common base class for unwrap_ and wrap_ handle objects. They
+// share a common base so that handles can be linked into a chain
+// within a function wrapper which is managed by a single object.
+struct BOOST_PYTHON_EXPORT handle : boost::noncopyable
+{
+ public: // member functions
+
+    // All constructors take a body* passed from the derived class.
+    //
+    // Constructors taking a handle links this into a chain of
+    // handles, for more efficient management in function wrappers
+    handle(body* body);
+    handle(body* body, handle& prev);
+
+    // returns true iff all handles in the chain can convert their
+    // arguments
+    bool convertible() const;
+
+    // safe_bool idiom from Peter Dimov: provides handles to/from
+    // bool without enabling handles to integer types/void*.
+ private:
+    struct dummy { inline void nonnull() {} };
+    typedef void (dummy::*safe_bool)();
+ public:
+    inline operator safe_bool() const;
+    inline safe_bool operator!() const;
+    
+ protected: // member functions for derived classes
+    // Get the body we hold
+    inline body* get_body() const;
+    
+    // Release all bodies in the chain, in reverse order of
+    // initialization. Only actually called for the head of the chain.
+    void destroy();
+    
+ private:
+    // Holds implementation
+    body* m_body;
+    
+    // handle for next argument, if any.
+    handle* m_next;
+};
+
+//
+// implementations
+// 
+inline handle::handle(body* body, handle& prev)
+    : m_body(body), m_next(0)
+{
+    prev.m_next = this;
+}
+
+inline handle::handle(body* body)
+    : m_body(body), m_next(0)
+{
+}
+
+inline handle::operator handle::safe_bool() const
+{
+    return convertible() ? &dummy::nonnull : 0;
+}
+
+inline handle::safe_bool handle::operator!() const
+{
+    return convertible() ? 0 : &dummy::nonnull;
+}
+
+inline body* handle::get_body() const
+{
+    return m_body;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // HANDLE_DWA20011130_HPP
diff --git a/include/boost/python/converter/registration.hpp b/include/boost/python/converter/registration.hpp
new file mode 100644
index 00000000..0d85d1d7
--- /dev/null
+++ b/include/boost/python/converter/registration.hpp
@@ -0,0 +1,83 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef REGISTRATION_DWA20011130_HPP
+# define REGISTRATION_DWA20011130_HPP
+# include <boost/config.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/export.hpp>
+# ifdef BOOST_PYTHON_TRACE
+#  include <iostream>
+# endif 
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_EXPORT wrapper_base;
+struct BOOST_PYTHON_EXPORT unwrapper_base;
+
+// This class is really sort of a "templated namespace". It manages a
+// static data member which refers to the registry entry for T. This
+// reference is acquired once to reduce the burden of multiple
+// dictionary lookups at runtime.
+template <class T>
+struct registration
+{
+ public: // member functions
+    // Return a converter which can convert the given Python object to
+    // T, or 0 if no such converter exists
+    static unwrapper_base* unwrapper(PyObject*);
+
+    // Return a converter which can convert T to a Python object, or 0
+    // if no such converter exists
+    static wrapper_base* wrapper();
+
+ private: // helper functions
+    static registry::entry* entry();
+    static registry::entry* find_entry();
+    
+ private: // data members
+    static registry::entry* m_registry_entry;
+};
+
+// because this is static POD data it will be initialized to zero
+template <class T>
+registry::entry* registration<T>::m_registry_entry;
+
+template <class T>
+registry::entry* registration<T>::find_entry()
+{
+    return registry::find(type_id<T>());
+}
+
+template <class T>
+inline registry::entry* registration<T>::entry()
+{
+    if (!m_registry_entry)
+        m_registry_entry = find_entry();
+    return m_registry_entry;
+}
+
+template <class T>
+unwrapper_base* registration<T>::unwrapper(PyObject* p)
+{
+# ifdef BOOST_PYTHON_TRACE
+    std::cout << "retrieving unwrapper for " << type_id<T>() << std::endl;
+# endif 
+    return entry()->unwrapper(p);
+}
+
+template <class T>
+wrapper_base* registration<T>::wrapper()
+{
+# ifdef BOOST_PYTHON_TRACE
+    std::cout << "retrieving wrapper for " << type_id<T>() << std::endl;
+# endif 
+    return entry()->wrapper();
+}
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTRATION_DWA20011130_HPP
diff --git a/include/boost/python/converter/registry.hpp b/include/boost/python/converter/registry.hpp
new file mode 100644
index 00000000..30eeba8d
--- /dev/null
+++ b/include/boost/python/converter/registry.hpp
@@ -0,0 +1,74 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+#ifndef REGISTRY_DWA20011127_HPP
+# define REGISTRY_DWA20011127_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/export.hpp>
+# include <list>
+# include <memory>
+
+namespace boost { namespace python { namespace converter {
+
+struct BOOST_PYTHON_EXPORT wrapper_base;
+struct BOOST_PYTHON_EXPORT unwrapper_base;
+
+// This namespace acts as a sort of singleton
+namespace registry
+{
+  // These are the elements stored in the registry
+  class BOOST_PYTHON_EXPORT entry
+  {
+   public: // member functions
+      entry();
+      ~entry();
+
+      // Return a converter appropriate for converting the given
+      // Python object from_python to the C++ type with which this
+      // converter is associated in the registry, or 0 if no such
+      // converter exists.
+      unwrapper_base* unwrapper(PyObject*) const;
+
+      // Return a converter appropriate for converting a C++ object
+      // whose type this entry is associated with in the registry to a
+      // Python object, or 0 if no such converter exists.
+      wrapper_base* wrapper() const;
+
+      // Conversion classes use these functions to register
+      // themselves.
+      void insert(wrapper_base&);
+      void remove(wrapper_base&);
+
+      void insert(unwrapper_base&);
+      void remove(unwrapper_base&);
+
+   private: // types
+      typedef std::list<unwrapper_base*> unwrappers;
+      
+   private: // helper functions
+      unwrappers::iterator find(unwrapper_base const&);
+      
+   private: // data members
+      
+      // The collection of from_python converters for the associated
+      // C++ type.
+      unwrappers m_unwrappers;
+
+      // The unique to_python converter for the associated C++ type.
+      converter::wrapper_base* m_wrapper;
+  };
+
+  BOOST_PYTHON_EXPORT entry* find(type_id_t);
+  
+  BOOST_PYTHON_EXPORT void insert(wrapper_base& x);
+  BOOST_PYTHON_EXPORT void insert(unwrapper_base& x);
+  BOOST_PYTHON_EXPORT void remove(wrapper_base& x);
+  BOOST_PYTHON_EXPORT void remove(unwrapper_base& x);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTRY_DWA20011127_HPP
diff --git a/include/boost/python/converter/source.hpp b/include/boost/python/converter/source.hpp
new file mode 100644
index 00000000..9af1cf49
--- /dev/null
+++ b/include/boost/python/converter/source.hpp
@@ -0,0 +1,80 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+#ifndef SOURCE_DWA20011119_HPP
+# define SOURCE_DWA20011119_HPP
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// source --
+//
+//    This type generator (see
+//    ../../../more/generic_programming.html#type_generator) is used
+//    to select the argument type to use when converting T to a PyObject*
+
+template <class T> struct source;
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+// Since for some strange reason temporaries can't be bound to const
+// volatile references (8.5.3/5 in the C++ standard), we cannot use a
+// const volatile reference as the standard for values and references.
+template <class T>
+struct source
+{
+    typedef T const& type;
+};
+
+// This will handle the following:
+//      T const volatile& -> T const volatile&
+//      T volatile& -> T const volatile&
+//      T const& -> T const&
+//      T& -> T const&
+template <class T>
+struct source<T&>
+{
+    typedef T const& type;
+};
+
+template <class T>
+struct source<T*>
+{
+    typedef T const* type;
+};
+
+template <class T>
+struct source<T* const>
+{
+    typedef T const* type;
+};
+
+// Deal with references to pointers
+template <class T>
+struct source<T*&>
+{
+    typedef T const* type;
+};
+
+template <class T>
+struct source<T* const&>
+{
+    typedef T const* type;
+};
+# else
+template <class T>
+struct source
+{
+    typedef typename add_reference<
+        typename add_const<T>::type
+    >::type type;
+};
+# endif
+
+}}} // namespace boost::python::converter
+
+#endif // SOURCE_DWA20011119_HPP
diff --git a/include/boost/python/converter/source_holder.hpp b/include/boost/python/converter/source_holder.hpp
new file mode 100644
index 00000000..f2c774f9
--- /dev/null
+++ b/include/boost/python/converter/source_holder.hpp
@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef SOURCE_HOLDER_DWA20011215_HPP
+# define SOURCE_HOLDER_DWA20011215_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+struct source_holder_base
+{
+};
+
+template <class T>
+struct source_holder : source_holder_base
+{
+    source_holder(T x) : value(x) {}
+    T value;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // SOURCE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/converter/target.hpp b/include/boost/python/converter/target.hpp
new file mode 100644
index 00000000..6effb996
--- /dev/null
+++ b/include/boost/python/converter/target.hpp
@@ -0,0 +1,173 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+#ifndef TARGET_DWA20011119_HPP
+# define TARGET_DWA20011119_HPP
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/type_traits/same_traits.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+// target --
+//
+//    This type generator (see
+//    ../../../more/generic_programming.html#type_generator) is used
+//    to select the return type of the appropriate converter for
+//    unwrapping a given type.
+
+// Strategy:
+//
+// 1. reduce everything to a common, un-cv-qualified reference
+//    type where possible. This will save on registering many different
+//    converter types.
+//
+// 2. Treat built-in types specially: when unwrapping a value or
+//    constant reference to one of these, use a value for the target
+//    type. It will bind to a const reference if neccessary, and more
+//    importantly, avoids having to dynamically allocate room for
+//    an lvalue of types which can be cheaply copied.
+//
+// In the tables below, "cv" stands for the set of all possible
+// cv-qualifications.
+
+// Target                Source
+// int                   int
+// int const&            int
+// int&                  int&
+// int volatile&         int volatile&
+// int const volatile&   int const volatile&
+
+// On compilers supporting partial specialization:
+//
+// Target                Source
+// T                     T&
+// T cv&                 T&
+// T cv*                 T*
+// T cv*const&           T*
+// T cv*&                T*& <- should this be legal?
+// T cv*volatile&        T*& <- should this be legal?
+// T cv*const volatile&  T*& <- should this be legal?
+
+// On others:
+//
+// Target                Source
+// T                     T&
+// T cv&                 T cv&
+// T cv*                 T cv*
+// T cv*cv&              T cv*cv&
+
+// As you can see, in order to handle the same range of types without
+// partial specialization, more converters need to be registered.
+
+template <class T>
+struct target
+{
+    // Some pointer types are handled in a more sophisticated way on
+    // compilers supporting partial specialization.
+    BOOST_STATIC_CONSTANT(bool, use_identity = (::boost::is_scalar<T>::value));
+
+    typedef typename mpl::select_type<
+        use_identity
+        , T
+        , typename add_reference<typename remove_cv<T>::type>::type 
+    >::type type;
+};
+
+// When partial specialization is not present, we'll simply need to
+// register many more converters.
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template <class T>
+struct target<T&>
+{
+    typedef typename remove_cv<T>::type& type;
+};
+
+template <class T>
+struct target<T*>
+{
+    typedef typename remove_cv<T>::type* type;
+};
+
+// Handle T*-cv for completeness. Function arguments in a signature
+// are never actually cv-qualified, but who knows how these converters
+// might be used, or whether compiler bugs lurk which make it seem
+// otherwise?
+template <class T>
+struct target<T* const>
+{
+    typedef typename remove_cv<T>::type* type;
+};
+
+template <class T>
+struct target<T* volatile>
+{
+    typedef typename remove_cv<T>::type* type;
+};
+
+template <class T>
+struct target<T* const volatile>
+{
+    typedef typename remove_cv<T>::type* type;
+};
+
+// non-const references to pointers should be handled by the
+// specialization for T&, above.
+template <class T>
+struct target<T* const&>
+{
+    typedef typename remove_cv<T>::type* type;
+};
+# endif
+
+// Fortunately, we can handle T const& where T is an arithmetic type
+// by explicit specialization. These specializations will cause value
+// and const& arguments to be converted to values, rather than to
+// references.
+# define  BOOST_PYTHON_UNWRAP_VALUE(T)  \
+template <>                             \
+struct target<T>                        \
+{                                       \
+    typedef T type;                     \
+};                                      \
+template <>                             \
+struct target<T const>                  \
+{                                       \
+    typedef T type;                     \
+};                                      \
+template <>                             \
+struct target<T volatile>               \
+{                                       \
+    typedef T type;                     \
+};                                      \
+template <>                             \
+struct target<T const volatile>         \
+{                                       \
+    typedef T type;                     \
+};                                      \
+template <>                             \
+struct target<T const&>                 \
+{                                       \
+    typedef T type;                     \
+}
+
+BOOST_PYTHON_UNWRAP_VALUE(char);
+BOOST_PYTHON_UNWRAP_VALUE(unsigned char);
+BOOST_PYTHON_UNWRAP_VALUE(signed char);
+BOOST_PYTHON_UNWRAP_VALUE(unsigned int);
+BOOST_PYTHON_UNWRAP_VALUE(signed int);
+BOOST_PYTHON_UNWRAP_VALUE(unsigned short);
+BOOST_PYTHON_UNWRAP_VALUE(signed short);
+BOOST_PYTHON_UNWRAP_VALUE(unsigned long);
+BOOST_PYTHON_UNWRAP_VALUE(signed long);
+BOOST_PYTHON_UNWRAP_VALUE(char const*);
+
+}}} // namespace boost::python::converter
+
+#endif // TARGET_DWA20011119_HPP
diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
new file mode 100644
index 00000000..ddc04266
--- /dev/null
+++ b/include/boost/python/converter/type_id.hpp
@@ -0,0 +1,200 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+#ifndef TYPE_ID_DWA20011127_HPP
+# define TYPE_ID_DWA20011127_HPP
+# include <boost/config.hpp>
+# include <boost/python/export.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/python/export.hpp>
+# include <boost/operators.hpp>
+# include <typeinfo>
+# include <iosfwd>
+# include <cstring>
+
+
+namespace boost { namespace python { namespace converter { 
+
+// a portable mechanism for identifying types at runtime across modules.
+
+namespace detail
+{
+  template <class T> class dummy;
+}
+
+// for this compiler at least, cross-shared-library type_info
+// comparisons don't work, so use typeid(x).name() instead. It's not
+// yet clear what the best default strategy is.
+# if defined(__GNUC__) && __GNUC__ >= 3
+#  define BOOST_PYTHON_TYPE_ID_NAME
+# endif 
+
+# if 1
+struct type_id_t : totally_ordered<type_id_t>
+{
+    enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
+    
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+typedef char const* base_id_t;
+#  else
+typedef std::type_info const* base_id_t;
+#  endif
+    
+    type_id_t(base_id_t, decoration decoration);
+
+    bool operator<(type_id_t const& rhs) const;
+    bool operator==(type_id_t const& rhs) const;
+    friend BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream&, type_id_t const&);
+    
+ private:
+    decoration m_decoration;
+    base_id_t m_base_type;
+};
+
+#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct is_reference_to_const
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_const<T const&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_volatile
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_volatile<T volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+#  else 
+template <typename V>
+struct is_const_help
+{
+    typedef typename mpl::select_type<
+        is_const<V>::value
+        , type_traits::yes_type
+        , type_traits::no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_volatile_help
+{
+    typedef typename mpl::select_type<
+        is_volatile<V>::value
+        , type_traits::yes_type
+        , type_traits::no_type
+        >::type type;
+};
+
+template <typename V>
+typename is_const_help<V>::type reference_to_const_helper(V&);
+    
+type_traits::no_type
+reference_to_const_helper(...);
+
+template <class T>
+struct is_reference_to_const
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(reference_to_const_helper(t)) == sizeof(type_traits::yes_type));
+};
+
+template <typename V>
+typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
+type_traits::no_type reference_to_volatile_helper(...);
+
+template <class T>
+struct is_reference_to_volatile
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(reference_to_volatile_helper(t)) == sizeof(type_traits::yes_type));
+};
+#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
+
+template <class T>
+inline type_id_t type_id(detail::dummy<T>* = 0)
+{
+    return type_id_t(
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+        typeid(T).name()
+#  else
+        &typeid(T)
+#  endif 
+        , type_id_t::decoration(
+            (is_const<T>::value || is_reference_to_const<T>::value
+             ? type_id_t::const_ : 0)
+            | (is_volatile<T>::value || is_reference_to_volatile<T>::value
+               ? type_id_t::volatile_ : 0)
+            | (is_reference<T>::value ? type_id_t::reference : 0)
+            )
+        );
+}
+
+inline type_id_t::type_id_t(base_id_t base_t, decoration decoration)
+    : m_decoration(decoration)
+    , m_base_type(base_t)
+{
+}
+
+inline bool type_id_t::operator<(type_id_t const& rhs) const
+{
+    return m_decoration < rhs.m_decoration
+        || m_decoration == rhs.m_decoration
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+           && std::strcmp(m_base_type, rhs.m_base_type) < 0;
+#  else
+           && m_base_type->before(*rhs.m_base_type);
+#  endif 
+}
+
+inline bool type_id_t::operator==(type_id_t const& rhs) const
+{
+    return m_decoration == rhs.m_decoration
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+        && !std::strcmp(m_base_type, rhs.m_base_type);
+#  else
+        && *m_base_type == *rhs.m_base_type;
+#  endif 
+}
+
+# else 
+// This is the type which is used to identify a type
+typedef char const* type_id_t;
+
+// This is a workaround for a silly MSVC bug
+// Converts a compile-time type to its corresponding runtime identifier.
+template <class T>
+type_id_t type_id(detail::dummy<T>* = 0)
+{
+    return typeid(T).name();
+}
+# endif 
+
+struct BOOST_PYTHON_EXPORT type_id_before
+{
+    bool operator()(type_id_t const& x, type_id_t const& y) const;
+};
+
+BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream&, type_id_t const&);
+
+}}} // namespace boost::python::converter
+
+#endif // TYPE_ID_DWA20011127_HPP
diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
new file mode 100644
index 00000000..6dda61fb
--- /dev/null
+++ b/include/boost/python/converter/unwrap.hpp
@@ -0,0 +1,192 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef UNWRAP_BASE_DWA20011130_HPP
+# define UNWRAP_BASE_DWA20011130_HPP
+
+# include <boost/python/converter/unwrapper_base.hpp>
+# include <boost/python/converter/unwrapper.hpp>
+# include <boost/python/converter/handle.hpp>
+# include <boost/python/converter/registration.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/export.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct unwrapper;
+struct BOOST_PYTHON_EXPORT body;
+
+struct BOOST_PYTHON_EXPORT unwrap_base : handle
+{
+ public: // member functions
+    inline unwrap_base(PyObject* source, body*, handle& prev);
+    inline unwrap_base(PyObject* source, body*);
+    inline PyObject* source() const;
+
+ private: // data members
+    PyObject* m_source;
+};
+
+// These converters will be used by the function wrappers. They don't
+// manage any resources, but are instead linked into a chain which is
+// managed by an instance of unwrap_ or wrap_.
+template <class T>
+struct unwrap_more_ : unwrap_base
+{
+ public: // member functions
+    // Construction
+    unwrap_more_(PyObject* source, handle& prev);
+
+    // invoke the conversion or throw an exception if unsuccessful
+    T operator*();
+
+ protected: // constructor
+    // this constructor is only for the use of unwrap_
+    unwrap_more_(PyObject* source);
+
+ private: // helper functions
+    // Return the unwrapper which will convert the given Python object
+    // to T, or 0 if no such converter exists
+    static unwrapper_base* lookup(PyObject*);
+
+ private:
+    // unspecified storage which may be allocated by the unwrapper to
+    // do value conversions.
+    mutable void* m_storage;
+    friend class unwrapper<T>;
+};
+
+// specialization for PyObject*
+template <>
+struct unwrap_more_<PyObject*>
+    : unwrap_base
+{
+ public: // member functions
+    // Construction
+    unwrap_more_(PyObject* source, handle& prev)
+        : unwrap_base(source, m_unwrapper, prev)
+    {
+    }
+
+
+    // invoke the conversion or throw an exception if unsuccessful
+    PyObject* operator*()
+    {
+        return source();
+    }
+        
+    bool convertible(PyObject*) const
+    {
+        return true;
+    }
+    
+ protected: // constructor
+    // this constructor is only for the use of unwrap_
+    unwrap_more_(PyObject* source)
+    : unwrap_base(source, m_unwrapper)
+
+    {
+    }
+ private:
+    static BOOST_PYTHON_EXPORT unwrapper_base* m_unwrapper;
+};
+
+template <class T>
+struct unwrap_ : unwrap_more_<T>
+{
+    unwrap_(PyObject* source);
+    ~unwrap_();
+};
+
+//
+// implementations
+//
+inline unwrap_base::unwrap_base(PyObject* source, body* body, handle& prev)
+    : handle(body, prev)
+    , m_source(source)
+{
+}
+
+inline unwrap_base::unwrap_base(PyObject* source, body* body)
+    : handle(body)
+    , m_source(source)
+{
+}
+
+inline PyObject* unwrap_base::source() const
+{
+    return m_source;
+}
+
+template <class T>
+inline unwrapper_base* unwrap_more_<T>::lookup(PyObject* source)
+{
+    // Find the converters registered for T and get a unwrapper
+    // appropriate for the source object
+    return registration<T>::unwrapper(source);
+}
+
+template <class T>
+unwrap_more_<T>::unwrap_more_(PyObject* source, handle& prev)
+    : unwrap_base(source, lookup(source), prev)
+    , m_storage(0)
+{
+}
+
+template <class T>
+unwrap_more_<T>::unwrap_more_(PyObject* source)
+    : unwrap_base(source, lookup(source))
+    , m_storage(0)
+{
+}
+
+# if 0
+template <>
+inline unwrap_more_<PyObject*>::unwrap_more_(PyObject* source, handle& prev)
+    : unwrap_base(source, m_unwrapper, prev)
+{
+}
+
+template <>
+inline unwrap_more_<PyObject*>::unwrap_more_(PyObject* source)
+    : unwrap_base(source, m_unwrapper)
+
+{
+}
+
+template <>
+inline PyObject* unwrap_more_<PyObject*>::operator*()
+{
+    return source();
+}
+
+template <>
+inline bool unwrap_more_<PyObject*>::convertible(PyObject*) const
+{
+    return true;
+}
+# endif 
+template <class T>
+inline unwrap_<T>::unwrap_(PyObject* source)
+    : unwrap_more_<T>(source)
+{
+}
+
+template <class T>
+T unwrap_more_<T>::operator*()
+{
+    return static_cast<unwrapper<T>*>(
+        get_body())->do_conversion(this);
+}
+
+template <class T>
+unwrap_<T>::~unwrap_()
+{
+    destroy();
+}
+    
+}}} // namespace boost::python::converter
+
+#endif // UNWRAP_BASE_DWA20011130_HPP
diff --git a/include/boost/python/converter/unwrapper.hpp b/include/boost/python/converter/unwrapper.hpp
new file mode 100644
index 00000000..a30ff522
--- /dev/null
+++ b/include/boost/python/converter/unwrapper.hpp
@@ -0,0 +1,53 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef UNWRAPPER_DWA2001127_HPP
+# define UNWRAPPER_DWA2001127_HPP
+
+# include <boost/python/converter/unwrapper_base.hpp>
+# include <boost/python/converter/unwrap.hpp>
+# include <boost/python/converter/body.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct unwrap_more_;
+
+// Abstract base for all unwrappers of Ts
+template <class T>
+struct unwrapper : unwrapper_base
+{
+ public:
+    unwrapper();
+
+    T do_conversion(unwrap_more_<T> const* handle) const;
+    
+ private:
+    virtual T convert(PyObject*, void*&) const = 0;
+    
+ private: // body required interface implementation
+    void destroy_handle(handle*) const {}
+};
+
+//
+// implementations
+//
+template <class T>
+unwrapper<T>::unwrapper()
+    : unwrapper_base(type_id<T>())
+{
+}
+
+// We could think about making this virtual in an effort to get its
+// code generated in the module where the unwrapper is defined, but
+// it's not clear that it's a good tradeoff.
+template <class T>
+T unwrapper<T>::do_conversion(unwrap_more_<T> const* handle) const
+{
+    return convert(handle->source(), handle->m_storage);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // UNWRAPPER_DWA2001127_HPP
diff --git a/include/boost/python/converter/unwrapper_base.hpp b/include/boost/python/converter/unwrapper_base.hpp
new file mode 100644
index 00000000..54e2e54c
--- /dev/null
+++ b/include/boost/python/converter/unwrapper_base.hpp
@@ -0,0 +1,25 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef UNWRAPPER_BASE_DWA20011215_HPP
+# define UNWRAPPER_BASE_DWA20011215_HPP
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/body.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/export.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_EXPORT unwrapper_base : body
+{
+ public:
+    unwrapper_base(type_id_t); // registers
+    ~unwrapper_base();         // unregisters
+    virtual bool convertible(PyObject*) const = 0;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // UNWRAPPER_BASE_DWA20011215_HPP
diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
new file mode 100644
index 00000000..91c9de86
--- /dev/null
+++ b/include/boost/python/converter/wrap.hpp
@@ -0,0 +1,145 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef WRAP_DWA2001127_HPP
+# define WRAP_DWA2001127_HPP
+# include <boost/python/converter/registration.hpp>
+# include <boost/python/converter/handle.hpp>
+# include <boost/python/converter/body.hpp>
+# include <boost/python/converter/wrapper.hpp>
+# include <boost/python/export.hpp>
+# include <boost/python/converter/source_holder.hpp>
+# include <cassert>
+
+namespace boost { namespace python { namespace converter { 
+
+struct BOOST_PYTHON_EXPORT wrapper_base;
+
+template <class T> struct wrapper;
+
+struct wrap_base : handle
+{
+ public: // member functions
+    wrap_base(body*, handle& prev);
+    wrap_base(body*);
+    PyObject* release();
+    
+ public: // accessor, really only for wrappers
+    PyObject*& target() const;
+    
+ protected:
+    void hold_result(PyObject*) const;
+    
+ private: 
+    mutable PyObject* m_target;
+};
+
+template <class T>
+struct wrap_more_ : wrap_base
+{
+ protected:
+    typedef T source_t;
+    
+ public: // member functions
+    wrap_more_(handle& prev);
+
+    PyObject* operator()(source_t) const;
+
+ protected: // constructor for wrap_<T>, below
+    wrap_more_();
+    
+ private: // helper functions
+    static wrapper_base* lookup();
+    
+ private:
+    friend class wrapper<T>;
+};
+
+template <class T>
+struct wrap_ : wrap_more_<T>
+{
+    typedef typename wrap_more_<T>::source_t source_t;
+ public: // member functions
+    wrap_();
+    ~wrap_();
+};
+
+//
+// implementations
+//
+
+inline wrap_base::wrap_base(body* body, handle& prev)
+    : handle(body, prev),
+      m_target(0)
+{
+}
+
+inline wrap_base::wrap_base(body* body)
+    : handle(body),
+      m_target(0)
+{
+}
+
+inline PyObject*& wrap_base::target() const
+{
+    return m_target;
+}
+
+inline void wrap_base::hold_result(PyObject* p) const
+{
+    assert(m_target == 0);
+    m_target = p;
+}
+
+inline PyObject* wrap_base::release()
+{
+    PyObject* result = m_target;
+    m_target = 0;
+    return result;
+}
+
+template <class T>
+inline wrapper_base* wrap_more_<T>::lookup()
+{
+    // Find the converters registered for T and get a wrapper
+    // appropriate for the source object
+    return registration<T>::wrapper();
+}
+
+template <class T>
+inline wrap_more_<T>::wrap_more_(handle& prev)
+    : wrap_base(lookup(), prev)
+{
+    
+}
+
+template <class T>
+PyObject* wrap_more_<T>::operator()(source_t x) const
+{
+    return static_cast<wrapper<T>*>(
+        get_body())->do_conversion(*this, source_holder<T>(x));
+}
+
+template <class T>
+wrap_more_<T>::wrap_more_()
+    : wrap_base(lookup())
+{
+}
+
+template <class T>
+wrap_<T>::wrap_()
+    : wrap_more_<T>()
+{
+}
+
+template <class T>
+wrap_<T>::~wrap_()
+{
+    destroy();
+}
+
+}}} // namespace boost::python::converter
+
+#endif // WRAP_DWA2001127_HPP
diff --git a/include/boost/python/converter/wrapper.hpp b/include/boost/python/converter/wrapper.hpp
new file mode 100644
index 00000000..ada5e8cb
--- /dev/null
+++ b/include/boost/python/converter/wrapper.hpp
@@ -0,0 +1,69 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef WRAPPER_DWA2001127_HPP
+# define WRAPPER_DWA2001127_HPP
+# include <boost/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/body.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/wrap.hpp>
+# include <boost/python/converter/source_holder.hpp>
+# include <boost/python/export.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct source_holder_base;
+struct wrap_base;
+template <class T> struct wrap_more_;
+
+struct BOOST_PYTHON_EXPORT wrapper_base : body
+{
+ public:
+    wrapper_base(type_id_t); // registers
+    ~wrapper_base();         // unregisters
+    
+    virtual PyObject* do_conversion(wrap_base const&, source_holder_base const&) const = 0;
+};
+
+template <class T>
+struct wrapper : wrapper_base
+{
+ public:
+    wrapper();
+    
+    PyObject* do_conversion(wrap_base const&, source_holder_base const&) const;
+    
+    // This does the actual conversion
+    virtual PyObject* convert(T source) const = 0;
+};
+
+//
+// implementations
+//
+
+template <class T>
+wrapper<T>::wrapper()
+    : wrapper_base(type_id<T>())
+{
+}
+
+
+template <class T>
+PyObject* wrapper<T>::do_conversion(wrap_base const& handle_, source_holder_base const& data_) const
+{
+    // Casting pointers instead of references suppresses a CWPro7 bug.
+    wrap_more_<T> const& handle = *static_cast<wrap_more_<T> const*>(&handle_);
+    source_holder<T> const& data = *static_cast<source_holder<T> const*>(&data_);
+    if (handle.target() == 0)
+    {
+        handle.hold_result(convert(data.value));
+    }
+    return handle.target();
+}
+
+}}} // namespace boost::python::converter
+
+#endif // WRAPPER_DWA2001127_HPP
diff --git a/include/boost/python/cross_module.hpp b/include/boost/python/cross_module.hpp
index dd1c47d2..f5ca315d 100644
--- a/include/boost/python/cross_module.hpp
+++ b/include/boost/python/cross_module.hpp
@@ -18,26 +18,28 @@
 # include <boost/python/class_builder.hpp>
 
 namespace boost { namespace python {
-    struct import_error : error_already_set {};
-    struct export_error : error_already_set {};
-}}
+    struct BOOST_PYTHON_DECL import_error: error_already_set {};
+    struct BOOST_PYTHON_DECL export_error : error_already_set {};
 
-namespace boost { namespace python { namespace detail {
+namespace detail
+{
 
 // Concept: throw exception if api_major is changed
 //          show warning on stderr if api_minor is changed
-const int export_converters_api_major = 4;
-const int export_converters_api_minor = 1;
-extern const char* converters_attribute_name;
-void* import_converter_object(const std::string& module_name,
-                              const std::string& py_class_name,
-                              const std::string& attribute_name);
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor);
+  const int export_converters_api_major = 4;
+  const int export_converters_api_minor = 1;
+  extern BOOST_PYTHON_DECL const char* converters_attribute_name;
+  BOOST_PYTHON_DECL void* import_converter_object(const std::string& module_name,
+                                const std::string& py_class_name,
+                                const std::string& attribute_name);
+  BOOST_PYTHON_DECL void check_export_converters_api(const int importing_major,
+                                   const int importing_minor,
+                                   const int imported_major,
+                                   const int imported_minor);
 
-}}}
+}
+
+}} // namespace boost::python
 
 // forward declaration
 namespace boost { namespace python { namespace detail {
@@ -232,56 +234,56 @@ struct export_converter_object : export_converter_object_noncopyable<T>
     }
 };
 
-namespace detail {
+namespace detail
+{
 
 /* This class template is instantiated by import_converters<T>.
    Its purpose is to import the converter_object via the Python API.
    The actual import is only done once. The pointer to the
    imported converter object is kept in the static data member
    imported_converters.
- */
-template <class T>
-class import_extension_class
-    : public python_import_extension_class_converters<T>
-{
- public:
-    inline import_extension_class(const char* module, const char* py_class) {
-      m_module = module;
-      m_py_class = py_class;
-    }
+*/
+  template <class T>
+  class import_extension_class
+      : public python_import_extension_class_converters<T>
+  {
+   public:
+      inline import_extension_class(const char* module, const char* py_class) {
+          m_module = module;
+          m_py_class = py_class;
+      }
 
-    static boost::python::export_converter_object_base<T>* get_converters();
+      static boost::python::export_converter_object_base<T>* get_converters();
 
-  private:
-    static std::string m_module;
-    static std::string m_py_class;
-    static boost::python::export_converter_object_base<T>* imported_converters;
-};
+   private:
+      static std::string m_module;
+      static std::string m_py_class;
+      static boost::python::export_converter_object_base<T>* imported_converters;
+  };
 
-template <class T> std::string import_extension_class<T>::m_module;
-template <class T> std::string import_extension_class<T>::m_py_class;
-template <class T>
-boost::python::export_converter_object_base<T>*
-import_extension_class<T>::imported_converters = 0;
+  template <class T> std::string import_extension_class<T>::m_module;
+  template <class T> std::string import_extension_class<T>::m_py_class;
+  template <class T>
+  boost::python::export_converter_object_base<T>*
+  import_extension_class<T>::imported_converters = 0;
 
-template <class T>
-boost::python::export_converter_object_base<T>*
-import_extension_class<T>::get_converters() {
-  if (imported_converters == 0) {
-    void* cobject
-      = import_converter_object(m_module, m_py_class,
-                                converters_attribute_name);
-    imported_converters
-      = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
-    check_export_converters_api(
-      export_converters_api_major,
-      export_converters_api_minor,
-      imported_converters->get_api_major(),
-      imported_converters->get_api_minor());
+  template <class T>
+  boost::python::export_converter_object_base<T>*
+  import_extension_class<T>::get_converters() {
+      if (imported_converters == 0) {
+          void* cobject
+              = import_converter_object(m_module, m_py_class,
+                                        converters_attribute_name);
+          imported_converters
+              = static_cast<boost::python::export_converter_object_base<T>*>(cobject);
+          check_export_converters_api(
+              export_converters_api_major,
+              export_converters_api_minor,
+              imported_converters->get_api_major(),
+              imported_converters->get_api_minor());
+      }
+      return imported_converters;
   }
-  return imported_converters;
-}
-
 }}} // namespace boost::python::detail
 
 namespace boost { namespace python {
diff --git a/include/boost/python/detail/arg_tuple_size.hpp b/include/boost/python/detail/arg_tuple_size.hpp
new file mode 100644
index 00000000..e6b6ccc1
--- /dev/null
+++ b/include/boost/python/detail/arg_tuple_size.hpp
@@ -0,0 +1,233 @@
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for 5-argument member functions and 6-argument free
+//  functions by gen_arg_tuple_size.python
+
+#ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
+# define ARG_TUPLE_SIZE_DWA20011201_HPP
+
+namespace boost { namespace python { namespace detail {
+
+// Computes (at compile-time) the number of elements that a Python
+// argument tuple must have in order to be passed to a wrapped C++
+// (member) function of the given type.
+template <class F> struct arg_tuple_size;
+
+# if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(__BORLANDC__)
+
+template <class R>
+struct arg_tuple_size<R (*)()>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 0);
+};
+
+template <class R, class A1>
+struct arg_tuple_size<R (*)(A1)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+};
+
+template <class R, class A1, class A2>
+struct arg_tuple_size<R (*)(A1, A2)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
+};
+
+template <class R, class A1, class A2, class A3>
+struct arg_tuple_size<R (*)(A1, A2, A3)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
+};
+
+template <class R, class A1, class A2, class A3, class A4>
+struct arg_tuple_size<R (*)(A1, A2, A3, A4)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
+};
+
+template <class R, class A1, class A2, class A3, class A4, class A5>
+struct arg_tuple_size<R (*)(A1, A2, A3, A4, A5)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
+};
+
+template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
+struct arg_tuple_size<R (*)(A1, A2, A3, A4, A5, A6)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
+};
+
+
+template <class R, class A0>
+struct arg_tuple_size<R (A0::*)()>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+};
+
+template <class R, class A0, class A1>
+struct arg_tuple_size<R (A0::*)(A1)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
+};
+
+template <class R, class A0, class A1, class A2>
+struct arg_tuple_size<R (A0::*)(A1, A2)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
+};
+
+template <class R, class A0, class A1, class A2, class A3>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5)>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
+};
+
+# else
+
+// We will use the "sizeof() trick" to work around the lack of
+// partial specialization in MSVC6 and its broken-ness in borland.
+// See http://opensource.adobe.com  or
+// http://groups.yahoo.com/group/boost/message/5441 for
+// more examples
+
+// This little package is used to transmit the number of arguments
+// from the helper functions below to the sizeof() expression below.
+// Because we can never have an array of fewer than 1 element, we
+// add 1 to n and then subtract 1 from the result of sizeof() below.
+template <int n>
+struct char_array
+{
+    char elements[n+1];
+};
+
+// The following helper functions are never actually called, since
+// they are only used within a sizeof() expression, but the type of
+// their return value is used to discriminate between various free
+// and member function pointers at compile-time.
+
+template <class R>
+char_array<0> arg_tuple_size_helper(R (*)());
+
+template <class R, class A1>
+char_array<1> arg_tuple_size_helper(R (*)(A1));
+
+template <class R, class A1, class A2>
+char_array<2> arg_tuple_size_helper(R (*)(A1, A2));
+
+template <class R, class A1, class A2, class A3>
+char_array<3> arg_tuple_size_helper(R (*)(A1, A2, A3));
+
+template <class R, class A1, class A2, class A3, class A4>
+char_array<4> arg_tuple_size_helper(R (*)(A1, A2, A3, A4));
+
+template <class R, class A1, class A2, class A3, class A4, class A5>
+char_array<5> arg_tuple_size_helper(R (*)(A1, A2, A3, A4, A5));
+
+template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
+char_array<6> arg_tuple_size_helper(R (*)(A1, A2, A3, A4, A5, A6));
+
+template <class R, class A0>
+char_array<1> arg_tuple_size_helper(R (A0::*)());
+
+template <class R, class A0, class A1>
+char_array<2> arg_tuple_size_helper(R (A0::*)(A1));
+
+template <class R, class A0, class A1, class A2>
+char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2));
+
+template <class R, class A0, class A1, class A2, class A3>
+char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3));
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4));
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5));
+
+
+template <class R, class A0>
+char_array<1> arg_tuple_size_helper(R (A0::*)() const);
+
+template <class R, class A0, class A1>
+char_array<2> arg_tuple_size_helper(R (A0::*)(A1) const);
+
+template <class R, class A0, class A1, class A2>
+char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) const);
+
+template <class R, class A0, class A1, class A2, class A3>
+char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) const);
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) const);
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) const);
+
+
+template <class R, class A0>
+char_array<1> arg_tuple_size_helper(R (A0::*)() volatile);
+
+template <class R, class A0, class A1>
+char_array<2> arg_tuple_size_helper(R (A0::*)(A1) volatile);
+
+template <class R, class A0, class A1, class A2>
+char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) volatile);
+
+template <class R, class A0, class A1, class A2, class A3>
+char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) volatile);
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) volatile);
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) volatile);
+
+
+template <class R, class A0>
+char_array<1> arg_tuple_size_helper(R (A0::*)() const volatile);
+
+template <class R, class A0, class A1>
+char_array<2> arg_tuple_size_helper(R (A0::*)(A1) const volatile);
+
+template <class R, class A0, class A1, class A2>
+char_array<3> arg_tuple_size_helper(R (A0::*)(A1, A2) const volatile);
+
+template <class R, class A0, class A1, class A2, class A3>
+char_array<4> arg_tuple_size_helper(R (A0::*)(A1, A2, A3) const volatile);
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+char_array<5> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4) const volatile);
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+char_array<6> arg_tuple_size_helper(R (A0::*)(A1, A2, A3, A4, A5) const volatile);
+
+
+template <class F>
+struct arg_tuple_size
+{
+    // The sizeof() magic happens here
+    BOOST_STATIC_CONSTANT(std::size_t, value
+      = sizeof(arg_tuple_size_helper(F(0)).elements) - 1);
+};
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+}}} // namespace boost::python::detail
+
+#endif // ARG_TUPLE_SIZE_DWA20011201_HPP
+
diff --git a/include/boost/python/detail/base_object.hpp b/include/boost/python/detail/base_object.hpp
index 19715876..d92b3972 100644
--- a/include/boost/python/detail/base_object.hpp
+++ b/include/boost/python/detail/base_object.hpp
@@ -13,7 +13,6 @@
 # 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>
 
@@ -45,10 +44,7 @@ template <class PythonType>
 base_object<PythonType>::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));
+    BOOST_CSTD_::memset(bp, 0, sizeof(base_python_type));
     Py_INCREF(type_obj);
     PyObject_INIT(bp, type_obj);
 }
diff --git a/include/boost/python/detail/call_object.hpp b/include/boost/python/detail/call_object.hpp
new file mode 100644
index 00000000..5595e5c0
--- /dev/null
+++ b/include/boost/python/detail/call_object.hpp
@@ -0,0 +1,66 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CALL_OBJECT_DWA20011222_HPP
+# define CALL_OBJECT_DWA20011222_HPP
+# include <boost/python/errors.hpp>
+# include <boost/python/detail/types.hpp>
+# include <boost/bind.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  // A function object adaptor which turns a function returning R into
+  // an "equivalent" function returning void, but taking an R& in
+  // which the adapted function's result is stored.
+  template <class R, class F>
+  struct return_by_reference
+  {
+      typedef void return_type;
+      
+      return_by_reference(R& result, F f)
+          : m_result(result)
+          , m_f(f)
+      {
+      }
+      
+      void operator()() const
+      {
+          m_result = m_f();
+      }
+      
+      R& m_result;
+      F m_f;
+  };
+
+  // An object generator for the above adaptors
+  template <class R, class F>
+  return_by_reference<R,F> bind_return(R& result, F f)
+  {
+      return return_by_reference<R,F>(result, f);
+  }
+
+  // Given a function object f with signature
+  //
+  //    R f(PyTypeObject*,PyObject*)
+  //
+  // calls f inside of handle_exception_impl, placing f's result in
+  // ret. Returns true iff an exception is thrown by f, leaving ret
+  // unmodified.
+  template <class R, class F>
+  bool call_object(R& ret, PyObject* obj, F f)
+  {
+      return handle_exception(
+          detail::bind_return(
+              ret
+              , boost::bind<R>(
+                  f, static_cast<type_object_base*>(obj->ob_type), obj)));
+  }
+} // namespace detail
+
+}} // namespace boost::python
+
+#endif // CALL_OBJECT_DWA20011222_HPP
diff --git a/include/boost/python/detail/caller.hpp b/include/boost/python/detail/caller.hpp
new file mode 100644
index 00000000..95c6dc7a
--- /dev/null
+++ b/include/boost/python/detail/caller.hpp
@@ -0,0 +1,27 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CALLER_DWA20011214_HPP
+# define CALLER_DWA20011214_HPP
+
+# include <boost/python/call.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+struct caller
+{
+    typedef PyObject* result_type;
+    
+    template <class F>
+    PyObject* operator()(F f, PyObject* args, PyObject* keywords)
+    {
+        return call(f, args, keywords);
+    }
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CALLER_DWA20011214_HPP
diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 0fc1093a..498fa07a 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -59,9 +59,9 @@
 
 # ifndef BOOST_PYTHON_MODULE_INIT
 #  if defined(_WIN32) || defined(__CYGWIN__)
-#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" __declspec(dllexport) void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
+#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" __declspec(dllexport) void init##name() { boost::python::handle_exception(&init_module_##name); } void init_module_##name()
 #  else
-#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" void init##name() { boost::python::handle_exception(init_module_##name); } void init_module_##name()
+#   define BOOST_PYTHON_MODULE_INIT(name) void init_module_##name(); extern "C" void init##name() { boost::python::handle_exception(&init_module_##name); } void init_module_##name()
 #  endif
 # endif 
 
@@ -72,23 +72,23 @@
  ****************************************************************************/
 
 // backwards compatibility:
-#ifdef BOOST_RE_STATIC_LIB
+#ifdef BOOST_PYTHON_STATIC_LIB
 #  define BOOST_PYTHON_STATIC_LINK
 #endif
 
-#if defined(BOOST_MSVC) && defined(_DLL)
+#if defined(BOOST_MSVC) && defined(_DLL) && !defined(BOOST_PYTHON_HAS_DLL_RUNTIME)
 #  define BOOST_PYTHON_HAS_DLL_RUNTIME
 #endif
 
-#if defined(__BORLANDC__) && defined(_RTLDLL)
+#if defined(__BORLANDC__) && defined(_RTLDLL) && !defined(BOOST_PYTHON_HAS_DLL_RUNTIME)
 #  define BOOST_PYTHON_HAS_DLL_RUNTIME
 #endif
 
-#if defined(__ICL) && defined(_DLL)
+#if defined(__ICL) && defined(_DLL) && !defined(BOOST_PYTHON_HAS_DLL_RUNTIME)
 #  define BOOST_PYTHON_HAS_DLL_RUNTIME
 #endif
 
-#if defined(BOOST_PYTHON_HAS_DLL_RUNTIME) && !defined(BOOST_PYTHON_STATIC_LINK)
+#if defined(BOOST_PYTHON_DYNAMIC_LIB) && defined(_WIN32) // && !defined(BOOST_PYTHON_STATIC_LINK)
 #  if defined(BOOST_PYTHON_SOURCE)
 #     define BOOST_PYTHON_DECL __declspec(dllexport)
 #     define BOOST_PYTHON_BUILD_DLL
@@ -102,7 +102,7 @@
 #endif
 
 #if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_PYTHON_NO_LIB) && !defined(BOOST_PYTHON_SOURCE)
-#  include <boost/python/detail/python_library_include.hpp>
+// #  include <boost/python/detail/python_library_include.hpp>
 #endif
 
 // Borland C++ Fix/error check:
@@ -117,7 +117,7 @@
 #        endif
 #     endif
 #     ifndef _RTLDLL
-         // this is harmless for a staic link:
+         // this is harmless for a static link:
 #        define _RWSTD_COMPILE_INSTANTIATE
 #     endif
 #  endif
diff --git a/include/boost/python/detail/python_library_include.hpp b/include/boost/python/detail/python_library_include.hpp
index 903f02be..d2b78c6e 100644
--- a/include/boost/python/detail/python_library_include.hpp
+++ b/include/boost/python/detail/python_library_include.hpp
@@ -1,3 +1,4 @@
+#error obsolete
 /*
  *
  * Copyright (c) 1998-2000
diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
new file mode 100644
index 00000000..28f1846e
--- /dev/null
+++ b/include/boost/python/detail/returning.hpp
@@ -0,0 +1,846 @@
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for 5-argument member functions and 6-argument free
+//  functions by gen_returning.py
+
+#ifndef RETURNING_DWA20011201_HPP
+# define RETURNING_DWA20011201_HPP
+
+//# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/config.hpp>
+# include <boost/python/convert.hpp>
+# include <boost/python/detail/none.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+// Calling C++ from Python
+template <class R>
+struct returning
+{
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+
+        // find the result converter
+        wrap_more<R> r(c0);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)() );
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        // find the result converter
+        wrap_more<R> r(c1);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1) );
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        // find the result converter
+        wrap_more<R> r(c2);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2) );
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        // find the result converter
+        wrap_more<R> r(c3);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        // find the result converter
+        wrap_more<R> r(c4);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        // find the result converter
+        wrap_more<R> r(c5);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+    };
+
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+
+        // find the result converter
+        wrap_more<R> r(c0);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)() );
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        // find the result converter
+        wrap_more<R> r(c1);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1) );
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        // find the result converter
+        wrap_more<R> r(c2);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2) );
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        // find the result converter
+        wrap_more<R> r(c3);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        // find the result converter
+        wrap_more<R> r(c4);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        // find the result converter
+        wrap_more<R> r(c5);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+    };
+
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+
+        // find the result converter
+        wrap_more<R> r(c0);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)() );
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        // find the result converter
+        wrap_more<R> r(c1);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1) );
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        // find the result converter
+        wrap_more<R> r(c2);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2) );
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        // find the result converter
+        wrap_more<R> r(c3);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        // find the result converter
+        wrap_more<R> r(c4);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        // find the result converter
+        wrap_more<R> r(c5);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+    };
+
+
+// missing const volatile type traits
+#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+
+        // find the result converter
+        wrap_more<R> r(c0);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)() );
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        // find the result converter
+        wrap_more<R> r(c1);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1) );
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        // find the result converter
+        wrap_more<R> r(c2);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2) );
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        // find the result converter
+        wrap_more<R> r(c3);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        // find the result converter
+        wrap_more<R> r(c4);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        // find the result converter
+        wrap_more<R> r(c5);
+        if (!c0) return 0;
+        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+    };
+
+#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+            
+    static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
+    {
+        // find the result converter
+        wrap<R> r;
+        return r( (*pf)() );
+    };
+    template <class A0>
+    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+
+        // find the result converter
+        wrap_more<R> r(c0);
+        if (!c0) return 0;
+        return r( (*pf)(*c0) );
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        // find the result converter
+        wrap_more<R> r(c1);
+        if (!c0) return 0;
+        return r( (*pf)(*c0, *c1) );
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        // find the result converter
+        wrap_more<R> r(c2);
+        if (!c0) return 0;
+        return r( (*pf)(*c0, *c1, *c2) );
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        // find the result converter
+        wrap_more<R> r(c3);
+        if (!c0) return 0;
+        return r( (*pf)(*c0, *c1, *c2, *c3) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        // find the result converter
+        wrap_more<R> r(c4);
+        if (!c0) return 0;
+        return r( (*pf)(*c0, *c1, *c2, *c3, *c4) );
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        // find the result converter
+        wrap_more<R> r(c5);
+        if (!c0) return 0;
+        return r( (*pf)(*c0, *c1, *c2, *c3, *c4, *c5) );
+    };
+};
+                           
+template <>
+struct returning<void>
+{
+    typedef void R;
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+
+        if (!c0) return 0;
+        ((*c0).*pmf)();
+        return detail::none();
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        return detail::none();
+    };
+
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+
+        if (!c0) return 0;
+        ((*c0).*pmf)();
+        return detail::none();
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        return detail::none();
+    };
+
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+
+        if (!c0) return 0;
+        ((*c0).*pmf)();
+        return detail::none();
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        return detail::none();
+    };
+
+
+// missing const volatile type traits
+#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class A0>
+    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+
+        if (!c0) return 0;
+        ((*c0).*pmf)();
+        return detail::none();
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        if (!c0) return 0;
+        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        return detail::none();
+    };
+
+#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+            
+    static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
+    {
+        (*pf)();
+        return detail::none();
+    };
+    template <class A0>
+    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+
+        if (!c0) return 0;
+        (*pf)(*c0);
+        return detail::none();
+    };
+    template <class A0, class A1>
+    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+
+        if (!c0) return 0;
+        (*pf)(*c0, *c1);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2>
+    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+
+        if (!c0) return 0;
+        (*pf)(*c0, *c1, *c2);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+
+        if (!c0) return 0;
+        (*pf)(*c0, *c1, *c2, *c3);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+
+        if (!c0) return 0;
+        (*pf)(*c0, *c1, *c2, *c3, *c4);
+        return detail::none();
+    };
+    template <class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+
+        if (!c0) return 0;
+        (*pf)(*c0, *c1, *c2, *c3, *c4, *c5);
+        return detail::none();
+    };
+};
+
+}}} // namespace boost::python::detail
+
+#endif // RETURNING_DWA20011201_HPP
+
diff --git a/include/boost/python/detail/types.hpp b/include/boost/python/detail/types.hpp
index f4e62f88..2e69d24e 100644
--- a/include/boost/python/detail/types.hpp
+++ b/include/boost/python/detail/types.hpp
@@ -31,12 +31,8 @@
 
 namespace boost { namespace python {
 
-class string;
-
 namespace detail {
 
-class instance_holder_base;
-
 class BOOST_PYTHON_DECL type_object_base : public python_type
 {
  public:
diff --git a/include/boost/python/detail/void_adaptor.hpp b/include/boost/python/detail/void_adaptor.hpp
index 3d60e4bf..3b4b2124 100644
--- a/include/boost/python/detail/void_adaptor.hpp
+++ b/include/boost/python/detail/void_adaptor.hpp
@@ -8,7 +8,7 @@
 
 namespace boost { namespace python { namespace detail {
 
-  BOOST_PYTHON_DECL extern PyObject arbitrary_object;
+  extern BOOST_PYTHON_DECL PyObject arbitrary_object;
 
   template <class T>
   struct void_adaptor
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index 34a9c2b5..d0ad5dd2 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -34,36 +34,36 @@
 // Some things we need in order to get Python.h to work with compilers other
 // than MSVC on Win32
 //
-#if defined(_WIN32)
+#if defined(_WIN32) || defined(__CYGWIN__)
 # if defined(__GNUC__) && defined(__CYGWIN__)
 #  if PY_MAJOR_VERSION < 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION <= 2
 typedef int pid_t;
 #   define WORD_BIT 32
 #   define hypot _hypot
 #   include <stdio.h>
+#   if PY_MAJOR_VERSION < 2
+#    define HAVE_CLOCK
+#    define HAVE_STRFTIME
+#    define HAVE_STRERROR
+#   endif
+#   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
 #  endif 
-#  if !defined(PY_MAJOR_VERSION) || PY_MAJOR_VERSION < 2
-#   define HAVE_CLOCK
-#   define HAVE_STRFTIME
-#   define HAVE_STRERROR
-#  endif
-#  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__)
 
diff --git a/include/boost/python/errors.hpp b/include/boost/python/errors.hpp
index 66f15587..b9eb4363 100644
--- a/include/boost/python/errors.hpp
+++ b/include/boost/python/errors.hpp
@@ -9,57 +9,31 @@
 #ifndef ERRORS_DWA052500_H_
 # define ERRORS_DWA052500_H_
 
+# include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/function.hpp>
 
 namespace boost { namespace python {
 
 struct error_already_set {};
 struct argument_error : error_already_set {};
 
-struct object_functor_base
-{
-    typedef PyObject* result_type;
-    virtual PyObject* operator()() const = 0;
- private:
-    static void* operator new(std::size_t); // don't allow dynamic allocation
-    void operator delete(void*); 
-    void operator delete(void*, size_t); 
-};
-
-template <class T>
-struct object_functor : object_functor_base
-{
-    object_functor(T const& f)
-        : m_f(f)
-    {
-    }
-    
-    PyObject* operator()() const
-    {
-        return m_f();
-    }
- private:
-    T const& m_f;
-};
-
-
 // Handles exceptions caught just before returning to Python code.
-PyObject* handle_exception_impl(object_functor_base const& f);
+// Returns true iff an exception was caught.
+BOOST_PYTHON_DECL bool handle_exception_impl(function0<void>);
 
 template <class T>
-PyObject* handle_exception(T const& f)
+bool handle_exception(T f)
 {
-    return handle_exception_impl(object_functor<T>(f));
+    return handle_exception_impl(function0<void>(boost::ref(f)));
 }
 
-void handle_exception(void (*)());
+BOOST_PYTHON_DECL PyObject* expect_non_null(PyObject* x);
 
 template <class T>
 T* expect_non_null(T* x)
 {
-    if (x == 0)
-        throw error_already_set();
-    return x;
+    return (T*)expect_non_null((PyObject*)x);
 }
 
 }} // namespace boost::python
diff --git a/include/boost/python/export.hpp b/include/boost/python/export.hpp
new file mode 100644
index 00000000..1229dffe
--- /dev/null
+++ b/include/boost/python/export.hpp
@@ -0,0 +1,20 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef EXPORT_DWA20011220_HPP
+# define EXPORT_DWA20011220_HPP
+
+# include <boost/python/detail/config.hpp>
+# ifdef _WIN32
+#  ifdef BOOST_PYTHON_SOURCE
+#   define BOOST_PYTHON_EXPORT __declspec(dllexport)
+#  else 
+#   define BOOST_PYTHON_EXPORT __declspec(dllimport)
+#  endif
+# else
+#  define BOOST_PYTHON_EXPORT
+# endif 
+
+#endif // EXPORT_DWA20011220_HPP
diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
new file mode 100644
index 00000000..d824c0a4
--- /dev/null
+++ b/include/boost/python/make_function.hpp
@@ -0,0 +1,40 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MAKE_FUNCTION_DWA20011221_HPP
+# define MAKE_FUNCTION_DWA20011221_HPP
+
+# include <boost/mpl/size.hpp>
+# include <boost/function.hpp>
+# include <boost/bind.hpp>
+# include <boost/python/object/function.hpp>
+# include <boost/python/object/make_holder.hpp>
+# include <boost/python/detail/caller.hpp>
+
+namespace boost { namespace python {
+
+template <class F>
+PyObject* make_function(F f)
+{
+    return new object::function(
+        object::py_function(
+            bind<PyObject*>(detail::caller(), f, _1, _2)));
+}
+
+template <class T, class ArgList, class Generator>
+PyObject* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
+{
+    enum { nargs = mpl::size<ArgList>::value };
+    return new object::function(
+        object::py_function(
+            bind<PyObject*>(detail::caller(),
+                 object::make_holder<nargs>
+                            ::template apply<T,Generator,ArgList>::execute
+                 , _1, _2)));
+}
+
+}} // namespace boost::python
+
+#endif // MAKE_FUNCTION_DWA20011221_HPP
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
new file mode 100644
index 00000000..c20279c3
--- /dev/null
+++ b/include/boost/python/module.hpp
@@ -0,0 +1,12 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MODULE_DWA2001128_HPP
+# define MODULE_DWA2001128_HPP
+
+# include <boost/python/errors.hpp>
+# include <boost/python/detail/config.hpp>
+
+#endif // MODULE_DWA20011221_HPP
diff --git a/include/boost/python/module_builder.hpp b/include/boost/python/module_builder.hpp
index 6a8a9b4b..180a6200 100644
--- a/include/boost/python/module_builder.hpp
+++ b/include/boost/python/module_builder.hpp
@@ -16,30 +16,18 @@
 
 namespace boost { namespace python {
 
-class module_builder
+class BOOST_PYTHON_DECL module_builder_base
 {
  public:
     // Create a module. REQUIRES: only one module_builder is created per module.
-    module_builder(const char* name);
-    ~module_builder();
+    module_builder_base(const char* name);
+    ~module_builder_base();
 
     // 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();
     
@@ -55,10 +43,29 @@ class module_builder
     static PyMethodDef initial_methods[1];
 };
 
+class module_builder : public module_builder_base
+{
+ public:
+    module_builder(const char* name)
+        : module_builder_base(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);
+    }
+};
+
 //
 // inline implementations
 //
-inline PyObject* module_builder::module() const
+inline PyObject* module_builder_base::module() const
 {
     return m_module;
 }
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
new file mode 100644
index 00000000..548d4053
--- /dev/null
+++ b/include/boost/python/object/class.hpp
@@ -0,0 +1,103 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_DWA20011214_HPP
+# define CLASS_DWA20011214_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/export.hpp>
+# include <boost/utility.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/iterator_adaptors.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+template <class T> struct holder;
+
+// Base class for all holders
+struct BOOST_PYTHON_EXPORT holder_base : noncopyable
+{
+ public:
+    holder_base(converter::type_id_t id);
+    virtual ~holder_base();
+    virtual bool held_by_value() const = 0;
+    
+    holder_base* next() const;
+    converter::type_id_t type() const;
+
+    void install(PyObject* inst);
+    
+    struct iterator_policies : default_iterator_policies
+    {
+        template <class Iterator>
+        void increment(Iterator& p)
+        {
+            p.base() = p.base()->next();
+        }
+    };
+    
+    typedef iterator_adaptor<
+        holder_base*
+        , iterator_policies
+        , value_type_is<noncopyable>
+        , reference_is<holder_base&>
+        , pointer_is<holder_base*>
+        , iterator_category_is<std::input_iterator_tag> > iterator;
+    
+ private:
+    converter::type_id_t m_type;
+    holder_base* m_next;
+};
+
+// Abstract base class which holds a Held, somehow. Provides a uniform
+// way to get a pointer to the held object
+template <class Held>
+struct holder : holder_base
+{
+    typedef Held held_type;
+    holder();
+    virtual Held* target() = 0;
+};
+
+// Each extension instance will be one of these
+struct instance
+{
+    PyObject_HEAD
+    holder_base* objects;
+};
+
+BOOST_PYTHON_EXPORT holder_base* find_holder_impl(PyObject*, converter::type_id_t);
+
+template <class T>
+holder<T>* find_holder(PyObject* p, T* = 0)
+{
+    return static_cast<holder<T>*>(find_holder_impl(p, converter::type_id<T>()));
+}
+
+BOOST_PYTHON_EXPORT PyTypeObject* class_metatype();
+BOOST_PYTHON_EXPORT PyTypeObject* class_type();
+
+//
+// implementation
+//
+inline holder_base* holder_base::next() const
+{
+    return m_next;
+}
+
+inline converter::type_id_t holder_base::type() const
+{
+    return m_type;
+}
+
+template <class Held>
+holder<Held>::holder()
+    : holder_base(converter::type_id<Held>())
+{
+}
+
+}}} // namespace boost::python::object
+
+#endif // CLASS_DWA20011214_HPP
diff --git a/include/boost/python/object/class_unwrapper.hpp b/include/boost/python/object/class_unwrapper.hpp
new file mode 100644
index 00000000..4fa441e1
--- /dev/null
+++ b/include/boost/python/object/class_unwrapper.hpp
@@ -0,0 +1,40 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_UNWRAPPER_DWA20011221_HPP
+# define CLASS_UNWRAPPER_DWA20011221_HPP
+
+# include <boost/python/object/class.hpp>
+# include <boost/python/converter/unwrapper.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+template <class T>
+struct class_unwrapper
+{
+ private:
+    template <class Target>
+    struct reference_unwrapper : converter::unwrapper<Target>
+    {
+        bool convertible(PyObject* p) const
+        {
+            return find_holder<T>(p) != 0;
+        }
+        
+        Target convert(PyObject* p, void*&) const
+        {
+            return *find_holder<T>(p)->target();
+        }
+    };
+    
+    reference_unwrapper<T&> m_reference;
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    reference_unwrapper<T const&> m_const_reference;
+# endif 
+};
+
+}}} // namespace boost::python::object
+
+#endif // CLASS_UNWRAPPER_DWA20011221_HPP
diff --git a/include/boost/python/object/construct.hpp b/include/boost/python/object/construct.hpp
new file mode 100644
index 00000000..3ff701d2
--- /dev/null
+++ b/include/boost/python/object/construct.hpp
@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CONSTRUCT_DWA20011215_HPP
+# define CONSTRUCT_DWA20011215_HPP
+
+namespace boost { namespace python { namespace object { 
+
+template <class T, class ArgList>
+struct construct
+{
+    static 
+    template <class 
+    void operator()(PyObject* args, PyObject* keywords)
+    {
+        
+    }
+};
+
+}}} // namespace boost::python::object
+
+#endif // CONSTRUCT_DWA20011215_HPP
diff --git a/include/boost/python/object/forward.hpp b/include/boost/python/object/forward.hpp
new file mode 100644
index 00000000..cc9d65bb
--- /dev/null
+++ b/include/boost/python/object/forward.hpp
@@ -0,0 +1,33 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FORWARD_DWA20011215_HPP
+# define FORWARD_DWA20011215_HPP
+
+# include <boost/mpl/select_type.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+// A little metaprogram which selects the type to pass through an
+// intermediate forwarding function when the destination argument type
+// is T.
+template <class T>
+struct forward
+{
+    typedef typename mpl::select_type<
+        is_scalar<T>::value | is_reference<T>::value
+        , T
+        , reference_wrapper<
+                typename add_const<T>::type
+          >
+    >::type type;
+};
+
+}}} // namespace boost::python::object
+
+#endif // FORWARD_DWA20011215_HPP
diff --git a/include/boost/python/object/function.hpp b/include/boost/python/object/function.hpp
new file mode 100644
index 00000000..f550e8dc
--- /dev/null
+++ b/include/boost/python/object/function.hpp
@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FUNCTION_DWA20011214_HPP
+# define FUNCTION_DWA20011214_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/export.hpp>
+# include <boost/function.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+// We use boost::function to avoid generating lots of virtual tables
+typedef boost::function2<PyObject*, PyObject*, PyObject*> py_function;
+
+struct BOOST_PYTHON_EXPORT function : PyObject
+{
+    function(py_function);
+    ~function();
+    
+    PyObject* call(PyObject*, PyObject*) const;
+ private:    
+    py_function m_fn;
+};
+
+extern BOOST_PYTHON_EXPORT PyTypeObject function_type;
+
+//
+// implementations
+//
+
+}}} // namespace boost::python::object
+
+#endif // FUNCTION_DWA20011214_HPP
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
new file mode 100644
index 00000000..fb5ec382
--- /dev/null
+++ b/include/boost/python/object/make_holder.hpp
@@ -0,0 +1,124 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MAKE_HOLDER_DWA20011215_HPP
+# define MAKE_HOLDER_DWA20011215_HPP
+
+# include <boost/mpl/at.hpp>
+# include <boost/python/object/forward.hpp>
+# include <boost/python/object/class.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+
+template <class T> struct undefined;
+template <class UnaryMetaFunction, class T>
+struct eval
+{
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
+   // based on the (non-conforming) MSVC trick from MPL
+    template<bool>
+    struct unarymetafunction_vc : UnaryMetaFunction {};
+
+    // illegal C++ which causes VC to admit that unarymetafunction_vc
+    // can have a nested template:
+    template<>
+    struct unarymetafunction_vc<true>
+    {
+        template<class> struct apply;
+    };
+
+    typedef typename unarymetafunction_vc<
+        ::boost::mpl::detail::msvc_never_true<UnaryMetaFunction>::value
+    >::template apply<T>::type type;
+# else
+    typedef typename UnaryMetaFunction::template apply<T>::type type;
+# endif
+};
+
+
+template <int nargs> struct make_holder;
+
+template <>
+struct make_holder<0>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename eval<Generator,T>::type holder;
+        static void execute(
+            PyObject* p)
+        {
+            (new holder(p))->install(p);
+        }
+    };
+};
+
+
+template <>
+struct make_holder<1>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename eval<Generator,T>::type holder;
+        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename forward<t0>::type f0;
+        
+        static void execute(
+            PyObject* p
+            , t0 a0)
+        {
+            (new holder(p, f0(a0)))->install(p);
+        }
+    };
+};
+
+template <>
+struct make_holder<2>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename eval<Generator,T>::type holder;
+        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename forward<t0>::type f0;
+        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename forward<t1>::type f1;
+        
+        static void execute(
+            PyObject* p, t0 a0, t1 a1)
+        {
+            (new holder(p, f0(a0), f1(a1)))->install(p);
+        }
+    };
+};
+
+template <>
+struct make_holder<3>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename eval<Generator,T>::type holder;
+        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename forward<t0>::type f0;
+        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename forward<t1>::type f1;
+        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename forward<t2>::type f2;
+        
+        static void execute(
+            PyObject* p, t0 a0, t1 a1, t2 a2)
+        {
+            (new holder(p, f0(a0), f1(a1), f2(a2)))->install(p);
+        }
+    };
+};
+
+}}} // namespace boost::python::object
+
+#endif // MAKE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
new file mode 100644
index 00000000..128d170b
--- /dev/null
+++ b/include/boost/python/object/value_holder.hpp
@@ -0,0 +1,80 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VALUE_HOLDER_DWA20011215_HPP
+# define VALUE_HOLDER_DWA20011215_HPP
+
+# include <boost/python/object/class.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+template <class Held>
+struct value_holder : holder<Held>
+{
+    // Forward construction to the held object
+    value_holder(PyObject*)
+        : m_held() {}
+    
+    template <class A1>
+    value_holder(PyObject*, A1 a1)
+        : m_held(a1) {}
+    
+    template <class A1, class A2>
+    value_holder(PyObject*, A1 a1, A2 a2)
+        : m_held(a1, a2) {}
+    
+    template <class A1, class A2, class A3>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3)
+        : m_held(a1, a2, a3) {}
+    
+    template <class A1, class A2, class A3, class A4>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
+        : m_held(a1, a2, a3, a4) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+        : m_held(a1, a2, a3, a4, a5) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+        : m_held(a1, a2, a3, a4, a5, a6) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+        : m_held(a1, a2, a3, a4, a5, a6, a7) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+        : m_held(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>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+        : m_held(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>
+    value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
+        : m_held(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
+
+ private: // required holder implementation
+    Held* target() { return &m_held; }
+    bool held_by_value() const { return true; }
+
+ private: // data members
+    Held m_held;
+};
+
+// A generator metafunction which can be passed to make_holder
+struct value_holder_generator
+{
+    template <class Held>
+    struct apply
+    {
+        typedef value_holder<Held> type;
+    };
+};
+
+}}} // namespace boost::python::object
+
+#endif // VALUE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/objects.hpp b/include/boost/python/objects.hpp
index 3b1a9094..93173462 100644
--- a/include/boost/python/objects.hpp
+++ b/include/boost/python/objects.hpp
@@ -17,7 +17,7 @@
 
 namespace boost { namespace python {
 
-class object
+class BOOST_PYTHON_DECL object
 {
  public:
     explicit object(ref p);
@@ -32,15 +32,36 @@ class object
     ref m_p;
 };
 
-class tuple : public object
+class tuple;
+
+class BOOST_PYTHON_DECL tuple_base : public object
 {
  public:
-    explicit tuple(std::size_t n = 0);
-    explicit tuple(ref p);
+    explicit tuple_base(std::size_t n = 0);
+    explicit tuple_base(ref p);
+
+    static PyTypeObject* type_obj();
+    static bool accepts(ref p);
+    std::size_t size() const;
+    ref operator[](std::size_t pos) const;
+
+    void set_item(std::size_t pos, const ref& rhs);
+    
+    tuple slice(int low, int high) const;
+
+    friend BOOST_PYTHON_DECL tuple operator+(const tuple&, const tuple&);
+    friend BOOST_PYTHON_DECL tuple& operator+=(tuple&, const tuple&);
+};
+
+class  tuple : public tuple_base
+{
+ public:
+    explicit tuple(std::size_t n = 0) : tuple_base(n) {}
+    explicit tuple(ref p) : tuple_base(p) {}
 
     template <class First, class Second>
     tuple(const std::pair<First,Second>& x)
-        : object(ref(PyTuple_New(2)))
+        : tuple_base(ref(PyTuple_New(2)))
     {
         set_item(0, x.first);
         set_item(1, x.second);
@@ -48,7 +69,7 @@ class tuple : public object
     
     template <class First, class Second>
     tuple(const First& first, const Second& second)
-        : object(ref(PyTuple_New(2)))
+        : tuple_base(ref(PyTuple_New(2)))
     {
         set_item(0, first);
         set_item(1, second);
@@ -56,7 +77,7 @@ class tuple : public object
     
     template <class First, class Second, class Third>
     tuple(const First& first, const Second& second, const Third& third)
-        : object(ref(PyTuple_New(3)))
+        : tuple_base(ref(PyTuple_New(3)))
     {
         set_item(0, first);
         set_item(1, second);
@@ -65,7 +86,7 @@ class tuple : public object
     
     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)))
+        : tuple_base(ref(PyTuple_New(4)))
     {
         set_item(0, first);
         set_item(1, second);
@@ -73,32 +94,31 @@ class tuple : public object
         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);
+    void set_item(std::size_t pos, const ref& rhs)
+    {
+        tuple_base::set_item(pos, rhs);
+    }
 };
 
-class list : public object
+class list;
+
+struct BOOST_PYTHON_DECL list_proxy;
+struct BOOST_PYTHON_DECL list_slice_proxy;
+
+class BOOST_PYTHON_DECL list_base : public object
 {
-    struct proxy;
-    struct slice_proxy;
+ protected:
+    typedef list_proxy proxy;
+    typedef list_slice_proxy slice_proxy;
  public:
-    explicit list(ref p);
-    explicit list(std::size_t sz = 0);
+    explicit list_base(ref p);
+    explicit list_base(std::size_t sz = 0);
     static PyTypeObject* type_obj();
     static bool accepts(ref p);
     std::size_t size() const;
@@ -106,26 +126,14 @@ class list : public object
     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;
@@ -135,7 +143,31 @@ class list : public object
     tuple as_tuple() const;
 };
 
-class string
+class list : public list_base
+{
+ public:    
+    explicit list(ref p) : list_base(p) {}
+    explicit list(std::size_t sz = 0) : list_base(sz) {}
+    template <class T>
+    void set_item(std::size_t pos, const T& x)
+        { this->set_item(pos, make_ref(x)); }
+    template <class T>
+    void insert(std::size_t index, const T& x)
+        { this->insert(index, make_ref(x)); }
+    template <class T>
+    void push_back(const T& item)
+        { this->push_back(make_ref(item)); }
+    template <class T>
+    void append(const T& item)
+        { this->append(make_ref(item)); }
+    
+    void set_item(std::size_t pos, const ref& x) { list_base::set_item(pos, x); }
+    void insert(std::size_t index, const ref& item) { list_base::insert(index, item); }
+    void push_back(const ref& item) { list_base::push_back(item); }
+    void append(const ref& item) { list_base::append(item); }
+};
+
+class BOOST_PYTHON_DECL string
     : public object, public boost::multipliable2<string, unsigned int>
 {
  public:
@@ -175,48 +207,31 @@ class string
     friend string operator%(const string& format, const tuple& args);
 };
 
-class dictionary : public object
+class dictionary;
+
+struct BOOST_PYTHON_DECL dictionary_proxy;
+
+class BOOST_PYTHON_DECL dictionary_base : public object
 {
- private:
-    struct proxy;
+ protected:
+    typedef dictionary_proxy proxy;
     
  public:
-    explicit dictionary(ref p);
-    dictionary();
+    explicit dictionary_base(ref p);
+    dictionary_base();
     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);
@@ -235,7 +250,7 @@ class dictionary : public object
     // TODO: iterator support
 };
 
-struct dictionary::proxy
+struct BOOST_PYTHON_DECL dictionary_proxy
 {
     template <class T>
     const ref& operator=(const T& rhs)
@@ -244,19 +259,63 @@ struct dictionary::proxy
 
     operator ref() const;
  private:
-    friend class dictionary;
-    proxy(const ref& dict, const ref& key);
+    friend class dictionary_base;
+    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
+    const ref& operator=(const dictionary_proxy&); // Not actually implemented
  private:
     ref m_dict;
     ref m_key;
 };
 
-struct list::proxy
+class dictionary : public dictionary_base
+{
+    typedef dictionary_proxy proxy;
+ public:
+    explicit dictionary(ref p) : dictionary_base(p) {}
+    dictionary() : dictionary_base() {}
+    
+    template <class Key>
+    proxy operator[](const Key& key)
+        { return this->operator[](make_ref(key)); }
+    proxy operator[](ref key)
+    { return dictionary_base::operator[](key); }
+    
+    template <class Key>
+    ref operator[](const Key& key) const
+        { return this->operator[](make_ref(key)); }
+    ref operator[](ref key) const
+    { return dictionary_base::operator[](key); }
+
+    template <class Key>
+    ref get_item(const Key& key) const
+        { return this->get_item(make_ref(key)); }
+    ref get_item(const ref& key) const
+    { return dictionary_base::get_item(key); }
+    
+    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
+    { return dictionary_base::get_item(key, default_); }
+    
+    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)
+    { dictionary_base::set_item(key, value); }
+
+    template <class Key>
+    void erase(const Key& key)
+        { this->erase(make_ref(key)); }
+    void erase(ref key)
+    { dictionary_base::erase(key); }
+};
+
+struct BOOST_PYTHON_DECL list_proxy
 {
     template <class T>
     const ref& operator=(const T& rhs)
@@ -266,19 +325,19 @@ struct list::proxy
     operator ref() const;
     
  private:
-    friend class list;
-    proxy(const ref& list, std::size_t index);
+    friend class list_base;
+    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
+    const ref& operator=(const list_proxy&); // Not actually implemented
  private:
     list m_list;
     std::size_t m_index;
 };
 
-struct list::slice_proxy
+struct BOOST_PYTHON_DECL list_slice_proxy
 {
     const list& operator=(const list& rhs);
     operator ref() const;
@@ -286,8 +345,8 @@ struct list::slice_proxy
     std::size_t size() const;
     ref operator[](std::size_t pos) const;
  private:
-    friend class list;
-    slice_proxy(const ref& list, int low, int high);
+    friend class list_base;
+    list_slice_proxy(const ref& list, int low, int high);
  private:
     ref m_list;
     int m_low, m_high;
@@ -297,32 +356,32 @@ struct list::slice_proxy
 
 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>);
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::tuple&);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::list&);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::string&);
+BOOST_PYTHON_DECL 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>);
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::dictionary&);
+BOOST_PYTHON_DECL 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&>)
 {
diff --git a/include/boost/python/operators.hpp b/include/boost/python/operators.hpp
index 52e52eee..c766c8b6 100644
--- a/include/boost/python/operators.hpp
+++ b/include/boost/python/operators.hpp
@@ -31,7 +31,7 @@
 
 namespace boost { namespace python {
 
-tuple standard_coerce(ref l, ref r);
+BOOST_PYTHON_DECL tuple standard_coerce(ref l, ref r);
 
 namespace detail {
   
diff --git a/src/classes.cpp b/src/classes.cpp
index f51d1a2f..b018c0ce 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -11,6 +11,8 @@
 // 03 Mar 01  added: pickle safety measures (Ralf W. Grosse-Kunstleve)
 // 03 Mar 01  bug fix: use bound_function::create() (instead of new bound_function)
 
+#define BOOST_PYTHON_SOURCE
+
 #include <boost/python/classes.hpp>
 #include <boost/python/detail/functions.hpp>
 #include <boost/python/detail/singleton.hpp>
@@ -997,7 +999,7 @@ namespace {
   }
 }
 
-void adjust_slice_indices(PyObject* obj, int& start, int& finish)
+BOOST_PYTHON_DECL void adjust_slice_indices(PyObject* obj, int& start, int& finish)
 {
     int length = callback<int>::call_method(obj, "__len__");
     
diff --git a/src/conversions.cpp b/src/conversions.cpp
index f1534dd9..e6b6161a 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -16,65 +16,16 @@
 #define BOOST_PYTHON_SOURCE
 
 #include <boost/python/conversions.hpp>
-#include <boost/python/detail/void_adaptor.hpp>
+#include <boost/function.hpp>
 #include <typeinfo>
 #include <exception>
 #ifndef BOOST_NO_LIMITS
 # include <boost/cast.hpp>
 #endif
 
-namespace boost { namespace python {
-
-// IMPORTANT: this function may only be called from within a catch block!
-PyObject* handle_exception_impl(object_functor_base const& f)
-{
-    try
-    {
-        return f();
-    }
-    catch(const boost::python::error_already_set&)
-    {
-        // The python error reporting has already been handled.
-    }
-    catch(const std::bad_alloc&)
-    {
-        PyErr_NoMemory();
-    }
-    catch(const std::exception& x)
-    {
-        PyErr_SetString(PyExc_RuntimeError, x.what());
-    }
-    catch(...)
-    {
-        PyErr_SetString(PyExc_RuntimeError, "unidentifiable C++ exception");
-    }
-    return 0;
-}
-
-void handle_exception(void (*f)())
-{
-    handle_exception(
-        boost::python::detail::make_void_adaptor(f));
-}
-
-namespace detail {
-
-  void expect_complex(PyObject* p)
-  {
-      if (!PyComplex_Check(p))
-      {
-          PyErr_SetString(PyExc_TypeError, "expected a complex number");
-          throw boost::python::argument_error();
-      }
-  }
-
-} // namespace boost::python::detail
-
-}} // namespace boost::python
-
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-long from_python(PyObject* p, boost::python::type<long>)
+BOOST_PYTHON_DECL long from_python(PyObject* p, boost::python::type<long>)
 {
     // Why am I clearing the error here before trying to convert? I know there's a reason...
     long result;
@@ -86,7 +37,7 @@ long from_python(PyObject* p, boost::python::type<long>)
     return result;
 }
 
-double from_python(PyObject* p, boost::python::type<double>)
+BOOST_PYTHON_DECL double from_python(PyObject* p, boost::python::type<double>)
 {
     double result;
     {
@@ -151,48 +102,48 @@ PyObject* integer_to_python(T value)
     return to_python(value_as_long);
 }
 
-int from_python(PyObject* p, boost::python::type<int> type)
+BOOST_PYTHON_DECL int from_python(PyObject* p, boost::python::type<int> type)
 {
     return integer_from_python(p, type);
 }
 
-PyObject* to_python(unsigned int i)
+BOOST_PYTHON_DECL PyObject* to_python(unsigned int i)
 {
     return integer_to_python(i);
 }
 
-unsigned int from_python(PyObject* p, boost::python::type<unsigned int> type)
+BOOST_PYTHON_DECL unsigned int from_python(PyObject* p, boost::python::type<unsigned int> type)
 {
     return integer_from_python(p, type);
 }
 
-short from_python(PyObject* p, boost::python::type<short> type)
+BOOST_PYTHON_DECL short from_python(PyObject* p, boost::python::type<short> type)
 {
     return integer_from_python(p, type);
 }
 
-float from_python(PyObject* p, boost::python::type<float>)
+BOOST_PYTHON_DECL float from_python(PyObject* p, boost::python::type<float>)
 {
     return static_cast<float>(from_python(p, boost::python::type<double>()));
 }
 
-PyObject* to_python(unsigned short i)
+BOOST_PYTHON_DECL PyObject* to_python(unsigned short i)
 {
     return integer_to_python(i);
 }
 
-unsigned short from_python(PyObject* p, boost::python::type<unsigned short> type)
+BOOST_PYTHON_DECL unsigned short from_python(PyObject* p, boost::python::type<unsigned short> type)
 {
     return integer_from_python(p, type);
 }
 
-PyObject* to_python(char c)
+BOOST_PYTHON_DECL PyObject* to_python(char c)
 {
     if (c == '\0') return PyString_FromString("");
     return PyString_FromStringAndSize(&c, 1);
 }
 
-char from_python(PyObject* p, boost::python::type<char>)
+BOOST_PYTHON_DECL char from_python(PyObject* p, boost::python::type<char>)
 {
     int l = -1;
     if (PyString_Check(p)) l = PyString_Size(p);
@@ -204,37 +155,37 @@ char from_python(PyObject* p, boost::python::type<char>)
     return PyString_AsString(p)[0];
 }
 
-PyObject* to_python(unsigned char i)
+BOOST_PYTHON_DECL PyObject* to_python(unsigned char i)
 {
     return integer_to_python(i);
 }
 
-unsigned char from_python(PyObject* p, boost::python::type<unsigned char> type)
+BOOST_PYTHON_DECL unsigned char from_python(PyObject* p, boost::python::type<unsigned char> type)
 {
     return integer_from_python(p, type);
 }
 
-PyObject* to_python(signed char i)
+BOOST_PYTHON_DECL PyObject* to_python(signed char i)
 {
     return integer_to_python(i);
 }
 
-signed char from_python(PyObject* p, boost::python::type<signed char> type)
+BOOST_PYTHON_DECL signed char from_python(PyObject* p, boost::python::type<signed char> type)
 {
     return integer_from_python(p, type);
 }
 
-PyObject* to_python(unsigned long x)
+BOOST_PYTHON_DECL PyObject* to_python(unsigned long x)
 {
     return integer_to_python(x);
 }
 
-unsigned long from_python(PyObject* p, boost::python::type<unsigned long> type)
+BOOST_PYTHON_DECL unsigned long from_python(PyObject* p, boost::python::type<unsigned long> type)
 {
     return integer_from_python(p, type);
 }
 
-void from_python(PyObject* p, boost::python::type<void>)
+BOOST_PYTHON_DECL void from_python(PyObject* p, boost::python::type<void>)
 {
     if (p != Py_None) {
         PyErr_SetString(PyExc_TypeError, "expected argument of type None");
@@ -242,7 +193,7 @@ void from_python(PyObject* p, boost::python::type<void>)
     }
 }
 
-const char* from_python(PyObject* p, boost::python::type<const char*>)
+BOOST_PYTHON_DECL const char* from_python(PyObject* p, boost::python::type<const char*>)
 {
     const char* s = PyString_AsString(p);
     if (!s)
@@ -250,12 +201,12 @@ const char* from_python(PyObject* p, boost::python::type<const char*>)
     return s;
 }
 
-PyObject* to_python(const std::string& s)
+BOOST_PYTHON_DECL PyObject* to_python(const std::string& s)
 {
     return PyString_FromStringAndSize(s.data(), s.size());
 }
 
-std::string from_python(PyObject* p, boost::python::type<std::string>)
+BOOST_PYTHON_DECL std::string from_python(PyObject* p, boost::python::type<std::string>)
 {
     if (! PyString_Check(p)) {
         PyErr_SetString(PyExc_TypeError, "expected a string");
@@ -264,7 +215,7 @@ std::string from_python(PyObject* p, boost::python::type<std::string>)
     return std::string(PyString_AsString(p), PyString_Size(p));
 }
 
-bool from_python(PyObject* p, boost::python::type<bool>)
+BOOST_PYTHON_DECL bool from_python(PyObject* p, boost::python::type<bool>)
 {
     int value = from_python(p, boost::python::type<int>());
     if (value == 0)
@@ -274,12 +225,12 @@ bool from_python(PyObject* p, boost::python::type<bool>)
 
 #ifdef BOOST_MSVC6_OR_EARLIER
 // An optimizer bug prevents these from being inlined.
-PyObject* to_python(double d)
+BOOST_PYTHON_DECL PyObject* to_python(double d)
 {
     return PyFloat_FromDouble(d);
 }
 
-PyObject* to_python(float f)
+BOOST_PYTHON_DECL PyObject* to_python(float f)
 {
     return PyFloat_FromDouble(f);
 }
diff --git a/src/converter/body.cpp b/src/converter/body.cpp
new file mode 100644
index 00000000..637f8c3e
--- /dev/null
+++ b/src/converter/body.cpp
@@ -0,0 +1,18 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/converter/body.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// default implementation is a no-op. Most handles will not hold any
+// data that needs to be managed. Unwrap objects which convert
+// by-value are an exception. Fortunately, the concrete body subclass
+// has that knowledge.
+void body::destroy_handle(handle*) const
+{
+}
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/handle.cpp b/src/converter/handle.cpp
new file mode 100644
index 00000000..1a2b8c31
--- /dev/null
+++ b/src/converter/handle.cpp
@@ -0,0 +1,35 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/converter/handle.hpp>
+#include <boost/python/converter/body.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+bool handle::convertible() const
+{
+    for (handle const* p = this; p != 0; p = p->m_next)
+    {
+        if (p->m_body == 0)
+            return false;
+    }
+    return true;
+}
+
+void handle::destroy()
+{
+    // Recurse down the chain releasing from tail to head
+    if (m_next != 0)
+        m_next->destroy();
+
+    // Our body knows how to destroy us. If we never got a body,
+    // there's nothing to do.
+    if (m_body)
+        m_body->destroy_handle(this);
+}
+
+// void handle::dummy::nonnull() {}
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
new file mode 100644
index 00000000..88d96637
--- /dev/null
+++ b/src/converter/registry.cpp
@@ -0,0 +1,177 @@
+//  Copyright David Abrahams 2001. Permission to copy, use,
+//  modify, sell and distribute this software is granted provided this
+//  copyright notice appears in all copies. This software is provided
+//  "as is" without express or implied warranty, and with no claim as
+//  to its suitability for any purpose.
+
+# include <boost/python/converter/unwrapper.hpp>
+# include <boost/python/converter/wrapper.hpp>
+# include <map>
+# include <list>
+# include <algorithm>
+# include <stdexcept>
+# ifdef BOOST_PYTHON_TRACE
+#  include <iostream>
+# endif 
+
+namespace boost { namespace python { namespace converter { 
+
+namespace // <unnamed>
+{
+  typedef std::map<type_id_t, registry::entry, type_id_before> registry_t;
+  
+  registry_t& entries()
+  {
+      static registry_t registry;
+      return registry;
+  }
+} // namespace <unnamed>
+
+namespace registry
+{
+  entry* find(type_id_t type)
+  {
+      return &entries()[type];
+  }
+
+  entry::entry()
+      : m_wrapper(0)
+  {
+  }
+
+  namespace // <unnamed>
+  {
+    // A UnaryFunction type which deletes its argument
+    struct delete_item
+    {
+        template <class T>
+        void operator()(T* x) const
+        {
+            delete x;
+        }
+    };
+
+    // A UnaryFunction type which returns true iff its argument is a
+    // unwrapper which can convert the given Python object.
+    struct convertible
+    {
+        convertible(PyObject* p)
+            : m_p(p)
+        {}
+        
+        bool operator()(unwrapper_base* converter) const
+        {
+            return converter->convertible(m_p);
+        }
+        
+        PyObject* m_p;
+    };
+  }
+
+  entry::~entry()
+  {
+      if (m_wrapper != 0)
+          m_wrapper->m_can_unregister = false;
+      
+      for (unwrappers::iterator p = m_unwrappers.begin(); p != m_unwrappers.end(); ++p)
+      {
+          (*p)->m_can_unregister = false;
+      }
+  }
+
+  unwrapper_base* entry::unwrapper(PyObject* p) const
+  {
+      unwrappers::const_iterator q =
+          std::find_if(m_unwrappers.begin(), m_unwrappers.end(), convertible(p));
+      
+      return q == m_unwrappers.end() ? 0 : *q;
+  }
+  
+  wrapper_base* entry::wrapper() const
+  {
+      return m_wrapper;
+  }
+
+  entry::unwrappers::iterator entry::find(unwrapper_base const& x)
+  {
+      return std::find(m_unwrappers.begin(), m_unwrappers.end(), &x);
+  }
+
+  void entry::insert(unwrapper_base& x)
+  {
+      unwrappers::iterator p = this->find(x);
+      
+      assert(p == m_unwrappers.end());
+      if (p != m_unwrappers.end())
+      {
+          throw std::runtime_error(
+              "trying to register unrapper which is already registered");
+      }
+      m_unwrappers.push_back(&x);
+  }
+  
+  void entry::remove(unwrapper_base& x)
+  {
+      unwrappers::iterator p = find(x);
+
+      // Be sure we're not removing a converter which hasn't been
+      // registered.
+      assert(p != m_unwrappers.end());
+      if (p == m_unwrappers.end())
+      {
+          throw std::runtime_error(
+              "trying to unregister unwrapper which is not registered");
+      }
+      m_unwrappers.erase(p);
+  }
+  
+  void entry::insert(wrapper_base& x)
+  {
+      assert(m_wrapper == 0); // we have a problem otherwise
+      if (m_wrapper != 0)
+      {
+          throw std::runtime_error(
+              "trying to register wrapper for a type which already has a registered wrapper");
+      }
+      m_wrapper = &x;
+  }
+  
+  void entry::remove(wrapper_base& x)
+  {
+      assert(m_wrapper == &x);
+      if (m_wrapper != &x)
+      {
+          throw std::runtime_error(
+              "trying to unregister a wrapper which is not registered");
+      }
+      m_wrapper = 0;
+  }
+
+  void insert(wrapper_base& w)
+  {
+# ifdef BOOST_PYTHON_TRACE
+      std::cout << "inserting wrapper for " << w.key() << std::endl;
+# endif 
+      find(w.key())->insert(w);
+  }
+
+  void insert(unwrapper_base& u)
+  {
+# ifdef BOOST_PYTHON_TRACE
+      std::cout << "inserting unwrapper for " << u.key() << std::endl;
+# endif 
+      find(u.key())->insert(u);
+  }
+
+  void remove(wrapper_base& w)
+  {
+      find(w.key())->remove(w);
+  }
+
+  void remove(unwrapper_base& u)
+  {
+      find(u.key())->remove(u);
+  }
+} // namespace registry
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/type_id.cpp b/src/converter/type_id.cpp
new file mode 100644
index 00000000..86974638
--- /dev/null
+++ b/src/converter/type_id.cpp
@@ -0,0 +1,67 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/converter/type_id.hpp>
+#if !defined(__GNUC__) || __GNUC__ >= 3 || __SGI_STL_PORT
+# include <ostream>
+#else 
+# include <ostream.h>
+#endif 
+
+namespace boost { namespace python { namespace converter { 
+
+#if 1
+bool type_id_before::operator()(type_id_t const& x, type_id_t const&  y) const
+{
+    return x < y;
+}
+
+BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream& os, type_id_t const& x)
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    os << x.m_base_type;
+#  else
+    os << x.m_base_type->name();
+#  endif 
+    // VC6 mistakenly distinguishes typeid(X) from typeid(X const)
+    // from typeid(X&)...  so the name is already correct. I have it
+    // from Jason Shirk that VC7.0 has the same bug but it will be
+    // fixed in 7.1
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+    if (x.m_decoration & type_id_t::const_)
+        os << " const";
+    if (x.m_decoration & type_id_t::volatile_)
+        os << " volatile";
+    if (x.m_decoration & type_id_t::reference)
+        os << "&";
+# endif 
+    return os;
+}
+
+#else 
+bool type_id_before::operator()(type_id_t const& x, type_id_t const&  y) const
+{
+    for (;;)
+    {
+        if (*y == 0)
+        {
+            return 0;
+        }
+        else if (*x == 0)
+        {
+            return 1;
+        }
+        else if (*x != *y)
+        {
+            return *x < *y;
+        }
+        ++x;
+        ++y;
+    }
+}
+#endif
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/unwrap.cpp b/src/converter/unwrap.cpp
new file mode 100644
index 00000000..e0c09db6
--- /dev/null
+++ b/src/converter/unwrap.cpp
@@ -0,0 +1,35 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/converter/unwrap.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace
+{
+  struct pyobject_unwrapper : unwrapper_base
+  {
+      pyobject_unwrapper();
+      bool convertible(PyObject*) const;
+  };
+  
+  pyobject_unwrapper static_unwrapper;
+
+  pyobject_unwrapper::pyobject_unwrapper()
+      : unwrapper_base(type_id<PyObject*>())
+  {
+  }
+      
+  bool pyobject_unwrapper::convertible(PyObject*) const
+  {
+      return true;
+  }
+}
+
+BOOST_PYTHON_EXPORT unwrapper_base*
+unwrap_more_<PyObject*>::m_unwrapper = &static_unwrapper;
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/unwrapper.cpp b/src/converter/unwrapper.cpp
new file mode 100644
index 00000000..2b0adbd0
--- /dev/null
+++ b/src/converter/unwrapper.cpp
@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/converter/unwrapper.hpp>
+#include <boost/python/converter/registry.hpp>
+#include <boost/type_traits/same_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+unwrapper_base::unwrapper_base(type_id_t key)
+    : body(key)
+{
+    registry::insert(*this);
+}
+
+unwrapper_base::~unwrapper_base()
+{
+    if (can_unregister())
+        registry::remove(*this);
+}
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/wrapper.cpp b/src/converter/wrapper.cpp
new file mode 100644
index 00000000..0d817217
--- /dev/null
+++ b/src/converter/wrapper.cpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/converter/registry.hpp>
+#include <boost/python/converter/wrapper.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+wrapper_base::wrapper_base(type_id_t type)
+    : body(type)
+{
+    // static assertions for target<T>. These would go in a header,
+    // but Metrowerks only respects BOOST_STATIC_ASSERT if it is in an
+    // instantiated function
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#else
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
+    registry::insert(*this);
+}
+
+wrapper_base::~wrapper_base()
+{
+    if (can_unregister())
+        registry::remove(*this);
+}
+
+}}} // namespace boost::python::converter
diff --git a/src/cross_module.cpp b/src/cross_module.cpp
index 5949be4d..2bce5a61 100644
--- a/src/cross_module.cpp
+++ b/src/cross_module.cpp
@@ -15,7 +15,8 @@ namespace python = boost::python;
 # include <stdio.h> // MSVC6.0SP4 does not know std::fprintf
 # include <string.h> // MSVC6.0SP4 does not know std::strcmp
 
-namespace {
+namespace
+{
 
   PyObject* get_module_dict(const char* module_name)
   {
@@ -26,64 +27,68 @@ namespace {
   }
 }
 
-namespace boost { namespace python { namespace detail {
+namespace boost { namespace python {
 
-const char* converters_attribute_name = "__converters__";
-
-void* import_converter_object(const std::string& module_name,
-                              const std::string& py_class_name,
-                              const std::string& attribute_name)
+namespace detail
 {
-    static std::string err;
-    PyObject* module_dict = get_module_dict(const_cast<char*>(module_name.c_str()));
-    PyObject* py_class = PyDict_GetItemString(module_dict, const_cast<char*>(py_class_name.c_str()));
-    if (py_class == 0) {
-        err = std::string("module ") + module_name + " has no attribute " + py_class_name;
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    python::ref c_obj(PyObject_GetAttrString(py_class, const_cast<char*>(attribute_name.c_str())), ref::null_ok);
-    if (c_obj.get() == 0) {
-        err = std::string("object ") + module_name + "." + py_class_name
+  BOOST_PYTHON_DECL const char* converters_attribute_name = "__converters__";
+
+  BOOST_PYTHON_DECL void* import_converter_object(const std::string& module_name,
+                                                  const std::string& py_class_name,
+                                                  const std::string& attribute_name)
+  {
+      static std::string err;
+      PyObject* module_dict = get_module_dict(const_cast<char*>(module_name.c_str()));
+      PyObject* py_class = PyDict_GetItemString(module_dict, const_cast<char*>(py_class_name.c_str()));
+      if (py_class == 0) {
+          err = std::string("module ") + module_name + " has no attribute " + py_class_name;
+          PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+          throw python::import_error();
+      }
+      python::ref c_obj(PyObject_GetAttrString(py_class, const_cast<char*>(attribute_name.c_str())), ref::null_ok);
+      if (c_obj.get() == 0) {
+          err = std::string("object ") + module_name + "." + py_class_name
               + " has no attribute " + attribute_name;
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    if (! PyCObject_Check(c_obj.get())) {
-        err = std::string("object ") + module_name + "." + py_class_name + "."
+          PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+          throw python::import_error();
+      }
+      if (! PyCObject_Check(c_obj.get())) {
+          err = std::string("object ") + module_name + "." + py_class_name + "."
               + attribute_name + " is not a PyCObject";
-        PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
-        throw python::import_error();
-    }
-    return PyCObject_AsVoidPtr(c_obj.get());
+          PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(err.c_str()));
+          throw python::import_error();
+      }
+      return PyCObject_AsVoidPtr(c_obj.get());
+  }
+
+  BOOST_PYTHON_DECL void check_export_converters_api(const int importing_major,
+                                                     const int importing_minor,
+                                                     const int imported_major,
+                                                     const int imported_minor)
+  {
+      if (importing_major != imported_major) {
+          // Python uses fprintf(stderr, ...) for API warnings.
+          fprintf(stderr,
+                  "Fatal: export_converters_api mismatch:"
+                  " Importing module = %d.%d"
+                  " Imported module = %d.%d\n",
+                  importing_major, importing_minor,
+                  imported_major, imported_minor);
+          PyErr_SetString(PyExc_RuntimeError,
+                          "Fatal: export_converters_api mismatch");
+          throw import_error();
+      }
+      if (importing_minor != imported_minor) {
+          // Python uses fprintf(stderr, ...) for API warnings.
+          fprintf(stderr,
+                  "Warning: export_converters_api mismatch:"
+                  " Importing module = %d.%d"
+                  " Imported module = %d.%d\n",
+                  importing_major, importing_minor,
+                  imported_major, imported_minor);
+      }
+  }
+
 }
 
-void check_export_converters_api(const int importing_major,
-                                 const int importing_minor,
-                                 const int imported_major,
-                                 const int imported_minor)
-{
-    if (importing_major != imported_major) {
-        // Python uses fprintf(stderr, ...) for API warnings.
-        fprintf(stderr,
-          "Fatal: export_converters_api mismatch:"
-          " Importing module = %d.%d"
-          " Imported module = %d.%d\n",
-          importing_major, importing_minor,
-          imported_major, imported_minor);
-        PyErr_SetString(PyExc_RuntimeError,
-          "Fatal: export_converters_api mismatch");
-        throw import_error();
-    }
-    if (importing_minor != imported_minor) {
-        // Python uses fprintf(stderr, ...) for API warnings.
-        fprintf(stderr,
-          "Warning: export_converters_api mismatch:"
-          " Importing module = %d.%d"
-          " Imported module = %d.%d\n",
-          importing_major, importing_minor,
-          imported_major, imported_minor);
-    }
-}
-
-}}} // namespace boost::python::detail
+}} // namespace boost::python::detail
diff --git a/src/errors.cpp b/src/errors.cpp
new file mode 100644
index 00000000..1290df50
--- /dev/null
+++ b/src/errors.cpp
@@ -0,0 +1,68 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#ifndef BOOST_PYTHON_SOURCE
+# define BOOST_PYTHON_SOURCE
+#endif
+
+#include <boost/python/errors.hpp>
+
+namespace boost { namespace python {
+
+// IMPORTANT: this function may only be called from within a catch block!
+BOOST_PYTHON_DECL bool handle_exception_impl(function0<void> f)
+{
+    try
+    {
+        f();
+        return false;
+    }
+    catch(const boost::python::error_already_set&)
+    {
+        // The python error reporting has already been handled.
+    }
+    catch(const std::bad_alloc&)
+    {
+        PyErr_NoMemory();
+    }
+    catch(const std::exception& x)
+    {
+        PyErr_SetString(PyExc_RuntimeError, x.what());
+    }
+    catch(...)
+    {
+        PyErr_SetString(PyExc_RuntimeError, "unidentifiable C++ exception");
+    }
+    return true;
+}
+
+BOOST_PYTHON_DECL PyObject* expect_non_null(PyObject* x)
+{
+    if (x == 0)
+        throw error_already_set();
+    return x;
+}
+
+namespace detail {
+
+  BOOST_PYTHON_DECL void expect_complex(PyObject* p)
+  {
+      if (!PyComplex_Check(p))
+      {
+          PyErr_SetString(PyExc_TypeError, "expected a complex number");
+          throw boost::python::argument_error();
+      }
+  }
+
+// needed by void_adaptor (see void_adaptor.hpp)
+BOOST_PYTHON_DECL PyObject arbitrary_object = { 0 };
+
+
+} // namespace boost::python::detail
+
+}} // namespace boost::python
+
+
diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index e9183c82..f8bcf9ad 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -12,6 +12,7 @@
 #define BOOST_PYTHON_SOURCE
 
 #include <boost/python/detail/extension_class.hpp>
+#include <boost/python/detail/call_object.hpp>
 #include <boost/utility.hpp>
 #include <boost/bind.hpp>
 #include <cstring>
@@ -52,7 +53,7 @@ BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 namespace boost { namespace python { 
 
-tuple standard_coerce(ref l, ref r)
+BOOST_PYTHON_DECL tuple standard_coerce(ref l, ref r)
 {
     // Introduced sequence points for exception-safety.
     ref first(detail::operator_dispatcher::create(l, l));
@@ -487,21 +488,15 @@ void operator_dispatcher_dealloc(PyObject* self)
 int operator_dispatcher_coerce(PyObject** l, PyObject** r)
 {
     Py_INCREF(*l);
-    PyObject* new_r = handle_exception(
-        bind(operator_dispatcher::create,
-                    ref(*r, ref::increment_count),
-                    ref()));
-    if (new_r)
-    {
-        *r = new_r;
-        return 0;
-    }
-    else
-    {
-        return -1;
-    }
-}
 
+    return handle_exception(
+        bind_return(
+            *r
+            , bind(operator_dispatcher::create,
+                   ref(*r, ref::increment_count),
+                   ref())))
+        ? -1 : 0;
+}
 
 #define PY_DEFINE_OPERATOR(id, symbol) \
     PyObject* operator_dispatcher_call_##id(PyObject* left, PyObject* right)                   \
diff --git a/src/gen_call.py b/src/gen_call.py
new file mode 100644
index 00000000..dd178648
--- /dev/null
+++ b/src/gen_call.py
@@ -0,0 +1,82 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+#  This work was funded in part by Lawrence Berkeley National Labs
+
+from gen_function import *
+import string
+
+header = '''// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for %d-argument member functions and %d-argument free
+//  functions by gen_call.py
+
+#ifndef CALL_DWA20011214_HPP
+# define CALL_DWA20011214_HPP
+
+# include <boost/python/detail/returning.hpp>
+
+namespace boost { namespace python { 
+
+'''
+_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
+            
+def gen_call(member_function_args, free_function_args = None):
+    if free_function_args is None:
+        free_function_args = member_function_args + 1
+
+    return (header % (member_function_args, free_function_args)
+            + gen_functions(
+'''template <class R%(, class A%n%)>
+PyObject* call(R (*f)(%(A%n%:, %)), PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+''', free_function_args)
+            +
+'''// Member functions
+'''
+             + reduce(lambda x,y: x+y
+                   , map(lambda cv:
+                         gen_functions(
+'''template <class R, class A0%(, class A%+%)>
+PyObject* call(R (A0::*f)(%(A%+%:, %))%1, PyObject* args, PyObject* keywords)
+{
+    return detail::returning<R>::call(f, args, keywords);
+}
+
+'''
+                        , member_function_args, cv)
+                      , _cv_qualifiers))
+            +
+'''
+}} // namespace boost::python
+
+#endif // CALL_DWA20011214_HPP
+''')            
+
+if __name__ == '__main__':
+    import sys
+
+    if len(sys.argv) == 1:
+        member_function_args = 5
+        free_function_args = 6
+    else:
+        member_function_args = int(sys.argv[1])
+        if len(sys.argv) > 2:
+            free_function_args = int(sys.argv[2])
+        else:
+            free_function_args = member_function_args
+
+    print gen_call(member_function_args, free_function_args)
+
+
diff --git a/src/gen_returning.py b/src/gen_returning.py
new file mode 100644
index 00000000..2b112cc0
--- /dev/null
+++ b/src/gen_returning.py
@@ -0,0 +1,191 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+#  This work was funded in part by Lawrence Berkeley National Labs
+
+from gen_function import *
+import string
+
+header = '''//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for %d-argument member functions and %d-argument free
+//  functions by gen_returning.py
+'''
+
+body_sections = (
+'''
+#ifndef RETURNING_DWA20011201_HPP
+# define RETURNING_DWA20011201_HPP
+
+//# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/config.hpp>
+# include <boost/python/convert.hpp>
+# include <boost/python/detail/none.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+// Calling C++ from Python
+template <class R>
+struct returning
+{
+''',
+'''
+''',
+'''    // Free functions
+''',
+'''};
+                           
+template <>
+struct returning<void>
+{
+    typedef void R;
+''',
+'''
+''',
+'''
+    // Free functions
+''',
+'''};
+
+}}} // namespace boost::python::detail
+
+#endif // RETURNING_DWA20011201_HPP
+''')
+
+#'
+
+member_function = '''    template <class A0%(, class A%+%)>
+    static PyObject* call(R (A0::*pmf)(%(A%+%:, %))%1, PyObject* args, PyObject* /* keywords */ )
+    {
+        // check that each of the arguments is convertible
+        unwrap<A0%1&> c0(PyTuple_GET_ITEM(args, 0));
+%(        unwrap_more<A%+> c%+(PyTuple_GET_ITEM(args, %+), c%n);
+%)
+%[r%:        // find the result converter
+        wrap_more<R> r(c%n);
+%]        if (!c0) return 0;
+        %[r%:return r( %]((*c0).*pmf)(%(*c%+%:, %))%[r%: )%];%[v%:
+        return detail::none();%]
+    };
+''' 
+        
+free_function = '''%{    template <%(class A%n%:, %)>
+%}    static PyObject* call(R (*pf)(%(A%n%:, %)), PyObject*%{ args%}, PyObject* /* keywords */ )
+    {%{
+        // check that each of the arguments is convertible
+%}%(        unwrap%{_more%}<A%n> c%n(PyTuple_GET_ITEM(args, %n)%{, c%-%});
+%)%[r%:
+        // find the result converter
+        wrap%{_more%}<R> r%{(c%-)%};%]%{
+        if (!c0) return 0;%}
+        %[r%:return r( %](*pf)(%(*c%n%:, %))%[r%: )%];%[v%:
+        return detail::none();%]
+    };
+''' 
+
+def _returns_value(key, n, args, value):
+    if key == 'r':
+        return value
+        # pass the value through gen_function again for recursive expansion
+#        return apply(gen_function, (value, n) + args
+#                     , {'fill': _returns_value})
+    else:
+        assert key == 'v'
+        return ''
+
+def _returns_void(key, n, args, value):
+    if key == 'v':
+        return value
+    else:
+        assert key == 'r'
+        # return the empty string, ignoring the value
+        return ''
+
+_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
+
+_prefix = {
+#     ' const': '''
+
+# // missing cv-qualified -> cv-unqualified member pointer conversions
+# # if defined(__MWERKS__) && __MWERKS__ <=0x2406 || defined(BOOST_MSVC) && BOOST_MSVC <= 1200 || defined(__BORLANDC__)
+# ''',
+             ' const volatile': '''
+// missing const volatile type traits
+#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+'''};
+            
+def gen_returning(member_function_args, free_function_args = None):
+    if free_function_args is None:
+        free_function_args = member_function_args + 1
+
+    return_none = ''';
+        return detail::none();'''
+    
+    return (header % (member_function_args, free_function_args)
+            + body_sections[0]
+            #
+            # functions returning results
+            #
+
+            + reduce(lambda x,y: x+y
+                   , map(lambda cv:
+                         _prefix.get(cv,'') 
+                         + gen_functions(member_function,
+                                         member_function_args, cv,
+                                         fill = _returns_value) + '\n'
+        , _cv_qualifiers))
+            + '''#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+            
+'''
+## endif // missing cv-qualified -> cv-unqualified member pointer conversions
+#'''
+            # free functions
+            + gen_functions(free_function, free_function_args, fill = _returns_value)
+            + body_sections[3]
+
+            #
+            # functions returning void
+            #
+
+            + reduce(lambda x,y: x+y
+                   , map(lambda cv:
+                         _prefix.get(cv,'')
+                         + gen_functions(member_function,
+                                         member_function_args, cv, fill =
+                                         _returns_void) + '\n'
+        , _cv_qualifiers))
+            
+            + '''#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+            
+'''
+## endif // missing cv-qualified -> cv-unqualified member pointer conversions
+#'''
+            # free functions
+            + gen_functions(free_function, free_function_args, fill = _returns_void)
+            + body_sections[6]
+            )
+
+if __name__ == '__main__':
+    import sys
+
+    if len(sys.argv) == 1:
+        member_function_args = 5
+        free_function_args = 6
+    else:
+        member_function_args = int(sys.argv[1])
+        if len(sys.argv) > 2:
+            free_function_args = int(sys.argv[2])
+        else:
+            free_function_args = member_function_args
+
+    print gen_returning(member_function_args, free_function_args)
+
+
diff --git a/src/module_builder.cpp b/src/module_builder.cpp
index bd04a89c..0a195621 100644
--- a/src/module_builder.cpp
+++ b/src/module_builder.cpp
@@ -16,19 +16,19 @@ namespace {
   ref name_holder;
 }
 
-bool module_builder::initializing()
+bool module_builder_base::initializing()
 {
     return name_holder.get() != 0;
 }
 
-string module_builder::name()
+string module_builder_base::name()
 {
     // If this fails, you haven't created a module_builder object
     assert(initializing());
     return string(name_holder);
 }
 
-module_builder::module_builder(const char* name)
+module_builder_base::module_builder_base(const char* name)
     : m_module(Py_InitModule(const_cast<char*>(name), initial_methods))
 {
     // If this fails, you've created more than 1 module_builder object in your module    
@@ -36,29 +36,29 @@ module_builder::module_builder(const char* name)
     name_holder = ref(PyObject_GetAttrString(m_module, const_cast<char*>("__name__")));
 }
 
-module_builder::~module_builder()
+module_builder_base::~module_builder_base()
 {
     name_holder.reset();
 }
 
 void
-module_builder::add(detail::function* x, const char* name)
+module_builder_base::add(detail::function* x, const char* name)
 {
     reference<detail::function> f(x); // First take possession of the object.
     detail::function::add_to_namespace(f, name, PyModule_GetDict(m_module));
 }
 
-void module_builder::add(ref x, const char* name)
+void module_builder_base::add(ref x, const char* name)
 {
 	PyObject* dictionary = PyModule_GetDict(m_module);
     PyDict_SetItemString(dictionary, const_cast<char*>(name), x.get());
 }
 
-void module_builder::add(PyTypeObject* x, const char* name /*= 0*/)
+void module_builder_base::add(PyTypeObject* x, const char* name /*= 0*/)
 {
     this->add(ref(as_object(x)), name ? name : x->tp_name);
 }
 
-PyMethodDef module_builder::initial_methods[] = { { 0, 0, 0, 0 } };
+PyMethodDef module_builder_base::initial_methods[] = { { 0, 0, 0, 0 } };
 
 }} // namespace boost::python
diff --git a/src/object/class.cpp b/src/object/class.cpp
new file mode 100644
index 00000000..cc3903e3
--- /dev/null
+++ b/src/object/class.cpp
@@ -0,0 +1,165 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/export.hpp>
+#include <boost/python/module.hpp>
+#include <boost/python/detail/wrap_python.hpp>
+#include <boost/python/object/class.hpp>
+#include <boost/bind.hpp>
+#include <functional>
+
+namespace boost { namespace python { namespace object { 
+
+holder_base::holder_base(converter::type_id_t id)
+    : m_type(id)
+    , m_next(0)
+{
+}
+
+holder_base::~holder_base()
+{
+}
+
+//BOOST_PYTHON_EXPORT
+PyTypeObject class_metatype_object = {
+    PyObject_HEAD_INIT(0)//&PyType_Type)
+        0,
+        "Boost.Python.class",
+        PyType_Type.tp_basicsize,
+        0,
+        0,                                      /* tp_dealloc */
+        0,                                      /* tp_print */
+        0,                                      /* tp_getattr */
+        0,                                      /* tp_setattr */
+        0,                                      /* tp_compare */
+        0,                                      /* tp_repr */
+        0,                                      /* tp_as_number */
+        0,                                      /* tp_as_sequence */
+        0,                                      /* tp_as_mapping */
+        0,                                      /* tp_hash */
+        0,                                      /* tp_call */
+        0,                                      /* tp_str */
+        0,                                      /* tp_getattro */
+        0,                                      /* tp_setattro */
+        0,                                      /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | // Py_TPFLAGS_HAVE_GC |
+		Py_TPFLAGS_BASETYPE,		/* tp_flags */
+        0,                                      /* tp_doc */
+        0,                                      /* tp_traverse */
+        0,                                      /* tp_clear */
+        0,                                      /* tp_richcompare */
+        0,                                      /* tp_weaklistoffset */
+        0,                                      /* tp_iter */
+        0,                                      /* tp_iternext */
+        0,                                      /* tp_methods */
+        0,                                      /* tp_members */
+        0,                                      /* tp_getset */
+        0, //&PyType_Type,                           /* tp_base */
+        0,                                      /* tp_dict */
+        0,                                      /* tp_descr_get */
+        0,                                      /* tp_descr_set */
+        0,                                      /* tp_dictoffset */
+        0,                                      /* tp_init */
+        0,                                      /* tp_alloc */
+        0,
+        // PyType_GenericNew                       /* tp_new */
+};
+
+//BOOST_PYTHON_EXPORT
+PyTypeObject class_type_object = {
+    PyObject_HEAD_INIT(0) //&class_metatype_object)
+        0,
+        "Boost.Python.instance",
+        sizeof(instance),
+        0,
+        0,                                      /* tp_dealloc */
+        0,                                      /* tp_print */
+        0,                                      /* tp_getattr */
+        0,                                      /* tp_setattr */
+        0,                                      /* tp_compare */
+        0,                                      /* tp_repr */
+        0,                                      /* tp_as_number */
+        0,                                      /* tp_as_sequence */
+        0,                                      /* tp_as_mapping */
+        0,                                      /* tp_hash */
+        0,                                      /* tp_call */
+        0,                                      /* tp_str */
+        0,                                      /* tp_getattro */
+        0,                                      /* tp_setattro */
+        0,                                      /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+		Py_TPFLAGS_BASETYPE,		/* tp_flags */
+        0,                                      /* tp_doc */
+        0,                                      /* tp_traverse */
+        0,                                      /* tp_clear */
+        0,                                      /* tp_richcompare */
+        0,                                      /* tp_weaklistoffset */
+        0,                                      /* tp_iter */
+        0,                                      /* tp_iternext */
+        0,                                      /* tp_methods */
+        0,                                      /* tp_members */
+        0,                                      /* tp_getset */
+    0, //&PyBaseObject_Type,                     /* tp_base */
+        0,                                      /* tp_dict */
+        0,                                      /* tp_descr_get */
+        0,                                      /* tp_descr_set */
+        0,                                      /* tp_dictoffset */
+        0,                                      /* tp_init */
+        0,                                      /* tp_alloc */
+        PyType_GenericNew
+};
+
+BOOST_PYTHON_EXPORT PyTypeObject* class_metatype()
+{
+    if (class_metatype_object.tp_dict == 0)
+    {
+        class_metatype_object.ob_type = &PyType_Type;
+        class_metatype_object.tp_base = &PyType_Type;
+        if (PyType_Ready(&class_metatype_object))
+            return 0;
+    }
+    Py_INCREF(&class_metatype_object);
+    return &class_metatype_object;
+}
+
+BOOST_PYTHON_EXPORT PyTypeObject* class_type()
+{
+    if (class_type_object.tp_dict == 0)
+    {
+        class_type_object.ob_type = class_metatype();
+        class_type_object.tp_base = &PyBaseObject_Type;
+        if (PyType_Ready(&class_type_object))
+            return 0;
+    }
+    Py_INCREF(&class_type_object);
+    return &class_type_object;
+}
+
+void holder_base::install(PyObject* self)
+{
+    assert(self->ob_type->ob_type == &class_metatype_object);
+    m_next = ((instance*)self)->objects;
+    ((instance*)self)->objects = this;
+}
+
+BOOST_PYTHON_EXPORT holder_base*
+find_holder_impl(PyObject* inst, converter::type_id_t type)
+{
+    if (inst->ob_type->ob_type != &class_metatype_object)
+        return 0;
+    instance* self = reinterpret_cast<instance*>(inst);
+
+    holder_base::iterator match = std::find_if(
+        holder_base::iterator(self->objects), holder_base::iterator(0)
+        , bind<bool>(std::equal_to<converter::type_id_t>()
+               , bind<converter::type_id_t>(mem_fn(&holder_base::type), _1)
+               , type));
+    
+    return match != holder_base::iterator(0)
+        ? match.base() : 0;
+}
+
+}}} // namespace boost::python::object
diff --git a/src/object/function.cpp b/src/object/function.cpp
new file mode 100644
index 00000000..4c2de3c7
--- /dev/null
+++ b/src/object/function.cpp
@@ -0,0 +1,95 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/object/function.hpp>
+
+namespace boost { namespace python { namespace object { 
+
+
+function::function(py_function implementation)
+    : m_fn(implementation)
+{
+    PyObject* p = this;
+    PyObject_INIT(p, &function_type);
+}
+
+function::~function()
+{
+}
+    
+PyObject* function::call(PyObject* args, PyObject* keywords) const
+{
+    return m_fn(args, keywords);
+}
+
+extern "C"
+{
+    // Stolen from Python's funcobject.c
+    static PyObject *
+    function_descr_get(PyObject *func, PyObject *obj, PyObject *type)
+    {
+        if (obj == Py_None)
+            obj = NULL;
+        return PyMethod_New(func, obj, type);
+    }
+
+    static void
+    function_dealloc(PyObject* p)
+    {
+        delete static_cast<function*>(p);
+    }
+
+    static PyObject *
+    function_call(PyObject *func, PyObject *arg, PyObject *kw)
+    {
+        return static_cast<function*>(func)->call(arg, kw);
+    }
+}
+
+PyTypeObject function_type = {
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,
+    "Boost.Python.function",
+    sizeof(function),
+    0,
+    (destructor)function_dealloc,               /* tp_dealloc */
+    0,                                  /* tp_print */
+    0,                                  /* tp_getattr */
+    0,                                  /* tp_setattr */
+    0,                                  /* tp_compare */
+    0, //(reprfunc)func_repr,                   /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    0,                                  /* tp_hash */
+    function_call,                              /* tp_call */
+    0,                                  /* tp_str */
+    0, // PyObject_GenericGetAttr,            /* tp_getattro */
+    0, // PyObject_GenericSetAttr,            /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT /* | Py_TPFLAGS_HAVE_GC */,/* tp_flags */
+    0,                                  /* tp_doc */
+    0, // (traverseproc)func_traverse,          /* tp_traverse */
+    0,                                  /* tp_clear */
+    0,                                  /* tp_richcompare */
+    0, //offsetof(PyFunctionObject, func_weakreflist), /* tp_weaklistoffset */
+    0,                                  /* tp_iter */
+    0,                                  /* tp_iternext */
+    0,                                  /* tp_methods */
+    0, // func_memberlist,                      /* tp_members */
+    0, //func_getsetlist,                       /* tp_getset */
+    0,                                  /* tp_base */
+    0,                                  /* tp_dict */
+    function_descr_get,                 /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0, //offsetof(PyFunctionObject, func_dict),      /* tp_dictoffset */
+    0,                                      /* tp_init */
+    0,                                      /* tp_alloc */
+    0,
+    0                                       /* tp_new */
+};
+
+}}} // namespace boost::python::object
diff --git a/src/objects.cpp b/src/objects.cpp
index 70257388..90417dac 100644
--- a/src/objects.cpp
+++ b/src/objects.cpp
@@ -51,42 +51,42 @@ PyObject* object::get() const
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
-PyObject* to_python(const boost::python::tuple& x)
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::tuple& x)
 {
     return object_to_python(x);
 }
 
-boost::python::tuple from_python(PyObject* p, boost::python::type<boost::python::tuple> type)
+BOOST_PYTHON_DECL boost::python::tuple from_python(PyObject* p, boost::python::type<boost::python::tuple> type)
 {
     return boost::python::object_from_python(p, type);
 }
 
-PyObject* to_python(const boost::python::list& x)
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::list& x)
 {
     return object_to_python(x);
 }
 
-boost::python::list from_python(PyObject* p, boost::python::type<boost::python::list> type)
+BOOST_PYTHON_DECL boost::python::list from_python(PyObject* p, boost::python::type<boost::python::list> type)
 {
     return boost::python::object_from_python(p, type);
 }
 
-PyObject* to_python(const boost::python::dictionary& x)
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::dictionary& x)
 {
     return object_to_python(x);
 }
 
-boost::python::dictionary from_python(PyObject* p, boost::python::type<boost::python::dictionary> type)
+BOOST_PYTHON_DECL boost::python::dictionary from_python(PyObject* p, boost::python::type<boost::python::dictionary> type)
 {
     return boost::python::object_from_python(p, type);
 }
 
-PyObject* to_python(const boost::python::string& x)
+BOOST_PYTHON_DECL PyObject* to_python(const boost::python::string& x)
 {
     return object_to_python(x);
 }
 
-boost::python::string from_python(PyObject* p, boost::python::type<boost::python::string> type)
+BOOST_PYTHON_DECL boost::python::string from_python(PyObject* p, boost::python::type<boost::python::string> type)
 {
     return boost::python::object_from_python(p, type);
 }
@@ -95,14 +95,14 @@ BOOST_PYTHON_END_CONVERSION_NAMESPACE
 
 namespace boost { namespace python {
 
-tuple::tuple(std::size_t n)
+tuple_base::tuple_base(std::size_t n)
     : object(ref(PyTuple_New(n)))
 {
     for (std::size_t i = 0; i < n; ++i)
         PyTuple_SET_ITEM(get(), i, detail::none());
 }
     
-tuple::tuple(ref p)
+tuple_base::tuple_base(ref p)
     : object(p)
 {
     assert(accepts(p));
@@ -113,28 +113,28 @@ tuple::tuple(ref p)
     }
 }
 
-PyTypeObject* tuple::type_obj()
+PyTypeObject* tuple_base::type_obj()
 {
     return &PyTuple_Type;
 }
 
-bool tuple::accepts(ref p)
+bool tuple_base::accepts(ref p)
 {
     return PyTuple_Check(p.get());
 }
 
-std::size_t tuple::size() const
+std::size_t tuple_base::size() const
 {
     return PyTuple_Size(get());
 }
 
-ref tuple::operator[](std::size_t pos) const
+ref tuple_base::operator[](std::size_t pos) const
 {
     return ref(PyTuple_GetItem(get(), static_cast<int>(pos)),
                ref::increment_count);
 }
 
-void tuple::set_item(std::size_t pos, const ref& rhs)
+void tuple_base::set_item(std::size_t pos, const ref& rhs)
 {
     int failed = PyTuple_SetItem(
         get(), static_cast<int>(pos), ref(rhs).release()); // A reference is stolen here.
@@ -142,14 +142,14 @@ void tuple::set_item(std::size_t pos, const ref& rhs)
     assert(failed == 0);
 }
 
-tuple tuple::slice(int low, int high) const
+tuple tuple_base::slice(int low, int high) const
 {
     return tuple(ref(PyTuple_GetSlice(get(), low, high)));
 }
 
-tuple& tuple::operator+=(const tuple& rhs)
+BOOST_PYTHON_DECL tuple& operator+=(tuple& self, const tuple& rhs)
 {
-    return *this = *this + rhs;
+    return self = self + rhs;
 }
 
 
@@ -216,7 +216,7 @@ string& string::operator*=(unsigned int repeat_count)
     return *this;
 }
 
-dictionary::dictionary(ref p)
+dictionary_base::dictionary_base(ref p)
     : object(p)
 {
     assert(accepts(p));
@@ -227,49 +227,49 @@ dictionary::dictionary(ref p)
     }
 }
 
-dictionary::dictionary()
+dictionary_base::dictionary_base()
     : object(ref(PyDict_New())) {}
 
-PyTypeObject* dictionary::type_obj()
+PyTypeObject* dictionary_base::type_obj()
 { return &PyDict_Type; }
 
-bool dictionary::accepts(ref p)
+bool dictionary_base::accepts(ref p)
 { return PyDict_Check(p.get()); }
 
-void dictionary::clear()
+void dictionary_base::clear()
 { PyDict_Clear(get()); }
 
-const ref& dictionary::proxy::operator=(const ref& rhs)
+const ref& dictionary_proxy::operator=(const ref& rhs)
 {
     if (PyDict_SetItem(m_dict.get(), m_key.get(), rhs.get()) == -1)
         throw error_already_set();
     return rhs;
 }
 
-dictionary::proxy::operator ref() const
+dictionary_proxy::operator ref() const
 {
     return ref(m_dict->ob_type->tp_as_mapping->mp_subscript(m_dict.get(), m_key.get()),
                ref::increment_count);
 }
 
-dictionary::proxy::proxy(const ref& dict, const ref& key)
+dictionary_proxy::dictionary_proxy(const ref& dict, const ref& key)
     : m_dict(dict), m_key(key) {}
 
-dictionary::proxy dictionary::operator[](ref key)
+dictionary_proxy dictionary_base::operator[](ref key)
 { return proxy(reference(), key); }
     
-ref dictionary::operator[](ref key) const {
+ref dictionary_base::operator[](ref key) const {
     // An odd MSVC bug causes the ".operator Ptr()" to be needed
     return proxy(reference(), key).operator ref();
 }
 
     
-ref dictionary::get_item(const ref& key) const
+ref dictionary_base::get_item(const ref& key) const
 {
     return get_item(key, ref());
 }
 
-ref dictionary::get_item(const ref& key, const ref& default_) const
+ref dictionary_base::get_item(const ref& key, const ref& default_) const
 {
     PyObject* value_or_null = PyDict_GetItem(get(), key.get());
     if (value_or_null == 0 && !PyErr_Occurred())
@@ -278,22 +278,22 @@ ref dictionary::get_item(const ref& key, const ref& default_) const
         return ref(value_or_null, ref::increment_count); // Will throw if there was another error
 }
         
-void dictionary::set_item(const ref& key, const ref& value)
+void dictionary_base::set_item(const ref& key, const ref& value)
 {
     if (PyDict_SetItem(get(), key.get(), value.get()) == -1)
         throw error_already_set();
 }
 
-void dictionary::erase(ref key) {
+void dictionary_base::erase(ref key) {
     if (PyDict_DelItem(get(), key.get()) == -1)
         throw error_already_set();
 }
 
-list dictionary::items() const { return list(ref(PyDict_Items(get()))); }
-list dictionary::keys() const { return list(ref(PyDict_Keys(get()))); }
-list dictionary::values() const { return list(ref(PyDict_Values(get()))); }
+list dictionary_base::items() const { return list(ref(PyDict_Items(get()))); }
+list dictionary_base::keys() const { return list(ref(PyDict_Keys(get()))); }
+list dictionary_base::values() const { return list(ref(PyDict_Values(get()))); }
 
-std::size_t dictionary::size() const { return static_cast<std::size_t>(PyDict_Size(get())); }
+std::size_t dictionary_base::size() const { return static_cast<std::size_t>(PyDict_Size(get())); }
 
 string operator+(string x, string y)
 {
@@ -338,7 +338,7 @@ tuple operator+(const tuple& x, const tuple& y)
 }
 
 
-list::list(ref p)
+list_base::list_base(ref p)
     : object(p)
 {
     assert(accepts(p));
@@ -349,97 +349,97 @@ list::list(ref p)
     }
 }
 
-list::list(std::size_t sz)
+list_base::list_base(std::size_t sz)
     : object(ref(PyList_New(sz)))
 {
 }
 
-PyTypeObject* list::type_obj()
+PyTypeObject* list_base::type_obj()
 {
     return &PyList_Type;
 }
 
-bool list::accepts(ref p)
+bool list_base::accepts(ref p)
 {
     return PyList_Check(p.get());
 }
 
-std::size_t list::size() const
+std::size_t list_base::size() const
 {
     return PyList_Size(get());
 }
 
-ref list::operator[](std::size_t pos) const
+ref list_base::operator[](std::size_t pos) const
 {
     return ref(PyList_GetItem(get(), pos), ref::increment_count);
 }
 
-list::proxy list::operator[](std::size_t pos)
+list_proxy list_base::operator[](std::size_t pos)
 {
     return proxy(reference(), pos);
 }
 
-void list::insert(std::size_t index, const ref& item)
+void list_base::insert(std::size_t index, const ref& item)
 {
     if (PyList_Insert(get(), index, item.get()) == -1)
         throw error_already_set();
 }
 
-void list::push_back(const ref& item)
+void list_base::push_back(const ref& item)
 {
     if (PyList_Append(get(), item.get()) == -1)
         throw error_already_set();
 }
 
-void list::append(const ref& item)
+void list_base::append(const ref& item)
 {
     this->push_back(item);
 }
 
-list list::slice(int low, int high) const
+list list_base::slice(int low, int high) const
 {
     return list(ref(PyList_GetSlice(get(), low, high)));
 }
 
-list::slice_proxy list::slice(int low, int high)
+list_slice_proxy list_base::slice(int low, int high)
 {
-    return slice_proxy(reference(), low, high);
+    return list_slice_proxy(reference(), low, high);
 }
 
-void list::sort()
+void list_base::sort()
 {
     if (PyList_Sort(get()) == -1)
         throw error_already_set();
 }
 
-void list::reverse()
+void list_base::reverse()
 {
     if (PyList_Reverse(get()) == -1)
         throw error_already_set();
 }
 
-tuple list::as_tuple() const
+tuple list_base::as_tuple() const
 {
     return tuple(ref(PyList_AsTuple(get())));
 }
 
-const ref& list::proxy::operator=(const ref& rhs)
+const ref& list_proxy::operator=(const ref& rhs)
 {
     m_list.set_item(m_index, rhs);
     return rhs;
 }
 
-list::proxy::operator ref() const
+list_proxy::operator ref() const
 {
     return ref(PyList_GetItem(m_list.get(), m_index), ref::increment_count);
 }
 
-ref list::get_item(std::size_t pos) const
+ref list_base::get_item(std::size_t pos) const
 {
     return ref(PyList_GetItem(this->get(), pos), ref::increment_count);
 }
 
-void list::set_item(std::size_t pos, const ref& rhs)
+void list_base::set_item(std::size_t pos, const ref& rhs)
 {
     int result = PyList_SetItem(this->get(), pos, rhs.get());
     if (result == -1)
@@ -447,39 +447,39 @@ void list::set_item(std::size_t pos, const ref& rhs)
     Py_INCREF(rhs.get());
 }
 
-list::proxy::proxy(const ref& list, std::size_t index)
+list_proxy::list_proxy(const ref& list, std::size_t index)
     : m_list(list), m_index(index)
 {
 }
 
-const list& list::slice_proxy::operator=(const list& rhs)
+const list& list_slice_proxy::operator=(const list& rhs)
 {
     if (PyList_SetSlice(m_list.get(), m_low, m_high, rhs.get()) == -1)
         throw error_already_set();
     return rhs;
 }
 
-list::slice_proxy::operator ref() const
+list_slice_proxy::operator ref() const
 {
     return ref(PyList_GetSlice(m_list.get(), m_low, m_high));
 }
 
-list::slice_proxy::operator list() const
+list_slice_proxy::operator list() const
 {
     return list(this->operator ref());
 }
 
-std::size_t list::slice_proxy::size() const
+std::size_t list_slice_proxy::size() const
 {
     return this->operator list().size();
 }
 
-ref list::slice_proxy::operator[](std::size_t pos) const
+ref list_slice_proxy::operator[](std::size_t pos) const
 {
     return this->operator list()[pos].operator ref();
 }
 
-list::slice_proxy::slice_proxy(const ref& list, int low, int high)
+list_slice_proxy::list_slice_proxy(const ref& list, int low, int high)
     : m_list(list), m_low(low), m_high(high)
 {
 }
diff --git a/src/types.cpp b/src/types.cpp
index f411aa42..e76503d2 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -8,6 +8,7 @@
 
 #define BOOST_PYTHON_SOURCE
 
+#include <boost/python/detail/call_object.hpp>
 #include <boost/python/detail/types.hpp>
 #include <boost/python/reference.hpp> // for handle_exception()
 #include <boost/python/conversions.hpp>
@@ -25,9 +26,11 @@
 
 namespace boost { namespace python {
 
-namespace {
-
+namespace
+{
   using detail::type_object_base;
+  using detail::call_object;
+
 
   // Define a family of forwarding functions that can be called from a
   // PyTypeObject's slots. These functions dispatch through a (virtual) member
@@ -35,7 +38,6 @@ namespace {
   // uniform way, preventing us from having to rewrite the dispatching code over
   // and over.
 
-
   // Given a function object f with signature
   //
   //    PyObject* f(PyTypeObject*,PyObject*)
@@ -43,88 +45,24 @@ namespace {
   // calls f inside of handle_exception, and returns the result. If an exception
   // is thrown by f, returns 0.
   template <class F>
-  PyObject* obj_call(PyObject* obj, F const& f)
+  PyObject* obj_call(PyObject* obj, F f)
   {
-      return handle_exception(
-          boost::bind<PyObject*>(f, static_cast<type_object_base*>(obj->ob_type), obj));
+      PyObject* result;
+      return call_object(result, obj, f) ? 0 : result;
   }
 
-
-  // int_converter<T>/value_holder<T>
-  //
-  // A simple function object which converts its argument to a PyObject*. We
-  // need this because handle_exception needs to return a PyObject*, even if the
-  // function being called is supposed to return int. It has two parts...
-
-  // holds the value actually returned by the underlying function
-  template <class T>
-  struct value_holder : PyObject
-  {
-      value_holder() : is_set(false), value(-1) {}
-
-      // Tricky constructor allows us to grab the result even if rhs == 0.
-      explicit value_holder(value_holder const* rhs)
-          : is_set(rhs ? rhs->is_set : false), value(rhs ? rhs->value : -1) {}
-
-      // true if the function object was ever called (false if an exception occurred)
-      bool is_set;
-
-      // The returned value
-      T value;
-  };
-
-  // The function object
-  template <class R>
-  struct int_converter
-  {
-      typedef PyObject* result_type;
-      
-      PyObject* operator()(R const& x)
-      {
-          m_holder.is_set = true;
-          m_holder.value = x;
-          return &m_holder; // returns
-      }
-
-      value_holder<R> m_holder;
-  };
-
-  // Call the given int-returning function object inside of handle_exception,
-  // returning a value_holder. F is a function object with "signature"
+  // Call the given integer-returning function object inside of
+  // handle_exception, returning a value_holder. F is a function
+  // object with "signature"
   //
   //     R F(PyTypeObject*, PyObject*)
   //
   // where R is an integer type.
   template <class R, class F>
-  value_holder<R> int_call_holder(PyObject* obj, F f)
+  R int_call(PyObject* obj, F f, R* = 0)
   {
-      return value_holder<R>(
-          
-          // The int_converter object containing the value_holder is valid
-          // through the life of the full-expression, so we can construct from
-          // the pointer
-          static_cast<value_holder<R>*>(
-              handle_exception(
-
-                  boost::bind<PyObject*>(
-                      // Add an int_converter back-end to f
-                      int_converter<R>()
-                      // Bind the object's type and the object itself into f
-                      , boost::bind<R>(f, static_cast<type_object_base*>(obj->ob_type), obj)
-                      )
-                  
-                  )
-              )
-          );
-  }
-
-  // Just like int_call_holder (above), but returns the integer directly. If F
-  // throws an exception, returns -1
-  template <class R, class F>
-  R int_call(PyObject* obj, F f)
-  {
-      value_holder<R> const v(int_call_holder<R>(obj, f));
-      return v.value;
+      R result;
+      return call_object(result, obj, f) ? -1 : result;
   }
 
   // Implemented in terms of obj_call, above
@@ -171,27 +109,18 @@ namespace {
 
   int call_length_function(PyObject* obj, int (type_object_base::*f)(PyObject*) const)
   {
-      value_holder<int> const r(int_call_holder<int>(obj, bind(f, _1, _2)));
-      
-      if (!r.is_set)
-      {
+      int result;
+      if (call_object(result, obj, bind(f, _1, _2)))
           return -1;
-      }
       
-      const int outcome = r.value;
-      if (outcome >= 0)
-          return outcome;
+      if (result >= 0)
+          return result;
 
       PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0");
       return -1;
   }
 }  // anonymous namespace
 
-namespace detail {
-  // needed by void_adaptor (see void_adaptor.hpp)
-  PyObject arbitrary_object;
-}
-
 extern "C" {
 
 //
@@ -247,14 +176,11 @@ static PyObject* do_instance_call(PyObject* obj, PyObject* args, PyObject* keywo
 
 static void do_instance_dealloc(PyObject* obj)
 {
-    PyObject* success = handle_exception(
-        // translate the void return value of instance_dealloc into a PyObject*
-        // that can indicate no error.
-        detail::make_void_adaptor(
+    if (handle_exception(
             bind(&type_object_base::instance_dealloc
-                       , static_cast<type_object_base*>(obj->ob_type)
-                       , obj)));
-    if (!success)
+                 , static_cast<type_object_base*>(obj->ob_type)
+                 , obj))
+        )
     {
         assert(!"exception during destruction!");
     }
@@ -300,11 +226,9 @@ static PyObject* do_instance_sq_item(PyObject* obj, int index)
         return 0;
     }
 
-    return handle_exception(
-        bind(&type_object_base::instance_sequence_item
-             , static_cast<type_object_base*>(obj->ob_type)
-             , obj
-             , index));
+    return obj_call(
+        obj
+        , bind(&type_object_base::instance_sequence_item, _1, _2, index));
 }
 
 static int do_instance_mp_ass_subscript(PyObject* obj, PyObject* index, PyObject* value)
diff --git a/test/complicated.hpp b/test/complicated.hpp
new file mode 100644
index 00000000..123c53fe
--- /dev/null
+++ b/test/complicated.hpp
@@ -0,0 +1,39 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef COMPLICATED_DWA20011215_HPP
+# define COMPLICATED_DWA20011215_HPP
+# include <iostream>
+
+# include "simple_type.hpp"
+
+struct complicated
+{
+    complicated(simple const&, int = 0);
+    ~complicated();
+
+    int get_n() const;
+
+    char* s;
+    int n;
+};
+
+inline complicated::complicated(simple const&s, int n)
+    : s(s.s), n(n)
+{
+    std::cout << "constructing complicated: " << this->s << ", " << n << std::endl;
+}
+
+inline complicated::~complicated()
+{
+    std::cout << "destroying complicated: " << this->s << ", " << n << std::endl;
+}
+
+inline int complicated::get_n() const
+{
+    return n;
+}
+
+#endif // COMPLICATED_DWA20011215_HPP
diff --git a/test/m1.cpp b/test/m1.cpp
new file mode 100644
index 00000000..f4ad6390
--- /dev/null
+++ b/test/m1.cpp
@@ -0,0 +1,281 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+// Seems to be neccessary to suppress an ICE with MSVC
+#include "boost/mpl/comparison/less.hpp"
+
+#include "simple_type.hpp"
+#include "complicated.hpp"
+#include <boost/python/converter/wrapper.hpp>
+#include <boost/python/converter/unwrapper.hpp>
+#include <boost/python/detail/config.hpp>
+#include <boost/python/convert.hpp>
+#include <boost/python/object/value_holder.hpp>
+#include <boost/python/object/class_unwrapper.hpp>
+#include <boost/python/object/class.hpp>
+#include <boost/python/make_function.hpp>
+#include <boost/python/errors.hpp>
+#include <boost/mpl/type_list.hpp>
+#include <string.h>
+
+extern "C" void
+dealloc(PyObject* self)
+{
+    PyObject_Del(self);
+}
+
+struct NoddyObject : PyObject
+{
+    int x;
+};
+
+PyTypeObject NoddyType = {
+    PyObject_HEAD_INIT(NULL)
+    0,
+    "Noddy",
+    sizeof(NoddyObject),
+    0,
+    dealloc, /*tp_dealloc*/
+    0,          /*tp_print*/
+    0,          /*tp_getattr*/
+    0,          /*tp_setattr*/
+    0,          /*tp_compare*/
+    0,          /*tp_repr*/
+    0,          /*tp_as_number*/
+    0,          /*tp_as_sequence*/
+    0,          /*tp_as_mapping*/
+    0,          /*tp_hash */
+};
+
+struct SimpleObject : PyObject
+{
+    simple x;
+};
+
+PyTypeObject SimpleType = {
+    PyObject_HEAD_INIT(NULL)
+    0,
+    "Simple",
+    sizeof(SimpleObject),
+    0,
+    dealloc, /*tp_dealloc*/
+    0,          /*tp_print*/
+    0,          /*tp_getattr*/
+    0,          /*tp_setattr*/
+    0,          /*tp_compare*/
+    0,          /*tp_repr*/
+    0,          /*tp_as_number*/
+    0,          /*tp_as_sequence*/
+    0,          /*tp_as_mapping*/
+    0,          /*tp_hash */
+};
+
+extern "C" PyObject*
+new_noddy(PyObject* self, PyObject* args)
+{
+    NoddyObject* noddy;
+
+    if (!PyArg_ParseTuple(args,":new_noddy")) 
+        return NULL;
+
+    noddy = PyObject_New(NoddyObject, &NoddyType);
+    noddy->x = 42;
+    
+    return (PyObject*)noddy;
+}
+
+extern "C" PyObject*
+new_simple(PyObject* self, PyObject* args)
+{
+    SimpleObject* simple;
+
+    if (!PyArg_ParseTuple(args,":new_simple")) 
+        return NULL;
+
+    simple = PyObject_New(SimpleObject, &SimpleType);
+    simple->x.s = "hello, world";
+    
+    return (PyObject*)simple;
+}
+
+static PyMethodDef methods[] = {
+    { "new_noddy", new_noddy, METH_VARARGS },
+    { "new_simple", new_simple, METH_VARARGS },
+    {0, 0, 0, 0}
+};
+
+struct int_wrapper
+    : boost::python::converter::wrapper<int const&>
+{
+    PyObject* convert(int const& x) const
+    {
+        return PyInt_FromLong(x);
+    }
+};
+
+struct simple_wrapper
+    : boost::python::converter::wrapper<simple const&>
+{
+    PyObject* convert(simple const& x) const
+    {
+        SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
+        p->x = x;
+        return p;
+    }
+};
+
+struct simple_ref_wrapper
+    : boost::python::converter::wrapper<simple&>
+{
+    PyObject* convert(simple& x) const
+    {
+        SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
+        p->x = x;
+        return p;
+    }
+};
+
+struct native_int_unwrapper
+    : boost::python::converter::unwrapper<int>
+{
+    bool convertible(PyObject* p) const
+    {
+        return PyInt_Check(p);
+    }
+    
+    int convert(PyObject* p, void*&) const
+    {
+        return PyInt_AsLong(p);
+    }
+};
+
+struct noddy_int_unwrapper
+    : boost::python::converter::unwrapper<int>
+{
+    bool convertible(PyObject* p) const
+    {
+        return p->ob_type == &NoddyType;
+    }
+    
+    int convert(PyObject* p, void*&) const
+    {
+        return static_cast<NoddyObject*>(p)->x;
+    }
+};
+
+struct noddy_int_ref_unwrapper
+    : boost::python::converter::unwrapper<int&>
+{
+    bool convertible(PyObject* p) const
+    {
+        return p->ob_type == &NoddyType;
+    }
+    
+    int& convert(PyObject* p, void*&) const
+    {
+        return static_cast<NoddyObject*>(p)->x;
+    }
+};
+
+struct simple_ref_unwrapper
+    : boost::python::converter::unwrapper<simple&>
+{
+    bool convertible(PyObject* p) const
+    {
+        return p->ob_type == &SimpleType;
+    }
+    
+    simple& convert(PyObject* p, void*&) const
+    {
+        return static_cast<SimpleObject*>(p)->x;
+    }
+};
+
+struct simple_const_ref_unwrapper
+    : boost::python::converter::unwrapper<simple const&>
+{
+    bool convertible(PyObject* p) const
+    {
+        return p->ob_type == &SimpleType;
+    }
+    
+    simple const& convert(PyObject* p, void*&) const
+    {
+        return static_cast<SimpleObject*>(p)->x;
+    }
+};
+
+int f(simple const& s)
+{
+    return strlen(s.s);
+}
+
+simple const& g(simple const& x)
+{
+    return x;
+}
+
+BOOST_PYTHON_MODULE_INIT(m1)
+{
+    PyObject* m1 = Py_InitModule(const_cast<char*>("m1"), methods);
+
+    static int_wrapper wrap_int;
+    static simple_wrapper wrap_simple;
+    static native_int_unwrapper unwrap_int1;
+    static noddy_int_unwrapper unwrap_int2;
+    static noddy_int_ref_unwrapper unwrap_int3;
+    static simple_ref_unwrapper unwrap_simple;
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    // These compilers will need additional converters
+    static simple_const_ref_unwrapper unwrap_simple_const_ref;
+    static simple_ref_wrapper wrap_simple_ref;
+#endif
+    static boost::python::object::class_unwrapper<complicated> unwrap_complicated;
+    
+    PyObject* d = PyModule_GetDict(m1);
+    if (d == NULL)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "xclass", (PyObject *)boost::python::object::class_metatype()) < 0)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "xinst", (PyObject *)boost::python::object::class_type()) < 0)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "f", boost::python::make_function(f)) < 0)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "g", boost::python::make_function(g)) < 0)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "get_n", boost::python::make_function(&complicated::get_n)) < 0)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "init1"
+            , boost::python::make_constructor<
+                complicated
+                , boost::mpl::type_list<simple const&,int>
+                , boost::python::object::value_holder_generator>()
+            ) < 0)
+        return;
+
+    if (PyDict_SetItemString(
+            d, "init2"
+            , boost::python::make_constructor<
+                complicated
+                , boost::mpl::type_list<simple const&>
+                , boost::python::object::value_holder_generator>()
+            ) < 0)
+        return;
+}
+
+#include "module_tail.cpp"
diff --git a/test/m2.cpp b/test/m2.cpp
new file mode 100644
index 00000000..d2093a20
--- /dev/null
+++ b/test/m2.cpp
@@ -0,0 +1,197 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/convert.hpp>
+#include <boost/python/module.hpp>
+#include "simple_type.hpp"
+
+using boost::python::wrap;
+using boost::python::unwrap;
+
+extern "C" {
+    PyObject*
+    unwrap_simple(PyObject* self, PyObject* args)
+    {
+        PyObject* p;
+        if (!PyArg_ParseTuple(args, "O", &p))
+            return 0;
+
+        boost::python::unwrap<simple> in(p);
+        if (!in)
+            return 0;
+    
+        simple x = *in;
+    
+        return PyString_FromString(x.s);
+    };
+
+    PyObject*
+    unwrap_simple_ref(PyObject* self, PyObject* args)
+    {
+        PyObject* p;
+        if (!PyArg_ParseTuple(args, "O", &p))
+            return 0;
+
+        unwrap<simple&> in(p);
+        if (!in)
+            return 0;
+    
+        simple& x = *in;
+    
+        return PyString_FromString(x.s);
+    };
+
+    PyObject*
+    unwrap_simple_const_ref(PyObject* self, PyObject* args)
+    {
+        PyObject* p;
+        if (!PyArg_ParseTuple(args, "O", &p))
+            return 0;
+    
+        unwrap<simple const&> in(p);
+        if (!in)
+            return 0;
+    
+        simple const& x = *in;
+    
+        return PyString_FromString(x.s);
+    };
+
+    PyObject*
+    unwrap_int(PyObject* self, PyObject* args)
+    {
+        PyObject* p;
+        if (!PyArg_ParseTuple(args, "O", &p))
+            return 0;
+    
+        unwrap<int> in(p);
+        if (!in)
+            return 0;
+    
+        int x = *in;
+    
+        return PyInt_FromLong(x);
+    };
+
+    PyObject*
+    unwrap_int_ref(PyObject* self, PyObject* args)
+    {
+        PyObject* p;
+        if (!PyArg_ParseTuple(args, "O", &p))
+            return 0;
+    
+        unwrap<int&> in(p);
+        if (!in)
+            return 0;
+    
+        int& x = *in;
+    
+        return PyInt_FromLong(x);
+    };
+
+    PyObject*
+    unwrap_int_const_ref(PyObject* self, PyObject* args)
+    {
+        PyObject* p;
+        if (!PyArg_ParseTuple(args, "O", &p))
+            return 0;
+    
+        unwrap<int&> in(p);
+        if (!in)
+            return 0;
+    
+        int const& x = *in;
+    
+        return PyInt_FromLong(x);
+    };
+
+    // -------------------
+}
+template <class T> struct xxxx;
+
+template <class T>
+PyObject*
+rewrap(PyObject* self, PyObject* args, xxxx<T>* = 0)
+{
+    PyObject* p;
+    if (!PyArg_ParseTuple(args, "O", &p))
+        return 0;
+
+    boost::python::unwrap<T> in(p);
+    if (!in)
+        return 0;
+
+    boost::python::wrap<T> out;
+    if (!out)
+        return 0;
+    
+    T x = *in;
+    return out(x);
+}
+
+extern "C"
+{
+    PyObject*
+    wrap_simple(PyObject* self, PyObject* args)
+    {
+        return rewrap<simple>(self, args);
+    };
+
+    PyObject*
+    wrap_simple_ref(PyObject* self, PyObject* args)
+    {
+        return rewrap<simple&>(self, args);
+    };
+
+    PyObject*
+    wrap_simple_const_ref(PyObject* self, PyObject* args)
+    {
+        return rewrap<simple const&>(self, args);
+    };
+
+    PyObject*
+    wrap_int(PyObject* self, PyObject* args)
+    {
+        return rewrap<int>(self, args);
+    };
+
+    PyObject*
+    wrap_int_ref(PyObject* self, PyObject* args)
+    {
+        return rewrap<int&>(self, args);
+    };
+
+    PyObject*
+    wrap_int_const_ref(PyObject* self, PyObject* args)
+    {
+        return rewrap<int const&>(self, args);
+    };
+}
+
+PyMethodDef initial_methods[] =
+{
+    { "unwrap_int", unwrap_int, METH_VARARGS, 0 },
+    { "unwrap_int_ref", unwrap_int_ref, METH_VARARGS, 0 },
+    { "unwrap_int_const_ref", unwrap_int_const_ref, METH_VARARGS, 0 },
+    { "unwrap_simple", unwrap_simple, METH_VARARGS, 0 },
+    { "unwrap_simple_ref", unwrap_simple_ref, METH_VARARGS, 0 },
+    { "unwrap_simple_const_ref", unwrap_simple_const_ref, METH_VARARGS, 0 },
+
+    { "wrap_int", wrap_int, METH_VARARGS, 0 },
+    { "wrap_int_ref", wrap_int_ref, METH_VARARGS, 0 },
+    { "wrap_int_const_ref", wrap_int_const_ref, METH_VARARGS, 0 },
+    { "wrap_simple", wrap_simple, METH_VARARGS, 0 },
+    { "wrap_simple_ref", wrap_simple_ref, METH_VARARGS, 0 },
+    { "wrap_simple_const_ref", wrap_simple_const_ref, METH_VARARGS, 0 },
+    { 0, 0, 0, 0 }
+};
+
+BOOST_PYTHON_MODULE_INIT(m2)
+{
+    Py_InitModule(const_cast<char*>("m2"), initial_methods);
+}
+
+#include "module_tail.cpp"
diff --git a/test/module_tail.cpp b/test/module_tail.cpp
new file mode 100644
index 00000000..6849bf83
--- /dev/null
+++ b/test/module_tail.cpp
@@ -0,0 +1,39 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#if defined(_WIN32)
+# ifdef __MWERKS__
+#  pragma ANSI_strict off
+# endif
+# include <windows.h>
+# ifdef __MWERKS__
+#  pragma ANSI_strict reset
+# endif
+
+extern "C" BOOL WINAPI DllMain ( HINSTANCE hInst, DWORD wDataSeg, LPVOID lpvReserved );
+
+# ifdef BOOST_MSVC
+extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+{
+    throw;
+}
+# endif
+
+BOOL WINAPI DllMain(
+    HINSTANCE,  //hDllInst
+    DWORD fdwReason,
+    LPVOID  // lpvReserved
+    )
+{
+# ifdef BOOST_MSVC
+    _set_se_translator(structured_exception_translator);
+# endif
+    (void)fdwReason; // warning suppression.
+
+    return 1;
+}
+#endif // _WIN32
+
diff --git a/test/newtest.py b/test/newtest.py
new file mode 100644
index 00000000..783e2240
--- /dev/null
+++ b/test/newtest.py
@@ -0,0 +1,95 @@
+"""
+>>> from m1 import *
+
+>>> from m2 import *
+
+>>> n = new_noddy()
+>>> s = new_simple()
+>>> unwrap_int(n)
+42
+>>> unwrap_int_ref(n)
+42
+>>> unwrap_int_const_ref(n)
+42
+>>> unwrap_simple(s)
+'hello, world'
+>>> unwrap_simple_ref(s)
+'hello, world'
+>>> unwrap_simple_const_ref(s)
+'hello, world'
+>>> unwrap_int(5)
+5
+
+Can't get a reference to a built-in integer object
+>>> try:
+...     unwrap_int_ref(7)
+... except: pass
+... else: print 'no exception'
+
+>>> try:
+...     unwrap_int_const_ref(9)
+... except: pass
+... else: print 'no exception'
+
+>>> wrap_int(n)
+42
+
+try: wrap_int_ref(n)
+... except: pass
+... else: print 'no exception'
+
+>>> wrap_int_const_ref(n)
+42
+
+>>> unwrap_simple_ref(wrap_simple(s))
+'hello, world'
+
+>>> unwrap_simple_ref(wrap_simple_ref(s))
+'hello, world'
+
+>>> unwrap_simple_ref(wrap_simple_const_ref(s))
+'hello, world'
+
+>>> f(s)
+12
+
+>>> unwrap_simple(g(s))
+'hello, world'
+
+>>> f(g(s))
+12
+
+>>> C = xclass('C', (xinst,), {'__init__': init1, 'get_n': get_n})
+>>> c = C(s, 99)
+>>> c.get_n()
+99
+
+>>> D = xclass('D', (xinst,), {'__init__': init2, 'get_n': get_n})
+>>> d = D(s)
+>>> d.get_n()
+0
+
+"""
+
+def run(args = None):
+
+    ### Strange bug somewhere: with Metrowerks: it will crash in
+    ### garbage-collection code unless traceback and sre have been
+    ### loaded before m1.
+    
+#     import traceback
+#     import sre
+#     import m2
+#     import m1
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    # import sys
+    return doctest.testmod(sys.modules.get(__name__))
+    
+if __name__ == '__main__':
+    print "running..."
+    import sys
+    sys.exit(run()[0])
diff --git a/test/simple_type.hpp b/test/simple_type.hpp
new file mode 100644
index 00000000..2df97cfd
--- /dev/null
+++ b/test/simple_type.hpp
@@ -0,0 +1,14 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef SIMPLE_TYPE_DWA2001128_HPP
+# define SIMPLE_TYPE_DWA2001128_HPP
+
+struct simple
+{
+    char* s;
+};
+
+#endif // SIMPLE_TYPE_DWA2001128_HPP

From 14f6f8852646f649823774e4ed69877bb0edf17d Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 28 Dec 2001 13:26:36 +0000
Subject: [PATCH 173/369] irix_CC workaround; updated makefiles

[SVN r12163]
---
 build/como.mak                         |  1 +
 build/filemgr.py                       |  1 +
 build/gcc.mak                          |  1 +
 build/irix_CC.mak                      | 10 +++++-----
 build/linux_gcc.mak                    | 10 +++++-----
 build/mingw32.mak                      |  2 +-
 build/tru64_cxx.mak                    | 10 +++++-----
 build/vc60.mak                         | 16 ++++++++--------
 build/win32_mwcc.mak                   |  6 +++---
 include/boost/python/detail/config.hpp |  9 +++++++++
 10 files changed, 39 insertions(+), 27 deletions(-)

diff --git a/build/como.mak b/build/como.mak
index 8f05e309..edf05f83 100644
--- a/build/como.mak
+++ b/build/como.mak
@@ -7,6 +7,7 @@ LIBSRC = \
     classes.cpp \
     conversions.cpp \
     cross_module.cpp \
+    errors.cpp \
     extension_class.cpp \
     functions.cpp \
     init_function.cpp \
diff --git a/build/filemgr.py b/build/filemgr.py
index 99f4ca30..93cef1cb 100644
--- a/build/filemgr.py
+++ b/build/filemgr.py
@@ -8,6 +8,7 @@ bpl_exa = "/libs/python/example"
 files = (
 bpl_src + "/classes.cpp",
 bpl_src + "/conversions.cpp",
+bpl_src + "/errors.cpp",
 bpl_src + "/extension_class.cpp",
 bpl_src + "/functions.cpp",
 bpl_src + "/init_function.cpp",
diff --git a/build/gcc.mak b/build/gcc.mak
index ce718f2b..b818030e 100644
--- a/build/gcc.mak
+++ b/build/gcc.mak
@@ -11,6 +11,7 @@ LIBSRC = \
     classes.cpp \
     conversions.cpp \
     cross_module.cpp \
+    errors.cpp \
     extension_class.cpp \
     functions.cpp \
     init_function.cpp \
diff --git a/build/irix_CC.mak b/build/irix_CC.mak
index ec387746..f7d6004e 100644
--- a/build/irix_CC.mak
+++ b/build/irix_CC.mak
@@ -17,10 +17,10 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
-PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
-#PYINC=-I/usr/local/Python-2.1/include/python2.1
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+PYEXE=PYTHONPATH=. /usr/local_cci/Python-2.1.1/bin/python
+PYINC=-I/usr/local_cci/Python-2.1.1/include/python2.1
 STLPORTINC=-I$(BOOST)/boost/compatibility/cpp_c_headers
 
 STDOPTS=
@@ -35,7 +35,7 @@ MAKEDEP=-M
 LD=CC -LANG:std -n32 -mips4
 LDOPTS=-shared
 
-OBJ=classes.o conversions.o extension_class.o functions.o \
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
     init_function.o module_builder.o \
     objects.o types.o cross_module.o
 DEPOBJ=$(OBJ) \
diff --git a/build/linux_gcc.mak b/build/linux_gcc.mak
index ef643991..3b466e7d 100644
--- a/build/linux_gcc.mak
+++ b/build/linux_gcc.mak
@@ -17,12 +17,12 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=PYTHONPATH=. /usr/bin/python
-PYINC=-I/usr/include/python1.5
+#PYEXE=PYTHONPATH=. /usr/bin/python
+#PYINC=-I/usr/include/python1.5
 #PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
 #PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
-#PYINC=-I/usr/local/Python-2.1/include/python2.1
+PYEXE=PYTHONPATH=. /usr/local_cci/Python-2.1.1/bin/python
+PYINC=-I/usr/local_cci/Python-2.1.1/include/python2.1
 
 STDOPTS=-fPIC -ftemplate-depth-21
 WARNOPTS=
@@ -36,7 +36,7 @@ MAKEDEP=-M
 LD=$(CPP)
 LDOPTS=-shared
 
-OBJ=classes.o conversions.o extension_class.o functions.o \
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
     init_function.o module_builder.o \
     objects.o types.o cross_module.o
 DEPOBJ=$(OBJ) \
diff --git a/build/mingw32.mak b/build/mingw32.mak
index bf590409..d8c31b68 100644
--- a/build/mingw32.mak
+++ b/build/mingw32.mak
@@ -52,7 +52,7 @@ CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) -I$(BOOST_WIN) $(PYINC) \
 LD=g++
 LDOPTS=-shared
 
-OBJ=classes.o conversions.o extension_class.o functions.o \
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
     init_function.o module_builder.o \
     objects.o types.o cross_module.o
 
diff --git a/build/tru64_cxx.mak b/build/tru64_cxx.mak
index f996a0c1..a64927b1 100644
--- a/build/tru64_cxx.mak
+++ b/build/tru64_cxx.mak
@@ -17,10 +17,10 @@
 ROOT=$(HOME)
 BOOST=$(ROOT)/boost
 
-PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
-PYINC=-I/usr/local/Python-1.5.2/include/python1.5
-#PYEXE=PYTHONPATH=. /usr/local/Python-2.1/bin/python
-#PYINC=-I/usr/local/Python-2.1/include/python2.1
+#PYEXE=PYTHONPATH=. /usr/local/Python-1.5.2/bin/python
+#PYINC=-I/usr/local/Python-1.5.2/include/python1.5
+PYEXE=PYTHONPATH=. /usr/local_cci/Python-2.1.1/bin/python
+PYINC=-I/usr/local_cci/Python-2.1.1/include/python2.1
 #STLPORTINC=-I/usr/local/STLport-4.1b3/stlport
 #STLPORTINC=-I/usr/local/STLport-4.1b4/stlport
 #STLPORTOPTS= \
@@ -46,7 +46,7 @@ LDOPTS=-shared -expect_unresolved 'Py*' -expect_unresolved '_Py*'
 
 #HIDDEN=-hidden
 
-OBJ=classes.o conversions.o extension_class.o functions.o \
+OBJ=classes.o conversions.o errors.o extension_class.o functions.o \
     init_function.o module_builder.o \
     objects.o types.o cross_module.o
 DEPOBJ=$(OBJ) \
diff --git a/build/vc60.mak b/build/vc60.mak
index a348de54..6f303791 100644
--- a/build/vc60.mak
+++ b/build/vc60.mak
@@ -14,14 +14,14 @@ ROOT=R:
 BOOST_WIN="$(ROOT)\boost"
 BOOST_UNIX=$(HOME)/boost
 
-PYEXE="C:\Program files\Python\python.exe"
-PYINC=/I"C:\Program files\Python\include"
-PYLIB="C:\Program files\Python\libs\python15.lib"
-#PYEXE="C:\Python21\python.exe"
-#PYINC=/I"C:\Python21\include"
-#PYLIB="C:\Python21\libs\python21.lib"
+#PYEXE="C:\Program files\Python\python.exe"
+#PYINC=/I"C:\Program files\Python\include"
+#PYLIB="C:\Program files\Python\libs\python15.lib"
+PYEXE="C:\Python21\python.exe"
+PYINC=/I"C:\Python21\include"
+PYLIB="C:\Python21\libs\python21.lib"
 
-STDOPTS=/nologo /MD /GR /GX /Zm200
+STDOPTS=/nologo /MD /GR /GX /Zm200 /DBOOST_PYTHON_STATIC_LIB
 WARNOPTS=
 OPTOPTS=
 
@@ -32,7 +32,7 @@ CPPOPTS=$(STLPORTINC) $(STLPORTOPTS) /I$(BOOST_WIN) $(PYINC) \
 LD=link.exe
 LDOPTS=/nologo /dll /incremental:no
 
-OBJ=classes.obj conversions.obj extension_class.obj functions.obj \
+OBJ=classes.obj conversions.obj errors.obj extension_class.obj functions.obj \
     init_function.obj module_builder.obj \
     objects.obj types.obj cross_module.obj
 
diff --git a/build/win32_mwcc.mak b/build/win32_mwcc.mak
index ac054c07..c49af71c 100755
--- a/build/win32_mwcc.mak
+++ b/build/win32_mwcc.mak
@@ -10,7 +10,7 @@
 #   14 Dec 01 derived from vc60.mak (R.W. Grosse-Kunstleve)
 
 ROOT=R:
-BOOST_WIN="$(ROOT)\boostdev"
+BOOST_WIN="$(ROOT)\boost"
 BOOST_UNIX=$(HOME)/boost
 
 #PYEXE="C:\Program files\Python\python.exe"
@@ -20,7 +20,7 @@ PYEXE="C:\Python21\python.exe"
 PYINC=-I"C:\Python21\include"
 PYLIB="C:\Python21\libs\python21.lib"
 
-STDOPTS=-gccinc -prefix UseDLLPrefix.h
+STDOPTS=-gccinc -prefix UseDLLPrefix.h -DBOOST_PYTHON_STATIC_LIB
 WARNOPTS=-warn on,nounusedexpr,nounused
 OPTOPTS=-O
 
@@ -31,7 +31,7 @@ CPPOPTS=$(STDOPTS) $(WARNOPTS) $(OPTOPTS) \
 LD=mwld
 LDOPTS=-export dllexport -shared
 
-OBJ=classes.obj conversions.obj extension_class.obj functions.obj \
+OBJ=classes.obj conversions.obj errors.obj extension_class.obj functions.obj \
     init_function.obj module_builder.obj \
     objects.obj types.obj cross_module.obj
 
diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 498fa07a..c79eb2ca 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -129,4 +129,13 @@
 #  endif
 #endif
 
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::detail::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace detail {
+class function;
+}}}
+#endif
+
 #endif // CONFIG_DWA052200_H_

From 2eb2e52a79dbd4d24be54cda2b1cd864e8ca8e31 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 28 Dec 2001 23:52:01 +0000
Subject: [PATCH 174/369] workaround some compiler limitations

[SVN r12165]
---
 .../boost/python/detail/extension_class.hpp   | 54 +++++++++++--------
 1 file changed, 32 insertions(+), 22 deletions(-)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 00f9b6b4..05ebe229 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -38,20 +38,45 @@ template <class T> struct right_operand;
 
 enum without_downcast_t { without_downcast };
 
-namespace detail {
+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;
+  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;
 
+  class BOOST_PYTHON_DECL 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;
+  };
+
+} // namespace detail
+
+# ifndef BOOST_PYTHON_NO_TEMPLATE_EXPORT
+BOOST_PYTHON_EXPORT_TEMPLATE_CLASS class_t<detail::extension_instance>;
+BOOST_PYTHON_EXPORT_TEMPLATE_CLASS meta_class<detail::extension_instance>;
+# endif 
+
+namespace detail {
+
 BOOST_PYTHON_DECL meta_class<extension_instance>* extension_meta_class();
 BOOST_PYTHON_DECL extension_instance* get_extension_instance(PyObject* p);
 BOOST_PYTHON_DECL void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
@@ -813,21 +838,6 @@ class instance_ptr_holder : public instance_holder<HeldType>
     PtrType m_ptr;
 };
 
-class BOOST_PYTHON_DECL 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
 //

From ed9bc835a267ff3fc5116708bb50c71d38868f3b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 28 Dec 2001 23:56:10 +0000
Subject: [PATCH 175/369] Stuck the extension_class code in the DLL whenever
 possible Removed some flotsam

[SVN r12166]
---
 include/boost/python/detail/config.hpp | 44 ++++++++++++++++++++------
 1 file changed, 35 insertions(+), 9 deletions(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index c79eb2ca..97d84a79 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -76,19 +76,29 @@
 #  define BOOST_PYTHON_STATIC_LINK
 #endif
 
-#if defined(BOOST_MSVC) && defined(_DLL) && !defined(BOOST_PYTHON_HAS_DLL_RUNTIME)
-#  define BOOST_PYTHON_HAS_DLL_RUNTIME
+#if defined(__MWERKS__)
+# define BOOST_PYTHON_NO_TEMPLATE_EXPORT
 #endif
 
-#if defined(__BORLANDC__) && defined(_RTLDLL) && !defined(BOOST_PYTHON_HAS_DLL_RUNTIME)
-#  define BOOST_PYTHON_HAS_DLL_RUNTIME
+#if defined(__GNUC__)
+# define BOOST_PYTHON_IMPORT_TEMPLATE_KEYWORD extern
+# define BOOST_PYTHON_EXPORT_TEMPLATE_KEYWORD extern
 #endif
 
-#if defined(__ICL) && defined(_DLL) && !defined(BOOST_PYTHON_HAS_DLL_RUNTIME)
-#  define BOOST_PYTHON_HAS_DLL_RUNTIME
+// Handle default cases
+#ifndef BOOST_PYTHON_IMPORT_TEMPLATE_KEYWORD
+# ifdef _WIN32
+#  define BOOST_PYTHON_IMPORT_TEMPLATE_KEYWORD extern
+# else
+#  define BOOST_PYTHON_IMPORT_TEMPLATE_KEYWORD
+# endif 
 #endif
 
-#if defined(BOOST_PYTHON_DYNAMIC_LIB) && defined(_WIN32) // && !defined(BOOST_PYTHON_STATIC_LINK)
+#ifndef BOOST_PYTHON_EXPORT_TEMPLATE_KEYWORD
+# define BOOST_PYTHON_EXPORT_TEMPLATE_KEYWORD
+#endif 
+
+#if defined(BOOST_PYTHON_DYNAMIC_LIB) && defined(_WIN32)
 #  if defined(BOOST_PYTHON_SOURCE)
 #     define BOOST_PYTHON_DECL __declspec(dllexport)
 #     define BOOST_PYTHON_BUILD_DLL
@@ -101,10 +111,26 @@
 #  define BOOST_PYTHON_DECL
 #endif
 
-#if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_PYTHON_NO_LIB) && !defined(BOOST_PYTHON_SOURCE)
-// #  include <boost/python/detail/python_library_include.hpp>
+#ifndef BOOST_PYTHON_DECL_TEMPLATE
+# ifndef BOOST_PYTHON_NO_TEMPLATE_EXPORT
+#  define BOOST_PYTHON_DECL_TEMPLATE BOOST_PYTHON_DECL
+# else
+#  define BOOST_PYTHON_DECL_TEMPLATE
+# endif
 #endif
 
+#if defined(BOOST_PYTHON_SOURCE)
+# define BOOST_PYTHON_EXPORT BOOST_PYTHON_EXPORT_TEMPLATE_KEYWORD
+#else
+# define BOOST_PYTHON_EXPORT BOOST_PYTHON_IMPORT_TEMPLATE_KEYWORD
+#endif
+
+# ifndef BOOST_PYTHON_EXPORT_TEMPLATE
+#  define  BOOST_PYTHON_EXPORT_TEMPLATE BOOST_PYTHON_EXPORT template
+# endif
+
+# define BOOST_PYTHON_EXPORT_TEMPLATE_CLASS BOOST_PYTHON_EXPORT template class BOOST_PYTHON_DECL
+
 // Borland C++ Fix/error check:
 #if defined(__BORLANDC__)
 #  if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551)

From 94c0e947f5f6c03bd73ac66627de95f900d583e7 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 28 Dec 2001 23:59:02 +0000
Subject: [PATCH 176/369] Stuck the extension_class code in the DLL whenever
 possible Removed copyability restriction in class_base to enable the above

[SVN r12167]
---
 include/boost/python/classes.hpp | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/include/boost/python/classes.hpp b/include/boost/python/classes.hpp
index 548a57db..31af430f 100644
--- a/include/boost/python/classes.hpp
+++ b/include/boost/python/classes.hpp
@@ -128,6 +128,10 @@ namespace detail {
 
    private: // boost::python::type_object_base required interface implementation
       void instance_dealloc(PyObject*) const; // subclasses should not override this
+    
+   private: // noncopyable, without the size bloat
+      class_base(const class_base&);
+      void operator=(const class_base&);
       
    private:
       string m_name;
@@ -141,11 +145,12 @@ namespace detail {
 // 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
+class BOOST_PYTHON_DECL_TEMPLATE class_t
     : public boost::python::detail::class_base
 {
  public:
     class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space);
+    ~class_t();
     
     // Standard Python functions.
     PyObject* call(PyObject* args, PyObject* keywords);
@@ -218,15 +223,11 @@ class class_t
 
  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
+class BOOST_PYTHON_DECL_TEMPLATE meta_class
     : public boost::python::detail::reprable<
                 boost::python::detail::callable<
                    boost::python::detail::getattrable<
@@ -264,6 +265,11 @@ class_t<T>::class_t(meta_class<T>* meta_class_obj, string name, tuple bases, con
 {
 }
 
+template <class T>
+class_t<T>::~class_t()
+{
+}
+
 template <class T>
 void class_t<T>::delete_instance(PyObject* obj) const
 {

From dc831fb3f62897eb052d6e37fc8e64daa061a364 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 29 Dec 2001 00:00:19 +0000
Subject: [PATCH 177/369] Stuck the extension_class code in the DLL whenever
 possible

[SVN r12168]
---
 src/extension_class.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index f8bcf9ad..cc784ca6 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -11,6 +11,7 @@
 
 #define BOOST_PYTHON_SOURCE
 
+#include <boost/python/detail/extension_class.hpp>
 #include <boost/python/detail/extension_class.hpp>
 #include <boost/python/detail/call_object.hpp>
 #include <boost/utility.hpp>
@@ -681,4 +682,9 @@ PyNumberMethods operator_dispatcher::number_methods =
 
 } // namespace detail
 
+# ifndef BOOST_PYTHON_NO_TEMPLATE_EXPORT
+template class BOOST_PYTHON_DECL meta_class<detail::extension_instance>;
+template class BOOST_PYTHON_DECL class_t<detail::extension_instance>;
+# endif
+
 }} // namespace boost::python

From 1247ff2543e8816a0c9f9ea2eaf39609a57aaffd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 31 Dec 2001 17:02:43 +0000
Subject: [PATCH 178/369] *** empty log message ***

[SVN r12177]
---
 include/boost/python/converter/unwrap.hpp | 31 +++--------------------
 1 file changed, 3 insertions(+), 28 deletions(-)

diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
index 6dda61fb..4a2ea04c 100644
--- a/include/boost/python/converter/unwrap.hpp
+++ b/include/boost/python/converter/unwrap.hpp
@@ -11,6 +11,7 @@
 # include <boost/python/converter/handle.hpp>
 # include <boost/python/converter/registration.hpp>
 # include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/unwrapper_select.hpp>
 # include <boost/python/export.hpp>
 
 namespace boost { namespace python { namespace converter { 
@@ -55,7 +56,7 @@ struct unwrap_more_ : unwrap_base
     // unspecified storage which may be allocated by the unwrapper to
     // do value conversions.
     mutable void* m_storage;
-    friend class unwrapper<T>;
+    typedef typename unwrapper_select<T>::type unwrapper_t;
 };
 
 // specialization for PyObject*
@@ -142,32 +143,6 @@ unwrap_more_<T>::unwrap_more_(PyObject* source)
 {
 }
 
-# if 0
-template <>
-inline unwrap_more_<PyObject*>::unwrap_more_(PyObject* source, handle& prev)
-    : unwrap_base(source, m_unwrapper, prev)
-{
-}
-
-template <>
-inline unwrap_more_<PyObject*>::unwrap_more_(PyObject* source)
-    : unwrap_base(source, m_unwrapper)
-
-{
-}
-
-template <>
-inline PyObject* unwrap_more_<PyObject*>::operator*()
-{
-    return source();
-}
-
-template <>
-inline bool unwrap_more_<PyObject*>::convertible(PyObject*) const
-{
-    return true;
-}
-# endif 
 template <class T>
 inline unwrap_<T>::unwrap_(PyObject* source)
     : unwrap_more_<T>(source)
@@ -178,7 +153,7 @@ template <class T>
 T unwrap_more_<T>::operator*()
 {
     return static_cast<unwrapper<T>*>(
-        get_body())->do_conversion(this);
+        get_body())->convert(this->m_source, this->m_storage);
 }
 
 template <class T>

From 015b875a9ec0bc82016959bea34e18bc061965ea Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:21:06 +0000
Subject: [PATCH 179/369] Convertibility checks now collect the auxiliary
 conversion data

[SVN r12186]
---
 src/converter/registry.cpp  | 50 +++++++++++++------------------------
 src/converter/unwrap.cpp    | 10 ++++----
 src/converter/unwrapper.cpp |  7 ++++++
 3 files changed, 29 insertions(+), 38 deletions(-)

diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
index 88d96637..d247353c 100644
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -39,35 +39,6 @@ namespace registry
   {
   }
 
-  namespace // <unnamed>
-  {
-    // A UnaryFunction type which deletes its argument
-    struct delete_item
-    {
-        template <class T>
-        void operator()(T* x) const
-        {
-            delete x;
-        }
-    };
-
-    // A UnaryFunction type which returns true iff its argument is a
-    // unwrapper which can convert the given Python object.
-    struct convertible
-    {
-        convertible(PyObject* p)
-            : m_p(p)
-        {}
-        
-        bool operator()(unwrapper_base* converter) const
-        {
-            return converter->convertible(m_p);
-        }
-        
-        PyObject* m_p;
-    };
-  }
-
   entry::~entry()
   {
       if (m_wrapper != 0)
@@ -79,12 +50,25 @@ namespace registry
       }
   }
 
-  unwrapper_base* entry::unwrapper(PyObject* p) const
+  std::pair<unwrapper_base*,void*>
+  entry::unwrapper(PyObject* p) const
   {
-      unwrappers::const_iterator q =
-          std::find_if(m_unwrappers.begin(), m_unwrappers.end(), convertible(p));
+      unwrapper_base* body = 0;
+      void* data = 0;
       
-      return q == m_unwrappers.end() ? 0 : *q;
+      for (unwrappers::const_iterator q = m_unwrappers.begin(),
+               finish = m_unwrappers.end();
+           q != finish;
+           ++q)
+      {
+          data = (*q)->can_convert(p);
+          if (data != 0)
+          {
+              body = *q;
+              break;
+          }
+      }
+      return std::make_pair(body,data);
   }
   
   wrapper_base* entry::wrapper() const
diff --git a/src/converter/unwrap.cpp b/src/converter/unwrap.cpp
index e0c09db6..33a7d7ae 100644
--- a/src/converter/unwrap.cpp
+++ b/src/converter/unwrap.cpp
@@ -13,7 +13,7 @@ namespace
   struct pyobject_unwrapper : unwrapper_base
   {
       pyobject_unwrapper();
-      bool convertible(PyObject*) const;
+      void* can_convert(PyObject*) const;
   };
   
   pyobject_unwrapper static_unwrapper;
@@ -23,13 +23,13 @@ namespace
   {
   }
       
-  bool pyobject_unwrapper::convertible(PyObject*) const
+  void* pyobject_unwrapper::can_convert(PyObject*) const
   {
-      return true;
+      return non_null;
   }
 }
 
-BOOST_PYTHON_EXPORT unwrapper_base*
-unwrap_more_<PyObject*>::m_unwrapper = &static_unwrapper;
+BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*>
+unwrap_more_<PyObject*>::m_unwrapper(&static_unwrapper,&static_unwrapper);
 
 }}} // namespace boost::python::converter
diff --git a/src/converter/unwrapper.cpp b/src/converter/unwrapper.cpp
index 2b0adbd0..6279febf 100644
--- a/src/converter/unwrapper.cpp
+++ b/src/converter/unwrapper.cpp
@@ -21,4 +21,11 @@ unwrapper_base::~unwrapper_base()
         registry::remove(*this);
 }
 
+namespace
+{
+  int arbitrary;
+}
+
+void* const unwrapper_base::non_null = &arbitrary;
+
 }}} // namespace boost::python::converter

From e934be2d991249f2bf18ce58a520e40ef8abb113 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:21:31 +0000
Subject: [PATCH 180/369] BOOST_PYTHON_EXPORT -> BOOST_PYTHON_DECL

[SVN r12187]
---
 src/converter/type_id.cpp |  2 +-
 src/object/class.cpp      | 10 ++++------
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/converter/type_id.cpp b/src/converter/type_id.cpp
index 86974638..fc2db66a 100644
--- a/src/converter/type_id.cpp
+++ b/src/converter/type_id.cpp
@@ -19,7 +19,7 @@ bool type_id_before::operator()(type_id_t const& x, type_id_t const&  y) const
     return x < y;
 }
 
-BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream& os, type_id_t const& x)
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, type_id_t const& x)
 {
 #  ifdef BOOST_PYTHON_TYPE_ID_NAME
     os << x.m_base_type;
diff --git a/src/object/class.cpp b/src/object/class.cpp
index cc3903e3..bdd66a77 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -4,7 +4,7 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
 
-#include <boost/python/export.hpp>
+#include <boost/python/detail/config.hpp>
 #include <boost/python/module.hpp>
 #include <boost/python/detail/wrap_python.hpp>
 #include <boost/python/object/class.hpp>
@@ -23,7 +23,6 @@ holder_base::~holder_base()
 {
 }
 
-//BOOST_PYTHON_EXPORT
 PyTypeObject class_metatype_object = {
     PyObject_HEAD_INIT(0)//&PyType_Type)
         0,
@@ -68,7 +67,6 @@ PyTypeObject class_metatype_object = {
         // PyType_GenericNew                       /* tp_new */
 };
 
-//BOOST_PYTHON_EXPORT
 PyTypeObject class_type_object = {
     PyObject_HEAD_INIT(0) //&class_metatype_object)
         0,
@@ -112,7 +110,7 @@ PyTypeObject class_type_object = {
         PyType_GenericNew
 };
 
-BOOST_PYTHON_EXPORT PyTypeObject* class_metatype()
+BOOST_PYTHON_DECL PyTypeObject* class_metatype()
 {
     if (class_metatype_object.tp_dict == 0)
     {
@@ -125,7 +123,7 @@ BOOST_PYTHON_EXPORT PyTypeObject* class_metatype()
     return &class_metatype_object;
 }
 
-BOOST_PYTHON_EXPORT PyTypeObject* class_type()
+BOOST_PYTHON_DECL PyTypeObject* class_type()
 {
     if (class_type_object.tp_dict == 0)
     {
@@ -145,7 +143,7 @@ void holder_base::install(PyObject* self)
     ((instance*)self)->objects = this;
 }
 
-BOOST_PYTHON_EXPORT holder_base*
+BOOST_PYTHON_DECL holder_base*
 find_holder_impl(PyObject* inst, converter::type_id_t type)
 {
     if (inst->ob_type->ob_type != &class_metatype_object)

From a7b844810789cb6c7daa7c61187d3e1a55ae09e1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:45:49 +0000
Subject: [PATCH 181/369] obsolete now that Boost.Python is in a shared lib.

[SVN r12188]
---
 include/boost/python/export.hpp | 20 --------------------
 1 file changed, 20 deletions(-)
 delete mode 100644 include/boost/python/export.hpp

diff --git a/include/boost/python/export.hpp b/include/boost/python/export.hpp
deleted file mode 100644
index 1229dffe..00000000
--- a/include/boost/python/export.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef EXPORT_DWA20011220_HPP
-# define EXPORT_DWA20011220_HPP
-
-# include <boost/python/detail/config.hpp>
-# ifdef _WIN32
-#  ifdef BOOST_PYTHON_SOURCE
-#   define BOOST_PYTHON_EXPORT __declspec(dllexport)
-#  else 
-#   define BOOST_PYTHON_EXPORT __declspec(dllimport)
-#  endif
-# else
-#  define BOOST_PYTHON_EXPORT
-# endif 
-
-#endif // EXPORT_DWA20011220_HPP

From ccd21d52549450c82284a71f2712e602f1feb212 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:47:32 +0000
Subject: [PATCH 182/369] Accounting for by-value conversions Convertibility
 checks now collect the auxiliary conversion data

[SVN r12189]
---
 include/boost/python/converter/class.hpp | 78 +++++++++++++-----------
 1 file changed, 43 insertions(+), 35 deletions(-)

diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
index 305ec448..6e09a961 100644
--- a/include/boost/python/converter/class.hpp
+++ b/include/boost/python/converter/class.hpp
@@ -11,46 +11,54 @@
 
 namespace boost { namespace python { namespace converter { 
 
-struct class_unwrapper_base
-{
-    class_unwrapper_base(type_id_t sought_type);
-    void*
-};
-
 template <class T>
 struct class_unwrapper
+    : private unwrapper<T&>
+    , private unwrapper<T const&>
+    , private unwrapper<T*>
+    , private unwrapper<T const*>
 {
-    struct ref_unwrapper : unwrapper<T&>
-    {
-        bool convertible(PyObject* p) const
-        {
-            return p->ob_type == &SimpleType;
-        }
-    
-        simple const& convert(PyObject* p, void*&) const
-        {
-            return static_cast<SimpleObject*>(p)->x;
-        }
-        
-    };
-    
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    struct const_ref_unwrapper : unwrapper<T const&>
-    {
-        bool convertible(PyObject* p) const
-        {
-            return p->ob_type == &SimpleType;
-        }
-    
-        simple const& convert(PyObject* p, void*&) const
-        {
-            return static_cast<SimpleObject*>(p)->x;
-        }
-        
-    };
-# endif 
+ private:
+    void* can_convert(PyObject*) const;
+    T& convert(PyObject*, void*, boost::type<T&>) const;
+    T const& convert(PyObject*, void*, boost::type<T const&>) const;
+    T* convert(PyObject*, void*, boost::type<T*>) const;
+    T const* convert(PyObject*, void*, boost::type<T const*>) const;
 };
 
+//
+// implementations
+//
+template <class T>
+void* class_unwrapper<T>::can_convert(PyObject* p) const
+{
+    return object::find_holder<T>(p);
+}
+
+template <class T>
+T& class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T&>) const
+{
+    return *static_cast<object::holder<T>*>(holder_)->target();
+}
+
+template <class T>
+T const& class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T const&>) const
+{
+    return *static_cast<object::holder<T>*>(holder_)->target();
+}
+
+template <class T>
+T* class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T*>) const
+{
+    return static_cast<object::holder<T>*>(holder_)->target();
+}
+
+template <class T>
+T const* class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T const*>) const
+{
+    return static_cast<object::holder<T>*>(holder_)->target();
+}
+
 }}} // namespace boost::python::converter
 
 #endif // CLASS_DWA20011215_HPP

From bfcb36927c98ca69095b482ebb159e06d2a7a654 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:49:20 +0000
Subject: [PATCH 183/369] Accounting for by-value conversions

[SVN r12190]
---
 include/boost/python/converter/target.hpp | 44 ++++++++++++++++-------
 1 file changed, 31 insertions(+), 13 deletions(-)

diff --git a/include/boost/python/converter/target.hpp b/include/boost/python/converter/target.hpp
index 6effb996..f8f33171 100644
--- a/include/boost/python/converter/target.hpp
+++ b/include/boost/python/converter/target.hpp
@@ -33,8 +33,6 @@ namespace boost { namespace python { namespace converter {
 //    importantly, avoids having to dynamically allocate room for
 //    an lvalue of types which can be cheaply copied.
 //
-// In the tables below, "cv" stands for the set of all possible
-// cv-qualifications.
 
 // Target                Source
 // int                   int
@@ -46,10 +44,16 @@ namespace boost { namespace python { namespace converter {
 // On compilers supporting partial specialization:
 //
 // Target                Source
-// T                     T&
-// T cv&                 T&
-// T cv*                 T*
-// T cv*const&           T*
+// T                     T const&
+// T&                    T&
+// T const&              T const&
+// T volatile            T&
+// T const volatile&     T const&
+// T*                    T*
+// T const*              T const*
+// T volatile            T*
+// T const volatile*     T const*
+// T cv*const&           same as T cv*
 // T cv*&                T*& <- should this be legal?
 // T cv*volatile&        T*& <- should this be legal?
 // T cv*const volatile&  T*& <- should this be legal?
@@ -75,7 +79,11 @@ struct target
     typedef typename mpl::select_type<
         use_identity
         , T
-        , typename add_reference<typename remove_cv<T>::type>::type 
+        , typename add_reference<
+                typename add_const<
+                        typename remove_volatile<T>::type
+                >::type
+          >::type
     >::type type;
 };
 
@@ -86,13 +94,23 @@ struct target
 template <class T>
 struct target<T&>
 {
-    typedef typename remove_cv<T>::type& type;
+    typedef typename remove_volatile<T>::type& type;
+};
+
+template <class T>
+struct target<T const&>
+{
+    typedef typename boost::mpl::select_type<
+        is_scalar<T>::value
+        , typename remove_cv<T>::type
+        , typename remove_volatile<T>::type const&
+    >::type type;
 };
 
 template <class T>
 struct target<T*>
 {
-    typedef typename remove_cv<T>::type* type;
+    typedef typename remove_volatile<T>::type* type;
 };
 
 // Handle T*-cv for completeness. Function arguments in a signature
@@ -102,19 +120,19 @@ struct target<T*>
 template <class T>
 struct target<T* const>
 {
-    typedef typename remove_cv<T>::type* type;
+    typedef typename remove_volatile<T>::type* type;
 };
 
 template <class T>
 struct target<T* volatile>
 {
-    typedef typename remove_cv<T>::type* type;
+    typedef typename remove_volatile<T>::type* type;
 };
 
 template <class T>
 struct target<T* const volatile>
 {
-    typedef typename remove_cv<T>::type* type;
+    typedef typename remove_volatile<T>::type* type;
 };
 
 // non-const references to pointers should be handled by the
@@ -122,7 +140,7 @@ struct target<T* const volatile>
 template <class T>
 struct target<T* const&>
 {
-    typedef typename remove_cv<T>::type* type;
+    typedef typename remove_volatile<T>::type* type;
 };
 # endif
 

From b2944a12debbac87919f7841d1547af5e1a97b45 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:52:04 +0000
Subject: [PATCH 184/369] Convertibility checks now collect the auxiliary
 conversion data BOOST_PYTHON_EXPORT -> BOOST_PYTHON_DECL

[SVN r12191]
---
 .../boost/python/converter/registration.hpp   | 13 ++--
 include/boost/python/converter/registry.hpp   | 21 +++---
 include/boost/python/converter/unwrap.hpp     | 65 ++++++++++---------
 include/boost/python/converter/unwrapper.hpp  | 18 +----
 .../boost/python/converter/unwrapper_base.hpp | 17 ++++-
 5 files changed, 68 insertions(+), 66 deletions(-)

diff --git a/include/boost/python/converter/registration.hpp b/include/boost/python/converter/registration.hpp
index 0d85d1d7..b8a6326b 100644
--- a/include/boost/python/converter/registration.hpp
+++ b/include/boost/python/converter/registration.hpp
@@ -5,18 +5,19 @@
 // to its suitability for any purpose.
 #ifndef REGISTRATION_DWA20011130_HPP
 # define REGISTRATION_DWA20011130_HPP
-# include <boost/config.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
+# include <utility>
 # ifdef BOOST_PYTHON_TRACE
 #  include <iostream>
 # endif 
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_EXPORT wrapper_base;
-struct BOOST_PYTHON_EXPORT unwrapper_base;
+struct BOOST_PYTHON_DECL wrapper_base;
+struct BOOST_PYTHON_DECL unwrapper_base;
 
 // This class is really sort of a "templated namespace". It manages a
 // static data member which refers to the registry entry for T. This
@@ -28,7 +29,7 @@ struct registration
  public: // member functions
     // Return a converter which can convert the given Python object to
     // T, or 0 if no such converter exists
-    static unwrapper_base* unwrapper(PyObject*);
+    static std::pair<unwrapper_base*,void*> unwrapper(PyObject*);
 
     // Return a converter which can convert T to a Python object, or 0
     // if no such converter exists
@@ -61,7 +62,7 @@ inline registry::entry* registration<T>::entry()
 }
 
 template <class T>
-unwrapper_base* registration<T>::unwrapper(PyObject* p)
+std::pair<unwrapper_base*,void*> registration<T>::unwrapper(PyObject* p)
 {
 # ifdef BOOST_PYTHON_TRACE
     std::cout << "retrieving unwrapper for " << type_id<T>() << std::endl;
diff --git a/include/boost/python/converter/registry.hpp b/include/boost/python/converter/registry.hpp
index 30eeba8d..2023a732 100644
--- a/include/boost/python/converter/registry.hpp
+++ b/include/boost/python/converter/registry.hpp
@@ -7,20 +7,21 @@
 # define REGISTRY_DWA20011127_HPP
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/type_id.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
 # include <list>
 # include <memory>
+# include <utility>
 
 namespace boost { namespace python { namespace converter {
 
-struct BOOST_PYTHON_EXPORT wrapper_base;
-struct BOOST_PYTHON_EXPORT unwrapper_base;
+struct BOOST_PYTHON_DECL wrapper_base;
+struct BOOST_PYTHON_DECL unwrapper_base;
 
 // This namespace acts as a sort of singleton
 namespace registry
 {
   // These are the elements stored in the registry
-  class BOOST_PYTHON_EXPORT entry
+  class BOOST_PYTHON_DECL entry
   {
    public: // member functions
       entry();
@@ -30,7 +31,7 @@ namespace registry
       // Python object from_python to the C++ type with which this
       // converter is associated in the registry, or 0 if no such
       // converter exists.
-      unwrapper_base* unwrapper(PyObject*) const;
+      std::pair<unwrapper_base*,void*> unwrapper(PyObject*) const;
 
       // Return a converter appropriate for converting a C++ object
       // whose type this entry is associated with in the registry to a
@@ -61,12 +62,12 @@ namespace registry
       converter::wrapper_base* m_wrapper;
   };
 
-  BOOST_PYTHON_EXPORT entry* find(type_id_t);
+  BOOST_PYTHON_DECL entry* find(type_id_t);
   
-  BOOST_PYTHON_EXPORT void insert(wrapper_base& x);
-  BOOST_PYTHON_EXPORT void insert(unwrapper_base& x);
-  BOOST_PYTHON_EXPORT void remove(wrapper_base& x);
-  BOOST_PYTHON_EXPORT void remove(unwrapper_base& x);
+  BOOST_PYTHON_DECL void insert(wrapper_base& x);
+  BOOST_PYTHON_DECL void insert(unwrapper_base& x);
+  BOOST_PYTHON_DECL void remove(wrapper_base& x);
+  BOOST_PYTHON_DECL void remove(unwrapper_base& x);
 }
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
index 4a2ea04c..ffd0f081 100644
--- a/include/boost/python/converter/unwrap.hpp
+++ b/include/boost/python/converter/unwrap.hpp
@@ -12,22 +12,28 @@
 # include <boost/python/converter/registration.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/unwrapper_select.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
+# include <boost/type.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
 template <class T> struct unwrapper;
-struct BOOST_PYTHON_EXPORT body;
+struct BOOST_PYTHON_DECL body;
 
-struct BOOST_PYTHON_EXPORT unwrap_base : handle
+struct BOOST_PYTHON_DECL unwrap_base : handle
 {
  public: // member functions
-    inline unwrap_base(PyObject* source, body*, handle& prev);
-    inline unwrap_base(PyObject* source, body*);
+    inline unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*>, handle& prev);
+    inline unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*>);
     inline PyObject* source() const;
-
+    
+ protected:
+    inline PyObject*& source();
+    inline void* data() const;
+        
  private: // data members
     PyObject* m_source;
+    void* m_data;
 };
 
 // These converters will be used by the function wrappers. They don't
@@ -47,15 +53,7 @@ struct unwrap_more_ : unwrap_base
     // this constructor is only for the use of unwrap_
     unwrap_more_(PyObject* source);
 
- private: // helper functions
-    // Return the unwrapper which will convert the given Python object
-    // to T, or 0 if no such converter exists
-    static unwrapper_base* lookup(PyObject*);
-
  private:
-    // unspecified storage which may be allocated by the unwrapper to
-    // do value conversions.
-    mutable void* m_storage;
     typedef typename unwrapper_select<T>::type unwrapper_t;
 };
 
@@ -78,9 +76,9 @@ struct unwrap_more_<PyObject*>
         return source();
     }
         
-    bool convertible(PyObject*) const
+    void* can_convert(PyObject*) const
     {
-        return true;
+        return &m_unwrapper;
     }
     
  protected: // constructor
@@ -91,7 +89,7 @@ struct unwrap_more_<PyObject*>
     {
     }
  private:
-    static BOOST_PYTHON_EXPORT unwrapper_base* m_unwrapper;
+    static BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*> m_unwrapper;
 };
 
 template <class T>
@@ -104,42 +102,47 @@ struct unwrap_ : unwrap_more_<T>
 //
 // implementations
 //
-inline unwrap_base::unwrap_base(PyObject* source, body* body, handle& prev)
-    : handle(body, prev)
+inline unwrap_base::unwrap_base(
+    PyObject* source, std::pair<unwrapper_base*,void*> unwrapper, handle& prev)
+    : handle(unwrapper.first, prev)
     , m_source(source)
+    , m_data(unwrapper.second)
 {
 }
 
-inline unwrap_base::unwrap_base(PyObject* source, body* body)
-    : handle(body)
+inline unwrap_base::unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*> unwrapper)
+    : handle(unwrapper.first)
     , m_source(source)
+    , m_data(unwrapper.second)
 {
 }
 
+inline void* unwrap_base::data() const
+{
+    return m_data;
+}
+
 inline PyObject* unwrap_base::source() const
 {
     return m_source;
 }
 
-template <class T>
-inline unwrapper_base* unwrap_more_<T>::lookup(PyObject* source)
+inline PyObject*& unwrap_base::source()
 {
-    // Find the converters registered for T and get a unwrapper
-    // appropriate for the source object
-    return registration<T>::unwrapper(source);
+    return m_source;
 }
 
 template <class T>
 unwrap_more_<T>::unwrap_more_(PyObject* source, handle& prev)
-    : unwrap_base(source, lookup(source), prev)
-    , m_storage(0)
+    : unwrap_base(source,
+                  registration<T>::unwrapper(source),
+                  prev)
 {
 }
 
 template <class T>
 unwrap_more_<T>::unwrap_more_(PyObject* source)
-    : unwrap_base(source, lookup(source))
-    , m_storage(0)
+    : unwrap_base(source, registration<T>::unwrapper(source))
 {
 }
 
@@ -153,7 +156,7 @@ template <class T>
 T unwrap_more_<T>::operator*()
 {
     return static_cast<unwrapper<T>*>(
-        get_body())->convert(this->m_source, this->m_storage);
+        get_body())->convert(this->source(), this->data(), boost::type<T>());
 }
 
 template <class T>
diff --git a/include/boost/python/converter/unwrapper.hpp b/include/boost/python/converter/unwrapper.hpp
index a30ff522..7f0609cf 100644
--- a/include/boost/python/converter/unwrapper.hpp
+++ b/include/boost/python/converter/unwrapper.hpp
@@ -9,6 +9,7 @@
 # include <boost/python/converter/unwrapper_base.hpp>
 # include <boost/python/converter/unwrap.hpp>
 # include <boost/python/converter/body.hpp>
+# include <boost/type.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -21,13 +22,7 @@ struct unwrapper : unwrapper_base
  public:
     unwrapper();
 
-    T do_conversion(unwrap_more_<T> const* handle) const;
-    
- private:
-    virtual T convert(PyObject*, void*&) const = 0;
-    
- private: // body required interface implementation
-    void destroy_handle(handle*) const {}
+    virtual T convert(PyObject*, void* data, boost::type<T>) const = 0;
 };
 
 //
@@ -39,15 +34,6 @@ unwrapper<T>::unwrapper()
 {
 }
 
-// We could think about making this virtual in an effort to get its
-// code generated in the module where the unwrapper is defined, but
-// it's not clear that it's a good tradeoff.
-template <class T>
-T unwrapper<T>::do_conversion(unwrap_more_<T> const* handle) const
-{
-    return convert(handle->source(), handle->m_storage);
-}
-
 }}} // namespace boost::python::converter
 
 #endif // UNWRAPPER_DWA2001127_HPP
diff --git a/include/boost/python/converter/unwrapper_base.hpp b/include/boost/python/converter/unwrapper_base.hpp
index 54e2e54c..ea437eb2 100644
--- a/include/boost/python/converter/unwrapper_base.hpp
+++ b/include/boost/python/converter/unwrapper_base.hpp
@@ -8,16 +8,27 @@
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/body.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_EXPORT unwrapper_base : body
+struct BOOST_PYTHON_DECL unwrapper_base : body
 {
  public:
     unwrapper_base(type_id_t); // registers
     ~unwrapper_base();         // unregisters
-    virtual bool convertible(PyObject*) const = 0;
+
+    // Must return non-null iff the conversion will be successful. Any
+    // non-null pointer is acceptable, and will be passed on to the
+    // convert() function, so useful data can be stored there.
+    virtual void* can_convert(PyObject*) const = 0;
+    
+ protected:
+    // this is an arbitrary non-null pointer you can use to indicate success
+    static void* const non_null;
+    
+ private: // body required interface implementation
+    void destroy_handle(handle*) const {}
 };
 
 }}} // namespace boost::python::converter

From a179f87d54b4a7fc2e50aff59b109a1df6237889 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:53:12 +0000
Subject: [PATCH 185/369] BOOST_PYTHON_EXPORT -> BOOST_PYTHON_DECL

[SVN r12192]
---
 include/boost/python/converter/body.hpp    |  7 +++----
 include/boost/python/converter/handle.hpp  |  7 +++----
 include/boost/python/converter/type_id.hpp | 11 +++++------
 include/boost/python/converter/wrap.hpp    |  4 ++--
 include/boost/python/converter/wrapper.hpp |  5 ++---
 include/boost/python/object/class.hpp      | 10 +++++-----
 include/boost/python/object/function.hpp   |  6 +++---
 7 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/include/boost/python/converter/body.hpp b/include/boost/python/converter/body.hpp
index c8d932a0..72653ee0 100644
--- a/include/boost/python/converter/body.hpp
+++ b/include/boost/python/converter/body.hpp
@@ -5,20 +5,19 @@
 // to its suitability for any purpose.
 #ifndef BODY_DWA2001127_HPP
 # define BODY_DWA2001127_HPP
-# include <boost/config.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/python/converter/type_id.hpp>
-# include <boost/python/export.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_EXPORT handle;
+struct BOOST_PYTHON_DECL handle;
 
 namespace registry
 {
   class entry;
 }
 
-struct BOOST_PYTHON_EXPORT body
+struct BOOST_PYTHON_DECL body
 {
  public:
     body(type_id_t key);
diff --git a/include/boost/python/converter/handle.hpp b/include/boost/python/converter/handle.hpp
index 16a50b38..03671634 100644
--- a/include/boost/python/converter/handle.hpp
+++ b/include/boost/python/converter/handle.hpp
@@ -5,19 +5,18 @@
 // to its suitability for any purpose.
 #ifndef HANDLE_DWA20011130_HPP
 # define HANDLE_DWA20011130_HPP
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/utility.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_EXPORT body;
+struct BOOST_PYTHON_DECL body;
 
 // The common base class for unwrap_ and wrap_ handle objects. They
 // share a common base so that handles can be linked into a chain
 // within a function wrapper which is managed by a single object.
-struct BOOST_PYTHON_EXPORT handle : boost::noncopyable
+struct BOOST_PYTHON_DECL handle : boost::noncopyable
 {
  public: // member functions
 
diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
index ddc04266..c383c352 100644
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -5,12 +5,11 @@
 //  to its suitability for any purpose.
 #ifndef TYPE_ID_DWA20011127_HPP
 # define TYPE_ID_DWA20011127_HPP
-# include <boost/config.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/type_traits/composite_traits.hpp>
-# include <boost/python/export.hpp>
 # include <boost/operators.hpp>
 # include <typeinfo>
 # include <iosfwd>
@@ -48,7 +47,7 @@ typedef std::type_info const* base_id_t;
 
     bool operator<(type_id_t const& rhs) const;
     bool operator==(type_id_t const& rhs) const;
-    friend BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream&, type_id_t const&);
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
     
  private:
     decoration m_decoration;
@@ -188,12 +187,12 @@ type_id_t type_id(detail::dummy<T>* = 0)
 }
 # endif 
 
-struct BOOST_PYTHON_EXPORT type_id_before
+struct BOOST_PYTHON_DECL type_id_before
 {
     bool operator()(type_id_t const& x, type_id_t const& y) const;
 };
 
-BOOST_PYTHON_EXPORT std::ostream& operator<<(std::ostream&, type_id_t const&);
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
 
 }}} // namespace boost::python::converter
 
diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
index 91c9de86..e26cf0f6 100644
--- a/include/boost/python/converter/wrap.hpp
+++ b/include/boost/python/converter/wrap.hpp
@@ -9,13 +9,13 @@
 # include <boost/python/converter/handle.hpp>
 # include <boost/python/converter/body.hpp>
 # include <boost/python/converter/wrapper.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/python/converter/source_holder.hpp>
 # include <cassert>
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_EXPORT wrapper_base;
+struct BOOST_PYTHON_DECL wrapper_base;
 
 template <class T> struct wrapper;
 
diff --git a/include/boost/python/converter/wrapper.hpp b/include/boost/python/converter/wrapper.hpp
index ada5e8cb..49c32186 100644
--- a/include/boost/python/converter/wrapper.hpp
+++ b/include/boost/python/converter/wrapper.hpp
@@ -5,13 +5,12 @@
 // to its suitability for any purpose.
 #ifndef WRAPPER_DWA2001127_HPP
 # define WRAPPER_DWA2001127_HPP
-# include <boost/config.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/body.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/wrap.hpp>
 # include <boost/python/converter/source_holder.hpp>
-# include <boost/python/export.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -19,7 +18,7 @@ struct source_holder_base;
 struct wrap_base;
 template <class T> struct wrap_more_;
 
-struct BOOST_PYTHON_EXPORT wrapper_base : body
+struct BOOST_PYTHON_DECL wrapper_base : body
 {
  public:
     wrapper_base(type_id_t); // registers
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 548d4053..35085e5f 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -7,7 +7,7 @@
 # define CLASS_DWA20011214_HPP
 
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/utility.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/iterator_adaptors.hpp>
@@ -17,7 +17,7 @@ namespace boost { namespace python { namespace object {
 template <class T> struct holder;
 
 // Base class for all holders
-struct BOOST_PYTHON_EXPORT holder_base : noncopyable
+struct BOOST_PYTHON_DECL holder_base : noncopyable
 {
  public:
     holder_base(converter::type_id_t id);
@@ -68,7 +68,7 @@ struct instance
     holder_base* objects;
 };
 
-BOOST_PYTHON_EXPORT holder_base* find_holder_impl(PyObject*, converter::type_id_t);
+BOOST_PYTHON_DECL holder_base* find_holder_impl(PyObject*, converter::type_id_t);
 
 template <class T>
 holder<T>* find_holder(PyObject* p, T* = 0)
@@ -76,8 +76,8 @@ holder<T>* find_holder(PyObject* p, T* = 0)
     return static_cast<holder<T>*>(find_holder_impl(p, converter::type_id<T>()));
 }
 
-BOOST_PYTHON_EXPORT PyTypeObject* class_metatype();
-BOOST_PYTHON_EXPORT PyTypeObject* class_type();
+BOOST_PYTHON_DECL PyTypeObject* class_metatype();
+BOOST_PYTHON_DECL PyTypeObject* class_type();
 
 //
 // implementation
diff --git a/include/boost/python/object/function.hpp b/include/boost/python/object/function.hpp
index f550e8dc..a0257676 100644
--- a/include/boost/python/object/function.hpp
+++ b/include/boost/python/object/function.hpp
@@ -7,7 +7,7 @@
 # define FUNCTION_DWA20011214_HPP
 
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/export.hpp>
+# include <boost/python/detail/config.hpp>
 # include <boost/function.hpp>
 
 namespace boost { namespace python { namespace object { 
@@ -15,7 +15,7 @@ namespace boost { namespace python { namespace object {
 // We use boost::function to avoid generating lots of virtual tables
 typedef boost::function2<PyObject*, PyObject*, PyObject*> py_function;
 
-struct BOOST_PYTHON_EXPORT function : PyObject
+struct BOOST_PYTHON_DECL function : PyObject
 {
     function(py_function);
     ~function();
@@ -25,7 +25,7 @@ struct BOOST_PYTHON_EXPORT function : PyObject
     py_function m_fn;
 };
 
-extern BOOST_PYTHON_EXPORT PyTypeObject function_type;
+extern BOOST_PYTHON_DECL PyTypeObject function_type;
 
 //
 // implementations

From bdf68f092e6b7b94fa87b04d3da6c53c5f8fd16b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 1 Jan 2002 18:55:23 +0000
Subject: [PATCH 186/369] Accounting for by-value conversions Convertibility
 checks now collect the auxiliary conversion data

[SVN r12193]
---
 test/m1.cpp | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/test/m1.cpp b/test/m1.cpp
index f4ad6390..809a0d63 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -14,8 +14,8 @@
 #include <boost/python/detail/config.hpp>
 #include <boost/python/convert.hpp>
 #include <boost/python/object/value_holder.hpp>
-#include <boost/python/object/class_unwrapper.hpp>
 #include <boost/python/object/class.hpp>
+#include <boost/python/converter/class.hpp>
 #include <boost/python/make_function.hpp>
 #include <boost/python/errors.hpp>
 #include <boost/mpl/type_list.hpp>
@@ -141,12 +141,12 @@ struct simple_ref_wrapper
 struct native_int_unwrapper
     : boost::python::converter::unwrapper<int>
 {
-    bool convertible(PyObject* p) const
+    void* can_convert(PyObject* p) const
     {
-        return PyInt_Check(p);
+        return PyInt_Check(p) ? non_null : 0;
     }
     
-    int convert(PyObject* p, void*&) const
+    int convert(PyObject* p, void*, boost::type<int>) const
     {
         return PyInt_AsLong(p);
     }
@@ -155,12 +155,12 @@ struct native_int_unwrapper
 struct noddy_int_unwrapper
     : boost::python::converter::unwrapper<int>
 {
-    bool convertible(PyObject* p) const
+    void* can_convert(PyObject* p) const
     {
-        return p->ob_type == &NoddyType;
+        return p->ob_type == &NoddyType ? non_null : 0;
     }
     
-    int convert(PyObject* p, void*&) const
+    int convert(PyObject* p, void*, boost::type<int>) const
     {
         return static_cast<NoddyObject*>(p)->x;
     }
@@ -169,12 +169,12 @@ struct noddy_int_unwrapper
 struct noddy_int_ref_unwrapper
     : boost::python::converter::unwrapper<int&>
 {
-    bool convertible(PyObject* p) const
+    void* can_convert(PyObject* p) const
     {
-        return p->ob_type == &NoddyType;
+        return p->ob_type == &NoddyType ? non_null : 0;
     }
     
-    int& convert(PyObject* p, void*&) const
+    int& convert(PyObject* p, void*, boost::type<int&>) const
     {
         return static_cast<NoddyObject*>(p)->x;
     }
@@ -183,12 +183,12 @@ struct noddy_int_ref_unwrapper
 struct simple_ref_unwrapper
     : boost::python::converter::unwrapper<simple&>
 {
-    bool convertible(PyObject* p) const
+    void* can_convert(PyObject* p) const
     {
-        return p->ob_type == &SimpleType;
+        return p->ob_type == &SimpleType ? non_null : 0;
     }
     
-    simple& convert(PyObject* p, void*&) const
+    simple& convert(PyObject* p, void*, boost::type<simple&>) const
     {
         return static_cast<SimpleObject*>(p)->x;
     }
@@ -197,12 +197,12 @@ struct simple_ref_unwrapper
 struct simple_const_ref_unwrapper
     : boost::python::converter::unwrapper<simple const&>
 {
-    bool convertible(PyObject* p) const
+    void* can_convert(PyObject* p) const
     {
-        return p->ob_type == &SimpleType;
+        return p->ob_type == &SimpleType ? non_null : 0;
     }
     
-    simple const& convert(PyObject* p, void*&) const
+    simple const& convert(PyObject* p, void*, boost::type<simple const&>) const
     {
         return static_cast<SimpleObject*>(p)->x;
     }
@@ -228,12 +228,12 @@ BOOST_PYTHON_MODULE_INIT(m1)
     static noddy_int_unwrapper unwrap_int2;
     static noddy_int_ref_unwrapper unwrap_int3;
     static simple_ref_unwrapper unwrap_simple;
+    static simple_const_ref_unwrapper unwrap_simple_const_ref;
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     // These compilers will need additional converters
-    static simple_const_ref_unwrapper unwrap_simple_const_ref;
     static simple_ref_wrapper wrap_simple_ref;
 #endif
-    static boost::python::object::class_unwrapper<complicated> unwrap_complicated;
+    static boost::python::converter::class_unwrapper<complicated> unwrap_complicated;
     
     PyObject* d = PyModule_GetDict(m1);
     if (d == NULL)

From 1201761ff399b73378d5a70a88cbd86bfb99938e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 2 Jan 2002 17:53:34 +0000
Subject: [PATCH 187/369] initial checkin

[SVN r12198]
---
 .../python/converter/unwrapper_select.hpp     | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 include/boost/python/converter/unwrapper_select.hpp

diff --git a/include/boost/python/converter/unwrapper_select.hpp b/include/boost/python/converter/unwrapper_select.hpp
new file mode 100644
index 00000000..d60923af
--- /dev/null
+++ b/include/boost/python/converter/unwrapper_select.hpp
@@ -0,0 +1,33 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef UNWRAPPER_SELECT_DWA20011229_HPP
+# define UNWRAPPER_SELECT_DWA20011229_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct unwrapper;
+
+// Select the type returned by unwrapper objects when unwrapping a
+// given type. When unwrapping T const&, the unwrapper returns T&, so
+// that the same unwrapper object can be used for both conversions (on
+// a conforming compiler).
+template <class T>
+struct unwrapper_select
+{
+    typedef unwrapper<T> type;
+};
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct unwrapper_select<T const&>
+{
+    typedef unwrapper<T&> type;
+};
+# endif 
+
+}}} // namespace boost::python::converter
+
+#endif // UNWRAPPER_SELECT_DWA20011229_HPP

From 586e6178b49f3f7602852d7c1d31f7c94f3cd893 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 4 Jan 2002 02:06:21 +0000
Subject: [PATCH 188/369] commented

[SVN r12209]
---
 test/m1.cpp     | 73 +++++++++++++++++++++++++++++++++++++++----------
 test/m2.cpp     | 27 +++++++++++++++++-
 test/newtest.py |  6 ++++
 3 files changed, 90 insertions(+), 16 deletions(-)

diff --git a/test/m1.cpp b/test/m1.cpp
index 809a0d63..db450f77 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -5,7 +5,7 @@
 // to its suitability for any purpose.
 
 // Seems to be neccessary to suppress an ICE with MSVC
-#include "boost/mpl/comparison/less.hpp"
+#include <boost/mpl/comparison/less.hpp>
 
 #include "simple_type.hpp"
 #include "complicated.hpp"
@@ -21,12 +21,14 @@
 #include <boost/mpl/type_list.hpp>
 #include <string.h>
 
+// Declare some straightforward extension types
 extern "C" void
 dealloc(PyObject* self)
 {
     PyObject_Del(self);
 }
 
+// Noddy is a type we got from one of the Python sample files
 struct NoddyObject : PyObject
 {
     int x;
@@ -50,6 +52,22 @@ PyTypeObject NoddyType = {
     0,          /*tp_hash */
 };
 
+// Create a Noddy containing 42
+extern "C" PyObject*
+new_noddy(PyObject* self, PyObject* args)
+{
+    NoddyObject* noddy;
+
+    if (!PyArg_ParseTuple(args,":new_noddy")) 
+        return NULL;
+
+    noddy = PyObject_New(NoddyObject, &NoddyType);
+    noddy->x = 42;
+    
+    return (PyObject*)noddy;
+}
+
+// Simple is a wrapper around a struct simple, which just contains a char*
 struct SimpleObject : PyObject
 {
     simple x;
@@ -73,20 +91,7 @@ PyTypeObject SimpleType = {
     0,          /*tp_hash */
 };
 
-extern "C" PyObject*
-new_noddy(PyObject* self, PyObject* args)
-{
-    NoddyObject* noddy;
-
-    if (!PyArg_ParseTuple(args,":new_noddy")) 
-        return NULL;
-
-    noddy = PyObject_New(NoddyObject, &NoddyType);
-    noddy->x = 42;
-    
-    return (PyObject*)noddy;
-}
-
+// Create a Simple containing "hello, world"
 extern "C" PyObject*
 new_simple(PyObject* self, PyObject* args)
 {
@@ -101,12 +106,21 @@ new_simple(PyObject* self, PyObject* args)
     return (PyObject*)simple;
 }
 
+// Initial method table for the module
 static PyMethodDef methods[] = {
     { "new_noddy", new_noddy, METH_VARARGS },
     { "new_simple", new_simple, METH_VARARGS },
     {0, 0, 0, 0}
 };
 
+//
+// Declare some wrappers/unwrappers to test the low-level conversion
+// mechanism. See boost/python/converter/source.hpp,target.hpp for a
+// description of how the type parameters to wrapper<> and unwrapper<>
+// are selected.
+//
+
+// Wrap an int by converting it to a Python Int
 struct int_wrapper
     : boost::python::converter::wrapper<int const&>
 {
@@ -116,6 +130,7 @@ struct int_wrapper
     }
 };
 
+// Wrap a simple by converting it to a Simple
 struct simple_wrapper
     : boost::python::converter::wrapper<simple const&>
 {
@@ -127,6 +142,10 @@ struct simple_wrapper
     }
 };
 
+// wrap a mutable reference to a simple by converting it to a
+// Simple. Normally we wouldn't do it this way, since modifications to
+// the result clearly don't change the original object, but here we're
+// just proving that the mechanism works.
 struct simple_ref_wrapper
     : boost::python::converter::wrapper<simple&>
 {
@@ -138,6 +157,9 @@ struct simple_ref_wrapper
     }
 };
 
+// extract an int from a Python Int by converting it to an int. Since
+// int is a scalar type, we convert by-value. Since Python Ints are
+// immutable, there's no non-const reference converter.
 struct native_int_unwrapper
     : boost::python::converter::unwrapper<int>
 {
@@ -152,6 +174,7 @@ struct native_int_unwrapper
     }
 };
 
+// Extract an int from a Noddy
 struct noddy_int_unwrapper
     : boost::python::converter::unwrapper<int>
 {
@@ -166,6 +189,7 @@ struct noddy_int_unwrapper
     }
 };
 
+// Extract a mutable reference to an int from a Noddy.
 struct noddy_int_ref_unwrapper
     : boost::python::converter::unwrapper<int&>
 {
@@ -180,6 +204,7 @@ struct noddy_int_ref_unwrapper
     }
 };
 
+// Extract a mutable reference to a simple from a Simple
 struct simple_ref_unwrapper
     : boost::python::converter::unwrapper<simple&>
 {
@@ -194,6 +219,7 @@ struct simple_ref_unwrapper
     }
 };
 
+// Extract a const reference to a simple from a Simple
 struct simple_const_ref_unwrapper
     : boost::python::converter::unwrapper<simple const&>
 {
@@ -208,11 +234,17 @@ struct simple_const_ref_unwrapper
     }
 };
 
+//
+// Some C++ functions to expose to Python
+//
+
+// Returns the length of s's held string
 int f(simple const& s)
 {
     return strlen(s.s);
 }
 
+// A trivial passthru function for simple objects
 simple const& g(simple const& x)
 {
     return x;
@@ -222,6 +254,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
 {
     PyObject* m1 = Py_InitModule(const_cast<char*>("m1"), methods);
 
+    // Create the converters; they are self-registering/unregistering.
     static int_wrapper wrap_int;
     static simple_wrapper wrap_simple;
     static native_int_unwrapper unwrap_int1;
@@ -233,32 +266,41 @@ BOOST_PYTHON_MODULE_INIT(m1)
     // These compilers will need additional converters
     static simple_ref_wrapper wrap_simple_ref;
 #endif
+
+    // This unwrapper extracts pointers and references to the "complicated" class.
     static boost::python::converter::class_unwrapper<complicated> unwrap_complicated;
     
     PyObject* d = PyModule_GetDict(m1);
     if (d == NULL)
         return;
 
+    // Insert the extension metaclass object
     if (PyDict_SetItemString(
             d, "xclass", (PyObject *)boost::python::object::class_metatype()) < 0)
         return;
 
+    // Insert the base class for all extension classes
     if (PyDict_SetItemString(
             d, "xinst", (PyObject *)boost::python::object::class_type()) < 0)
         return;
 
+    // Expose f()
     if (PyDict_SetItemString(
             d, "f", boost::python::make_function(f)) < 0)
         return;
 
+    // Expose g()
     if (PyDict_SetItemString(
             d, "g", boost::python::make_function(g)) < 0)
         return;
 
+    // Expose complicated's get_n() member function. See newtest.py
+    // for how it's used to build an extension class.
     if (PyDict_SetItemString(
             d, "get_n", boost::python::make_function(&complicated::get_n)) < 0)
         return;
 
+    // Expose complicated::complicated(simple const&, int) as init1
     if (PyDict_SetItemString(
             d, "init1"
             , boost::python::make_constructor<
@@ -268,6 +310,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
             ) < 0)
         return;
 
+    // Expose complicated::complicated(simple const&) as init2
     if (PyDict_SetItemString(
             d, "init2"
             , boost::python::make_constructor<
diff --git a/test/m2.cpp b/test/m2.cpp
index d2093a20..04750dd7 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -4,6 +4,13 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
 
+// This module exercises the converters exposed in m1 at a low level
+// by exposing raw Python extension functions that use wrap<> and
+// unwrap<> objects.
+
+// Seems to be neccessary to suppress an ICE with MSVC
+#include <boost/mpl/comparison/less.hpp>
+
 #include <boost/python/convert.hpp>
 #include <boost/python/module.hpp>
 #include "simple_type.hpp"
@@ -11,7 +18,10 @@
 using boost::python::wrap;
 using boost::python::unwrap;
 
-extern "C" {
+extern "C"
+{
+    // Get a simple (by value) from the argument, and return the
+    // string it holds.
     PyObject*
     unwrap_simple(PyObject* self, PyObject* args)
     {
@@ -28,6 +38,8 @@ extern "C" {
         return PyString_FromString(x.s);
     };
 
+    // Likewise, but demands that its possible to get a non-const
+    // reference to the simple.
     PyObject*
     unwrap_simple_ref(PyObject* self, PyObject* args)
     {
@@ -44,6 +56,7 @@ extern "C" {
         return PyString_FromString(x.s);
     };
 
+    // Likewise, with a const reference to the simple object.
     PyObject*
     unwrap_simple_const_ref(PyObject* self, PyObject* args)
     {
@@ -60,6 +73,8 @@ extern "C" {
         return PyString_FromString(x.s);
     };
 
+    // Get an int (by value) from the argument, and convert it to a
+    // Python Int.
     PyObject*
     unwrap_int(PyObject* self, PyObject* args)
     {
@@ -76,6 +91,7 @@ extern "C" {
         return PyInt_FromLong(x);
     };
 
+    // Get a non-const reference to an int from the argument
     PyObject*
     unwrap_int_ref(PyObject* self, PyObject* args)
     {
@@ -92,6 +108,7 @@ extern "C" {
         return PyInt_FromLong(x);
     };
 
+    // Get a const reference to an  int from the argument.
     PyObject*
     unwrap_int_const_ref(PyObject* self, PyObject* args)
     {
@@ -110,8 +127,12 @@ extern "C" {
 
     // -------------------
 }
+
+// MSVC6 bug workaround
 template <class T> struct xxxx;
 
+// rewrap<T> extracts a T from the argument, then converts the T back
+// to a PyObject* and returns it.
 template <class T>
 PyObject*
 rewrap(PyObject* self, PyObject* args, xxxx<T>* = 0)
@@ -134,6 +155,10 @@ rewrap(PyObject* self, PyObject* args, xxxx<T>* = 0)
 
 extern "C"
 {
+    //
+    // Use rewrap<T> to test simple, simple&, simple const&, int,
+    // int&, int const&
+    //
     PyObject*
     wrap_simple(PyObject* self, PyObject* args)
     {
diff --git a/test/newtest.py b/test/newtest.py
index 783e2240..b866258c 100644
--- a/test/newtest.py
+++ b/test/newtest.py
@@ -59,11 +59,17 @@ try: wrap_int_ref(n)
 >>> f(g(s))
 12
 
+Create an extension class which wraps "complicated" (init1 and get_n)
+are a complicated constructor and member function, respectively.
+
 >>> C = xclass('C', (xinst,), {'__init__': init1, 'get_n': get_n})
 >>> c = C(s, 99)
 >>> c.get_n()
 99
 
+Create another extension class which wraps "complicated" (init2 is a
+different constructor -- no overloading yet).
+
 >>> D = xclass('D', (xinst,), {'__init__': init2, 'get_n': get_n})
 >>> d = D(s)
 >>> d.get_n()

From 451aac806e9dc8938ad542bd8ecb8387415d8500 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 4 Jan 2002 20:15:49 +0000
Subject: [PATCH 189/369] remove extra semicolons

[SVN r12214]
---
 include/boost/python/detail/returning.hpp | 124 +++++++++++-----------
 src/gen_returning.py                      |   4 +-
 test/m2.cpp                               |  24 ++---
 3 files changed, 76 insertions(+), 76 deletions(-)

diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index 28f1846e..ed107d37 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -33,7 +33,7 @@ struct returning
         wrap_more<R> r(c0);
         if (!c0) return 0;
         return r( ((*c0).*pmf)() );
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
     {
@@ -45,7 +45,7 @@ struct returning
         wrap_more<R> r(c1);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1) );
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
@@ -58,7 +58,7 @@ struct returning
         wrap_more<R> r(c2);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2) );
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
@@ -72,7 +72,7 @@ struct returning
         wrap_more<R> r(c3);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
@@ -87,7 +87,7 @@ struct returning
         wrap_more<R> r(c4);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
@@ -103,7 +103,7 @@ struct returning
         wrap_more<R> r(c5);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
+    }
 
     template <class A0>
     static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
@@ -115,7 +115,7 @@ struct returning
         wrap_more<R> r(c0);
         if (!c0) return 0;
         return r( ((*c0).*pmf)() );
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -127,7 +127,7 @@ struct returning
         wrap_more<R> r(c1);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1) );
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -140,7 +140,7 @@ struct returning
         wrap_more<R> r(c2);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2) );
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -154,7 +154,7 @@ struct returning
         wrap_more<R> r(c3);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -169,7 +169,7 @@ struct returning
         wrap_more<R> r(c4);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -185,7 +185,7 @@ struct returning
         wrap_more<R> r(c5);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
+    }
 
     template <class A0>
     static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
@@ -197,7 +197,7 @@ struct returning
         wrap_more<R> r(c0);
         if (!c0) return 0;
         return r( ((*c0).*pmf)() );
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -209,7 +209,7 @@ struct returning
         wrap_more<R> r(c1);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1) );
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -222,7 +222,7 @@ struct returning
         wrap_more<R> r(c2);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2) );
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -236,7 +236,7 @@ struct returning
         wrap_more<R> r(c3);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -251,7 +251,7 @@ struct returning
         wrap_more<R> r(c4);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -267,7 +267,7 @@ struct returning
         wrap_more<R> r(c5);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
+    }
 
 
 // missing const volatile type traits
@@ -282,7 +282,7 @@ struct returning
         wrap_more<R> r(c0);
         if (!c0) return 0;
         return r( ((*c0).*pmf)() );
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -294,7 +294,7 @@ struct returning
         wrap_more<R> r(c1);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1) );
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -307,7 +307,7 @@ struct returning
         wrap_more<R> r(c2);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2) );
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -321,7 +321,7 @@ struct returning
         wrap_more<R> r(c3);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -336,7 +336,7 @@ struct returning
         wrap_more<R> r(c4);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -352,7 +352,7 @@ struct returning
         wrap_more<R> r(c5);
         if (!c0) return 0;
         return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
-    };
+    }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
             
@@ -361,7 +361,7 @@ struct returning
         // find the result converter
         wrap<R> r;
         return r( (*pf)() );
-    };
+    }
     template <class A0>
     static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
     {
@@ -372,7 +372,7 @@ struct returning
         wrap_more<R> r(c0);
         if (!c0) return 0;
         return r( (*pf)(*c0) );
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
     {
@@ -384,7 +384,7 @@ struct returning
         wrap_more<R> r(c1);
         if (!c0) return 0;
         return r( (*pf)(*c0, *c1) );
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
@@ -397,7 +397,7 @@ struct returning
         wrap_more<R> r(c2);
         if (!c0) return 0;
         return r( (*pf)(*c0, *c1, *c2) );
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
@@ -411,7 +411,7 @@ struct returning
         wrap_more<R> r(c3);
         if (!c0) return 0;
         return r( (*pf)(*c0, *c1, *c2, *c3) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
@@ -426,7 +426,7 @@ struct returning
         wrap_more<R> r(c4);
         if (!c0) return 0;
         return r( (*pf)(*c0, *c1, *c2, *c3, *c4) );
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
@@ -442,7 +442,7 @@ struct returning
         wrap_more<R> r(c5);
         if (!c0) return 0;
         return r( (*pf)(*c0, *c1, *c2, *c3, *c4, *c5) );
-    };
+    }
 };
                            
 template <>
@@ -458,7 +458,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)();
         return detail::none();
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
     {
@@ -469,7 +469,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
@@ -481,7 +481,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
@@ -494,7 +494,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
@@ -508,7 +508,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
@@ -523,7 +523,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
         return detail::none();
-    };
+    }
 
     template <class A0>
     static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
@@ -534,7 +534,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)();
         return detail::none();
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -545,7 +545,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -557,7 +557,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -570,7 +570,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -584,7 +584,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
     {
@@ -599,7 +599,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
         return detail::none();
-    };
+    }
 
     template <class A0>
     static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
@@ -610,7 +610,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)();
         return detail::none();
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -621,7 +621,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -633,7 +633,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -646,7 +646,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -660,7 +660,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -675,7 +675,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
         return detail::none();
-    };
+    }
 
 
 // missing const volatile type traits
@@ -689,7 +689,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)();
         return detail::none();
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -700,7 +700,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -712,7 +712,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -725,7 +725,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -739,7 +739,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
@@ -754,7 +754,7 @@ struct returning<void>
         if (!c0) return 0;
         ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
         return detail::none();
-    };
+    }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
             
@@ -762,7 +762,7 @@ struct returning<void>
     {
         (*pf)();
         return detail::none();
-    };
+    }
     template <class A0>
     static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
     {
@@ -772,7 +772,7 @@ struct returning<void>
         if (!c0) return 0;
         (*pf)(*c0);
         return detail::none();
-    };
+    }
     template <class A0, class A1>
     static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
     {
@@ -783,7 +783,7 @@ struct returning<void>
         if (!c0) return 0;
         (*pf)(*c0, *c1);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2>
     static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
@@ -795,7 +795,7 @@ struct returning<void>
         if (!c0) return 0;
         (*pf)(*c0, *c1, *c2);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
@@ -808,7 +808,7 @@ struct returning<void>
         if (!c0) return 0;
         (*pf)(*c0, *c1, *c2, *c3);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
@@ -822,7 +822,7 @@ struct returning<void>
         if (!c0) return 0;
         (*pf)(*c0, *c1, *c2, *c3, *c4);
         return detail::none();
-    };
+    }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
@@ -837,7 +837,7 @@ struct returning<void>
         if (!c0) return 0;
         (*pf)(*c0, *c1, *c2, *c3, *c4, *c5);
         return detail::none();
-    };
+    }
 };
 
 }}} // namespace boost::python::detail
diff --git a/src/gen_returning.py b/src/gen_returning.py
index 2b112cc0..2c33cfe5 100644
--- a/src/gen_returning.py
+++ b/src/gen_returning.py
@@ -74,7 +74,7 @@ member_function = '''    template <class A0%(, class A%+%)>
 %]        if (!c0) return 0;
         %[r%:return r( %]((*c0).*pmf)(%(*c%+%:, %))%[r%: )%];%[v%:
         return detail::none();%]
-    };
+    }
 ''' 
         
 free_function = '''%{    template <%(class A%n%:, %)>
@@ -88,7 +88,7 @@ free_function = '''%{    template <%(class A%n%:, %)>
         if (!c0) return 0;%}
         %[r%:return r( %](*pf)(%(*c%n%:, %))%[r%: )%];%[v%:
         return detail::none();%]
-    };
+    }
 ''' 
 
 def _returns_value(key, n, args, value):
diff --git a/test/m2.cpp b/test/m2.cpp
index 04750dd7..377ce02e 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -36,7 +36,7 @@ extern "C"
         simple x = *in;
     
         return PyString_FromString(x.s);
-    };
+    }
 
     // Likewise, but demands that its possible to get a non-const
     // reference to the simple.
@@ -54,7 +54,7 @@ extern "C"
         simple& x = *in;
     
         return PyString_FromString(x.s);
-    };
+    }
 
     // Likewise, with a const reference to the simple object.
     PyObject*
@@ -71,7 +71,7 @@ extern "C"
         simple const& x = *in;
     
         return PyString_FromString(x.s);
-    };
+    }
 
     // Get an int (by value) from the argument, and convert it to a
     // Python Int.
@@ -89,7 +89,7 @@ extern "C"
         int x = *in;
     
         return PyInt_FromLong(x);
-    };
+    }
 
     // Get a non-const reference to an int from the argument
     PyObject*
@@ -106,7 +106,7 @@ extern "C"
         int& x = *in;
     
         return PyInt_FromLong(x);
-    };
+    }
 
     // Get a const reference to an  int from the argument.
     PyObject*
@@ -123,7 +123,7 @@ extern "C"
         int const& x = *in;
     
         return PyInt_FromLong(x);
-    };
+    }
 
     // -------------------
 }
@@ -163,37 +163,37 @@ extern "C"
     wrap_simple(PyObject* self, PyObject* args)
     {
         return rewrap<simple>(self, args);
-    };
+    }
 
     PyObject*
     wrap_simple_ref(PyObject* self, PyObject* args)
     {
         return rewrap<simple&>(self, args);
-    };
+    }
 
     PyObject*
     wrap_simple_const_ref(PyObject* self, PyObject* args)
     {
         return rewrap<simple const&>(self, args);
-    };
+    }
 
     PyObject*
     wrap_int(PyObject* self, PyObject* args)
     {
         return rewrap<int>(self, args);
-    };
+    }
 
     PyObject*
     wrap_int_ref(PyObject* self, PyObject* args)
     {
         return rewrap<int&>(self, args);
-    };
+    }
 
     PyObject*
     wrap_int_const_ref(PyObject* self, PyObject* args)
     {
         return rewrap<int const&>(self, args);
-    };
+    }
 }
 
 PyMethodDef initial_methods[] =

From acdae42fc538593b730f3d9ce58c6e771d1661f3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Fri, 4 Jan 2002 20:49:20 +0000
Subject: [PATCH 190/369] work-around for cxx

[SVN r12215]
---
 include/boost/python/detail/config.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 97d84a79..886e2fa8 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -76,7 +76,7 @@
 #  define BOOST_PYTHON_STATIC_LINK
 #endif
 
-#if defined(__MWERKS__)
+#if defined(__MWERKS__) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60290024)
 # define BOOST_PYTHON_NO_TEMPLATE_EXPORT
 #endif
 

From e2623c5e82ed2c8af75a17b09c6b80e0182cf4fb Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 4 Jan 2002 23:32:23 +0000
Subject: [PATCH 191/369] fixes for gcc-3.0.3

[SVN r12221]
---
 include/boost/python/detail/wrap_python.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index d0ad5dd2..3807eae1 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -47,7 +47,9 @@ typedef int pid_t;
 #    define HAVE_STRERROR
 #   endif
 #   define NT_THREADS
-#   define WITH_THREAD
+#   if __GNUC__ < 3 || __GNUC__ == 3 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ < 3
+#    define WITH_THREAD
+#   endif 
 #   ifndef NETSCAPE_PI
 #    define USE_SOCKET
 #   endif

From 8d27b4822507b72b63b3ffa834c5e874ddd71c16 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 5 Jan 2002 02:18:00 +0000
Subject: [PATCH 192/369] update for cxx 6.5 and irix_CC

[SVN r12222]
---
 include/boost/python/detail/config.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 886e2fa8..c488cb64 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -76,7 +76,9 @@
 #  define BOOST_PYTHON_STATIC_LINK
 #endif
 
-#if defined(__MWERKS__) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60290024)
+#if  defined(__MWERKS__) \
+  || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590002) \
+  || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730)
 # define BOOST_PYTHON_NO_TEMPLATE_EXPORT
 #endif
 

From b65f4ff963a6ea6a7962b5b221a2befd76d404df Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:29:54 +0000
Subject: [PATCH 193/369] added inlines

[SVN r12224]
---
 include/boost/python/call.hpp | 62 +++++++++++++++++------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/include/boost/python/call.hpp b/include/boost/python/call.hpp
index bdda879d..b95a31d5 100644
--- a/include/boost/python/call.hpp
+++ b/include/boost/python/call.hpp
@@ -17,188 +17,188 @@
 namespace boost { namespace python { 
 
 template <class R>
-PyObject* call(R (*f)(), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0>
-PyObject* call(R (*f)(A0), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(A0), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1>
-PyObject* call(R (*f)(A0, A1), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(A0, A1), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2>
-PyObject* call(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 // Member functions
 template <class R, class A0>
-PyObject* call(R (A0::*f)(), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0>
-PyObject* call(R (A0::*f)() const, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)() const, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0>
-PyObject* call(R (A0::*f)() volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)() volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0>
-PyObject* call(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1>
-PyObject* call(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2>
-PyObject* call(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3>
-PyObject* call(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
 
 template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }

From 462b91fb0830dc5b23d21ee84bc249b3f666ac51 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:30:46 +0000
Subject: [PATCH 194/369] Added min/max argument count checking

[SVN r12225]
---
 include/boost/python/make_function.hpp | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index d824c0a4..fddc640b 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -12,27 +12,30 @@
 # include <boost/python/object/function.hpp>
 # include <boost/python/object/make_holder.hpp>
 # include <boost/python/detail/caller.hpp>
+# include <boost/python/detail/arg_tuple_size.hpp>
 
 namespace boost { namespace python {
 
 template <class F>
-PyObject* make_function(F f)
+objects::function* make_function(F f)
 {
-    return new object::function(
-        object::py_function(
-            bind<PyObject*>(detail::caller(), f, _1, _2)));
+    return new objects::function(
+        objects::py_function(
+            bind<PyObject*>(detail::caller(), f, _1, _2))
+        , detail::arg_tuple_size<F>::value);
 }
 
 template <class T, class ArgList, class Generator>
-PyObject* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
+objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
 {
     enum { nargs = mpl::size<ArgList>::value };
-    return new object::function(
-        object::py_function(
+    return new objects::function(
+        objects::py_function(
             bind<PyObject*>(detail::caller(),
-                 object::make_holder<nargs>
+                 objects::make_holder<nargs>
                             ::template apply<T,Generator,ArgList>::execute
-                 , _1, _2)));
+                 , _1, _2))
+        , nargs + 1);
 }
 
 }} // namespace boost::python

From 4b88b9eed19077136414ff961ff648fcf7c9d791 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:31:27 +0000
Subject: [PATCH 195/369] Added most of the module_builder interface

[SVN r12226]
---
 include/boost/python/module.hpp | 63 +++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index c20279c3..b257b9ff 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -8,5 +8,68 @@
 
 # include <boost/python/errors.hpp>
 # include <boost/python/detail/config.hpp>
+# include <boost/python/reference.hpp>
+# include <boost/python/make_function.hpp>
+# include <boost/python/objects.hpp>
+
+namespace boost { namespace python {
+
+class BOOST_PYTHON_DECL module_base
+{
+ public:
+    // Create a module. REQUIRES: only one module is created per module.
+    module_base(const char* name);
+    ~module_base();
+
+    // Add elements to the module
+    void add(PyObject* x, const char* name);
+    void add(PyTypeObject* x, const char* name = 0);
+    void add(ref x, const char*name);
+    void add_overload(objects::function* x, const char* 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];
+};
+
+class module : public module_base
+{
+ public:
+    module(const char* name)
+        : module_base(name) {}
+
+# if 0
+    template <class Fn>
+    void def_raw(Fn fn, const char* name)
+    {
+        add(detail::new_raw_arguments_function(fn), name);
+    }
+# endif 
+    template <class Fn>
+    void def(Fn fn, const char* name)
+    {
+        add_overload(make_function(fn), name);
+    }
+};
+
+//
+// inline implementations
+//
+inline PyObject* module_base::module() const
+{
+    return m_module;
+}
+
+}} // namespace boost::python
 
 #endif // MODULE_DWA20011221_HPP

From 8d56c529916bb3e12c0241ab3af50691d5b329b6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:32:51 +0000
Subject: [PATCH 196/369] simplification: I didn't really understand what I was
 dealing with, so I pared things down.

[SVN r12227]
---
 include/boost/python/converter/source.hpp | 58 +++--------------------
 1 file changed, 7 insertions(+), 51 deletions(-)

diff --git a/include/boost/python/converter/source.hpp b/include/boost/python/converter/source.hpp
index 9af1cf49..94fdc5b8 100644
--- a/include/boost/python/converter/source.hpp
+++ b/include/boost/python/converter/source.hpp
@@ -17,63 +17,19 @@ namespace boost { namespace python { namespace converter {
 //    ../../../more/generic_programming.html#type_generator) is used
 //    to select the argument type to use when converting T to a PyObject*
 
-template <class T> struct source;
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-// Since for some strange reason temporaries can't be bound to const
-// volatile references (8.5.3/5 in the C++ standard), we cannot use a
-// const volatile reference as the standard for values and references.
 template <class T>
 struct source
 {
-    typedef T const& type;
-};
+    BOOST_STATIC_CONSTANT(bool, use_identity = (::boost::is_pointer<T>::value));
 
-// This will handle the following:
-//      T const volatile& -> T const volatile&
-//      T volatile& -> T const volatile&
-//      T const& -> T const&
-//      T& -> T const&
-template <class T>
-struct source<T&>
-{
-    typedef T const& type;
-};
-
-template <class T>
-struct source<T*>
-{
-    typedef T const* type;
-};
-
-template <class T>
-struct source<T* const>
-{
-    typedef T const* type;
-};
-
-// Deal with references to pointers
-template <class T>
-struct source<T*&>
-{
-    typedef T const* type;
-};
-
-template <class T>
-struct source<T* const&>
-{
-    typedef T const* type;
-};
-# else
-template <class T>
-struct source
-{
-    typedef typename add_reference<
-        typename add_const<T>::type
+    typedef typename mpl::select_type<
+        use_identity
+        , T
+        , typename add_reference<
+                typename add_const<T>::type
+          >::type
     >::type type;
 };
-# endif
 
 }}} // namespace boost::python::converter
 

From 1cc65a47eb708d0569319481bda49ff8fe8ad247 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:33:33 +0000
Subject: [PATCH 197/369] Added wrapper for PyObject*

[SVN r12228]
---
 include/boost/python/converter/wrap.hpp    | 29 +++++++++++++++++++---
 include/boost/python/converter/wrapper.hpp |  2 ++
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
index e26cf0f6..ec87f73d 100644
--- a/include/boost/python/converter/wrap.hpp
+++ b/include/boost/python/converter/wrap.hpp
@@ -16,6 +16,7 @@
 namespace boost { namespace python { namespace converter { 
 
 struct BOOST_PYTHON_DECL wrapper_base;
+extern BOOST_PYTHON_DECL body& identity_wrapper;
 
 template <class T> struct wrapper;
 
@@ -66,13 +67,33 @@ struct wrap_ : wrap_more_<T>
     ~wrap_();
 };
 
+
+// Specialization for PyObject*
+template <>
+struct wrap_more_<PyObject*> : wrap_base
+{
+ protected:
+    typedef PyObject* source_t;
+    
+ public: // member functions
+    wrap_more_(handle& prev)
+        : wrap_base(&identity_wrapper, prev) {}
+
+    PyObject* operator()(source_t x) const { return x; }
+
+ protected: // constructor for wrap_<T>, below
+    wrap_more_()
+        : wrap_base(&identity_wrapper) {}
+ private:
+    friend class wrapper<PyObject*>;
+};
+
 //
 // implementations
 //
-
 inline wrap_base::wrap_base(body* body, handle& prev)
-    : handle(body, prev),
-      m_target(0)
+    : handle(body, prev)
+      , m_target(0)
 {
 }
 
@@ -119,7 +140,7 @@ template <class T>
 PyObject* wrap_more_<T>::operator()(source_t x) const
 {
     return static_cast<wrapper<T>*>(
-        get_body())->do_conversion(*this, source_holder<T>(x));
+        this->get_body())->do_conversion(*this, source_holder<T>(x));
 }
 
 template <class T>
diff --git a/include/boost/python/converter/wrapper.hpp b/include/boost/python/converter/wrapper.hpp
index 49c32186..80afae46 100644
--- a/include/boost/python/converter/wrapper.hpp
+++ b/include/boost/python/converter/wrapper.hpp
@@ -27,6 +27,8 @@ struct BOOST_PYTHON_DECL wrapper_base : body
     virtual PyObject* do_conversion(wrap_base const&, source_holder_base const&) const = 0;
 };
 
+extern BOOST_PYTHON_DECL body& identity_wrapper;
+
 template <class T>
 struct wrapper : wrapper_base
 {

From fb333f36419cb3c32211d1c811c1d718d213419a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:34:14 +0000
Subject: [PATCH 198/369] Bug fix: convertability checks were missed in one
 case

[SVN r12229]
---
 include/boost/python/detail/returning.hpp | 29 ++++++++++++-----------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index ed107d37..87aecac5 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -359,8 +359,9 @@ struct returning
     static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
     {
         // find the result converter
-        wrap<R> r;
-        return r( (*pf)() );
+        wrap<R> c0;
+        if (!c0) return 0;
+        return c0( (*pf)() );
     }
     template <class A0>
     static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
@@ -369,9 +370,9 @@ struct returning
         unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
 
         // find the result converter
-        wrap_more<R> r(c0);
+        wrap_more<R> c1(c0);
         if (!c0) return 0;
-        return r( (*pf)(*c0) );
+        return c1( (*pf)(*c0) );
     }
     template <class A0, class A1>
     static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
@@ -381,9 +382,9 @@ struct returning
         unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
 
         // find the result converter
-        wrap_more<R> r(c1);
+        wrap_more<R> c2(c1);
         if (!c0) return 0;
-        return r( (*pf)(*c0, *c1) );
+        return c2( (*pf)(*c0, *c1) );
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
@@ -394,9 +395,9 @@ struct returning
         unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
 
         // find the result converter
-        wrap_more<R> r(c2);
+        wrap_more<R> c3(c2);
         if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2) );
+        return c3( (*pf)(*c0, *c1, *c2) );
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
@@ -408,9 +409,9 @@ struct returning
         unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
 
         // find the result converter
-        wrap_more<R> r(c3);
+        wrap_more<R> c4(c3);
         if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2, *c3) );
+        return c4( (*pf)(*c0, *c1, *c2, *c3) );
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
@@ -423,9 +424,9 @@ struct returning
         unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
 
         // find the result converter
-        wrap_more<R> r(c4);
+        wrap_more<R> c5(c4);
         if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2, *c3, *c4) );
+        return c5( (*pf)(*c0, *c1, *c2, *c3, *c4) );
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
@@ -439,9 +440,9 @@ struct returning
         unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
 
         // find the result converter
-        wrap_more<R> r(c5);
+        wrap_more<R> c6(c5);
         if (!c0) return 0;
-        return r( (*pf)(*c0, *c1, *c2, *c3, *c4, *c5) );
+        return c6( (*pf)(*c0, *c1, *c2, *c3, *c4, *c5) );
     }
 };
                            

From 26d520af3cd25249987f0864cac66f1fc1683818 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:35:27 +0000
Subject: [PATCH 199/369] avoiding naming conflict, object:: -> objects::

[SVN r12230]
---
 include/boost/python/converter/class.hpp        | 10 +++++-----
 include/boost/python/object/class.hpp           |  4 ++--
 include/boost/python/object/class_unwrapper.hpp |  4 ++--
 include/boost/python/object/construct.hpp       |  4 ++--
 include/boost/python/object/make_holder.hpp     |  4 ++--
 include/boost/python/object/value_holder.hpp    |  4 ++--
 6 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
index 6e09a961..c6fef86a 100644
--- a/include/boost/python/converter/class.hpp
+++ b/include/boost/python/converter/class.hpp
@@ -32,31 +32,31 @@ struct class_unwrapper
 template <class T>
 void* class_unwrapper<T>::can_convert(PyObject* p) const
 {
-    return object::find_holder<T>(p);
+    return objects::find_holder<T>(p);
 }
 
 template <class T>
 T& class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T&>) const
 {
-    return *static_cast<object::holder<T>*>(holder_)->target();
+    return *static_cast<objects::holder<T>*>(holder_)->target();
 }
 
 template <class T>
 T const& class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T const&>) const
 {
-    return *static_cast<object::holder<T>*>(holder_)->target();
+    return *static_cast<objects::holder<T>*>(holder_)->target();
 }
 
 template <class T>
 T* class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T*>) const
 {
-    return static_cast<object::holder<T>*>(holder_)->target();
+    return static_cast<objects::holder<T>*>(holder_)->target();
 }
 
 template <class T>
 T const* class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T const*>) const
 {
-    return static_cast<object::holder<T>*>(holder_)->target();
+    return static_cast<objects::holder<T>*>(holder_)->target();
 }
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 35085e5f..b272d5fe 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -12,7 +12,7 @@
 # include <boost/python/converter/type_id.hpp>
 # include <boost/iterator_adaptors.hpp>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 template <class T> struct holder;
 
@@ -98,6 +98,6 @@ holder<Held>::holder()
 {
 }
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // CLASS_DWA20011214_HPP
diff --git a/include/boost/python/object/class_unwrapper.hpp b/include/boost/python/object/class_unwrapper.hpp
index 4fa441e1..666c6e93 100644
--- a/include/boost/python/object/class_unwrapper.hpp
+++ b/include/boost/python/object/class_unwrapper.hpp
@@ -9,7 +9,7 @@
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/unwrapper.hpp>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 template <class T>
 struct class_unwrapper
@@ -35,6 +35,6 @@ struct class_unwrapper
 # endif 
 };
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // CLASS_UNWRAPPER_DWA20011221_HPP
diff --git a/include/boost/python/object/construct.hpp b/include/boost/python/object/construct.hpp
index 3ff701d2..1eb73e4a 100644
--- a/include/boost/python/object/construct.hpp
+++ b/include/boost/python/object/construct.hpp
@@ -6,7 +6,7 @@
 #ifndef CONSTRUCT_DWA20011215_HPP
 # define CONSTRUCT_DWA20011215_HPP
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 template <class T, class ArgList>
 struct construct
@@ -19,6 +19,6 @@ struct construct
     }
 };
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // CONSTRUCT_DWA20011215_HPP
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index fb5ec382..76b3a5f4 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -11,7 +11,7 @@
 # include <boost/python/object/class.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 
 template <class T> struct undefined;
@@ -119,6 +119,6 @@ struct make_holder<3>
     };
 };
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // MAKE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index 128d170b..a06afe84 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -8,7 +8,7 @@
 
 # include <boost/python/object/class.hpp>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 template <class Held>
 struct value_holder : holder<Held>
@@ -75,6 +75,6 @@ struct value_holder_generator
     };
 };
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // VALUE_HOLDER_DWA20011215_HPP

From ab22e1b3a9b592837f73fb29de5feb275e440626 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:36:28 +0000
Subject: [PATCH 200/369] Added most of the module_builder interface

[SVN r12231]
---
 Jamfile | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/Jamfile b/Jamfile
index 18372684..13cb04d7 100644
--- a/Jamfile
+++ b/Jamfile
@@ -13,17 +13,19 @@ PYTHON_PROPERTIES
 
 dll bpl
   : 
-  src/converter/body.cpp
-  src/converter/handle.cpp
-  src/converter/registry.cpp
-  src/converter/wrapper.cpp
-  src/converter/unwrap.cpp
-  src/converter/unwrapper.cpp
-  src/converter/type_id.cpp
-  src/object/class.cpp
-  src/object/function.cpp
-  src/errors.cpp
-  :
+    src/converter/body.cpp
+    src/converter/handle.cpp
+    src/converter/registry.cpp
+    src/converter/wrapper.cpp
+    src/converter/unwrap.cpp
+    src/converter/unwrapper.cpp
+    src/converter/type_id.cpp
+    src/object/class.cpp
+    src/object/function.cpp
+    src/errors.cpp
+    src/module.cpp
+    src/objects.cpp
+    :
   $(PYTHON_PROPERTIES)
     <define>BOOST_PYTHON_SOURCE
   ;

From d598d0a4dbc3fad4426d6dc90b8d6d76c047fcd6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:39:34 +0000
Subject: [PATCH 201/369] added inlines

[SVN r12232]
---
 src/gen_call.py |   4 +-
 test/m1.cpp     |  99 ++++++++-------------------
 test/m2.cpp     | 177 +++++++-----------------------------------------
 test/newtest.py |  21 ++----
 4 files changed, 61 insertions(+), 240 deletions(-)

diff --git a/src/gen_call.py b/src/gen_call.py
index dd178648..f609c0ae 100644
--- a/src/gen_call.py
+++ b/src/gen_call.py
@@ -36,7 +36,7 @@ def gen_call(member_function_args, free_function_args = None):
     return (header % (member_function_args, free_function_args)
             + gen_functions(
 '''template <class R%(, class A%n%)>
-PyObject* call(R (*f)(%(A%n%:, %)), PyObject* args, PyObject* keywords)
+inline PyObject* call(R (*f)(%(A%n%:, %)), PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
@@ -49,7 +49,7 @@ PyObject* call(R (*f)(%(A%n%:, %)), PyObject* args, PyObject* keywords)
                    , map(lambda cv:
                          gen_functions(
 '''template <class R, class A0%(, class A%+%)>
-PyObject* call(R (A0::*f)(%(A%+%:, %))%1, PyObject* args, PyObject* keywords)
+inline PyObject* call(R (A0::*f)(%(A%+%:, %))%1, PyObject* args, PyObject* keywords)
 {
     return detail::returning<R>::call(f, args, keywords);
 }
diff --git a/test/m1.cpp b/test/m1.cpp
index db450f77..78471bfc 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -4,15 +4,13 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
 
-// Seems to be neccessary to suppress an ICE with MSVC
-#include <boost/mpl/comparison/less.hpp>
-
 #include "simple_type.hpp"
 #include "complicated.hpp"
 #include <boost/python/converter/wrapper.hpp>
 #include <boost/python/converter/unwrapper.hpp>
 #include <boost/python/detail/config.hpp>
 #include <boost/python/convert.hpp>
+#include <boost/python/module.hpp>
 #include <boost/python/object/value_holder.hpp>
 #include <boost/python/object/class.hpp>
 #include <boost/python/converter/class.hpp>
@@ -53,17 +51,10 @@ PyTypeObject NoddyType = {
 };
 
 // Create a Noddy containing 42
-extern "C" PyObject*
-new_noddy(PyObject* self, PyObject* args)
+PyObject* new_noddy()
 {
-    NoddyObject* noddy;
-
-    if (!PyArg_ParseTuple(args,":new_noddy")) 
-        return NULL;
-
-    noddy = PyObject_New(NoddyObject, &NoddyType);
+    NoddyObject* noddy = PyObject_New(NoddyObject, &NoddyType);
     noddy->x = 42;
-    
     return (PyObject*)noddy;
 }
 
@@ -92,27 +83,13 @@ PyTypeObject SimpleType = {
 };
 
 // Create a Simple containing "hello, world"
-extern "C" PyObject*
-new_simple(PyObject* self, PyObject* args)
+PyObject* new_simple()
 {
-    SimpleObject* simple;
-
-    if (!PyArg_ParseTuple(args,":new_simple")) 
-        return NULL;
-
-    simple = PyObject_New(SimpleObject, &SimpleType);
+    SimpleObject* simple = PyObject_New(SimpleObject, &SimpleType);
     simple->x.s = "hello, world";
-    
     return (PyObject*)simple;
 }
 
-// Initial method table for the module
-static PyMethodDef methods[] = {
-    { "new_noddy", new_noddy, METH_VARARGS },
-    { "new_simple", new_simple, METH_VARARGS },
-    {0, 0, 0, 0}
-};
-
 //
 // Declare some wrappers/unwrappers to test the low-level conversion
 // mechanism. See boost/python/converter/source.hpp,target.hpp for a
@@ -252,7 +229,7 @@ simple const& g(simple const& x)
 
 BOOST_PYTHON_MODULE_INIT(m1)
 {
-    PyObject* m1 = Py_InitModule(const_cast<char*>("m1"), methods);
+    boost::python::module m1("m1");
 
     // Create the converters; they are self-registering/unregistering.
     static int_wrapper wrap_int;
@@ -262,63 +239,45 @@ BOOST_PYTHON_MODULE_INIT(m1)
     static noddy_int_ref_unwrapper unwrap_int3;
     static simple_ref_unwrapper unwrap_simple;
     static simple_const_ref_unwrapper unwrap_simple_const_ref;
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    // These compilers will need additional converters
     static simple_ref_wrapper wrap_simple_ref;
-#endif
 
     // This unwrapper extracts pointers and references to the "complicated" class.
     static boost::python::converter::class_unwrapper<complicated> unwrap_complicated;
     
-    PyObject* d = PyModule_GetDict(m1);
-    if (d == NULL)
-        return;
-
     // Insert the extension metaclass object
-    if (PyDict_SetItemString(
-            d, "xclass", (PyObject *)boost::python::object::class_metatype()) < 0)
-        return;
-
+    m1.add(boost::python::objects::class_metatype(), "xclass");
+    
     // Insert the base class for all extension classes
-    if (PyDict_SetItemString(
-            d, "xinst", (PyObject *)boost::python::object::class_type()) < 0)
-        return;
+    m1.add(boost::python::objects::class_type(), "xinst");
 
+    m1.def(new_noddy, "new_noddy");
+    m1.def(new_simple, "new_simple");
+    
     // Expose f()
-    if (PyDict_SetItemString(
-            d, "f", boost::python::make_function(f)) < 0)
-        return;
+    m1.def(f, "f");
 
     // Expose g()
-    if (PyDict_SetItemString(
-            d, "g", boost::python::make_function(g)) < 0)
-        return;
+    m1.def(g, "g");
 
     // Expose complicated's get_n() member function. See newtest.py
     // for how it's used to build an extension class.
-    if (PyDict_SetItemString(
-            d, "get_n", boost::python::make_function(&complicated::get_n)) < 0)
-        return;
+    m1.def(&complicated::get_n, "get_n");
 
     // Expose complicated::complicated(simple const&, int) as init1
-    if (PyDict_SetItemString(
-            d, "init1"
-            , boost::python::make_constructor<
-                complicated
-                , boost::mpl::type_list<simple const&,int>
-                , boost::python::object::value_holder_generator>()
-            ) < 0)
-        return;
-
-    // Expose complicated::complicated(simple const&) as init2
-    if (PyDict_SetItemString(
-            d, "init2"
-            , boost::python::make_constructor<
-                complicated
-                , boost::mpl::type_list<simple const&>
-                , boost::python::object::value_holder_generator>()
-            ) < 0)
-        return;
+    boost::python::objects::function* init = boost::python::make_constructor<
+        complicated
+        , boost::mpl::type_list<simple const&,int>
+        , boost::python::objects::value_holder_generator>();
+    
+    boost::python::ref manager(init);
+    
+    init->add_overload(
+        boost::python::make_constructor<
+        complicated
+        , boost::mpl::type_list<simple const&>
+        , boost::python::objects::value_holder_generator>());
+    
+    m1.add(manager, "init1");
 }
 
 #include "module_tail.cpp"
diff --git a/test/m2.cpp b/test/m2.cpp
index 377ce02e..3c5267d0 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -7,10 +7,6 @@
 // This module exercises the converters exposed in m1 at a low level
 // by exposing raw Python extension functions that use wrap<> and
 // unwrap<> objects.
-
-// Seems to be neccessary to suppress an ICE with MSVC
-#include <boost/mpl/comparison/less.hpp>
-
 #include <boost/python/convert.hpp>
 #include <boost/python/module.hpp>
 #include "simple_type.hpp"
@@ -22,106 +18,40 @@ extern "C"
 {
     // Get a simple (by value) from the argument, and return the
     // string it holds.
-    PyObject*
-    unwrap_simple(PyObject* self, PyObject* args)
+    PyObject* unwrap_simple(simple x)
     {
-        PyObject* p;
-        if (!PyArg_ParseTuple(args, "O", &p))
-            return 0;
-
-        boost::python::unwrap<simple> in(p);
-        if (!in)
-            return 0;
-    
-        simple x = *in;
-    
         return PyString_FromString(x.s);
     }
 
     // Likewise, but demands that its possible to get a non-const
     // reference to the simple.
-    PyObject*
-    unwrap_simple_ref(PyObject* self, PyObject* args)
+    PyObject* unwrap_simple_ref(simple& x)
     {
-        PyObject* p;
-        if (!PyArg_ParseTuple(args, "O", &p))
-            return 0;
-
-        unwrap<simple&> in(p);
-        if (!in)
-            return 0;
-    
-        simple& x = *in;
-    
         return PyString_FromString(x.s);
     }
 
     // Likewise, with a const reference to the simple object.
-    PyObject*
-    unwrap_simple_const_ref(PyObject* self, PyObject* args)
+    PyObject* unwrap_simple_const_ref(simple const& x)
     {
-        PyObject* p;
-        if (!PyArg_ParseTuple(args, "O", &p))
-            return 0;
-    
-        unwrap<simple const&> in(p);
-        if (!in)
-            return 0;
-    
-        simple const& x = *in;
-    
         return PyString_FromString(x.s);
     }
 
     // Get an int (by value) from the argument, and convert it to a
     // Python Int.
-    PyObject*
-    unwrap_int(PyObject* self, PyObject* args)
+    PyObject* unwrap_int(int x)
     {
-        PyObject* p;
-        if (!PyArg_ParseTuple(args, "O", &p))
-            return 0;
-    
-        unwrap<int> in(p);
-        if (!in)
-            return 0;
-    
-        int x = *in;
-    
         return PyInt_FromLong(x);
     }
 
     // Get a non-const reference to an int from the argument
-    PyObject*
-    unwrap_int_ref(PyObject* self, PyObject* args)
+    PyObject* unwrap_int_ref(int& x)
     {
-        PyObject* p;
-        if (!PyArg_ParseTuple(args, "O", &p))
-            return 0;
-    
-        unwrap<int&> in(p);
-        if (!in)
-            return 0;
-    
-        int& x = *in;
-    
         return PyInt_FromLong(x);
     }
 
     // Get a const reference to an  int from the argument.
-    PyObject*
-    unwrap_int_const_ref(PyObject* self, PyObject* args)
+    PyObject* unwrap_int_const_ref(int const& x)
     {
-        PyObject* p;
-        if (!PyArg_ParseTuple(args, "O", &p))
-            return 0;
-    
-        unwrap<int&> in(p);
-        if (!in)
-            return 0;
-    
-        int const& x = *in;
-    
         return PyInt_FromLong(x);
     }
 
@@ -134,89 +64,28 @@ template <class T> struct xxxx;
 // rewrap<T> extracts a T from the argument, then converts the T back
 // to a PyObject* and returns it.
 template <class T>
-PyObject*
-rewrap(PyObject* self, PyObject* args, xxxx<T>* = 0)
+struct rewrap
 {
-    PyObject* p;
-    if (!PyArg_ParseTuple(args, "O", &p))
-        return 0;
-
-    boost::python::unwrap<T> in(p);
-    if (!in)
-        return 0;
-
-    boost::python::wrap<T> out;
-    if (!out)
-        return 0;
-    
-    T x = *in;
-    return out(x);
-}
-
-extern "C"
-{
-    //
-    // Use rewrap<T> to test simple, simple&, simple const&, int,
-    // int&, int const&
-    //
-    PyObject*
-    wrap_simple(PyObject* self, PyObject* args)
-    {
-        return rewrap<simple>(self, args);
-    }
-
-    PyObject*
-    wrap_simple_ref(PyObject* self, PyObject* args)
-    {
-        return rewrap<simple&>(self, args);
-    }
-
-    PyObject*
-    wrap_simple_const_ref(PyObject* self, PyObject* args)
-    {
-        return rewrap<simple const&>(self, args);
-    }
-
-    PyObject*
-    wrap_int(PyObject* self, PyObject* args)
-    {
-        return rewrap<int>(self, args);
-    }
-
-    PyObject*
-    wrap_int_ref(PyObject* self, PyObject* args)
-    {
-        return rewrap<int&>(self, args);
-    }
-
-    PyObject*
-    wrap_int_const_ref(PyObject* self, PyObject* args)
-    {
-        return rewrap<int const&>(self, args);
-    }
-}
-
-PyMethodDef initial_methods[] =
-{
-    { "unwrap_int", unwrap_int, METH_VARARGS, 0 },
-    { "unwrap_int_ref", unwrap_int_ref, METH_VARARGS, 0 },
-    { "unwrap_int_const_ref", unwrap_int_const_ref, METH_VARARGS, 0 },
-    { "unwrap_simple", unwrap_simple, METH_VARARGS, 0 },
-    { "unwrap_simple_ref", unwrap_simple_ref, METH_VARARGS, 0 },
-    { "unwrap_simple_const_ref", unwrap_simple_const_ref, METH_VARARGS, 0 },
-
-    { "wrap_int", wrap_int, METH_VARARGS, 0 },
-    { "wrap_int_ref", wrap_int_ref, METH_VARARGS, 0 },
-    { "wrap_int_const_ref", wrap_int_const_ref, METH_VARARGS, 0 },
-    { "wrap_simple", wrap_simple, METH_VARARGS, 0 },
-    { "wrap_simple_ref", wrap_simple_ref, METH_VARARGS, 0 },
-    { "wrap_simple_const_ref", wrap_simple_const_ref, METH_VARARGS, 0 },
-    { 0, 0, 0, 0 }
+    static T f(T x) { return x; }
 };
 
 BOOST_PYTHON_MODULE_INIT(m2)
 {
-    Py_InitModule(const_cast<char*>("m2"), initial_methods);
+    boost::python::module m2("m2");
+    
+    m2.def(unwrap_int, "unwrap_int");
+    m2.def(unwrap_int_ref, "unwrap_int_ref");
+    m2.def(unwrap_int_const_ref, "unwrap_int_const_ref");
+    m2.def(unwrap_simple, "unwrap_simple");
+    m2.def(unwrap_simple_ref, "unwrap_simple_ref");
+    m2.def(unwrap_simple_const_ref, "unwrap_simple_const_ref");
+
+    m2.def(&rewrap<int>::f, "wrap_int");
+    m2.def(&rewrap<int&>::f, "wrap_int_ref");
+    m2.def(&rewrap<int const&>::f, "wrap_int_const_ref");
+    m2.def(&rewrap<simple>::f, "wrap_simple");
+    m2.def(&rewrap<simple&>::f, "wrap_simple_ref");
+    m2.def(&rewrap<simple const&>::f, "wrap_simple_const_ref");
 }
 
 #include "module_tail.cpp"
diff --git a/test/newtest.py b/test/newtest.py
index b866258c..d29ac129 100644
--- a/test/newtest.py
+++ b/test/newtest.py
@@ -20,16 +20,14 @@
 >>> unwrap_int(5)
 5
 
-Can't get a reference to a built-in integer object
+Can't get a non-const reference to a built-in integer object
 >>> try:
 ...     unwrap_int_ref(7)
 ... except: pass
 ... else: print 'no exception'
 
->>> try:
-...     unwrap_int_const_ref(9)
-... except: pass
-... else: print 'no exception'
+>>> unwrap_int_const_ref(9)
+9
 
 >>> wrap_int(n)
 42
@@ -63,16 +61,11 @@ Create an extension class which wraps "complicated" (init1 and get_n)
 are a complicated constructor and member function, respectively.
 
 >>> C = xclass('C', (xinst,), {'__init__': init1, 'get_n': get_n})
->>> c = C(s, 99)
->>> c.get_n()
+>>> c1 = C(s, 99)
+>>> c1.get_n()
 99
-
-Create another extension class which wraps "complicated" (init2 is a
-different constructor -- no overloading yet).
-
->>> D = xclass('D', (xinst,), {'__init__': init2, 'get_n': get_n})
->>> d = D(s)
->>> d.get_n()
+>>> c2 = C(s)
+>>> c2.get_n()
 0
 
 """

From 03fef3106d17d2b3e46dfc2175d047276f720cfd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:39:52 +0000
Subject: [PATCH 202/369] Bug fix: convertability checks were missed in one
 case

[SVN r12233]
---
 src/gen_returning.py | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/src/gen_returning.py b/src/gen_returning.py
index 2c33cfe5..80e3342b 100644
--- a/src/gen_returning.py
+++ b/src/gen_returning.py
@@ -84,29 +84,23 @@ free_function = '''%{    template <%(class A%n%:, %)>
 %}%(        unwrap%{_more%}<A%n> c%n(PyTuple_GET_ITEM(args, %n)%{, c%-%});
 %)%[r%:
         // find the result converter
-        wrap%{_more%}<R> r%{(c%-)%};%]%{
-        if (!c0) return 0;%}
-        %[r%:return r( %](*pf)(%(*c%n%:, %))%[r%: )%];%[v%:
+        wrap%{_more%}<R> c%n%{(c%-)%};%]%[not-void-and-0-arg%:
+        if (!c0) return 0;%]
+        %[r%:return c%n( %](*pf)(%(*c%n%:, %))%[r%: )%];%[v%:
         return detail::none();%]
     }
 ''' 
 
 def _returns_value(key, n, args, value):
-    if key == 'r':
+    if key != 'v':
         return value
-        # pass the value through gen_function again for recursive expansion
-#        return apply(gen_function, (value, n) + args
-#                     , {'fill': _returns_value})
     else:
-        assert key == 'v'
         return ''
 
 def _returns_void(key, n, args, value):
-    if key == 'v':
+    if key == 'v' or key == 'not-void-and-0-arg' and n != 0:
         return value
     else:
-        assert key == 'r'
-        # return the empty string, ignoring the value
         return ''
 
 _cv_qualifiers = ('', ' const', ' volatile', ' const volatile')

From cdac34efeaa77d6ea82606e731f3c46c795e62b4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:40:33 +0000
Subject: [PATCH 203/369] Added wrapper for PyObject*

[SVN r12234]
---
 src/converter/wrapper.cpp | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/src/converter/wrapper.cpp b/src/converter/wrapper.cpp
index 0d817217..567ff99d 100644
--- a/src/converter/wrapper.cpp
+++ b/src/converter/wrapper.cpp
@@ -12,12 +12,6 @@ namespace boost { namespace python { namespace converter {
 wrapper_base::wrapper_base(type_id_t type)
     : body(type)
 {
-    // static assertions for target<T>. These would go in a header,
-    // but Metrowerks only respects BOOST_STATIC_ASSERT if it is in an
-    // instantiated function
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#else
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
     registry::insert(*this);
 }
 
@@ -27,4 +21,21 @@ wrapper_base::~wrapper_base()
         registry::remove(*this);
 }
 
+namespace
+{
+  // This doesn't actually get called, but we need something to fill
+  // in the slot in the wrap<PyObject*> class.
+  struct identity_wrapper_t : wrapper<PyObject*>
+  {
+      PyObject* convert(PyObject* source) const
+      {
+          return source;
+      }
+  };
+
+  identity_wrapper_t identity_wrapper_object;
+}
+
+BOOST_PYTHON_DECL body& identity_wrapper = identity_wrapper_object;
+
 }}} // namespace boost::python::converter

From 65c74e39761c0237581d0459d1db6775ec055478 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:40:53 +0000
Subject: [PATCH 204/369] avoiding naming conflict, object:: -> objects::

[SVN r12235]
---
 src/object/class.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/object/class.cpp b/src/object/class.cpp
index bdd66a77..1b855120 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -3,15 +3,13 @@
 // copyright notice appears in all copies. This software is provided
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
-
 #include <boost/python/detail/config.hpp>
-#include <boost/python/module.hpp>
 #include <boost/python/detail/wrap_python.hpp>
 #include <boost/python/object/class.hpp>
 #include <boost/bind.hpp>
 #include <functional>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 holder_base::holder_base(converter::type_id_t id)
     : m_type(id)
@@ -160,4 +158,4 @@ find_holder_impl(PyObject* inst, converter::type_id_t type)
         ? match.base() : 0;
 }
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects

From 72aa7682352c5cfeb327810521168472ffd5adff Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 6 Jan 2002 14:41:51 +0000
Subject: [PATCH 205/369] Added overload capability

[SVN r12236]
---
 src/object/function.cpp | 59 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 53 insertions(+), 6 deletions(-)

diff --git a/src/object/function.cpp b/src/object/function.cpp
index 4c2de3c7..52a0456c 100644
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -5,12 +5,16 @@
 // to its suitability for any purpose.
 
 #include <boost/python/object/function.hpp>
+#include <numeric>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 
-function::function(py_function implementation)
+function::function(py_function implementation, unsigned min_args, unsigned max_args)
     : m_fn(implementation)
+    , m_min_args(min_args)
+      , m_max_args(std::max(max_args,min_args))
+      , m_overloads(0)
 {
     PyObject* p = this;
     PyObject_INIT(p, &function_type);
@@ -18,22 +22,65 @@ function::function(py_function implementation)
 
 function::~function()
 {
+    PyObject* overloads = m_overloads;
+    Py_XDECREF(overloads);
 }
     
 PyObject* function::call(PyObject* args, PyObject* keywords) const
 {
-    return m_fn(args, keywords);
+    int nargs = PyTuple_GET_SIZE(args);
+    function const* f = this;
+    do
+    {
+        // Check for a plausible number of arguments
+        if (nargs >= f->m_min_args && nargs <= f->m_max_args)
+        {
+            // Call the function
+            PyObject* result = f->m_fn(args, keywords);
+            
+            // If the result is NULL but no error was set, m_fn failed
+            // the argument-matching test.
+
+            // This assumes that all other error-reporters are
+            // well-behaved and never return NULL to python without
+            // setting an error.
+            if (result != 0 || PyErr_Occurred())
+                return result;
+        }
+        f = f->m_overloads;
+    }
+    while (f);
+    // None of the overloads matched; time to generate the error message
+    argument_error(args, keywords);
+    return 0;
+}
+
+void function::argument_error(PyObject* args, PyObject* keywords) const
+{
+    // This function needs to be improved to do better error reporting.
+    PyErr_BadArgument();
+}
+
+void function::add_overload(function* overload)
+{
+    function* parent = this;
+    
+    while (parent->m_overloads != 0)
+    {
+        parent = parent->m_overloads;
+    }
+    parent->m_overloads = overload;
 }
 
 extern "C"
 {
     // Stolen from Python's funcobject.c
     static PyObject *
-    function_descr_get(PyObject *func, PyObject *obj, PyObject *type)
+    function_descr_get(PyObject *func, PyObject *obj, PyObject *type_)
     {
         if (obj == Py_None)
             obj = NULL;
-        return PyMethod_New(func, obj, type);
+        return PyMethod_New(func, obj, type_);
     }
 
     static void
@@ -92,4 +139,4 @@ PyTypeObject function_type = {
     0                                       /* tp_new */
 };
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects

From e83e8a8f1caf73c4068646b7c9b852b36910e690 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 7 Jan 2002 06:45:53 +0000
Subject: [PATCH 206/369] object::->objects::

[SVN r12237]
---
 include/boost/python/object/forward.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/object/forward.hpp b/include/boost/python/object/forward.hpp
index cc9d65bb..88eefe6b 100644
--- a/include/boost/python/object/forward.hpp
+++ b/include/boost/python/object/forward.hpp
@@ -11,7 +11,7 @@
 # include <boost/type_traits/composite_traits.hpp>
 # include <boost/type_traits/transform_traits.hpp>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 // A little metaprogram which selects the type to pass through an
 // intermediate forwarding function when the destination argument type
@@ -28,6 +28,6 @@ struct forward
     >::type type;
 };
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // FORWARD_DWA20011215_HPP

From 0dafa9e2299d0b0f629482ce03998d30f4dff0a7 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 7 Jan 2002 06:46:32 +0000
Subject: [PATCH 207/369] check number of arguments

[SVN r12238]
---
 include/boost/python/object/function.hpp | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/object/function.hpp b/include/boost/python/object/function.hpp
index a0257676..ed7dd319 100644
--- a/include/boost/python/object/function.hpp
+++ b/include/boost/python/object/function.hpp
@@ -8,21 +8,30 @@
 
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/config.hpp>
+# include <boost/python/reference.hpp>
 # include <boost/function.hpp>
 
-namespace boost { namespace python { namespace object { 
+namespace boost { namespace python { namespace objects { 
 
 // We use boost::function to avoid generating lots of virtual tables
 typedef boost::function2<PyObject*, PyObject*, PyObject*> py_function;
 
 struct BOOST_PYTHON_DECL function : PyObject
 {
-    function(py_function);
+    function(py_function, unsigned min_args, unsigned max_args = 0);
     ~function();
     
     PyObject* call(PyObject*, PyObject*) const;
- private:    
+    void add_overload(function* overload);
+    
+ private: // helper functions
+    void argument_error(PyObject* args, PyObject* keywords) const;
+    
+ private: // data members
     py_function m_fn;
+    unsigned m_min_args;
+    unsigned m_max_args;
+    function* m_overloads;
 };
 
 extern BOOST_PYTHON_DECL PyTypeObject function_type;
@@ -31,6 +40,6 @@ extern BOOST_PYTHON_DECL PyTypeObject function_type;
 // implementations
 //
 
-}}} // namespace boost::python::object
+}}} // namespace boost::python::objects
 
 #endif // FUNCTION_DWA20011214_HPP

From 9923a4c4ff81a150fa5367cccd1b392908afe54e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 7 Jan 2002 06:47:22 +0000
Subject: [PATCH 208/369] More "realism"

[SVN r12239]
---
 include/boost/python/converter/class.hpp     | 18 +++----
 include/boost/python/object/class.hpp        | 53 ++++++--------------
 include/boost/python/object/value_holder.hpp | 12 +++--
 src/object/class.cpp                         | 29 ++++++-----
 4 files changed, 48 insertions(+), 64 deletions(-)

diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
index c6fef86a..458ecee4 100644
--- a/include/boost/python/converter/class.hpp
+++ b/include/boost/python/converter/class.hpp
@@ -32,31 +32,31 @@ struct class_unwrapper
 template <class T>
 void* class_unwrapper<T>::can_convert(PyObject* p) const
 {
-    return objects::find_holder<T>(p);
+    return objects::find_instance<T>(p);
 }
 
 template <class T>
-T& class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T&>) const
+T& class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T&>) const
 {
-    return *static_cast<objects::holder<T>*>(holder_)->target();
+    return *static_cast<T*>(found);
 }
 
 template <class T>
-T const& class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T const&>) const
+T const& class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T const&>) const
 {
-    return *static_cast<objects::holder<T>*>(holder_)->target();
+    return *static_cast<T*>(found);
 }
 
 template <class T>
-T* class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T*>) const
+T* class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T*>) const
 {
-    return static_cast<objects::holder<T>*>(holder_)->target();
+    return static_cast<T*>(found);
 }
 
 template <class T>
-T const* class_unwrapper<T>::convert(PyObject*, void* holder_, boost::type<T const*>) const
+T const* class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T const*>) const
 {
-    return static_cast<objects::holder<T>*>(holder_)->target();
+    return static_cast<T*>(found);
 }
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index b272d5fe..bc8f40d1 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -17,15 +17,16 @@ namespace boost { namespace python { namespace objects {
 template <class T> struct holder;
 
 // Base class for all holders
-struct BOOST_PYTHON_DECL holder_base : noncopyable
+struct BOOST_PYTHON_DECL instance_holder : noncopyable
 {
  public:
-    holder_base(converter::type_id_t id);
-    virtual ~holder_base();
-    virtual bool held_by_value() const = 0;
+    instance_holder();
+    virtual ~instance_holder();
     
-    holder_base* next() const;
-    converter::type_id_t type() const;
+    // return the next holder in a chain
+    instance_holder* next() const;
+
+    virtual void* holds(converter::type_id_t) = 0;
 
     void install(PyObject* inst);
     
@@ -39,41 +40,30 @@ struct BOOST_PYTHON_DECL holder_base : noncopyable
     };
     
     typedef iterator_adaptor<
-        holder_base*
+        instance_holder*
         , iterator_policies
         , value_type_is<noncopyable>
-        , reference_is<holder_base&>
-        , pointer_is<holder_base*>
+        , reference_is<instance_holder&>
+        , pointer_is<instance_holder*>
         , iterator_category_is<std::input_iterator_tag> > iterator;
     
  private:
-    converter::type_id_t m_type;
-    holder_base* m_next;
-};
-
-// Abstract base class which holds a Held, somehow. Provides a uniform
-// way to get a pointer to the held object
-template <class Held>
-struct holder : holder_base
-{
-    typedef Held held_type;
-    holder();
-    virtual Held* target() = 0;
+    instance_holder* m_next;
 };
 
 // Each extension instance will be one of these
 struct instance
 {
     PyObject_HEAD
-    holder_base* objects;
+    instance_holder* objects;
 };
 
-BOOST_PYTHON_DECL holder_base* find_holder_impl(PyObject*, converter::type_id_t);
+BOOST_PYTHON_DECL void* find_instance_impl(PyObject*, converter::type_id_t);
 
 template <class T>
-holder<T>* find_holder(PyObject* p, T* = 0)
+T* find_instance(PyObject* p, T* = 0)
 {
-    return static_cast<holder<T>*>(find_holder_impl(p, converter::type_id<T>()));
+    return static_cast<T*>(find_instance_impl(p, converter::type_id<T>()));
 }
 
 BOOST_PYTHON_DECL PyTypeObject* class_metatype();
@@ -82,22 +72,11 @@ BOOST_PYTHON_DECL PyTypeObject* class_type();
 //
 // implementation
 //
-inline holder_base* holder_base::next() const
+inline instance_holder* instance_holder::next() const
 {
     return m_next;
 }
 
-inline converter::type_id_t holder_base::type() const
-{
-    return m_type;
-}
-
-template <class Held>
-holder<Held>::holder()
-    : holder_base(converter::type_id<Held>())
-{
-}
-
 }}} // namespace boost::python::objects
 
 #endif // CLASS_DWA20011214_HPP
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index a06afe84..be7247da 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -7,11 +7,12 @@
 # define VALUE_HOLDER_DWA20011215_HPP
 
 # include <boost/python/object/class.hpp>
+# include <boost/python/converter/type_id.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
 template <class Held>
-struct value_holder : holder<Held>
+struct value_holder : instance_holder
 {
     // Forward construction to the held object
     value_holder(PyObject*)
@@ -58,8 +59,7 @@ struct value_holder : holder<Held>
         : m_held(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
 
  private: // required holder implementation
-    Held* target() { return &m_held; }
-    bool held_by_value() const { return true; }
+    void* holds(converter::type_id_t);
 
  private: // data members
     Held m_held;
@@ -75,6 +75,12 @@ struct value_holder_generator
     };
 };
 
+template <class Held>
+void* value_holder<Held>::holds(converter::type_id_t x)
+{
+    return x == converter::type_id<Held>() ? &m_held : 0;
+}
+
 }}} // namespace boost::python::objects
 
 #endif // VALUE_HOLDER_DWA20011215_HPP
diff --git a/src/object/class.cpp b/src/object/class.cpp
index 1b855120..8e85f38b 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -11,13 +11,12 @@
 
 namespace boost { namespace python { namespace objects { 
 
-holder_base::holder_base(converter::type_id_t id)
-    : m_type(id)
-    , m_next(0)
+instance_holder::instance_holder()
+    : m_next(0)
 {
 }
 
-holder_base::~holder_base()
+instance_holder::~instance_holder()
 {
 }
 
@@ -134,28 +133,28 @@ BOOST_PYTHON_DECL PyTypeObject* class_type()
     return &class_type_object;
 }
 
-void holder_base::install(PyObject* self)
+void instance_holder::install(PyObject* self)
 {
     assert(self->ob_type->ob_type == &class_metatype_object);
     m_next = ((instance*)self)->objects;
     ((instance*)self)->objects = this;
 }
 
-BOOST_PYTHON_DECL holder_base*
-find_holder_impl(PyObject* inst, converter::type_id_t type)
+BOOST_PYTHON_DECL void*
+find_instance_impl(PyObject* inst, converter::type_id_t type)
 {
     if (inst->ob_type->ob_type != &class_metatype_object)
         return 0;
+    
     instance* self = reinterpret_cast<instance*>(inst);
 
-    holder_base::iterator match = std::find_if(
-        holder_base::iterator(self->objects), holder_base::iterator(0)
-        , bind<bool>(std::equal_to<converter::type_id_t>()
-               , bind<converter::type_id_t>(mem_fn(&holder_base::type), _1)
-               , type));
-    
-    return match != holder_base::iterator(0)
-        ? match.base() : 0;
+    for (instance_holder::iterator match(self->objects), end(0); match != end; ++match)
+    {
+        void* const found = (*match).holds(type);
+        if (found)
+            return found;
+    }
+    return 0;
 }
 
 }}} // namespace boost::python::objects

From 10a04acf418f39cca5f046d5456699c7200f8045 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Wed, 9 Jan 2002 21:20:51 +0000
Subject: [PATCH 209/369] Missing this-> inserted (due to EDG 245 diagnostics)

[SVN r12261]
---
 include/boost/python/converter/unwrap.hpp | 2 +-
 include/boost/python/converter/wrap.hpp   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
index ffd0f081..525f1bb0 100644
--- a/include/boost/python/converter/unwrap.hpp
+++ b/include/boost/python/converter/unwrap.hpp
@@ -162,7 +162,7 @@ T unwrap_more_<T>::operator*()
 template <class T>
 unwrap_<T>::~unwrap_()
 {
-    destroy();
+    this->destroy();
 }
     
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
index ec87f73d..97d7b8de 100644
--- a/include/boost/python/converter/wrap.hpp
+++ b/include/boost/python/converter/wrap.hpp
@@ -158,7 +158,7 @@ wrap_<T>::wrap_()
 template <class T>
 wrap_<T>::~wrap_()
 {
-    destroy();
+    this->destroy();
 }
 
 }}} // namespace boost::python::converter

From 8cff66e8c62dd88f5fcdc3cceb4bcccca23cf6e0 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 9 Jan 2002 23:23:44 +0000
Subject: [PATCH 210/369] initial checkin

[SVN r12264]
---
 src/module.cpp | 78 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 src/module.cpp

diff --git a/src/module.cpp b/src/module.cpp
new file mode 100644
index 00000000..9faaca06
--- /dev/null
+++ b/src/module.cpp
@@ -0,0 +1,78 @@
+//  (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.
+
+#include <boost/python/module.hpp>
+#include <boost/python/errors.hpp>
+
+namespace boost { namespace python {
+
+namespace {
+  ref name_holder;
+}
+
+bool module_base::initializing()
+{
+    return name_holder.get() != 0;
+}
+
+string module_base::name()
+{
+    // If this fails, you haven't created a module object
+    assert(initializing());
+    return string(name_holder);
+}
+
+module_base::module_base(const char* name)
+    : m_module(Py_InitModule(const_cast<char*>(name), initial_methods))
+{
+    // If this fails, you've created more than 1 module object in your module    
+    assert(name_holder.get() == 0);
+    name_holder = ref(PyObject_GetAttrString(m_module, const_cast<char*>("__name__")));
+}
+
+module_base::~module_base()
+{
+    name_holder.reset();
+}
+
+void module_base::add(PyObject* x, const char* name)
+{
+    add(ref(x), name);
+}
+
+void module_base::add(ref x, const char* name)
+{
+    ref f(x); // First take possession of the object.
+    if (PyObject_SetAttrString(m_module, const_cast<char*>(name), x.get()) < 0)
+        throw error_already_set();
+}
+
+void module_base::add(PyTypeObject* x, const char* name /*= 0*/)
+{
+    this->add((PyObject*)x, name ? name : x->tp_name);
+}
+
+void module_base::add_overload(objects::function* x, const char* name)
+{
+    PyObject* existing = PyObject_HasAttrString(m_module, const_cast<char*>(name))
+        ? PyObject_GetAttrString(m_module, const_cast<char*>(name))
+        : 0;
+    
+    if (existing != 0 && existing->ob_type == &objects::function_type)
+    {
+        static_cast<objects::function*>(existing)->add_overload(x);
+    }
+    else
+    {
+        add(x, name);
+    }
+}
+
+PyMethodDef module_base::initial_methods[] = { { 0, 0, 0, 0 } };
+
+}} // namespace boost::python

From aeef66ce3504ddeaaa60b677739132f9287a6fcf Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 10 Jan 2002 02:32:47 +0000
Subject: [PATCH 211/369] Handle cv-qualified member functions

[SVN r12265]
---
 .../boost/python/detail/arg_tuple_size.hpp    | 116 ++++++++++++++++++
 src/gen_arg_tuple_size.py                     |  19 ++-
 2 files changed, 133 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/detail/arg_tuple_size.hpp b/include/boost/python/detail/arg_tuple_size.hpp
index e6b6ccc1..a330a939 100644
--- a/include/boost/python/detail/arg_tuple_size.hpp
+++ b/include/boost/python/detail/arg_tuple_size.hpp
@@ -99,6 +99,122 @@ struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5)>
     BOOST_STATIC_CONSTANT(std::size_t, value = 6);
 };
 
+
+// Metrowerks thinks this creates ambiguities
+# if !defined(__MWERKS__) || __MWERKS__ > 0x2406
+
+template <class R, class A0>
+struct arg_tuple_size<R (A0::*)() const>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+};
+
+template <class R, class A0, class A1>
+struct arg_tuple_size<R (A0::*)(A1) const>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
+};
+
+template <class R, class A0, class A1, class A2>
+struct arg_tuple_size<R (A0::*)(A1, A2) const>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
+};
+
+template <class R, class A0, class A1, class A2, class A3>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3) const>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4) const>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5) const>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
+};
+
+
+template <class R, class A0>
+struct arg_tuple_size<R (A0::*)() volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+};
+
+template <class R, class A0, class A1>
+struct arg_tuple_size<R (A0::*)(A1) volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
+};
+
+template <class R, class A0, class A1, class A2>
+struct arg_tuple_size<R (A0::*)(A1, A2) volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
+};
+
+template <class R, class A0, class A1, class A2, class A3>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3) volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4) volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5) volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
+};
+
+
+template <class R, class A0>
+struct arg_tuple_size<R (A0::*)() const volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 1);
+};
+
+template <class R, class A0, class A1>
+struct arg_tuple_size<R (A0::*)(A1) const volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 2);
+};
+
+template <class R, class A0, class A1, class A2>
+struct arg_tuple_size<R (A0::*)(A1, A2) const volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 3);
+};
+
+template <class R, class A0, class A1, class A2, class A3>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3) const volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 4);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4) const volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 5);
+};
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5) const volatile>
+{
+    BOOST_STATIC_CONSTANT(std::size_t, value = 6);
+};
+
+
+# endif // __MWERKS__
 # else
 
 // We will use the "sizeof() trick" to work around the lack of
diff --git a/src/gen_arg_tuple_size.py b/src/gen_arg_tuple_size.py
index 68e379cb..5edd3286 100644
--- a/src/gen_arg_tuple_size.py
+++ b/src/gen_arg_tuple_size.py
@@ -21,6 +21,15 @@ header = '''//  (C) Copyright David Abrahams 2001. Permission to copy, use, modi
 
 _cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
 
+_suffix = {
+    '': '''
+// Metrowerks thinks this creates ambiguities
+# if !defined(__MWERKS__) || __MWERKS__ > 0x2406
+''', ' const volatile': '''
+# endif // __MWERKS__
+'''
+    };
+
 def gen_arg_tuple_size(member_function_args, free_function_args = None):
     if free_function_args is None:
         free_function_args = member_function_args + 1
@@ -53,14 +62,20 @@ struct arg_tuple_size<R (*)(%(A%+%:, %))>
 ''', free_function_args)
 
             + '\n'
-            + gen_functions(
+
+            + reduce(lambda x,y: x+'\n'+y
+                   , map(
+        lambda cv: gen_functions(
 '''template <class R, class A0%(, class A%+%)>
 struct arg_tuple_size<R (A0::*)(%(A%+%:, %))%1>
 {
     BOOST_STATIC_CONSTANT(std::size_t, value = %+);
 };
 
-''', member_function_args, '')
+'''
+        , member_function_args, cv) + _suffix.get(cv, '')
+        , _cv_qualifiers))
+
             +
 '''# else
 

From 98c9e67625052c9c3ee3dea2c3a338da96230e70 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 10 Jan 2002 13:59:14 +0000
Subject: [PATCH 212/369] Fixed mistaken "C" linkage

[SVN r12268]
---
 test/m2.cpp | 67 +++++++++++++++++++++++++----------------------------
 1 file changed, 31 insertions(+), 36 deletions(-)

diff --git a/test/m2.cpp b/test/m2.cpp
index 3c5267d0..7ea1f9ac 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -14,48 +14,43 @@
 using boost::python::wrap;
 using boost::python::unwrap;
 
-extern "C"
+// Get a simple (by value) from the argument, and return the
+// string it holds.
+PyObject* unwrap_simple(simple x)
 {
-    // Get a simple (by value) from the argument, and return the
-    // string it holds.
-    PyObject* unwrap_simple(simple x)
-    {
-        return PyString_FromString(x.s);
-    }
+    return PyString_FromString(x.s);
+}
 
-    // Likewise, but demands that its possible to get a non-const
-    // reference to the simple.
-    PyObject* unwrap_simple_ref(simple& x)
-    {
-        return PyString_FromString(x.s);
-    }
+// Likewise, but demands that its possible to get a non-const
+// reference to the simple.
+PyObject* unwrap_simple_ref(simple& x)
+{
+    return PyString_FromString(x.s);
+}
 
-    // Likewise, with a const reference to the simple object.
-    PyObject* unwrap_simple_const_ref(simple const& x)
-    {
-        return PyString_FromString(x.s);
-    }
+// Likewise, with a const reference to the simple object.
+PyObject* unwrap_simple_const_ref(simple const& x)
+{
+    return PyString_FromString(x.s);
+}
 
-    // Get an int (by value) from the argument, and convert it to a
-    // Python Int.
-    PyObject* unwrap_int(int x)
-    {
-        return PyInt_FromLong(x);
-    }
+// Get an int (by value) from the argument, and convert it to a
+// Python Int.
+PyObject* unwrap_int(int x)
+{
+    return PyInt_FromLong(x);
+}
 
-    // Get a non-const reference to an int from the argument
-    PyObject* unwrap_int_ref(int& x)
-    {
-        return PyInt_FromLong(x);
-    }
+// Get a non-const reference to an int from the argument
+PyObject* unwrap_int_ref(int& x)
+{
+    return PyInt_FromLong(x);
+}
 
-    // Get a const reference to an  int from the argument.
-    PyObject* unwrap_int_const_ref(int const& x)
-    {
-        return PyInt_FromLong(x);
-    }
-
-    // -------------------
+// Get a const reference to an  int from the argument.
+PyObject* unwrap_int_const_ref(int const& x)
+{
+    return PyInt_FromLong(x);
 }
 
 // MSVC6 bug workaround

From 7d1cbcb0c12955e990576384c94f3199c42ef848 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 10 Jan 2002 19:07:18 +0000
Subject: [PATCH 213/369] Possible workaround for cxx 6.2

[SVN r12270]
---
 include/boost/python/object/forward.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/object/forward.hpp b/include/boost/python/object/forward.hpp
index 88eefe6b..149b7330 100644
--- a/include/boost/python/object/forward.hpp
+++ b/include/boost/python/object/forward.hpp
@@ -19,8 +19,12 @@ namespace boost { namespace python { namespace objects {
 template <class T>
 struct forward
 {
+    BOOST_STATIC_CONSTANT(
+        bool, by_value = (is_scalar<T>::value | is_reference<T>::value)
+        );
+
     typedef typename mpl::select_type<
-        is_scalar<T>::value | is_reference<T>::value
+        by_value
         , T
         , reference_wrapper<
                 typename add_const<T>::type

From dd1ac7952b961d9c9c77d1c9d0c251984115c260 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 10 Jan 2002 19:28:16 +0000
Subject: [PATCH 214/369] Modified Files: 
 boost/graph/breadth_first_search.hpp

		MSVC workaround

	boost/python/reference.hpp boost/python/converter/type_id.hpp
	boost/python/converter/unwrap.hpp
	boost/python/converter/wrap.hpp
	boost/python/converter/wrapper.hpp
	boost/python/detail/config.hpp libs/python/Jamfile
	libs/python/src/converter/registry.cpp
	libs/python/src/converter/type_id.cpp
	libs/python/src/converter/unwrap.cpp libs/python/test/m1.cpp
Added Files:
	boost/python/converter/wrapper_base.hpp


		CXX 6.x fixes


[SVN r12271]
---
 Jamfile                                       |   2 +
 include/boost/python/converter/type_id.hpp    | 102 +++++++++++-------
 include/boost/python/converter/unwrap.hpp     |   2 +-
 include/boost/python/converter/wrap.hpp       |   2 +-
 include/boost/python/converter/wrapper.hpp    |  16 +--
 .../boost/python/converter/wrapper_base.hpp   |  28 +++++
 include/boost/python/reference.hpp            |  11 +-
 src/converter/registry.cpp                    |   2 +-
 src/converter/type_id.cpp                     |  36 ++-----
 src/converter/unwrap.cpp                      |   5 +-
 10 files changed, 116 insertions(+), 90 deletions(-)
 create mode 100644 include/boost/python/converter/wrapper_base.hpp

diff --git a/Jamfile b/Jamfile
index 13cb04d7..deb8c690 100644
--- a/Jamfile
+++ b/Jamfile
@@ -8,6 +8,7 @@ PYTHON_PROPERTIES
   += <metrowerks><*><cxxflags>"-inline deferred" 
   <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
     <define>BOOST_PYTHON_DYNAMIC_LIB
+      <define>BOOST_PYTHON_V2
   ;
 
 
@@ -22,6 +23,7 @@ dll bpl
     src/converter/type_id.cpp
     src/object/class.cpp
     src/object/function.cpp
+    # src/object/inheritance.cpp
     src/errors.cpp
     src/module.cpp
     src/objects.cpp
diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
index c383c352..cf3e4a0d 100644
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -32,24 +32,43 @@ namespace detail
 #  define BOOST_PYTHON_TYPE_ID_NAME
 # endif 
 
-# if 1
+// type ids which represent the same information as std::type_info
+// (i.e. the top-level reference and cv-qualifiers are stripped), but
+// which works across shared libraries.
+struct undecorated_type_id_t : totally_ordered<undecorated_type_id_t>
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    typedef char const* base_id_t;
+#  else
+    typedef std::type_info const* base_id_t;
+#  endif
+    
+    undecorated_type_id_t(base_id_t);
+
+    bool operator<(undecorated_type_id_t const& rhs) const;
+    bool operator==(undecorated_type_id_t const& rhs) const;
+    
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(
+        std::ostream&, undecorated_type_id_t const&);
+    
+ private: // data members
+    base_id_t m_base_type;
+};
+
 struct type_id_t : totally_ordered<type_id_t>
 {
     enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
     
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-typedef char const* base_id_t;
-#  else
-typedef std::type_info const* base_id_t;
-#  endif
-    
-    type_id_t(base_id_t, decoration decoration);
+    type_id_t(undecorated_type_id_t, decoration decoration);
 
     bool operator<(type_id_t const& rhs) const;
     bool operator==(type_id_t const& rhs) const;
     friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
     
- private:
+ private: // type
+    typedef undecorated_type_id_t base_id_t;
+    
+ private: // data members
     decoration m_decoration;
     base_id_t m_base_type;
 };
@@ -129,14 +148,22 @@ struct is_reference_to_volatile
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
 
 template <class T>
-inline type_id_t type_id(detail::dummy<T>* = 0)
+inline undecorated_type_id_t undecorated_type_id(detail::dummy<T>* = 0)
 {
-    return type_id_t(
+    return undecorated_type_id_t(
 #  ifdef BOOST_PYTHON_TYPE_ID_NAME
         typeid(T).name()
 #  else
         &typeid(T)
-#  endif 
+#  endif
+        );
+}
+
+template <class T>
+inline type_id_t type_id(detail::dummy<T>* = 0)
+{
+    return type_id_t(
+        undecorated_type_id<T>()
         , type_id_t::decoration(
             (is_const<T>::value || is_reference_to_const<T>::value
              ? type_id_t::const_ : 0)
@@ -147,51 +174,48 @@ inline type_id_t type_id(detail::dummy<T>* = 0)
         );
 }
 
-inline type_id_t::type_id_t(base_id_t base_t, decoration decoration)
+inline undecorated_type_id_t::undecorated_type_id_t(base_id_t base_t)
+    : m_base_type(base_t)
+{
+}
+
+inline type_id_t::type_id_t(undecorated_type_id_t base_t, decoration decoration)
     : m_decoration(decoration)
     , m_base_type(base_t)
 {
 }
 
+inline bool undecorated_type_id_t::operator<(undecorated_type_id_t const& rhs) const
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return std::strcmp(m_base_type, rhs.m_base_type) < 0;
+#  else
+    return m_base_type->before(*rhs.m_base_type);
+#  endif 
+}
+
 inline bool type_id_t::operator<(type_id_t const& rhs) const
 {
     return m_decoration < rhs.m_decoration
         || m_decoration == rhs.m_decoration
+           && m_base_type < rhs.m_base_type;
+}
+
+inline bool undecorated_type_id_t::operator==(undecorated_type_id_t const& rhs) const
+{
 #  ifdef BOOST_PYTHON_TYPE_ID_NAME
-           && std::strcmp(m_base_type, rhs.m_base_type) < 0;
+    return !std::strcmp(m_base_type, rhs.m_base_type);
 #  else
-           && m_base_type->before(*rhs.m_base_type);
+    return *m_base_type == *rhs.m_base_type;
 #  endif 
 }
 
 inline bool type_id_t::operator==(type_id_t const& rhs) const
 {
-    return m_decoration == rhs.m_decoration
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        && !std::strcmp(m_base_type, rhs.m_base_type);
-#  else
-        && *m_base_type == *rhs.m_base_type;
-#  endif 
+    return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
 }
 
-# else 
-// This is the type which is used to identify a type
-typedef char const* type_id_t;
-
-// This is a workaround for a silly MSVC bug
-// Converts a compile-time type to its corresponding runtime identifier.
-template <class T>
-type_id_t type_id(detail::dummy<T>* = 0)
-{
-    return typeid(T).name();
-}
-# endif 
-
-struct BOOST_PYTHON_DECL type_id_before
-{
-    bool operator()(type_id_t const& x, type_id_t const& y) const;
-};
-
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, undecorated_type_id_t const&);
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
index 525f1bb0..3380d49d 100644
--- a/include/boost/python/converter/unwrap.hpp
+++ b/include/boost/python/converter/unwrap.hpp
@@ -89,7 +89,7 @@ struct unwrap_more_<PyObject*>
     {
     }
  private:
-    static BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*> m_unwrapper;
+    static BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*>& m_unwrapper;
 };
 
 template <class T>
diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
index 97d7b8de..eb23c6d3 100644
--- a/include/boost/python/converter/wrap.hpp
+++ b/include/boost/python/converter/wrap.hpp
@@ -11,11 +11,11 @@
 # include <boost/python/converter/wrapper.hpp>
 # include <boost/python/detail/config.hpp>
 # include <boost/python/converter/source_holder.hpp>
+# include <boost/python/converter/wrapper_base.hpp>
 # include <cassert>
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_DECL wrapper_base;
 extern BOOST_PYTHON_DECL body& identity_wrapper;
 
 template <class T> struct wrapper;
diff --git a/include/boost/python/converter/wrapper.hpp b/include/boost/python/converter/wrapper.hpp
index 80afae46..5d4874d2 100644
--- a/include/boost/python/converter/wrapper.hpp
+++ b/include/boost/python/converter/wrapper.hpp
@@ -5,28 +5,14 @@
 // to its suitability for any purpose.
 #ifndef WRAPPER_DWA2001127_HPP
 # define WRAPPER_DWA2001127_HPP
-# include <boost/python/detail/config.hpp>
+# include <boost/python/converter/wrapper_base.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/body.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/wrap.hpp>
 # include <boost/python/converter/source_holder.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-struct source_holder_base;
-struct wrap_base;
-template <class T> struct wrap_more_;
-
-struct BOOST_PYTHON_DECL wrapper_base : body
-{
- public:
-    wrapper_base(type_id_t); // registers
-    ~wrapper_base();         // unregisters
-    
-    virtual PyObject* do_conversion(wrap_base const&, source_holder_base const&) const = 0;
-};
-
 extern BOOST_PYTHON_DECL body& identity_wrapper;
 
 template <class T>
diff --git a/include/boost/python/converter/wrapper_base.hpp b/include/boost/python/converter/wrapper_base.hpp
new file mode 100644
index 00000000..585959ae
--- /dev/null
+++ b/include/boost/python/converter/wrapper_base.hpp
@@ -0,0 +1,28 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef WRAPPER_BASE_DWA2002110_HPP
+# define WRAPPER_BASE_DWA2002110_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/body.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct source_holder_base;
+struct wrap_base;
+template <class T> struct wrap_more_;
+
+struct BOOST_PYTHON_DECL wrapper_base : body
+{
+ public:
+    wrapper_base(type_id_t); // registers
+    ~wrapper_base();         // unregisters
+    
+    virtual PyObject* do_conversion(wrap_base const&, source_holder_base const&) const = 0;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // WRAPPER_BASE_DWA2002110_HPP
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
index 4eb9ad51..b950f01b 100644
--- a/include/boost/python/reference.hpp
+++ b/include/boost/python/reference.hpp
@@ -16,7 +16,9 @@
 # include <cassert>
 # include <boost/python/detail/signatures.hpp>
 # include <boost/python/errors.hpp>
-# include <boost/python/conversions.hpp>
+
+# ifndef BOOST_PYTHON_V2
+#  include <boost/python/conversions.hpp>
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
@@ -35,14 +37,19 @@ struct py_ptr_conversions : Base
 };
 
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
+# endif
 
 namespace boost { namespace python {
 
+# ifndef BOOST_PYTHON_V2
 BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
+# endif 
 
 template <class T>
 class reference
+# ifndef BOOST_PYTHON_V2
     : public py_ptr_conversions<reference<T>, T>
+# endif 
 {
 public:
     typedef T value_type;
@@ -165,11 +172,13 @@ private:
 
 typedef reference<PyObject> ref;
 
+#ifndef BOOST_PYTHON_V2
 template <class T>
 ref make_ref(const T& x)
 {
     return ref(to_python(x));
 }
+#endif 
 
 }} // namespace boost::python
 
diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
index d247353c..4ce9e709 100644
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -18,7 +18,7 @@ namespace boost { namespace python { namespace converter {
 
 namespace // <unnamed>
 {
-  typedef std::map<type_id_t, registry::entry, type_id_before> registry_t;
+  typedef std::map<type_id_t, registry::entry> registry_t;
   
   registry_t& entries()
   {
diff --git a/src/converter/type_id.cpp b/src/converter/type_id.cpp
index fc2db66a..421cc5cf 100644
--- a/src/converter/type_id.cpp
+++ b/src/converter/type_id.cpp
@@ -13,19 +13,18 @@
 
 namespace boost { namespace python { namespace converter { 
 
-#if 1
-bool type_id_before::operator()(type_id_t const& x, type_id_t const&  y) const
+BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, undecorated_type_id_t const& x)
 {
-    return x < y;
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return os << x.m_base_type;
+#  else
+    return os << x.m_base_type->name();
+#  endif 
 }
 
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, type_id_t const& x)
 {
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
     os << x.m_base_type;
-#  else
-    os << x.m_base_type->name();
-#  endif 
     // VC6 mistakenly distinguishes typeid(X) from typeid(X const)
     // from typeid(X&)...  so the name is already correct. I have it
     // from Jason Shirk that VC7.0 has the same bug but it will be
@@ -41,27 +40,4 @@ BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, type_id_t const& x)
     return os;
 }
 
-#else 
-bool type_id_before::operator()(type_id_t const& x, type_id_t const&  y) const
-{
-    for (;;)
-    {
-        if (*y == 0)
-        {
-            return 0;
-        }
-        else if (*x == 0)
-        {
-            return 1;
-        }
-        else if (*x != *y)
-        {
-            return *x < *y;
-        }
-        ++x;
-        ++y;
-    }
-}
-#endif
-
 }}} // namespace boost::python::converter
diff --git a/src/converter/unwrap.cpp b/src/converter/unwrap.cpp
index 33a7d7ae..6a72ab77 100644
--- a/src/converter/unwrap.cpp
+++ b/src/converter/unwrap.cpp
@@ -17,6 +17,7 @@ namespace
   };
   
   pyobject_unwrapper static_unwrapper;
+  std::pair<unwrapper_base*,void*> unwrapper_pair(&static_unwrapper,&static_unwrapper);  
 
   pyobject_unwrapper::pyobject_unwrapper()
       : unwrapper_base(type_id<PyObject*>())
@@ -29,7 +30,7 @@ namespace
   }
 }
 
-BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*>
-unwrap_more_<PyObject*>::m_unwrapper(&static_unwrapper,&static_unwrapper);
+BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*>&
+unwrap_more_<PyObject*>::m_unwrapper = unwrapper_pair;
 
 }}} // namespace boost::python::converter

From 0964ecac8c88b9fd9464b08ad651909ff7b8c52c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 10 Jan 2002 20:10:32 +0000
Subject: [PATCH 215/369] cxx fixes

[SVN r12272]
---
 include/boost/python/detail/cast.hpp |  7 +++++--
 include/boost/python/reference.hpp   | 11 ++++++++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/include/boost/python/detail/cast.hpp b/include/boost/python/detail/cast.hpp
index 67fe7b34..367f1f14 100644
--- a/include/boost/python/detail/cast.hpp
+++ b/include/boost/python/detail/cast.hpp
@@ -9,8 +9,9 @@
 #ifndef CAST_DWA052500_H_
 # define CAST_DWA052500_H_
 
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/operators.hpp>
+# ifndef BOOST_PYTHON_V2
+#  include <boost/python/detail/wrap_python.hpp>
+#  include <boost/operators.hpp>
 
 namespace boost { namespace python {
 
@@ -75,4 +76,6 @@ struct downcast
 
 }} // namespace boost::python
 
+# endif // BOOST_PYTHON_V2
+
 #endif // CAST_DWA052500_H_
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
index b950f01b..e081e07c 100644
--- a/include/boost/python/reference.hpp
+++ b/include/boost/python/reference.hpp
@@ -14,8 +14,10 @@
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/cast.hpp>
 # include <cassert>
+# include <cstddef>
 # include <boost/python/detail/signatures.hpp>
 # include <boost/python/errors.hpp>
+# include <boost/python/detail/cast.hpp>
 
 # ifndef BOOST_PYTHON_V2
 #  include <boost/python/conversions.hpp>
@@ -165,7 +167,14 @@ private:
 #endif
 
     inline PyObject* object() const
-        { return as_object(m_p); }
+        {
+#ifdef BOOST_PYTHON_V2
+            return (PyObject*)(
+                (char*)&m_p->ob_type - offsetof(PyObject,ob_type));
+#else 
+            return as_object(m_p);
+#endif 
+        }
 
     T* m_p;
 };

From b796db648ae317ea008ffe4ee5b4421ccf156035 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 14 Jan 2002 21:28:49 +0000
Subject: [PATCH 216/369] added default constructor for use with BGL

[SVN r12318]
---
 include/boost/python/converter/type_id.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
index cf3e4a0d..2c0c1a26 100644
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -44,6 +44,9 @@ struct undecorated_type_id_t : totally_ordered<undecorated_type_id_t>
 #  endif
     
     undecorated_type_id_t(base_id_t);
+    
+    // default constructor for use in BGL graph internal properties
+    undecorated_type_id_t() {} 
 
     bool operator<(undecorated_type_id_t const& rhs) const;
     bool operator==(undecorated_type_id_t const& rhs) const;

From 7926e1bc3cfd28fe4a121926835c4343e09b207d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 03:08:08 +0000
Subject: [PATCH 217/369] Fixes for reference parameters to constructors

[SVN r12364]
---
 .../boost/python/detail/extension_class.hpp   |  77 +++++++++--
 include/boost/python/detail/init_function.hpp |  52 +++++++-
 include/boost/python/reference.hpp            | 117 ++++++++++++-----
 src/gen_extclass.py                           | 122 ++++++++++++------
 src/gen_init_function.py                      |  52 +++++++-
 5 files changed, 328 insertions(+), 92 deletions(-)

diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 05ebe229..638217d1 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -1,4 +1,4 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
@@ -727,25 +727,80 @@ class held_instance : public Held
 public:
     held_instance(PyObject*) : Held() {}
     template <class A1>
-    held_instance(PyObject*, A1 a1) : Held(a1) {}
+    held_instance(PyObject*, A1 a1) : Held(
+        typename unwrap_parameter<A1>::type(a1)) {}
     template <class A1, class A2>
-    held_instance(PyObject*, A1 a1, A2 a2) : Held(a1, a2) {}
+    held_instance(PyObject*, A1 a1, A2 a2) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)) {}
     template <class A1, class A2, class A3>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : Held(a1, a2, a3) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)) {}
     template <class A1, class A2, class A3, class A4>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : Held(a1, a2, a3, a4) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(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) : Held(a1, a2, a3, a4, a5) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(a4)
+        , typename unwrap_parameter<A5>::type(a5)) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : Held(a1, a2, a3, a4, a5, a6) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(a4)
+        , typename unwrap_parameter<A5>::type(a5)
+        , typename unwrap_parameter<A6>::type(a6)) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : Held(a1, a2, a3, a4, a5, a6, a7) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(a4)
+        , typename unwrap_parameter<A5>::type(a5)
+        , typename unwrap_parameter<A6>::type(a6)
+        , typename unwrap_parameter<A7>::type(a7)) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : Held(a1, a2, a3, a4, a5, a6, a7, a8) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(a4)
+        , typename unwrap_parameter<A5>::type(a5)
+        , typename unwrap_parameter<A6>::type(a6)
+        , typename unwrap_parameter<A7>::type(a7)
+        , typename unwrap_parameter<A8>::type(a8)) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : Held(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(a4)
+        , typename unwrap_parameter<A5>::type(a5)
+        , typename unwrap_parameter<A6>::type(a6)
+        , typename unwrap_parameter<A7>::type(a7)
+        , typename unwrap_parameter<A8>::type(a8)
+        , typename unwrap_parameter<A9>::type(a9)) {}
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : Held(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
+    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : Held(
+        typename unwrap_parameter<A1>::type(a1)
+        , typename unwrap_parameter<A2>::type(a2)
+        , typename unwrap_parameter<A3>::type(a3)
+        , typename unwrap_parameter<A4>::type(a4)
+        , typename unwrap_parameter<A5>::type(a5)
+        , typename unwrap_parameter<A6>::type(a6)
+        , typename unwrap_parameter<A7>::type(a7)
+        , typename unwrap_parameter<A8>::type(a8)
+        , typename unwrap_parameter<A9>::type(a9)
+        , typename unwrap_parameter<A10>::type(a10)) {}
 };
 
 // Abstract base class for all obj holders. Base for template class
diff --git a/include/boost/python/detail/init_function.hpp b/include/boost/python/detail/init_function.hpp
index 69df703d..ed34f9be 100644
--- a/include/boost/python/detail/init_function.hpp
+++ b/include/boost/python/detail/init_function.hpp
@@ -1,4 +1,4 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
+//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
@@ -89,11 +89,14 @@ namespace detail {
       typedef void const_reference;
   };
 
+  struct reference_parameter_base {};
+
   template <class T>
   class reference_parameter
+      : public reference_parameter_base
   {
-      typedef typename parameter_traits<T>::const_reference const_reference;
    public:
+      typedef typename parameter_traits<T>::const_reference const_reference;
       reference_parameter(const_reference value)
           : value(value) {}
       operator const_reference() { return value; }
@@ -101,6 +104,51 @@ namespace detail {
       const_reference value;
   };
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  template <class T>
+  struct unwrap_parameter
+  {
+      typedef typename boost::add_reference<T>::type type;
+  };
+
+  template <class T>
+  struct unwrap_parameter<reference_parameter<T> >
+  {
+      typedef typename reference_parameter<T>::const_reference type;
+  };
+# else
+  template <bool is_wrapped>
+  struct unwrap_parameter_helper
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::const_reference type;
+      };
+  };
+
+  template <>
+  struct unwrap_parameter_helper<false>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename add_reference<T>::type type;
+      };
+  };
+
+  template <class T>
+  struct unwrap_parameter
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, is_wrapped = (is_base_and_derived<T,reference_parameter_base>::value));
+      
+      typedef typename unwrap_parameter_helper<
+          is_wrapped
+      >::template apply<T>::type type;
+  };
+# endif 
+  
 class extension_instance;
 class instance_holder_base;
 
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
index e081e07c..f0cdab55 100644
--- a/include/boost/python/reference.hpp
+++ b/include/boost/python/reference.hpp
@@ -59,18 +59,10 @@ public:
     reference(const reference& rhs)
         : m_p(rhs.m_p)
     {
-        Py_XINCREF(object());
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(m_p);
     }
 
-#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
@@ -81,85 +73,140 @@ public:
     
     template <class T2>
     explicit reference(T2* x)
-        : m_p(expect_non_null(x)) {}
+        : m_p(expect_non_null(x))
+    {
+        assert(m_p->ob_refcnt > 0);
+    }
 
     template <class T2>
     reference(T2* x, increment_count_t)
-        : m_p(expect_non_null(x)) { Py_INCREF(object()); }
+        : m_p(expect_non_null(x))
+    {
+        assert(m_p->ob_refcnt > 0);
+        Py_INCREF(m_p);
+    }
     
     template <class T2>
     reference(T2* x, allow_null)
-        : m_p(x) {}
+        : m_p(x)
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+    }
 
     template <class T2>
     reference(T2* x, allow_null, increment_count_t)
-        : m_p(x) { Py_XINCREF(object()); }
+        : m_p(x)
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(m_p);
+    }
     
     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)
+        : m_p(x)
     {
-        Py_XDECREF(object());
-        m_p = rhs.m_p;
-        Py_XINCREF(object());
-        return *this;
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(m_p);
     }
-#endif
-
+    
     reference& operator=(const reference& rhs)
     {
+        assert(rhs.m_p == 0 || rhs.m_p->ob_refcnt > 0);
         Py_XINCREF(static_cast<PyObject*>(rhs.m_p));
-        Py_XDECREF(object());
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
         m_p = rhs.m_p;
         return *this;
     }
     
     ~reference()
     {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
         Py_XDECREF(m_p);
     }
     
-    T& operator*() const { return *m_p; }
+    T& operator*() const
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        return *m_p;
+    }
     
     // MSVC doesn't like boost::dereferencable unless T has a default
     // constructor, so operator-> must be defined by hand :(
-    T* operator->() const { return &**this; } 
+    T* operator->() const
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        return &**this;
+    } 
     
-    T* get() const { return m_p; }
+    T* get() const
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        return m_p;
+    }
 
     T* release()
     {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
         T* p = m_p;
         m_p = 0;
         return p;
     }
 
     void reset()
-        { Py_XDECREF(m_p); m_p = 0; }
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
+        m_p = 0;
+    }
     
     template <class T2>
     void reset(T2* x)
-        { Py_XDECREF(m_p); m_p = expect_non_null(x);}
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
+        m_p = expect_non_null(x);
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+    }
 
     template <class T2>
     void reset(T2* x, increment_count_t)
-        { Py_XDECREF(m_p); m_p = expect_non_null(x); Py_INCREF(object()); }
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
+        m_p = expect_non_null(x);
+        assert(m_p->ob_refcnt > 0);
+        Py_INCREF(m_p);
+    }
     
     template <class T2>
     void reset(T2* x, allow_null)
-        { Py_XDECREF(m_p); m_p = x;}
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
+        m_p = x;
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+    }
 
     template <class T2>
     void reset(T2* x, allow_null, increment_count_t)
-        { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
+        m_p = x;
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(m_p);
+    }
     
     template <class T2>
     void reset(T2* x, increment_count_t, allow_null)
-        { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
+    {
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XDECREF(m_p);
+        m_p = x;
+        assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(m_p);
+    }
     
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
 private:
diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index b794dc2c..6316bab9 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -3,7 +3,7 @@ import string
 
 def gen_extclass(args):
     return (
-"""//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
+"""//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
@@ -43,26 +43,51 @@ template <class T> struct right_operand;
 
 enum without_downcast_t { without_downcast };
 
-namespace detail {
+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;
+  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&);
+  class BOOST_PYTHON_DECL 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;
+  };
+
+} // namespace detail
+
+# ifndef BOOST_PYTHON_NO_TEMPLATE_EXPORT
+BOOST_PYTHON_EXPORT_TEMPLATE_CLASS class_t<detail::extension_instance>;
+BOOST_PYTHON_EXPORT_TEMPLATE_CLASS meta_class<detail::extension_instance>;
+# endif 
+
+namespace detail {
+
+BOOST_PYTHON_DECL meta_class<extension_instance>* extension_meta_class();
+BOOST_PYTHON_DECL extension_instance* get_extension_instance(PyObject* p);
+BOOST_PYTHON_DECL void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
+BOOST_PYTHON_DECL void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
+BOOST_PYTHON_DECL void report_missing_class_object(const std::type_info&);
+BOOST_PYTHON_DECL void report_released_smart_pointer(const std::type_info&);
     
 template <class T>
 T* check_non_null(T* p)
@@ -76,7 +101,7 @@ template <class Held> class held_instance;
 
 typedef void* (*conversion_function_ptr)(void*);
 
-struct base_class_info
+struct BOOST_PYTHON_DECL base_class_info
 {
     base_class_info(extension_class_base* t, conversion_function_ptr f)
         :class_object(t), convert(f)
@@ -90,7 +115,7 @@ typedef base_class_info derived_class_info;
 
 struct add_operator_base;
 
-class extension_class_base : public class_t<extension_instance>
+class BOOST_PYTHON_DECL extension_class_base : public class_t<extension_instance>
 {
  public:
     extension_class_base(const char* name);
@@ -270,8 +295,7 @@ class python_extension_class_converters
         boost::python::detail::report_missing_ptr_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
         throw boost::python::argument_error();
 #if defined(__MWERKS__) && __MWERKS__ <= 0x2406
-        PtrType x;
-        return x;
+        return *(PtrType*)0;
 #endif
     }
 
@@ -384,7 +408,7 @@ namespace detail {
 
 template <class T> class instance_holder;
 
-class read_only_setattr_function : public function
+class BOOST_PYTHON_DECL read_only_setattr_function : public function
 {
  public:
     read_only_setattr_function(const char* name);
@@ -703,13 +727,15 @@ class held_instance : public Held
 public:"""
         + gen_functions("""%{
     template <%(class A%n%:, %)>%}
-    held_instance(PyObject*%(, A%n% a%n%)) : Held(%(a%n%:, %)) {}""", args)
+    held_instance(PyObject*%(, A%n% a%n%)) : Held(
+        %(typename unwrap_parameter<A%n>::type(a%n)%:
+        , %)) {}""", args)
         + """
 };
 
 // Abstract base class for all obj holders. Base for template class
 // instance_holder<>, below.
-class instance_holder_base
+class BOOST_PYTHON_DECL instance_holder_base
 {
 public:
     virtual ~instance_holder_base() {}
@@ -738,12 +764,39 @@ class instance_value_holder : public instance_holder<Held>
 public:
     Held* target() { return &m_held; }
     Wrapper* value_target() { return &m_held; }
-"""
-        + gen_functions("""%{
-    template <%(class A%n%:, %)>%}
-    instance_value_holder(extension_instance* p%(, A%n a%n%)) :
-        m_held(p%(, a%n%)) {}""", args)
-        + """
+
+    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) {}
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
+        m_held(p, a1, a2, a3, a4, a5, a6) {}
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
+        m_held(p, a1, a2, a3, a4, a5, a6, a7) {}
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :
+        m_held(p, 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>
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :
+        m_held(p, 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>
+    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :
+        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
 
  public: // implementation of instance_holder_base required interface
     bool held_by_value() { return true; }
@@ -770,21 +823,6 @@ class instance_ptr_holder : public instance_holder<HeldType>
     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
 //
diff --git a/src/gen_init_function.py b/src/gen_init_function.py
index 80a9c199..ff294dbb 100644
--- a/src/gen_init_function.py
+++ b/src/gen_init_function.py
@@ -4,7 +4,7 @@ import string
 def gen_init_function(args):
 
     return (
-"""//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
+"""//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
 //  distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
@@ -95,11 +95,14 @@ namespace detail {
       typedef void const_reference;
   };
 
+  struct reference_parameter_base {};
+
   template <class T>
   class reference_parameter
+      : public reference_parameter_base
   {
-      typedef typename parameter_traits<T>::const_reference const_reference;
    public:
+      typedef typename parameter_traits<T>::const_reference const_reference;
       reference_parameter(const_reference value)
           : value(value) {}
       operator const_reference() { return value; }
@@ -107,6 +110,51 @@ namespace detail {
       const_reference value;
   };
 
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  template <class T>
+  struct unwrap_parameter
+  {
+      typedef typename boost::add_reference<T>::type type;
+  };
+
+  template <class T>
+  struct unwrap_parameter<reference_parameter<T> >
+  {
+      typedef typename reference_parameter<T>::const_reference type;
+  };
+# else
+  template <bool is_wrapped>
+  struct unwrap_parameter_helper
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::const_reference type;
+      };
+  };
+
+  template <>
+  struct unwrap_parameter_helper<false>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename add_reference<T>::type type;
+      };
+  };
+
+  template <class T>
+  struct unwrap_parameter
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, is_wrapped = (is_base_and_derived<T,reference_parameter_base>::value));
+      
+      typedef typename unwrap_parameter_helper<
+          is_wrapped
+      >::template apply<T>::type type;
+  };
+# endif 
+  
 class extension_instance;
 class instance_holder_base;
 

From c3a311ab85a7f6612885459cf8eadbeebc561372 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:07:05 +0000
Subject: [PATCH 218/369] Explicit qualifications help MSVC6

[SVN r12380]
---
 include/boost/python/make_function.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index fddc640b..f9ffd5c3 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -6,13 +6,13 @@
 #ifndef MAKE_FUNCTION_DWA20011221_HPP
 # define MAKE_FUNCTION_DWA20011221_HPP
 
-# include <boost/mpl/size.hpp>
-# include <boost/function.hpp>
-# include <boost/bind.hpp>
 # include <boost/python/object/function.hpp>
 # include <boost/python/object/make_holder.hpp>
 # include <boost/python/detail/caller.hpp>
 # include <boost/python/detail/arg_tuple_size.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/function.hpp>
+# include <boost/bind.hpp>
 
 namespace boost { namespace python {
 
@@ -21,7 +21,7 @@ objects::function* make_function(F f)
 {
     return new objects::function(
         objects::py_function(
-            bind<PyObject*>(detail::caller(), f, _1, _2))
+            ::boost::bind<PyObject*>(detail::caller(), f, _1, _2))
         , detail::arg_tuple_size<F>::value);
 }
 
@@ -31,7 +31,7 @@ objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
     enum { nargs = mpl::size<ArgList>::value };
     return new objects::function(
         objects::py_function(
-            bind<PyObject*>(detail::caller(),
+            ::boost::bind<PyObject*>(detail::caller(),
                  objects::make_holder<nargs>
                             ::template apply<T,Generator,ArgList>::execute
                  , _1, _2))

From a48f252cfaa9d2d15881ee3de7c199616093965e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:41:56 +0000
Subject: [PATCH 219/369] Moved add_overload functionality to
 function::add_to_namespace

[SVN r12381]
---
 include/boost/python/module.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index b257b9ff..317cc5e4 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -11,6 +11,7 @@
 # include <boost/python/reference.hpp>
 # include <boost/python/make_function.hpp>
 # include <boost/python/objects.hpp>
+# include <boost/python/detail/wrap_python.hpp>
 
 namespace boost { namespace python {
 
@@ -25,7 +26,6 @@ class BOOST_PYTHON_DECL module_base
     void add(PyObject* x, const char* name);
     void add(PyTypeObject* x, const char* name = 0);
     void add(ref x, const char*name);
-    void add_overload(objects::function* x, const char* name);
 
     // Return true iff a module is currently being built.
     static bool initializing();
@@ -58,7 +58,7 @@ class module : public module_base
     template <class Fn>
     void def(Fn fn, const char* name)
     {
-        add_overload(make_function(fn), name);
+        this->add(boost::python::make_function(fn), name);
     }
 };
 

From 386992c3b8ad845a0790348a987f6c8321560d3d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:43:36 +0000
Subject: [PATCH 220/369] suppress gcc warning

[SVN r12382]
---
 include/boost/python/converter/class.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
index 458ecee4..f437a73a 100644
--- a/include/boost/python/converter/class.hpp
+++ b/include/boost/python/converter/class.hpp
@@ -18,6 +18,10 @@ struct class_unwrapper
     , private unwrapper<T*>
     , private unwrapper<T const*>
 {
+ protected:
+# ifdef __GNUC__ // suppress warning that "all member functions are private" (duh)
+    void uncallable();
+# endif 
  private:
     void* can_convert(PyObject*) const;
     T& convert(PyObject*, void*, boost::type<T&>) const;

From 3d03ca3d10268ddf08b87a49770b712de2bb7e91 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:50:52 +0000
Subject: [PATCH 221/369] made it possible to initialize from type_info

[SVN r12383]
---
 include/boost/python/converter/type_id.hpp | 67 +++++++++++++++-------
 src/converter/type_id.cpp                  |  6 +-
 2 files changed, 46 insertions(+), 27 deletions(-)

diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
index 2c0c1a26..fd731f83 100644
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -37,24 +37,25 @@ namespace detail
 // which works across shared libraries.
 struct undecorated_type_id_t : totally_ordered<undecorated_type_id_t>
 {
+    undecorated_type_id_t(std::type_info const&);
+    
+    // default constructor needed to build arrays, etc.
+    undecorated_type_id_t();
+
+    bool operator<(undecorated_type_id_t const& rhs) const;
+    bool operator==(undecorated_type_id_t const& rhs) const;
+
+    char const* name() const;
+    friend BOOST_PYTHON_DECL std::ostream& operator<<(
+        std::ostream&, undecorated_type_id_t const&);
+    
+ private: // data members
 #  ifdef BOOST_PYTHON_TYPE_ID_NAME
     typedef char const* base_id_t;
 #  else
     typedef std::type_info const* base_id_t;
 #  endif
     
-    undecorated_type_id_t(base_id_t);
-    
-    // default constructor for use in BGL graph internal properties
-    undecorated_type_id_t() {} 
-
-    bool operator<(undecorated_type_id_t const& rhs) const;
-    bool operator==(undecorated_type_id_t const& rhs) const;
-    
-    friend BOOST_PYTHON_DECL std::ostream& operator<<(
-        std::ostream&, undecorated_type_id_t const&);
-    
- private: // data members
     base_id_t m_base_type;
 };
 
@@ -66,8 +67,10 @@ struct type_id_t : totally_ordered<type_id_t>
 
     bool operator<(type_id_t const& rhs) const;
     bool operator==(type_id_t const& rhs) const;
+
     friend BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
-    
+
+    operator undecorated_type_id_t const&() const;
  private: // type
     typedef undecorated_type_id_t base_id_t;
     
@@ -153,13 +156,7 @@ struct is_reference_to_volatile
 template <class T>
 inline undecorated_type_id_t undecorated_type_id(detail::dummy<T>* = 0)
 {
-    return undecorated_type_id_t(
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-        typeid(T).name()
-#  else
-        &typeid(T)
-#  endif
-        );
+    return undecorated_type_id_t(typeid(T));
 }
 
 template <class T>
@@ -177,8 +174,19 @@ inline type_id_t type_id(detail::dummy<T>* = 0)
         );
 }
 
-inline undecorated_type_id_t::undecorated_type_id_t(base_id_t base_t)
-    : m_base_type(base_t)
+inline undecorated_type_id_t::undecorated_type_id_t(std::type_info const& id)
+    : m_base_type(
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+        id.name()
+#  else
+        &id
+#  endif
+        )
+{
+}
+
+inline undecorated_type_id_t::undecorated_type_id_t()
+    : m_base_type()
 {
 }
 
@@ -218,6 +226,21 @@ inline bool type_id_t::operator==(type_id_t const& rhs) const
     return m_decoration == rhs.m_decoration && m_base_type == rhs.m_base_type;
 }
 
+inline type_id_t::operator undecorated_type_id_t const&() const
+{
+    return m_base_type;
+}
+
+inline char const* undecorated_type_id_t::name() const
+{
+#  ifdef BOOST_PYTHON_TYPE_ID_NAME
+    return m_base_type;
+#  else
+    return m_base_type->name();
+#  endif 
+}
+
+
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, undecorated_type_id_t const&);
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream&, type_id_t const&);
 
diff --git a/src/converter/type_id.cpp b/src/converter/type_id.cpp
index 421cc5cf..688dd2bc 100644
--- a/src/converter/type_id.cpp
+++ b/src/converter/type_id.cpp
@@ -15,11 +15,7 @@ namespace boost { namespace python { namespace converter {
 
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, undecorated_type_id_t const& x)
 {
-#  ifdef BOOST_PYTHON_TYPE_ID_NAME
-    return os << x.m_base_type;
-#  else
-    return os << x.m_base_type->name();
-#  endif 
+    return os << x.name();
 }
 
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, type_id_t const& x)

From dabb22bb6aaa636bc245c747447eaccf4249feaf Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:52:36 +0000
Subject: [PATCH 222/369] added class wrapping

[SVN r12384]
---
 include/boost/python/object/class.hpp         |  38 +++++-
 .../boost/python/object/class_unwrapper.hpp   |   8 +-
 include/boost/python/object/function.hpp      |   8 +-
 include/boost/python/object/value_holder.hpp  |   8 +-
 src/object/class.cpp                          | 118 +++++++++++++++---
 5 files changed, 150 insertions(+), 30 deletions(-)

diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index bc8f40d1..808e3669 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -6,16 +6,44 @@
 #ifndef CLASS_DWA20011214_HPP
 # define CLASS_DWA20011214_HPP
 
+# include <boost/python/module.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/config.hpp>
 # include <boost/utility.hpp>
 # include <boost/python/converter/type_id.hpp>
+# include <boost/python/reference.hpp>
 # include <boost/iterator_adaptors.hpp>
+# include <cstddef>
 
-namespace boost { namespace python { namespace objects { 
+namespace boost { namespace python {
+
+class module;
+
+namespace objects { 
 
 template <class T> struct holder;
 
+// To identify a class, we don't need cv/reference decorations
+typedef converter::undecorated_type_id_t class_id;
+
+struct BOOST_PYTHON_DECL class_base : noncopyable
+{
+    // constructor
+    class_base(
+        module& name_space              // Which name space the class will live in
+        , char const* name              // The name of the class
+        
+        , std::size_t num_types         // A list of class_ids. The first is the type
+        , class_id const*const types    // this is wrapping. The rest are the types of
+                                        // any bases.
+        );
+
+    // Retrieve a pointer to the underlying object
+    PyObject* object() const { return m_object.get(); }
+ private:
+    ref m_object;
+};
+
 // Base class for all holders
 struct BOOST_PYTHON_DECL instance_holder : noncopyable
 {
@@ -28,7 +56,7 @@ struct BOOST_PYTHON_DECL instance_holder : noncopyable
 
     virtual void* holds(converter::type_id_t) = 0;
 
-    void install(PyObject* inst);
+    void install(PyObject* inst) throw();
     
     struct iterator_policies : default_iterator_policies
     {
@@ -58,6 +86,8 @@ struct instance
     instance_holder* objects;
 };
 
+// Given a type_id, find the instance data which corresponds to it, or
+// return 0 in case no such type is held.
 BOOST_PYTHON_DECL void* find_instance_impl(PyObject*, converter::type_id_t);
 
 template <class T>
@@ -66,8 +96,8 @@ T* find_instance(PyObject* p, T* = 0)
     return static_cast<T*>(find_instance_impl(p, converter::type_id<T>()));
 }
 
-BOOST_PYTHON_DECL PyTypeObject* class_metatype();
-BOOST_PYTHON_DECL PyTypeObject* class_type();
+BOOST_PYTHON_DECL ref class_metatype();
+BOOST_PYTHON_DECL ref class_type();
 
 //
 // implementation
diff --git a/include/boost/python/object/class_unwrapper.hpp b/include/boost/python/object/class_unwrapper.hpp
index 666c6e93..0877ff24 100644
--- a/include/boost/python/object/class_unwrapper.hpp
+++ b/include/boost/python/object/class_unwrapper.hpp
@@ -18,14 +18,14 @@ struct class_unwrapper
     template <class Target>
     struct reference_unwrapper : converter::unwrapper<Target>
     {
-        bool convertible(PyObject* p) const
+        void* can_convert(PyObject* p) const
         {
-            return find_holder<T>(p) != 0;
+            return find_instance<T>(p);
         }
         
-        Target convert(PyObject* p, void*&) const
+        Target convert(PyObject* p, void* data, ) const
         {
-            return *find_holder<T>(p)->target();
+            return *find_instance<T>(p)->target();
         }
     };
     
diff --git a/include/boost/python/object/function.hpp b/include/boost/python/object/function.hpp
index ed7dd319..cc2695d8 100644
--- a/include/boost/python/object/function.hpp
+++ b/include/boost/python/object/function.hpp
@@ -22,10 +22,16 @@ struct BOOST_PYTHON_DECL function : PyObject
     ~function();
     
     PyObject* call(PyObject*, PyObject*) const;
-    void add_overload(function* overload);
+
+    // Add an attributeto the name_space with the given name. If it is
+    // a function object (this class), and an existing function is
+    // already there, add it as an overload.
+    static void add_to_namespace(
+        PyObject* name_space, char const* name, PyObject* attribute);
     
  private: // helper functions
     void argument_error(PyObject* args, PyObject* keywords) const;
+    void add_overload(function* overload);
     
  private: // data members
     py_function m_fn;
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index be7247da..d6e38a79 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -8,6 +8,8 @@
 
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
+# include <boost/python/object/inheritance.hpp>
+# include <boost/ref.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -76,9 +78,11 @@ struct value_holder_generator
 };
 
 template <class Held>
-void* value_holder<Held>::holds(converter::type_id_t x)
+void* value_holder<Held>::holds(converter::type_id_t dst_t)
 {
-    return x == converter::type_id<Held>() ? &m_held : 0;
+    converter::type_id_t src_t = converter::type_id<Held>();
+    return src_t == dst_t ? &m_held
+        : find_static_type(&m_held, src_t, dst_t);
 }
 
 }}} // namespace boost::python::objects
diff --git a/src/object/class.cpp b/src/object/class.cpp
index 8e85f38b..5ebabba1 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -6,8 +6,14 @@
 #include <boost/python/detail/config.hpp>
 #include <boost/python/detail/wrap_python.hpp>
 #include <boost/python/object/class.hpp>
+#include <boost/python/object/class_wrapper.hpp>
+#include <boost/python/objects.hpp>
+#include <boost/python/detail/map_entry.hpp>
+#include <boost/detail/binary_search.hpp>
 #include <boost/bind.hpp>
+#include <boost/python/detail/wrap_python.hpp>
 #include <functional>
+#include <vector>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -64,6 +70,20 @@ PyTypeObject class_metatype_object = {
         // PyType_GenericNew                       /* tp_new */
 };
 
+// Get the metatype object for all extension classes.
+BOOST_PYTHON_DECL ref class_metatype()
+{
+    if (class_metatype_object.tp_dict == 0)
+    {
+        class_metatype_object.ob_type = &PyType_Type;
+        class_metatype_object.tp_base = &PyType_Type;
+        if (PyType_Ready(&class_metatype_object))
+            return ref();
+    }
+    return ref((PyObject*)&class_metatype_object, ref::increment_count);
+}
+
+// Do we really need this? I'm beginning to think we don't!
 PyTypeObject class_type_object = {
     PyObject_HEAD_INIT(0) //&class_metatype_object)
         0,
@@ -107,33 +127,21 @@ PyTypeObject class_type_object = {
         PyType_GenericNew
 };
 
-BOOST_PYTHON_DECL PyTypeObject* class_metatype()
-{
-    if (class_metatype_object.tp_dict == 0)
-    {
-        class_metatype_object.ob_type = &PyType_Type;
-        class_metatype_object.tp_base = &PyType_Type;
-        if (PyType_Ready(&class_metatype_object))
-            return 0;
-    }
-    Py_INCREF(&class_metatype_object);
-    return &class_metatype_object;
-}
-
-BOOST_PYTHON_DECL PyTypeObject* class_type()
+BOOST_PYTHON_DECL ref class_type()
 {
     if (class_type_object.tp_dict == 0)
     {
-        class_type_object.ob_type = class_metatype();
+        class_type_object.ob_type = (PyTypeObject*)class_metatype().release();
         class_type_object.tp_base = &PyBaseObject_Type;
         if (PyType_Ready(&class_type_object))
-            return 0;
+            return ref();
     }
-    Py_INCREF(&class_type_object);
-    return &class_type_object;
+    return ref((PyObject*)&class_type_object, ref::increment_count);
 }
 
-void instance_holder::install(PyObject* self)
+// Install the instance data for a C++ object into a Python instance
+// object.
+void instance_holder::install(PyObject* self) throw()
 {
     assert(self->ob_type->ob_type == &class_metatype_object);
     m_next = ((instance*)self)->objects;
@@ -157,4 +165,76 @@ find_instance_impl(PyObject* inst, converter::type_id_t type)
     return 0;
 }
 
+namespace
+{
+  struct class_registry
+  {
+   public:
+      ref get(class_id id) const;
+      void set(class_id, ref class_object);
+   private:
+      typedef detail::map_entry<class_id,ref> entry;
+      std::vector<entry> m_impl;
+  };
+
+  class_registry& registry()
+  {
+      static class_registry x;
+      return x;
+  }
+
+  ref class_registry::get(class_id id) const
+  {
+      std::vector<entry>::const_iterator start = m_impl.begin();
+      std::vector<entry>::const_iterator finish = m_impl.end();
+
+      std::vector<entry>::const_iterator p
+          = boost::detail::lower_bound(start, finish, id);
+      
+      if (p == finish && p->key != id)
+      {
+          string report("extension class wrapper for base class ");
+          (report += id.name()) += "has not been created yet";
+          PyErr_SetObject(PyExc_RuntimeError, report.get());
+          throw error_already_set();
+      }
+      return p->value;
+  }
+
+  void class_registry::set(class_id id, ref object)
+  {
+      std::vector<entry>::iterator start = m_impl.begin();
+      std::vector<entry>::iterator finish = m_impl.end();
+      m_impl.insert(
+          boost::detail::lower_bound(start, finish, id)
+          , entry(id, object));
+  }
+}
+
+class_base::class_base(
+    module& m, char const* name, std::size_t num_types, class_id const* const types)
+{
+    class_registry& r = registry();
+    assert(num_types >= 1);
+    tuple bases(std::max(num_types - 1, static_cast<std::size_t>(1)));
+    if (num_types > 1)
+    {
+        for (std::size_t i = 1; i < num_types; ++i)
+            bases.set_item(i - 1, r.get(types[i]));
+    }
+    else
+    {
+        bases.set_item(0, class_type());
+    }
+    
+    tuple args(3);
+    args.set_item(0, string(name).reference());
+    args.set_item(1, bases.reference());
+    args.set_item(2, dictionary().reference());
+    
+    m_object = ref(PyObject_CallObject(class_metatype().get(), args.get()));
+    r.set(types[0], m_object);
+    m.add(m_object, name);
+}
+
 }}} // namespace boost::python::objects

From f7a5e6deb81ce98b71fb99280b4cbf55244c10bb Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:52:52 +0000
Subject: [PATCH 223/369] Moved add_overload functionality to
 function::add_to_namespace

[SVN r12385]
---
 src/module.cpp          | 23 +++-------------------
 src/object/function.cpp | 42 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 44 insertions(+), 21 deletions(-)

diff --git a/src/module.cpp b/src/module.cpp
index 9faaca06..0851805f 100644
--- a/src/module.cpp
+++ b/src/module.cpp
@@ -7,7 +7,6 @@
 //  producing this work.
 
 #include <boost/python/module.hpp>
-#include <boost/python/errors.hpp>
 
 namespace boost { namespace python {
 
@@ -47,9 +46,9 @@ void module_base::add(PyObject* x, const char* name)
 
 void module_base::add(ref x, const char* name)
 {
-    ref f(x); // First take possession of the object.
-    if (PyObject_SetAttrString(m_module, const_cast<char*>(name), x.get()) < 0)
-        throw error_already_set();
+    // Use function::add_to_namespace to achieve overloading if
+    // appropriate.
+    objects::function::add_to_namespace(m_module, name, x.get());
 }
 
 void module_base::add(PyTypeObject* x, const char* name /*= 0*/)
@@ -57,22 +56,6 @@ void module_base::add(PyTypeObject* x, const char* name /*= 0*/)
     this->add((PyObject*)x, name ? name : x->tp_name);
 }
 
-void module_base::add_overload(objects::function* x, const char* name)
-{
-    PyObject* existing = PyObject_HasAttrString(m_module, const_cast<char*>(name))
-        ? PyObject_GetAttrString(m_module, const_cast<char*>(name))
-        : 0;
-    
-    if (existing != 0 && existing->ob_type == &objects::function_type)
-    {
-        static_cast<objects::function*>(existing)->add_overload(x);
-    }
-    else
-    {
-        add(x, name);
-    }
-}
-
 PyMethodDef module_base::initial_methods[] = { { 0, 0, 0, 0 } };
 
 }} // namespace boost::python
diff --git a/src/object/function.cpp b/src/object/function.cpp
index 52a0456c..3755dfb1 100644
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -6,6 +6,8 @@
 
 #include <boost/python/object/function.hpp>
 #include <numeric>
+#include <boost/python/errors.hpp>
+#include <boost/python/objects.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -28,7 +30,7 @@ function::~function()
     
 PyObject* function::call(PyObject* args, PyObject* keywords) const
 {
-    int nargs = PyTuple_GET_SIZE(args);
+    std::size_t nargs = PyTuple_GET_SIZE(args);
     function const* f = this;
     do
     {
@@ -63,6 +65,8 @@ void function::argument_error(PyObject* args, PyObject* keywords) const
 
 void function::add_overload(function* overload)
 {
+    Py_XINCREF(overload);
+    
     function* parent = this;
     
     while (parent->m_overloads != 0)
@@ -72,6 +76,42 @@ void function::add_overload(function* overload)
     parent->m_overloads = overload;
 }
 
+void function::add_to_namespace(
+    PyObject* name_space, char const* name_, PyObject* attribute_)
+{
+    ref attribute(attribute_, ref::increment_count);
+    string name(name_);
+    
+    if (attribute_->ob_type == &function_type)
+    {
+        PyObject* dict = 0;
+        
+        if (PyClass_Check(name_space))
+            dict = ((PyClassObject*)name_space)->cl_dict;
+        else if (PyType_Check(name_space))
+            dict = ((PyTypeObject*)name_space)->tp_dict;
+        else
+            dict = PyObject_GetAttrString(name_space, "__dict__");
+
+        if (dict == 0)
+            throw error_already_set();
+        
+        ref existing(PyObject_GetItem(dict, name.get()), ref::null_ok);
+        
+        if (existing.get() && existing->ob_type == &function_type)
+        {
+            static_cast<function*>(existing.get())->add_overload(
+                static_cast<function*>(attribute_));
+            return;
+        }
+    }
+    
+    // The PyObject_GetAttrString() call above left an active error
+    PyErr_Clear();
+    if (PyObject_SetAttr(name_space, name.get(), attribute_) < 0)
+        throw error_already_set();
+}
+
 extern "C"
 {
     // Stolen from Python's funcobject.c

From 4a1d077238fecb53f5010b7c197e9c52fb70e544 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 20 Jan 2002 23:54:26 +0000
Subject: [PATCH 224/369] Added implicit conversion tests

[SVN r12386]
---
 test/newtest.py | 74 +++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 71 insertions(+), 3 deletions(-)

diff --git a/test/newtest.py b/test/newtest.py
index d29ac129..0636641b 100644
--- a/test/newtest.py
+++ b/test/newtest.py
@@ -60,14 +60,82 @@ try: wrap_int_ref(n)
 Create an extension class which wraps "complicated" (init1 and get_n)
 are a complicated constructor and member function, respectively.
 
->>> C = xclass('C', (xinst,), {'__init__': init1, 'get_n': get_n})
->>> c1 = C(s, 99)
+>>> c1 = complicated(s, 99)
 >>> c1.get_n()
 99
->>> c2 = C(s)
+>>> c2 = complicated(s)
 >>> c2.get_n()
 0
 
+>>> a = A()
+>>> b = B()
+>>> c = C()
+>>> d = D()
+
+------
+>>> take_a(a)
+0
+
+>>> try:
+...     take_b(a)
+... except: pass
+... else: print 'no exception'
+
+>>> try:
+...     take_c(a)
+... except: pass
+... else: print 'no exception'
+
+>>> try:
+...     take_d(a)
+... except: pass
+... else: print 'no exception'
+
+------
+>>> take_a(b)
+0
+
+>>> take_b(b)
+1
+
+>>> try:
+...     take_c(b)
+... except: pass
+... else: print 'no exception'
+
+>>> try:
+...     take_d(b)
+... except: pass
+... else: print 'no exception'
+
+-------
+>>> take_a(c)
+0
+
+>>> try:
+...     take_b(c)
+... except: pass
+... else: print 'no exception'
+
+>>> take_c(c)
+2
+
+>>> try:
+...     take_d(c)
+... except: pass
+... else: print 'no exception'
+
+-------
+>>> take_a(d)
+0
+>>> take_b(d)
+1
+>>> take_c(d)
+2
+>>> take_d(d)
+3
+
+
 """
 
 def run(args = None):

From 03e9e4c1d9fff14e25f62f0aecca289ab9630dd1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 21 Jan 2002 00:47:05 +0000
Subject: [PATCH 225/369] Added class wrapping

[SVN r12387]
---
 Jamfile                                       |   2 +-
 include/boost/python/class.hpp                | 166 ++++++
 include/boost/python/detail/map_entry.hpp     |  44 ++
 include/boost/python/detail/wrap_function.hpp |  56 ++
 .../boost/python/object/class_converters.hpp  | 101 ++++
 include/boost/python/object/class_wrapper.hpp |  62 +++
 include/boost/python/object/inheritance.hpp   | 165 ++++++
 src/object/inheritance.cpp                    | 493 ++++++++++++++++++
 test/m1.cpp                                   |  99 +++-
 9 files changed, 1164 insertions(+), 24 deletions(-)
 create mode 100644 include/boost/python/class.hpp
 create mode 100644 include/boost/python/detail/map_entry.hpp
 create mode 100644 include/boost/python/detail/wrap_function.hpp
 create mode 100644 include/boost/python/object/class_converters.hpp
 create mode 100644 include/boost/python/object/class_wrapper.hpp
 create mode 100644 include/boost/python/object/inheritance.hpp
 create mode 100644 src/object/inheritance.cpp

diff --git a/Jamfile b/Jamfile
index deb8c690..71e0c5b7 100644
--- a/Jamfile
+++ b/Jamfile
@@ -23,7 +23,7 @@ dll bpl
     src/converter/type_id.cpp
     src/object/class.cpp
     src/object/function.cpp
-    # src/object/inheritance.cpp
+    src/object/inheritance.cpp
     src/errors.cpp
     src/module.cpp
     src/objects.cpp
diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
new file mode 100644
index 00000000..d61a8fc0
--- /dev/null
+++ b/include/boost/python/class.hpp
@@ -0,0 +1,166 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_DWA200216_HPP
+# define CLASS_DWA200216_HPP
+
+# include <boost/python/module.hpp>
+# include <boost/python/reference.hpp>
+# include <boost/python/object/class.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/detail/wrap_function.hpp>
+# include <boost/mpl/type_list.hpp>
+# include <boost/python/object/class_converters.hpp>
+# include <boost/mpl/size.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/type_list.hpp>
+
+namespace // put some convenience classes into the unnamed namespace for the user
+{
+  // A type list for specifying bases
+  template < BOOST_MPL_LIST_DEFAULT_PARAMETERS(typename B, ::boost::mpl::null_argument) >
+  struct bases : ::boost::mpl::type_list< BOOST_MPL_LIST_PARAMETERS(B) >::type
+  {};
+
+  // A type list for specifying arguments
+  template < BOOST_MPL_LIST_DEFAULT_PARAMETERS(typename A, ::boost::mpl::null_argument) >
+  struct args : ::boost::mpl::type_list< BOOST_MPL_LIST_PARAMETERS(A) >::type
+  {};
+}
+
+namespace boost { namespace python { 
+
+// Forward declarations
+namespace objects
+{
+  struct value_holder_generator;
+}
+
+namespace detail
+{
+  // This is an mpl BinaryMetaFunction object with a runtime behavior,
+  // which is to write the id of the type which is passed as its 2nd
+  // compile-time argument into the iterator pointed to by its runtime
+  // argument
+  struct write_type_id
+  {
+      // The first argument is Ignored because mpl::for_each is still
+      // currently an accumulate (reduce) implementation.
+      template <class Ignored, class T> struct apply
+      {
+          // also an artifact of accumulate-based for_each
+          typedef void type;
+
+          // Here's the runtime behavior
+          static void execute(converter::undecorated_type_id_t** p)
+          {
+              *(*p)++ = converter::undecorated_type_id<T>();
+          }
+      };
+  };
+}
+
+//
+// class_<T,Bases,HolderGenerator>
+//
+//      This is the primary mechanism through which users will expose
+//      C++ classes to Python. The three template arguments are:
+//
+//        T - The class being exposed to Python
+//
+//        Bases - An MPL sequence of base classes
+//
+//        HolderGenerator -
+//           An optional type generator for the "holder" which
+//           maintains the C++ object inside the Python instance. The
+//           default just holds the object "by-value", but other
+//           holders can be substituted which will hold the C++ object
+//           by smart pointer, for example.
+//
+template <
+    class T // class being wrapped
+    , class Bases = mpl::type_list<>::type
+    , class HolderGenerator = objects::value_holder_generator
+    >
+class class_ : objects::class_base
+{
+    typedef class_<T,Bases,HolderGenerator> self;
+ public:
+
+    // Construct with the module and class name
+    class_(module&, char const* name);
+
+    // Wrap a member function or a non-member function which can take
+    // a T, T cv&, or T cv* as its first parameter, or a callable
+    // python object.
+    template <class F>
+    self& def(F f, char const* name)
+    {
+        // Use function::add_to_namespace to achieve overloading if
+        // appropriate.
+        objects::function::add_to_namespace(this->object(), name, detail::wrap_function(f));
+        return *this;
+    }
+
+    // Define the constructor with the given Args, which should be an
+    // MPL sequence of types.
+    template <class Args>
+    self& def_init(Args const& = Args())
+    {
+        def(make_constructor<T,Args,HolderGenerator>(), "__init__");
+        return *this;
+    }
+
+    // Define the default constructor.
+    self& def_init()
+    {
+        this->def_init(mpl::type_list<>::type());
+        return *this;
+    }
+
+ private: // types
+    typedef objects::class_id class_id;
+    
+    // A helper class which will contain an array of id objects to be
+    // passed to the base class constructor
+    struct id_vector
+    {
+        id_vector()
+        {
+            // Stick the derived class id into the first element of the array
+            ids[0] = converter::undecorated_type_id<T>();
+    
+            // Write the rest of the elements into succeeding positions.
+            class_id* p = ids + 1;
+            mpl::for_each<Bases, void, detail::write_type_id>::execute(&p);
+        }
+        
+        BOOST_STATIC_CONSTANT(
+            std::size_t, size = mpl::size<Bases>::value + 1);
+        class_id ids[size];
+    };
+
+ private: // helper functions
+    void initialize_converters();
+};
+
+
+//
+// implementations
+//
+template <class T, class Bases, class HolderGenerator>
+inline class_<T, Bases, HolderGenerator>::class_(
+    module& m, char const* name = typeid(T).name())
+    : class_base(m, name, id_vector::size, id_vector().ids)
+{
+    // Bring the class converters into existence. This static object
+    // will survive until the shared library this module lives in is
+    // unloaded (that doesn't happen until Python terminates).
+    static objects::class_converters<T,Bases> converters(object());
+}
+
+}} // namespace boost::python
+
+#endif // CLASS_DWA200216_HPP
diff --git a/include/boost/python/detail/map_entry.hpp b/include/boost/python/detail/map_entry.hpp
new file mode 100644
index 00000000..9249523a
--- /dev/null
+++ b/include/boost/python/detail/map_entry.hpp
@@ -0,0 +1,44 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MAP_ENTRY_DWA2002118_HPP
+# define MAP_ENTRY_DWA2002118_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+// A trivial type that works well as the value_type of associative
+// vector maps
+template <class Key, class Value>
+struct map_entry
+{
+    map_entry() {}
+    map_entry(Key k) : key(k), value() {}
+    map_entry(Key k, Value v) : key(k), value(v) {}
+    
+    bool operator<(map_entry const& rhs) const
+    {
+        return this->key < rhs.key;
+    }
+        
+    Key key;
+    Value value;
+};
+
+template <class Key, class Value>
+bool operator<(map_entry<Key,Value> const& e, Key const& k)
+{
+    return e.key < k;
+}
+
+template <class Key, class Value>
+bool operator<(Key const& k, map_entry<Key,Value> const& e)
+{
+    return k < e.key;
+}
+
+
+}}} // namespace boost::python::detail
+
+#endif // MAP_ENTRY_DWA2002118_HPP
diff --git a/include/boost/python/detail/wrap_function.hpp b/include/boost/python/detail/wrap_function.hpp
new file mode 100644
index 00000000..0424183d
--- /dev/null
+++ b/include/boost/python/detail/wrap_function.hpp
@@ -0,0 +1,56 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef WRAP_FUNCTION_DWA2002118_HPP
+# define WRAP_FUNCTION_DWA2002118_HPP
+
+# include <boost/python/make_function.hpp>
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+// A function which converts its argument into a Python callable
+// object. Not very general yet!
+
+// This should eventually be replaced with a mechanism for specialized
+// wrap/unwrap objects. In other words, to_python(f), where f is a
+// function pointer or function type, should produce a callable Python
+// object.
+
+template <bool needs_wrapping>
+struct wrap_function_select
+{
+    template <class F>
+    static objects::function* execute(F f)
+    {
+        return make_function(f);
+    }
+};
+
+template<>
+struct wrap_function_select<false>
+{
+    template <class F>
+    static F execute(F f)
+    {
+        return f;
+    }
+};
+
+template <class F>
+PyObject* wrap_function(F f)
+{
+    return wrap_function_select<
+              type_traits::ice_or<
+                 is_function<F>::value
+                 , is_member_function_pointer<F>::value
+        >::value >::execute(f);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // WRAP_FUNCTION_DWA2002118_HPP
diff --git a/include/boost/python/object/class_converters.hpp b/include/boost/python/object/class_converters.hpp
new file mode 100644
index 00000000..c14103b6
--- /dev/null
+++ b/include/boost/python/object/class_converters.hpp
@@ -0,0 +1,101 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_CONVERTERS_DWA2002119_HPP
+# define CLASS_CONVERTERS_DWA2002119_HPP
+
+# include <boost/python/converter/class.hpp>
+# include <boost/python/object/class_wrapper.hpp>
+# include <boost/mpl/for_each.hpp>
+
+namespace boost { namespace python { namespace objects { 
+
+// Instantiating this class brings into existence all converters
+// associated with a class Bases is expected to be an mpl sequence of
+// base types.
+template <class Derived, class Bases>
+struct class_converters
+{
+ public: // member functions
+    // Constructor takes the python class object associated with T
+    class_converters(PyObject* python_class);
+
+ private: // data members
+    converter::class_unwrapper<Derived> m_unwrapper;
+    class_wrapper<Derived> m_wrapper;
+};
+
+//
+// Implementation details
+//
+
+//////////////////////////////////////////////////////////////////////
+//
+// register_base_of<T> -
+//      A BinaryMetaFunction object which registers a single base
+//      class of T, and the corresponding cast(s)
+//
+
+
+// register_downcast/do_nothing -
+//      Helpers for register_base_of<> which take care of registering
+//      down-casts
+template <class Base, class Derived>
+struct register_downcast
+{
+    static void execute()
+    {
+        register_conversion<Base, Derived>(true);
+    }
+};
+
+struct do_nothing
+{
+    static void execute() { }
+};
+
+// Here's where the real work gets done:
+template <class Derived>
+struct register_base_of
+{
+    // Ignored is needed because mpl::for_each is still actually
+    // accumulate. We're not using any state so it just sits there.
+    template <class Ignored, class Base>
+    struct apply
+    {
+        typedef void type; // 'type' needs to be defined for the same reasons
+
+        // Here's the runtime part:
+        static void execute()
+        {
+            // Register the Base class
+            register_dynamic_id<Base>();
+            // Register the up-cast
+            register_conversion<Derived,Base>(false);
+
+            // Register the down-cast, if appropriate.
+            mpl::select_type<
+                is_polymorphic<Base>::value
+                , register_downcast<Base,Derived>
+                , do_nothing
+                >::type::execute();
+        }
+    };
+};
+
+template <class Derived, class Bases>
+class_converters<Derived,Bases>::class_converters(PyObject* type_object)
+    : m_wrapper(type_object)
+{
+    // register all up/downcasts here
+    register_dynamic_id<Derived>();
+
+    // register each base in the sequence
+    mpl::for_each<Bases, void, register_base_of<Derived> >::execute();
+}
+
+}}} // namespace boost::python::object
+
+#endif // CLASS_CONVERTERS_DWA2002119_HPP
diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
new file mode 100644
index 00000000..0e49ce84
--- /dev/null
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -0,0 +1,62 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_WRAPPER_DWA20011221_HPP
+# define CLASS_WRAPPER_DWA20011221_HPP
+
+# include <boost/python/object/class.hpp>
+# include <boost/python/object/value_holder.hpp>
+# include <boost/python/converter/wrapper.hpp>
+# include <boost/python/reference.hpp>
+# include <memory>
+
+namespace boost { namespace python { namespace objects { 
+
+template <class T>
+struct class_wrapper
+    : converter::wrapper<T const&>
+{
+    class_wrapper(PyObject* type_)
+        : m_class_object(type_)
+    {
+# ifndef NDEBUG
+        assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
+# endif NDEBUG 
+    }
+    
+    PyObject* convert(T const& x) const
+    {
+        // Don't call the type to do the construction, since that
+        // would require the registration of an __init__ copy
+        // constructor. Instead, just construct the object in place.
+        PyObject* raw_result = (PyObject*)PyObject_New(
+            instance, (PyTypeObject*)m_class_object.get());
+        
+        if (raw_result == 0)
+            return 0;
+
+        // Everything's OK; Bypass NULL checks but guard against
+        // exceptions.
+        ref result(raw_result, ref::allow_null());
+
+        // Build a value_holder to contain the object using the copy
+        // constructor
+        value_holder<T>* p = new value_holder<T>(raw_result, cref(x));
+
+        // Install it in the instance
+        p->install(raw_result);
+
+        // Return the new result
+        return result.release();
+    }
+    
+ private:
+    ref m_class_object;
+};
+
+
+}}} // namespace boost::python::objects
+
+#endif // CLASS_WRAPPER_DWA20011221_HPP
diff --git a/include/boost/python/object/inheritance.hpp b/include/boost/python/object/inheritance.hpp
new file mode 100644
index 00000000..60aeda58
--- /dev/null
+++ b/include/boost/python/object/inheritance.hpp
@@ -0,0 +1,165 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef INHERITANCE_DWA200216_HPP
+# define INHERITANCE_DWA200216_HPP
+
+# include <boost/python/converter/type_id.hpp>
+# include <boost/smart_ptr.hpp>
+
+namespace boost { namespace python { namespace objects {
+
+typedef converter::undecorated_type_id_t class_id;
+using converter::undecorated_type_id;
+
+// Types used to get address and id of most derived type
+typedef std::pair<void*,class_id> dynamic_id_t;
+typedef dynamic_id_t (*dynamic_id_function)(void*);
+
+BOOST_PYTHON_DECL void register_dynamic_id_aux(
+    class_id static_id, dynamic_id_function get_dynamic_id);
+
+BOOST_PYTHON_DECL void add_cast(
+    class_id src_t, class_id dst_t, void* (*cast)(void*), bool polymorphic);
+
+BOOST_PYTHON_DECL void* find_static_type(void* p, class_id src, class_id dst);
+
+BOOST_PYTHON_DECL void* find_dynamic_type(void* p, class_id src, class_id dst);
+
+// is_polymorphic test from John Maddock
+template <class T>
+struct is_polymorphic
+{
+   struct d1 : public T
+   {
+      d1();
+      char padding[256];
+   };
+   struct d2 : public T
+   {
+      d2();
+      virtual ~d2();
+      virtual void foo();
+      char padding[256];
+   };
+   BOOST_STATIC_CONSTANT(bool, value = (sizeof(d2) == sizeof(d1)));
+};
+
+//
+// a generator with an execute() function which, given a source type
+// and a pointer to an object of that type, returns its most-derived
+// /reachable/ type identifier and object pointer.
+//
+
+// first, the case where T has virtual functions
+template <class T>
+struct polymorphic_id_generator
+{
+    static dynamic_id_t execute(void* p_)
+    {
+        T* p = static_cast<T*>(p_);
+        return std::make_pair(dynamic_cast<void*>(p), class_id(typeid(*p)));
+    }
+};
+
+// now, the non-polymorphic case.
+template <class T>
+struct non_polymorphic_id_generator
+{
+    static dynamic_id_t execute(void* p_)
+    {
+        return std::make_pair(p_, converter::undecorated_type_id<T>());
+    }
+};
+
+// Now the generalized selector
+template <class T>
+struct dynamic_id_generator
+{
+    typedef typename mpl::select_type<
+        is_polymorphic<T>::value
+        , polymorphic_id_generator<T>
+        , non_polymorphic_id_generator<T> >::type type;
+};
+
+// Register the dynamic id function for T with the type-conversion
+// system.
+template <class T>
+void register_dynamic_id(T* = 0)
+{
+    typedef typename dynamic_id_generator<T>::type generator;
+    register_dynamic_id_aux(
+        converter::undecorated_type_id<T>(), &generator::execute);
+}
+
+//
+// a generator with an execute() function which, given a void*
+// pointing to an object of type Source will attempt to convert it to
+// an object of type Target.
+//
+
+template <class Source, class Target>
+struct dynamic_cast_generator
+{
+    static void* execute(void* source)
+    {
+        return dynamic_cast<Target*>(
+            static_cast<Source*>(source));
+    }
+        
+};
+
+template <class Source, class Target>
+struct implicit_cast_generator
+{
+    static void* execute(void* source)
+    {
+        Target* result = static_cast<Source*>(source);
+        return result;
+    }
+};
+
+template <class Source, class Target>
+struct cast_generator
+{
+    // CWPro7 will return false sometimes, but that's OK since we can
+    // always cast up with dynamic_cast<>
+    BOOST_STATIC_CONSTANT(
+        bool, is_upcast = (
+            is_base_and_derived<Target,Source>::value
+            ));
+
+    typedef typename mpl::select_type<
+        is_upcast
+# if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+        // grab a few more implicit_cast cases for CodeWarrior
+        || !is_polymorphic<Source>::value
+        || !is_polymorphic<Target>::value
+# endif 
+        , implicit_cast_generator<Source,Target>
+        , dynamic_cast_generator<Source,Target>
+    >::type type;
+};
+
+template <class Source, class Target>
+inline void register_conversion(
+    // We need this parameter because CWPro7 can't determine
+    // which is the base reliably.
+    bool is_downcast = !cast_generator<Source,Target>::is_upcast
+
+    // These parameters shouldn't be used, they're an MSVC bug workaround
+    , Source* = 0, Target* = 0)
+{
+    typedef typename cast_generator<Source,Target>::type generator;
+    
+    add_cast(converter::undecorated_type_id<Source>()
+             , converter::undecorated_type_id<Target>()
+             , &generator::execute
+             , is_downcast);
+}
+
+}}} // namespace boost::python::object
+
+#endif // INHERITANCE_DWA200216_HPP
diff --git a/src/object/inheritance.cpp b/src/object/inheritance.cpp
new file mode 100644
index 00000000..5b95e478
--- /dev/null
+++ b/src/object/inheritance.cpp
@@ -0,0 +1,493 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/object/inheritance.hpp>
+#include <boost/python/converter/type_id.hpp>
+#include <boost/graph/breadth_first_search.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/reverse_graph.hpp>
+#include <boost/property_map.hpp>
+#include <boost/bind.hpp>
+#include <boost/integer_traits.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/tuple/tuple_comparison.hpp>
+#include <queue>
+#include <vector>
+#include <functional>
+
+//
+// Procedure:
+//
+//      The search is a BFS over the space of (type,address) pairs
+//      guided by the edges of the casting graph whose nodes
+//      correspond to classes, and whose edges are traversed by
+//      applying associated cast functions to an address. We use
+//      vertex distance to the goal node in the cast_graph to rate the
+//      paths. The vertex distance to any goal node is calculated on
+//      demand and outdated by the addition of edges to the graph.
+
+namespace boost {
+namespace
+{
+  enum edge_cast_t { edge_cast = 8010 };
+}
+
+// Install properties
+BOOST_INSTALL_PROPERTY(edge, cast);
+
+namespace
+{
+  typedef void*(*cast_function)(void*);
+  
+  //
+  // Here we put together the low-level data structures of the
+  // casting graph representation.
+  //
+  typedef python::converter::undecorated_type_id_t class_id;
+
+  // represents a graph of available casts
+  
+#if 0
+  struct cast_graph
+      :
+#else
+        typedef
+#endif 
+        adjacency_list<vecS,vecS, bidirectionalS, no_property
+
+      // edge index property allows us to look up edges in the connectivity matrix
+      , property<edge_index_t,std::size_t
+  
+                 // The function which casts a void* from the edge's source type
+                 // to its destination type.
+                 , property<edge_cast_t,cast_function> > >
+#if 0
+  {};
+#else
+  cast_graph;
+#endif 
+
+  typedef cast_graph::vertex_descriptor vertex_t;
+  typedef cast_graph::edge_descriptor edge_t;
+  
+  struct smart_graph
+  {
+      typedef std::vector<std::size_t>::const_iterator node_distance_map;
+      
+      typedef std::pair<cast_graph::out_edge_iterator
+                        , cast_graph::out_edge_iterator> out_edges_t;
+      
+      // Return a map of the distances from any node to the given
+      // target node
+      node_distance_map distances_to(vertex_t target) const
+      {
+          std::size_t n = num_vertices(m_topology);
+          if (m_distances.size() != n * n)
+          {
+              m_distances.clear();
+              m_distances.resize(n * n, std::numeric_limits<std::size_t>::max());
+              m_known_vertices = n;
+          }
+          
+          std::vector<std::size_t>::iterator to_target = m_distances.begin() + n * target;
+
+          // this node hasn't been used as a target yet
+          if (to_target[target] != 0)
+          {
+              typedef reverse_graph<cast_graph> reverse_cast_graph;
+              reverse_cast_graph reverse_topology(m_topology);
+              
+              to_target[target] = 0;
+              
+              breadth_first_search(
+                  reverse_topology, target
+                  , visitor(
+                      make_bfs_visitor(
+                          record_distances(
+                              make_iterator_property_map(
+                                  to_target
+                                  , get(vertex_index, reverse_topology)
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+                                  , *to_target
+# endif 
+                                  )
+                              , on_tree_edge()
+                              ))));
+          }
+
+          return to_target;
+      }
+
+      cast_graph& topology() { return m_topology; }
+      cast_graph const& topology() const { return m_topology; }
+
+      std::size_t known_vertices() const { return m_known_vertices; }
+
+      smart_graph()
+          : m_known_vertices(0)
+      {}
+      
+   private:
+      cast_graph m_topology;
+      mutable std::vector<std::size_t> m_distances;
+      mutable std::size_t m_known_vertices;
+  };
+  
+  smart_graph& full_graph()
+  {
+      static smart_graph x;
+      return x;
+  }
+  
+  smart_graph& up_graph()
+  {
+      static smart_graph x;
+      return x;
+  }
+
+  //
+  // Our index of class types
+  //
+  using boost::python::objects::dynamic_id_function;
+  typedef tuples::tuple<
+      class_id               // static type
+      , vertex_t             // corresponding vertex 
+      , dynamic_id_function  // dynamic_id if polymorphic, or 0
+      >
+  index_entry_interface;
+  typedef index_entry_interface::inherited index_entry;
+  enum { ksrc_static_t, kvertex, kdynamic_id };
+  
+  typedef std::vector<index_entry> type_index_t;
+
+  
+  type_index_t& type_index()
+  {
+      static type_index_t x;
+      return x;
+  }
+
+  template <class Tuple>
+  struct select1st
+  {
+      typedef typename tuples::element<0, Tuple>::type result_type;
+      
+      result_type const& operator()(Tuple const& x) const
+      {
+          return tuples::get<0>(x);
+      }
+  };
+  
+  // map a type to a position in the index
+  inline type_index_t::iterator type_position(class_id type)
+  {
+      typedef index_entry entry;
+      
+      return std::lower_bound(
+          type_index().begin(), type_index().end()
+          , make_tuple(type, vertex_t(), dynamic_id_function(0))
+          , boost::bind<bool>(std::less<class_id>()
+               , boost::bind<class_id>(select1st<entry>(), _1)
+               , boost::bind<class_id>(select1st<entry>(), _2)));
+  }
+
+  inline index_entry* seek_type(class_id type)
+  {
+      type_index_t::iterator p = type_position(type);
+      if (p == type_index().end() || tuples::get<ksrc_static_t>(*p) != type)
+          return 0;
+      else
+          return &*p;
+  }
+  
+  // Get the entry for a type, inserting if neccessary
+  inline type_index_t::iterator demand_type(class_id type)
+  {
+      type_index_t::iterator p = type_position(type);
+
+      if (p != type_index().end() && tuples::get<ksrc_static_t>(*p) == type)
+          return p;
+
+      vertex_t v = add_vertex(full_graph().topology());
+      vertex_t v2 = add_vertex(up_graph().topology());
+      assert(v == v2);
+      return type_index().insert(p, make_tuple(type, v, dynamic_id_function(0)));
+  }
+
+  // Map a two types to a vertex in the graph, inserting if neccessary
+  typedef std::pair<type_index_t::iterator, type_index_t::iterator>
+        type_index_iterator_pair;
+  
+  inline type_index_iterator_pair
+  demand_types(class_id t1, class_id t2)
+  {
+      // be sure there will be no reallocation
+      type_index().reserve(type_index().size() + 2);
+      type_index_t::iterator first = demand_type(t1);
+      type_index_t::iterator second = demand_type(t2);
+      if (first == second)
+          ++first;
+      return std::make_pair(first, second);
+  }
+
+  struct q_elt
+  {
+      q_elt(std::size_t distance
+            , void* src_address
+            , vertex_t target
+            , cast_function cast
+            )
+          : distance(distance)
+          , src_address(src_address)
+          , target(target)
+          , cast(cast)
+      {}
+      
+      std::size_t distance;
+      void* src_address;
+      vertex_t target;
+      cast_function cast;
+
+      bool operator<(q_elt const& rhs) const
+      {
+          return distance < rhs.distance;
+      }
+  };
+
+  // Optimization:
+  //
+  // Given p, src_t, dst_t
+  //
+  // Get a pointer pd to the most-derived object
+  //    if it's polymorphic, dynamic_cast to void*
+  //    otherwise pd = p
+  //
+  // Get the most-derived typeid src_td
+  //
+  // ptrdiff_t offset = p - pd
+  //
+  // Now we can keep a cache, for [src_t, offset, src_td, dst_t] of
+  // the cast transformation function to use on p and the next src_t
+  // in the chain.  src_td, dst_t don't change throughout this
+  // process. In order to represent unreachability, when a pair is
+  // found to be unreachable, we stick a 0-returning "dead-cast"
+  // function in the cache.
+  
+  // This is needed in a few places below
+  inline void* identity_cast(void* p)
+  {
+      return p;
+  }
+
+  void* search(smart_graph const& g, void* p, vertex_t src, vertex_t dst)
+  {
+      // I think this test was thoroughly bogus -- dwa
+      // If we know there's no path; bail now.
+      // if (src > g.known_vertices() || dst > g.known_vertices())
+      //    return 0;
+      
+      smart_graph::node_distance_map d(g.distances_to(dst));
+
+      if (d[src] == std::numeric_limits<std::size_t>::max())
+          return 0;
+
+      typedef property_map<cast_graph,edge_cast_t>::const_type cast_map;
+      cast_map casts = get(edge_cast, g.topology());
+      
+      typedef std::pair<vertex_t,void*> search_state;
+      typedef std::vector<search_state> visited_t;
+      visited_t visited;
+      std::priority_queue<q_elt> q;
+      
+      q.push(q_elt(d[src], p, src, identity_cast));
+      while (!q.empty())
+      {
+          q_elt top = q.top();
+          q.pop();
+          
+          // Check to see if we have a real state
+          void* dst_address = top.cast(top.src_address);
+          if (dst_address == 0)
+              continue;
+
+          if (top.target == dst)
+              return dst_address;
+          
+          search_state s(top.target,dst_address);
+
+          visited_t::iterator pos = std::lower_bound(
+              visited.begin(), visited.end(), s);
+
+          // If already visited, continue
+          if (pos != visited.end() && *pos == s)
+              continue;
+          
+          visited.insert(pos, s); // mark it
+
+          // expand it:
+          smart_graph::out_edges_t edges = out_edges(s.first, g.topology());
+          for (cast_graph::out_edge_iterator p = edges.first
+                   , finish = edges.second
+                   ; p != finish
+                   ; ++p
+              )
+          {
+              edge_t e = *p;
+              q.push(q_elt(
+                         d[target(e, g.topology())]
+                         , dst_address
+                         , target(e, g.topology())
+                         , boost::get(casts, e)));
+          }
+      }
+      return 0;
+  }
+
+  struct cache_element
+  {
+      typedef tuples::tuple<
+          class_id              // source static type
+          , class_id            // target type
+          , std::ptrdiff_t      // offset within source object
+          , class_id            // source dynamic type
+          >::inherited key_type;
+
+      cache_element(key_type const& k)
+          : key(k)
+          , offset(0)
+      {}
+      
+      key_type key;
+      std::ptrdiff_t offset;
+
+      BOOST_STATIC_CONSTANT(
+          std::ptrdiff_t, not_found = integer_traits<std::ptrdiff_t>::const_min);
+      
+      bool operator<(cache_element const& rhs) const
+      {
+          return this->key < rhs.key;
+      }
+
+      bool unreachable() const
+      {
+          return offset == not_found;
+      }
+  };
+  
+  enum { kdst_t = ksrc_static_t + 1, koffset, ksrc_dynamic_t };
+  typedef std::vector<cache_element> cache_t;
+
+  cache_t& cache()
+  {
+      static cache_t x;
+      return x;
+  }
+
+  inline void* convert_type(void* const p, class_id src_t, class_id dst_t, bool polymorphic)
+  {
+      // Quickly rule out unregistered types
+      index_entry* src_p = seek_type(src_t);
+      if (src_p == 0)
+          return 0;
+
+      index_entry* dst_p = seek_type(dst_t);
+      if (dst_p == 0)
+          return 0;
+    
+      // Look up the dynamic_id function and call it to get the dynamic
+      // info
+      boost::python::objects::dynamic_id_t dynamic_id = polymorphic
+          ? tuples::get<kdynamic_id>(*src_p)(p)
+          : std::make_pair(p, src_t);
+    
+      // Look in the cache first for a quickie address translation
+      std::ptrdiff_t offset = (char*)p - (char*)dynamic_id.first;
+
+      cache_element seek(make_tuple(src_t, dst_t, offset, dynamic_id.second));
+      cache_t& c = cache();
+      cache_t::iterator const cache_pos
+          = std::lower_bound(c.begin(), c.end(), seek);
+                      
+
+      // if found in the cache, we're done
+      if (cache_pos != c.end() && cache_pos->key == seek.key)
+      {
+          return cache_pos->offset == cache_element::not_found
+              ? 0 : (char*)p + cache_pos->offset;
+      }
+
+      // If we are starting at the most-derived type, only look in the up graph
+      smart_graph const& g = polymorphic && dynamic_id.second != src_t
+          ? full_graph() : up_graph();
+    
+      void* result = search(
+          g, p, tuples::get<kvertex>(*src_p)
+          , tuples::get<kvertex>(*dst_p));
+
+      // update the cache
+      c.insert(cache_pos, seek)->offset
+          = (result == 0) ? cache_element::not_found : (char*)result - (char*)p;
+
+      return result;
+  }
+}
+
+namespace python { namespace objects {
+
+BOOST_PYTHON_DECL void* find_dynamic_type(void* p, class_id src_t, class_id dst_t)
+{
+    return convert_type(p, src_t, dst_t, true);
+}
+
+BOOST_PYTHON_DECL void* find_static_type(void* p, class_id src_t, class_id dst_t)
+{
+    return convert_type(p, src_t, dst_t, false);
+}
+
+BOOST_PYTHON_DECL void add_cast(
+    class_id src_t, class_id dst_t, cast_function cast, bool is_downcast)
+{
+    // adding an edge will invalidate any record of unreachability in
+    // the cache.
+    static std::size_t expected_cache_len = 0;
+    cache_t& c = cache();
+    if (c.size() > expected_cache_len)
+    {
+        c.erase(std::remove_if(
+                    c.begin(), c.end(),
+                    mem_fn(&cache_element::unreachable))
+                , c.end());
+
+        // If any new cache entries get added, we'll have to do this
+        // again when the next edge is added
+        expected_cache_len = c.size();
+    }
+    
+    type_index_iterator_pair types = demand_types(src_t, dst_t);
+    vertex_t src = tuples::get<kvertex>(*types.first);
+    vertex_t dst = tuples::get<kvertex>(*types.second);
+
+    cast_graph* const g[2] = { &up_graph().topology(), &full_graph().topology() };
+    
+    for (cast_graph*const* p = g + (is_downcast ? 1 : 0); p < g + 2; ++p)
+    {
+        edge_t e;
+        bool added;
+
+        tie(e, added) = add_edge(src, dst, **p);
+        assert(added);
+
+        put(get(edge_cast, **p), e, cast);
+        put(get(edge_index, **p), e, num_edges(full_graph().topology()) - 1);
+    }
+}
+
+BOOST_PYTHON_DECL void register_dynamic_id_aux(
+    class_id static_id, dynamic_id_function get_dynamic_id)
+{
+    tuples::get<kdynamic_id>(*demand_type(static_id)) = get_dynamic_id;
+}
+
+}}} // namespace boost::python::objects
diff --git a/test/m1.cpp b/test/m1.cpp
index 78471bfc..da3ca5d5 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -11,8 +11,10 @@
 #include <boost/python/detail/config.hpp>
 #include <boost/python/convert.hpp>
 #include <boost/python/module.hpp>
+#include <boost/python/class.hpp>
 #include <boost/python/object/value_holder.hpp>
 #include <boost/python/object/class.hpp>
+#include <boost/python/object/inheritance.hpp>
 #include <boost/python/converter/class.hpp>
 #include <boost/python/make_function.hpp>
 #include <boost/python/errors.hpp>
@@ -227,10 +229,47 @@ simple const& g(simple const& x)
     return x;
 }
 
+struct A
+{
+    A() : x(0) {}
+    char const* name() { return "A"; }
+    int x;
+};
+
+struct B : A
+{
+    B() : x(1) {}
+    char const* name() { return "B"; }
+    int x;
+};
+
+
+struct C : A
+{
+    C() : x(2) {}
+    char const* name() { return "C"; }
+    virtual ~C() {}
+    int x;
+};
+
+struct D : B, C
+{
+    D() : x(3) {}
+    char const* name() { return "D"; }
+    int x;
+};
+
+int take_a(A const& a) { return a.x; }
+int take_b(B const& b) { return b.x; }
+int take_c(C const& c) { return c.x; }
+int take_d(D const& d) { return d.x; }
+    
 BOOST_PYTHON_MODULE_INIT(m1)
 {
-    boost::python::module m1("m1");
-
+    using boost::python::module;
+    using boost::python::class_;
+    
+    module m1("m1");
     // Create the converters; they are self-registering/unregistering.
     static int_wrapper wrap_int;
     static simple_wrapper wrap_simple;
@@ -242,13 +281,16 @@ BOOST_PYTHON_MODULE_INIT(m1)
     static simple_ref_wrapper wrap_simple_ref;
 
     // This unwrapper extracts pointers and references to the "complicated" class.
-    static boost::python::converter::class_unwrapper<complicated> unwrap_complicated;
+    //    static boost::python::converter::class_unwrapper<complicated> unwrap_complicated;
     
     // Insert the extension metaclass object
-    m1.add(boost::python::objects::class_metatype(), "xclass");
+    m1.add(
+        boost::python::objects::class_metatype()
+        , "xclass");
     
     // Insert the base class for all extension classes
-    m1.add(boost::python::objects::class_type(), "xinst");
+    m1.add(boost::python::objects::class_type()
+           , "xinst");
 
     m1.def(new_noddy, "new_noddy");
     m1.def(new_simple, "new_simple");
@@ -259,25 +301,36 @@ BOOST_PYTHON_MODULE_INIT(m1)
     // Expose g()
     m1.def(g, "g");
 
-    // Expose complicated's get_n() member function. See newtest.py
-    // for how it's used to build an extension class.
-    m1.def(&complicated::get_n, "get_n");
+    m1.def(take_a, "take_a");
+    m1.def(take_b, "take_b");
+    m1.def(take_c, "take_c");
+    m1.def(take_d, "take_d");
 
-    // Expose complicated::complicated(simple const&, int) as init1
-    boost::python::objects::function* init = boost::python::make_constructor<
-        complicated
-        , boost::mpl::type_list<simple const&,int>
-        , boost::python::objects::value_holder_generator>();
-    
-    boost::python::ref manager(init);
-    
-    init->add_overload(
-        boost::python::make_constructor<
-        complicated
-        , boost::mpl::type_list<simple const&>
-        , boost::python::objects::value_holder_generator>());
-    
-    m1.add(manager, "init1");
+    class_<A>(m1, "A")
+        .def_init()
+        .def(&A::name, "name")
+        ;
+          
+    class_<B,bases<A> >(m1, "B")
+        .def_init()
+        .def(&B::name, "name")
+        ;
+          
+    class_<C,bases<A> >(m1, "C")
+        .def_init()
+        .def(&C::name, "name")
+        ;
+
+    class_<D,bases<B,C> >(m1, "D")
+        .def_init()
+        .def(&D::name, "name")
+        ;
+
+    class_<complicated>(m1, "complicated")
+        .def_init(args<simple const&,int>())
+        .def_init(args<simple const&>())
+        .def(&complicated::get_n, "get_n")
+        ;
 }
 
 #include "module_tail.cpp"

From 078585db28da772b7cb1d8f31f7198f83463483e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 21 Jan 2002 06:20:15 +0000
Subject: [PATCH 226/369] fixed transfer-of-ownership counting to avoid
 problems

[SVN r12392]
---
 include/boost/python/reference.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
index f0cdab55..97edef99 100644
--- a/include/boost/python/reference.hpp
+++ b/include/boost/python/reference.hpp
@@ -173,10 +173,10 @@ public:
     void reset(T2* x, increment_count_t)
     {
         assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(x);
         Py_XDECREF(m_p);
         m_p = expect_non_null(x);
         assert(m_p->ob_refcnt > 0);
-        Py_INCREF(m_p);
     }
     
     template <class T2>
@@ -192,20 +192,20 @@ public:
     void reset(T2* x, allow_null, increment_count_t)
     {
         assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(x);
         Py_XDECREF(m_p);
         m_p = x;
         assert(m_p == 0 || m_p->ob_refcnt > 0);
-        Py_XINCREF(m_p);
     }
     
     template <class T2>
     void reset(T2* x, increment_count_t, allow_null)
     {
         assert(m_p == 0 || m_p->ob_refcnt > 0);
+        Py_XINCREF(x);
         Py_XDECREF(m_p);
         m_p = x;
         assert(m_p == 0 || m_p->ob_refcnt > 0);
-        Py_XINCREF(m_p);
     }
     
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)

From 93501af04601590e46feede4a11e03fae700d2d6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 21 Jan 2002 06:23:33 +0000
Subject: [PATCH 227/369] always use ref (counting) for safety

[SVN r12393]
---
 include/boost/python/object/class.hpp            | 4 ++--
 include/boost/python/object/class_converters.hpp | 5 +++--
 include/boost/python/object/class_wrapper.hpp    | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 808e3669..4817e15d 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -38,8 +38,8 @@ struct BOOST_PYTHON_DECL class_base : noncopyable
                                         // any bases.
         );
 
-    // Retrieve a pointer to the underlying object
-    PyObject* object() const { return m_object.get(); }
+    // Retrieve the underlying object
+    ref object() const { return m_object; }
  private:
     ref m_object;
 };
diff --git a/include/boost/python/object/class_converters.hpp b/include/boost/python/object/class_converters.hpp
index c14103b6..d4ba4b6d 100644
--- a/include/boost/python/object/class_converters.hpp
+++ b/include/boost/python/object/class_converters.hpp
@@ -9,6 +9,7 @@
 # include <boost/python/converter/class.hpp>
 # include <boost/python/object/class_wrapper.hpp>
 # include <boost/mpl/for_each.hpp>
+# include <boost/python/reference.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -20,7 +21,7 @@ struct class_converters
 {
  public: // member functions
     // Constructor takes the python class object associated with T
-    class_converters(PyObject* python_class);
+    class_converters(ref const& python_class);
 
  private: // data members
     converter::class_unwrapper<Derived> m_unwrapper;
@@ -86,7 +87,7 @@ struct register_base_of
 };
 
 template <class Derived, class Bases>
-class_converters<Derived,Bases>::class_converters(PyObject* type_object)
+class_converters<Derived,Bases>::class_converters(ref const& type_object)
     : m_wrapper(type_object)
 {
     // register all up/downcasts here
diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
index 0e49ce84..cbfb2ae6 100644
--- a/include/boost/python/object/class_wrapper.hpp
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -18,7 +18,7 @@ template <class T>
 struct class_wrapper
     : converter::wrapper<T const&>
 {
-    class_wrapper(PyObject* type_)
+    class_wrapper(ref const& type_)
         : m_class_object(type_)
     {
 # ifndef NDEBUG

From 41634f9998844058678b169b42e2eedccdb6a9c4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 21 Jan 2002 06:56:27 +0000
Subject: [PATCH 228/369] Use ref everywhere for reliability

[SVN r12394]
---
 include/boost/python/class.hpp           |  2 +-
 include/boost/python/module.hpp          |  8 ++++----
 include/boost/python/object/function.hpp |  2 +-
 src/module.cpp                           | 11 +++++++----
 src/object/function.cpp                  | 22 +++++++++++-----------
 5 files changed, 24 insertions(+), 21 deletions(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index d61a8fc0..76a74df2 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -100,7 +100,7 @@ class class_ : objects::class_base
     {
         // Use function::add_to_namespace to achieve overloading if
         // appropriate.
-        objects::function::add_to_namespace(this->object(), name, detail::wrap_function(f));
+        objects::function::add_to_namespace(this->object(), name, ref(detail::wrap_function(f)));
         return *this;
     }
 
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index 317cc5e4..318f4a64 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -25,7 +25,7 @@ class BOOST_PYTHON_DECL module_base
     // Add elements to the module
     void add(PyObject* x, const char* name);
     void add(PyTypeObject* x, const char* name = 0);
-    void add(ref x, const char*name);
+    void add(ref const& x, const char*name);
 
     // Return true iff a module is currently being built.
     static bool initializing();
@@ -35,10 +35,10 @@ class BOOST_PYTHON_DECL module_base
     static string name();
 
     // Return a pointer to the Python module object being built
-    PyObject* module() const;
+    ref module() const;
 
  private:
-    PyObject* m_module;
+    ref m_module;
     static PyMethodDef initial_methods[1];
 };
 
@@ -65,7 +65,7 @@ class module : public module_base
 //
 // inline implementations
 //
-inline PyObject* module_base::module() const
+inline ref module_base::module() const
 {
     return m_module;
 }
diff --git a/include/boost/python/object/function.hpp b/include/boost/python/object/function.hpp
index cc2695d8..c239b6e6 100644
--- a/include/boost/python/object/function.hpp
+++ b/include/boost/python/object/function.hpp
@@ -27,7 +27,7 @@ struct BOOST_PYTHON_DECL function : PyObject
     // a function object (this class), and an existing function is
     // already there, add it as an overload.
     static void add_to_namespace(
-        PyObject* name_space, char const* name, PyObject* attribute);
+        ref const& name_space, char const* name, ref const& attribute);
     
  private: // helper functions
     void argument_error(PyObject* args, PyObject* keywords) const;
diff --git a/src/module.cpp b/src/module.cpp
index 0851805f..917f8d3a 100644
--- a/src/module.cpp
+++ b/src/module.cpp
@@ -27,11 +27,14 @@ string module_base::name()
 }
 
 module_base::module_base(const char* name)
-    : m_module(Py_InitModule(const_cast<char*>(name), initial_methods))
+    : m_module(
+        Py_InitModule(const_cast<char*>(name), initial_methods)
+        , ref::increment_count)
 {
     // If this fails, you've created more than 1 module object in your module    
     assert(name_holder.get() == 0);
-    name_holder = ref(PyObject_GetAttrString(m_module, const_cast<char*>("__name__")));
+    name_holder = ref(PyObject_GetAttrString(
+                          m_module.get() , const_cast<char*>("__name__")));
 }
 
 module_base::~module_base()
@@ -44,11 +47,11 @@ void module_base::add(PyObject* x, const char* name)
     add(ref(x), name);
 }
 
-void module_base::add(ref x, const char* name)
+void module_base::add(ref const& x, const char* name)
 {
     // Use function::add_to_namespace to achieve overloading if
     // appropriate.
-    objects::function::add_to_namespace(m_module, name, x.get());
+    objects::function::add_to_namespace(m_module, name, x);
 }
 
 void module_base::add(PyTypeObject* x, const char* name /*= 0*/)
diff --git a/src/object/function.cpp b/src/object/function.cpp
index 3755dfb1..7878fa47 100644
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -77,21 +77,21 @@ void function::add_overload(function* overload)
 }
 
 void function::add_to_namespace(
-    PyObject* name_space, char const* name_, PyObject* attribute_)
+    ref const& name_space, char const* name_, ref const& attribute)
 {
-    ref attribute(attribute_, ref::increment_count);
-    string name(name_);
+    string const name(name_);
+    PyObject* const ns = name_space.get();
     
-    if (attribute_->ob_type == &function_type)
+    if (attribute->ob_type == &function_type)
     {
         PyObject* dict = 0;
         
-        if (PyClass_Check(name_space))
-            dict = ((PyClassObject*)name_space)->cl_dict;
-        else if (PyType_Check(name_space))
-            dict = ((PyTypeObject*)name_space)->tp_dict;
+        if (PyClass_Check(ns))
+            dict = ((PyClassObject*)ns)->cl_dict;
+        else if (PyType_Check(ns))
+            dict = ((PyTypeObject*)ns)->tp_dict;
         else
-            dict = PyObject_GetAttrString(name_space, "__dict__");
+            dict = PyObject_GetAttrString(ns, "__dict__");
 
         if (dict == 0)
             throw error_already_set();
@@ -101,14 +101,14 @@ void function::add_to_namespace(
         if (existing.get() && existing->ob_type == &function_type)
         {
             static_cast<function*>(existing.get())->add_overload(
-                static_cast<function*>(attribute_));
+                static_cast<function*>(attribute.get()));
             return;
         }
     }
     
     // The PyObject_GetAttrString() call above left an active error
     PyErr_Clear();
-    if (PyObject_SetAttr(name_space, name.get(), attribute_) < 0)
+    if (PyObject_SetAttr(ns, name.get(), attribute.get()) < 0)
         throw error_already_set();
 }
 

From ed2ebc7d3d506ab8874cf0ba1f479748d1513534 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Mon, 21 Jan 2002 21:18:47 +0000
Subject: [PATCH 229/369] added: missing // after #endif

[SVN r12405]
---
 include/boost/python/object/class_wrapper.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
index cbfb2ae6..f199a99f 100644
--- a/include/boost/python/object/class_wrapper.hpp
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -23,7 +23,7 @@ struct class_wrapper
     {
 # ifndef NDEBUG
         assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
-# endif NDEBUG 
+# endif // NDEBUG 
     }
     
     PyObject* convert(T const& x) const

From 98a1329dd72525920c3edfc19f06b5ea2db418e3 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Tue, 22 Jan 2002 01:43:40 +0000
Subject: [PATCH 230/369] default argument moved to declaration.

[SVN r12414]
---
 include/boost/python/class.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 76a74df2..abd38d82 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -90,7 +90,7 @@ class class_ : objects::class_base
  public:
 
     // Construct with the module and class name
-    class_(module&, char const* name);
+    class_(module&, char const* name = typeid(T).name());
 
     // Wrap a member function or a non-member function which can take
     // a T, T cv&, or T cv* as its first parameter, or a callable
@@ -152,7 +152,7 @@ class class_ : objects::class_base
 //
 template <class T, class Bases, class HolderGenerator>
 inline class_<T, Bases, HolderGenerator>::class_(
-    module& m, char const* name = typeid(T).name())
+    module& m, char const* name)
     : class_base(m, name, id_vector::size, id_vector().ids)
 {
     // Bring the class converters into existence. This static object

From 996d83eae0638804dc51158a3ec315507e7aee61 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Jan 2002 02:32:48 +0000
Subject: [PATCH 231/369] fix for EDG

[SVN r12415]
---
 include/boost/python/class.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index abd38d82..25815acc 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -127,6 +127,7 @@ class class_ : objects::class_base
     // passed to the base class constructor
     struct id_vector
     {
+        typedef objects::class_id class_id;
         id_vector()
         {
             // Stick the derived class id into the first element of the array

From 248985e51a080ba328e48b8ce0fa30bba5c27bfe Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Jan 2002 13:12:41 +0000
Subject: [PATCH 232/369] ICL compatibility

[SVN r12435]
---
 src/object/inheritance.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/object/inheritance.cpp b/src/object/inheritance.cpp
index 5b95e478..7efc980c 100644
--- a/src/object/inheritance.cpp
+++ b/src/object/inheritance.cpp
@@ -109,7 +109,7 @@ namespace
                               make_iterator_property_map(
                                   to_target
                                   , get(vertex_index, reverse_topology)
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# ifdef BOOST_MSVC_STD_ITERATOR
                                   , *to_target
 # endif 
                                   )

From 51a66a32028d68c04d91470305a666120405013c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Jan 2002 13:52:05 +0000
Subject: [PATCH 233/369] Fixes for gcc-2.95.3

[SVN r12442]
---
 include/boost/python/class.hpp | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 25815acc..3b20406e 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -89,8 +89,15 @@ class class_ : objects::class_base
     typedef class_<T,Bases,HolderGenerator> self;
  public:
 
-    // Construct with the module and class name
-    class_(module&, char const* name = typeid(T).name());
+    // Construct with the module and automatically derive the class
+    // name
+    class_(module&);
+    
+    // Construct with the module and class name.  [ Would have used a
+    // default argument but gcc-2.95.2 choked on typeid(T).name() as a
+    // default parameter value]
+    class_(module&, char const* name);
+
 
     // Wrap a member function or a non-member function which can take
     // a T, T cv&, or T cv* as its first parameter, or a callable
@@ -100,7 +107,8 @@ class class_ : objects::class_base
     {
         // Use function::add_to_namespace to achieve overloading if
         // appropriate.
-        objects::function::add_to_namespace(this->object(), name, ref(detail::wrap_function(f)));
+        objects::function::add_to_namespace(
+            this->object(), name, ref(detail::wrap_function(f)));
         return *this;
     }
 
@@ -151,6 +159,17 @@ class class_ : objects::class_base
 //
 // implementations
 //
+template <class T, class Bases, class HolderGenerator>
+inline class_<T, Bases, HolderGenerator>::class_(
+    module& m)
+    : class_base(m, typeid(T).name(), id_vector::size, id_vector().ids)
+{
+    // Bring the class converters into existence. This static object
+    // will survive until the shared library this module lives in is
+    // unloaded (that doesn't happen until Python terminates).
+    static objects::class_converters<T,Bases> converters(object());
+}
+
 template <class T, class Bases, class HolderGenerator>
 inline class_<T, Bases, HolderGenerator>::class_(
     module& m, char const* name)

From 0389aab0a33211c99fac0986930ab0a037fb74e5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Jan 2002 19:51:04 +0000
Subject: [PATCH 234/369] Nicer syntactic sugar

[SVN r12447]
---
 include/boost/python/class.hpp        | 40 +++++++++-------
 include/boost/python/module.hpp       | 67 +++++++++++++++++++++------
 include/boost/python/object/class.hpp |  3 +-
 src/module.cpp                        | 37 +++++----------
 src/object/class.cpp                  |  8 ++--
 5 files changed, 90 insertions(+), 65 deletions(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 3b20406e..0f8d2a69 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -6,7 +6,6 @@
 #ifndef CLASS_DWA200216_HPP
 # define CLASS_DWA200216_HPP
 
-# include <boost/python/module.hpp>
 # include <boost/python/reference.hpp>
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
@@ -84,26 +83,26 @@ template <
     , class Bases = mpl::type_list<>::type
     , class HolderGenerator = objects::value_holder_generator
     >
-class class_ : objects::class_base
+class class_ : private objects::class_base
 {
     typedef class_<T,Bases,HolderGenerator> self;
  public:
 
-    // Construct with the module and automatically derive the class
-    // name
-    class_(module&);
+    // Automatically derive the class name - only works on some
+    // compilers because type_info::name is sometimes mangled (gcc)
+    class_();
     
-    // Construct with the module and class name.  [ Would have used a
-    // default argument but gcc-2.95.2 choked on typeid(T).name() as a
-    // default parameter value]
-    class_(module&, char const* name);
+    // Construct with the class name.  [ Would have used a default
+    // argument but gcc-2.95.2 choked on typeid(T).name() as a default
+    // parameter value]
+    class_(char const* name);
 
 
     // Wrap a member function or a non-member function which can take
     // a T, T cv&, or T cv* as its first parameter, or a callable
     // python object.
     template <class F>
-    self& def(F f, char const* name)
+    self& def(char const* name, F f)
     {
         // Use function::add_to_namespace to achieve overloading if
         // appropriate.
@@ -117,7 +116,7 @@ class class_ : objects::class_base
     template <class Args>
     self& def_init(Args const& = Args())
     {
-        def(make_constructor<T,Args,HolderGenerator>(), "__init__");
+        def("__init__", make_constructor<T,Args,HolderGenerator>());
         return *this;
     }
 
@@ -128,6 +127,9 @@ class class_ : objects::class_base
         return *this;
     }
 
+    // return the underlying object
+    ref object() const;
+
  private: // types
     typedef objects::class_id class_id;
     
@@ -160,9 +162,8 @@ class class_ : objects::class_base
 // implementations
 //
 template <class T, class Bases, class HolderGenerator>
-inline class_<T, Bases, HolderGenerator>::class_(
-    module& m)
-    : class_base(m, typeid(T).name(), id_vector::size, id_vector().ids)
+inline class_<T, Bases, HolderGenerator>::class_()
+    : class_base(typeid(T).name(), id_vector::size, id_vector().ids)
 {
     // Bring the class converters into existence. This static object
     // will survive until the shared library this module lives in is
@@ -171,9 +172,8 @@ inline class_<T, Bases, HolderGenerator>::class_(
 }
 
 template <class T, class Bases, class HolderGenerator>
-inline class_<T, Bases, HolderGenerator>::class_(
-    module& m, char const* name)
-    : class_base(m, name, id_vector::size, id_vector().ids)
+inline class_<T, Bases, HolderGenerator>::class_(char const* name)
+    : class_base(name, id_vector::size, id_vector().ids)
 {
     // Bring the class converters into existence. This static object
     // will survive until the shared library this module lives in is
@@ -181,6 +181,12 @@ inline class_<T, Bases, HolderGenerator>::class_(
     static objects::class_converters<T,Bases> converters(object());
 }
 
+template <class T, class Bases, class HolderGenerator>
+inline ref class_<T, Bases, HolderGenerator>::object() const
+{
+    return this->class_base::object();
+}
+
 }} // namespace boost::python
 
 #endif // CLASS_DWA200216_HPP
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index 318f4a64..a6a3a8e7 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -15,6 +15,8 @@
 
 namespace boost { namespace python {
 
+template <class T, class Bases, class HolderGenerator> class class_;
+
 class BOOST_PYTHON_DECL module_base
 {
  public:
@@ -23,18 +25,12 @@ class BOOST_PYTHON_DECL module_base
     ~module_base();
 
     // Add elements to the module
-    void add(PyObject* x, const char* name);
-    void add(PyTypeObject* x, const char* name = 0);
-    void add(ref const& x, const char*name);
-
-    // Return true iff a module is currently being built.
-    static bool initializing();
+    void setattr(const char* name, PyObject*);
+    void setattr(const char* name, ref const&);
+    void add(PyTypeObject* x); // just use the type's name
+    void add_type(ref);
     
-    // 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
+    // Return a reference to the Python module object being built
     ref module() const;
 
  private:
@@ -48,17 +44,34 @@ class module : public module_base
     module(const char* name)
         : module_base(name) {}
 
+    // Add elements to the module
+    module& setattr(const char* name, PyObject*);
+    module& setattr(const char* name, PyTypeObject*);
+    module& setattr(const char* name, ref const&);
+    module& add(PyTypeObject* x); // just use the type's name
+    
+    template <class T, class Bases, class HolderGenerator>
+    module& add(class_<T,Bases,HolderGenerator> const& c)
+    {
+        std::cout << "adding " << typeid(T).name() << " to module" << std::endl << std::flush;
+        Py_INCREF(c.object());
+        this->add_type(c.object());
+        return *this;
+    }
+    
 # if 0
     template <class Fn>
-    void def_raw(Fn fn, const char* name)
+    void def_raw(char const* name, Fn fn)
     {
         add(detail::new_raw_arguments_function(fn), name);
     }
-# endif 
+# endif
+    
     template <class Fn>
-    void def(Fn fn, const char* name)
+    module& def(char const* name, Fn fn)
     {
-        this->add(boost::python::make_function(fn), name);
+        this->setattr(name, boost::python::make_function(fn));
+        return *this;
     }
 };
 
@@ -70,6 +83,30 @@ inline ref module_base::module() const
     return m_module;
 }
 
+inline module& module::setattr(const char* name, PyObject* x)
+{
+    this->module_base::setattr(name, x);
+    return *this;
+}
+
+inline module& module::setattr(const char* name, PyTypeObject* x)
+{
+    this->module_base::setattr(name, (PyObject*)x);
+    return *this;
+}
+
+inline module& module::setattr(const char* name, ref const& x)
+{
+    this->module_base::setattr(name, x);
+    return *this;
+}
+
+inline module& module::add(PyTypeObject* x)
+{
+    this->module_base::add(x);
+    return *this;
+}
+
 }} // namespace boost::python
 
 #endif // MODULE_DWA20011221_HPP
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 4817e15d..53d886fa 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -30,8 +30,7 @@ struct BOOST_PYTHON_DECL class_base : noncopyable
 {
     // constructor
     class_base(
-        module& name_space              // Which name space the class will live in
-        , char const* name              // The name of the class
+        char const* name              // The name of the class
         
         , std::size_t num_types         // A list of class_ids. The first is the type
         , class_id const*const types    // this is wrapping. The rest are the types of
diff --git a/src/module.cpp b/src/module.cpp
index 917f8d3a..dbc81729 100644
--- a/src/module.cpp
+++ b/src/module.cpp
@@ -10,53 +10,38 @@
 
 namespace boost { namespace python {
 
-namespace {
-  ref name_holder;
-}
-
-bool module_base::initializing()
-{
-    return name_holder.get() != 0;
-}
-
-string module_base::name()
-{
-    // If this fails, you haven't created a module object
-    assert(initializing());
-    return string(name_holder);
-}
-
 module_base::module_base(const char* name)
     : m_module(
         Py_InitModule(const_cast<char*>(name), initial_methods)
         , ref::increment_count)
 {
-    // If this fails, you've created more than 1 module object in your module    
-    assert(name_holder.get() == 0);
-    name_holder = ref(PyObject_GetAttrString(
-                          m_module.get() , const_cast<char*>("__name__")));
 }
 
 module_base::~module_base()
 {
-    name_holder.reset();
 }
 
-void module_base::add(PyObject* x, const char* name)
+void module_base::setattr(const char* name, PyObject* x)
 {
-    add(ref(x), name);
+    setattr(name, ref(x));
 }
 
-void module_base::add(ref const& x, const char* name)
+void module_base::setattr(char const* name, ref const& x)
 {
     // Use function::add_to_namespace to achieve overloading if
     // appropriate.
     objects::function::add_to_namespace(m_module, name, x);
 }
 
-void module_base::add(PyTypeObject* x, const char* name /*= 0*/)
+void module_base::add(PyTypeObject* x)
 {
-    this->add((PyObject*)x, name ? name : x->tp_name);
+    this->setattr(x->tp_name, (PyObject*)x);
+}
+
+void module_base::add_type(ref x)
+{
+    assert(PyObject_TypeCheck(x.get(), &PyType_Type));
+    add((PyTypeObject*)x.release());
 }
 
 PyMethodDef module_base::initial_methods[] = { { 0, 0, 0, 0 } };
diff --git a/src/object/class.cpp b/src/object/class.cpp
index 5ebabba1..b928ba66 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -11,7 +11,6 @@
 #include <boost/python/detail/map_entry.hpp>
 #include <boost/detail/binary_search.hpp>
 #include <boost/bind.hpp>
-#include <boost/python/detail/wrap_python.hpp>
 #include <functional>
 #include <vector>
 
@@ -190,11 +189,11 @@ namespace
 
       std::vector<entry>::const_iterator p
           = boost::detail::lower_bound(start, finish, id);
-      
+
       if (p == finish && p->key != id)
       {
           string report("extension class wrapper for base class ");
-          (report += id.name()) += "has not been created yet";
+          (report += id.name()) += " has not been created yet";
           PyErr_SetObject(PyExc_RuntimeError, report.get());
           throw error_already_set();
       }
@@ -212,7 +211,7 @@ namespace
 }
 
 class_base::class_base(
-    module& m, char const* name, std::size_t num_types, class_id const* const types)
+    char const* name, std::size_t num_types, class_id const* const types)
 {
     class_registry& r = registry();
     assert(num_types >= 1);
@@ -234,7 +233,6 @@ class_base::class_base(
     
     m_object = ref(PyObject_CallObject(class_metatype().get(), args.get()));
     r.set(types[0], m_object);
-    m.add(m_object, name);
 }
 
 }}} // namespace boost::python::objects

From f2785302392eaf4e1b26c5fed8e3d52f9d48e052 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Jan 2002 19:56:36 +0000
Subject: [PATCH 235/369] Nicer syntactic sugar

[SVN r12448]
---
 test/m1.cpp | 93 +++++++++++++++++++++++++++++------------------------
 test/m2.cpp | 28 ++++++++--------
 2 files changed, 65 insertions(+), 56 deletions(-)

diff --git a/test/m1.cpp b/test/m1.cpp
index da3ca5d5..7f88af2b 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -269,7 +269,6 @@ BOOST_PYTHON_MODULE_INIT(m1)
     using boost::python::module;
     using boost::python::class_;
     
-    module m1("m1");
     // Create the converters; they are self-registering/unregistering.
     static int_wrapper wrap_int;
     static simple_wrapper wrap_simple;
@@ -280,56 +279,66 @@ BOOST_PYTHON_MODULE_INIT(m1)
     static simple_const_ref_unwrapper unwrap_simple_const_ref;
     static simple_ref_wrapper wrap_simple_ref;
 
-    // This unwrapper extracts pointers and references to the "complicated" class.
-    //    static boost::python::converter::class_unwrapper<complicated> unwrap_complicated;
+    module m1("m1");
+
+    m1
+      // Insert the metaclass for all extension classes
+      .setattr("xclass", boost::python::objects::class_metatype())
     
-    // Insert the extension metaclass object
-    m1.add(
-        boost::python::objects::class_metatype()
-        , "xclass");
-    
-    // Insert the base class for all extension classes
-    m1.add(boost::python::objects::class_type()
-           , "xinst");
+      // Insert the base class for all extension classes
+      .setattr("xinst", boost::python::objects::class_type())
 
-    m1.def(new_noddy, "new_noddy");
-    m1.def(new_simple, "new_simple");
-    
-    // Expose f()
-    m1.def(f, "f");
+      .def("new_noddy", new_noddy)
+      .def("new_simple", new_simple)
 
-    // Expose g()
-    m1.def(g, "g");
+      // Expose f()
+      .def("f", f)
 
-    m1.def(take_a, "take_a");
-    m1.def(take_b, "take_b");
-    m1.def(take_c, "take_c");
-    m1.def(take_d, "take_d");
+      // Expose g()
+      .def("g", g)
 
-    class_<A>(m1, "A")
-        .def_init()
-        .def(&A::name, "name")
-        ;
-          
-    class_<B,bases<A> >(m1, "B")
-        .def_init()
-        .def(&B::name, "name")
-        ;
-          
-    class_<C,bases<A> >(m1, "C")
-        .def_init()
-        .def(&C::name, "name")
+      .def("take_a", take_a)
+      .def("take_b", take_b)
+      .def("take_c", take_c)
+      .def("take_d", take_d)
+
+      .add(
+          class_<A>("A")
+          .def_init()
+          .def("name", &A::name)
+          )
+        
         ;
 
-    class_<D,bases<B,C> >(m1, "D")
-        .def_init()
-        .def(&D::name, "name")
+    // sequence points don't ensure that "A" is constructed before "B"
+    // or "C" below if we make them part of the same chain
+    m1
+        .add(
+            class_<B,bases<A> >("B")
+            .def_init()
+            .def("name", &B::name)
+            )
+        
+        .add(
+            class_<C,bases<A> >("C")
+            .def_init()
+            .def("name", &C::name)
+            )
         ;
 
-    class_<complicated>(m1, "complicated")
-        .def_init(args<simple const&,int>())
-        .def_init(args<simple const&>())
-        .def(&complicated::get_n, "get_n")
+    m1
+        .add(
+            class_<D,bases<B,C> >("D")
+            .def_init()
+            .def("name", &D::name)
+            )
+
+        .add(
+            class_<complicated>("complicated")
+            .def_init(args<simple const&,int>())
+            .def_init(args<simple const&>())
+            .def("get_n", &complicated::get_n)
+            )
         ;
 }
 
diff --git a/test/m2.cpp b/test/m2.cpp
index 7ea1f9ac..d70b0c13 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -66,21 +66,21 @@ struct rewrap
 
 BOOST_PYTHON_MODULE_INIT(m2)
 {
-    boost::python::module m2("m2");
-    
-    m2.def(unwrap_int, "unwrap_int");
-    m2.def(unwrap_int_ref, "unwrap_int_ref");
-    m2.def(unwrap_int_const_ref, "unwrap_int_const_ref");
-    m2.def(unwrap_simple, "unwrap_simple");
-    m2.def(unwrap_simple_ref, "unwrap_simple_ref");
-    m2.def(unwrap_simple_const_ref, "unwrap_simple_const_ref");
+    boost::python::module("m2")
+        .def("unwrap_int", unwrap_int)
+        .def("unwrap_int_ref", unwrap_int_ref)
+        .def("unwrap_int_const_ref", unwrap_int_const_ref)
+        .def("unwrap_simple", unwrap_simple)
+        .def("unwrap_simple_ref", unwrap_simple_ref)
+        .def("unwrap_simple_const_ref", unwrap_simple_const_ref)
 
-    m2.def(&rewrap<int>::f, "wrap_int");
-    m2.def(&rewrap<int&>::f, "wrap_int_ref");
-    m2.def(&rewrap<int const&>::f, "wrap_int_const_ref");
-    m2.def(&rewrap<simple>::f, "wrap_simple");
-    m2.def(&rewrap<simple&>::f, "wrap_simple_ref");
-    m2.def(&rewrap<simple const&>::f, "wrap_simple_const_ref");
+        .def("wrap_int", &rewrap<int>::f)
+        .def("wrap_int_ref", &rewrap<int&>::f)
+        .def("wrap_int_const_ref", &rewrap<int const&>::f)
+        .def("wrap_simple", &rewrap<simple>::f)
+        .def("wrap_simple_ref", &rewrap<simple&>::f)
+        .def("wrap_simple_const_ref", &rewrap<simple const&>::f)
+        ;
 }
 
 #include "module_tail.cpp"

From f40a534bfb1b6aabc21b4f5075c49d31a2529c48 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 22 Jan 2002 21:55:08 +0000
Subject: [PATCH 236/369] cleanup

[SVN r12449]
---
 include/boost/python/module.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index a6a3a8e7..5661e106 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -53,7 +53,6 @@ class module : public module_base
     template <class T, class Bases, class HolderGenerator>
     module& add(class_<T,Bases,HolderGenerator> const& c)
     {
-        std::cout << "adding " << typeid(T).name() << " to module" << std::endl << std::flush;
         Py_INCREF(c.object());
         this->add_type(c.object());
         return *this;

From 088b1cab833fea1852fc72ed688d14708ef84df5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 23 Jan 2002 06:08:46 +0000
Subject: [PATCH 237/369] workarounds for KCC's reservation of 'overload' as a
 keyword

[SVN r12451]
---
 include/boost/python/object/function.hpp | 2 +-
 src/object/function.cpp                  | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/object/function.hpp b/include/boost/python/object/function.hpp
index c239b6e6..2a05a946 100644
--- a/include/boost/python/object/function.hpp
+++ b/include/boost/python/object/function.hpp
@@ -31,7 +31,7 @@ struct BOOST_PYTHON_DECL function : PyObject
     
  private: // helper functions
     void argument_error(PyObject* args, PyObject* keywords) const;
-    void add_overload(function* overload);
+    void add_overload(function*);
     
  private: // data members
     py_function m_fn;
diff --git a/src/object/function.cpp b/src/object/function.cpp
index 7878fa47..a30e9f15 100644
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -63,9 +63,9 @@ void function::argument_error(PyObject* args, PyObject* keywords) const
     PyErr_BadArgument();
 }
 
-void function::add_overload(function* overload)
+void function::add_overload(function* overload_)
 {
-    Py_XINCREF(overload);
+    Py_XINCREF(overload_);
     
     function* parent = this;
     
@@ -73,7 +73,7 @@ void function::add_overload(function* overload)
     {
         parent = parent->m_overloads;
     }
-    parent->m_overloads = overload;
+    parent->m_overloads = overload_;
 }
 
 void function::add_to_namespace(

From 71032f6c4c0887834d4657b3405729b149810911 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 30 Jan 2002 20:18:39 +0000
Subject: [PATCH 238/369] New conversion mechanism, builtin converters

[SVN r12590]
---
 Jamfile                                       |  65 +-
 include/boost/python/converter/class.hpp      |  89 +-
 .../boost/python/converter/registration.hpp   |  94 +-
 include/boost/python/converter/registry.hpp   |  43 +-
 include/boost/python/converter/source.hpp     |  10 +-
 include/boost/python/converter/unwrap.hpp     |   6 +-
 include/boost/python/converter/unwrapper.hpp  |   3 +-
 include/boost/python/converter/wrap.hpp       |   1 +
 include/boost/python/converter/wrapper.hpp    |   1 +
 .../boost/python/detail/arg_tuple_size.hpp    |  12 +-
 include/boost/python/detail/char_array.hpp    |  23 +
 include/boost/python/detail/eval.hpp          |  38 +
 include/boost/python/detail/returning.hpp     | 876 ++++++++++--------
 include/boost/python/detail/signature.hpp     | 217 +++++
 include/boost/python/make_function.hpp        |   7 +
 .../boost/python/object/class_converters.hpp  |   2 +-
 include/boost/python/object/class_wrapper.hpp |  19 +-
 include/boost/python/object/make_holder.hpp   |  36 +-
 include/boost/python/object/value_holder.hpp  |  93 +-
 include/boost/python/objects.hpp              |   4 +-
 src/converter/registry.cpp                    | 111 ++-
 src/gen_arg_tuple_size.py                     |  12 +-
 src/gen_signature.py                          |  90 ++
 src/gen_value_holder.py                       |  35 +
 src/object/class.cpp                          |   2 +-
 test/m1.cpp                                   | 180 ++--
 test/m2.cpp                                   |   4 -
 27 files changed, 1352 insertions(+), 721 deletions(-)
 create mode 100644 include/boost/python/detail/char_array.hpp
 create mode 100644 include/boost/python/detail/eval.hpp
 create mode 100644 include/boost/python/detail/signature.hpp
 create mode 100644 src/gen_signature.py
 create mode 100644 src/gen_value_holder.py

diff --git a/Jamfile b/Jamfile
index 71e0c5b7..684c21d5 100644
--- a/Jamfile
+++ b/Jamfile
@@ -8,36 +8,47 @@ PYTHON_PROPERTIES
   += <metrowerks><*><cxxflags>"-inline deferred" 
   <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
     <define>BOOST_PYTHON_DYNAMIC_LIB
-      <define>BOOST_PYTHON_V2
-  ;
+    <define>BOOST_PYTHON_V2
+    ;
 
+{
+    dll bpl
+      : 
+      src/converter/from_python.cpp
+      src/converter/to_python.cpp
+      src/converter/registry.cpp
+      src/converter/type_id.cpp
+      src/object/class.cpp
+      src/object/function.cpp
+      src/object/inheritance.cpp
+      src/errors.cpp
+      src/module.cpp
+      src/objects.cpp
+      src/converter/builtin_converters.cpp
+      :
+      $(PYTHON_PROPERTIES)
+        <define>BOOST_PYTHON_SOURCE
+        ;
 
-dll bpl
-  : 
-    src/converter/body.cpp
-    src/converter/handle.cpp
-    src/converter/registry.cpp
-    src/converter/wrapper.cpp
-    src/converter/unwrap.cpp
-    src/converter/unwrapper.cpp
-    src/converter/type_id.cpp
-    src/object/class.cpp
-    src/object/function.cpp
-    src/object/inheritance.cpp
-    src/errors.cpp
-    src/module.cpp
-    src/objects.cpp
-    :
-  $(PYTHON_PROPERTIES)
-    <define>BOOST_PYTHON_SOURCE
-  ;
+    extension m1 : test/m1.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
+      : 
+      : debug-python
+      ;
 
-extension m1 : test/m1.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
-    : 
-    : debug-python ;
-
-extension m2 : test/m2.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
+    extension m2 : test/m2.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
       : 
       : debug-python ;
 
-boost-python-runtest try : test/newtest.py <lib>m1 <lib>m2 : : debug-python ;
\ No newline at end of file
+    boost-python-runtest try : test/newtest.py <lib>m1 <lib>m2 : : debug-python ;
+
+    extension builtin_converters_ext : test/test_builtin_converters.cpp <lib>bpl
+      :
+      : debug-python
+      ;
+
+    boost-python-runtest test_builtin_converters : test/test_builtin_converters.py
+      <lib>builtin_converters_ext
+      :
+      : debug-python
+      ;
+}
diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
index f437a73a..67de6fad 100644
--- a/include/boost/python/converter/class.hpp
+++ b/include/boost/python/converter/class.hpp
@@ -7,62 +7,69 @@
 # define CLASS_DWA20011215_HPP
 
 # include <boost/python/object/class.hpp>
-# include <boost/python/converter/unwrapper.hpp>
+# include <boost/python/converter/from_python.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
 template <class T>
-struct class_unwrapper
-    : private unwrapper<T&>
-    , private unwrapper<T const&>
-    , private unwrapper<T*>
-    , private unwrapper<T const*>
+struct class_from_python_converter
 {
- protected:
-# ifdef __GNUC__ // suppress warning that "all member functions are private" (duh)
-    void uncallable();
-# endif 
- private:
-    void* can_convert(PyObject*) const;
-    T& convert(PyObject*, void*, boost::type<T&>) const;
-    T const& convert(PyObject*, void*, boost::type<T const&>) const;
-    T* convert(PyObject*, void*, boost::type<T*>) const;
-    T const* convert(PyObject*, void*, boost::type<T const*>) const;
+    class_from_python_converter();
+    
+    static void* convertible(PyObject*);
+    static T& convert_ref(PyObject*, from_python_data&);
+    static T const& convert_cref(PyObject*, from_python_data&);
+    static T* convert_ptr(PyObject*, from_python_data&);
+    static T const* convert_cptr(PyObject*, from_python_data&);
+
+    from_python_converter<T&> to_ref;
+    from_python_converter<T const&> to_cref;
+    from_python_converter<T*> to_ptr;
+    from_python_converter<T const*> to_cptr;
 };
 
 //
 // implementations
 //
 template <class T>
-void* class_unwrapper<T>::can_convert(PyObject* p) const
+class_from_python_converter<T>::class_from_python_converter()
+    : to_ref(convertible, convert_ref)
+      , to_cref(convertible, convert_cref)
+      , to_ptr(convertible, convert_ptr)
+      , to_cptr(convertible, convert_cptr)
+{}
+
+template <class T>
+T& class_from_python_converter<T>::convert_ref(PyObject*, from_python_data& x)
+{
+    return *static_cast<T*>(x.stage1);
+}
+
+template <class T>
+T const& class_from_python_converter<T>::convert_cref(PyObject*, from_python_data& x)
+{
+    return *static_cast<T*>(x.stage1);
+}
+    
+
+template <class T>
+T* class_from_python_converter<T>::convert_ptr(PyObject*, from_python_data& x)
+{
+    return static_cast<T*>(x.stage1);
+}
+
+template <class T>
+T const* class_from_python_converter<T>::convert_cptr(PyObject*, from_python_data& x)
+{
+    return static_cast<T*>(x.stage1);
+}
+
+template <class T>
+void* class_from_python_converter<T>::convertible(PyObject* p)
 {
     return objects::find_instance<T>(p);
 }
 
-template <class T>
-T& class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T&>) const
-{
-    return *static_cast<T*>(found);
-}
-
-template <class T>
-T const& class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T const&>) const
-{
-    return *static_cast<T*>(found);
-}
-
-template <class T>
-T* class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T*>) const
-{
-    return static_cast<T*>(found);
-}
-
-template <class T>
-T const* class_unwrapper<T>::convert(PyObject*, void* found, boost::type<T const*>) const
-{
-    return static_cast<T*>(found);
-}
-
 }}} // namespace boost::python::converter
 
 #endif // CLASS_DWA20011215_HPP
diff --git a/include/boost/python/converter/registration.hpp b/include/boost/python/converter/registration.hpp
index b8a6326b..39223d8a 100644
--- a/include/boost/python/converter/registration.hpp
+++ b/include/boost/python/converter/registration.hpp
@@ -9,6 +9,9 @@
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/config.hpp>
+# include <boost/mpl/pop_front.hpp>
+# include <boost/mpl/for_each.hpp>
+# include <boost/mpl/front.hpp>
 # include <utility>
 # ifdef BOOST_PYTHON_TRACE
 #  include <iostream>
@@ -16,8 +19,9 @@
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_DECL wrapper_base;
-struct BOOST_PYTHON_DECL unwrapper_base;
+template <class T> struct from_python_converter;
+template <class T> struct target;
+template <class T> struct source;
 
 // This class is really sort of a "templated namespace". It manages a
 // static data member which refers to the registry entry for T. This
@@ -28,21 +32,74 @@ struct registration
 {
  public: // member functions
     // Return a converter which can convert the given Python object to
-    // T, or 0 if no such converter exists
-    static std::pair<unwrapper_base*,void*> unwrapper(PyObject*);
+    // T, or 0 if no such converter exists. Fill in data with
+    // the result of the converter's check function
+    static from_python_converter<T> const* get_from_python(PyObject*, void*& data);
 
     // Return a converter which can convert T to a Python object, or 0
     // if no such converter exists
-    static wrapper_base* wrapper();
+    static to_python_function<T>::type get_to_python();
 
+    static registry::entry* find_entry();
  private: // helper functions
     static registry::entry* entry();
-    static registry::entry* find_entry();
+    static registry::entry* known_entry();
     
  private: // data members
     static registry::entry* m_registry_entry;
 };
 
+namespace detail
+{
+  // An MPL BinaryMetaFunction class which initializes the
+  // registration entry for the target type of its 2nd argument.
+  struct setup_target_registration
+  {
+      template <class Ignored, class T> struct apply
+      {
+          typedef T type;
+          static void execute()
+          {
+              typedef typename target<T>::type target_t;
+              registration<target_t>::find_entry();
+          }
+      };
+  };
+
+  template <class T>
+  struct find_return_value_entry
+  {
+      static void execute() { registration<T>::find_entry(); }
+  };
+
+  template <>
+  struct find_return_value_entry<void>
+  {
+      static void execute() {}
+  };
+  
+# if !defined(BOOST_MSVC) || BOOST_MSVC > 1200
+  template <>
+  struct find_return_value_entry<void const>
+  {
+      static void execute() {}
+  };
+# endif 
+}
+
+template <class Sequence>
+void acquire_registrations(Sequence signature)
+{
+    typedef typename mpl::pop_front<Sequence>::sequence args;
+    typedef typename mpl::front<Sequence>::type return_type;
+    
+    mpl::for_each<args, void, detail::setup_target_registration>::execute();
+    
+    typedef typename source<return_type>::type return_source_type;
+    detail::find_return_value_entry<return_source_type>::execute();
+}
+  
+
 // because this is static POD data it will be initialized to zero
 template <class T>
 registry::entry* registration<T>::m_registry_entry;
@@ -50,33 +107,40 @@ registry::entry* registration<T>::m_registry_entry;
 template <class T>
 registry::entry* registration<T>::find_entry()
 {
-    return registry::find(type_id<T>());
+    return m_registry_entry = registry::find(type_id<T>());
 }
 
 template <class T>
 inline registry::entry* registration<T>::entry()
 {
     if (!m_registry_entry)
-        m_registry_entry = find_entry();
+        find_entry();
     return m_registry_entry;
 }
 
 template <class T>
-std::pair<unwrapper_base*,void*> registration<T>::unwrapper(PyObject* p)
+inline registry::entry* registration<T>::known_entry()
 {
-# ifdef BOOST_PYTHON_TRACE
-    std::cout << "retrieving unwrapper for " << type_id<T>() << std::endl;
-# endif 
-    return entry()->unwrapper(p);
+    assert(m_registry_entry != 0);
+    return m_registry_entry;
 }
 
 template <class T>
-wrapper_base* registration<T>::wrapper()
+from_python_converter<T> const* registration<T>::get_from_python(PyObject* p, void*& data)
+{
+    return static_cast<from_python_converter<T> const*>(
+        known_entry()->get_from_python(p, data)
+        );
+}
+
+template <class T>
+typename to_python_function<T>::type registration<T>::get_to_python()
 {
 # ifdef BOOST_PYTHON_TRACE
     std::cout << "retrieving wrapper for " << type_id<T>() << std::endl;
 # endif 
-    return entry()->wrapper();
+    return reinterpret_cast<to_python_function<T>::type>(
+        known_entry()->get_to_python());
 }
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/registry.hpp b/include/boost/python/converter/registry.hpp
index 2023a732..21f31692 100644
--- a/include/boost/python/converter/registry.hpp
+++ b/include/boost/python/converter/registry.hpp
@@ -8,14 +8,15 @@
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/detail/config.hpp>
-# include <list>
+# include <boost/python/converter/to_python_function.hpp>
+# include <vector>
 # include <memory>
 # include <utility>
 
 namespace boost { namespace python { namespace converter {
 
-struct BOOST_PYTHON_DECL wrapper_base;
-struct BOOST_PYTHON_DECL unwrapper_base;
+struct BOOST_PYTHON_DECL from_python_converter_base;
+struct BOOST_PYTHON_DECL to_python_converter_base;
 
 // This namespace acts as a sort of singleton
 namespace registry
@@ -31,43 +32,45 @@ namespace registry
       // Python object from_python to the C++ type with which this
       // converter is associated in the registry, or 0 if no such
       // converter exists.
-      std::pair<unwrapper_base*,void*> unwrapper(PyObject*) const;
+      from_python_converter_base const* get_from_python(PyObject*, void*& data) const;
 
-      // Return a converter appropriate for converting a C++ object
-      // whose type this entry is associated with in the registry to a
-      // Python object, or 0 if no such converter exists.
-      wrapper_base* wrapper() const;
+      // Return a conversion function appropriate for converting a C++
+      // object whose type this entry is associated with in the
+      // registry to a Python object, or 0 if no such converter
+      // exists. This function must be reinterpret_cast to the
+      // appropriate to_python_function type.
+      to_python_function_base get_to_python() const;
 
       // Conversion classes use these functions to register
       // themselves.
-      void insert(wrapper_base&);
-      void remove(wrapper_base&);
+      void insert(from_python_converter_base&);
+      void remove(from_python_converter_base&);
 
-      void insert(unwrapper_base&);
-      void remove(unwrapper_base&);
+      void insert(to_python_converter_base&);
+      void remove(to_python_converter_base&);
 
    private: // types
-      typedef std::list<unwrapper_base*> unwrappers;
+      typedef std::vector<from_python_converter_base*> from_python_converters;
       
    private: // helper functions
-      unwrappers::iterator find(unwrapper_base const&);
+      from_python_converters::iterator find(from_python_converter_base const&);
       
    private: // data members
       
       // The collection of from_python converters for the associated
       // C++ type.
-      unwrappers m_unwrappers;
+      from_python_converters m_from_python_converters;
 
       // The unique to_python converter for the associated C++ type.
-      converter::wrapper_base* m_wrapper;
+      to_python_converter_base* m_to_python_converter;
   };
 
   BOOST_PYTHON_DECL entry* find(type_id_t);
   
-  BOOST_PYTHON_DECL void insert(wrapper_base& x);
-  BOOST_PYTHON_DECL void insert(unwrapper_base& x);
-  BOOST_PYTHON_DECL void remove(wrapper_base& x);
-  BOOST_PYTHON_DECL void remove(unwrapper_base& x);
+  BOOST_PYTHON_DECL void insert(to_python_converter_base& x);
+  BOOST_PYTHON_DECL void insert(from_python_converter_base& x);
+  BOOST_PYTHON_DECL void remove(to_python_converter_base& x);
+  BOOST_PYTHON_DECL void remove(from_python_converter_base& x);
 }
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/source.hpp b/include/boost/python/converter/source.hpp
index 94fdc5b8..9abf245f 100644
--- a/include/boost/python/converter/source.hpp
+++ b/include/boost/python/converter/source.hpp
@@ -20,15 +20,11 @@ namespace boost { namespace python { namespace converter {
 template <class T>
 struct source
 {
-    BOOST_STATIC_CONSTANT(bool, use_identity = (::boost::is_pointer<T>::value));
-
-    typedef typename mpl::select_type<
-        use_identity
-        , T
-        , typename add_reference<
+    typedef
+        typename add_reference<
                 typename add_const<T>::type
           >::type
-    >::type type;
+    type;
 };
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
index 3380d49d..eccb0992 100644
--- a/include/boost/python/converter/unwrap.hpp
+++ b/include/boost/python/converter/unwrap.hpp
@@ -1,3 +1,4 @@
+#error obsolete 
 // Copyright David Abrahams 2001. Permission to copy, use,
 // modify, sell and distribute this software is granted provided this
 // copyright notice appears in all copies. This software is provided
@@ -27,9 +28,10 @@ struct BOOST_PYTHON_DECL unwrap_base : handle
     inline unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*>);
     inline PyObject* source() const;
     
+    inline void*& data();
+    
  protected:
     inline PyObject*& source();
-    inline void* data() const;
         
  private: // data members
     PyObject* m_source;
@@ -117,7 +119,7 @@ inline unwrap_base::unwrap_base(PyObject* source, std::pair<unwrapper_base*,void
 {
 }
 
-inline void* unwrap_base::data() const
+inline void*& unwrap_base::data()
 {
     return m_data;
 }
diff --git a/include/boost/python/converter/unwrapper.hpp b/include/boost/python/converter/unwrapper.hpp
index 7f0609cf..8a16e957 100644
--- a/include/boost/python/converter/unwrapper.hpp
+++ b/include/boost/python/converter/unwrapper.hpp
@@ -1,3 +1,4 @@
+#error obsolete 
 // Copyright David Abrahams 2001. Permission to copy, use,
 // modify, sell and distribute this software is granted provided this
 // copyright notice appears in all copies. This software is provided
@@ -22,7 +23,7 @@ struct unwrapper : unwrapper_base
  public:
     unwrapper();
 
-    virtual T convert(PyObject*, void* data, boost::type<T>) const = 0;
+    virtual T convert(PyObject*, void*& data, boost::type<T>) const = 0;
 };
 
 //
diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
index eb23c6d3..b61fff19 100644
--- a/include/boost/python/converter/wrap.hpp
+++ b/include/boost/python/converter/wrap.hpp
@@ -1,3 +1,4 @@
+#error obsolete 
 // Copyright David Abrahams 2001. Permission to copy, use,
 // modify, sell and distribute this software is granted provided this
 // copyright notice appears in all copies. This software is provided
diff --git a/include/boost/python/converter/wrapper.hpp b/include/boost/python/converter/wrapper.hpp
index 5d4874d2..e20ed404 100644
--- a/include/boost/python/converter/wrapper.hpp
+++ b/include/boost/python/converter/wrapper.hpp
@@ -1,3 +1,4 @@
+#error obsolete 
 // Copyright David Abrahams 2001. Permission to copy, use,
 // modify, sell and distribute this software is granted provided this
 // copyright notice appears in all copies. This software is provided
diff --git a/include/boost/python/detail/arg_tuple_size.hpp b/include/boost/python/detail/arg_tuple_size.hpp
index a330a939..04bca0af 100644
--- a/include/boost/python/detail/arg_tuple_size.hpp
+++ b/include/boost/python/detail/arg_tuple_size.hpp
@@ -11,6 +11,8 @@
 #ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
 # define ARG_TUPLE_SIZE_DWA20011201_HPP
 
+# include <boost/python/detail/char_array.hpp>
+
 namespace boost { namespace python { namespace detail {
 
 // Computes (at compile-time) the number of elements that a Python
@@ -223,16 +225,6 @@ struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5) const volatile>
 // http://groups.yahoo.com/group/boost/message/5441 for
 // more examples
 
-// This little package is used to transmit the number of arguments
-// from the helper functions below to the sizeof() expression below.
-// Because we can never have an array of fewer than 1 element, we
-// add 1 to n and then subtract 1 from the result of sizeof() below.
-template <int n>
-struct char_array
-{
-    char elements[n+1];
-};
-
 // The following helper functions are never actually called, since
 // they are only used within a sizeof() expression, but the type of
 // their return value is used to discriminate between various free
diff --git a/include/boost/python/detail/char_array.hpp b/include/boost/python/detail/char_array.hpp
new file mode 100644
index 00000000..d68aea47
--- /dev/null
+++ b/include/boost/python/detail/char_array.hpp
@@ -0,0 +1,23 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CHAR_ARRAY_DWA2002129_HPP
+# define CHAR_ARRAY_DWA2002129_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+// This little package is used to transmit the number of arguments
+// from the helper functions below to the sizeof() expression below.
+// Because we can never have an array of fewer than 1 element, we
+// add 1 to n and then subtract 1 from the result of sizeof() below.
+template <int n>
+struct char_array
+{
+    char elements[n+1];
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CHAR_ARRAY_DWA2002129_HPP
diff --git a/include/boost/python/detail/eval.hpp b/include/boost/python/detail/eval.hpp
new file mode 100644
index 00000000..3e799507
--- /dev/null
+++ b/include/boost/python/detail/eval.hpp
@@ -0,0 +1,38 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef EVAL_DWA2002124_HPP
+# define EVAL_DWA2002124_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T> struct undefined;
+template <class UnaryMetaFunction, class T>
+struct eval
+{
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
+   // based on the (non-conforming) MSVC trick from MPL
+    template<bool>
+    struct unarymetafunction_vc : UnaryMetaFunction {};
+
+    // illegal C++ which causes VC to admit that unarymetafunction_vc
+    // can have a nested template:
+    template<>
+    struct unarymetafunction_vc<true>
+    {
+        template<class> struct apply;
+    };
+
+    typedef typename unarymetafunction_vc<
+        ::boost::mpl::detail::msvc_never_true<UnaryMetaFunction>::value
+    >::template apply<T>::type type;
+# else
+    typedef typename UnaryMetaFunction::template apply<T>::type type;
+# endif
+};
+
+}}} // namespace boost::python::detail
+
+#endif // EVAL_DWA2002124_HPP
diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index 87aecac5..4aa228b5 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -14,8 +14,9 @@
 //# include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/config.hpp>
-# include <boost/python/convert.hpp>
 # include <boost/python/detail/none.hpp>
+# include <boost/python/from_python.hpp>
+# include <boost/python/to_python.hpp>
 
 namespace boost { namespace python { namespace detail {
 
@@ -27,246 +28,291 @@ struct returning
     static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
     }
 
     template <class A0>
     static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
     }
 
     template <class A0>
     static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
     }
 
 
@@ -276,82 +322,97 @@ struct returning
     static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c0);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)() );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c1);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c2);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c3);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c4);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> r(c5);
-        if (!c0) return 0;
-        return r( ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5) );
+        to_python<R> r;
+        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
     }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -359,90 +420,104 @@ struct returning
     static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
     {
         // find the result converter
-        wrap<R> c0;
-        if (!c0) return 0;
+        to_python<R> c0;
         return c0( (*pf)() );
     }
     template <class A0>
     static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> c1(c0);
-        if (!c0) return 0;
-        return c1( (*pf)(*c0) );
+        to_python<R> c1;
+        return c1( (*pf)(c0(PyTuple_GET_ITEM(args, 0))) );
     }
     template <class A0, class A1>
     static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> c2(c1);
-        if (!c0) return 0;
-        return c2( (*pf)(*c0, *c1) );
+        to_python<R> c2;
+        return c2( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1))) );
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> c3(c2);
-        if (!c0) return 0;
-        return c3( (*pf)(*c0, *c1, *c2) );
+        to_python<R> c3;
+        return c3( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> c4(c3);
-        if (!c0) return 0;
-        return c4( (*pf)(*c0, *c1, *c2, *c3) );
+        to_python<R> c4;
+        return c4( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> c5(c4);
-        if (!c0) return 0;
-        return c5( (*pf)(*c0, *c1, *c2, *c3, *c4) );
+        to_python<R> c5;
+        return c5( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
         // find the result converter
-        wrap_more<R> c6(c5);
-        if (!c0) return 0;
-        return c6( (*pf)(*c0, *c1, *c2, *c3, *c4, *c5) );
+        to_python<R> c6;
+        return c6( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
     }
 };
                            
@@ -454,75 +529,90 @@ struct returning<void>
     static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)();
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
         return detail::none();
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
         return detail::none();
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
         return detail::none();
     }
 
@@ -530,75 +620,90 @@ struct returning<void>
     static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)();
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
         return detail::none();
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
         return detail::none();
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
         return detail::none();
     }
 
@@ -606,75 +711,90 @@ struct returning<void>
     static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)();
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
         return detail::none();
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
         return detail::none();
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
         return detail::none();
     }
 
@@ -685,75 +805,90 @@ struct returning<void>
     static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)();
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
         return detail::none();
     }
     template <class A0, class A1>
     static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
         return detail::none();
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
-        if (!c0) return 0;
-        ((*c0).*pmf)(*c1, *c2, *c3, *c4, *c5);
+        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
         return detail::none();
     }
 
@@ -768,75 +903,90 @@ struct returning<void>
     static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
 
-        if (!c0) return 0;
-        (*pf)(*c0);
+        (*pf)(c0(PyTuple_GET_ITEM(args, 0)));
         return detail::none();
     }
     template <class A0, class A1>
     static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
 
-        if (!c0) return 0;
-        (*pf)(*c0, *c1);
+        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)));
         return detail::none();
     }
     template <class A0, class A1, class A2>
     static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
 
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2);
+        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3>
     static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
 
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2, *c3);
+        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
 
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2, *c3, *c4);
+        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
         return detail::none();
     }
     template <class A0, class A1, class A2, class A3, class A4, class A5>
     static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
     {
         // check that each of the arguments is convertible
-        unwrap<A0> c0(PyTuple_GET_ITEM(args, 0));
-        unwrap_more<A1> c1(PyTuple_GET_ITEM(args, 1), c0);
-        unwrap_more<A2> c2(PyTuple_GET_ITEM(args, 2), c1);
-        unwrap_more<A3> c3(PyTuple_GET_ITEM(args, 3), c2);
-        unwrap_more<A4> c4(PyTuple_GET_ITEM(args, 4), c3);
-        unwrap_more<A5> c5(PyTuple_GET_ITEM(args, 5), c4);
+        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        if (!c0.convertible()) return 0;
+        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        if (!c1.convertible()) return 0;
+        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        if (!c2.convertible()) return 0;
+        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        if (!c3.convertible()) return 0;
+        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        if (!c4.convertible()) return 0;
+        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        if (!c5.convertible()) return 0;
 
-        if (!c0) return 0;
-        (*pf)(*c0, *c1, *c2, *c3, *c4, *c5);
+        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
         return detail::none();
     }
 };
diff --git a/include/boost/python/detail/signature.hpp b/include/boost/python/detail/signature.hpp
new file mode 100644
index 00000000..db8b39a4
--- /dev/null
+++ b/include/boost/python/detail/signature.hpp
@@ -0,0 +1,217 @@
+//  (C) Copyright David Abrahams 2002. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley and Lawrence
+//  Livermore National Labs
+//
+//  This file generated for 5-argument member functions and 6-argument free
+//  functions by gen_signature.py
+
+#ifndef SIGNATURE_DWA2002128_HPP
+# define SIGNATURE_DWA2002128_HPP
+
+# include <boost/mpl/type_list.hpp>
+
+namespace boost { namespace python { namespace detail {
+
+template <class R>
+mpl::type_list<R>
+signature(R (*)())
+{
+    return mpl::type_list<R>();
+}
+
+template <class R, class A0>
+mpl::type_list<R,A0>
+signature(R (*)(A0))
+{
+    return mpl::type_list<R,A0>();
+}
+
+template <class R, class A0, class A1>
+mpl::type_list<R,A0,A1>
+signature(R (*)(A0, A1))
+{
+    return mpl::type_list<R,A0,A1>();
+}
+
+template <class R, class A0, class A1, class A2>
+mpl::type_list<R,A0,A1,A2>
+signature(R (*)(A0, A1, A2))
+{
+    return mpl::type_list<R,A0,A1,A2>();
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+mpl::type_list<R,A0,A1,A2,A3>
+signature(R (*)(A0, A1, A2, A3))
+{
+    return mpl::type_list<R,A0,A1,A2,A3>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+mpl::type_list<R,A0,A1,A2,A3,A4>
+signature(R (*)(A0, A1, A2, A3, A4))
+{
+    return mpl::type_list<R,A0,A1,A2,A3,A4>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+mpl::type_list<R,A0,A1,A2,A3,A4,A5>
+signature(R (*)(A0, A1, A2, A3, A4, A5))
+{
+    return mpl::type_list<R,A0,A1,A2,A3,A4,A5>();
+}
+template <class R, class A0>
+mpl::type_list<R,A0&> signature(R (A0::*)())
+{
+    return mpl::type_list<R,A0&>();
+}
+
+template <class R, class A0, class A1>
+mpl::type_list<R,A0&,A1> signature(R (A0::*)(A1))
+{
+    return mpl::type_list<R,A0&,A1>();
+}
+
+template <class R, class A0, class A1, class A2>
+mpl::type_list<R,A0&,A1,A2> signature(R (A0::*)(A1, A2))
+{
+    return mpl::type_list<R,A0&,A1,A2>();
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+mpl::type_list<R,A0&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3))
+{
+    return mpl::type_list<R,A0&,A1,A2,A3>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+mpl::type_list<R,A0&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4))
+{
+    return mpl::type_list<R,A0&,A1,A2,A3,A4>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+mpl::type_list<R,A0&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5))
+{
+    return mpl::type_list<R,A0&,A1,A2,A3,A4,A5>();
+}
+
+
+template <class R, class A0>
+mpl::type_list<R,A0 const&> signature(R (A0::*)() const)
+{
+    return mpl::type_list<R,A0 const&>();
+}
+
+template <class R, class A0, class A1>
+mpl::type_list<R,A0 const&,A1> signature(R (A0::*)(A1) const)
+{
+    return mpl::type_list<R,A0 const&,A1>();
+}
+
+template <class R, class A0, class A1, class A2>
+mpl::type_list<R,A0 const&,A1,A2> signature(R (A0::*)(A1, A2) const)
+{
+    return mpl::type_list<R,A0 const&,A1,A2>();
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+mpl::type_list<R,A0 const&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3) const)
+{
+    return mpl::type_list<R,A0 const&,A1,A2,A3>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+mpl::type_list<R,A0 const&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4) const)
+{
+    return mpl::type_list<R,A0 const&,A1,A2,A3,A4>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+mpl::type_list<R,A0 const&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5) const)
+{
+    return mpl::type_list<R,A0 const&,A1,A2,A3,A4,A5>();
+}
+
+
+template <class R, class A0>
+mpl::type_list<R,A0 volatile&> signature(R (A0::*)() volatile)
+{
+    return mpl::type_list<R,A0 volatile&>();
+}
+
+template <class R, class A0, class A1>
+mpl::type_list<R,A0 volatile&,A1> signature(R (A0::*)(A1) volatile)
+{
+    return mpl::type_list<R,A0 volatile&,A1>();
+}
+
+template <class R, class A0, class A1, class A2>
+mpl::type_list<R,A0 volatile&,A1,A2> signature(R (A0::*)(A1, A2) volatile)
+{
+    return mpl::type_list<R,A0 volatile&,A1,A2>();
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+mpl::type_list<R,A0 volatile&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3) volatile)
+{
+    return mpl::type_list<R,A0 volatile&,A1,A2,A3>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+mpl::type_list<R,A0 volatile&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4) volatile)
+{
+    return mpl::type_list<R,A0 volatile&,A1,A2,A3,A4>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+mpl::type_list<R,A0 volatile&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5) volatile)
+{
+    return mpl::type_list<R,A0 volatile&,A1,A2,A3,A4,A5>();
+}
+
+
+template <class R, class A0>
+mpl::type_list<R,A0 const volatile&> signature(R (A0::*)() const volatile)
+{
+    return mpl::type_list<R,A0 const volatile&>();
+}
+
+template <class R, class A0, class A1>
+mpl::type_list<R,A0 const volatile&,A1> signature(R (A0::*)(A1) const volatile)
+{
+    return mpl::type_list<R,A0 const volatile&,A1>();
+}
+
+template <class R, class A0, class A1, class A2>
+mpl::type_list<R,A0 const volatile&,A1,A2> signature(R (A0::*)(A1, A2) const volatile)
+{
+    return mpl::type_list<R,A0 const volatile&,A1,A2>();
+}
+
+template <class R, class A0, class A1, class A2, class A3>
+mpl::type_list<R,A0 const volatile&,A1,A2,A3> signature(R (A0::*)(A1, A2, A3) const volatile)
+{
+    return mpl::type_list<R,A0 const volatile&,A1,A2,A3>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4>
+mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4> signature(R (A0::*)(A1, A2, A3, A4) const volatile)
+{
+    return mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4>();
+}
+
+template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
+mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4,A5> signature(R (A0::*)(A1, A2, A3, A4, A5) const volatile)
+{
+    return mpl::type_list<R,A0 const volatile&,A1,A2,A3,A4,A5>();
+}
+
+}}} // namespace boost::python::detail
+
+#endif // SIGNATURE_DWA2002128_HPP
+
diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index f9ffd5c3..dfd11865 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -8,8 +8,10 @@
 
 # include <boost/python/object/function.hpp>
 # include <boost/python/object/make_holder.hpp>
+# include <boost/python/converter/registration.hpp>
 # include <boost/python/detail/caller.hpp>
 # include <boost/python/detail/arg_tuple_size.hpp>
+# include <boost/python/detail/signature.hpp>
 # include <boost/mpl/size.hpp>
 # include <boost/function.hpp>
 # include <boost/bind.hpp>
@@ -19,6 +21,7 @@ namespace boost { namespace python {
 template <class F>
 objects::function* make_function(F f)
 {
+    converter::acquire_registrations(detail::signature(f));
     return new objects::function(
         objects::py_function(
             ::boost::bind<PyObject*>(detail::caller(), f, _1, _2))
@@ -29,6 +32,10 @@ template <class T, class ArgList, class Generator>
 objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
 {
     enum { nargs = mpl::size<ArgList>::value };
+    
+    typedef typename mpl::push_front<ArgList,void>::sequence signature;
+    converter::acquire_registrations(signature());
+    
     return new objects::function(
         objects::py_function(
             ::boost::bind<PyObject*>(detail::caller(),
diff --git a/include/boost/python/object/class_converters.hpp b/include/boost/python/object/class_converters.hpp
index d4ba4b6d..d5978af7 100644
--- a/include/boost/python/object/class_converters.hpp
+++ b/include/boost/python/object/class_converters.hpp
@@ -24,7 +24,7 @@ struct class_converters
     class_converters(ref const& python_class);
 
  private: // data members
-    converter::class_unwrapper<Derived> m_unwrapper;
+    converter::class_from_python_converter<Derived> m_unwrapper;
     class_wrapper<Derived> m_wrapper;
 };
 
diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
index f199a99f..26334bc7 100644
--- a/include/boost/python/object/class_wrapper.hpp
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -8,31 +8,31 @@
 
 # include <boost/python/object/class.hpp>
 # include <boost/python/object/value_holder.hpp>
-# include <boost/python/converter/wrapper.hpp>
 # include <boost/python/reference.hpp>
+# include <boost/python/converter/to_python.hpp>
 # include <memory>
 
 namespace boost { namespace python { namespace objects { 
 
 template <class T>
 struct class_wrapper
-    : converter::wrapper<T const&>
+    : converter::to_python_converter<T const&>
 {
     class_wrapper(ref const& type_)
-        : m_class_object(type_)
+        : converter::to_python_converter<T const&>(convert)
+        , m_class_object_keeper(type_)
     {
-# ifndef NDEBUG
         assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
-# endif // NDEBUG 
+        m_class_object = (PyTypeObject*)type_.get();
     }
     
-    PyObject* convert(T const& x) const
+    static PyObject* convert(T const& x)
     {
         // Don't call the type to do the construction, since that
         // would require the registration of an __init__ copy
         // constructor. Instead, just construct the object in place.
         PyObject* raw_result = (PyObject*)PyObject_New(
-            instance, (PyTypeObject*)m_class_object.get());
+            instance, m_class_object);
         
         if (raw_result == 0)
             return 0;
@@ -53,9 +53,12 @@ struct class_wrapper
     }
     
  private:
-    ref m_class_object;
+    ref m_class_object_keeper;
+    static PyTypeObject* m_class_object;
 };
 
+template <class T>
+PyTypeObject* class_wrapper<T>::m_class_object;
 
 }}} // namespace boost::python::objects
 
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 76b3a5f4..8a72a880 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -10,36 +10,10 @@
 # include <boost/python/object/forward.hpp>
 # include <boost/python/object/class.hpp>
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/eval.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
-
-template <class T> struct undefined;
-template <class UnaryMetaFunction, class T>
-struct eval
-{
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
-   // based on the (non-conforming) MSVC trick from MPL
-    template<bool>
-    struct unarymetafunction_vc : UnaryMetaFunction {};
-
-    // illegal C++ which causes VC to admit that unarymetafunction_vc
-    // can have a nested template:
-    template<>
-    struct unarymetafunction_vc<true>
-    {
-        template<class> struct apply;
-    };
-
-    typedef typename unarymetafunction_vc<
-        ::boost::mpl::detail::msvc_never_true<UnaryMetaFunction>::value
-    >::template apply<T>::type type;
-# else
-    typedef typename UnaryMetaFunction::template apply<T>::type type;
-# endif
-};
-
-
 template <int nargs> struct make_holder;
 
 template <>
@@ -48,7 +22,7 @@ struct make_holder<0>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename eval<Generator,T>::type holder;
+        typedef typename detail::eval<Generator,T>::type holder;
         static void execute(
             PyObject* p)
         {
@@ -64,7 +38,7 @@ struct make_holder<1>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename eval<Generator,T>::type holder;
+        typedef typename detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         
@@ -83,7 +57,7 @@ struct make_holder<2>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename eval<Generator,T>::type holder;
+        typedef typename detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -103,7 +77,7 @@ struct make_holder<3>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename eval<Generator,T>::type holder;
+        typedef typename detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index d6e38a79..85e3797f 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -22,43 +22,116 @@ struct value_holder : instance_holder
     
     template <class A1>
     value_holder(PyObject*, A1 a1)
-        : m_held(a1) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            )
+    {}
     
     template <class A1, class A2>
     value_holder(PyObject*, A1 a1, A2 a2)
-        : m_held(a1, a2) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            )
+    {}
     
     template <class A1, class A2, class A3>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3)
-        : m_held(a1, a2, a3) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            )
+    {}
     
     template <class A1, class A2, class A3, class A4>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_held(a1, a2, a3, a4) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            )
+    {}
     
     template <class A1, class A2, class A3, class A4, class A5>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_held(a1, a2, a3, a4, a5) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            ) {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_held(a1, a2, a3, a4, a5, a6) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            ) {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_held(a1, a2, a3, a4, a5, a6, a7) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            )
+    {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_held(a1, a2, a3, a4, a5, a6, a7, a8) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            , (unwrap_reference<A8>::type&)(a8)
+            )
+    {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_held(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            , (unwrap_reference<A8>::type&)(a8)
+            , (unwrap_reference<A9>::type&)(a9)
+            )
+    {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_held(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
+        : m_held(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            , (unwrap_reference<A8>::type&)(a8)
+            , (unwrap_reference<A9>::type&)(a9)
+            , (unwrap_reference<A10>::type&)(a10)
+            )
+    {}
 
  private: // required holder implementation
     void* holds(converter::type_id_t);
diff --git a/include/boost/python/objects.hpp b/include/boost/python/objects.hpp
index 93173462..8b230478 100644
--- a/include/boost/python/objects.hpp
+++ b/include/boost/python/objects.hpp
@@ -354,6 +354,8 @@ struct BOOST_PYTHON_DECL list_slice_proxy
 
 }} // namespace boost::python
 
+# ifndef BOOST_PYTHON_V2
+
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
 BOOST_PYTHON_DECL PyObject* to_python(const boost::python::tuple&);
@@ -389,5 +391,5 @@ inline boost::python::dictionary from_python(PyObject* p, boost::python::type<co
 }
 
 BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
+# endif 
 #endif // OBJECTS_DWA051100_H_
diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
index 4ce9e709..5b4563a4 100644
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -4,10 +4,11 @@
 //  "as is" without express or implied warranty, and with no claim as
 //  to its suitability for any purpose.
 
-# include <boost/python/converter/unwrapper.hpp>
-# include <boost/python/converter/wrapper.hpp>
+# include <boost/python/converter/to_python.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/builtin_converters.hpp>
+# include <boost/detail/binary_search.hpp>
 # include <map>
-# include <list>
 # include <algorithm>
 # include <stdexcept>
 # ifdef BOOST_PYTHON_TRACE
@@ -23,6 +24,15 @@ namespace // <unnamed>
   registry_t& entries()
   {
       static registry_t registry;
+      static bool builtin_converters_initialized = false;
+      if (!builtin_converters_initialized)
+      {
+          // Make this true early because registering the builtin
+          // converters will cause recursion.
+          builtin_converters_initialized = true;
+          
+          initialize_builtin_converters();
+      }
       return registry;
   }
 } // namespace <unnamed>
@@ -35,124 +45,127 @@ namespace registry
   }
 
   entry::entry()
-      : m_wrapper(0)
+      : m_to_python_converter(0)
   {
   }
 
   entry::~entry()
   {
-      if (m_wrapper != 0)
-          m_wrapper->m_can_unregister = false;
+      if (m_to_python_converter != 0)
+          m_to_python_converter->m_can_unregister = false;
       
-      for (unwrappers::iterator p = m_unwrappers.begin(); p != m_unwrappers.end(); ++p)
+      for (from_python_converters::iterator p = m_from_python_converters.begin()
+               ; p != m_from_python_converters.end()
+               ; ++p)
       {
           (*p)->m_can_unregister = false;
       }
   }
 
-  std::pair<unwrapper_base*,void*>
-  entry::unwrapper(PyObject* p) const
-  {
-      unwrapper_base* body = 0;
-      void* data = 0;
-      
-      for (unwrappers::const_iterator q = m_unwrappers.begin(),
-               finish = m_unwrappers.end();
+  from_python_converter_base const*
+  entry::get_from_python(PyObject* p, void*& data_out) const
+  {      
+      for (from_python_converters::const_iterator q = m_from_python_converters.begin(),
+               finish = m_from_python_converters.end();
            q != finish;
            ++q)
       {
-          data = (*q)->can_convert(p);
+          void* const data = (*q)->convertible(p);
           if (data != 0)
           {
-              body = *q;
+              data_out = data;
+              return *q;
               break;
           }
       }
-      return std::make_pair(body,data);
+      return 0;
   }
   
-  wrapper_base* entry::wrapper() const
+  to_python_function_base entry::get_to_python() const
   {
-      return m_wrapper;
+      return m_to_python_converter
+          ? m_to_python_converter->converter()
+          : 0;
   }
 
-  entry::unwrappers::iterator entry::find(unwrapper_base const& x)
+  entry::from_python_converters::iterator entry::find(from_python_converter_base const& x)
   {
-      return std::find(m_unwrappers.begin(), m_unwrappers.end(), &x);
+      return std::find(m_from_python_converters.begin(), m_from_python_converters.end(), &x);
   }
 
-  void entry::insert(unwrapper_base& x)
+  void entry::insert(from_python_converter_base& x)
   {
-      unwrappers::iterator p = this->find(x);
+      from_python_converters::iterator p = this->find(x);
       
-      assert(p == m_unwrappers.end());
-      if (p != m_unwrappers.end())
+      if (p != m_from_python_converters.end())
       {
+          assert(!"converter already registered");
           throw std::runtime_error(
               "trying to register unrapper which is already registered");
       }
-      m_unwrappers.push_back(&x);
+
+      m_from_python_converters.push_back(&x);
   }
   
-  void entry::remove(unwrapper_base& x)
+  void entry::remove(from_python_converter_base& x)
   {
-      unwrappers::iterator p = find(x);
+      from_python_converters::iterator p = find(x);
 
       // Be sure we're not removing a converter which hasn't been
       // registered.
-      assert(p != m_unwrappers.end());
-      if (p == m_unwrappers.end())
+      if (p == m_from_python_converters.end())
       {
+          assert(!"trying to unregister from_python_converter which is not registered");
           throw std::runtime_error(
-              "trying to unregister unwrapper which is not registered");
+              "trying to unregister from_python_converter which is not registered");
       }
-      m_unwrappers.erase(p);
+      m_from_python_converters.erase(p);
   }
   
-  void entry::insert(wrapper_base& x)
+  void entry::insert(to_python_converter_base& x)
   {
-      assert(m_wrapper == 0); // we have a problem otherwise
-      if (m_wrapper != 0)
+      assert(m_to_python_converter == 0); // we have a problem otherwise
+      if (m_to_python_converter != 0)
       {
           throw std::runtime_error(
-              "trying to register wrapper for a type which already has a registered wrapper");
+              "trying to register to_python_converter for a type which already has a registered to_python_converter");
       }
-      m_wrapper = &x;
+      m_to_python_converter = &x;
   }
   
-  void entry::remove(wrapper_base& x)
+  void entry::remove(to_python_converter_base& x)
   {
-      assert(m_wrapper == &x);
-      if (m_wrapper != &x)
+      assert(m_to_python_converter == &x);
+      if (m_to_python_converter != &x)
       {
           throw std::runtime_error(
-              "trying to unregister a wrapper which is not registered");
+              "trying to unregister a to_python_converter which is not registered");
       }
-      m_wrapper = 0;
+      m_to_python_converter = 0;
   }
 
-  void insert(wrapper_base& w)
+  void insert(to_python_converter_base& w)
   {
 # ifdef BOOST_PYTHON_TRACE
-      std::cout << "inserting wrapper for " << w.key() << std::endl;
+      std::cout << "inserting to_python_converter for " << w.key() << std::endl;
 # endif 
       find(w.key())->insert(w);
   }
 
-  void insert(unwrapper_base& u)
+  void insert(from_python_converter_base& u)
   {
 # ifdef BOOST_PYTHON_TRACE
-      std::cout << "inserting unwrapper for " << u.key() << std::endl;
+      std::cout << "inserting from_python_converter for " << u.key() << std::endl;
 # endif 
       find(u.key())->insert(u);
   }
 
-  void remove(wrapper_base& w)
+  void remove(to_python_converter_base& w)
   {
       find(w.key())->remove(w);
   }
 
-  void remove(unwrapper_base& u)
+  void remove(from_python_converter_base& u)
   {
       find(u.key())->remove(u);
   }
diff --git a/src/gen_arg_tuple_size.py b/src/gen_arg_tuple_size.py
index 5edd3286..9de332ab 100644
--- a/src/gen_arg_tuple_size.py
+++ b/src/gen_arg_tuple_size.py
@@ -42,6 +42,8 @@ def gen_arg_tuple_size(member_function_args, free_function_args = None):
 #ifndef ARG_TUPLE_SIZE_DWA20011201_HPP
 # define ARG_TUPLE_SIZE_DWA20011201_HPP
 
+# include <boost/python/detail/char_array.hpp>
+
 namespace boost { namespace python { namespace detail {
 
 // Computes (at compile-time) the number of elements that a Python
@@ -85,16 +87,6 @@ struct arg_tuple_size<R (A0::*)(%(A%+%:, %))%1>
 // http://groups.yahoo.com/group/boost/message/5441 for
 // more examples
 
-// This little package is used to transmit the number of arguments
-// from the helper functions below to the sizeof() expression below.
-// Because we can never have an array of fewer than 1 element, we
-// add 1 to n and then subtract 1 from the result of sizeof() below.
-template <int n>
-struct char_array
-{
-    char elements[n+1];
-};
-
 // The following helper functions are never actually called, since
 // they are only used within a sizeof() expression, but the type of
 // their return value is used to discriminate between various free
diff --git a/src/gen_signature.py b/src/gen_signature.py
new file mode 100644
index 00000000..1af3437d
--- /dev/null
+++ b/src/gen_signature.py
@@ -0,0 +1,90 @@
+#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  distribute this software is granted provided this copyright notice appears
+#  in all copies. This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+#
+#  This work was funded in part by Lawrence Berkeley National Labs
+
+from gen_function import *
+import string
+
+header = '''//  (C) Copyright David Abrahams 2002. Permission to copy, use, modify, sell and
+//  distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley and Lawrence
+//  Livermore National Labs
+//
+//  This file generated for %d-argument member functions and %d-argument free
+//  functions by gen_signature.py
+'''
+
+_cv_qualifiers = ('', ' const', ' volatile', ' const volatile')
+
+_suffix = {
+    '': '''
+// Metrowerks thinks this creates ambiguities
+# if !defined(__MWERKS__) || __MWERKS__ > 0x2406
+''', ' const volatile': '''
+# endif // __MWERKS__
+'''
+    };
+
+def gen_arg_tuple_size(member_function_args, free_function_args = None):
+    if free_function_args is None:
+        free_function_args = member_function_args + 1
+
+    return_none = ''';
+        return detail::none();'''
+    
+    return (header % (member_function_args, free_function_args)
+            + '''
+#ifndef SIGNATURE_DWA2002128_HPP
+# define SIGNATURE_DWA2002128_HPP
+
+# include <boost/mpl/type_list.hpp>
+
+namespace boost { namespace python { namespace detail {
+'''
+
+            + gen_functions('''
+template <class R%(, class A%n%)>
+mpl::type_list<R%(,A%n%)>
+signature(R (*)(%(A%n%:, %)))
+{
+    return mpl::type_list<R%(,A%n%)>()
+}
+''', free_function_args)
+            
+            + reduce(lambda x,y: x+'\n'+y
+                   , map(
+        lambda cv: gen_functions(
+'''template <class R, class A0%(, class A%+%)>
+mpl::type_list<R%,A0%1&%(,A%+%)> signature(R (A0::*)(%(A%+%:, %))%1)
+{
+    return mpl::type_list<R%,A0%1&%(,A%+%)>();
+}
+
+''', member_function_args, cv)
+        , _cv_qualifiers)) + '''}}} // namespace boost::python::detail
+
+#endif // SIGNATURE_DWA2002128_HPP
+''')
+            
+if __name__ == '__main__':
+    import sys
+
+    if len(sys.argv) == 1:
+        member_function_args = 5
+        free_function_args = 6
+    else:
+        member_function_args = int(sys.argv[1])
+        if len(sys.argv) > 2:
+            free_function_args = int(sys.argv[2])
+        else:
+            free_function_args = member_function_args
+
+    print gen_arg_tuple_size(member_function_args, free_function_args)
+
+
diff --git a/src/gen_value_holder.py b/src/gen_value_holder.py
new file mode 100644
index 00000000..b01e2c0e
--- /dev/null
+++ b/src/gen_value_holder.py
@@ -0,0 +1,35 @@
+#  Copyright David Abrahams 2002. Permission to copy, use, modify,
+#  sell and distribute this software is granted provided this
+#  copyright notice appears in all copies. This software is provided
+#  "as is" without express or implied warranty, and with no claim as
+#  to its suitability for any purpose.
+#
+#  This work was funded in part by Lawrence Livermore National Labs
+
+from gen_function import *
+import string
+
+def _generate(member_function_args, free_function_args = None):
+    return ('''// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VALUE_HOLDER_DWA20011215_HPP
+# define VALUE_HOLDER_DWA20011215_HPP
+
+# include <boost/python/object/class.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/object/inheritance.hpp>
+# include <boost/ref.hpp>
+# include <boost/function/function_base.hpp>
+
+namespace boost { namespace python { namespace objects { 
+
+template <class Held>
+struct value_holder : instance_holder
+{
+    // Forward construction to the held object
+'''
+            +
+            gen_functions(
diff --git a/src/object/class.cpp b/src/object/class.cpp
index b928ba66..de3e32f5 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -46,7 +46,7 @@ PyTypeObject class_metatype_object = {
         0,                                      /* tp_getattro */
         0,                                      /* tp_setattro */
         0,                                      /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | // Py_TPFLAGS_HAVE_GC |
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
 		Py_TPFLAGS_BASETYPE,		/* tp_flags */
         0,                                      /* tp_doc */
         0,                                      /* tp_traverse */
diff --git a/test/m1.cpp b/test/m1.cpp
index 7f88af2b..6b4c55e1 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -4,19 +4,18 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
 
+
 #include "simple_type.hpp"
 #include "complicated.hpp"
-#include <boost/python/converter/wrapper.hpp>
-#include <boost/python/converter/unwrapper.hpp>
-#include <boost/python/detail/config.hpp>
-#include <boost/python/convert.hpp>
 #include <boost/python/module.hpp>
 #include <boost/python/class.hpp>
 #include <boost/python/object/value_holder.hpp>
+#include <boost/python/object/pointer_holder.hpp>
 #include <boost/python/object/class.hpp>
-#include <boost/python/object/inheritance.hpp>
+//#include <boost/python/object/inheritance.hpp>
 #include <boost/python/converter/class.hpp>
-#include <boost/python/make_function.hpp>
+#include <boost/python/reference_from_python.hpp>
+#include <boost/python/value_from_python.hpp>
 #include <boost/python/errors.hpp>
 #include <boost/mpl/type_list.hpp>
 #include <string.h>
@@ -61,9 +60,12 @@ PyObject* new_noddy()
 }
 
 // Simple is a wrapper around a struct simple, which just contains a char*
-struct SimpleObject : PyObject
+struct SimpleObject
 {
+    PyObject_HEAD
     simple x;
+
+    static simple& extract(SimpleObject& o) { return o.x; }
 };
 
 PyTypeObject SimpleType = {
@@ -72,7 +74,7 @@ PyTypeObject SimpleType = {
     "Simple",
     sizeof(SimpleObject),
     0,
-    dealloc, /*tp_dealloc*/
+    dealloc,    /*tp_dealloc*/
     0,          /*tp_print*/
     0,          /*tp_getattr*/
     0,          /*tp_setattr*/
@@ -98,120 +100,38 @@ PyObject* new_simple()
 // description of how the type parameters to wrapper<> and unwrapper<>
 // are selected.
 //
-
-// Wrap an int by converting it to a Python Int
-struct int_wrapper
-    : boost::python::converter::wrapper<int const&>
-{
-    PyObject* convert(int const& x) const
-    {
-        return PyInt_FromLong(x);
-    }
-};
+using boost::python::converter::from_python_data;
 
 // Wrap a simple by converting it to a Simple
-struct simple_wrapper
-    : boost::python::converter::wrapper<simple const&>
+PyObject* simple_to_python(simple const& x)
 {
-    PyObject* convert(simple const& x) const
-    {
-        SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
-        p->x = x;
-        return p;
-    }
-};
+    SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
+    p->x = x;
+    return (PyObject*)p;
+}
+
 
 // wrap a mutable reference to a simple by converting it to a
 // Simple. Normally we wouldn't do it this way, since modifications to
 // the result clearly don't change the original object, but here we're
 // just proving that the mechanism works.
-struct simple_ref_wrapper
-    : boost::python::converter::wrapper<simple&>
+PyObject* simple_ref_to_python(simple& x)
 {
-    PyObject* convert(simple& x) const
-    {
-        SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
-        p->x = x;
-        return p;
-    }
-};
+    SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
+    p->x = x;
+    return (PyObject*)p;
+}
 
-// extract an int from a Python Int by converting it to an int. Since
-// int is a scalar type, we convert by-value. Since Python Ints are
-// immutable, there's no non-const reference converter.
-struct native_int_unwrapper
-    : boost::python::converter::unwrapper<int>
+int noddy_to_int(PyObject* p, from_python_data&)
 {
-    void* can_convert(PyObject* p) const
-    {
-        return PyInt_Check(p) ? non_null : 0;
-    }
-    
-    int convert(PyObject* p, void*, boost::type<int>) const
-    {
-        return PyInt_AsLong(p);
-    }
-};
-
-// Extract an int from a Noddy
-struct noddy_int_unwrapper
-    : boost::python::converter::unwrapper<int>
-{
-    void* can_convert(PyObject* p) const
-    {
-        return p->ob_type == &NoddyType ? non_null : 0;
-    }
-    
-    int convert(PyObject* p, void*, boost::type<int>) const
-    {
-        return static_cast<NoddyObject*>(p)->x;
-    }
-};
+    return static_cast<NoddyObject*>(p)->x;
+}
 
 // Extract a mutable reference to an int from a Noddy.
-struct noddy_int_ref_unwrapper
-    : boost::python::converter::unwrapper<int&>
+int& noddy_to_int_ref(PyObject* p, from_python_data&) 
 {
-    void* can_convert(PyObject* p) const
-    {
-        return p->ob_type == &NoddyType ? non_null : 0;
-    }
-    
-    int& convert(PyObject* p, void*, boost::type<int&>) const
-    {
-        return static_cast<NoddyObject*>(p)->x;
-    }
-};
-
-// Extract a mutable reference to a simple from a Simple
-struct simple_ref_unwrapper
-    : boost::python::converter::unwrapper<simple&>
-{
-    void* can_convert(PyObject* p) const
-    {
-        return p->ob_type == &SimpleType ? non_null : 0;
-    }
-    
-    simple& convert(PyObject* p, void*, boost::type<simple&>) const
-    {
-        return static_cast<SimpleObject*>(p)->x;
-    }
-};
-
-// Extract a const reference to a simple from a Simple
-struct simple_const_ref_unwrapper
-    : boost::python::converter::unwrapper<simple const&>
-{
-    void* can_convert(PyObject* p) const
-    {
-        return p->ob_type == &SimpleType ? non_null : 0;
-    }
-    
-    simple const& convert(PyObject* p, void*, boost::type<simple const&>) const
-    {
-        return static_cast<SimpleObject*>(p)->x;
-    }
-};
+    return static_cast<NoddyObject*>(p)->x;
+}
 
 //
 // Some C++ functions to expose to Python
@@ -232,6 +152,7 @@ simple const& g(simple const& x)
 struct A
 {
     A() : x(0) {}
+    virtual ~A() {}
     char const* name() { return "A"; }
     int x;
 };
@@ -268,19 +189,38 @@ BOOST_PYTHON_MODULE_INIT(m1)
 {
     using boost::python::module;
     using boost::python::class_;
+    using boost::python::converter::to_python_converter;
+    using boost::python::converter::from_python_converter;
+    using boost::python::reference_from_python;
+    using boost::python::value_from_python;
+    using boost::python::type_from_python;
+    using boost::python::get_member;
     
     // Create the converters; they are self-registering/unregistering.
-    static int_wrapper wrap_int;
-    static simple_wrapper wrap_simple;
-    static native_int_unwrapper unwrap_int1;
-    static noddy_int_unwrapper unwrap_int2;
-    static noddy_int_ref_unwrapper unwrap_int3;
-    static simple_ref_unwrapper unwrap_simple;
-    static simple_const_ref_unwrapper unwrap_simple_const_ref;
-    static simple_ref_wrapper wrap_simple_ref;
+    static to_python_converter<simple const&> c1(simple_to_python);
+
+    static from_python_converter<int> c2(
+        &(boost::python::type_from_python<&NoddyType>::convertible), noddy_to_int);
+    
+    static from_python_converter<int&> c3(
+        &(boost::python::type_from_python<&NoddyType>::convertible), noddy_to_int_ref);
+
+    static boost::python::reference_from_python<
+        &SimpleType
+        , simple
+        , SimpleObject
+        , &SimpleObject::extract
+        >
+        unwrap_simple;
+    
+    static to_python_converter<simple&> simple_ref_wrapper(simple_ref_to_python);
 
     module m1("m1");
 
+    typedef boost::python::objects::pointer_holder_generator<
+        boost::python::objects::shared_ptr_generator
+    > use_shared_ptr;
+
     m1
       // Insert the metaclass for all extension classes
       .setattr("xclass", boost::python::objects::class_metatype())
@@ -303,7 +243,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
       .def("take_d", take_d)
 
       .add(
-          class_<A>("A")
+          class_<A, bases<>, use_shared_ptr>("A")
           .def_init()
           .def("name", &A::name)
           )
@@ -314,13 +254,13 @@ BOOST_PYTHON_MODULE_INIT(m1)
     // or "C" below if we make them part of the same chain
     m1
         .add(
-            class_<B,bases<A> >("B")
+            class_<B,bases<A>, use_shared_ptr>("B")
             .def_init()
             .def("name", &B::name)
             )
         
         .add(
-            class_<C,bases<A> >("C")
+            class_<C,bases<A>, use_shared_ptr>("C")
             .def_init()
             .def("name", &C::name)
             )
@@ -328,7 +268,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
 
     m1
         .add(
-            class_<D,bases<B,C> >("D")
+            class_<D,bases<B,C>, use_shared_ptr>("D")
             .def_init()
             .def("name", &D::name)
             )
diff --git a/test/m2.cpp b/test/m2.cpp
index d70b0c13..be2934e0 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -7,13 +7,9 @@
 // This module exercises the converters exposed in m1 at a low level
 // by exposing raw Python extension functions that use wrap<> and
 // unwrap<> objects.
-#include <boost/python/convert.hpp>
 #include <boost/python/module.hpp>
 #include "simple_type.hpp"
 
-using boost::python::wrap;
-using boost::python::unwrap;
-
 // Get a simple (by value) from the argument, and return the
 // string it holds.
 PyObject* unwrap_simple(simple x)

From 1f128575514a887278e0b5ceaffbb43e1d327529 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 30 Jan 2002 22:12:07 +0000
Subject: [PATCH 239/369] initial checkin

[SVN r12591]
---
 .../boost/python/reference_from_python.hpp    | 57 ++++++++++++++++++
 include/boost/python/value_from_python.hpp    | 60 +++++++++++++++++++
 2 files changed, 117 insertions(+)
 create mode 100644 include/boost/python/reference_from_python.hpp
 create mode 100644 include/boost/python/value_from_python.hpp

diff --git a/include/boost/python/reference_from_python.hpp b/include/boost/python/reference_from_python.hpp
new file mode 100644
index 00000000..8e7b9b6c
--- /dev/null
+++ b/include/boost/python/reference_from_python.hpp
@@ -0,0 +1,57 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef REFERENCE_FROM_PYTHON_DWA2002130_HPP
+# define REFERENCE_FROM_PYTHON_DWA2002130_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/type_from_python.hpp>
+
+namespace boost { namespace python { 
+
+// Utility which produces a member extractor function on platforms
+// other than VC6.
+template <class Class, class Member, Member (Class::*mp)>
+struct get_member
+{
+    static Member& execute(Class* c)
+    {
+        return c->*mp;
+    }
+};
+
+template <
+    PyTypeObject const* python_type
+    , class Value
+    , class PythonObject
+    , Value& (*extract)(PythonObject&)
+    >
+struct reference_from_python : type_from_python<python_type>
+{
+    reference_from_python()
+        : m_mutable_converter(convertible, convert_mutable)
+        , m_const_converter(convertible, convert_const)
+    {}
+    
+    static Value& convert_mutable(PyObject* op, converter::from_python_data&)
+    {
+        return extract(*(PythonObject*)op);
+    }
+    
+    static Value const& convert_const(PyObject* op, converter::from_python_data&)
+    {
+        return extract(*(PythonObject*)op);
+    }
+    
+ private:
+    typedef converter::from_python_converter<Value&> mutable_converter;
+    typedef converter::from_python_converter<Value const&> const_converter;
+    mutable_converter m_mutable_converter;
+    const_converter m_const_converter;
+};
+
+}} // namespace boost::python
+
+#endif // REFERENCE_FROM_PYTHON_DWA2002130_HPP
diff --git a/include/boost/python/value_from_python.hpp b/include/boost/python/value_from_python.hpp
new file mode 100644
index 00000000..bb4ecf87
--- /dev/null
+++ b/include/boost/python/value_from_python.hpp
@@ -0,0 +1,60 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VALUE_FROM_PYTHON_DWA2002130_HPP
+# define VALUE_FROM_PYTHON_DWA2002130_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+
+namespace boost { namespace python { 
+
+template <typename T, class Derived>
+struct value_from_python
+{
+    value_from_python()
+        : m_converter(
+            &Derived::convertible
+            , &Derived::convert
+            
+            // Change this to a compile-time check later to avoid
+            // generating destroy function
+            , has_trivial_destructor<T>::value ? 0 : &Derived::destroy
+            )
+    {
+        // Scalar types are really converted by-value; the formulation
+        // is much simpler.
+        BOOST_STATIC_ASSERT(!(is_scalar<T>::value));
+    }
+
+    static void* get_storage(converter::from_python_data& data)
+    {
+        return converter::get_storage<T const&>(data);
+    }
+
+    // Mark successful construction
+    static void constructed(converter::from_python_data& data)
+    {
+        data.stage1 = get_storage(data);
+    }
+    
+    inline static void destroy(converter::from_python_data& data)
+    {
+        // Get the location of the storage for
+        void* storage = get_storage(data);
+
+        // Check for successful construction
+        if (data.stage1 == storage)
+            static_cast<T*>(storage)->~T();
+    }
+
+ private:
+    converter::from_python_converter<T const&> m_converter;
+};
+
+}} // namespace boost::python
+
+#endif // VALUE_FROM_PYTHON_DWA2002130_HPP

From 88a8721b89ba445bf83cd2f3272c036f34820302 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 30 Jan 2002 22:18:50 +0000
Subject: [PATCH 240/369] initial checkin

[SVN r12592]
---
 src/converter/builtin_converters.cpp | 153 +++++++++++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 src/converter/builtin_converters.cpp

diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
new file mode 100644
index 00000000..07a00259
--- /dev/null
+++ b/src/converter/builtin_converters.cpp
@@ -0,0 +1,153 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/detail/config.hpp>
+#include <boost/python/detail/wrap_python.hpp>
+#include <boost/python/converter/builtin_converters.hpp>
+#include <boost/python/converter/target.hpp>
+#include <boost/python/converter/from_python.hpp>
+#include <boost/python/reference.hpp>
+#include <boost/cast.hpp>
+//#include <boost/mpl/type_list.hpp>
+#include <string>
+
+namespace boost { namespace python { namespace converter {
+
+namespace
+{
+  struct int_value_functions_base
+  {
+      static void* convertible(PyObject* obj)
+      {
+          PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
+      
+          return number_methods && number_methods->nb_int
+              ? &number_methods->nb_int : 0;
+      }
+  };
+  
+  template <class T>
+  struct int_value_functions : int_value_functions_base
+  {
+      static T convert(PyObject* obj, from_python_data& data)
+      {
+          unaryfunc f = *static_cast<unaryfunc*>(data.stage1);
+          ref int_object(f(obj));
+          return numeric_cast<T>(PyInt_AsLong(int_object.get()));
+      }
+  };
+
+  struct cstring_value_functions
+  {
+      static void* convertible(PyObject* obj)
+      {
+          return PyString_Check(obj) ? obj : 0;
+      }
+      
+      static char const* convert(PyObject* obj, from_python_data&)
+      {
+          return PyString_AsString(obj);
+      }
+  };
+
+  char constructed;
+  
+  struct string_cref_functions
+  {
+      typedef std::string const& result_type;
+      
+      static void* convertible(PyObject* obj)
+      {
+          return obj->ob_type->tp_str ? &obj->ob_type->tp_str : 0;
+      }
+      
+      static std::string const& convert(
+          PyObject* obj, from_python_data& data)
+      {
+          ref string_object((**static_cast<reprfunc*>(data.stage1))(obj));
+          void* storage = get_storage<result_type>(data);
+          std::string* p = new (storage) std::string(PyString_AsString(string_object.get()));
+          
+          // note that construction is successful.
+          data.stage1 = &constructed; 
+          return *p;
+      }
+
+      static void destroy(from_python_data& data)
+      {
+          if (data.stage1 == &constructed)
+          {
+              typedef std::string string_t;
+              void* storage = get_storage<result_type>(data);
+              ((string_t*)storage)->~string_t();
+          }
+      }
+  };
+
+  template <class T, class Base>
+  struct rvalue_const_ref_functions : Base
+  {
+      static T const& convert(PyObject* obj, from_python_data& data)
+      {
+          void* storage = get_storage<T const&>(data);
+          T* p = new (storage) T(Base::convert(obj,data));
+          
+          // note that construction is successful.
+          data.stage1 = &constructed; 
+          return *p;
+      }
+  };
+
+  struct register_int_converters
+  {
+      template <class Ignored, class T>
+      struct apply
+      {
+          typedef void type;
+          
+          static void execute()
+          {
+              typedef int_value_functions<T> value_functions;
+              typedef rvalue_const_ref_functions<T,value_functions> cref_functions;
+              
+              static from_python_converter<T> value_from_python( 
+                  value_functions::convertible 
+                  , value_functions::convert);
+              static from_python_converter<T const&> cref_from_python(
+                  cref_functions::convertible
+                  , cref_functions::convert);
+          };
+      };
+  };
+}  
+
+#define REGISTER_INT_CONVERTERS(U) register_int_converters::apply<void,U>::execute()
+#define REGISTER_INT_CONVERTERS2(U) REGISTER_INT_CONVERTERS(signed U); REGISTER_INT_CONVERTERS(unsigned U)  
+
+
+void initialize_builtin_converters()
+{
+    REGISTER_INT_CONVERTERS2(char);
+    REGISTER_INT_CONVERTERS2(short);
+    REGISTER_INT_CONVERTERS2(int);
+    REGISTER_INT_CONVERTERS2(long);
+//    mpl::for_each<integral_types,void,register_int_converters>::execute();
+
+    static from_python_converter<char const*> cstring_from_python(
+        &cstring_value_functions::convertible
+        , &cstring_value_functions::convert);
+
+    static from_python_converter<char const*const&> cstring_cref_from_python(
+        &rvalue_const_ref_functions<char const*,cstring_value_functions>::convertible
+        , &rvalue_const_ref_functions<char const*, cstring_value_functions>::convert);
+
+    static from_python_converter<std::string const&> string_cref_from_python(
+        &string_cref_functions::convertible
+        , &string_cref_functions::convert
+        , &string_cref_functions::destroy);
+}
+
+}}} // namespace boost::python::converter

From 6a75fa83b5b6fab78dbe915563fffc5bb298cf1d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 31 Jan 2002 05:53:54 +0000
Subject: [PATCH 241/369] New conversion methods, builtin converters
 ----------------------------------------------------------------------

Committing in .

Modified Files:
	boost/python/reference_from_python.hpp
	boost/python/value_from_python.hpp
	boost/python/converter/body.hpp
	boost/python/converter/handle.hpp
	libs/python/src/converter/builtin_converters.cpp
	libs/python/test/m1.cpp libs/python/test/m2.cpp
Added Files:
	boost/python/converter/builtin_converters.hpp
	boost/python/converter/builtin_to_python_converters.hpp
	boost/python/converter/from_python.hpp
	boost/python/converter/from_python_data.hpp
	boost/python/converter/from_python_function.hpp
	boost/python/converter/to_python.hpp
	boost/python/converter/to_python_function.hpp
	boost/python/object/auto_ptr_generator.hpp
	boost/python/object/pointer_holder.hpp
	libs/python/src/converter/from_python.cpp
	libs/python/src/converter/to_python.cpp
	libs/python/test/test_builtin_converters.cpp
	libs/python/test/test_builtin_converters.py
Removed Files:
	boost/python/convert.hpp boost/python/converter/unwrap.hpp
	boost/python/converter/unwrapper.hpp
	boost/python/converter/wrap.hpp
	boost/python/converter/wrapper.hpp
	boost/python/object/class_unwrapper.hpp
----------------------------------------------------------------------


[SVN r12596]
---
 include/boost/python/convert.hpp              |  84 -------
 include/boost/python/converter/body.hpp       |   5 -
 .../python/converter/builtin_converters.hpp   |  15 ++
 .../builtin_to_python_converters.hpp          |  75 ++++++
 .../boost/python/converter/from_python.hpp    | 169 +++++++++++++
 .../python/converter/from_python_data.hpp     | 206 +++++++++++++++
 .../python/converter/from_python_function.hpp |  23 ++
 include/boost/python/converter/handle.hpp     |  18 ++
 include/boost/python/converter/to_python.hpp  | 116 +++++++++
 .../python/converter/to_python_function.hpp   |  23 ++
 include/boost/python/converter/unwrap.hpp     | 172 -------------
 include/boost/python/converter/unwrapper.hpp  |  40 ---
 include/boost/python/converter/wrap.hpp       | 167 ------------
 include/boost/python/converter/wrapper.hpp    |  57 -----
 .../python/object/auto_ptr_generator.hpp      |  23 ++
 .../boost/python/object/class_unwrapper.hpp   |  40 ---
 .../boost/python/object/pointer_holder.hpp    | 201 +++++++++++++++
 .../boost/python/reference_from_python.hpp    |  17 +-
 include/boost/python/value_from_python.hpp    |  18 +-
 src/converter/builtin_converters.cpp          | 238 ++++++++++++------
 src/converter/from_python.cpp                 |  27 ++
 src/converter/to_python.cpp                   |  24 ++
 test/m1.cpp                                   |   8 +-
 test/m2.cpp                                   |   3 -
 test/test_builtin_converters.cpp              |  65 +++++
 test/test_builtin_converters.py               |  86 +++++++
 26 files changed, 1259 insertions(+), 661 deletions(-)
 delete mode 100644 include/boost/python/convert.hpp
 create mode 100644 include/boost/python/converter/builtin_converters.hpp
 create mode 100644 include/boost/python/converter/builtin_to_python_converters.hpp
 create mode 100644 include/boost/python/converter/from_python.hpp
 create mode 100644 include/boost/python/converter/from_python_data.hpp
 create mode 100644 include/boost/python/converter/from_python_function.hpp
 create mode 100644 include/boost/python/converter/to_python.hpp
 create mode 100644 include/boost/python/converter/to_python_function.hpp
 delete mode 100644 include/boost/python/converter/unwrap.hpp
 delete mode 100644 include/boost/python/converter/unwrapper.hpp
 delete mode 100644 include/boost/python/converter/wrap.hpp
 delete mode 100644 include/boost/python/converter/wrapper.hpp
 create mode 100644 include/boost/python/object/auto_ptr_generator.hpp
 delete mode 100644 include/boost/python/object/class_unwrapper.hpp
 create mode 100644 include/boost/python/object/pointer_holder.hpp
 create mode 100644 src/converter/from_python.cpp
 create mode 100644 src/converter/to_python.cpp
 create mode 100644 test/test_builtin_converters.cpp
 create mode 100644 test/test_builtin_converters.py

diff --git a/include/boost/python/convert.hpp b/include/boost/python/convert.hpp
deleted file mode 100644
index 5614bd3b..00000000
--- a/include/boost/python/convert.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CONVERT_DWA20011129_HPP
-# define CONVERT_DWA20011129_HPP
-
-# include <boost/python/converter/target.hpp>
-# include <boost/python/converter/source.hpp>
-# include <boost/python/converter/wrap.hpp>
-# include <boost/python/converter/unwrap.hpp>
-
-namespace boost { namespace python {
-
-namespace detail
-{
-  template <class T>
-  struct converter_gen
-  {
-      typedef T value_type;
-      typedef typename converter::source<value_type>::type source_t;
-      typedef converter::wrap_<source_t> wrap_t;
-      typedef converter::wrap_more_<source_t> wrap_more_t;
-
-      typedef typename converter::target<value_type>::type target_t;
-      typedef converter::unwrap_<target_t> unwrap_t;
-      typedef converter::unwrap_more_<target_t> unwrap_more_t;
-  };
-}
-
-template <class T>
-struct wrap : detail::converter_gen<T>::wrap_t
-{
-    typedef typename detail::converter_gen<T>::wrap_t base_t;
-    typedef typename detail::converter_gen<T>::source_t source_t;
-};
-
-template <class T>
-struct wrap_more : detail::converter_gen<T>::wrap_more_t
-{
-    typedef typename detail::converter_gen<T>::wrap_more_t base_t;
-    typedef typename detail::converter_gen<T>::source_t source_t;
-    wrap_more(converter::handle& prev);
-};
-
-template <class T>
-struct unwrap : detail::converter_gen<T>::unwrap_t
-{
-    typedef typename detail::converter_gen<T>::unwrap_t base_t;
-    unwrap(PyObject*);
-};
-
-template <class T>
-struct unwrap_more : detail::converter_gen<T>::unwrap_more_t
-{
-    typedef typename detail::converter_gen<T>::unwrap_more_t base_t;
-    unwrap_more(PyObject*, converter::handle& prev);
-};
-
-//
-// implementations
-//
-template <class T>
-inline wrap_more<T>::wrap_more(converter::handle& prev)
-    : base_t(prev)
-{
-}
-
-template <class T>
-inline unwrap<T>::unwrap(PyObject* source)
-    : base_t(source)
-{
-}
-
-template <class T>
-inline unwrap_more<T>::unwrap_more(PyObject* source, converter::handle& prev)
-    : base_t(source, prev)
-{
-}
-
-}} // namespace boost::python
-
-#endif // CONVERT_DWA20011129_HPP
diff --git a/include/boost/python/converter/body.hpp b/include/boost/python/converter/body.hpp
index 72653ee0..d9170839 100644
--- a/include/boost/python/converter/body.hpp
+++ b/include/boost/python/converter/body.hpp
@@ -10,8 +10,6 @@
 
 namespace boost { namespace python { namespace converter { 
 
-struct BOOST_PYTHON_DECL handle;
-
 namespace registry
 {
   class entry;
@@ -23,9 +21,6 @@ struct BOOST_PYTHON_DECL body
     body(type_id_t key);
     virtual ~body() {}
 
-    // default implementation is a no-op
-    virtual void destroy_handle(handle*) const;
-
     type_id_t key() const;
 
  protected:
diff --git a/include/boost/python/converter/builtin_converters.hpp b/include/boost/python/converter/builtin_converters.hpp
new file mode 100644
index 00000000..9c19cbc5
--- /dev/null
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -0,0 +1,15 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef BUILTIN_CONVERTERS_DWA2002124_HPP
+# define BUILTIN_CONVERTERS_DWA2002124_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+void initialize_builtin_converters();
+
+}}} // namespace boost::python::converter
+
+#endif // BUILTIN_CONVERTERS_DWA2002124_HPP
diff --git a/include/boost/python/converter/builtin_to_python_converters.hpp b/include/boost/python/converter/builtin_to_python_converters.hpp
new file mode 100644
index 00000000..4e9f89e3
--- /dev/null
+++ b/include/boost/python/converter/builtin_to_python_converters.hpp
@@ -0,0 +1,75 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
+# define BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
+# include <string>
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct to_python_lookup;
+
+template <class T>
+struct to_python_int
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(T x) const { return PyInt_FromLong(long(x)); }
+};
+
+# define BOOST_PYTHON_TO_INT(T) \
+    template <> struct to_python_lookup<signed T const&> : to_python_int<signed T const&> {}; \
+    template <> struct to_python_lookup<unsigned T const&> : to_python_int<unsigned T const&> {};
+
+BOOST_PYTHON_TO_INT(char)
+BOOST_PYTHON_TO_INT(short)
+BOOST_PYTHON_TO_INT(int)
+BOOST_PYTHON_TO_INT(long)
+# undef BOOST_TO_PYTHON_INT
+
+template <>
+struct to_python_lookup<char const*const&>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(char const* x) const { return PyString_FromString(x); }
+};
+    
+template <>
+struct to_python_lookup<std::string const&>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(std::string const& x) const
+    {
+        return PyString_FromString(x.c_str());
+    }
+};
+
+template <>
+struct to_python_lookup<float const&>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(float x) const { return PyFloat_FromDouble(x); }
+};
+    
+template <>
+struct to_python_lookup<double const&>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(double x) const { return PyFloat_FromDouble(x); }
+};
+    
+template <>
+struct to_python_lookup<long double const&>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(long double x) const
+    {
+        return PyFloat_FromDouble(x);
+    }
+};
+    
+}}} // namespace boost::python::converter
+
+#endif // BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
new file mode 100644
index 00000000..234f61d1
--- /dev/null
+++ b/include/boost/python/converter/from_python.hpp
@@ -0,0 +1,169 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FROM_PYTHON_DWA2002127_HPP
+# define FROM_PYTHON_DWA2002127_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/converter/body.hpp>
+# include <boost/python/converter/from_python_function.hpp>
+# include <boost/python/converter/from_python_data.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registration.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// The type of convertibility checking functions
+typedef void* (*from_python_check)(PyObject*);
+typedef void (*from_python_destructor)(from_python_data&);
+
+// forward declaration
+template <class T> struct from_python_lookup;
+
+// from_python --
+//    A body class representing a conversion from python to C++.
+
+struct BOOST_PYTHON_DECL from_python_converter_base : body
+{
+    from_python_converter_base(type_id_t, from_python_check); // registers
+    ~from_python_converter_base();         // unregisters
+
+    // Must return non-null iff the conversion will be successful. Any
+    // non-null pointer is acceptable, and will be passed on to the
+    // convert() function, so useful data can be stored there.
+    inline void* convertible(PyObject*) const;
+//    inline type_id_t key() const;
+ private:
+//    type_id_t m_key;
+    from_python_check m_convertible;
+};
+
+
+template <class T>
+struct from_python_converter : from_python_converter_base
+{
+ public: // types
+    typedef typename from_python_function<T>::type conversion_function;
+    
+ public: // member functions    
+    from_python_converter(from_python_check, conversion_function, from_python_destructor = 0);
+    T convert(PyObject*, from_python_data&) const;
+    void destroy(from_python_data&) const;
+    
+ private: // data members
+    conversion_function m_convert;
+    from_python_destructor m_destroy;
+};
+
+// -------------------------------------------------------------------------
+
+//struct from_python_base
+//{
+//};
+
+// A class which implements from_python with a registry lookup.
+template <class T>
+struct from_python_lookup // : from_python_base
+{
+ public: // types
+    
+ public: // member functions
+    from_python_lookup(PyObject* source);
+    ~from_python_lookup();
+
+    bool convertible() const;
+    T operator()(PyObject*);
+
+ public: // functions for use by conversion implementations
+    // Get the converter object
+    from_python_converter<T> const* converter() const;
+    
+ private: // data members
+    typedef typename from_python_intermediate_data<T>::type intermediate_t;
+    mutable intermediate_t m_intermediate_data;
+    from_python_converter<T> const* m_converter;
+};
+
+//
+// implementations
+//
+inline void* from_python_converter_base::convertible(PyObject* o) const
+{
+    return m_convertible(o);
+}
+
+# if 0
+inline type_id_t from_python_converter_base::key() const
+{
+    return m_key;
+}
+# endif 
+
+template <class T>
+inline from_python_converter<T>::from_python_converter(
+     from_python_check checker
+    , conversion_function converter
+    , from_python_destructor destructor // = 0
+    )
+    : from_python_converter_base(type_id<T>(), checker)
+    , m_convert(converter)
+    , m_destroy(destructor)
+{
+    
+}
+
+template <class T>
+inline T from_python_converter<T>::convert(PyObject* src, from_python_data& data) const
+{
+    return this->m_convert(src, data);
+}
+
+template <class T>
+inline void from_python_converter<T>::destroy(from_python_data& data) const
+{
+    if (this->m_destroy)
+    {
+        this->m_destroy(data);
+    }
+}
+
+template <class T>
+inline from_python_lookup<T>::from_python_lookup(PyObject* src)
+    : m_converter(
+        registration<T>::get_from_python(
+            src, m_intermediate_data.stage1))
+{
+}
+
+template <class T>
+inline from_python_lookup<T>::~from_python_lookup()
+{
+    if (m_converter != 0)
+        m_converter->destroy(m_intermediate_data);
+}
+
+template <class T>
+inline bool from_python_lookup<T>::convertible() const
+{
+    return this->m_converter != 0;
+}
+
+template <class T>
+inline T from_python_lookup<T>::operator()(PyObject* obj)
+{
+    return this->m_converter->convert(obj, m_intermediate_data);
+}
+
+template <class T>
+inline from_python_converter<T> const*
+from_python_lookup<T>::converter() const
+{
+    return this->m_converter;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_DWA2002127_HPP
diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
new file mode 100644
index 00000000..3edcbad7
--- /dev/null
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -0,0 +1,206 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+# define FROM_PYTHON_AUX_DATA_DWA2002128_HPP
+
+# include <boost/python/detail/char_array.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/type_traits/same_traits.hpp>
+# include <boost/type.hpp>
+
+// Keep these for the metaprogram which EDG is choking on.
+# if !defined(__EDG__) || (__EDG_VERSION__ > 245)
+#  include <boost/mpl/type_list.hpp>
+#  include <boost/mpl/for_each.hpp>
+#  include <boost/type_traits/alignment_traits.hpp>
+#  include <boost/type_traits/composite_traits.hpp>
+# endif 
+
+namespace boost { namespace python { namespace converter { 
+
+// A POD which is layout-compatible with the real intermediate data
+// for all from_python conversions. There may be additional storage if
+// we are converting a reference type.
+struct from_python_data
+{
+    void* stage1;
+};
+
+namespace detail
+{
+  template <class T> struct referent_alignment;
+  template <class T> struct referent_size;
+  
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  
+  template <class T>
+  struct referent_alignment<T&>
+  {
+      BOOST_STATIC_CONSTANT(
+          std::size_t, value = alignment_of<T>::value);
+  };
+
+  template <class T>
+  struct referent_size<T&>
+  {
+      BOOST_STATIC_CONSTANT(
+          std::size_t, value = sizeof(T));
+  };
+
+# else
+
+  template <class U>
+  struct alignment_chars
+  {
+      BOOST_STATIC_CONSTANT(
+          std::size_T, n = alignment_of<U>::value);
+      char elements[n + 1];
+  };
+
+  template <class T> struct referent_alignment
+  {
+      template <class U>
+      static alignment_chars<U> helper(U&);
+  
+      static T t;
+      
+      BOOST_STATIC_CONSTANT(
+          std::size_t, value = sizeof(helper(t).elements) - 1);
+  };
+
+  
+  template <class T> struct referent_size
+  {
+      static T t;
+      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(t));
+  };
+  
+# endif
+
+  struct unknown_alignment
+  {
+      void* p;
+  };
+  
+// EDG is too slow to handle this metaprogram :(  
+#if !defined(__EDG__) || (__EDG_VERSION__ > 245)
+  struct alignment_dummy;
+
+  template <std::size_t target_alignment>
+  struct best_alignment_type
+  {
+      template <class T1, class T2>
+      struct apply
+      {
+          BOOST_STATIC_CONSTANT(
+              std::size_t, align1 = alignment_of<T1>::value);
+          
+          BOOST_STATIC_CONSTANT(
+              std::size_t, align2 = alignment_of<T2>::value);
+          
+          BOOST_STATIC_CONSTANT(
+              bool, aligned2 = (
+                  (align2 >= target_alignment)
+                  & (align2 % target_alignment == 0))
+              );
+          
+          BOOST_STATIC_CONSTANT(
+              bool, choose_t2 = (
+                  aligned2 && (
+                      is_same<T1,unknown_alignment>::value
+                      | (align2 < alignment_of<T1>::value)
+                      | (sizeof(T2) < sizeof(T1)))
+                  ));
+          
+          typedef mpl::select_type<choose_t2, T2, T1>::type type;
+      };
+  };
+
+  typedef mpl::type_list<
+      char,short,int,long,float,double,long double
+      ,void*
+      ,void(*)()
+      ,void (alignment_dummy::*)()
+      , char (alignment_dummy::*)
+  >
+  align_types;
+#endif // EDG is too slow
+  
+  template <class Align, std::size_t size>
+  struct aligned_storage
+  {
+      typedef Align align_t;
+      union 
+      {
+          Align align;
+          char bytes[size
+                     // this is just a STATIC_ASSERT. For some reason
+                     // MSVC was barfing on the boost one.
+              - (is_same<align_t,unknown_alignment>::value ? size : 0)];
+      };
+  };
+
+  template <class Reference>
+  struct referent_storage
+  {
+// EDG is too slow to handle this metaprogram :(  
+#if !defined(__EDG__) || (__EDG_VERSION__ > 245)
+      typedef mpl::for_each<
+          align_types
+          , unknown_alignment
+          , best_alignment_type<referent_alignment<Reference>::value>
+      > loop;
+      typedef typename loop::state align_t;
+#else
+      // The Python source makes the assumption that double has
+      // maximal alignment anyway
+      typedef double align_t;
+#endif 
+
+      typedef aligned_storage<align_t,referent_size<Reference>::value> type;
+  };
+
+  template <class T>
+  struct intermediate_data : from_python_data
+  {
+      typename referent_storage<T>::type stage2;
+  };
+
+  template <>
+  struct intermediate_data<void> : from_python_data
+  {
+  };
+
+}
+
+// -------------------------------------------------------------------------
+// Auxiliary POD storage where the convertible and/or convert functions of a
+// from_python object may place arbitrary data.
+//
+// Always starts with a void*
+//
+// For references, we produce additional aligned storage sufficient to
+// store the referent
+
+template <class T>
+struct from_python_intermediate_data
+{
+    typedef typename mpl::select_type<
+        is_reference<T>::value, T, void>::type just_reference_t;
+
+    typedef detail::intermediate_data<just_reference_t> type;
+};
+
+template <class T>
+void* get_storage(from_python_data& x, boost::type<T>* = 0)
+{
+    typedef typename from_python_intermediate_data<T>::type layout;
+    return static_cast<layout*>(&x)->stage2.bytes;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP
diff --git a/include/boost/python/converter/from_python_function.hpp b/include/boost/python/converter/from_python_function.hpp
new file mode 100644
index 00000000..0cf90459
--- /dev/null
+++ b/include/boost/python/converter/from_python_function.hpp
@@ -0,0 +1,23 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FROM_PYTHON_FUNCTION_DWA2002128_HPP
+# define FROM_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct from_python_data;
+
+template <class T>
+struct from_python_function
+{
+    typedef T (*type)(PyObject*, from_python_data&);
+};
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_FUNCTION_DWA2002128_HPP
diff --git a/include/boost/python/converter/handle.hpp b/include/boost/python/converter/handle.hpp
index 03671634..bc06be38 100644
--- a/include/boost/python/converter/handle.hpp
+++ b/include/boost/python/converter/handle.hpp
@@ -24,6 +24,7 @@ struct BOOST_PYTHON_DECL handle : boost::noncopyable
     //
     // Constructors taking a handle links this into a chain of
     // handles, for more efficient management in function wrappers
+    handle();
     handle(body* body);
     handle(body* body, handle& prev);
 
@@ -43,6 +44,9 @@ struct BOOST_PYTHON_DECL handle : boost::noncopyable
  protected: // member functions for derived classes
     // Get the body we hold
     inline body* get_body() const;
+
+    inline void set_body(body*);
+    inline void set_prev(handle&);
     
     // Release all bodies in the chain, in reverse order of
     // initialization. Only actually called for the head of the chain.
@@ -59,6 +63,10 @@ struct BOOST_PYTHON_DECL handle : boost::noncopyable
 //
 // implementations
 // 
+inline handle::handle()
+    : m_next(0)
+{}
+
 inline handle::handle(body* body, handle& prev)
     : m_body(body), m_next(0)
 {
@@ -85,6 +93,16 @@ inline body* handle::get_body() const
     return m_body;
 }
 
+inline void handle::set_body(body* body)
+{
+    m_body = body;
+}
+
+inline void handle::set_prev(handle& prev)
+{
+    prev.m_next = this;
+}
+
 }}} // namespace boost::python::converter
 
 #endif // HANDLE_DWA20011130_HPP
diff --git a/include/boost/python/converter/to_python.hpp b/include/boost/python/converter/to_python.hpp
new file mode 100644
index 00000000..61dc7dad
--- /dev/null
+++ b/include/boost/python/converter/to_python.hpp
@@ -0,0 +1,116 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_DWA2002127_HPP
+# define TO_PYTHON_DWA2002127_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/converter/body.hpp>
+# include <boost/python/converter/registration.hpp>
+# include <boost/python/converter/source_holder.hpp>
+# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/builtin_to_python_converters.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+template <class T> struct to_python_lookup;
+
+struct BOOST_PYTHON_DECL to_python_converter_base : body
+{
+    to_python_converter_base(type_id_t, to_python_function_base); // registers
+    ~to_python_converter_base();         // unregisters
+    
+//    inline type_id_t key() const;
+    inline to_python_function_base converter() const;
+ private:
+//    type_id_t m_key;
+    to_python_function_base m_convert;
+};
+
+template <class T>
+struct to_python_converter : to_python_converter_base
+{
+ public: // types
+    typedef typename to_python_function<T>::type converter_t;
+    
+ public: // member functions
+    to_python_converter(converter_t);
+    converter_t converter() const;
+
+ private: // data members
+    converter_t m_convert;
+};
+
+// -------------------------------------------------------------------------
+
+//struct to_python_base {};
+
+template <class T>
+struct to_python_lookup //: to_python_base
+{
+ public: // member functions
+    to_python_lookup();
+    bool convertible() const;
+    PyObject* operator()(T) const;
+ private:
+    typename to_python_function<T>::type m_convert;
+};
+
+//
+// implementations
+//
+# if 0
+inline type_id_t
+to_python_converter_base::key() const
+{
+    return m_key;
+}
+# endif
+
+inline to_python_function_base
+to_python_converter_base::converter() const
+{
+    return m_convert;
+}
+
+template <class T>
+to_python_converter<T>::to_python_converter(converter_t convert)
+    : to_python_converter_base(
+        type_id<T>(), reinterpret_cast<to_python_function_base>(convert))
+{
+}
+
+template <class T>
+inline typename to_python_function<T>::type
+to_python_converter<T>::converter() const
+{
+    return reinterpret_cast<converter_t>(
+        this->to_python_converter_base::converter());
+}
+
+template <class T>
+inline to_python_lookup<T>::to_python_lookup()
+    : m_convert(
+        registration<T>::get_to_python())
+{
+}
+
+template <class T>
+inline bool
+to_python_lookup<T>::convertible() const
+{
+    return m_converter != 0;
+}
+
+template <class T>
+inline PyObject*
+to_python_lookup<T>::operator()(T x) const
+{
+    return m_convert ? m_convert(x) : 0;
+}
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_DWA2002127_HPP
diff --git a/include/boost/python/converter/to_python_function.hpp b/include/boost/python/converter/to_python_function.hpp
new file mode 100644
index 00000000..9d408749
--- /dev/null
+++ b/include/boost/python/converter/to_python_function.hpp
@@ -0,0 +1,23 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+typedef PyObject* (*to_python_function_base)(void);
+
+template <class T>
+struct to_python_function
+{
+    typedef PyObject*(*type)(T);
+};
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_FUNCTION_DWA2002128_HPP
diff --git a/include/boost/python/converter/unwrap.hpp b/include/boost/python/converter/unwrap.hpp
deleted file mode 100644
index eccb0992..00000000
--- a/include/boost/python/converter/unwrap.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-#error obsolete 
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAP_BASE_DWA20011130_HPP
-# define UNWRAP_BASE_DWA20011130_HPP
-
-# include <boost/python/converter/unwrapper_base.hpp>
-# include <boost/python/converter/unwrapper.hpp>
-# include <boost/python/converter/handle.hpp>
-# include <boost/python/converter/registration.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/unwrapper_select.hpp>
-# include <boost/python/detail/config.hpp>
-# include <boost/type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct unwrapper;
-struct BOOST_PYTHON_DECL body;
-
-struct BOOST_PYTHON_DECL unwrap_base : handle
-{
- public: // member functions
-    inline unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*>, handle& prev);
-    inline unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*>);
-    inline PyObject* source() const;
-    
-    inline void*& data();
-    
- protected:
-    inline PyObject*& source();
-        
- private: // data members
-    PyObject* m_source;
-    void* m_data;
-};
-
-// These converters will be used by the function wrappers. They don't
-// manage any resources, but are instead linked into a chain which is
-// managed by an instance of unwrap_ or wrap_.
-template <class T>
-struct unwrap_more_ : unwrap_base
-{
- public: // member functions
-    // Construction
-    unwrap_more_(PyObject* source, handle& prev);
-
-    // invoke the conversion or throw an exception if unsuccessful
-    T operator*();
-
- protected: // constructor
-    // this constructor is only for the use of unwrap_
-    unwrap_more_(PyObject* source);
-
- private:
-    typedef typename unwrapper_select<T>::type unwrapper_t;
-};
-
-// specialization for PyObject*
-template <>
-struct unwrap_more_<PyObject*>
-    : unwrap_base
-{
- public: // member functions
-    // Construction
-    unwrap_more_(PyObject* source, handle& prev)
-        : unwrap_base(source, m_unwrapper, prev)
-    {
-    }
-
-
-    // invoke the conversion or throw an exception if unsuccessful
-    PyObject* operator*()
-    {
-        return source();
-    }
-        
-    void* can_convert(PyObject*) const
-    {
-        return &m_unwrapper;
-    }
-    
- protected: // constructor
-    // this constructor is only for the use of unwrap_
-    unwrap_more_(PyObject* source)
-    : unwrap_base(source, m_unwrapper)
-
-    {
-    }
- private:
-    static BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*>& m_unwrapper;
-};
-
-template <class T>
-struct unwrap_ : unwrap_more_<T>
-{
-    unwrap_(PyObject* source);
-    ~unwrap_();
-};
-
-//
-// implementations
-//
-inline unwrap_base::unwrap_base(
-    PyObject* source, std::pair<unwrapper_base*,void*> unwrapper, handle& prev)
-    : handle(unwrapper.first, prev)
-    , m_source(source)
-    , m_data(unwrapper.second)
-{
-}
-
-inline unwrap_base::unwrap_base(PyObject* source, std::pair<unwrapper_base*,void*> unwrapper)
-    : handle(unwrapper.first)
-    , m_source(source)
-    , m_data(unwrapper.second)
-{
-}
-
-inline void*& unwrap_base::data()
-{
-    return m_data;
-}
-
-inline PyObject* unwrap_base::source() const
-{
-    return m_source;
-}
-
-inline PyObject*& unwrap_base::source()
-{
-    return m_source;
-}
-
-template <class T>
-unwrap_more_<T>::unwrap_more_(PyObject* source, handle& prev)
-    : unwrap_base(source,
-                  registration<T>::unwrapper(source),
-                  prev)
-{
-}
-
-template <class T>
-unwrap_more_<T>::unwrap_more_(PyObject* source)
-    : unwrap_base(source, registration<T>::unwrapper(source))
-{
-}
-
-template <class T>
-inline unwrap_<T>::unwrap_(PyObject* source)
-    : unwrap_more_<T>(source)
-{
-}
-
-template <class T>
-T unwrap_more_<T>::operator*()
-{
-    return static_cast<unwrapper<T>*>(
-        get_body())->convert(this->source(), this->data(), boost::type<T>());
-}
-
-template <class T>
-unwrap_<T>::~unwrap_()
-{
-    this->destroy();
-}
-    
-}}} // namespace boost::python::converter
-
-#endif // UNWRAP_BASE_DWA20011130_HPP
diff --git a/include/boost/python/converter/unwrapper.hpp b/include/boost/python/converter/unwrapper.hpp
deleted file mode 100644
index 8a16e957..00000000
--- a/include/boost/python/converter/unwrapper.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#error obsolete 
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAPPER_DWA2001127_HPP
-# define UNWRAPPER_DWA2001127_HPP
-
-# include <boost/python/converter/unwrapper_base.hpp>
-# include <boost/python/converter/unwrap.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct unwrap_more_;
-
-// Abstract base for all unwrappers of Ts
-template <class T>
-struct unwrapper : unwrapper_base
-{
- public:
-    unwrapper();
-
-    virtual T convert(PyObject*, void*& data, boost::type<T>) const = 0;
-};
-
-//
-// implementations
-//
-template <class T>
-unwrapper<T>::unwrapper()
-    : unwrapper_base(type_id<T>())
-{
-}
-
-}}} // namespace boost::python::converter
-
-#endif // UNWRAPPER_DWA2001127_HPP
diff --git a/include/boost/python/converter/wrap.hpp b/include/boost/python/converter/wrap.hpp
deleted file mode 100644
index b61fff19..00000000
--- a/include/boost/python/converter/wrap.hpp
+++ /dev/null
@@ -1,167 +0,0 @@
-#error obsolete 
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef WRAP_DWA2001127_HPP
-# define WRAP_DWA2001127_HPP
-# include <boost/python/converter/registration.hpp>
-# include <boost/python/converter/handle.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/converter/wrapper.hpp>
-# include <boost/python/detail/config.hpp>
-# include <boost/python/converter/source_holder.hpp>
-# include <boost/python/converter/wrapper_base.hpp>
-# include <cassert>
-
-namespace boost { namespace python { namespace converter { 
-
-extern BOOST_PYTHON_DECL body& identity_wrapper;
-
-template <class T> struct wrapper;
-
-struct wrap_base : handle
-{
- public: // member functions
-    wrap_base(body*, handle& prev);
-    wrap_base(body*);
-    PyObject* release();
-    
- public: // accessor, really only for wrappers
-    PyObject*& target() const;
-    
- protected:
-    void hold_result(PyObject*) const;
-    
- private: 
-    mutable PyObject* m_target;
-};
-
-template <class T>
-struct wrap_more_ : wrap_base
-{
- protected:
-    typedef T source_t;
-    
- public: // member functions
-    wrap_more_(handle& prev);
-
-    PyObject* operator()(source_t) const;
-
- protected: // constructor for wrap_<T>, below
-    wrap_more_();
-    
- private: // helper functions
-    static wrapper_base* lookup();
-    
- private:
-    friend class wrapper<T>;
-};
-
-template <class T>
-struct wrap_ : wrap_more_<T>
-{
-    typedef typename wrap_more_<T>::source_t source_t;
- public: // member functions
-    wrap_();
-    ~wrap_();
-};
-
-
-// Specialization for PyObject*
-template <>
-struct wrap_more_<PyObject*> : wrap_base
-{
- protected:
-    typedef PyObject* source_t;
-    
- public: // member functions
-    wrap_more_(handle& prev)
-        : wrap_base(&identity_wrapper, prev) {}
-
-    PyObject* operator()(source_t x) const { return x; }
-
- protected: // constructor for wrap_<T>, below
-    wrap_more_()
-        : wrap_base(&identity_wrapper) {}
- private:
-    friend class wrapper<PyObject*>;
-};
-
-//
-// implementations
-//
-inline wrap_base::wrap_base(body* body, handle& prev)
-    : handle(body, prev)
-      , m_target(0)
-{
-}
-
-inline wrap_base::wrap_base(body* body)
-    : handle(body),
-      m_target(0)
-{
-}
-
-inline PyObject*& wrap_base::target() const
-{
-    return m_target;
-}
-
-inline void wrap_base::hold_result(PyObject* p) const
-{
-    assert(m_target == 0);
-    m_target = p;
-}
-
-inline PyObject* wrap_base::release()
-{
-    PyObject* result = m_target;
-    m_target = 0;
-    return result;
-}
-
-template <class T>
-inline wrapper_base* wrap_more_<T>::lookup()
-{
-    // Find the converters registered for T and get a wrapper
-    // appropriate for the source object
-    return registration<T>::wrapper();
-}
-
-template <class T>
-inline wrap_more_<T>::wrap_more_(handle& prev)
-    : wrap_base(lookup(), prev)
-{
-    
-}
-
-template <class T>
-PyObject* wrap_more_<T>::operator()(source_t x) const
-{
-    return static_cast<wrapper<T>*>(
-        this->get_body())->do_conversion(*this, source_holder<T>(x));
-}
-
-template <class T>
-wrap_more_<T>::wrap_more_()
-    : wrap_base(lookup())
-{
-}
-
-template <class T>
-wrap_<T>::wrap_()
-    : wrap_more_<T>()
-{
-}
-
-template <class T>
-wrap_<T>::~wrap_()
-{
-    this->destroy();
-}
-
-}}} // namespace boost::python::converter
-
-#endif // WRAP_DWA2001127_HPP
diff --git a/include/boost/python/converter/wrapper.hpp b/include/boost/python/converter/wrapper.hpp
deleted file mode 100644
index e20ed404..00000000
--- a/include/boost/python/converter/wrapper.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#error obsolete 
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef WRAPPER_DWA2001127_HPP
-# define WRAPPER_DWA2001127_HPP
-# include <boost/python/converter/wrapper_base.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/wrap.hpp>
-# include <boost/python/converter/source_holder.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-extern BOOST_PYTHON_DECL body& identity_wrapper;
-
-template <class T>
-struct wrapper : wrapper_base
-{
- public:
-    wrapper();
-    
-    PyObject* do_conversion(wrap_base const&, source_holder_base const&) const;
-    
-    // This does the actual conversion
-    virtual PyObject* convert(T source) const = 0;
-};
-
-//
-// implementations
-//
-
-template <class T>
-wrapper<T>::wrapper()
-    : wrapper_base(type_id<T>())
-{
-}
-
-
-template <class T>
-PyObject* wrapper<T>::do_conversion(wrap_base const& handle_, source_holder_base const& data_) const
-{
-    // Casting pointers instead of references suppresses a CWPro7 bug.
-    wrap_more_<T> const& handle = *static_cast<wrap_more_<T> const*>(&handle_);
-    source_holder<T> const& data = *static_cast<source_holder<T> const*>(&data_);
-    if (handle.target() == 0)
-    {
-        handle.hold_result(convert(data.value));
-    }
-    return handle.target();
-}
-
-}}} // namespace boost::python::converter
-
-#endif // WRAPPER_DWA2001127_HPP
diff --git a/include/boost/python/object/auto_ptr_generator.hpp b/include/boost/python/object/auto_ptr_generator.hpp
new file mode 100644
index 00000000..9c13e436
--- /dev/null
+++ b/include/boost/python/object/auto_ptr_generator.hpp
@@ -0,0 +1,23 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef AUTO_PTR_GENERATOR_DWA2002123_HPP
+# define AUTO_PTR_GENERATOR_DWA2002123_HPP
+# include <memory>
+
+namespace boost { namespace python { namespace object { 
+
+struct auto_ptr_generator
+{
+    template <class T>
+    struct apply
+    {
+        typedef std::auto_ptr<T> type;
+    };
+};
+
+}}} // namespace boost::python::object
+
+#endif // AUTO_PTR_GENERATOR_DWA2002123_HPP
diff --git a/include/boost/python/object/class_unwrapper.hpp b/include/boost/python/object/class_unwrapper.hpp
deleted file mode 100644
index 0877ff24..00000000
--- a/include/boost/python/object/class_unwrapper.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CLASS_UNWRAPPER_DWA20011221_HPP
-# define CLASS_UNWRAPPER_DWA20011221_HPP
-
-# include <boost/python/object/class.hpp>
-# include <boost/python/converter/unwrapper.hpp>
-
-namespace boost { namespace python { namespace objects { 
-
-template <class T>
-struct class_unwrapper
-{
- private:
-    template <class Target>
-    struct reference_unwrapper : converter::unwrapper<Target>
-    {
-        void* can_convert(PyObject* p) const
-        {
-            return find_instance<T>(p);
-        }
-        
-        Target convert(PyObject* p, void* data, ) const
-        {
-            return *find_instance<T>(p)->target();
-        }
-    };
-    
-    reference_unwrapper<T&> m_reference;
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    reference_unwrapper<T const&> m_const_reference;
-# endif 
-};
-
-}}} // namespace boost::python::objects
-
-#endif // CLASS_UNWRAPPER_DWA20011221_HPP
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
new file mode 100644
index 00000000..81fcac0c
--- /dev/null
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -0,0 +1,201 @@
+// Copyright David Abrahams 2001. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef POINTER_HOLDER_DWA20011215_HPP
+# define POINTER_HOLDER_DWA20011215_HPP
+
+# include <boost/python/object/class.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/object/inheritance.hpp>
+# include <boost/python/detail/eval.hpp>
+# include <boost/ref.hpp>
+# include <boost/type.hpp>
+
+namespace boost { namespace python { namespace objects { 
+
+template <class Pointer, class Value>
+struct pointer_holder : instance_holder
+{
+    pointer_holder(Pointer);
+    
+    // Forward construction to the held object
+    pointer_holder(PyObject*)
+        : m_p(new Value) {}
+
+    
+    template <class A1>
+    pointer_holder(PyObject*, A1 a1)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+                  ))
+    {}
+    
+    template <class A1, class A2>
+    pointer_holder(PyObject*, A1 a1, A2 a2)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            )) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            )) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            , (unwrap_reference<A8>::type&)(a8)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            , (unwrap_reference<A8>::type&)(a8)
+            , (unwrap_reference<A9>::type&)(a9)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
+        : m_p(new Value(
+            (unwrap_reference<A1>::type&)(a1)
+            , (unwrap_reference<A2>::type&)(a2)
+            , (unwrap_reference<A3>::type&)(a3)
+            , (unwrap_reference<A4>::type&)(a4)
+            , (unwrap_reference<A5>::type&)(a5)
+            , (unwrap_reference<A6>::type&)(a6)
+            , (unwrap_reference<A7>::type&)(a7)
+            , (unwrap_reference<A8>::type&)(a8)
+            , (unwrap_reference<A9>::type&)(a9)
+            , (unwrap_reference<A10>::type&)(a10)
+            ))
+    {}
+
+ private: // required holder implementation
+    void* holds(converter::type_id_t);
+
+ private: // data members
+    Pointer m_p;
+};
+
+}}}
+
+// back to namespace boost for this forward declaration
+namespace boost
+{
+  template <class T> class shared_ptr;
+}
+
+namespace boost { namespace python { namespace objects {
+
+struct shared_ptr_generator
+{
+    template <class T>
+    struct apply
+    {
+        typedef boost::shared_ptr<T> type;
+    };
+};
+
+// A generator metafunction which can be passed to make_holder
+// PointerGenerator should be another generator metafunction which
+// makes the appropriate (smart) pointer type to hold the argument to
+// pointer_holder_generator.
+template <class PointerGenerator>
+struct pointer_holder_generator
+{
+    template <class Held>
+    struct apply
+    {
+        typedef typename detail::eval<PointerGenerator,Held>::type pointer;
+        typedef pointer_holder<pointer, Held> type;
+    };
+};
+
+template <class Pointer, class Value>
+pointer_holder<Pointer,Value>::pointer_holder(Pointer p)
+    : m_p(p)
+{
+}
+
+template <class Pointer, class Value>
+void* pointer_holder<Pointer, Value>::holds(converter::type_id_t dst_t)
+{
+    if (dst_t == converter::type_id<Pointer>())
+        return &this->m_p;
+
+    converter::type_id_t src_t = converter::type_id<Value>();
+    return src_t == dst_t ? &*this->m_p
+        : find_dynamic_type(&*this->m_p, src_t, dst_t);
+}
+
+}}} // namespace boost::python::objects
+
+#endif // POINTER_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/reference_from_python.hpp b/include/boost/python/reference_from_python.hpp
index 8e7b9b6c..a9631dc5 100644
--- a/include/boost/python/reference_from_python.hpp
+++ b/include/boost/python/reference_from_python.hpp
@@ -26,23 +26,28 @@ template <
     PyTypeObject const* python_type
     , class Value
     , class PythonObject
-    , Value& (*extract)(PythonObject&)
+    , class Extract
     >
-struct reference_from_python : type_from_python<python_type>
+struct reference_from_python
 {
+    typedef type_from_python<python_type> convertible_t;
+    
     reference_from_python()
-        : m_mutable_converter(convertible, convert_mutable)
-        , m_const_converter(convertible, convert_const)
+        : m_mutable_converter(
+            &convertible_t::convertible, convert_mutable)
+        
+        , m_const_converter(
+            &convertible_t::convertible, convert_const)
     {}
     
     static Value& convert_mutable(PyObject* op, converter::from_python_data&)
     {
-        return extract(*(PythonObject*)op);
+        return Extract::execute(*(PythonObject*)op);
     }
     
     static Value const& convert_const(PyObject* op, converter::from_python_data&)
     {
-        return extract(*(PythonObject*)op);
+        return Extract::execute(*(PythonObject*)op);
     }
     
  private:
diff --git a/include/boost/python/value_from_python.hpp b/include/boost/python/value_from_python.hpp
index bb4ecf87..0ff80323 100644
--- a/include/boost/python/value_from_python.hpp
+++ b/include/boost/python/value_from_python.hpp
@@ -9,12 +9,27 @@
 # include <boost/python/converter/from_python.hpp>
 # include <boost/type_traits/object_traits.hpp>
 # include <boost/mpl/select_type.hpp>
+# include <boost/static_assert.hpp>
 
 namespace boost { namespace python { 
 
 template <typename T, class Derived>
 struct value_from_python
 {
+    typedef converter::from_python_check from_python_check;
+    
+    value_from_python(from_python_check convertible)
+        : m_converter(
+            convertible
+            , &Derived::convert
+            
+            // Change this to a compile-time check later to avoid
+            // generating destroy function
+            , has_trivial_destructor<T>::value ? 0 : &Derived::destroy
+            )
+    {
+    }
+
     value_from_python()
         : m_converter(
             &Derived::convertible
@@ -25,9 +40,6 @@ struct value_from_python
             , has_trivial_destructor<T>::value ? 0 : &Derived::destroy
             )
     {
-        // Scalar types are really converted by-value; the formulation
-        // is much simpler.
-        BOOST_STATIC_ASSERT(!(is_scalar<T>::value));
     }
 
     static void* get_storage(converter::from_python_data& data)
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 07a00259..c2ce3dae 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -8,7 +8,8 @@
 #include <boost/python/detail/wrap_python.hpp>
 #include <boost/python/converter/builtin_converters.hpp>
 #include <boost/python/converter/target.hpp>
-#include <boost/python/converter/from_python.hpp>
+#include <boost/python/value_from_python.hpp>
+#include <boost/python/converter/from_python_data.hpp>
 #include <boost/python/reference.hpp>
 #include <boost/cast.hpp>
 //#include <boost/mpl/type_list.hpp>
@@ -18,113 +19,185 @@ namespace boost { namespace python { namespace converter {
 
 namespace
 {
-  struct int_value_functions_base
+  // Only an object which we know is holding a char const* can be
+  // converted to one
+  struct convertible_to_cstring
   {
-      static void* convertible(PyObject* obj)
+      static unaryfunc* execute(PyObject* obj)
       {
-          PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
-      
-          return number_methods && number_methods->nb_int
-              ? &number_methods->nb_int : 0;
-      }
-  };
-  
-  template <class T>
-  struct int_value_functions : int_value_functions_base
-  {
-      static T convert(PyObject* obj, from_python_data& data)
-      {
-          unaryfunc f = *static_cast<unaryfunc*>(data.stage1);
-          ref int_object(f(obj));
-          return numeric_cast<T>(PyInt_AsLong(int_object.get()));
+          return PyString_Check(obj) ? &obj->ob_type->tp_str : 0;
       }
   };
 
-  struct cstring_value_functions
+  struct extract_cstring
   {
-      static void* convertible(PyObject* obj)
-      {
-          return PyString_Check(obj) ? obj : 0;
-      }
-      
-      static char const* convert(PyObject* obj, from_python_data&)
+      static char const* execute(PyObject* obj)
       {
           return PyString_AsString(obj);
       }
   };
 
-  char constructed;
-  
-  struct string_cref_functions
+  // Any object which can be converted to a Python string can also be
+  // converted to a C++ string, since the latter owns its bytes.
+  struct convertible_to_string
   {
-      typedef std::string const& result_type;
-      
-      static void* convertible(PyObject* obj)
+      static unaryfunc* execute(PyObject* obj)
       {
           return obj->ob_type->tp_str ? &obj->ob_type->tp_str : 0;
       }
+  };
+  
+  // Transform a function returning a unaryfunc* into one that returns a void*
+  template <class F>
+  struct return_void_ptr
+  {
+      static void* execute(PyObject* p) { return F::execute(p); }
+  };
+  
+  template <
+      class T                   // The target type
+      , class Convertible       // returns a pointer to a unaryfunc producing an object
+      , class TExtract          // ...from which TExtract extracts T's constructor argument
+      >
+  struct tp_scalar_from_python
+      : from_python_converter<T>
+  {
+   private:
+      typedef return_void_ptr<Convertible> convertible_fn;
       
-      static std::string const& convert(
-          PyObject* obj, from_python_data& data)
+   public:
+      tp_scalar_from_python()
+          : from_python_converter<T>(
+              &convertible_fn::execute
+              , convert)
+      {}
+      
+      static T convert(PyObject* obj, from_python_data& data)
       {
-          ref string_object((**static_cast<reprfunc*>(data.stage1))(obj));
-          void* storage = get_storage<result_type>(data);
-          std::string* p = new (storage) std::string(PyString_AsString(string_object.get()));
+          unaryfunc converter = *(unaryfunc*)data.stage1;
+          ref converted(converter(obj));
+          return TExtract::execute(converted.get());
+      }
+  };
+
+  // Extract a reference to T using the functions in the source
+  // object's type slots
+  template <
+      class T                   // The target type
+      , class Convertible       // returns a pointer to a unaryfunc producing an object
+      , class TExtract          // ...from which TExtract extracts T's constructor argument
+      >
+  struct tp_cref_from_python
+      : value_from_python<T, tp_cref_from_python<T,Convertible,TExtract> >
+  {
+   private:
+      typedef value_from_python<T, tp_cref_from_python<T,Convertible,TExtract> > base;
+      
+   public:
+      tp_cref_from_python()
+          : base(&return_void_ptr<Convertible>::execute)
+      {}
+      
+      static T const& convert(PyObject* obj, from_python_data& data)
+      {
+          unaryfunc converter = *(unaryfunc*)data.stage1;
+          
+          void* storage = get_storage(data);
+          
+          ref converted(converter(obj));
+              
+          T* const p = new (storage) T(TExtract::execute(converted.get()));
           
           // note that construction is successful.
-          data.stage1 = &constructed; 
+          data.stage1 = p;
+          
           return *p;
       }
+  };
 
-      static void destroy(from_python_data& data)
+  struct convertible_to_int
+  {
+      static unaryfunc* execute(PyObject* obj)
       {
-          if (data.stage1 == &constructed)
+          PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
+          if (number_methods == 0)
+              return 0;
+
+          // For floating types, return the float conversion slot to avoid
+          // creating a new object. We'll handle that in
+          // py_int_or_float_as_long, below
+          if (PyObject_TypeCheck(obj, &PyFloat_Type) && number_methods->nb_float)
+              return &number_methods->nb_float;
+      
+          return number_methods && number_methods->nb_int
+              ? &number_methods->nb_int : 0;
+      }
+  };
+
+  struct py_int_or_float_as_long
+  {
+      static long execute(PyObject* obj)
+      {
+          if (PyObject_TypeCheck(obj, &PyFloat_Type))
           {
-              typedef std::string string_t;
-              void* storage = get_storage<result_type>(data);
-              ((string_t*)storage)->~string_t();
+              return numeric_cast<long>(PyFloat_AS_DOUBLE(obj));
+          }
+          else
+          {
+              return PyInt_AS_LONG(obj);
           }
       }
   };
 
-  template <class T, class Base>
-  struct rvalue_const_ref_functions : Base
+  struct convertible_to_double
   {
-      static T const& convert(PyObject* obj, from_python_data& data)
+      static unaryfunc* execute(PyObject* obj)
       {
-          void* storage = get_storage<T const&>(data);
-          T* p = new (storage) T(Base::convert(obj,data));
-          
-          // note that construction is successful.
-          data.stage1 = &constructed; 
-          return *p;
+          PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
+          if (number_methods == 0)
+              return 0;
+
+          // For integer types, return the tp_int conversion slot to avoid
+          // creating a new object. We'll handle that in
+          // py_float_or_int_as_double, below
+          if (PyObject_TypeCheck(obj, &PyInt_Type) && number_methods->nb_int)
+              return &number_methods->nb_int;
+      
+          return number_methods && number_methods->nb_float
+              ? &number_methods->nb_float : 0;
       }
   };
 
-  struct register_int_converters
+  struct py_float_or_int_as_double
   {
-      template <class Ignored, class T>
-      struct apply
+      static double execute(PyObject* obj)
       {
-          typedef void type;
-          
-          static void execute()
+          if (PyObject_TypeCheck(obj, &PyInt_Type))
           {
-              typedef int_value_functions<T> value_functions;
-              typedef rvalue_const_ref_functions<T,value_functions> cref_functions;
-              
-              static from_python_converter<T> value_from_python( 
-                  value_functions::convertible 
-                  , value_functions::convert);
-              static from_python_converter<T const&> cref_from_python(
-                  cref_functions::convertible
-                  , cref_functions::convert);
-          };
-      };
+              return PyInt_AS_LONG(obj);
+          }
+          else
+          {
+              return PyFloat_AS_DOUBLE(obj);
+          }
+      }
   };
-}  
 
-#define REGISTER_INT_CONVERTERS(U) register_int_converters::apply<void,U>::execute()
+  template <class T, class Convertible, class Convert>
+  struct scalar_from_python
+  {
+      tp_cref_from_python<T,Convertible,Convert> cref_converter;
+      tp_scalar_from_python<T,Convertible,Convert> value_converter;
+  };
+  
+  template <class T>
+  void register_int_converters(T* = 0)
+  {
+      static scalar_from_python<T, convertible_to_int, py_int_or_float_as_long> x;
+  };
+}    
+
+#define REGISTER_INT_CONVERTERS(U) register_int_converters<U>()
 #define REGISTER_INT_CONVERTERS2(U) REGISTER_INT_CONVERTERS(signed U); REGISTER_INT_CONVERTERS(unsigned U)  
 
 
@@ -134,20 +207,21 @@ void initialize_builtin_converters()
     REGISTER_INT_CONVERTERS2(short);
     REGISTER_INT_CONVERTERS2(int);
     REGISTER_INT_CONVERTERS2(long);
-//    mpl::for_each<integral_types,void,register_int_converters>::execute();
 
-    static from_python_converter<char const*> cstring_from_python(
-        &cstring_value_functions::convertible
-        , &cstring_value_functions::convert);
+    static scalar_from_python<
+        float,convertible_to_double,py_float_or_int_as_double> float_from_python;
+    
+    static scalar_from_python<
+        double,convertible_to_double,py_float_or_int_as_double> double_from_python;
+    
+    static scalar_from_python<
+        long double,convertible_to_double,py_float_or_int_as_double> long_double_from_python;
+    
+    static scalar_from_python<
+        char const*, convertible_to_cstring, extract_cstring> cstring_from_python;
 
-    static from_python_converter<char const*const&> cstring_cref_from_python(
-        &rvalue_const_ref_functions<char const*,cstring_value_functions>::convertible
-        , &rvalue_const_ref_functions<char const*, cstring_value_functions>::convert);
-
-    static from_python_converter<std::string const&> string_cref_from_python(
-        &string_cref_functions::convertible
-        , &string_cref_functions::convert
-        , &string_cref_functions::destroy);
+    static tp_cref_from_python<
+        std::string, convertible_to_string, extract_cstring> string_from_python;
 }
 
 }}} // namespace boost::python::converter
diff --git a/src/converter/from_python.cpp b/src/converter/from_python.cpp
new file mode 100644
index 00000000..979ad935
--- /dev/null
+++ b/src/converter/from_python.cpp
@@ -0,0 +1,27 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/converter/from_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+from_python_converter_base::from_python_converter_base(
+    type_id_t type
+    , from_python_check checker
+    )
+    : body(type)
+    , m_convertible(checker)
+{
+    registry::insert(*this);
+}
+
+from_python_converter_base::~from_python_converter_base()
+{
+    if (can_unregister())
+        registry::remove(*this);
+}
+
+}}} // namespace boost::python::converter
diff --git a/src/converter/to_python.cpp b/src/converter/to_python.cpp
new file mode 100644
index 00000000..9cede51d
--- /dev/null
+++ b/src/converter/to_python.cpp
@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/converter/to_python.hpp>
+#include <boost/python/converter/registry.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+to_python_converter_base::to_python_converter_base(type_id_t key, to_python_function_base convert)
+    : body(key)
+    , m_convert(convert)
+{
+    registry::insert(*this);
+}
+
+to_python_converter_base::~to_python_converter_base()
+{
+    registry::remove(*this);
+}
+
+}}} // namespace boost::python::converter
diff --git a/test/m1.cpp b/test/m1.cpp
index 6b4c55e1..d422b426 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -64,8 +64,11 @@ struct SimpleObject
 {
     PyObject_HEAD
     simple x;
+};
 
-    static simple& extract(SimpleObject& o) { return o.x; }
+struct extract_simple_object
+{
+    static simple& execute(SimpleObject& o) { return o.x; }
 };
 
 PyTypeObject SimpleType = {
@@ -209,12 +212,13 @@ BOOST_PYTHON_MODULE_INIT(m1)
         &SimpleType
         , simple
         , SimpleObject
-        , &SimpleObject::extract
+        , extract_simple_object
         >
         unwrap_simple;
     
     static to_python_converter<simple&> simple_ref_wrapper(simple_ref_to_python);
 
+    
     module m1("m1");
 
     typedef boost::python::objects::pointer_holder_generator<
diff --git a/test/m2.cpp b/test/m2.cpp
index be2934e0..0a5df161 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -49,9 +49,6 @@ PyObject* unwrap_int_const_ref(int const& x)
     return PyInt_FromLong(x);
 }
 
-// MSVC6 bug workaround
-template <class T> struct xxxx;
-
 // rewrap<T> extracts a T from the argument, then converts the T back
 // to a PyObject* and returns it.
 template <class T>
diff --git a/test/test_builtin_converters.cpp b/test/test_builtin_converters.cpp
new file mode 100644
index 00000000..6ffccdf9
--- /dev/null
+++ b/test/test_builtin_converters.cpp
@@ -0,0 +1,65 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <string>
+#include <boost/python/module.hpp>
+#include <boost/mpl/type_list.hpp>
+#include <boost/mpl/for_each.hpp>
+
+
+template <class T>
+struct by_value
+{
+    static T rewrap(T x)
+    {
+        return x;
+    }
+};
+
+template <class T>
+struct by_const_reference
+{
+    static T rewrap(T const& x)
+    {
+        return x;
+    }
+};
+
+BOOST_PYTHON_MODULE_INIT(builtin_converters_ext)
+{
+    boost::python::module("builtin_converters_ext")
+        
+        .def("rewrap_value_signed_char", by_value<signed char>::rewrap)
+        .def("rewrap_value_unsigned_char", by_value<unsigned char>::rewrap)
+        .def("rewrap_value_int", by_value<int>::rewrap)
+        .def("rewrap_value_unsigned_int", by_value<unsigned int>::rewrap)
+        .def("rewrap_value_short", by_value<short>::rewrap)
+        .def("rewrap_value_unsigned_short", by_value<unsigned short>::rewrap)
+        .def("rewrap_value_long", by_value<long>::rewrap)
+        .def("rewrap_value_unsigned_long", by_value<unsigned long>::rewrap)
+        .def("rewrap_value_float", by_value<float>::rewrap)
+        .def("rewrap_value_double", by_value<double>::rewrap)
+        .def("rewrap_value_long_double", by_value<long double>::rewrap)
+        .def("rewrap_value_string", by_value<std::string>::rewrap)
+        .def("rewrap_value_cstring", by_value<char const*>::rewrap)
+
+
+        .def("rewrap_const_reference_signed_char", by_const_reference<signed char>::rewrap)
+        .def("rewrap_const_reference_unsigned_char", by_const_reference<unsigned char>::rewrap)
+        .def("rewrap_const_reference_int", by_const_reference<int>::rewrap)
+        .def("rewrap_const_reference_unsigned_int", by_const_reference<unsigned int>::rewrap)
+        .def("rewrap_const_reference_short", by_const_reference<short>::rewrap)
+        .def("rewrap_const_reference_unsigned_short", by_const_reference<unsigned short>::rewrap)
+        .def("rewrap_const_reference_long", by_const_reference<long>::rewrap)
+        .def("rewrap_const_reference_unsigned_long", by_const_reference<unsigned long>::rewrap)
+        .def("rewrap_const_reference_float", by_const_reference<float>::rewrap)
+        .def("rewrap_const_reference_double", by_const_reference<double>::rewrap)
+        .def("rewrap_const_reference_long_double", by_const_reference<long double>::rewrap)
+        .def("rewrap_const_reference_string", by_const_reference<std::string>::rewrap)
+        .def("rewrap_const_reference_cstring", by_const_reference<char const*>::rewrap)
+        
+        ;
+}
+
diff --git a/test/test_builtin_converters.py b/test/test_builtin_converters.py
new file mode 100644
index 00000000..3941a29c
--- /dev/null
+++ b/test/test_builtin_converters.py
@@ -0,0 +1,86 @@
+"""
+>>> from builtin_converters_ext import *
+>>> rewrap_value_signed_char(42)
+42
+>>> rewrap_value_unsigned_char(42)
+42
+>>> rewrap_value_int(42)
+42
+>>> rewrap_value_unsigned_int(42)
+42
+>>> rewrap_value_short(42)
+42
+>>> rewrap_value_unsigned_short(42)
+42
+>>> rewrap_value_long(42)
+42
+>>> rewrap_value_unsigned_long(42)
+42
+
+>>> abs(rewrap_value_float(4.2) - 4.2) < .000001
+1
+>>> rewrap_value_double(4.2) - 4.2
+0.0
+>>> rewrap_value_long_double(4.2) - 4.2
+0.0
+
+>>> rewrap_value_cstring('hello, world')
+'hello, world'
+>>> rewrap_value_string('yo, wassup?')
+'yo, wassup?'
+
+>>> rewrap_const_reference_signed_char(42)
+42
+>>> rewrap_const_reference_unsigned_char(42)
+42
+>>> rewrap_const_reference_int(42)
+42
+>>> rewrap_const_reference_unsigned_int(42)
+42
+>>> rewrap_const_reference_short(42)
+42
+>>> rewrap_const_reference_unsigned_short(42)
+42
+>>> rewrap_const_reference_long(42)
+42
+>>> rewrap_const_reference_unsigned_long(42)
+42
+>>> abs(rewrap_const_reference_float(4.2) - 4.2) < .000001
+1
+>>> rewrap_const_reference_double(4.2) - 4.2
+0.0
+>>> rewrap_const_reference_long_double(4.2) - 4.2
+0.0
+
+>>> rewrap_const_reference_cstring('hello, world')
+'hello, world'
+>>> rewrap_const_reference_string('yo, wassup?')
+'yo, wassup?'
+
+Now check implicit conversions between floating/integer types
+
+>>> rewrap_const_reference_float(42)
+42.0
+
+>>> rewrap_const_reference_int(42.0)
+42
+
+>>> rewrap_value_float(42)
+42.0
+
+>>> rewrap_value_int(42.0)
+42
+
+"""
+def run(args = None):
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    return doctest.testmod(sys.modules.get(__name__))
+    
+if __name__ == '__main__':
+    print "running..."
+    import sys
+    sys.exit(run()[0])

From b3117c2b02b9793325de5cc231e41327cac74903 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 1 Feb 2002 04:36:46 +0000
Subject: [PATCH 242/369] Use call policies

[SVN r12618]
---
 include/boost/python/converter/smart_ptr.hpp  |  70 ++
 include/boost/python/converter/to_python.hpp  |   2 +-
 include/boost/python/converter/type_id.hpp    |  82 +-
 include/boost/python/copy_const_reference.hpp |  42 +
 .../boost/python/copy_non_const_reference.hpp |  42 +
 .../boost/python/default_call_policies.hpp    |  72 ++
 include/boost/python/detail/caller.hpp        | 220 ++++-
 .../boost/python/detail/indirect_traits.hpp   | 116 +++
 include/boost/python/detail/returning.hpp     | 842 +++++++++++++-----
 include/boost/python/from_python.hpp          |  42 +
 include/boost/python/make_function.hpp        |  15 +-
 include/boost/python/module.hpp               |  16 +-
 .../python/return_internal_reference.hpp      |  45 +
 include/boost/python/return_value_policy.hpp  |  20 +
 include/boost/python/to_python.hpp            |  37 +
 include/boost/python/type_from_python.hpp     |  23 +
 src/objects.cpp                               |   4 +-
 test/m1.cpp                                   |  13 +-
 test/m2.cpp                                   |  28 +-
 19 files changed, 1380 insertions(+), 351 deletions(-)
 create mode 100644 include/boost/python/converter/smart_ptr.hpp
 create mode 100644 include/boost/python/copy_const_reference.hpp
 create mode 100644 include/boost/python/copy_non_const_reference.hpp
 create mode 100644 include/boost/python/default_call_policies.hpp
 create mode 100644 include/boost/python/detail/indirect_traits.hpp
 create mode 100644 include/boost/python/from_python.hpp
 create mode 100644 include/boost/python/return_internal_reference.hpp
 create mode 100644 include/boost/python/return_value_policy.hpp
 create mode 100644 include/boost/python/to_python.hpp
 create mode 100644 include/boost/python/type_from_python.hpp

diff --git a/include/boost/python/converter/smart_ptr.hpp b/include/boost/python/converter/smart_ptr.hpp
new file mode 100644
index 00000000..bae4c2b8
--- /dev/null
+++ b/include/boost/python/converter/smart_ptr.hpp
@@ -0,0 +1,70 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef SMART_PTR_DWA2002123_HPP
+# define SMART_PTR_DWA2002123_HPP
+
+# include <boost/python/converter/class.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+namespace boost { namespace python { namespace converter { 
+
+template <class Pointer, class Value>
+class smart_ptr_wrapper
+    : wrapper<Pointer const&>
+{
+    smart_ptr_wrapper(ref const& type_)
+        : m_class_object(type_)
+    {
+        assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
+    }
+    
+    PyObject* convert(Pointer x) const;
+    
+ private:
+    ref m_class_object;
+    
+    smart_ptr_converters();
+}
+
+
+//
+// implementations
+//
+
+template <class Pointer, class Value>
+PyObject* smart_ptr_wrapper<Pointer,Value>::convert(Pointer x) const
+{
+    if (x.operator->() == 0)
+        return detail::none();
+        
+    // Don't call the type to do the construction, since that
+    // would require the registration of an __init__ copy
+    // constructor. Instead, just construct the object in place.
+    PyObject* raw_result = (PyObject*)PyObject_New(
+        instance, (PyTypeObject*)m_class_object.get());
+        
+    if (raw_result == 0)
+        return 0;
+
+    // Everything's OK; Bypass NULL checks but guard against
+    // exceptions.
+    ref result(raw_result, ref::allow_null());
+
+    // Build a value_holder to contain the object using the copy
+    // constructor
+    objects::pointer_holder<Pointer,Value>*
+        p = new objects::pointer_holder<Pointer,Value>(x);
+
+    // Install it in the instance
+    p->install(raw_result);
+
+    // Return the new result
+    return result.release();
+}
+    
+
+}}} // namespace boost::python::converter
+
+#endif // SMART_PTR_DWA2002123_HPP
diff --git a/include/boost/python/converter/to_python.hpp b/include/boost/python/converter/to_python.hpp
index 61dc7dad..a1d6c28b 100644
--- a/include/boost/python/converter/to_python.hpp
+++ b/include/boost/python/converter/to_python.hpp
@@ -101,7 +101,7 @@ template <class T>
 inline bool
 to_python_lookup<T>::convertible() const
 {
-    return m_converter != 0;
+    return m_convert != 0;
 }
 
 template <class T>
diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
index fd731f83..e5068604 100644
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -6,10 +6,8 @@
 #ifndef TYPE_ID_DWA20011127_HPP
 # define TYPE_ID_DWA20011127_HPP
 # include <boost/python/detail/config.hpp>
-# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/indirect_traits.hpp>
 # include <boost/mpl/select_type.hpp>
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/composite_traits.hpp>
 # include <boost/operators.hpp>
 # include <typeinfo>
 # include <iosfwd>
@@ -79,80 +77,6 @@ struct type_id_t : totally_ordered<type_id_t>
     base_id_t m_base_type;
 };
 
-#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct is_reference_to_const
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_const<T const&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-
-template <class T>
-struct is_reference_to_volatile
-{
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_volatile<T volatile&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
-};
-#  else 
-template <typename V>
-struct is_const_help
-{
-    typedef typename mpl::select_type<
-        is_const<V>::value
-        , type_traits::yes_type
-        , type_traits::no_type
-        >::type type;
-};
-
-template <typename V>
-struct is_volatile_help
-{
-    typedef typename mpl::select_type<
-        is_volatile<V>::value
-        , type_traits::yes_type
-        , type_traits::no_type
-        >::type type;
-};
-
-template <typename V>
-typename is_const_help<V>::type reference_to_const_helper(V&);
-    
-type_traits::no_type
-reference_to_const_helper(...);
-
-template <class T>
-struct is_reference_to_const
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(reference_to_const_helper(t)) == sizeof(type_traits::yes_type));
-};
-
-template <typename V>
-typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
-type_traits::no_type reference_to_volatile_helper(...);
-
-template <class T>
-struct is_reference_to_volatile
-{
-    static T t;
-    BOOST_STATIC_CONSTANT(
-        bool, value
-        = sizeof(reference_to_volatile_helper(t)) == sizeof(type_traits::yes_type));
-};
-#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
-
 template <class T>
 inline undecorated_type_id_t undecorated_type_id(detail::dummy<T>* = 0)
 {
@@ -165,9 +89,9 @@ inline type_id_t type_id(detail::dummy<T>* = 0)
     return type_id_t(
         undecorated_type_id<T>()
         , type_id_t::decoration(
-            (is_const<T>::value || is_reference_to_const<T>::value
+            (is_const<T>::value || python::detail::is_reference_to_const<T>::value
              ? type_id_t::const_ : 0)
-            | (is_volatile<T>::value || is_reference_to_volatile<T>::value
+            | (is_volatile<T>::value || python::detail::is_reference_to_volatile<T>::value
                ? type_id_t::volatile_ : 0)
             | (is_reference<T>::value ? type_id_t::reference : 0)
             )
diff --git a/include/boost/python/copy_const_reference.hpp b/include/boost/python/copy_const_reference.hpp
new file mode 100644
index 00000000..55e8f87f
--- /dev/null
+++ b/include/boost/python/copy_const_reference.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef COPY_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_CONST_REFERENCE_DWA2002131_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/python/to_python.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_const_reference_expects_a_const_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python;
+
+struct copy_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::select_type<
+            detail::is_reference_to_const<T>::value
+            , to_python<T>
+            , detail::copy_const_reference_expects_a_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}} // namespace boost::python
+
+#endif // COPY_CONST_REFERENCE_DWA2002131_HPP
diff --git a/include/boost/python/copy_non_const_reference.hpp b/include/boost/python/copy_non_const_reference.hpp
new file mode 100644
index 00000000..4afdc369
--- /dev/null
+++ b/include/boost/python/copy_non_const_reference.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+# define COPY_NON_CONST_REFERENCE_DWA2002131_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/python/to_python.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct copy_non_const_reference_expects_a_non_const_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python;
+
+struct copy_non_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::select_type<
+            boost::python::detail::is_reference_to_non_const<T>::value
+            , to_python<T>
+            , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}} // namespace boost::python
+
+#endif // COPY_NON_CONST_REFERENCE_DWA2002131_HPP
diff --git a/include/boost/python/default_call_policies.hpp b/include/boost/python/default_call_policies.hpp
new file mode 100644
index 00000000..3dc3d4d4
--- /dev/null
+++ b/include/boost/python/default_call_policies.hpp
@@ -0,0 +1,72 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# define DEFAULT_CALL_POLICIES_DWA2002131_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/mpl/select_type.hpp>
+
+namespace boost { namespace python { 
+
+template <class T> struct to_python;
+
+namespace detail
+{
+// for "readable" error messages
+  template <class T> struct specify_a_result_policy_to_wrap_functions_returning
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif 
+  ;
+}
+
+struct default_result_converter;
+
+struct default_call_policies
+{
+    // Nothing to do
+    static bool precall(PyObject*)
+    {
+        return true;
+    }
+
+    // Pass the result through
+    static PyObject* postcall(PyObject*, PyObject* result)
+    {
+        return result;
+    }
+
+    typedef default_result_converter result_converter;
+};
+
+struct default_result_converter
+{
+    template <class R>
+    struct apply
+    {
+        typedef typename mpl::select_type<
+            is_reference<R>::value | is_pointer<R>::value
+            , detail::specify_a_result_policy_to_wrap_functions_returning<R>
+            , to_python<R>
+        >::type type;
+    };
+};
+
+// Exceptions for c strings an PyObject*s
+template <>
+struct default_result_converter::apply<char const*>
+{
+    typedef boost::python::to_python<char const*> type;
+};
+
+template <>
+struct default_result_converter::apply<PyObject*>
+{
+    typedef boost::python::to_python<PyObject*> type;
+};
+
+}} // namespace boost::python
+
+#endif // DEFAULT_CALL_POLICIES_DWA2002131_HPP
diff --git a/include/boost/python/detail/caller.hpp b/include/boost/python/detail/caller.hpp
index 95c6dc7a..fe022961 100644
--- a/include/boost/python/detail/caller.hpp
+++ b/include/boost/python/detail/caller.hpp
@@ -6,19 +6,229 @@
 #ifndef CALLER_DWA20011214_HPP
 # define CALLER_DWA20011214_HPP
 
-# include <boost/python/call.hpp>
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/eval.hpp>
+# include <boost/python/detail/returning.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/same_traits.hpp>
 
-namespace boost { namespace python { namespace detail { 
+namespace boost { namespace python
+{
+  template <class T> struct to_python;
+}}
+
+namespace boost { namespace python { namespace detail {
+
+// for "readable" error messages
+template <class T> struct must_use_a_result_handler_to_wrap_functions_returning
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+{}
+# endif 
+;
+
+struct to_python_generator
+{
+    template <class R>
+    struct apply
+    {
+        typedef typename mpl::select_type<
+                is_reference<R>::value | is_pointer<R>::value
+            , must_use_a_result_handler_to_wrap_functions_returning<R>
+            , to_python<R>
+        >::type type;
+    };
+};
 
 struct caller
 {
     typedef PyObject* result_type;
     
-    template <class F>
-    PyObject* operator()(F f, PyObject* args, PyObject* keywords)
+    template <class P, class R>
+    PyObject* operator()(R (*f)(), PyObject* args, PyObject* keywords, P const& policies) const
     {
-        return call(f, args, keywords);
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0>
+    PyObject* operator()(R (*f)(A0), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1>
+    PyObject* operator()(R (*f)(A0, A1), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2>
+    PyObject* operator()(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3>
+    PyObject* operator()(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4>
+    PyObject* operator()(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    PyObject* operator()(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+// Member functions
+    template <class P, class R, class A0>
+    PyObject* operator()(R (A0::*f)(), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1>
+    PyObject* operator()(R (A0::*f)(A1), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2>
+    PyObject* operator()(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0>
+    PyObject* operator()(R (A0::*f)() const, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1>
+    PyObject* operator()(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2>
+    PyObject* operator()(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0>
+    PyObject* operator()(R (A0::*f)() volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1>
+    PyObject* operator()(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2>
+    PyObject* operator()(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0>
+    PyObject* operator()(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1>
+    PyObject* operator()(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2>
+    PyObject* operator()(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
+    }
+
+    template <class P, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    PyObject* operator()(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords, P const& policies) const
+    {
+        return returning<R>::call(f, args, keywords, policies);
     }
 };
 
diff --git a/include/boost/python/detail/indirect_traits.hpp b/include/boost/python/detail/indirect_traits.hpp
new file mode 100644
index 00000000..c76ffbc0
--- /dev/null
+++ b/include/boost/python/detail/indirect_traits.hpp
@@ -0,0 +1,116 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef INDIRECT_TRAITS_DWA2002131_HPP
+# define INDIRECT_TRAITS_DWA2002131_HPP
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+#  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template <class T>
+struct is_reference_to_const
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_const<T const&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_non_const
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_non_const<T&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_volatile
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_volatile<T volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+#  else
+
+typedef char (&inner_yes_type)[3];
+typedef char (&inner_no_type)[2];
+typedef char (&outer_no_type)[1];
+
+template <typename V>
+struct is_const_help
+{
+    typedef typename mpl::select_type<
+        is_const<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+struct is_volatile_help
+{
+    typedef typename mpl::select_type<
+        is_volatile<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+typename is_const_help<V>::type reference_to_const_helper(V&);
+    
+outer_no_type
+reference_to_const_helper(...);
+
+template <class T>
+struct is_reference_to_const
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
+};
+
+template <class T>
+struct is_reference_to_non_const
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
+};
+
+template <typename V>
+typename is_volatile_help<V>::type reference_to_volatile_helper(V&);
+outer_no_type reference_to_volatile_helper(...);
+
+template <class T>
+struct is_reference_to_volatile
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
+};
+#  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
+
+}}} // namespace boost::python::detail
+
+#endif // INDIRECT_TRAITS_DWA2002131_HPP
diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index 4aa228b5..c8533f9e 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -18,25 +18,38 @@
 # include <boost/python/from_python.hpp>
 # include <boost/python/to_python.hpp>
 
+namespace boost { namespace python
+{
+  template <class T> struct to_python;
+}} // namespace boost::python
+
 namespace boost { namespace python { namespace detail {
 
 // Calling C++ from Python
 template <class R>
 struct returning
 {
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -45,11 +58,19 @@ struct returning
         if (!c1.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -60,11 +81,19 @@ struct returning
         if (!c2.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -77,11 +106,19 @@ struct returning
         if (!c3.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -96,11 +133,19 @@ struct returning
         if (!c4.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -117,23 +162,39 @@ struct returning
         if (!c5.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
 
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -142,11 +203,19 @@ struct returning
         if (!c1.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -157,11 +226,19 @@ struct returning
         if (!c2.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -174,11 +251,19 @@ struct returning
         if (!c3.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -193,11 +278,19 @@ struct returning
         if (!c4.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -214,23 +307,39 @@ struct returning
         if (!c5.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
 
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -239,11 +348,19 @@ struct returning
         if (!c1.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -254,11 +371,19 @@ struct returning
         if (!c2.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -271,11 +396,19 @@ struct returning
         if (!c3.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -290,11 +423,19 @@ struct returning
         if (!c4.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -311,26 +452,42 @@ struct returning
         if (!c5.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
 
 
 // missing const volatile type traits
 #  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -339,11 +496,19 @@ struct returning
         if (!c1.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -354,11 +519,19 @@ struct returning
         if (!c2.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -371,11 +544,19 @@ struct returning
         if (!c3.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -390,11 +571,19 @@ struct returning
         if (!c4.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -411,31 +600,58 @@ struct returning
         if (!c5.convertible()) return 0;
 
         // find the result converter
-        to_python<R> r;
-        return r( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            
-    static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
+
+  
+    template <class P>
+    static PyObject* call(R (*pf)(), PyObject* args, PyObject*, P const& policies)
     {
         // find the result converter
-        to_python<R> c0;
-        return c0( (*pf)() );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c0;
+        if (!c0.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c0( (*pf)() );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0>
-    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
+  
+    template <class P, class A0>
+    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
-        to_python<R> c1;
-        return c1( (*pf)(c0(PyTuple_GET_ITEM(args, 0))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c1;
+        if (!c1.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c1( (*pf)(c0(PyTuple_GET_ITEM(args, 0))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1>
-    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -444,11 +660,19 @@ struct returning
         if (!c1.convertible()) return 0;
 
         // find the result converter
-        to_python<R> c2;
-        return c2( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c2;
+        if (!c2.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c2( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -459,11 +683,19 @@ struct returning
         if (!c2.convertible()) return 0;
 
         // find the result converter
-        to_python<R> c3;
-        return c3( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c3;
+        if (!c3.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c3( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -476,11 +708,19 @@ struct returning
         if (!c3.convertible()) return 0;
 
         // find the result converter
-        to_python<R> c4;
-        return c4( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c4;
+        if (!c4.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c4( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -495,11 +735,19 @@ struct returning
         if (!c4.convertible()) return 0;
 
         // find the result converter
-        to_python<R> c5;
-        return c5( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c5;
+        if (!c5.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c5( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -516,8 +764,16 @@ struct returning
         if (!c5.convertible()) return 0;
 
         // find the result converter
-        to_python<R> c6;
-        return c6( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type c6;
+        if (!c6.convertible()) return 0;
+        
+        if (!policies.precall(args)) return 0;
+        
+        PyObject* result = c6( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
+        
+        if (!result) return 0;
+        return policies.postcall(args, result);
     }
 };
                            
@@ -525,30 +781,36 @@ template <>
 struct returning<void>
 {
     typedef void R;
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
         from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
         if (!c1.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -557,12 +819,15 @@ struct returning<void>
         if (!c1.convertible()) return 0;
         from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
         if (!c2.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -573,12 +838,15 @@ struct returning<void>
         if (!c2.convertible()) return 0;
         from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
         if (!c3.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -591,12 +859,15 @@ struct returning<void>
         if (!c3.convertible()) return 0;
         from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
         if (!c4.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
@@ -611,35 +882,44 @@ struct returning<void>
         if (!c4.convertible()) return 0;
         from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
         if (!c5.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
 
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
         from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
         if (!c1.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -648,12 +928,15 @@ struct returning<void>
         if (!c1.convertible()) return 0;
         from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
         if (!c2.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -664,12 +947,15 @@ struct returning<void>
         if (!c2.convertible()) return 0;
         from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
         if (!c3.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -682,12 +968,15 @@ struct returning<void>
         if (!c3.convertible()) return 0;
         from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
         if (!c4.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
@@ -702,35 +991,44 @@ struct returning<void>
         if (!c4.convertible()) return 0;
         from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
         if (!c5.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
 
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
         from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
         if (!c1.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -739,12 +1037,15 @@ struct returning<void>
         if (!c1.convertible()) return 0;
         from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
         if (!c2.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -755,12 +1056,15 @@ struct returning<void>
         if (!c2.convertible()) return 0;
         from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
         if (!c3.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -773,12 +1077,15 @@ struct returning<void>
         if (!c3.convertible()) return 0;
         from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
         if (!c4.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -793,38 +1100,47 @@ struct returning<void>
         if (!c4.convertible()) return 0;
         from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
         if (!c5.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
 
 
 // missing const volatile type traits
 #  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class A0>
-    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
         from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
         if (!c1.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -833,12 +1149,15 @@ struct returning<void>
         if (!c1.convertible()) return 0;
         from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
         if (!c2.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -849,12 +1168,15 @@ struct returning<void>
         if (!c2.convertible()) return 0;
         from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
         if (!c3.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -867,12 +1189,15 @@ struct returning<void>
         if (!c3.convertible()) return 0;
         from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
         if (!c4.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
@@ -887,42 +1212,53 @@ struct returning<void>
         if (!c4.convertible()) return 0;
         from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
         if (!c5.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-            
-    static PyObject* call(R (*pf)(), PyObject*, PyObject* /* keywords */ )
+
+    template <class P>
+    static PyObject* call(R (*pf)(), PyObject*, PyObject*, P const& policies)
     {
         (*pf)();
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0>
-    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0>
+    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         (*pf)(c0(PyTuple_GET_ITEM(args, 0)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1>
-    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1>
+    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
         if (!c0.convertible()) return 0;
         from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
         if (!c1.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2>
-    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2>
+    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -931,12 +1267,15 @@ struct returning<void>
         if (!c1.convertible()) return 0;
         from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
         if (!c2.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -947,12 +1286,15 @@ struct returning<void>
         if (!c2.convertible()) return 0;
         from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
         if (!c3.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -965,12 +1307,15 @@ struct returning<void>
         if (!c3.convertible()) return 0;
         from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
         if (!c4.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
-    template <class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* /* keywords */ )
+    template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
         from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
@@ -985,9 +1330,12 @@ struct returning<void>
         if (!c4.convertible()) return 0;
         from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
         if (!c5.convertible()) return 0;
-
+        
+        if (!policies.precall(args)) return 0;
+        
         (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        return detail::none();
+        
+        return policies.postcall(args, detail::none());
     }
 };
 
diff --git a/include/boost/python/from_python.hpp b/include/boost/python/from_python.hpp
new file mode 100644
index 00000000..995f7877
--- /dev/null
+++ b/include/boost/python/from_python.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FROM_PYTHON_DWA2002128_HPP
+# define FROM_PYTHON_DWA2002128_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/target.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct from_python
+    : converter::from_python_lookup<typename converter::target<T>::type>
+{
+    typedef converter::from_python_lookup<typename converter::target<T>::type> base;
+    from_python(PyObject*);
+};
+
+// specialization for PyObject*
+template <>
+struct from_python<PyObject*>
+{
+    from_python(PyObject*) {}
+    bool convertible() const { return true; }
+    PyObject* operator()(PyObject* source) const { return source; }
+};
+
+//
+// implementations
+//
+template <class T>
+from_python<T>::from_python(PyObject* source)
+    : base(source)
+{
+}
+
+}} // namespace boost::python
+
+#endif // FROM_PYTHON_DWA2002128_HPP
diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index dfd11865..6f989256 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -15,6 +15,7 @@
 # include <boost/mpl/size.hpp>
 # include <boost/function.hpp>
 # include <boost/bind.hpp>
+# include <boost/python/default_call_policies.hpp>
 
 namespace boost { namespace python {
 
@@ -24,7 +25,17 @@ objects::function* make_function(F f)
     converter::acquire_registrations(detail::signature(f));
     return new objects::function(
         objects::py_function(
-            ::boost::bind<PyObject*>(detail::caller(), f, _1, _2))
+            ::boost::bind<PyObject*>(detail::caller(), f, _1, _2, default_call_policies()))
+        , detail::arg_tuple_size<F>::value);
+}
+
+template <class F, class Policies>
+objects::function* make_function(F f, Policies const& policies)
+{
+    converter::acquire_registrations(detail::signature(f));
+    return new objects::function(
+        objects::py_function(
+            ::boost::bind<PyObject*>(detail::caller(), f, _1, _2, policies))
         , detail::arg_tuple_size<F>::value);
 }
 
@@ -41,7 +52,7 @@ objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
             ::boost::bind<PyObject*>(detail::caller(),
                  objects::make_holder<nargs>
                             ::template apply<T,Generator,ArgList>::execute
-                 , _1, _2))
+                 , _1, _2, default_call_policies()))
         , nargs + 1);
 }
 
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index 5661e106..3a243b06 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -58,20 +58,20 @@ class module : public module_base
         return *this;
     }
     
-# if 0
-    template <class Fn>
-    void def_raw(char const* name, Fn fn)
-    {
-        add(detail::new_raw_arguments_function(fn), name);
-    }
-# endif
-    
     template <class Fn>
     module& def(char const* name, Fn fn)
     {
         this->setattr(name, boost::python::make_function(fn));
         return *this;
     }
+
+    
+    template <class Fn, class ResultHandler>
+    module& def(char const* name, Fn fn, ResultHandler handler)
+    {
+        this->setattr(name, boost::python::make_function(fn, handler));
+        return *this;
+    }
 };
 
 //
diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
new file mode 100644
index 00000000..ac7f3fbf
--- /dev/null
+++ b/include/boost/python/return_internal_reference.hpp
@@ -0,0 +1,45 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
+# define RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
+
+# include <boost/python/default_call_policies.hpp>
+# include <boost/type_traits/object_traits.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class T>
+  struct return_internal_reference_requires_a_pointer_or_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+};
+
+struct internal_reference_to_python_generator
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::select_type<
+            !is_object<T>::value
+            , internal_reference_to_python<T>
+            , detail::return_internal_reference_requires_a_pointer_or_reference_return_type
+        >::type type;
+    };
+};
+
+template <std::size_t owner_arg, class Base = default_call_policies>
+struct return_internal_reference : Base
+{
+    typedef wrap_internal_reference<owner_arg> result_converter;
+};
+
+}} // namespace boost::python
+
+#endif // RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
diff --git a/include/boost/python/return_value_policy.hpp b/include/boost/python/return_value_policy.hpp
new file mode 100644
index 00000000..0beec47b
--- /dev/null
+++ b/include/boost/python/return_value_policy.hpp
@@ -0,0 +1,20 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef RETURN_VALUE_POLICY_DWA2002131_HPP
+# define RETURN_VALUE_POLICY_DWA2002131_HPP
+# include <boost/python/default_call_policies.hpp>
+
+namespace boost { namespace python { 
+
+template <class Handler, class Base = default_call_policies>
+struct return_value_policy : Base
+{
+    typedef Handler result_converter;
+};
+
+}} // namespace boost::python
+
+#endif // RETURN_VALUE_POLICY_DWA2002131_HPP
diff --git a/include/boost/python/to_python.hpp b/include/boost/python/to_python.hpp
new file mode 100644
index 00000000..e00346bb
--- /dev/null
+++ b/include/boost/python/to_python.hpp
@@ -0,0 +1,37 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_DWA2002128_HPP
+# define TO_PYTHON_DWA2002128_HPP
+
+# include <boost/python/converter/to_python.hpp>
+# include <boost/python/converter/source.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct to_python
+    : converter::to_python_lookup<typename converter::source<T>::type>
+{
+};
+
+// specialization for PyObject*
+template <>
+struct to_python<PyObject*>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(PyObject* source) const { return source; }
+};
+
+template <>
+struct to_python<PyObject*const&>
+{
+    bool convertible() const { return true; }
+    PyObject* operator()(PyObject* source) const { return source; }
+};
+
+}} // namespace boost::python
+
+#endif // TO_PYTHON_DWA2002128_HPP
diff --git a/include/boost/python/type_from_python.hpp b/include/boost/python/type_from_python.hpp
new file mode 100644
index 00000000..46d59d13
--- /dev/null
+++ b/include/boost/python/type_from_python.hpp
@@ -0,0 +1,23 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TYPE_FROM_PYTHON_DWA2002130_HPP
+# define TYPE_FROM_PYTHON_DWA2002130_HPP
+
+namespace boost { namespace python {
+
+template <PyTypeObject const* python_type>
+struct type_from_python
+{
+    static void* convertible(PyObject* op)
+    {
+        return PyObject_TypeCheck(
+            op, const_cast<PyTypeObject*>(python_type)) ? op : 0;
+    }
+};
+
+}} // namespace boost::python
+
+#endif // TYPE_FROM_PYTHON_DWA2002130_HPP
diff --git a/src/objects.cpp b/src/objects.cpp
index 90417dac..b447b262 100644
--- a/src/objects.cpp
+++ b/src/objects.cpp
@@ -8,7 +8,9 @@
 
 // TODO: Move inline implementations from objects.cpp here
 
-#define BOOST_PYTHON_SOURCE
+#ifndef BOOST_PYTHON_SOURCE
+r# define BOOST_PYTHON_SOURCE
+#endif 
 
 #include <boost/python/objects.hpp>
 #include <boost/python/detail/none.hpp>
diff --git a/test/m1.cpp b/test/m1.cpp
index d422b426..b807dc43 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -12,7 +12,8 @@
 #include <boost/python/object/value_holder.hpp>
 #include <boost/python/object/pointer_holder.hpp>
 #include <boost/python/object/class.hpp>
-//#include <boost/python/object/inheritance.hpp>
+#include <boost/python/copy_const_reference.hpp>
+#include <boost/python/return_value_policy.hpp>
 #include <boost/python/converter/class.hpp>
 #include <boost/python/reference_from_python.hpp>
 #include <boost/python/value_from_python.hpp>
@@ -198,6 +199,9 @@ BOOST_PYTHON_MODULE_INIT(m1)
     using boost::python::value_from_python;
     using boost::python::type_from_python;
     using boost::python::get_member;
+    using boost::python::copy_const_reference;
+    using boost::python::return_value_policy;
+    using boost::mpl::type_list;
     
     // Create the converters; they are self-registering/unregistering.
     static to_python_converter<simple const&> c1(simple_to_python);
@@ -239,7 +243,8 @@ BOOST_PYTHON_MODULE_INIT(m1)
       .def("f", f)
 
       // Expose g()
-      .def("g", g)
+      .def("g", g , return_value_policy<copy_const_reference>()
+          )
 
       .def("take_a", take_a)
       .def("take_b", take_b)
@@ -279,8 +284,8 @@ BOOST_PYTHON_MODULE_INIT(m1)
 
         .add(
             class_<complicated>("complicated")
-            .def_init(args<simple const&,int>())
-            .def_init(args<simple const&>())
+            .def_init(type_list<simple const&,int>())
+            .def_init(type_list<simple const&>())
             .def("get_n", &complicated::get_n)
             )
         ;
diff --git a/test/m2.cpp b/test/m2.cpp
index 0a5df161..afffb27d 100644
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -8,6 +8,9 @@
 // by exposing raw Python extension functions that use wrap<> and
 // unwrap<> objects.
 #include <boost/python/module.hpp>
+#include <boost/python/copy_non_const_reference.hpp>
+#include <boost/python/copy_const_reference.hpp>
+#include <boost/python/return_value_policy.hpp>
 #include "simple_type.hpp"
 
 // Get a simple (by value) from the argument, and return the
@@ -59,6 +62,10 @@ struct rewrap
 
 BOOST_PYTHON_MODULE_INIT(m2)
 {
+    using boost::python::return_value_policy;
+    using boost::python::copy_const_reference;
+    using boost::python::copy_non_const_reference;
+    
     boost::python::module("m2")
         .def("unwrap_int", unwrap_int)
         .def("unwrap_int_ref", unwrap_int_ref)
@@ -68,11 +75,24 @@ BOOST_PYTHON_MODULE_INIT(m2)
         .def("unwrap_simple_const_ref", unwrap_simple_const_ref)
 
         .def("wrap_int", &rewrap<int>::f)
-        .def("wrap_int_ref", &rewrap<int&>::f)
-        .def("wrap_int_const_ref", &rewrap<int const&>::f)
+        
+        .def("wrap_int_ref", &rewrap<int&>::f
+             , return_value_policy<copy_non_const_reference>()
+            )
+        
+        .def("wrap_int_const_ref", &rewrap<int const&>::f
+             , return_value_policy<copy_const_reference>()
+            )
+        
         .def("wrap_simple", &rewrap<simple>::f)
-        .def("wrap_simple_ref", &rewrap<simple&>::f)
-        .def("wrap_simple_const_ref", &rewrap<simple const&>::f)
+        
+        .def("wrap_simple_ref", &rewrap<simple&>::f
+             , return_value_policy<copy_non_const_reference>()
+            )
+        
+        .def("wrap_simple_const_ref", &rewrap<simple const&>::f
+             , return_value_policy<copy_const_reference>()
+            )
         ;
 }
 

From 7a16cd4c37525ff4ce58cf8f074d80633a019668 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 00:46:38 +0000
Subject: [PATCH 243/369] remove local rule usage for the time being.

[SVN r12625]
---
 build/Jamfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/Jamfile b/build/Jamfile
index 7fd8c285..744c8ec2 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -136,7 +136,7 @@ bpl-test noncopyable_import : ../example/noncopyable_import.cpp ;
 ############## cross-module tests from ../example ##########
 
 # A simple rule to build a test which depends on multiple modules in the PYTHONPATH
-local rule boost-python-multi-example-runtest ( test-name : modules + )
+rule boost-python-multi-example-runtest ( test-name : modules + )
 {
     boost-python-runtest $(test-name)
         : ../example/tst_$(test-name).py <lib>$(modules) <lib>libboost_python

From 684e391a9a38d4fb2687bc634da7e102e45727ed Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 00:49:24 +0000
Subject: [PATCH 244/369] remove local rule usage for the time being.

[SVN r12626]
---
 build/Jamfile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index 744c8ec2..1ea3665d 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -64,7 +64,7 @@ include <module@>python.jam ;
 local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) <define>BOOST_PYTHON_DYNAMIC_LIB ;
 
 #######################
-local rule bpl-test ( test-name : sources + )
+rule bpl-test ( test-name : sources + )
 {
     boost-python-test $(test-name) : $(sources) <lib>libboost_python ;
 }
@@ -108,7 +108,7 @@ boost-python-runtest comprehensive
 
 ############# simple tests from ../example ############
 
-local rule boost-python-example-runtest ( name )
+rule boost-python-example-runtest ( name )
 {
     bpl-test $(name)
       : ../example/$(name).cpp ;

From 12988b879e344446decf84bcf6764383bf7e1c50 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 08:31:11 +0000
Subject: [PATCH 245/369] *** empty log message ***

[SVN r12627]
---
 include/boost/python/copy_const_reference.hpp     |  4 ++--
 include/boost/python/copy_non_const_reference.hpp |  4 ++--
 include/boost/python/default_call_policies.hpp    | 12 ++++++++----
 include/boost/python/make_function.hpp            |  6 ------
 4 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/include/boost/python/copy_const_reference.hpp b/include/boost/python/copy_const_reference.hpp
index 55e8f87f..57c45fd4 100644
--- a/include/boost/python/copy_const_reference.hpp
+++ b/include/boost/python/copy_const_reference.hpp
@@ -21,7 +21,7 @@ namespace detail
   ;
 }
 
-template <class T> struct to_python;
+template <class T> struct to_python_value;
 
 struct copy_const_reference
 {
@@ -30,7 +30,7 @@ struct copy_const_reference
     {
         typedef typename mpl::select_type<
             detail::is_reference_to_const<T>::value
-            , to_python<T>
+            , to_python_value<T>
             , detail::copy_const_reference_expects_a_const_reference_return_type<T>
         >::type type;
     };
diff --git a/include/boost/python/copy_non_const_reference.hpp b/include/boost/python/copy_non_const_reference.hpp
index 4afdc369..dead736f 100644
--- a/include/boost/python/copy_non_const_reference.hpp
+++ b/include/boost/python/copy_non_const_reference.hpp
@@ -21,7 +21,7 @@ namespace detail
   ;
 }
 
-template <class T> struct to_python;
+template <class T> struct to_python_value;
 
 struct copy_non_const_reference
 {
@@ -30,7 +30,7 @@ struct copy_non_const_reference
     {
         typedef typename mpl::select_type<
             boost::python::detail::is_reference_to_non_const<T>::value
-            , to_python<T>
+            , to_python_value<T>
             , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
         >::type type;
     };
diff --git a/include/boost/python/default_call_policies.hpp b/include/boost/python/default_call_policies.hpp
index 3dc3d4d4..475278e4 100644
--- a/include/boost/python/default_call_policies.hpp
+++ b/include/boost/python/default_call_policies.hpp
@@ -7,10 +7,12 @@
 # define DEFAULT_CALL_POLICIES_DWA2002131_HPP
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/mpl/select_type.hpp>
+# include <boost/python/to_python_value.hpp>
+# include <boost/type_traits/transform_traits.hpp>
 
 namespace boost { namespace python { 
 
-template <class T> struct to_python;
+template <class T> struct to_python_value;
 
 namespace detail
 {
@@ -49,7 +51,9 @@ struct default_result_converter
         typedef typename mpl::select_type<
             is_reference<R>::value | is_pointer<R>::value
             , detail::specify_a_result_policy_to_wrap_functions_returning<R>
-            , to_python<R>
+            , boost::python::to_python_value<
+                typename add_reference<typename add_const<R>::type>::type
+                >
         >::type type;
     };
 };
@@ -58,13 +62,13 @@ struct default_result_converter
 template <>
 struct default_result_converter::apply<char const*>
 {
-    typedef boost::python::to_python<char const*> type;
+    typedef boost::python::to_python_value<char const*const&> type;
 };
 
 template <>
 struct default_result_converter::apply<PyObject*>
 {
-    typedef boost::python::to_python<PyObject*> type;
+    typedef boost::python::to_python_value<PyObject*const&> type;
 };
 
 }} // namespace boost::python
diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index 6f989256..90a5c12b 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -11,7 +11,6 @@
 # include <boost/python/converter/registration.hpp>
 # include <boost/python/detail/caller.hpp>
 # include <boost/python/detail/arg_tuple_size.hpp>
-# include <boost/python/detail/signature.hpp>
 # include <boost/mpl/size.hpp>
 # include <boost/function.hpp>
 # include <boost/bind.hpp>
@@ -22,7 +21,6 @@ namespace boost { namespace python {
 template <class F>
 objects::function* make_function(F f)
 {
-    converter::acquire_registrations(detail::signature(f));
     return new objects::function(
         objects::py_function(
             ::boost::bind<PyObject*>(detail::caller(), f, _1, _2, default_call_policies()))
@@ -32,7 +30,6 @@ objects::function* make_function(F f)
 template <class F, class Policies>
 objects::function* make_function(F f, Policies const& policies)
 {
-    converter::acquire_registrations(detail::signature(f));
     return new objects::function(
         objects::py_function(
             ::boost::bind<PyObject*>(detail::caller(), f, _1, _2, policies))
@@ -44,9 +41,6 @@ objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
 {
     enum { nargs = mpl::size<ArgList>::value };
     
-    typedef typename mpl::push_front<ArgList,void>::sequence signature;
-    converter::acquire_registrations(signature());
-    
     return new objects::function(
         objects::py_function(
             ::boost::bind<PyObject*>(detail::caller(),

From 25c56164b02dd578677b664191deebb6d6dca52b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 14:04:48 +0000
Subject: [PATCH 246/369] Last rewrite of the type conversion mechanism, I hope

[SVN r12631]
---
 Jamfile                                       |   1 -
 example/rwgk2.cpp                             |  50 ------
 example/rwgk3.cpp                             | 101 -----------
 .../builtin_to_python_converters.hpp          |  89 ++++------
 .../boost/python/converter/from_python.hpp    |  55 ++++--
 .../boost/python/converter/registration.hpp   | 148 ----------------
 include/boost/python/converter/registry.hpp   |  62 +------
 include/boost/python/converter/source.hpp     |  32 ----
 .../boost/python/converter/source_holder.hpp  |  24 ---
 include/boost/python/converter/to_python.hpp  | 116 -------------
 .../python/converter/to_python_function.hpp   |  17 +-
 include/boost/python/converter/type_id.hpp    |  25 +--
 .../boost/python/converter/wrapper_base.hpp   |  28 ---
 include/boost/python/copy_const_reference.hpp |   2 +-
 .../boost/python/copy_non_const_reference.hpp |   2 +-
 include/boost/python/detail/caller.hpp        |  20 ---
 include/boost/python/detail/msvc_typeinfo.hpp |  99 +++++++++++
 include/boost/python/detail/returning.hpp     |   7 -
 include/boost/python/make_function.hpp        |   1 -
 include/boost/python/object/class_wrapper.hpp |  16 +-
 include/boost/python/to_python.hpp            |  37 ----
 src/converter/builtin_converters.cpp          |   1 -
 src/converter/from_python.cpp                 |  11 +-
 src/converter/registry.cpp                    | 164 +++++-------------
 src/converter/to_python.cpp                   |  24 ---
 src/converter/type_id.cpp                     |   6 -
 src/object/class.cpp                          |   3 +-
 test/m1.cpp                                   |  44 ++---
 test/newtest.py                               |  36 ++--
 29 files changed, 305 insertions(+), 916 deletions(-)
 delete mode 100644 example/rwgk2.cpp
 delete mode 100644 example/rwgk3.cpp
 delete mode 100644 include/boost/python/converter/registration.hpp
 delete mode 100644 include/boost/python/converter/source.hpp
 delete mode 100644 include/boost/python/converter/source_holder.hpp
 delete mode 100644 include/boost/python/converter/to_python.hpp
 delete mode 100644 include/boost/python/converter/wrapper_base.hpp
 create mode 100644 include/boost/python/detail/msvc_typeinfo.hpp
 delete mode 100644 include/boost/python/to_python.hpp
 delete mode 100644 src/converter/to_python.cpp

diff --git a/Jamfile b/Jamfile
index 684c21d5..fec34d51 100644
--- a/Jamfile
+++ b/Jamfile
@@ -15,7 +15,6 @@ PYTHON_PROPERTIES
     dll bpl
       : 
       src/converter/from_python.cpp
-      src/converter/to_python.cpp
       src/converter/registry.cpp
       src/converter/type_id.cpp
       src/object/class.cpp
diff --git a/example/rwgk2.cpp b/example/rwgk2.cpp
deleted file mode 100644
index 35dce88f..00000000
--- a/example/rwgk2.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <iostream>
-#include <string>
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A friendly class.
-  class world
-  {
-    private:
-      std::string country;
-    public:
-      world(const std::string& country) { this->country = country; }
-      std::string greet() const { return "Hello from " + country + "!"; }
-  };
-
-  // A function taking a world object as an argument.
-  std::string invite(const world& w) {
-    return w.greet() + " Please come soon!";
-  }
-}
-
-#include <py_cpp/class_wrapper.h>
-
-// Python requires an exported function called init<module-name> in every
-// extension module. This is where we build the module contents.
-BOOST_PYTHON_MODULE_INIT(example2)
-{
-    // Create an object representing this extension module.
-    py::Module this_module("example2");
-
-    // Create the Python type object for our extension class.
-    py::ClassWrapper<world> world_class(this_module, "world");
-
-    // Add the __init__ function.
-    world_class.def(py::Constructor<std::string>());
-    // Add a regular member function.
-    world_class.def(&world::greet, "greet");
-
-    // Add invite() as a regular function to the module.
-    this_module.def(invite, "invite");
-
-    // Even better, invite() can also be made a member of world_class!!!
-    world_class.def(invite, "invite");
-}
-
-// Win32 DLL boilerplate
-#if defined(_WIN32)
-#include <windows.h>
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
-#endif // _WIN32
diff --git a/example/rwgk3.cpp b/example/rwgk3.cpp
deleted file mode 100644
index df17b28e..00000000
--- a/example/rwgk3.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include <py_cpp/class_wrapper.h>
-#include <py_cpp/objects.h>
-
-#define rangei(n)          for (int i = 0; i < n; i++)
-
-namespace { // Avoid cluttering the global namespace.
-
-  // A wrapper is used to define additional constructors.
-  //
-  struct vector_double_wrapper: std::vector<double>
-  {
-    // Tell the compiler how to convert a base class object to
-    // this wrapper object.
-    vector_double_wrapper(PyObject*, const std::vector<double>& vd)
-      : std::vector<double>(vd) {}
-
-    vector_double_wrapper(PyObject* self)
-      : std::vector<double>() {}
-
-    vector_double_wrapper(PyObject* self, const int n)
-      : std::vector<double>(n) {}
-
-    vector_double_wrapper(PyObject* self, py::Tuple tuple)
-      : std::vector<double>(tuple.size())
-    {
-      std::vector<double>::iterator vd = begin();
-      rangei(tuple.size())
-        vd[i] = from_python(tuple[i].get(), py::Type<double>()); // GCC BUG
-    }
-  };
-
-  double getitem(const std::vector<double>& vd, const std::size_t key) {
-    return vd[key];
-  }
-
-  void setitem(std::vector<double>& vd, const std::size_t key,
-               const double &d) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vditer[key] = d;
-  }
-
-  void delitem(std::vector<double>& vd, const std::size_t key) {
-    std::vector<double>::iterator vditer = vd.begin();
-    vd.erase(&vditer[key]);
-  }
-
-  // Convert vector_double to a regular Python tuple.
-  //
-  py::Tuple as_tuple(const std::vector<double>& vd)
-  {
-    py::Tuple t(vd.size());
-    rangei(vd.size()) t.set_item(i, py::Ptr(py::to_python(vd[i]))); // GCC BUG
-    return t;
-  }
-
-  // Function returning a vector_double object to Python.
-  //
-  std::vector<double> foo(const int n)
-  {
-    std::vector<double> vd(n);
-    std::vector<double>::iterator vditer = vd.begin();
-    rangei(n) vditer[i] = double(i);
-    return vd;
-  }
-
-  // Same as foo(), but avoid copying on return.
-  //
-  std::auto_ptr<std::vector<double> > bar(const int n)
-  {
-    std::auto_ptr<std::vector<double> > vdptr(new std::vector<double>(n));
-    std::vector<double>::iterator vditer = vdptr->begin();
-    rangei(n) vditer[i] = double(10 * i);
-    return vdptr;
-  }
-}
-
-BOOST_PYTHON_MODULE_INIT(example3)
-{
-    py::Module this_module("example3");
-
-    py::ClassWrapper<std::vector<double>, vector_double_wrapper>
-      vector_double(this_module, "vector_double");
-
-    vector_double.def(py::Constructor<>());
-    vector_double.def(py::Constructor<const int>());
-    vector_double.def(py::Constructor<py::Tuple>());
-    vector_double.def(&std::vector<double>::size, "__len__");
-    vector_double.def(getitem, "__getitem__");
-    vector_double.def(setitem, "__setitem__");
-    vector_double.def(delitem, "__delitem__");
-    vector_double.def(as_tuple, "as_tuple");
-
-    this_module.def(foo, "foo");
-    this_module.def(bar, "bar");
-}
-
-// Win32 DLL boilerplate
-#if defined(_WIN32)
-#include <windows.h>
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
-#endif // _WIN32
diff --git a/include/boost/python/converter/builtin_to_python_converters.hpp b/include/boost/python/converter/builtin_to_python_converters.hpp
index 4e9f89e3..89ad7b86 100644
--- a/include/boost/python/converter/builtin_to_python_converters.hpp
+++ b/include/boost/python/converter/builtin_to_python_converters.hpp
@@ -8,20 +8,41 @@
 # include <string>
 # include <boost/python/detail/wrap_python.hpp>
 
-namespace boost { namespace python { namespace converter { 
+namespace boost { namespace python { 
 
-template <class T> struct to_python_lookup;
+// Provide specializations of to_python_value
+template <class T> struct to_python_value;
 
-template <class T>
-struct to_python_int
+namespace detail
 {
-    bool convertible() const { return true; }
-    PyObject* operator()(T x) const { return PyInt_FromLong(long(x)); }
-};
+  struct builtin_to_python
+  {
+      static bool convertible() { return true; }
+  };
+}
 
-# define BOOST_PYTHON_TO_INT(T) \
-    template <> struct to_python_lookup<signed T const&> : to_python_int<signed T const&> {}; \
-    template <> struct to_python_lookup<unsigned T const&> : to_python_int<unsigned T const&> {};
+# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)   \
+    template <> struct to_python_value<T&>          \
+        : detail::builtin_to_python                 \
+    {                                               \
+        PyObject* operator()(T const& x) const      \
+        {                                           \
+            return (expr);                          \
+        }                                           \
+    };                                              \
+    template <> struct to_python_value<T const&>    \
+        : detail::builtin_to_python                 \
+    {                                               \
+        PyObject* operator()(T const& x) const      \
+        {                                           \
+            return (expr);                          \
+        }                                           \
+    };
+
+
+# define BOOST_PYTHON_TO_INT(T)                                         \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, PyInt_FromLong(x))
 
 BOOST_PYTHON_TO_INT(char)
 BOOST_PYTHON_TO_INT(short)
@@ -29,47 +50,13 @@ BOOST_PYTHON_TO_INT(int)
 BOOST_PYTHON_TO_INT(long)
 # undef BOOST_TO_PYTHON_INT
 
-template <>
-struct to_python_lookup<char const*const&>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(char const* x) const { return PyString_FromString(x); }
-};
-    
-template <>
-struct to_python_lookup<std::string const&>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(std::string const& x) const
-    {
-        return PyString_FromString(x.c_str());
-    }
-};
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, PyString_FromString(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x)
 
-template <>
-struct to_python_lookup<float const&>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(float x) const { return PyFloat_FromDouble(x); }
-};
-    
-template <>
-struct to_python_lookup<double const&>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(double x) const { return PyFloat_FromDouble(x); }
-};
-    
-template <>
-struct to_python_lookup<long double const&>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(long double x) const
-    {
-        return PyFloat_FromDouble(x);
-    }
-};
-    
-}}} // namespace boost::python::converter
+}} // namespace boost::python::converter
 
 #endif // BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index 234f61d1..ee16a741 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -11,7 +11,7 @@
 # include <boost/python/converter/from_python_function.hpp>
 # include <boost/python/converter/from_python_data.hpp>
 # include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/registration.hpp>
+# include <boost/python/converter/registry.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 
 namespace boost { namespace python { namespace converter { 
@@ -29,16 +29,21 @@ template <class T> struct from_python_lookup;
 struct BOOST_PYTHON_DECL from_python_converter_base : body
 {
     from_python_converter_base(type_id_t, from_python_check); // registers
-    ~from_python_converter_base();         // unregisters
 
     // Must return non-null iff the conversion will be successful. Any
     // non-null pointer is acceptable, and will be passed on to the
     // convert() function, so useful data can be stored there.
     inline void* convertible(PyObject*) const;
-//    inline type_id_t key() const;
+
+    // Given the head of a from_python converter chain, find the
+    // converter which can convert p, leaving its intermediate data in
+    // data.
+    inline static from_python_converter_base const*
+    find(from_python_converter_base const*chain, PyObject* p, void*& data);
+    
  private:
-//    type_id_t m_key;
     from_python_check m_convertible;
+    from_python_converter_base* m_next;
 };
 
 
@@ -52,17 +57,24 @@ struct from_python_converter : from_python_converter_base
     from_python_converter(from_python_check, conversion_function, from_python_destructor = 0);
     T convert(PyObject*, from_python_data&) const;
     void destroy(from_python_data&) const;
+
+    // Find a converter for converting p to a T.
+    static from_python_converter<T> const* find(PyObject* p, void*& data);
     
  private: // data members
     conversion_function m_convert;
     from_python_destructor m_destroy;
+
+    // Keeps the chain of converters which convert from PyObject* to T
+    static from_python_converter_base*const& chain;
 };
 
-// -------------------------------------------------------------------------
+// Initialized to refer to a common place in the registry.
+template <class T>
+from_python_converter_base*const&
+from_python_converter<T>::chain = registry::from_python_chain(type_id<T>());
 
-//struct from_python_base
-//{
-//};
+// -------------------------------------------------------------------------
 
 // A class which implements from_python with a registry lookup.
 template <class T>
@@ -95,12 +107,21 @@ inline void* from_python_converter_base::convertible(PyObject* o) const
     return m_convertible(o);
 }
 
-# if 0
-inline type_id_t from_python_converter_base::key() const
+inline from_python_converter_base const*
+from_python_converter_base::find(
+    from_python_converter_base const* chain, PyObject* p, void*& data)
 {
-    return m_key;
+    for (from_python_converter_base const* q = chain; q != 0 ; q = q->m_next)
+    {
+        void* d = q->convertible(p);
+        if (d != 0)
+        {
+            data = d;
+            return q;
+        }
+    }
+    return 0;
 }
-# endif 
 
 template <class T>
 inline from_python_converter<T>::from_python_converter(
@@ -115,6 +136,14 @@ inline from_python_converter<T>::from_python_converter(
     
 }
 
+template <class T>
+inline from_python_converter<T> const*
+from_python_converter<T>::find(PyObject* p, void*& data)
+{
+    return static_cast<from_python_converter<T> const*>(
+        from_python_converter_base::find(chain, p, data));
+}
+
 template <class T>
 inline T from_python_converter<T>::convert(PyObject* src, from_python_data& data) const
 {
@@ -133,7 +162,7 @@ inline void from_python_converter<T>::destroy(from_python_data& data) const
 template <class T>
 inline from_python_lookup<T>::from_python_lookup(PyObject* src)
     : m_converter(
-        registration<T>::get_from_python(
+        from_python_converter<T>::find(
             src, m_intermediate_data.stage1))
 {
 }
diff --git a/include/boost/python/converter/registration.hpp b/include/boost/python/converter/registration.hpp
deleted file mode 100644
index 39223d8a..00000000
--- a/include/boost/python/converter/registration.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef REGISTRATION_DWA20011130_HPP
-# define REGISTRATION_DWA20011130_HPP
-# include <boost/python/detail/config.hpp>
-# include <boost/python/converter/registry.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/config.hpp>
-# include <boost/mpl/pop_front.hpp>
-# include <boost/mpl/for_each.hpp>
-# include <boost/mpl/front.hpp>
-# include <utility>
-# ifdef BOOST_PYTHON_TRACE
-#  include <iostream>
-# endif 
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct from_python_converter;
-template <class T> struct target;
-template <class T> struct source;
-
-// This class is really sort of a "templated namespace". It manages a
-// static data member which refers to the registry entry for T. This
-// reference is acquired once to reduce the burden of multiple
-// dictionary lookups at runtime.
-template <class T>
-struct registration
-{
- public: // member functions
-    // Return a converter which can convert the given Python object to
-    // T, or 0 if no such converter exists. Fill in data with
-    // the result of the converter's check function
-    static from_python_converter<T> const* get_from_python(PyObject*, void*& data);
-
-    // Return a converter which can convert T to a Python object, or 0
-    // if no such converter exists
-    static to_python_function<T>::type get_to_python();
-
-    static registry::entry* find_entry();
- private: // helper functions
-    static registry::entry* entry();
-    static registry::entry* known_entry();
-    
- private: // data members
-    static registry::entry* m_registry_entry;
-};
-
-namespace detail
-{
-  // An MPL BinaryMetaFunction class which initializes the
-  // registration entry for the target type of its 2nd argument.
-  struct setup_target_registration
-  {
-      template <class Ignored, class T> struct apply
-      {
-          typedef T type;
-          static void execute()
-          {
-              typedef typename target<T>::type target_t;
-              registration<target_t>::find_entry();
-          }
-      };
-  };
-
-  template <class T>
-  struct find_return_value_entry
-  {
-      static void execute() { registration<T>::find_entry(); }
-  };
-
-  template <>
-  struct find_return_value_entry<void>
-  {
-      static void execute() {}
-  };
-  
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1200
-  template <>
-  struct find_return_value_entry<void const>
-  {
-      static void execute() {}
-  };
-# endif 
-}
-
-template <class Sequence>
-void acquire_registrations(Sequence signature)
-{
-    typedef typename mpl::pop_front<Sequence>::sequence args;
-    typedef typename mpl::front<Sequence>::type return_type;
-    
-    mpl::for_each<args, void, detail::setup_target_registration>::execute();
-    
-    typedef typename source<return_type>::type return_source_type;
-    detail::find_return_value_entry<return_source_type>::execute();
-}
-  
-
-// because this is static POD data it will be initialized to zero
-template <class T>
-registry::entry* registration<T>::m_registry_entry;
-
-template <class T>
-registry::entry* registration<T>::find_entry()
-{
-    return m_registry_entry = registry::find(type_id<T>());
-}
-
-template <class T>
-inline registry::entry* registration<T>::entry()
-{
-    if (!m_registry_entry)
-        find_entry();
-    return m_registry_entry;
-}
-
-template <class T>
-inline registry::entry* registration<T>::known_entry()
-{
-    assert(m_registry_entry != 0);
-    return m_registry_entry;
-}
-
-template <class T>
-from_python_converter<T> const* registration<T>::get_from_python(PyObject* p, void*& data)
-{
-    return static_cast<from_python_converter<T> const*>(
-        known_entry()->get_from_python(p, data)
-        );
-}
-
-template <class T>
-typename to_python_function<T>::type registration<T>::get_to_python()
-{
-# ifdef BOOST_PYTHON_TRACE
-    std::cout << "retrieving wrapper for " << type_id<T>() << std::endl;
-# endif 
-    return reinterpret_cast<to_python_function<T>::type>(
-        known_entry()->get_to_python());
-}
-
-}}} // namespace boost::python::converter
-
-#endif // REGISTRATION_DWA20011130_HPP
diff --git a/include/boost/python/converter/registry.hpp b/include/boost/python/converter/registry.hpp
index 21f31692..bdb64254 100644
--- a/include/boost/python/converter/registry.hpp
+++ b/include/boost/python/converter/registry.hpp
@@ -5,72 +5,26 @@
 //  to its suitability for any purpose.
 #ifndef REGISTRY_DWA20011127_HPP
 # define REGISTRY_DWA20011127_HPP
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/to_python_function.hpp>
-# include <vector>
-# include <memory>
-# include <utility>
 
 namespace boost { namespace python { namespace converter {
 
 struct BOOST_PYTHON_DECL from_python_converter_base;
-struct BOOST_PYTHON_DECL to_python_converter_base;
 
 // This namespace acts as a sort of singleton
 namespace registry
 {
-  // These are the elements stored in the registry
-  class BOOST_PYTHON_DECL entry
-  {
-   public: // member functions
-      entry();
-      ~entry();
-
-      // Return a converter appropriate for converting the given
-      // Python object from_python to the C++ type with which this
-      // converter is associated in the registry, or 0 if no such
-      // converter exists.
-      from_python_converter_base const* get_from_python(PyObject*, void*& data) const;
-
-      // Return a conversion function appropriate for converting a C++
-      // object whose type this entry is associated with in the
-      // registry to a Python object, or 0 if no such converter
-      // exists. This function must be reinterpret_cast to the
-      // appropriate to_python_function type.
-      to_python_function_base get_to_python() const;
-
-      // Conversion classes use these functions to register
-      // themselves.
-      void insert(from_python_converter_base&);
-      void remove(from_python_converter_base&);
-
-      void insert(to_python_converter_base&);
-      void remove(to_python_converter_base&);
-
-   private: // types
-      typedef std::vector<from_python_converter_base*> from_python_converters;
-      
-   private: // helper functions
-      from_python_converters::iterator find(from_python_converter_base const&);
-      
-   private: // data members
-      
-      // The collection of from_python converters for the associated
-      // C++ type.
-      from_python_converters m_from_python_converters;
-
-      // The unique to_python converter for the associated C++ type.
-      to_python_converter_base* m_to_python_converter;
-  };
-
-  BOOST_PYTHON_DECL entry* find(type_id_t);
+  BOOST_PYTHON_DECL to_python_value_function const&
+  to_python_function(undecorated_type_id_t);
   
-  BOOST_PYTHON_DECL void insert(to_python_converter_base& x);
-  BOOST_PYTHON_DECL void insert(from_python_converter_base& x);
-  BOOST_PYTHON_DECL void remove(to_python_converter_base& x);
-  BOOST_PYTHON_DECL void remove(from_python_converter_base& x);
+  BOOST_PYTHON_DECL void insert(to_python_value_function, undecorated_type_id_t);
+  
+  BOOST_PYTHON_DECL from_python_converter_base*& from_python_chain(type_id_t);
+  
+  BOOST_PYTHON_DECL PyTypeObject*& class_object(undecorated_type_id_t key);
 }
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/source.hpp b/include/boost/python/converter/source.hpp
deleted file mode 100644
index 9abf245f..00000000
--- a/include/boost/python/converter/source.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-#ifndef SOURCE_DWA20011119_HPP
-# define SOURCE_DWA20011119_HPP
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/mpl/select_type.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// source --
-//
-//    This type generator (see
-//    ../../../more/generic_programming.html#type_generator) is used
-//    to select the argument type to use when converting T to a PyObject*
-
-template <class T>
-struct source
-{
-    typedef
-        typename add_reference<
-                typename add_const<T>::type
-          >::type
-    type;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // SOURCE_DWA20011119_HPP
diff --git a/include/boost/python/converter/source_holder.hpp b/include/boost/python/converter/source_holder.hpp
deleted file mode 100644
index f2c774f9..00000000
--- a/include/boost/python/converter/source_holder.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef SOURCE_HOLDER_DWA20011215_HPP
-# define SOURCE_HOLDER_DWA20011215_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-struct source_holder_base
-{
-};
-
-template <class T>
-struct source_holder : source_holder_base
-{
-    source_holder(T x) : value(x) {}
-    T value;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // SOURCE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/converter/to_python.hpp b/include/boost/python/converter/to_python.hpp
deleted file mode 100644
index a1d6c28b..00000000
--- a/include/boost/python/converter/to_python.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef TO_PYTHON_DWA2002127_HPP
-# define TO_PYTHON_DWA2002127_HPP
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/converter/registration.hpp>
-# include <boost/python/converter/source_holder.hpp>
-# include <boost/python/converter/to_python_function.hpp>
-# include <boost/python/converter/builtin_to_python_converters.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct to_python_lookup;
-
-struct BOOST_PYTHON_DECL to_python_converter_base : body
-{
-    to_python_converter_base(type_id_t, to_python_function_base); // registers
-    ~to_python_converter_base();         // unregisters
-    
-//    inline type_id_t key() const;
-    inline to_python_function_base converter() const;
- private:
-//    type_id_t m_key;
-    to_python_function_base m_convert;
-};
-
-template <class T>
-struct to_python_converter : to_python_converter_base
-{
- public: // types
-    typedef typename to_python_function<T>::type converter_t;
-    
- public: // member functions
-    to_python_converter(converter_t);
-    converter_t converter() const;
-
- private: // data members
-    converter_t m_convert;
-};
-
-// -------------------------------------------------------------------------
-
-//struct to_python_base {};
-
-template <class T>
-struct to_python_lookup //: to_python_base
-{
- public: // member functions
-    to_python_lookup();
-    bool convertible() const;
-    PyObject* operator()(T) const;
- private:
-    typename to_python_function<T>::type m_convert;
-};
-
-//
-// implementations
-//
-# if 0
-inline type_id_t
-to_python_converter_base::key() const
-{
-    return m_key;
-}
-# endif
-
-inline to_python_function_base
-to_python_converter_base::converter() const
-{
-    return m_convert;
-}
-
-template <class T>
-to_python_converter<T>::to_python_converter(converter_t convert)
-    : to_python_converter_base(
-        type_id<T>(), reinterpret_cast<to_python_function_base>(convert))
-{
-}
-
-template <class T>
-inline typename to_python_function<T>::type
-to_python_converter<T>::converter() const
-{
-    return reinterpret_cast<converter_t>(
-        this->to_python_converter_base::converter());
-}
-
-template <class T>
-inline to_python_lookup<T>::to_python_lookup()
-    : m_convert(
-        registration<T>::get_to_python())
-{
-}
-
-template <class T>
-inline bool
-to_python_lookup<T>::convertible() const
-{
-    return m_convert != 0;
-}
-
-template <class T>
-inline PyObject*
-to_python_lookup<T>::operator()(T x) const
-{
-    return m_convert ? m_convert(x) : 0;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // TO_PYTHON_DWA2002127_HPP
diff --git a/include/boost/python/converter/to_python_function.hpp b/include/boost/python/converter/to_python_function.hpp
index 9d408749..a438ce0c 100644
--- a/include/boost/python/converter/to_python_function.hpp
+++ b/include/boost/python/converter/to_python_function.hpp
@@ -7,15 +7,24 @@
 # define TO_PYTHON_FUNCTION_DWA2002128_HPP
 
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-typedef PyObject* (*to_python_function_base)(void);
+// The type of stored function pointers which actually do conversion
+// by-value. The void* points to the object to be converted, and
+// type-safety is preserved through runtime registration.
+typedef PyObject* (*to_python_value_function)(void const*);
 
-template <class T>
-struct to_python_function
+// Given a typesafe to_python conversion function, produces a
+// to_python_value_function which can be registered in the usual way.
+template <class T, class ToPython>
+struct as_to_python_value_function
 {
-    typedef PyObject*(*type)(T);
+    static PyObject* convert(void const* x)
+    {
+        return ToPython::convert(*(T const*)x);
+    }
 };
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/type_id.hpp b/include/boost/python/converter/type_id.hpp
index e5068604..015e55e9 100644
--- a/include/boost/python/converter/type_id.hpp
+++ b/include/boost/python/converter/type_id.hpp
@@ -7,8 +7,12 @@
 # define TYPE_ID_DWA20011127_HPP
 # include <boost/python/detail/config.hpp>
 # include <boost/python/detail/indirect_traits.hpp>
+# include <boost/python/detail/msvc_typeinfo.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/type_traits/composite_traits.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/operators.hpp>
+# include <boost/type.hpp>
 # include <typeinfo>
 # include <iosfwd>
 # include <cstring>
@@ -16,13 +20,6 @@
 
 namespace boost { namespace python { namespace converter { 
 
-// a portable mechanism for identifying types at runtime across modules.
-
-namespace detail
-{
-  template <class T> class dummy;
-}
-
 // for this compiler at least, cross-shared-library type_info
 // comparisons don't work, so use typeid(x).name() instead. It's not
 // yet clear what the best default strategy is.
@@ -61,7 +58,7 @@ struct type_id_t : totally_ordered<type_id_t>
 {
     enum decoration { const_ = 0x1, volatile_ = 0x2, reference = 0x4 };
     
-    type_id_t(undecorated_type_id_t, decoration decoration);
+    type_id_t(undecorated_type_id_t, decoration = decoration());
 
     bool operator<(type_id_t const& rhs) const;
     bool operator==(type_id_t const& rhs) const;
@@ -78,13 +75,19 @@ struct type_id_t : totally_ordered<type_id_t>
 };
 
 template <class T>
-inline undecorated_type_id_t undecorated_type_id(detail::dummy<T>* = 0)
+inline undecorated_type_id_t undecorated_type_id(boost::type<T>* = 0)
 {
-    return undecorated_type_id_t(typeid(T));
+    return undecorated_type_id_t(
+#  if (!defined(BOOST_MSVC) || BOOST_MSVC > 1300) && (!defined(BOOST_INTEL_CXX_VERSION) || BOOST_INTEL_CXX_VERSION > 600)
+        typeid(T)
+#  else // strip the decoration which msvc and Intel mistakenly leave in
+        python::detail::msvc_typeid<T>()
+#  endif 
+        );
 }
 
 template <class T>
-inline type_id_t type_id(detail::dummy<T>* = 0)
+inline type_id_t type_id(boost::type<T>* = 0)
 {
     return type_id_t(
         undecorated_type_id<T>()
diff --git a/include/boost/python/converter/wrapper_base.hpp b/include/boost/python/converter/wrapper_base.hpp
deleted file mode 100644
index 585959ae..00000000
--- a/include/boost/python/converter/wrapper_base.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef WRAPPER_BASE_DWA2002110_HPP
-# define WRAPPER_BASE_DWA2002110_HPP
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/body.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct source_holder_base;
-struct wrap_base;
-template <class T> struct wrap_more_;
-
-struct BOOST_PYTHON_DECL wrapper_base : body
-{
- public:
-    wrapper_base(type_id_t); // registers
-    ~wrapper_base();         // unregisters
-    
-    virtual PyObject* do_conversion(wrap_base const&, source_holder_base const&) const = 0;
-};
-
-}}} // namespace boost::python::converter
-
-#endif // WRAPPER_BASE_DWA2002110_HPP
diff --git a/include/boost/python/copy_const_reference.hpp b/include/boost/python/copy_const_reference.hpp
index 57c45fd4..b2fdd61f 100644
--- a/include/boost/python/copy_const_reference.hpp
+++ b/include/boost/python/copy_const_reference.hpp
@@ -7,7 +7,7 @@
 # define COPY_CONST_REFERENCE_DWA2002131_HPP
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/mpl/select_type.hpp>
-# include <boost/python/to_python.hpp>
+# include <boost/python/to_python_value.hpp>
 
 namespace boost { namespace python { 
 
diff --git a/include/boost/python/copy_non_const_reference.hpp b/include/boost/python/copy_non_const_reference.hpp
index dead736f..6f53fbdc 100644
--- a/include/boost/python/copy_non_const_reference.hpp
+++ b/include/boost/python/copy_non_const_reference.hpp
@@ -7,7 +7,7 @@
 # define COPY_NON_CONST_REFERENCE_DWA2002131_HPP
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/mpl/select_type.hpp>
-# include <boost/python/to_python.hpp>
+# include <boost/python/to_python_value.hpp>
 
 namespace boost { namespace python { 
 
diff --git a/include/boost/python/detail/caller.hpp b/include/boost/python/detail/caller.hpp
index fe022961..d0b01b6e 100644
--- a/include/boost/python/detail/caller.hpp
+++ b/include/boost/python/detail/caller.hpp
@@ -20,26 +20,6 @@ namespace boost { namespace python
 
 namespace boost { namespace python { namespace detail {
 
-// for "readable" error messages
-template <class T> struct must_use_a_result_handler_to_wrap_functions_returning
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
-{}
-# endif 
-;
-
-struct to_python_generator
-{
-    template <class R>
-    struct apply
-    {
-        typedef typename mpl::select_type<
-                is_reference<R>::value | is_pointer<R>::value
-            , must_use_a_result_handler_to_wrap_functions_returning<R>
-            , to_python<R>
-        >::type type;
-    };
-};
-
 struct caller
 {
     typedef PyObject* result_type;
diff --git a/include/boost/python/detail/msvc_typeinfo.hpp b/include/boost/python/detail/msvc_typeinfo.hpp
new file mode 100644
index 00000000..2473023a
--- /dev/null
+++ b/include/boost/python/detail/msvc_typeinfo.hpp
@@ -0,0 +1,99 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MSVC_TYPEINFO_DWA200222_HPP
+# define MSVC_TYPEINFO_DWA200222_HPP
+
+#include <boost/type.hpp>
+#include <typeinfo>
+
+//
+// Fix for MSVC's broken typeid() implementation which doesn't strip
+// decoration. This fix doesn't handle cv-qualified array types. It
+// could probably be done, but I haven't figured it out yet.
+//
+
+# if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(BOOST_INTEL_CXX_VERSION) && BOOST_INTEL_CXX_VERSION <= 600
+
+namespace boost { namespace python { namespace detail { 
+
+typedef std::type_info const& typeinfo;
+
+template<int>struct value_id_accessor;
+
+template<>
+struct value_id_accessor<0>
+{
+    template <class T>
+    static typeinfo get(T*) { return typeid(T); }
+};
+
+template<>
+struct value_id_accessor<1>
+{
+    template <class T>
+    static typeinfo get(T const*) { return typeid(T); }
+};
+
+template<>
+struct value_id_accessor<2>
+{
+    template <class T>
+    static typeinfo get(T volatile*) { return typeid(T); }
+};
+
+template<>
+struct value_id_accessor<3>
+{
+    template <class T>
+    static typeinfo get(T const volatile*) { return typeid(T); }
+};
+
+template <bool> struct bool_t{};
+
+template <class T>
+inline typeinfo typeid_nonref(boost::type<T>* = 0)
+{
+    BOOST_STATIC_CONSTANT(bool, c = is_const<T>::value);
+    BOOST_STATIC_CONSTANT(bool, v = is_volatile<T>::value);
+    return value_id_accessor<(2 * v + c)>::get((T*)0);
+}
+
+template <class T>
+inline typeinfo typeid_ref(boost::type<T>*, ...) 
+{
+    return typeid_nonref<T>();
+}
+
+template <class U, class T>
+inline typeinfo typeid_ref(boost::type<U>*, T& (*)()) 
+{
+    return typeid_nonref<T>();
+}
+
+template <class T>
+inline typeinfo typeid_array(bool_t<false>, boost::type<T>* = 0)
+{
+    typedef T (*x)();
+    return typeid_ref((boost::type<T>*)0, x(0));
+}
+
+template <class T>
+inline typeinfo typeid_array(bool_t<true>, boost::type<T>* = 0)
+{
+    return typeid_nonref<T>();
+}
+
+template <class T>
+inline typeinfo msvc_typeid(boost::type<T>* = 0)
+{
+    typedef bool_t<is_array<T>::value> tag;
+    return typeid_array(tag(), (boost::type<T>*)0);
+}
+
+}}} // namespace boost::python::detail
+
+# endif // BOOST_MSVC
+#endif // MSVC_TYPEINFO_DWA200222_HPP
diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index c8533f9e..99bbc572 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -11,17 +11,10 @@
 #ifndef RETURNING_DWA20011201_HPP
 # define RETURNING_DWA20011201_HPP
 
-//# include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/config.hpp>
 # include <boost/python/detail/none.hpp>
 # include <boost/python/from_python.hpp>
-# include <boost/python/to_python.hpp>
-
-namespace boost { namespace python
-{
-  template <class T> struct to_python;
-}} // namespace boost::python
 
 namespace boost { namespace python { namespace detail {
 
diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index 90a5c12b..2943d96c 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -8,7 +8,6 @@
 
 # include <boost/python/object/function.hpp>
 # include <boost/python/object/make_holder.hpp>
-# include <boost/python/converter/registration.hpp>
 # include <boost/python/detail/caller.hpp>
 # include <boost/python/detail/arg_tuple_size.hpp>
 # include <boost/mpl/size.hpp>
diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
index 26334bc7..4a52f290 100644
--- a/include/boost/python/object/class_wrapper.hpp
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -6,21 +6,18 @@
 #ifndef CLASS_WRAPPER_DWA20011221_HPP
 # define CLASS_WRAPPER_DWA20011221_HPP
 
-# include <boost/python/object/class.hpp>
 # include <boost/python/object/value_holder.hpp>
 # include <boost/python/reference.hpp>
-# include <boost/python/converter/to_python.hpp>
-# include <memory>
+# include <boost/python/to_python_converter.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
 template <class T>
 struct class_wrapper
-    : converter::to_python_converter<T const&>
+    : to_python_converter<T, class_wrapper<T> >
 {
     class_wrapper(ref const& type_)
-        : converter::to_python_converter<T const&>(convert)
-        , m_class_object_keeper(type_)
+        : m_class_object_keeper(type_)
     {
         assert(type_->ob_type == (PyTypeObject*)class_metatype().get());
         m_class_object = (PyTypeObject*)type_.get();
@@ -31,9 +28,8 @@ struct class_wrapper
         // Don't call the type to do the construction, since that
         // would require the registration of an __init__ copy
         // constructor. Instead, just construct the object in place.
-        PyObject* raw_result = (PyObject*)PyObject_New(
-            instance, m_class_object);
-        
+        PyObject* raw_result = m_class_object->tp_alloc(m_class_object, 0);
+
         if (raw_result == 0)
             return 0;
 
@@ -41,6 +37,8 @@ struct class_wrapper
         // exceptions.
         ref result(raw_result, ref::allow_null());
 
+        ((instance*)raw_result)->objects = 0;
+        
         // Build a value_holder to contain the object using the copy
         // constructor
         value_holder<T>* p = new value_holder<T>(raw_result, cref(x));
diff --git a/include/boost/python/to_python.hpp b/include/boost/python/to_python.hpp
deleted file mode 100644
index e00346bb..00000000
--- a/include/boost/python/to_python.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef TO_PYTHON_DWA2002128_HPP
-# define TO_PYTHON_DWA2002128_HPP
-
-# include <boost/python/converter/to_python.hpp>
-# include <boost/python/converter/source.hpp>
-
-namespace boost { namespace python { 
-
-template <class T>
-struct to_python
-    : converter::to_python_lookup<typename converter::source<T>::type>
-{
-};
-
-// specialization for PyObject*
-template <>
-struct to_python<PyObject*>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(PyObject* source) const { return source; }
-};
-
-template <>
-struct to_python<PyObject*const&>
-{
-    bool convertible() const { return true; }
-    PyObject* operator()(PyObject* source) const { return source; }
-};
-
-}} // namespace boost::python
-
-#endif // TO_PYTHON_DWA2002128_HPP
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index c2ce3dae..26834635 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -200,7 +200,6 @@ namespace
 #define REGISTER_INT_CONVERTERS(U) register_int_converters<U>()
 #define REGISTER_INT_CONVERTERS2(U) REGISTER_INT_CONVERTERS(signed U); REGISTER_INT_CONVERTERS(unsigned U)  
 
-
 void initialize_builtin_converters()
 {
     REGISTER_INT_CONVERTERS2(char);
diff --git a/src/converter/from_python.cpp b/src/converter/from_python.cpp
index 979ad935..2e844acf 100644
--- a/src/converter/from_python.cpp
+++ b/src/converter/from_python.cpp
@@ -5,6 +5,7 @@
 // to its suitability for any purpose.
 
 #include <boost/python/converter/from_python.hpp>
+#include <boost/python/converter/registry.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -14,14 +15,12 @@ from_python_converter_base::from_python_converter_base(
     )
     : body(type)
     , m_convertible(checker)
-{
-    registry::insert(*this);
-}
 
-from_python_converter_base::~from_python_converter_base()
 {
-    if (can_unregister())
-        registry::remove(*this);
+    // Insert this in the converter chain.
+    from_python_converter_base*& head = registry::from_python_chain(type);
+    m_next = head;
+    head = this;
 }
 
 }}} // namespace boost::python::converter
diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
index 5b4563a4..c90d709d 100644
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -3,23 +3,32 @@
 //  copyright notice appears in all copies. This software is provided
 //  "as is" without express or implied warranty, and with no claim as
 //  to its suitability for any purpose.
-
-# include <boost/python/converter/to_python.hpp>
-# include <boost/python/converter/from_python.hpp>
-# include <boost/python/converter/builtin_converters.hpp>
-# include <boost/detail/binary_search.hpp>
-# include <map>
-# include <algorithm>
-# include <stdexcept>
-# ifdef BOOST_PYTHON_TRACE
-#  include <iostream>
-# endif 
+#include <boost/python/converter/registry.hpp>
+#include <boost/python/converter/builtin_converters.hpp>
+#include <map>
+#include <stdexcept>
 
 namespace boost { namespace python { namespace converter { 
 
 namespace // <unnamed>
 {
-  typedef std::map<type_id_t, registry::entry> registry_t;
+  // These are the elements stored in the registry
+  struct entry
+  {
+      entry();
+      
+      // The unique to_python converter for the associated C++ type.
+      to_python_value_function m_to_python_converter;
+
+      // The collection of from_python converters for the associated
+      // C++ type.
+      from_python_converter_base* m_from_python_converters;
+
+      // The class object associated with this type
+      PyTypeObject* m_class_object;
+  };
+  
+  typedef std::map<type_id_t, entry> registry_t;
   
   registry_t& entries()
   {
@@ -35,10 +44,7 @@ namespace // <unnamed>
       }
       return registry;
   }
-} // namespace <unnamed>
 
-namespace registry
-{
   entry* find(type_id_t type)
   {
       return &entries()[type];
@@ -46,128 +52,40 @@ namespace registry
 
   entry::entry()
       : m_to_python_converter(0)
+        , m_from_python_converters(0)
+        , m_class_object(0)
   {
   }
+} // namespace <unnamed>
 
-  entry::~entry()
+namespace registry
+{
+  to_python_value_function const& to_python_function(
+      undecorated_type_id_t key)
   {
-      if (m_to_python_converter != 0)
-          m_to_python_converter->m_can_unregister = false;
-      
-      for (from_python_converters::iterator p = m_from_python_converters.begin()
-               ; p != m_from_python_converters.end()
-               ; ++p)
-      {
-          (*p)->m_can_unregister = false;
-      }
-  }
-
-  from_python_converter_base const*
-  entry::get_from_python(PyObject* p, void*& data_out) const
-  {      
-      for (from_python_converters::const_iterator q = m_from_python_converters.begin(),
-               finish = m_from_python_converters.end();
-           q != finish;
-           ++q)
-      {
-          void* const data = (*q)->convertible(p);
-          if (data != 0)
-          {
-              data_out = data;
-              return *q;
-              break;
-          }
-      }
-      return 0;
+      return find(key)->m_to_python_converter;
   }
   
-  to_python_function_base entry::get_to_python() const
+  void insert(to_python_value_function f, undecorated_type_id_t source_t)
   {
-      return m_to_python_converter
-          ? m_to_python_converter->converter()
-          : 0;
-  }
-
-  entry::from_python_converters::iterator entry::find(from_python_converter_base const& x)
-  {
-      return std::find(m_from_python_converters.begin(), m_from_python_converters.end(), &x);
-  }
-
-  void entry::insert(from_python_converter_base& x)
-  {
-      from_python_converters::iterator p = this->find(x);
-      
-      if (p != m_from_python_converters.end())
-      {
-          assert(!"converter already registered");
-          throw std::runtime_error(
-              "trying to register unrapper which is already registered");
-      }
-
-      m_from_python_converters.push_back(&x);
-  }
-  
-  void entry::remove(from_python_converter_base& x)
-  {
-      from_python_converters::iterator p = find(x);
-
-      // Be sure we're not removing a converter which hasn't been
-      // registered.
-      if (p == m_from_python_converters.end())
-      {
-          assert(!"trying to unregister from_python_converter which is not registered");
-          throw std::runtime_error(
-              "trying to unregister from_python_converter which is not registered");
-      }
-      m_from_python_converters.erase(p);
-  }
-  
-  void entry::insert(to_python_converter_base& x)
-  {
-      assert(m_to_python_converter == 0); // we have a problem otherwise
-      if (m_to_python_converter != 0)
+      to_python_value_function& slot = find(source_t)->m_to_python_converter;
+      assert(slot == 0); // we have a problem otherwise
+      if (slot != 0)
       {
           throw std::runtime_error(
               "trying to register to_python_converter for a type which already has a registered to_python_converter");
       }
-      m_to_python_converter = &x;
+      slot = f;
+  }
+
+  from_python_converter_base*& from_python_chain(type_id_t key)
+  {
+      return find(key)->m_from_python_converters;
   }
   
-  void entry::remove(to_python_converter_base& x)
+  PyTypeObject*& class_object(undecorated_type_id_t key)
   {
-      assert(m_to_python_converter == &x);
-      if (m_to_python_converter != &x)
-      {
-          throw std::runtime_error(
-              "trying to unregister a to_python_converter which is not registered");
-      }
-      m_to_python_converter = 0;
-  }
-
-  void insert(to_python_converter_base& w)
-  {
-# ifdef BOOST_PYTHON_TRACE
-      std::cout << "inserting to_python_converter for " << w.key() << std::endl;
-# endif 
-      find(w.key())->insert(w);
-  }
-
-  void insert(from_python_converter_base& u)
-  {
-# ifdef BOOST_PYTHON_TRACE
-      std::cout << "inserting from_python_converter for " << u.key() << std::endl;
-# endif 
-      find(u.key())->insert(u);
-  }
-
-  void remove(to_python_converter_base& w)
-  {
-      find(w.key())->remove(w);
-  }
-
-  void remove(from_python_converter_base& u)
-  {
-      find(u.key())->remove(u);
+      return find(key)->m_class_object;
   }
 } // namespace registry
 
diff --git a/src/converter/to_python.cpp b/src/converter/to_python.cpp
deleted file mode 100644
index 9cede51d..00000000
--- a/src/converter/to_python.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-#include <boost/python/converter/to_python.hpp>
-#include <boost/python/converter/registry.hpp>
-
-namespace boost { namespace python { namespace converter {
-
-to_python_converter_base::to_python_converter_base(type_id_t key, to_python_function_base convert)
-    : body(key)
-    , m_convert(convert)
-{
-    registry::insert(*this);
-}
-
-to_python_converter_base::~to_python_converter_base()
-{
-    registry::remove(*this);
-}
-
-}}} // namespace boost::python::converter
diff --git a/src/converter/type_id.cpp b/src/converter/type_id.cpp
index 688dd2bc..904f30d0 100644
--- a/src/converter/type_id.cpp
+++ b/src/converter/type_id.cpp
@@ -21,18 +21,12 @@ BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, undecorated_type_id
 BOOST_PYTHON_DECL std::ostream& operator<<(std::ostream& os, type_id_t const& x)
 {
     os << x.m_base_type;
-    // VC6 mistakenly distinguishes typeid(X) from typeid(X const)
-    // from typeid(X&)...  so the name is already correct. I have it
-    // from Jason Shirk that VC7.0 has the same bug but it will be
-    // fixed in 7.1
-# if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
     if (x.m_decoration & type_id_t::const_)
         os << " const";
     if (x.m_decoration & type_id_t::volatile_)
         os << " volatile";
     if (x.m_decoration & type_id_t::reference)
         os << "&";
-# endif 
     return os;
 }
 
diff --git a/src/object/class.cpp b/src/object/class.cpp
index de3e32f5..5d1ecf01 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -6,7 +6,6 @@
 #include <boost/python/detail/config.hpp>
 #include <boost/python/detail/wrap_python.hpp>
 #include <boost/python/object/class.hpp>
-#include <boost/python/object/class_wrapper.hpp>
 #include <boost/python/objects.hpp>
 #include <boost/python/detail/map_entry.hpp>
 #include <boost/detail/binary_search.hpp>
@@ -122,7 +121,7 @@ PyTypeObject class_type_object = {
         0,                                      /* tp_descr_set */
         0,                                      /* tp_dictoffset */
         0,                                      /* tp_init */
-        0,                                      /* tp_alloc */
+        PyType_GenericAlloc,                    /* tp_alloc */
         PyType_GenericNew
 };
 
diff --git a/test/m1.cpp b/test/m1.cpp
index b807dc43..b42742ab 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -16,6 +16,7 @@
 #include <boost/python/return_value_policy.hpp>
 #include <boost/python/converter/class.hpp>
 #include <boost/python/reference_from_python.hpp>
+#include <boost/python/to_python_converter.hpp>
 #include <boost/python/value_from_python.hpp>
 #include <boost/python/errors.hpp>
 #include <boost/mpl/type_list.hpp>
@@ -105,26 +106,19 @@ PyObject* new_simple()
 // are selected.
 //
 using boost::python::converter::from_python_data;
+using boost::python::to_python_converter;
 
-// Wrap a simple by converting it to a Simple
-PyObject* simple_to_python(simple const& x)
+// Wrap a simple by copying it into a Simple
+struct simple_to_python
+    : to_python_converter<simple, simple_to_python>
 {
-    SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
-    p->x = x;
-    return (PyObject*)p;
-}
-
-
-// wrap a mutable reference to a simple by converting it to a
-// Simple. Normally we wouldn't do it this way, since modifications to
-// the result clearly don't change the original object, but here we're
-// just proving that the mechanism works.
-PyObject* simple_ref_to_python(simple& x)
-{
-    SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
-    p->x = x;
-    return (PyObject*)p;
-}
+    static PyObject* convert(simple const& x)
+    {
+        SimpleObject* p = PyObject_New(SimpleObject, &SimpleType);
+        p->x = x;
+        return (PyObject*)p;
+    }
+};
 
 int noddy_to_int(PyObject* p, from_python_data&)
 {
@@ -184,16 +178,15 @@ struct D : B, C
     int x;
 };
 
-int take_a(A const& a) { return a.x; }
-int take_b(B const& b) { return b.x; }
-int take_c(C const& c) { return c.x; }
-int take_d(D const& d) { return d.x; }
+A take_a(A const& a) { return a; }
+B take_b(B const& b) { return b; }
+C take_c(C const& c) { return c; }
+D take_d(D const& d) { return d; }
     
 BOOST_PYTHON_MODULE_INIT(m1)
 {
     using boost::python::module;
     using boost::python::class_;
-    using boost::python::converter::to_python_converter;
     using boost::python::converter::from_python_converter;
     using boost::python::reference_from_python;
     using boost::python::value_from_python;
@@ -204,7 +197,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
     using boost::mpl::type_list;
     
     // Create the converters; they are self-registering/unregistering.
-    static to_python_converter<simple const&> c1(simple_to_python);
+    static simple_to_python c1;
 
     static from_python_converter<int> c2(
         &(boost::python::type_from_python<&NoddyType>::convertible), noddy_to_int);
@@ -219,10 +212,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
         , extract_simple_object
         >
         unwrap_simple;
-    
-    static to_python_converter<simple&> simple_ref_wrapper(simple_ref_to_python);
 
-    
     module m1("m1");
 
     typedef boost::python::objects::pointer_holder_generator<
diff --git a/test/newtest.py b/test/newtest.py
index 0636641b..4e6de142 100644
--- a/test/newtest.py
+++ b/test/newtest.py
@@ -73,8 +73,8 @@ are a complicated constructor and member function, respectively.
 >>> d = D()
 
 ------
->>> take_a(a)
-0
+>>> take_a(a).name()
+'A'
 
 >>> try:
 ...     take_b(a)
@@ -92,11 +92,11 @@ are a complicated constructor and member function, respectively.
 ... else: print 'no exception'
 
 ------
->>> take_a(b)
-0
+>>> take_a(b).name()
+'A'
 
->>> take_b(b)
-1
+>>> take_b(b).name()
+'B'
 
 >>> try:
 ...     take_c(b)
@@ -109,16 +109,16 @@ are a complicated constructor and member function, respectively.
 ... else: print 'no exception'
 
 -------
->>> take_a(c)
-0
+>>> take_a(c).name()
+'A'
 
 >>> try:
 ...     take_b(c)
 ... except: pass
 ... else: print 'no exception'
 
->>> take_c(c)
-2
+>>> take_c(c).name()
+'C'
 
 >>> try:
 ...     take_d(c)
@@ -126,14 +126,14 @@ are a complicated constructor and member function, respectively.
 ... else: print 'no exception'
 
 -------
->>> take_a(d)
-0
->>> take_b(d)
-1
->>> take_c(d)
-2
->>> take_d(d)
-3
+>>> take_a(d).name()
+'A'
+>>> take_b(d).name()
+'B'
+>>> take_c(d).name()
+'C'
+>>> take_d(d).name()
+'D'
 
 
 """

From 14917c9791997288a11bcc3b309ca78efe8f89fd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 14:31:07 +0000
Subject: [PATCH 247/369] initial checkin

[SVN r12633]
---
 include/boost/python/to_python_converter.hpp | 39 +++++++++++++
 include/boost/python/to_python_value.hpp     | 58 ++++++++++++++++++++
 2 files changed, 97 insertions(+)
 create mode 100644 include/boost/python/to_python_converter.hpp
 create mode 100644 include/boost/python/to_python_value.hpp

diff --git a/include/boost/python/to_python_converter.hpp b/include/boost/python/to_python_converter.hpp
new file mode 100644
index 00000000..6bea9822
--- /dev/null
+++ b/include/boost/python/to_python_converter.hpp
@@ -0,0 +1,39 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_CONVERTER_DWA200221_HPP
+# define TO_PYTHON_CONVERTER_DWA200221_HPP
+
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/type_id.hpp>
+
+namespace boost { namespace python { 
+
+template <class T, class Derived>
+struct to_python_converter
+{
+    to_python_converter();
+};
+
+//
+// implementation
+//
+
+template <class T, class Derived>
+to_python_converter<T,Derived>::to_python_converter()
+{
+    typedef converter::as_to_python_value_function<
+        T, Derived
+        > normalized;
+        
+    converter::registry::insert(
+        &normalized::convert
+        , converter::undecorated_type_id<T>());
+}
+
+}} // namespace boost::python
+
+#endif // TO_PYTHON_CONVERTER_DWA200221_HPP
diff --git a/include/boost/python/to_python_value.hpp b/include/boost/python/to_python_value.hpp
new file mode 100644
index 00000000..a222e9a9
--- /dev/null
+++ b/include/boost/python/to_python_value.hpp
@@ -0,0 +1,58 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_VALUE_DWA200221_HPP
+# define TO_PYTHON_VALUE_DWA200221_HPP
+
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/builtin_to_python_converters.hpp>
+
+namespace boost { namespace python { 
+
+template <class T>
+struct to_python_value
+{
+    typedef typename add_reference<
+        typename add_const<T>::type
+    >::type argument_type;
+    
+    static bool convertible();
+    PyObject* operator()(argument_type) const;
+
+ private:
+    // Note that this is a pointer to a function pointer
+    static converter::to_python_value_function const* fconvert;
+};
+
+
+template <class T>
+converter::to_python_value_function const*
+to_python_value<T>::fconvert
+        = &converter::registry::to_python_function(converter::undecorated_type_id<T>());
+
+
+template <class T>
+bool to_python_value<T>::convertible()
+{
+    // if this assert fires, our static variable hasn't been set up yet.
+    assert(fconvert != 0);
+    return *fconvert != 0;
+}
+
+template <class T>
+PyObject* to_python_value<T>::operator()(argument_type x) const
+{
+    // This might be further optimized on platforms which dynamically
+    // link without specific imports/exports
+    converter::to_python_value_function f = *fconvert;
+    return f(&x);
+}
+
+}} // namespace boost::python
+
+#endif // TO_PYTHON_VALUE_DWA200221_HPP

From ecc8abcc50505b86d34693012486ec7c19824254 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 14:34:02 +0000
Subject: [PATCH 248/369] ice_ fixes for KCC

[SVN r12634]
---
 include/boost/python/default_call_policies.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/default_call_policies.hpp b/include/boost/python/default_call_policies.hpp
index 475278e4..f0b69255 100644
--- a/include/boost/python/default_call_policies.hpp
+++ b/include/boost/python/default_call_policies.hpp
@@ -48,8 +48,10 @@ struct default_result_converter
     template <class R>
     struct apply
     {
+        BOOST_STATIC_CONSTANT(bool, is_illegal = is_reference<R>::value || is_pointer<R>::value);
+        
         typedef typename mpl::select_type<
-            is_reference<R>::value | is_pointer<R>::value
+            is_illegal
             , detail::specify_a_result_policy_to_wrap_functions_returning<R>
             , boost::python::to_python_value<
                 typename add_reference<typename add_const<R>::type>::type

From 7703f91ee26512c7e7c2c8c97b3ac5f971bc64a5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 2 Feb 2002 15:17:37 +0000
Subject: [PATCH 249/369] fix typo

[SVN r12636]
---
 src/objects.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/objects.cpp b/src/objects.cpp
index b447b262..8b5ac3dd 100644
--- a/src/objects.cpp
+++ b/src/objects.cpp
@@ -9,7 +9,7 @@
 // TODO: Move inline implementations from objects.cpp here
 
 #ifndef BOOST_PYTHON_SOURCE
-r# define BOOST_PYTHON_SOURCE
+# define BOOST_PYTHON_SOURCE
 #endif 
 
 #include <boost/python/objects.hpp>

From 71de2b5ec52421ed0fd1f717c89b88295e6c0502 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sat, 2 Feb 2002 15:19:59 +0000
Subject: [PATCH 250/369] /Zm upgrade

[SVN r12637]
---
 build/vc60.mak | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/vc60.mak b/build/vc60.mak
index 6f303791..1709073c 100644
--- a/build/vc60.mak
+++ b/build/vc60.mak
@@ -21,7 +21,7 @@ PYEXE="C:\Python21\python.exe"
 PYINC=/I"C:\Python21\include"
 PYLIB="C:\Python21\libs\python21.lib"
 
-STDOPTS=/nologo /MD /GR /GX /Zm200 /DBOOST_PYTHON_STATIC_LIB
+STDOPTS=/nologo /MD /GR /GX /Zm300 /DBOOST_PYTHON_STATIC_LIB
 WARNOPTS=
 OPTOPTS=
 

From 6e5fc91885e622c4d513300e53a05477dd10892c Mon Sep 17 00:00:00 2001
From: Darin Adler <darin@bentspoon.com>
Date: Sat, 2 Feb 2002 18:36:12 +0000
Subject: [PATCH 251/369] New smart pointer documentation. Related clean-up of
 the smart pointer library. Changing includes to include the new individual
 smart pointer headers. Replacing old smart pointer library with an include of
 the new smart pointer headers. Simplify ifdefs that involve the member
 templates macros now that BOOST_MSVC6_MEMBER_TEMPLATES is also guaranteed to
 bet set for platforms that have full member templates.

[SVN r12647]
---
 include/boost/python/conversions.hpp            | 2 +-
 include/boost/python/detail/extension_class.hpp | 2 +-
 include/boost/python/object/inheritance.hpp     | 2 +-
 src/types.cpp                                   | 1 -
 4 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index aa07547f..24ac5614 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -19,7 +19,7 @@
 # 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/shared_ptr.hpp>
 # include <boost/python/errors.hpp>
 # include <string>
 
diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 638217d1..dd6741d2 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -26,7 +26,7 @@
 # include <memory>
 # include <boost/python/detail/init_function.hpp>
 # include <typeinfo>
-# include <boost/smart_ptr.hpp>
+# include <boost/shared_ptr.hpp>
 # include <boost/type_traits.hpp>
 
 namespace boost { namespace python {
diff --git a/include/boost/python/object/inheritance.hpp b/include/boost/python/object/inheritance.hpp
index 60aeda58..ceeac8f9 100644
--- a/include/boost/python/object/inheritance.hpp
+++ b/include/boost/python/object/inheritance.hpp
@@ -7,7 +7,7 @@
 # define INHERITANCE_DWA200216_HPP
 
 # include <boost/python/converter/type_id.hpp>
-# include <boost/smart_ptr.hpp>
+# include <boost/shared_ptr.hpp>
 
 namespace boost { namespace python { namespace objects {
 
diff --git a/src/types.cpp b/src/types.cpp
index e76503d2..eae9adff 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -19,7 +19,6 @@
 #include <vector>
 #include <cstddef>
 #include <stdexcept>
-#include <boost/smart_ptr.hpp>
 #include <boost/python/objects.hpp>
 #include <boost/type_traits/alignment_traits.hpp>
 #include <boost/bind.hpp>

From 8cc9080d367448edc08d6c8725282d2d5c5d0657 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 20:48:37 +0000
Subject: [PATCH 252/369] Initial pointer adoption tests Have instances
 actually dispose of their held C++ objects!

[SVN r12652]
---
 Jamfile                          | 20 +++++++++--
 src/object/class.cpp             | 19 +++++++++-
 test/test_builtin_converters.cpp |  2 --
 test/test_pointer_adoption.cpp   | 61 ++++++++++++++++++++++++++++++++
 test/test_pointer_adoption.py    | 29 +++++++++++++++
 5 files changed, 126 insertions(+), 5 deletions(-)
 create mode 100644 test/test_pointer_adoption.cpp
 create mode 100644 test/test_pointer_adoption.py

diff --git a/Jamfile b/Jamfile
index fec34d51..e897b19f 100644
--- a/Jamfile
+++ b/Jamfile
@@ -29,17 +29,20 @@ PYTHON_PROPERTIES
         <define>BOOST_PYTHON_SOURCE
         ;
 
-    extension m1 : test/m1.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
+    # -------- general test -------
+    extension m1 : test/m1.cpp <lib>bpl
       : 
       : debug-python
       ;
 
-    extension m2 : test/m2.cpp <lib>bpl       # <define>BOOST_PYTHON_TRACE
+    extension m2 : test/m2.cpp <lib>bpl
       : 
       : debug-python ;
 
     boost-python-runtest try : test/newtest.py <lib>m1 <lib>m2 : : debug-python ;
 
+    # ----------- builtin converters -----------
+    
     extension builtin_converters_ext : test/test_builtin_converters.cpp <lib>bpl
       :
       : debug-python
@@ -50,4 +53,17 @@ PYTHON_PROPERTIES
       :
       : debug-python
       ;
+    
+    # ----------- pointer adoption -----------
+    
+    extension test_pointer_adoption_ext : test/test_pointer_adoption.cpp <lib>bpl
+      :
+      : debug-python
+      ;
+
+    boost-python-runtest test_pointer_adoption : test/test_pointer_adoption.py
+      <lib>test_pointer_adoption_ext
+      :
+      : debug-python
+      ;
 }
diff --git a/src/object/class.cpp b/src/object/class.cpp
index 5d1ecf01..6a839fb2 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -81,6 +81,22 @@ BOOST_PYTHON_DECL ref class_metatype()
     return ref((PyObject*)&class_metatype_object, ref::increment_count);
 }
 
+extern "C"
+{
+    static void instance_dealloc(PyObject* inst)
+    {
+        instance* kill_me = (instance*)inst;
+
+        for (instance_holder* p = kill_me->objects, *next; p != 0; p = next)
+        {
+            next = p->next();
+            delete p;
+        }
+        
+        inst->ob_type->tp_free(inst);
+    }
+}
+
 // Do we really need this? I'm beginning to think we don't!
 PyTypeObject class_type_object = {
     PyObject_HEAD_INIT(0) //&class_metatype_object)
@@ -88,7 +104,7 @@ PyTypeObject class_type_object = {
         "Boost.Python.instance",
         sizeof(instance),
         0,
-        0,                                      /* tp_dealloc */
+        instance_dealloc,                       /* tp_dealloc */
         0,                                      /* tp_print */
         0,                                      /* tp_getattr */
         0,                                      /* tp_setattr */
@@ -206,6 +222,7 @@ namespace
       m_impl.insert(
           boost::detail::lower_bound(start, finish, id)
           , entry(id, object));
+      converter::registry::class_object(id) = (PyTypeObject*)object.get();
   }
 }
 
diff --git a/test/test_builtin_converters.cpp b/test/test_builtin_converters.cpp
index 6ffccdf9..7e21e046 100644
--- a/test/test_builtin_converters.cpp
+++ b/test/test_builtin_converters.cpp
@@ -5,8 +5,6 @@
 // to its suitability for any purpose.
 #include <string>
 #include <boost/python/module.hpp>
-#include <boost/mpl/type_list.hpp>
-#include <boost/mpl/for_each.hpp>
 
 
 template <class T>
diff --git a/test/test_pointer_adoption.cpp b/test/test_pointer_adoption.cpp
new file mode 100644
index 00000000..a49be5e8
--- /dev/null
+++ b/test/test_pointer_adoption.cpp
@@ -0,0 +1,61 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/module.hpp>
+#include <boost/python/return_value_policy.hpp>
+#include <boost/python/manage_new_object.hpp>
+#include <boost/python/class.hpp>
+#include <boost/mpl/type_list.hpp>
+
+using namespace boost::python;
+using boost::mpl::type_list;
+
+int a_instances = 0;
+
+int num_a_instances() { return a_instances; }
+
+struct A
+{
+    A(std::string const& s)
+        : s(s)
+    {
+        ++a_instances;
+    }
+    
+    ~A()
+    {
+        --a_instances;
+    }
+
+    std::string content() const
+    {
+        return s;
+    }
+    
+    std::string s;
+};
+
+A* create(std::string const& s)
+{
+    return new A(s);
+}
+
+BOOST_PYTHON_MODULE_INIT(test_pointer_adoption_ext)
+{
+    boost::python::module("test_pointer_adoption_ext")
+        .def("num_a_instances", num_a_instances)
+
+        // Specify the manage_new_object return policy to take
+        // ownership of create's result
+        .def("create", create, return_value_policy<manage_new_object>())
+        
+        .add(
+            class_<A>()
+                .def("content", &A::content)
+            )
+        
+        ;
+}
+
diff --git a/test/test_pointer_adoption.py b/test/test_pointer_adoption.py
new file mode 100644
index 00000000..264d69ce
--- /dev/null
+++ b/test/test_pointer_adoption.py
@@ -0,0 +1,29 @@
+"""
+>>> from test_pointer_adoption_ext import *
+
+>>> num_a_instances()
+0
+
+>>> a = create('dynamically allocated')
+>>> num_a_instances()
+1
+
+>>> a.content()
+'dynamically allocated'
+
+>>> a = None
+>>> num_a_instances()
+0
+"""
+def run(args = None):
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    return doctest.testmod(sys.modules.get(__name__))
+    
+if __name__ == '__main__':
+    print "running..."
+    import sys
+    sys.exit(run()[0])

From 90647f30f856040c218b3605791c2bd96636ca0c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Feb 2002 20:54:06 +0000
Subject: [PATCH 253/369] Initial pointer adoption tests Have instances
 actually dispose of their held C++ objects!

[SVN r12653]
---
 include/boost/python/class.hpp                |  7 +-
 include/boost/python/class_fwd.hpp            | 30 ++++++
 include/boost/python/detail/cv_category.hpp   | 34 +++++++
 include/boost/python/detail/type_list.hpp     | 16 ++++
 include/boost/python/detail/unwind_type.hpp   | 51 ++++++++++
 include/boost/python/manage_new_object.hpp    | 42 +++++++++
 include/boost/python/module.hpp               |  3 +-
 include/boost/python/object/class_object.hpp  | 26 ++++++
 include/boost/python/object/class_wrapper.hpp |  8 +-
 include/boost/python/to_python_owner.hpp      | 93 +++++++++++++++++++
 10 files changed, 300 insertions(+), 10 deletions(-)
 create mode 100644 include/boost/python/class_fwd.hpp
 create mode 100644 include/boost/python/detail/cv_category.hpp
 create mode 100644 include/boost/python/detail/type_list.hpp
 create mode 100644 include/boost/python/detail/unwind_type.hpp
 create mode 100644 include/boost/python/manage_new_object.hpp
 create mode 100644 include/boost/python/object/class_object.hpp
 create mode 100644 include/boost/python/to_python_owner.hpp

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 0f8d2a69..b63236c8 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -6,6 +6,7 @@
 #ifndef CLASS_DWA200216_HPP
 # define CLASS_DWA200216_HPP
 
+# include <boost/python/class_fwd.hpp>
 # include <boost/python/reference.hpp>
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
@@ -14,7 +15,7 @@
 # include <boost/python/object/class_converters.hpp>
 # include <boost/mpl/size.hpp>
 # include <boost/mpl/for_each.hpp>
-# include <boost/mpl/type_list.hpp>
+# include <boost/python/detail/type_list.hpp>
 
 namespace // put some convenience classes into the unnamed namespace for the user
 {
@@ -80,8 +81,8 @@ namespace detail
 //
 template <
     class T // class being wrapped
-    , class Bases = mpl::type_list<>::type
-    , class HolderGenerator = objects::value_holder_generator
+    , class Bases
+    , class HolderGenerator
     >
 class class_ : private objects::class_base
 {
diff --git a/include/boost/python/class_fwd.hpp b/include/boost/python/class_fwd.hpp
new file mode 100644
index 00000000..6faf7aae
--- /dev/null
+++ b/include/boost/python/class_fwd.hpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_FWD_DWA200222_HPP
+# define CLASS_FWD_DWA200222_HPP
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  struct empty_list;
+}
+
+namespace objects
+{
+  struct value_holder_generator;
+}
+
+template <
+    class T // class being wrapped
+    , class Bases = detail::empty_list
+    , class HolderGenerator = objects::value_holder_generator
+    >
+class class_;
+
+}} // namespace boost::python
+
+#endif // CLASS_FWD_DWA200222_HPP
diff --git a/include/boost/python/detail/cv_category.hpp b/include/boost/python/detail/cv_category.hpp
new file mode 100644
index 00000000..f4ac4b92
--- /dev/null
+++ b/include/boost/python/detail/cv_category.hpp
@@ -0,0 +1,34 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CV_CATEGORY_DWA200222_HPP
+# define CV_CATEGORY_DWA200222_HPP
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <bool is_const_, bool is_volatile_>
+struct cv_tag
+{
+    BOOST_STATIC_CONSTANT(bool, is_const = is_const_);
+    BOOST_STATIC_CONSTANT(bool, is_volatile = is_const_);
+};
+
+typedef cv_tag<false,false> cv_unqualified;
+typedef cv_tag<true,false> const_;
+typedef cv_tag<false,true> volatile_;
+typedef cv_tag<true,true> const_volatile_;
+
+template <class T>
+struct cv_category
+{
+    BOOST_STATIC_CONSTANT(bool, c = is_const<T>::value);
+    BOOST_STATIC_CONSTANT(bool, v = is_volatile<T>::value);
+    typedef cv_tag<c,v> type;
+};
+
+}}} // namespace boost::python::detail
+
+#endif // CV_CATEGORY_DWA200222_HPP
diff --git a/include/boost/python/detail/type_list.hpp b/include/boost/python/detail/type_list.hpp
new file mode 100644
index 00000000..66ac3857
--- /dev/null
+++ b/include/boost/python/detail/type_list.hpp
@@ -0,0 +1,16 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TYPE_LIST_DWA200222_HPP
+# define TYPE_LIST_DWA200222_HPP
+# include <boost/mpl/type_list.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+struct empty_list : boost::mpl::type_list<>::type {};
+
+}}} // namespace boost::python::detail
+
+#endif // TYPE_LIST_DWA200222_HPP
diff --git a/include/boost/python/detail/unwind_type.hpp b/include/boost/python/detail/unwind_type.hpp
new file mode 100644
index 00000000..eb103be4
--- /dev/null
+++ b/include/boost/python/detail/unwind_type.hpp
@@ -0,0 +1,51 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef UNWIND_TYPE_DWA200222_HPP
+# define UNWIND_TYPE_DWA200222_HPP
+
+# include <boost/python/detail/cv_category.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U* p, cv_unqualified, Generator* = 0)
+{
+    return Generator::execute(p);
+}
+    
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U const* p, const_, Generator* = 0)
+{
+    return unwind_type(const_cast<U*>(p), (Generator*)0);
+}
+    
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U volatile* p, volatile_, Generator* = 0)
+{
+    return unwind_type(const_cast<U*>(p), (Generator*)0);
+}
+    
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U const volatile* p, const_volatile_, Generator* = 0)
+{
+    return unwind_type(const_cast<U*>(p), (Generator*)0);
+}
+    
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type(U* p, Generator* = 0)
+{
+    typedef typename cv_category<U>::type tag;
+    return unwind_type_cv<Generator>(p, tag());
+}
+
+}}} // namespace boost::python::detail
+
+#endif // UNWIND_TYPE_DWA200222_HPP
diff --git a/include/boost/python/manage_new_object.hpp b/include/boost/python/manage_new_object.hpp
new file mode 100644
index 00000000..1c41a75d
--- /dev/null
+++ b/include/boost/python/manage_new_object.hpp
@@ -0,0 +1,42 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MANAGE_NEW_OBJECT_DWA200222_HPP
+# define MANAGE_NEW_OBJECT_DWA200222_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/python/to_python_owner.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct manage_new_object_requires_a_pointer_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct manage_new_object
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::select_type<
+            boost::is_pointer<T>::value
+            , to_python_owner<T>
+            , detail::manage_new_object_requires_a_pointer_return_type<T>
+        >::type type;
+    };
+};
+
+}} // namespace boost::python
+
+#endif // MANAGE_NEW_OBJECT_DWA200222_HPP
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index 3a243b06..1d4fdd6d 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -12,11 +12,10 @@
 # include <boost/python/make_function.hpp>
 # include <boost/python/objects.hpp>
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/class_fwd.hpp>
 
 namespace boost { namespace python {
 
-template <class T, class Bases, class HolderGenerator> class class_;
-
 class BOOST_PYTHON_DECL module_base
 {
  public:
diff --git a/include/boost/python/object/class_object.hpp b/include/boost/python/object/class_object.hpp
new file mode 100644
index 00000000..76960762
--- /dev/null
+++ b/include/boost/python/object/class_object.hpp
@@ -0,0 +1,26 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CLASS_OBJECT_DWA200222_HPP
+# define CLASS_OBJECT_DWA200222_HPP
+
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+
+namespace boost { namespace python { namespace objects { 
+
+template <class T>
+struct class_object
+{
+    static PyTypeObject*& reference;
+};
+
+template <class T>
+PyTypeObject*& class_object<T>::reference = converter::registry::class_object(
+    converter::undecorated_type_id<T>());
+
+}}} // namespace boost::python::objects
+
+#endif // CLASS_OBJECT_DWA200222_HPP
diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
index 4a52f290..f8702205 100644
--- a/include/boost/python/object/class_wrapper.hpp
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -25,9 +25,9 @@ struct class_wrapper
     
     static PyObject* convert(T const& x)
     {
-        // Don't call the type to do the construction, since that
-        // would require the registration of an __init__ copy
-        // constructor. Instead, just construct the object in place.
+        // Don't call the type directly to do the construction, since
+        // that would require the registration of an appropriate
+        // __init__ function.
         PyObject* raw_result = m_class_object->tp_alloc(m_class_object, 0);
 
         if (raw_result == 0)
@@ -37,8 +37,6 @@ struct class_wrapper
         // exceptions.
         ref result(raw_result, ref::allow_null());
 
-        ((instance*)raw_result)->objects = 0;
-        
         // Build a value_holder to contain the object using the copy
         // constructor
         value_holder<T>* p = new value_holder<T>(raw_result, cref(x));
diff --git a/include/boost/python/to_python_owner.hpp b/include/boost/python/to_python_owner.hpp
new file mode 100644
index 00000000..7d3ee5ae
--- /dev/null
+++ b/include/boost/python/to_python_owner.hpp
@@ -0,0 +1,93 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_OWNER_DWA200221_HPP
+# define TO_PYTHON_OWNER_DWA200221_HPP
+
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+# include <boost/python/object/class_object.hpp>
+# include <boost/python/detail/unwind_type.hpp>
+# include <memory>
+
+namespace boost { namespace python {
+
+template <class T>
+struct to_python_owner
+{
+    static bool convertible();
+    PyObject* operator()(T ptr) const;
+ private:
+    static PyTypeObject* type();
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  struct make_owning_holder
+  {
+      typedef objects::instance_holder* result_type;
+      template <class T>
+      static result_type execute(T* p)
+      {
+          return new objects::pointer_holder<std::auto_ptr<T>, T>(
+              std::auto_ptr<T>(p));
+      }
+  };
+
+  struct get_pointer_class
+  {
+      typedef PyTypeObject* result_type;
+      template <class T>
+      static result_type execute(T* p)
+      {
+          BOOST_STATIC_ASSERT(is_class<T>::value);
+          return python::objects::class_object<T>::reference;
+      }
+  };
+}
+
+template <class T>
+inline bool to_python_owner<T>::convertible()
+{
+    BOOST_STATIC_ASSERT(is_pointer<T>::value);
+    return type() != 0;
+}
+
+template <class T>
+inline PyObject* to_python_owner<T>::operator()(T x) const
+{
+    PyObject* raw_result = type()->tp_alloc(type(), 0);
+
+    if (raw_result == 0)
+        return 0;
+
+    // Everything's OK; Bypass NULL checks but guard against
+    // exceptions.
+    ref result(raw_result, ref::allow_null());
+
+    // Build a value_holder to contain the object using the copy
+    // constructor
+    objects::instance_holder* p =
+        detail::unwind_type<detail::make_owning_holder>(x);
+
+    // Install it in the instance
+    p->install(raw_result);
+
+    // Return the new result
+    return result.release();
+}
+
+template <class T>
+inline PyTypeObject* to_python_owner<T>::type()
+{
+    return detail::unwind_type<detail::get_pointer_class>(T(0));
+}
+
+}} // namespace boost::python
+
+#endif // TO_PYTHON_OWNER_DWA200221_HPP

From 55a431883925c4acbd22fab58d880c59f68e2e21 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 01:07:10 +0000
Subject: [PATCH 254/369] Handle references too

[SVN r12655]
---
 include/boost/python/detail/unwind_type.hpp | 70 ++++++++++++++++++++-
 1 file changed, 69 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/unwind_type.hpp b/include/boost/python/detail/unwind_type.hpp
index eb103be4..e3caa5fa 100644
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
@@ -40,12 +40,80 @@ unwind_type_cv(U const volatile* p, const_volatile_, Generator* = 0)
     
 template <class Generator, class U>
 inline typename Generator::result_type
-unwind_type(U* p, Generator* = 0)
+unwind_ptr_type(U* p, Generator* = 0)
 {
     typedef typename cv_category<U>::type tag;
     return unwind_type_cv<Generator>(p, tag());
 }
 
+template <bool is_ptr>
+struct unwind_helper
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U p, Generator* = 0)
+    {
+        return unwind_ptr_type(p, (Generator*)0);
+    }
+
+    template <class Generator, class U>
+    struct apply
+    {
+        static typename Generator::result_type
+        execute()
+        {
+            return unwind_ptr_type(U(0),(Generator*)0);
+        }
+    };
+};
+
+template <>
+struct unwind_helper<false>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U& p, Generator* = 0)
+    {
+        return unwind_ptr_type(&p, (Generator*)0);
+    }
+
+    template <class Generator, class U>
+    struct apply
+    {
+        static typename Generator::result_type
+        execute()
+        {
+            return unwind_ptr_type((U*)0,(Generator*)0);
+        }
+    };
+};
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type(U& p, Generator* = 0)
+{
+    return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
+}
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type(U const& p, Generator* = 0)
+{
+    return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
+}
+
+// Call this one with both template parameters explicitly specified
+// and no function arguments:
+//
+//      return unwind_type<my_generator,T>();
+//
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type(type<U>*p = 0, Generator* = 0)
+{
+    return unwind_helper<is_pointer<U>::value>::template apply<Generator,U>::execute();
+}
+
 }}} // namespace boost::python::detail
 
 #endif // UNWIND_TYPE_DWA200222_HPP

From 021070f0666d9d38335a0f2a716b0f4d4b2d52c7 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 01:07:29 +0000
Subject: [PATCH 255/369] Prepare to generalize

[SVN r12656]
---
 include/boost/python/to_python_owner.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/to_python_owner.hpp b/include/boost/python/to_python_owner.hpp
index 7d3ee5ae..bf92663b 100644
--- a/include/boost/python/to_python_owner.hpp
+++ b/include/boost/python/to_python_owner.hpp
@@ -85,7 +85,7 @@ inline PyObject* to_python_owner<T>::operator()(T x) const
 template <class T>
 inline PyTypeObject* to_python_owner<T>::type()
 {
-    return detail::unwind_type<detail::get_pointer_class>(T(0));
+    return detail::unwind_type<detail::get_pointer_class,T>();
 }
 
 }} // namespace boost::python

From 7590d546f1d5d34f51d2479f80a486853c09c4c0 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 03:05:01 +0000
Subject: [PATCH 256/369] initial checkin

[SVN r12657]
---
 .../python/reference_existing_object.hpp      |  45 ++++++++
 include/boost/python/to_python_indirect.hpp   | 102 ++++++++++++++++++
 2 files changed, 147 insertions(+)
 create mode 100644 include/boost/python/reference_existing_object.hpp
 create mode 100644 include/boost/python/to_python_indirect.hpp

diff --git a/include/boost/python/reference_existing_object.hpp b/include/boost/python/reference_existing_object.hpp
new file mode 100644
index 00000000..1f8a43d8
--- /dev/null
+++ b/include/boost/python/reference_existing_object.hpp
@@ -0,0 +1,45 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef REFERENCE_EXISTING_OBJECT_DWA200222_HPP
+# define REFERENCE_EXISTING_OBJECT_DWA200222_HPP
+# include <boost/python/detail/indirect_traits.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+
+namespace boost { namespace python { 
+
+namespace detail
+{
+  template <class R>
+  struct reference_existing_object_requires_a_pointer_or_reference_return_type
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct reference_existing_object
+{
+    template <class T>
+    struct apply
+    {
+        BOOST_STATIC_CONSTANT(
+            bool, ok = is_pointer<T>::value || is_reference<T>::value);
+        
+        typedef typename mpl::select_type<
+            ok
+            , to_python_indirect<T, detail::make_reference_holder>
+            , detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
+        >::type type;
+    };
+};
+
+}} // namespace boost::python
+
+#endif // REFERENCE_EXISTING_OBJECT_DWA200222_HPP
diff --git a/include/boost/python/to_python_indirect.hpp b/include/boost/python/to_python_indirect.hpp
new file mode 100644
index 00000000..e68eced0
--- /dev/null
+++ b/include/boost/python/to_python_indirect.hpp
@@ -0,0 +1,102 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_INDIRECT_DWA200221_HPP
+# define TO_PYTHON_INDIRECT_DWA200221_HPP
+
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+# include <boost/python/object/class_object.hpp>
+# include <boost/python/detail/unwind_type.hpp>
+# include <memory>
+
+namespace boost { namespace python {
+
+template <class T, class HolderGenerator>
+struct to_python_indirect
+{
+    static bool convertible();
+    PyObject* operator()(T ptr) const;
+ private:
+    static PyTypeObject* type();
+};
+
+//
+// implementations
+//
+namespace detail
+{
+  struct make_owning_holder
+  {
+      typedef objects::instance_holder* result_type;
+      template <class T>
+      static result_type execute(T* p)
+      {
+          return new objects::pointer_holder<std::auto_ptr<T>, T>(
+              std::auto_ptr<T>(p));
+      }
+  };
+
+  struct make_reference_holder
+  {
+      typedef objects::instance_holder* result_type;
+      template <class T>
+      static result_type execute(T* p)
+      {
+          return new objects::pointer_holder<T*, T>(p);
+      }
+  };
+
+  struct get_pointer_class
+  {
+      typedef PyTypeObject* result_type;
+      template <class T>
+      static result_type execute(T* p)
+      {
+          BOOST_STATIC_ASSERT(is_class<T>::value);
+          return python::objects::class_object<T>::reference;
+      }
+  };
+}
+
+template <class T, class HolderGenerator>
+inline bool to_python_indirect<T,HolderGenerator>::convertible()
+{
+    return type() != 0;
+}
+
+template <class T, class HolderGenerator>
+inline PyObject* to_python_indirect<T,HolderGenerator>::operator()(T x) const
+{
+    PyObject* raw_result = type()->tp_alloc(type(), 0);
+
+    if (raw_result == 0)
+        return 0;
+
+    // Everything's OK; Bypass NULL checks but guard against
+    // exceptions.
+    ref result(raw_result, ref::allow_null());
+
+    // Build a value_holder to contain the object using the copy
+    // constructor
+    objects::instance_holder* p =
+        detail::unwind_type<HolderGenerator>(x);
+
+    // Install it in the instance
+    p->install(raw_result);
+
+    // Return the new result
+    return result.release();
+}
+
+template <class T, class HolderGenerator>
+inline PyTypeObject* to_python_indirect<T,HolderGenerator>::type()
+{
+    return detail::unwind_type<detail::get_pointer_class,T>();
+}
+
+}} // namespace boost::python
+
+#endif // TO_PYTHON_INDIRECT_DWA200221_HPP

From 64239f1c04be4c18aa608e019c6a3b9ec5f0b1b1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 03:05:39 +0000
Subject: [PATCH 257/369] Allow indirect reference/pointer returns

[SVN r12659]
---
 include/boost/python/class.hpp                |  7 ++
 .../boost/python/detail/indirect_traits.hpp   | 68 +++++++++++++-
 include/boost/python/detail/unwind_type.hpp   | 76 ++++++++++-----
 include/boost/python/manage_new_object.hpp    |  4 +-
 include/boost/python/to_python_owner.hpp      | 93 -------------------
 test/test_pointer_adoption.cpp                | 37 +++++++-
 test/test_pointer_adoption.py                 |  6 ++
 7 files changed, 165 insertions(+), 126 deletions(-)
 delete mode 100644 include/boost/python/to_python_owner.hpp

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index b63236c8..4f30dc8d 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -112,6 +112,13 @@ class class_ : private objects::class_base
         return *this;
     }
 
+    template <class Fn, class CallPolicy>
+    self& def(char const* name, Fn fn, CallPolicy policy)
+    {
+        this->def(name, boost::python::make_function(fn, policy));
+        return *this;
+    }
+    
     // Define the constructor with the given Args, which should be an
     // MPL sequence of types.
     template <class Args>
diff --git a/include/boost/python/detail/indirect_traits.hpp b/include/boost/python/detail/indirect_traits.hpp
index c76ffbc0..41681719 100644
--- a/include/boost/python/detail/indirect_traits.hpp
+++ b/include/boost/python/detail/indirect_traits.hpp
@@ -47,6 +47,36 @@ struct is_reference_to_volatile<T volatile&>
 {
     BOOST_STATIC_CONSTANT(bool, value = true);
 };
+
+template <class T>
+struct is_reference_to_pointer
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+template <class T>
+struct is_reference_to_pointer<T*&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_pointer<T* volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const volatile&>
+{
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
 #  else
 
 typedef char (&inner_yes_type)[3];
@@ -74,8 +104,17 @@ struct is_volatile_help
 };
 
 template <typename V>
-typename is_const_help<V>::type reference_to_const_helper(V&);
-    
+struct is_pointer_help
+{
+    typedef typename mpl::select_type<
+        is_pointer<V>::value
+        , inner_yes_type
+        , inner_no_type
+        >::type type;
+};
+
+template <typename V>
+typename is_const_help<V>::type reference_to_const_helper(V&);    
 outer_no_type
 reference_to_const_helper(...);
 
@@ -85,7 +124,8 @@ struct is_reference_to_const
     static T t;
     BOOST_STATIC_CONSTANT(
         bool, value
-        = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type));
+        = (is_reference<T>::value
+           && sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type)));
 };
 
 template <class T>
@@ -94,7 +134,8 @@ struct is_reference_to_non_const
     static T t;
     BOOST_STATIC_CONSTANT(
         bool, value
-        = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type));
+        = (is_reference<T>::value
+           && sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type)));
 };
 
 template <typename V>
@@ -107,7 +148,24 @@ struct is_reference_to_volatile
     static T t;
     BOOST_STATIC_CONSTANT(
         bool, value
-        = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type));
+        = (is_reference<T>::value
+           && sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type)));
+};
+
+
+template <typename V>
+typename is_pointer_help<V>::type reference_to_pointer_helper(V&);
+outer_no_type reference_to_pointer_helper(...);
+
+template <class T>
+struct is_reference_to_pointer
+{
+    static T t;
+    BOOST_STATIC_CONSTANT(
+        bool, value
+        = (is_reference<T>::value
+           && sizeof(reference_to_pointer_helper(t)) == sizeof(inner_yes_type))
+        );
 };
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 
 
diff --git a/include/boost/python/detail/unwind_type.hpp b/include/boost/python/detail/unwind_type.hpp
index e3caa5fa..add3615a 100644
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
@@ -55,16 +55,6 @@ struct unwind_helper
     {
         return unwind_ptr_type(p, (Generator*)0);
     }
-
-    template <class Generator, class U>
-    struct apply
-    {
-        static typename Generator::result_type
-        execute()
-        {
-            return unwind_ptr_type(U(0),(Generator*)0);
-        }
-    };
 };
 
 template <>
@@ -76,16 +66,6 @@ struct unwind_helper<false>
     {
         return unwind_ptr_type(&p, (Generator*)0);
     }
-
-    template <class Generator, class U>
-    struct apply
-    {
-        static typename Generator::result_type
-        execute()
-        {
-            return unwind_ptr_type((U*)0,(Generator*)0);
-        }
-    };
 };
 
 template <class Generator, class U>
@@ -102,16 +82,70 @@ unwind_type(U const& p, Generator* = 0)
     return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
 }
 
+enum { direct_ = 0, pointer_ = 1, reference_ = 2, reference_to_pointer_ = 3 };
+template <int indirection> struct unwind_helper2;
+
+template <>
+struct unwind_helper2<direct_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type((U*)0, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper2<pointer_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U*(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type((U*)0, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper2<reference_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U&(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type((U*)0, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper2<reference_to_pointer_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U&(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type(U(0), (Generator*)0);
+    }
+};
+
 // Call this one with both template parameters explicitly specified
 // and no function arguments:
 //
 //      return unwind_type<my_generator,T>();
 //
+// Doesn't work if T is an array type; we could handle that case, but
+// why bother?
 template <class Generator, class U>
 inline typename Generator::result_type
 unwind_type(type<U>*p = 0, Generator* = 0)
 {
-    return unwind_helper<is_pointer<U>::value>::template apply<Generator,U>::execute();
+    BOOST_STATIC_CONSTANT(int, indirection
+                          = (pointer_ * is_pointer<U>::value)
+                          | (reference_ * is_reference<U>::value)
+                          | (reference_to_pointer_ * is_reference_to_pointer<U>::value));
+        
+    return unwind_helper2<indirection>::execute((U(*)())0,(Generator*)0);
 }
 
 }}} // namespace boost::python::detail
diff --git a/include/boost/python/manage_new_object.hpp b/include/boost/python/manage_new_object.hpp
index 1c41a75d..9c0912ab 100644
--- a/include/boost/python/manage_new_object.hpp
+++ b/include/boost/python/manage_new_object.hpp
@@ -7,7 +7,7 @@
 # define MANAGE_NEW_OBJECT_DWA200222_HPP
 # include <boost/python/detail/indirect_traits.hpp>
 # include <boost/mpl/select_type.hpp>
-# include <boost/python/to_python_owner.hpp>
+# include <boost/python/to_python_indirect.hpp>
 # include <boost/type_traits/composite_traits.hpp>
 
 namespace boost { namespace python { 
@@ -31,7 +31,7 @@ struct manage_new_object
     {
         typedef typename mpl::select_type<
             boost::is_pointer<T>::value
-            , to_python_owner<T>
+            , to_python_indirect<T, detail::make_owning_holder>
             , detail::manage_new_object_requires_a_pointer_return_type<T>
         >::type type;
     };
diff --git a/include/boost/python/to_python_owner.hpp b/include/boost/python/to_python_owner.hpp
deleted file mode 100644
index bf92663b..00000000
--- a/include/boost/python/to_python_owner.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef TO_PYTHON_OWNER_DWA200221_HPP
-# define TO_PYTHON_OWNER_DWA200221_HPP
-
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/python/object/pointer_holder.hpp>
-# include <boost/python/object/class_object.hpp>
-# include <boost/python/detail/unwind_type.hpp>
-# include <memory>
-
-namespace boost { namespace python {
-
-template <class T>
-struct to_python_owner
-{
-    static bool convertible();
-    PyObject* operator()(T ptr) const;
- private:
-    static PyTypeObject* type();
-};
-
-//
-// implementations
-//
-namespace detail
-{
-  struct make_owning_holder
-  {
-      typedef objects::instance_holder* result_type;
-      template <class T>
-      static result_type execute(T* p)
-      {
-          return new objects::pointer_holder<std::auto_ptr<T>, T>(
-              std::auto_ptr<T>(p));
-      }
-  };
-
-  struct get_pointer_class
-  {
-      typedef PyTypeObject* result_type;
-      template <class T>
-      static result_type execute(T* p)
-      {
-          BOOST_STATIC_ASSERT(is_class<T>::value);
-          return python::objects::class_object<T>::reference;
-      }
-  };
-}
-
-template <class T>
-inline bool to_python_owner<T>::convertible()
-{
-    BOOST_STATIC_ASSERT(is_pointer<T>::value);
-    return type() != 0;
-}
-
-template <class T>
-inline PyObject* to_python_owner<T>::operator()(T x) const
-{
-    PyObject* raw_result = type()->tp_alloc(type(), 0);
-
-    if (raw_result == 0)
-        return 0;
-
-    // Everything's OK; Bypass NULL checks but guard against
-    // exceptions.
-    ref result(raw_result, ref::allow_null());
-
-    // Build a value_holder to contain the object using the copy
-    // constructor
-    objects::instance_holder* p =
-        detail::unwind_type<detail::make_owning_holder>(x);
-
-    // Install it in the instance
-    p->install(raw_result);
-
-    // Return the new result
-    return result.release();
-}
-
-template <class T>
-inline PyTypeObject* to_python_owner<T>::type()
-{
-    return detail::unwind_type<detail::get_pointer_class,T>();
-}
-
-}} // namespace boost::python
-
-#endif // TO_PYTHON_OWNER_DWA200221_HPP
diff --git a/test/test_pointer_adoption.cpp b/test/test_pointer_adoption.cpp
index a49be5e8..be10aebd 100644
--- a/test/test_pointer_adoption.cpp
+++ b/test/test_pointer_adoption.cpp
@@ -6,6 +6,7 @@
 #include <boost/python/module.hpp>
 #include <boost/python/return_value_policy.hpp>
 #include <boost/python/manage_new_object.hpp>
+#include <boost/python/reference_existing_object.hpp>
 #include <boost/python/class.hpp>
 #include <boost/mpl/type_list.hpp>
 
@@ -16,10 +17,24 @@ int a_instances = 0;
 
 int num_a_instances() { return a_instances; }
 
+struct inner
+{
+    inner(std::string const& s)
+        : s(s)
+    {}
+
+    void change(std::string const& new_s)
+    {
+        this->s = new_s;
+    }
+    
+    std::string s;
+};
+
 struct A
 {
     A(std::string const& s)
-        : s(s)
+        : x(s)
     {
         ++a_instances;
     }
@@ -31,10 +46,15 @@ struct A
 
     std::string content() const
     {
-        return s;
+        return x.s;
     }
-    
-    std::string s;
+
+    inner& get_inner()
+    {
+        return x;
+    }
+
+    inner x;
 };
 
 A* create(std::string const& s)
@@ -52,8 +72,15 @@ BOOST_PYTHON_MODULE_INIT(test_pointer_adoption_ext)
         .def("create", create, return_value_policy<manage_new_object>())
         
         .add(
+            
             class_<A>()
-                .def("content", &A::content)
+            .def("content", &A::content)
+            .def("get_inner", &A::get_inner, return_value_policy<reference_existing_object>())
+            )
+
+        .add(
+            class_<inner>()
+            .def("change", &inner::change)
             )
         
         ;
diff --git a/test/test_pointer_adoption.py b/test/test_pointer_adoption.py
index 264d69ce..197a6df9 100644
--- a/test/test_pointer_adoption.py
+++ b/test/test_pointer_adoption.py
@@ -11,6 +11,12 @@
 >>> a.content()
 'dynamically allocated'
 
+>>> innards = a.get_inner()
+>>> innards.change('with an exposed reference')
+>>> a.content()
+'with an exposed reference'
+
+>>> innards = None
 >>> a = None
 >>> num_a_instances()
 0

From 0a9d5f680fab9094049392618b10c1ec7734d959 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 05:02:46 +0000
Subject: [PATCH 258/369] initial checkin

[SVN r12661]
---
 include/boost/python/object/life_support.hpp | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 include/boost/python/object/life_support.hpp

diff --git a/include/boost/python/object/life_support.hpp b/include/boost/python/object/life_support.hpp
new file mode 100644
index 00000000..c5276c06
--- /dev/null
+++ b/include/boost/python/object/life_support.hpp
@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef LIFE_SUPPORT_DWA200222_HPP
+# define LIFE_SUPPORT_DWA200222_HPP
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace objects { 
+
+BOOST_PYTHON_DECL int make_nurse_and_patient(PyObject* nurse, PyObject* patient);
+
+}}} // namespace boost::python::object
+
+#endif // LIFE_SUPPORT_DWA200222_HPP

From 262396d48b4183e3490d9478da758c045ebcf92b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 05:03:05 +0000
Subject: [PATCH 259/369] Object life support

[SVN r12662]
---
 Jamfile                                       |  1 +
 .../python/return_internal_reference.hpp      | 32 +++++-
 src/object/life_support.cpp                   | 99 +++++++++++++++++++
 test/test_pointer_adoption.cpp                |  4 +-
 test/test_pointer_adoption.py                 |  8 +-
 5 files changed, 137 insertions(+), 7 deletions(-)
 create mode 100644 src/object/life_support.cpp

diff --git a/Jamfile b/Jamfile
index e897b19f..ac32456b 100644
--- a/Jamfile
+++ b/Jamfile
@@ -20,6 +20,7 @@ PYTHON_PROPERTIES
       src/object/class.cpp
       src/object/function.cpp
       src/object/inheritance.cpp
+      src/object/life_support.cpp
       src/errors.cpp
       src/module.cpp
       src/objects.cpp
diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
index ac7f3fbf..a1888229 100644
--- a/include/boost/python/return_internal_reference.hpp
+++ b/include/boost/python/return_internal_reference.hpp
@@ -7,7 +7,10 @@
 # define RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
 
 # include <boost/python/default_call_policies.hpp>
+# include <boost/python/object/life_support.hpp>
 # include <boost/type_traits/object_traits.hpp>
+# include <boost/python/reference_existing_object.hpp>
+# include <boost/python/to_python_indirect.hpp>
 
 namespace boost { namespace python { 
 
@@ -28,18 +31,39 @@ struct internal_reference_to_python_generator
     {
         typedef typename mpl::select_type<
             !is_object<T>::value
-            , internal_reference_to_python<T>
-            , detail::return_internal_reference_requires_a_pointer_or_reference_return_type
+            , to_python_indirect<T, detail::make_reference_holder>
+            , detail::return_internal_reference_requires_a_pointer_or_reference_return_type<T>
         >::type type;
     };
 };
 
-template <std::size_t owner_arg, class Base = default_call_policies>
+template <std::size_t owner_arg = 1, class Base = default_call_policies>
 struct return_internal_reference : Base
 {
-    typedef wrap_internal_reference<owner_arg> result_converter;
+    typedef reference_existing_object result_converter;
+    static PyObject* postcall(PyObject* args, PyObject* result);
 };
 
+template <std::size_t owner_arg, class Base>
+PyObject* return_internal_reference<owner_arg,Base>::postcall(PyObject* args_, PyObject* result)
+{
+    PyObject* patient = PyTuple_GetItem(args_, owner_arg - 1);
+    if (patient != 0) // Make sure the argument was in range.
+    {
+        result = Base::postcall(args_,result);
+        if (result != 0)
+        {
+            if (python::objects::make_nurse_and_patient(result, patient) == 0)
+            {
+                return result;
+            }
+        }
+        
+    }
+    Py_XDECREF(result);
+    return 0;
+}
+
 }} // namespace boost::python
 
 #endif // RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
diff --git a/src/object/life_support.cpp b/src/object/life_support.cpp
new file mode 100644
index 00000000..f587eb42
--- /dev/null
+++ b/src/object/life_support.cpp
@@ -0,0 +1,99 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/object/life_support.hpp>
+#include <boost/python/detail/none.hpp>
+
+namespace boost { namespace python { namespace objects { 
+
+struct life_support
+{
+    PyObject_HEAD
+    PyObject* patient;
+};
+
+extern "C"
+{
+    static void
+    life_support_dealloc(PyObject* self)
+    {
+        self->ob_type->tp_free(self);
+    }
+
+    static PyObject *
+    life_support_call(PyObject *self, PyObject *arg, PyObject *kw)
+    {
+        // Let the patient die now
+        Py_XDECREF(((life_support*)self)->patient);
+        // Also let the weak reference die. This probably kills us.
+        Py_XDECREF(PyTuple_GET_ITEM(arg, 0));
+        return detail::none();
+    }
+}
+
+PyTypeObject life_support_type = {
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,
+    "Boost.Python.life_support",
+    sizeof(life_support),
+    0,
+    life_support_dealloc,               /* tp_dealloc */
+    0,                                  /* tp_print */
+    0,                                  /* tp_getattr */
+    0,                                  /* tp_setattr */
+    0,                                  /* tp_compare */
+    0, //(reprfunc)func_repr,                   /* tp_repr */
+    0,                                  /* tp_as_number */
+    0,                                  /* tp_as_sequence */
+    0,                                  /* tp_as_mapping */
+    0,                                  /* tp_hash */
+    life_support_call,                  /* tp_call */
+    0,                                  /* tp_str */
+    0, // PyObject_GenericGetAttr,            /* tp_getattro */
+    0, // PyObject_GenericSetAttr,            /* tp_setattro */
+    0,                                  /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT /* | Py_TPFLAGS_HAVE_GC */,/* tp_flags */
+    0,                                  /* tp_doc */
+    0, // (traverseproc)func_traverse,          /* tp_traverse */
+    0,                                  /* tp_clear */
+    0,                                  /* tp_richcompare */
+    0, //offsetof(PyLife_SupportObject, func_weakreflist), /* tp_weaklistoffset */
+    0,                                  /* tp_iter */
+    0,                                  /* tp_iternext */
+    0,                                  /* tp_methods */
+    0, // func_memberlist,                      /* tp_members */
+    0, //func_getsetlist,                       /* tp_getset */
+    0,                                  /* tp_base */
+    0,                                  /* tp_dict */
+    0,                                  /* tp_descr_get */
+    0,                                  /* tp_descr_set */
+    0, //offsetof(PyLife_SupportObject, func_dict),      /* tp_dictoffset */
+    0,                                      /* tp_init */
+    0,                                      /* tp_alloc */
+    0,
+    0                                       /* tp_new */
+};
+
+int make_nurse_and_patient(PyObject* nurse, PyObject* patient)
+{
+    life_support* system = PyObject_New(life_support, &life_support_type);
+    if (!system)
+        return -1;
+    
+    // We're going to leak this reference, but don't worry; the
+    // life_support system decrements it when the nurse dies.
+    PyObject* weakref = PyWeakref_NewRef(nurse, (PyObject*)system);
+    if (!weakref)
+    {
+        Py_XDECREF(system);
+        return -1;
+    }
+    
+    system->patient = patient;
+    Py_XINCREF(patient); // hang on to the patient until death
+    return 0;
+}
+
+}}} // namespace boost::python::objects
diff --git a/test/test_pointer_adoption.cpp b/test/test_pointer_adoption.cpp
index be10aebd..61cd49bd 100644
--- a/test/test_pointer_adoption.cpp
+++ b/test/test_pointer_adoption.cpp
@@ -6,7 +6,7 @@
 #include <boost/python/module.hpp>
 #include <boost/python/return_value_policy.hpp>
 #include <boost/python/manage_new_object.hpp>
-#include <boost/python/reference_existing_object.hpp>
+#include <boost/python/return_internal_reference.hpp>
 #include <boost/python/class.hpp>
 #include <boost/mpl/type_list.hpp>
 
@@ -75,7 +75,7 @@ BOOST_PYTHON_MODULE_INIT(test_pointer_adoption_ext)
             
             class_<A>()
             .def("content", &A::content)
-            .def("get_inner", &A::get_inner, return_value_policy<reference_existing_object>())
+            .def("get_inner", &A::get_inner, return_internal_reference<>())
             )
 
         .add(
diff --git a/test/test_pointer_adoption.py b/test/test_pointer_adoption.py
index 197a6df9..28e160dc 100644
--- a/test/test_pointer_adoption.py
+++ b/test/test_pointer_adoption.py
@@ -16,10 +16,16 @@
 >>> a.content()
 'with an exposed reference'
 
->>> innards = None
+# The a instance should be kept alive...
 >>> a = None
 >>> num_a_instances()
+1
+
+# ...until we're done with its innards
+>>> innards = None
+>>> num_a_instances()
 0
+
 """
 def run(args = None):
     import sys

From bcf4401858ce9b6db3deebb65915ad73eb96b300 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 05:09:31 +0000
Subject: [PATCH 260/369] KCC ice workaround

[SVN r12663]
---
 include/boost/python/return_internal_reference.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
index a1888229..8f60c476 100644
--- a/include/boost/python/return_internal_reference.hpp
+++ b/include/boost/python/return_internal_reference.hpp
@@ -30,9 +30,9 @@ struct internal_reference_to_python_generator
     struct apply
     {
         typedef typename mpl::select_type<
-            !is_object<T>::value
-            , to_python_indirect<T, detail::make_reference_holder>
+            is_object<T>::value
             , detail::return_internal_reference_requires_a_pointer_or_reference_return_type<T>
+            , to_python_indirect<T, detail::make_reference_holder>
         >::type type;
     };
 };

From 21d65ca0bf0f099e68a7d3c5e5a927b81f9a6083 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 06:34:15 +0000
Subject: [PATCH 261/369] arbitrary argument/result adoption

[SVN r12664]
---
 include/boost/python/object/life_support.hpp  |  2 +-
 include/boost/python/object/make_holder.hpp   | 78 ++++++++++++++++++
 .../python/return_internal_reference.hpp      | 26 +-----
 .../boost/python/with_custodian_and_ward.hpp  | 80 +++++++++++++++++++
 src/object/life_support.cpp                   | 12 +--
 test/test_pointer_adoption.cpp                | 28 +++++++
 test/test_pointer_adoption.py                 | 22 +++++
 7 files changed, 219 insertions(+), 29 deletions(-)
 create mode 100644 include/boost/python/with_custodian_and_ward.hpp

diff --git a/include/boost/python/object/life_support.hpp b/include/boost/python/object/life_support.hpp
index c5276c06..5d9587db 100644
--- a/include/boost/python/object/life_support.hpp
+++ b/include/boost/python/object/life_support.hpp
@@ -10,7 +10,7 @@
 
 namespace boost { namespace python { namespace objects { 
 
-BOOST_PYTHON_DECL int make_nurse_and_patient(PyObject* nurse, PyObject* patient);
+BOOST_PYTHON_DECL PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient);
 
 }}} // namespace boost::python::object
 
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 8a72a880..825e02b0 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -93,6 +93,84 @@ struct make_holder<3>
     };
 };
 
+template <>
+struct make_holder<4>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename forward<t0>::type f0;
+        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename forward<t1>::type f1;
+        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename forward<t2>::type f2;
+        typedef typename mpl::at<3,ArgList>::type t3;
+        typedef typename forward<t3>::type f3;
+        
+        static void execute(
+            PyObject* p, t0 a0, t1 a1, t2 a2, t3 a3)
+        {
+            (new holder(p, f0(a0), f1(a1), f2(a2), f3(a3)))->install(p);
+        }
+    };
+};
+
+template <>
+struct make_holder<5>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename forward<t0>::type f0;
+        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename forward<t1>::type f1;
+        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename forward<t2>::type f2;
+        typedef typename mpl::at<3,ArgList>::type t3;
+        typedef typename forward<t3>::type f3;
+        typedef typename mpl::at<4,ArgList>::type t4;
+        typedef typename forward<t4>::type f4;
+        
+        static void execute(
+            PyObject* p, t0 a0, t1 a1, t2 a2, t3 a3, t4 a4)
+        {
+            (new holder(p, f0(a0), f1(a1), f2(a2), f3(a3), f4(a4)))->install(p);
+        }
+    };
+};
+
+template <>
+struct make_holder<6>
+{
+    template <class T, class Generator, class ArgList>
+    struct apply
+    {
+        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename forward<t0>::type f0;
+        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename forward<t1>::type f1;
+        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename forward<t2>::type f2;
+        typedef typename mpl::at<3,ArgList>::type t3;
+        typedef typename forward<t3>::type f3;
+        typedef typename mpl::at<4,ArgList>::type t4;
+        typedef typename forward<t4>::type f4;
+        typedef typename mpl::at<5,ArgList>::type t5;
+        typedef typename forward<t5>::type f5;
+        
+        static void execute(
+            PyObject* p, t0 a0, t1 a1, t2 a2, t3 a3, t4 a4, t5 a5)
+        {
+            (new holder(p, f0(a0), f1(a1), f2(a2), f3(a3), f4(a4), f5(a5)))->install(p);
+        }
+    };
+};
+
 }}} // namespace boost::python::objects
 
 #endif // MAKE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
index 8f60c476..2066b7a9 100644
--- a/include/boost/python/return_internal_reference.hpp
+++ b/include/boost/python/return_internal_reference.hpp
@@ -7,10 +7,10 @@
 # define RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
 
 # include <boost/python/default_call_policies.hpp>
-# include <boost/python/object/life_support.hpp>
 # include <boost/type_traits/object_traits.hpp>
 # include <boost/python/reference_existing_object.hpp>
 # include <boost/python/to_python_indirect.hpp>
+# include <boost/python/with_custodian_and_ward.hpp>
 
 namespace boost { namespace python { 
 
@@ -38,32 +38,12 @@ struct internal_reference_to_python_generator
 };
 
 template <std::size_t owner_arg = 1, class Base = default_call_policies>
-struct return_internal_reference : Base
+struct return_internal_reference
+    : with_custodian_and_ward_postcall<0, owner_arg, Base>
 {
     typedef reference_existing_object result_converter;
-    static PyObject* postcall(PyObject* args, PyObject* result);
 };
 
-template <std::size_t owner_arg, class Base>
-PyObject* return_internal_reference<owner_arg,Base>::postcall(PyObject* args_, PyObject* result)
-{
-    PyObject* patient = PyTuple_GetItem(args_, owner_arg - 1);
-    if (patient != 0) // Make sure the argument was in range.
-    {
-        result = Base::postcall(args_,result);
-        if (result != 0)
-        {
-            if (python::objects::make_nurse_and_patient(result, patient) == 0)
-            {
-                return result;
-            }
-        }
-        
-    }
-    Py_XDECREF(result);
-    return 0;
-}
-
 }} // namespace boost::python
 
 #endif // RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
diff --git a/include/boost/python/with_custodian_and_ward.hpp b/include/boost/python/with_custodian_and_ward.hpp
new file mode 100644
index 00000000..4ae975af
--- /dev/null
+++ b/include/boost/python/with_custodian_and_ward.hpp
@@ -0,0 +1,80 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef WITH_CUSTODIAN_AND_WARD_DWA2002131_HPP
+# define WITH_CUSTODIAN_AND_WARD_DWA2002131_HPP
+
+# include <boost/python/default_call_policies.hpp>
+# include <boost/python/object/life_support.hpp>
+
+namespace boost { namespace python { 
+
+enum custodial_timing { pre_call, post_call };
+                        
+template <std::size_t custodian, std::size_t ward, class Base = default_call_policies>
+struct with_custodian_and_ward : Base
+{
+    static bool precall(PyObject* args);
+};
+
+template <std::size_t custodian, std::size_t ward, class Base = default_call_policies>
+struct with_custodian_and_ward_postcall : Base
+{
+    static PyObject* postcall(PyObject* args, PyObject* result);
+};
+
+//
+// implementations
+//
+template <std::size_t custodian, std::size_t ward, class Base>
+bool with_custodian_and_ward<custodian,ward,Base>::precall(PyObject* args_)
+{
+    BOOST_STATIC_ASSERT(custodian != ward);
+    BOOST_STATIC_ASSERT(custodian > 0);
+    BOOST_STATIC_ASSERT(ward > 0);
+    
+    PyObject* patient = PyTuple_GetItem(args_, ward - 1);
+    if (patient == 0) return false;
+    PyObject* nurse = PyTuple_GetItem(args_, custodian - 1);
+    if (nurse == 0) return false;
+    
+    PyObject* life_support = python::objects::make_nurse_and_patient(nurse, patient);
+    if (life_support == 0)
+        return false;
+    
+    bool result = Base::precall(args_);
+    
+    if (!result)
+        Py_XDECREF(life_support);
+    
+    return result;
+}
+
+template <std::size_t custodian, std::size_t ward, class Base>
+PyObject* with_custodian_and_ward_postcall<custodian,ward,Base>::postcall(PyObject* args_, PyObject* result)
+{
+    BOOST_STATIC_ASSERT(custodian != ward);
+    
+    PyObject* patient = ward > 0 ? PyTuple_GetItem(args_, ward - 1) : result;
+    if (patient == 0) return 0;
+    
+    PyObject* nurse = custodian > 0 ? PyTuple_GetItem(args_, custodian - 1) : result;
+    if (nurse == 0) return 0;
+    
+    result = Base::postcall(args_, result);
+    if (result == 0)
+        return 0;
+            
+    if (python::objects::make_nurse_and_patient(nurse, patient) == 0)
+    {
+        Py_XDECREF(result);
+        return 0;
+    }
+    return result;
+}
+
+}} // namespace boost::python
+
+#endif // WITH_CUSTODIAN_AND_WARD_DWA2002131_HPP
diff --git a/src/object/life_support.cpp b/src/object/life_support.cpp
index f587eb42..7507c71c 100644
--- a/src/object/life_support.cpp
+++ b/src/object/life_support.cpp
@@ -19,6 +19,7 @@ extern "C"
     static void
     life_support_dealloc(PyObject* self)
     {
+        Py_XDECREF(((life_support*)self)->patient);
         self->ob_type->tp_free(self);
     }
 
@@ -27,7 +28,8 @@ extern "C"
     {
         // Let the patient die now
         Py_XDECREF(((life_support*)self)->patient);
-        // Also let the weak reference die. This probably kills us.
+        ((life_support*)self)->patient = 0;
+        // Let the weak reference die. This probably kills us.
         Py_XDECREF(PyTuple_GET_ITEM(arg, 0));
         return detail::none();
     }
@@ -76,11 +78,11 @@ PyTypeObject life_support_type = {
     0                                       /* tp_new */
 };
 
-int make_nurse_and_patient(PyObject* nurse, PyObject* patient)
+PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient)
 {
     life_support* system = PyObject_New(life_support, &life_support_type);
     if (!system)
-        return -1;
+        return 0;
     
     // We're going to leak this reference, but don't worry; the
     // life_support system decrements it when the nurse dies.
@@ -88,12 +90,12 @@ int make_nurse_and_patient(PyObject* nurse, PyObject* patient)
     if (!weakref)
     {
         Py_XDECREF(system);
-        return -1;
+        return 0;
     }
     
     system->patient = patient;
     Py_XINCREF(patient); // hang on to the patient until death
-    return 0;
+    return weakref;
 }
 
 }}} // namespace boost::python::objects
diff --git a/test/test_pointer_adoption.cpp b/test/test_pointer_adoption.cpp
index 61cd49bd..87b3eaab 100644
--- a/test/test_pointer_adoption.cpp
+++ b/test/test_pointer_adoption.cpp
@@ -57,6 +57,21 @@ struct A
     inner x;
 };
 
+struct B
+{
+    B() : x(0) {}
+    
+    inner const* adopt(A* x) { this->x = x; return &x->get_inner(); }
+
+    std::string a_content()
+    {
+        return x ? x->content() : std::string("empty");
+    }
+
+    A* x;
+};
+
+
 A* create(std::string const& s)
 {
     return new A(s);
@@ -83,6 +98,19 @@ BOOST_PYTHON_MODULE_INIT(test_pointer_adoption_ext)
             .def("change", &inner::change)
             )
         
+        .add(
+            class_<B>("B")
+            .def_init()
+            
+            .def("adopt", &B::adopt
+                 // Adopt returns a pointer referring to a subobject of its 2nd argument (1st being "self")
+                 , return_internal_reference<2
+                      // Meanwhile, self holds a reference to the 2nd argument.
+                      , with_custodian_and_ward<1,2> >()
+                )
+            
+            .def("a_content", &B::a_content)
+            )
         ;
 }
 
diff --git a/test/test_pointer_adoption.py b/test/test_pointer_adoption.py
index 28e160dc..075a640b 100644
--- a/test/test_pointer_adoption.py
+++ b/test/test_pointer_adoption.py
@@ -26,6 +26,28 @@
 >>> num_a_instances()
 0
 
+>>> b = B()
+>>> a = create('another')
+>>> b.a_content()
+'empty'
+>>> innards = b.adopt(a);
+>>> b.a_content()
+'another'
+>>> num_a_instances()
+1
+>>> del a # innards and b are both holding a reference
+>>> num_a_instances()
+1
+>>> innards.change('yet another')
+>>> b.a_content()
+'yet another'
+
+>>> del innards
+>>> num_a_instances() # b still owns a reference to a
+1
+>>> del b
+>>> num_a_instances()
+0
 """
 def run(args = None):
     import sys

From d023d577b2bf22726cd79d839aac7e66592687b5 Mon Sep 17 00:00:00 2001
From: "Ralf W. Grosse-Kunstleve" <rwgk@yahoo.com>
Date: Sun, 3 Feb 2002 22:33:11 +0000
Subject: [PATCH 262/369] extra semicolon removed (cxx 6.3 diag.)

[SVN r12677]
---
 src/converter/builtin_converters.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 26834635..fcd7a2cd 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -194,7 +194,7 @@ namespace
   void register_int_converters(T* = 0)
   {
       static scalar_from_python<T, convertible_to_int, py_int_or_float_as_long> x;
-  };
+  }
 }    
 
 #define REGISTER_INT_CONVERTERS(U) register_int_converters<U>()

From 1ec58c1161cde52eb1c7a70cd6dcbecc77977309 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 23:21:48 +0000
Subject: [PATCH 263/369] bug fix

[SVN r12678]
---
 include/boost/python/detail/returning.hpp    |   2 +-
 include/boost/python/object/value_holder.hpp | 110 +++++++++----------
 2 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index 99bbc572..599e5d37 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -1216,7 +1216,7 @@ struct returning<void>
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
     template <class P>
-    static PyObject* call(R (*pf)(), PyObject*, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(), PyObject* args, PyObject*, P const& policies)
     {
         (*pf)();
         
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index 85e3797f..01431370 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -23,113 +23,113 @@ struct value_holder : instance_holder
     template <class A1>
     value_holder(PyObject*, A1 a1)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
+            (typename unwrap_reference<A1>::type&)(a1)
             )
     {}
     
     template <class A1, class A2>
     value_holder(PyObject*, A1 a1, A2 a2)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
             )
     {}
     
     template <class A1, class A2, class A3>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
             )
     {}
     
     template <class A1, class A2, class A3, class A4>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
             )
     {}
     
     template <class A1, class A2, class A3, class A4, class A5>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
             ) {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
             ) {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
             )
     {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
-            , (unwrap_reference<A8>::type&)(a8)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
             )
     {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
-            , (unwrap_reference<A8>::type&)(a8)
-            , (unwrap_reference<A9>::type&)(a9)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
             )
     {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     value_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
         : m_held(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
-            , (unwrap_reference<A8>::type&)(a8)
-            , (unwrap_reference<A9>::type&)(a9)
-            , (unwrap_reference<A10>::type&)(a10)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
+            , (typename unwrap_reference<A10>::type&)(a10)
             )
     {}
 

From 1dc6600b59b79a551f46f85dbf6197013a834465 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 23:51:16 +0000
Subject: [PATCH 264/369] kill extra ;

[SVN r12679]
---
 include/boost/python/return_internal_reference.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
index 2066b7a9..d696c7fa 100644
--- a/include/boost/python/return_internal_reference.hpp
+++ b/include/boost/python/return_internal_reference.hpp
@@ -22,7 +22,7 @@ namespace detail
   {}
 # endif
   ;
-};
+}
 
 struct internal_reference_to_python_generator
 {

From 9f33aa2afc143ab78e4b049c55c1add37dee961a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Feb 2002 23:58:10 +0000
Subject: [PATCH 265/369] bug fix

[SVN r12680]
---
 include/boost/python/class.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 4f30dc8d..978a226a 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -192,7 +192,9 @@ inline class_<T, Bases, HolderGenerator>::class_(char const* name)
 template <class T, class Bases, class HolderGenerator>
 inline ref class_<T, Bases, HolderGenerator>::object() const
 {
-    return this->class_base::object();
+    typedef objects::class_base base;
+    
+    return this->base::object();
 }
 
 }} // namespace boost::python

From 47c77487071bf47bf73c5652bc62aeef552e8822 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 4 Feb 2002 01:42:47 +0000
Subject: [PATCH 266/369] bug fix

[SVN r12681]
---
 .../boost/python/object/pointer_holder.hpp    | 110 +++++++++---------
 1 file changed, 55 insertions(+), 55 deletions(-)

diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index 81fcac0c..21fe8e96 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -28,113 +28,113 @@ struct pointer_holder : instance_holder
     template <class A1>
     pointer_holder(PyObject*, A1 a1)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
+            (typename unwrap_reference<A1>::type&)(a1)
                   ))
     {}
     
     template <class A1, class A2>
     pointer_holder(PyObject*, A1 a1, A2 a2)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
             ))
     {}
     
     template <class A1, class A2, class A3>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
             ))
     {}
     
     template <class A1, class A2, class A3, class A4>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
             ))
     {}
     
     template <class A1, class A2, class A3, class A4, class A5>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
             )) {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
             )) {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
             ))
     {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
-            , (unwrap_reference<A8>::type&)(a8)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
             ))
     {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
-            , (unwrap_reference<A8>::type&)(a8)
-            , (unwrap_reference<A9>::type&)(a9)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
             ))
     {}
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     pointer_holder(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
         : m_p(new Value(
-            (unwrap_reference<A1>::type&)(a1)
-            , (unwrap_reference<A2>::type&)(a2)
-            , (unwrap_reference<A3>::type&)(a3)
-            , (unwrap_reference<A4>::type&)(a4)
-            , (unwrap_reference<A5>::type&)(a5)
-            , (unwrap_reference<A6>::type&)(a6)
-            , (unwrap_reference<A7>::type&)(a7)
-            , (unwrap_reference<A8>::type&)(a8)
-            , (unwrap_reference<A9>::type&)(a9)
-            , (unwrap_reference<A10>::type&)(a10)
+            (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
+            , (typename unwrap_reference<A10>::type&)(a10)
             ))
     {}
 

From 80f697ef2a312ce49342c6ca7e387a6419f43104 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 4 Feb 2002 01:58:08 +0000
Subject: [PATCH 267/369] more bug fixes for really conformant compilers

[SVN r12682]
---
 include/boost/python/value_from_python.hpp | 5 +++--
 src/converter/builtin_converters.cpp       | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/value_from_python.hpp b/include/boost/python/value_from_python.hpp
index 0ff80323..c835de45 100644
--- a/include/boost/python/value_from_python.hpp
+++ b/include/boost/python/value_from_python.hpp
@@ -16,6 +16,7 @@ namespace boost { namespace python {
 template <typename T, class Derived>
 struct value_from_python
 {
+    typedef value_from_python<T,Derived> self;
     typedef converter::from_python_check from_python_check;
     
     value_from_python(from_python_check convertible)
@@ -50,13 +51,13 @@ struct value_from_python
     // Mark successful construction
     static void constructed(converter::from_python_data& data)
     {
-        data.stage1 = get_storage(data);
+        data.stage1 = self::get_storage(data);
     }
     
     inline static void destroy(converter::from_python_data& data)
     {
         // Get the location of the storage for
-        void* storage = get_storage(data);
+        void* storage = self::get_storage(data);
 
         // Check for successful construction
         if (data.stage1 == storage)
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index fcd7a2cd..33e1cb50 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -91,7 +91,8 @@ namespace
       : value_from_python<T, tp_cref_from_python<T,Convertible,TExtract> >
   {
    private:
-      typedef value_from_python<T, tp_cref_from_python<T,Convertible,TExtract> > base;
+      typedef tp_cref_from_python<T,Convertible,TExtract> self;
+      typedef value_from_python<T,tp_cref_from_python<T,Convertible,TExtract> > base;
       
    public:
       tp_cref_from_python()
@@ -102,7 +103,7 @@ namespace
       {
           unaryfunc converter = *(unaryfunc*)data.stage1;
           
-          void* storage = get_storage(data);
+          void* storage = self::get_storage(data);
           
           ref converted(converter(obj));
               

From 5d30ddac22c872e1413b3ea874edffc28f10ad8d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 4 Feb 2002 14:49:43 +0000
Subject: [PATCH 268/369] cxx 6.5 fixes

[SVN r12689]
---
 include/boost/python/detail/unwind_type.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/include/boost/python/detail/unwind_type.hpp b/include/boost/python/detail/unwind_type.hpp
index add3615a..e8ccd0c8 100644
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
@@ -141,9 +141,12 @@ inline typename Generator::result_type
 unwind_type(type<U>*p = 0, Generator* = 0)
 {
     BOOST_STATIC_CONSTANT(int, indirection
-                          = (pointer_ * is_pointer<U>::value)
-                          | (reference_ * is_reference<U>::value)
-                          | (reference_to_pointer_ * is_reference_to_pointer<U>::value));
+                          = (is_pointer<U>::value ? pointer_ : 0)
+                          + (is_reference_to_pointer<U>::value
+                             ? reference_to_pointer_
+                             : is_reference<U>::value
+                             ? reference_
+                             : 0));
         
     return unwind_helper2<indirection>::execute((U(*)())0,(Generator*)0);
 }

From 8ff5450ece1658bdc973c01b58587e3182eb96c1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 4 Feb 2002 20:14:53 +0000
Subject: [PATCH 269/369] moved contents of builtin_to_python_converters.hpp to
 builtin_converters.hpp

[SVN r12705]
---
 .../python/converter/builtin_converters.hpp   | 60 +++++++++++++++++-
 .../builtin_to_python_converters.hpp          | 62 -------------------
 include/boost/python/to_python_value.hpp      |  2 +-
 3 files changed, 58 insertions(+), 66 deletions(-)
 delete mode 100644 include/boost/python/converter/builtin_to_python_converters.hpp

diff --git a/include/boost/python/converter/builtin_converters.hpp b/include/boost/python/converter/builtin_converters.hpp
index 9c19cbc5..a21fd27b 100644
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -5,11 +5,65 @@
 // to its suitability for any purpose.
 #ifndef BUILTIN_CONVERTERS_DWA2002124_HPP
 # define BUILTIN_CONVERTERS_DWA2002124_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <string>
 
-namespace boost { namespace python { namespace converter { 
+namespace boost { namespace python {
 
-void initialize_builtin_converters();
+// Provide specializations of to_python_value
+template <class T> struct to_python_value;
 
-}}} // namespace boost::python::converter
+namespace detail
+{
+  struct builtin_to_python
+  {
+      static bool convertible() { return true; }
+  };
+}
+
+# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)   \
+    template <> struct to_python_value<T&>          \
+        : detail::builtin_to_python                 \
+    {                                               \
+        PyObject* operator()(T const& x) const      \
+        {                                           \
+            return (expr);                          \
+        }                                           \
+    };                                              \
+    template <> struct to_python_value<T const&>    \
+        : detail::builtin_to_python                 \
+    {                                               \
+        PyObject* operator()(T const& x) const      \
+        {                                           \
+            return (expr);                          \
+        }                                           \
+    };
+
+
+# define BOOST_PYTHON_TO_INT(T)                                         \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
+    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, PyInt_FromLong(x))
+
+BOOST_PYTHON_TO_INT(char)
+BOOST_PYTHON_TO_INT(short)
+BOOST_PYTHON_TO_INT(int)
+BOOST_PYTHON_TO_INT(long)
+# undef BOOST_TO_PYTHON_INT
+
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, PyString_FromString(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x)
+
+namespace converter
+{ 
+
+  void initialize_builtin_converters();
+
+}
+
+}} // namespace boost::python::converter
 
 #endif // BUILTIN_CONVERTERS_DWA2002124_HPP
diff --git a/include/boost/python/converter/builtin_to_python_converters.hpp b/include/boost/python/converter/builtin_to_python_converters.hpp
deleted file mode 100644
index 89ad7b86..00000000
--- a/include/boost/python/converter/builtin_to_python_converters.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
-# define BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
-# include <string>
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { 
-
-// Provide specializations of to_python_value
-template <class T> struct to_python_value;
-
-namespace detail
-{
-  struct builtin_to_python
-  {
-      static bool convertible() { return true; }
-  };
-}
-
-# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)   \
-    template <> struct to_python_value<T&>          \
-        : detail::builtin_to_python                 \
-    {                                               \
-        PyObject* operator()(T const& x) const      \
-        {                                           \
-            return (expr);                          \
-        }                                           \
-    };                                              \
-    template <> struct to_python_value<T const&>    \
-        : detail::builtin_to_python                 \
-    {                                               \
-        PyObject* operator()(T const& x) const      \
-        {                                           \
-            return (expr);                          \
-        }                                           \
-    };
-
-
-# define BOOST_PYTHON_TO_INT(T)                                         \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, PyInt_FromLong(x))
-
-BOOST_PYTHON_TO_INT(char)
-BOOST_PYTHON_TO_INT(short)
-BOOST_PYTHON_TO_INT(int)
-BOOST_PYTHON_TO_INT(long)
-# undef BOOST_TO_PYTHON_INT
-
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, PyString_FromString(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x)
-
-}} // namespace boost::python::converter
-
-#endif // BUILTIN_TO_PYTHON_CONVERTERS_DWA2002129_HPP
diff --git a/include/boost/python/to_python_value.hpp b/include/boost/python/to_python_value.hpp
index a222e9a9..ecff5808 100644
--- a/include/boost/python/to_python_value.hpp
+++ b/include/boost/python/to_python_value.hpp
@@ -10,7 +10,7 @@
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/converter/to_python_function.hpp>
-# include <boost/python/converter/builtin_to_python_converters.hpp>
+# include <boost/python/converter/builtin_converters.hpp>
 
 namespace boost { namespace python { 
 

From e37a97e2d57f3fd598ff222d1d4cbbfe5785e5f2 Mon Sep 17 00:00:00 2001
From: Darin Adler <darin@bentspoon.com>
Date: Fri, 8 Feb 2002 20:08:15 +0000
Subject: [PATCH 270/369] Always say "private noncopyable" to avoid warnings.

[SVN r12762]
---
 include/boost/python/classes.hpp          | 2 +-
 include/boost/python/converter/handle.hpp | 2 +-
 include/boost/python/object/class.hpp     | 4 ++--
 test/comprehensive.hpp                    | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/boost/python/classes.hpp b/include/boost/python/classes.hpp
index 31af430f..2725ed7b 100644
--- a/include/boost/python/classes.hpp
+++ b/include/boost/python/classes.hpp
@@ -233,7 +233,7 @@ class BOOST_PYTHON_DECL_TEMPLATE meta_class
                    boost::python::detail::getattrable<
                       boost::python::detail::setattrable<
                          boost::python::detail::type_object<class_t<T> > > > > >,
-      boost::noncopyable
+      private boost::noncopyable
 {
  public:
     meta_class();
diff --git a/include/boost/python/converter/handle.hpp b/include/boost/python/converter/handle.hpp
index bc06be38..82e085b0 100644
--- a/include/boost/python/converter/handle.hpp
+++ b/include/boost/python/converter/handle.hpp
@@ -16,7 +16,7 @@ struct BOOST_PYTHON_DECL body;
 // The common base class for unwrap_ and wrap_ handle objects. They
 // share a common base so that handles can be linked into a chain
 // within a function wrapper which is managed by a single object.
-struct BOOST_PYTHON_DECL handle : boost::noncopyable
+struct BOOST_PYTHON_DECL handle : private boost::noncopyable
 {
  public: // member functions
 
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 53d886fa..35280074 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -26,7 +26,7 @@ template <class T> struct holder;
 // To identify a class, we don't need cv/reference decorations
 typedef converter::undecorated_type_id_t class_id;
 
-struct BOOST_PYTHON_DECL class_base : noncopyable
+struct BOOST_PYTHON_DECL class_base : private noncopyable
 {
     // constructor
     class_base(
@@ -44,7 +44,7 @@ struct BOOST_PYTHON_DECL class_base : noncopyable
 };
 
 // Base class for all holders
-struct BOOST_PYTHON_DECL instance_holder : noncopyable
+struct BOOST_PYTHON_DECL instance_holder : private noncopyable
 {
  public:
     instance_holder();
diff --git a/test/comprehensive.hpp b/test/comprehensive.hpp
index deb68a88..370f7d04 100644
--- a/test/comprehensive.hpp
+++ b/test/comprehensive.hpp
@@ -27,8 +27,8 @@ namespace bpl_test {
 // example: Foo, Bar, and Baz are C++ classes we want to wrap.
 //
 
-class Foo                // prohibit copying, proving that it doesn't choke 
-    : boost::noncopyable // our generation of to_python().
+class Foo                        // prohibit copying, proving that it doesn't choke 
+    : private boost::noncopyable // our generation of to_python().
 {
  public: // constructor/destructor
     Foo(int x) : m_x(x) {}

From 93735c7bf1538572018fedae9c76b05f46298d12 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Feb 2002 22:04:01 +0000
Subject: [PATCH 271/369] Updated docs and provided backwards compatibility for
 handle_exception()

[SVN r12764]
---
 doc/example1.html            |  7 -------
 doc/exporting_classes.html   |  7 -------
 doc/inheritance.html         | 33 +++++++++++++--------------------
 doc/overriding.html          | 13 +++----------
 example/getting_started1.cpp |  5 +++++
 5 files changed, 21 insertions(+), 44 deletions(-)

diff --git a/doc/example1.html b/doc/example1.html
index 402cc7a6..ee01e72c 100644
--- a/doc/example1.html
+++ b/doc/example1.html
@@ -37,19 +37,12 @@ namespace python = boost::python;
 
 BOOST_PYTHON_MODULE_INIT(getting_started1)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("getting_started1");
 
     // Add regular functions to the module.
     this_module.def(greet, "greet");
     this_module.def(square, "square");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
 </pre>
       </blockquote>
diff --git a/doc/exporting_classes.html b/doc/exporting_classes.html
index 61c5ef88..cbeb8a9e 100644
--- a/doc/exporting_classes.html
+++ b/doc/exporting_classes.html
@@ -47,8 +47,6 @@ namespace python = boost::python;
 
 BOOST_PYTHON_MODULE_INIT(getting_started2)
 {
-  try
-  {
     // Create an object representing this extension module.
     python::module_builder this_module("getting_started2");
 
@@ -65,11 +63,6 @@ BOOST_PYTHON_MODULE_INIT(getting_started2)
 
     // Even better, invite() can also be made a member of hello_class!!!
     hello_class.def(invite, "invite");
-  }
-  catch(...)
-  {
-    python::handle_exception(); // Deal with the exception for Python
-  }
 }
 </blockquote></pre>
       <p>
diff --git a/doc/inheritance.html b/doc/inheritance.html
index cd95c744..3cceb0d0 100644
--- a/doc/inheritance.html
+++ b/doc/inheritance.html
@@ -78,26 +78,19 @@ namespace python = boost::python;
 
 BOOST_PYTHON_MODULE_INIT(my_module)
 {
-    try
-    {
-       python::module_builder my_module("my_module");
-
-       python::class_builder&lt;Base&gt; base_class(my_module, "Base");
-       base_class.def(python::constructor&lt;void&gt;());
-
-       python::class_builder&lt;Derived&gt; derived_class(my_module, "Derived");
-       derived_class.def(python::constructor&lt;void&gt;());
-       <b>// Establish the inheritance relationship between Base and Derived
-       derived_class.declare_base(base_class);</b>
-
-       my_module.def(derived_as_base, "derived_as_base");
-       my_module.def(get_name, "get_name");
-       my_module.def(get_derived_x, "get_derived_x");
-    }
-    catch(...)
-    {
-       python::handle_exception();    // Deal with the exception for Python
-    }
+    python::module_builder my_module("my_module");                            
+                                                                              
+    python::class_builder&lt;Base&gt; base_class(my_module, "Base");          
+    base_class.def(python::constructor&lt;void&gt;());                        
+                                                                              
+    python::class_builder&lt;Derived&gt; derived_class(my_module, "Derived"); 
+    derived_class.def(python::constructor&lt;void&gt;());                     
+    <b>// Establish the inheritance relationship between Base and Derived     
+    derived_class.declare_base(base_class);</b>                               
+                                                                              
+    my_module.def(derived_as_base, "derived_as_base");                        
+    my_module.def(get_name, "get_name");                                      
+    my_module.def(get_derived_x, "get_derived_x"); 
 }
 </pre>
 </blockquote>
diff --git a/doc/overriding.html b/doc/overriding.html
index 02665be5..085d5a7f 100644
--- a/doc/overriding.html
+++ b/doc/overriding.html
@@ -151,16 +151,9 @@ struct baz_callback {
 
 BOOST_PYTHON_MODULE_INIT(foobar)
 {
-    try
-    {
-       boost::python::module_builder foobar("foobar");
-       boost::python::class_builder&lt;baz,baz_callback&gt; baz_class("baz");
-       baz_class.def(&amp;baz::calls_pure, "calls_pure");
-    }
-    catch(...)
-    {
-       boost::python::handle_exception();    // Deal with the exception for Python
-    }
+     boost::python::module_builder foobar("foobar");                          
+     boost::python::class_builder&lt;baz,baz_callback&gt; baz_class("baz");   
+     baz_class.def(&amp;baz::calls_pure, "calls_pure"); 
 }
 </pre>
     </blockquote>
diff --git a/example/getting_started1.cpp b/example/getting_started1.cpp
index 2f180633..91a1f551 100644
--- a/example/getting_started1.cpp
+++ b/example/getting_started1.cpp
@@ -16,10 +16,15 @@ namespace python = boost::python;
 // extension module. This is where we build the module contents.
 BOOST_PYTHON_MODULE_INIT(getting_started1)
 {
+    try {
     // Create an object representing this extension module.
     python::module_builder this_module("getting_started1");
 
     // Add regular functions to the module.
     this_module.def(greet, "greet");
     this_module.def(square, "square");
+    }
+    catch(...) {
+        boost::python::handle_exception();
+    }
 }

From 9e8273c7f7981d012b13a7d23310dc93ec0d80b1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Feb 2002 00:49:13 +0000
Subject: [PATCH 272/369] backward-compatibility hack for handle_exception()

[SVN r12777]
---
 include/boost/python/errors.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/include/boost/python/errors.hpp b/include/boost/python/errors.hpp
index b9eb4363..d0f71a24 100644
--- a/include/boost/python/errors.hpp
+++ b/include/boost/python/errors.hpp
@@ -28,6 +28,13 @@ bool handle_exception(T f)
     return handle_exception_impl(function0<void>(boost::ref(f)));
 }
 
+namespace detail { inline void rethrow() { throw; } }
+
+inline void handle_exception()
+{
+    handle_exception(detail::rethrow);
+}
+
 BOOST_PYTHON_DECL PyObject* expect_non_null(PyObject* x);
 
 template <class T>

From 44e43d3b47295269f67e6f1e17bfacca12af60bb Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 14 Feb 2002 03:39:41 +0000
Subject: [PATCH 273/369] Initial checkin of V2 docs

[SVN r12797]
---
 build/Jamfile                        |   2 +-
 doc/boost.css                        |  57 +++++
 doc/v2/acknowledgments.html          |  31 +++
 doc/v2/bibliography.html             |  31 +++
 doc/v2/call.html                     |  62 +++++
 doc/v2/class.html                    | 328 +++++++++++++++++++++++++++
 doc/v2/class_hpp.py                  |  20 ++
 doc/v2/configuration.html            |  90 ++++++++
 doc/v2/copy_const_reference.html     | 118 ++++++++++
 doc/v2/copy_non_const_reference.html | 119 ++++++++++
 doc/v2/default_call_policies.html    | 144 ++++++++++++
 doc/v2/definitions.html              |  34 +++
 doc/v2/errors.html                   | 223 ++++++++++++++++++
 doc/v2/faq.html                      |  38 ++++
 doc/v2/foo.cpp                       | 142 ++++++++++++
 doc/v2/from_python.html              | 156 +++++++++++++
 doc/v2/header.html                   | 181 +++++++++++++++
 doc/v2/index.html                    |  41 ++++
 doc/v2/overview.html                 |  47 ++++
 doc/v2/rationale.html                |  47 ++++
 doc/v2/reference.html                | 271 ++++++++++++++++++++++
 21 files changed, 2181 insertions(+), 1 deletion(-)
 create mode 100644 doc/boost.css
 create mode 100644 doc/v2/acknowledgments.html
 create mode 100644 doc/v2/bibliography.html
 create mode 100644 doc/v2/call.html
 create mode 100644 doc/v2/class.html
 create mode 100644 doc/v2/class_hpp.py
 create mode 100644 doc/v2/configuration.html
 create mode 100644 doc/v2/copy_const_reference.html
 create mode 100644 doc/v2/copy_non_const_reference.html
 create mode 100644 doc/v2/default_call_policies.html
 create mode 100644 doc/v2/definitions.html
 create mode 100644 doc/v2/errors.html
 create mode 100644 doc/v2/faq.html
 create mode 100644 doc/v2/foo.cpp
 create mode 100644 doc/v2/from_python.html
 create mode 100644 doc/v2/header.html
 create mode 100644 doc/v2/index.html
 create mode 100644 doc/v2/overview.html
 create mode 100644 doc/v2/rationale.html
 create mode 100644 doc/v2/reference.html

diff --git a/build/Jamfile b/build/Jamfile
index 1ea3665d..7dd6ecfe 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -9,7 +9,7 @@
 # To run all tests with verbose output: jam -sPYTHON_TEST_ARGS=-v test
 #
 # Declares the following targets:
-#   1. libboost_python, a static link library to be linked with all
+#   1. libboost_python.dll/.so, a dynamic library to be linked with all
 #      Boost.Python modules
 #
 #   2. pairs of test targets of the form <name>.test and <name>.run
diff --git a/doc/boost.css b/doc/boost.css
new file mode 100644
index 00000000..c382d4c6
--- /dev/null
+++ b/doc/boost.css
@@ -0,0 +1,57 @@
+H1
+{
+    FONT-SIZE: 200%
+    COLOR: #00007f
+}
+H2
+{
+    FONT-SIZE: 150%;
+}
+H3
+{
+    FONT-SIZE: 125%;
+}
+H4
+{
+    FONT-SIZE: 108%;
+}
+BODY
+{
+    FONT-SIZE: 100%;
+    BACKGROUND-COLOR: #ffffff
+}
+PRE
+{
+    MARGIN-LEFT: 2pc;
+    BACKGROUND-COLOR: #dfffff
+}
+CODE
+{
+     white-space: pre
+}
+.index
+{
+    TEXT-ALIGN: left
+}
+.page-index
+{
+	TEXT-ALIGN: left
+}
+.definition
+{
+	TEXT-ALIGN: left
+}
+.footnote
+{
+    FONT-SIZE: 66%;
+    VERTICAL-ALIGN: super;
+    TEXT-DECORATION: none
+}
+.function-semantics
+{
+    CLEAR: left
+}
+.metafunction-semantics
+{
+    CLEAR: left
+}
diff --git a/doc/v2/acknowledgments.html b/doc/v2/acknowledgments.html
new file mode 100644
index 00000000..bd13fa79
--- /dev/null
+++ b/doc/v2/acknowledgments.html
@@ -0,0 +1,31 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Acknowledgments</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Acknowledgments</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+{{text}}
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/bibliography.html b/doc/v2/bibliography.html
new file mode 100644
index 00000000..e1be0141
--- /dev/null
+++ b/doc/v2/bibliography.html
@@ -0,0 +1,31 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Bibliography</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Bibliography</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+{{bibliographical information}}
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/call.html b/doc/v2/call.html
new file mode 100644
index 00000000..eb3e706c
--- /dev/null
+++ b/doc/v2/call.html
@@ -0,0 +1,62 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;call.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;call.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+
+  <dt><a href="#functions">Functions</a></dt>
+  <dl class="page-index">
+    <dt><a href="#call-spec">call</a></dt>
+  </dl>
+
+  <dt><a href="#examples">Example(s)</a></dt>
+
+</dl>
+<hr>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>{{Introductory text}}</p>
+
+<h2><a name="functions"></a>Functions</h2>
+<pre>
+<a name="call-spec"></a>call
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+
+<h2><a name="examples"></a>Example(s)</h2>
+
+<p>{{Example(s)}}</p>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/class.html b/doc/v2/class.html
new file mode 100644
index 00000000..e6eee244
--- /dev/null
+++ b/doc/v2/class.html
@@ -0,0 +1,328 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/class.hpp&gt;, &lt;boost/python/class_fwd.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Headers &lt;boost/python/class.hpp&gt;, &lt;boost/python/class_fwd.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+
+  <dt><a href="#classes">Classes</a></dt>
+
+  <dl class="page-index">
+
+    <dt><a href="#class_-spec">Class template <code>class_</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#class_-spec-synopsis">Class <code>class_</code> synopsis</a></dt>
+	  <dt><a href="#class_-spec-ctors">Class <code>class_</code> constructors</a></dt>
+  	  <dt><a href="#class_-spec-modifiers">Class <code>class_</code> modifier functions</a></dt>
+  	  <dt><a href="#class_-spec-observers">Class <code>class_</code> observer functions</a></dt>
+	</dl>
+
+    <dt><a href="#bases-spec">Class template <code>bases</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#bases-spec-synopsis">Class <code>bases</code> synopsis</a></dt>
+	</dl>
+
+    <dt><a href="#args-spec">Class template <code>args</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#args-spec-synopsis">Class <code>args</code> synopsis</a></dt>
+	</dl>
+
+  </dl>
+
+  <dt><a href="#examples">Example(s)</a></dt>
+</dl>
+<hr>
+<h2><a name="introduction"></a>Introduction</h2>
+
+  <p><code>&lt;boost/python/class.hpp&gt;</code> defines the interface through
+  which users expose their C++ classes to Python. It declares the
+  <code>class_</code> class template, which is parameterized on the
+  class type being exposed, and the <code>args</code> and
+  <code>bases</code> utility class templates in the anonymous
+  namespace (the latter definitions will probably be moved in a future
+  release).
+
+  <p>
+  <code>&lt;boost/python/class_fwd.hpp&gt;</code>  contains a forward
+  declaration of the <code>class_</code> class template.
+
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="class_-spec">
+</a>Class template <code>class_&lt;T,&nbsp;Bases,&nbsp;<a
+ href="HolderGenerator.html">HolderGenerator</a>&gt;</code></h3>
+
+<p>Creates a Python class associated with the C++ type passed as its
+first parameter. Its template arguments are:
+<br><br>
+    <table border="1" summary="class_ template parameters">
+      <tr>
+        <th>Parameter
+        <th>Description
+        <th>Default
+      <tr>
+        <td><code>T</code>
+        <td>The class being exposed to Python
+      <tr>
+        <td><code>Bases</code>
+        <td>An <a href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++ base classes
+        <td>An unspecified empty sequence
+      <tr>
+        <td><a href="HolderGenerator.html">HolderGenerator</a></code>
+        <td>A type generator for the holder which
+maintains the C++ object inside the Python instance. 
+        <td><code>boost::python::objects::value_holder_generator</code>
+      </table>
+
+
+
+<h4><a name="class_-spec-synopsis"></a>Class template <code>class_</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+
+  template &lt;class T
+            , class Bases = <i>none</i>
+            , class HolderGenerator = objects::value_holder_generator&gt;
+  class class_
+  {
+    class_();
+    class_(char const* name);
+
+    template &lt;class F&gt;
+    class_&amp; def(char const* name, F f);
+
+    template &lt;class Fn, class CallPolicy&gt;
+    class_&amp; def(char const* name, Fn fn, CallPolicy policy);
+    
+    template &lt;class Args&gt;
+    class_&amp; def_init(Args const&amp; = Args());
+
+    class_&amp; def_init();
+
+    ref object() const;
+  };
+}}
+</pre>
+
+<h4><a name="class_-spec-ctors"></a>Class template <code>class_</code> constructors</h4>
+<pre>
+class_()
+</pre>
+<dl class="function-semantics"> 
+
+  <dt><b>Requires:</b> The platform's
+  <code>std::type_info::name()</code> implementation produces a string
+  which corresponds to the type's declaration in C++</dt>
+
+  <dt><b>Effects:</b> Constructs a <code>class_</code> object which
+  generates a Boost.Python extension class with the same name as
+  <code>T</code>.</dt>
+
+  <dt><b>Rationale:</b> Many platforms can generate reasonable names
+  for Python classes without user intervention.</dt>
+
+</dl>
+
+<pre>
+class_(char const* name)
+</pre>
+<dl class="function-semantics"> 
+
+  <dt><b>Requires:</b> Name is a ntbs which conforms to Python's <a
+  href="http://www.python.org/doc/current/ref/identifiers.html">identifier
+  naming rules</a>.</dt>
+
+  <dt><b>Effects:</b> Constructs a <code>class_</code> object which
+  generates a Boost.Python extension class named
+  <code>name</code>.</dt>
+
+  <dt><b>Rationale:</b> Gives the user full control over class naming.</dt>
+
+</dl>
+
+<h4><a name="class_-spec-modifiers"></a>Class template <code>class_</code> modifier functions</h4>
+
+<pre>
+template &lt;class F&gt;
+class_&amp; def(char const* name, F f)
+
+template &lt;class Fn, class CallPolicy&gt;
+class_&amp; def(char const* name, Fn fn, CallPolicy policy)
+</pre>
+
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b>
+
+    <code>f</code> is a non-null pointer-to-function or
+    pointer-to-member-function.
+
+    <code>name</code> is a ntbs which conforms to Python's <a
+    href="http://www.python.org/doc/current/ref/identifiers.html">identifier
+    naming rules</a>.
+
+    If supplied, <code>policy</code> conforms to the <a
+    href="CallPolicy.html">CallPolicy</a> concept requirements.
+</dt>
+
+  <dt><b>Effects:</b> Adds the result of <code><a
+  href="make_function.html#make_function-spec">make_function</a>(f)</code>
+  to the Boost.Python extension class being defined, with the given
+  <code>name</code>. If the extension class already has an attribute
+  named <code><i>name</i></code>, the usual <a
+  href="http:overloading.html">overloading procedure</a> applies.
+
+  </dt>
+
+  <dt><b>Returns:</b> <code>*this</code></dt>
+</dl>
+
+<pre>
+template &lt;class Args&gt;
+class_&amp; def_init(Args const&amp; argument_types)
+
+class_&amp; def_init()
+</pre>
+
+<dl class="function-semantics"> 
+
+  <dt><b>Requires:</b> in the first form, argument_types must be an <a
+  href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++
+  argument types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
+  <code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
+  <i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression
+  <code>T(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>) is
+  valid. In the second form, the expression <code>T()</code> must be
+  valid.
+</dt>
+
+  <dt><b>Effects:</b> Adds the result of <code><a
+  href="make_function.html#make_constructor-spec">
+  make_constructor</a>&lt;T,Args,HolderGenerator&gt;()</code> to the
+  Boost.Python extension class being defined with the name
+  &quot;__init__&quot;. If the 2nd form is used, an unspecified empty
+  <a href="../../../mpl/doc/Sequences.html">MPL sequence</a> type is
+  substituted for <code>Args</code>.
+  If the extension class already has an
+   &quot;__init__&quot; attribute, the usual <a
+  href="http:overloading.html">overloading procedure</a> applies.
+
+  <dt><b>Returns:</b> <code>*this</code></dt>
+
+  <dt><b>Rationale:</b> Allows users to easily expose a class'
+  constructor to Python.</dt>
+</dl>
+
+
+<h4><a name="class_-spec-observers"></a>Class template <code>class_</code> observer
+functions</h4>
+<pre>
+ref object() const;
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Returns:</b> A <code>ref</code> object which holds a
+  reference to the Boost.Python extension class object created by the
+  <code>class_</code> constructor.</dt>
+
+  <dt><b>Rationale:</b> Mostly not needed by users, since <code><a
+  href="module.html#add-spec">module::add</a>()</code> uses this to
+  insert the extension class in the module.</dt>
+</dl>
+
+
+<h3><a name="args-spec">
+</a>Class template <code>args&lt;T1,&nbsp;T2,</code>...<code>TN&gt;</code></h3>
+
+<p>Essentially an alias for <code>boost::mpl::type_list</code> which
+users can use in <code>def_init</code> calls to make their code more
+readable. Currently it is in the global unnammed namespace, but that
+will probably change.
+
+<h4><a name="args-spec-synopsis"></a>Class template <code>args</code> synopsis</h4>
+<pre>
+namespace
+{
+  template &lt;T1 = <i>unspecified</i>,...TN = <i>unspecified</i>&gt;
+  struct args : ::boost::mpl::type_list&lt;T1,...TN&gt;::type
+  {};
+}
+</pre>
+
+<h3><a name="bases-spec">
+</a>Class template <code>bases&lt;T1,&nbsp;T2,</code>...<code>TN&gt;</code></h3>
+
+<p>Essentially an alias for <code>boost::mpl::type_list</code> which
+users can use in <code>class_&lt;</code>...<code>&gt;</code>
+instantiations to make their code more readable. Currently it is in
+the global unnammed namespace, but that will probably change.
+
+<h4><a name="bases-spec-synopsis"></a>Class template <code>bases</code> synopsis</h4>
+<pre>
+namespace
+{
+  template &lt;T1 = <i>unspecified</i>,...TN = <i>unspecified</i>&gt;
+  struct bases : ::boost::mpl::type_list&lt;T1,...TN&gt;::type
+  {};
+}
+</pre>
+
+<h2><a name="examples"></a>Example(s)</h2>
+
+<p>Given a C++ class declaration:
+
+<pre>
+class Foo : public Bar, public Baz
+{
+ public:
+   Foo(int, char const*);
+   Foo(double);
+
+   std::string const&amp; name() { return m_name; }
+   void name(char const*);
+ private:
+   ...
+};
+</pre>
+
+A corresponding Boost.Python extension class can be created with:
+
+<pre>
+using namespace boost::python;
+ref foo =
+class_&lt;Foo,bases&lt;Bar,Baz&gt; &gt;()
+   .def_init(args&lt;int,char const*&gt;())
+   .def_init(args&lt;double&gt;())
+   .def("get_name", &amp;Foo::get_name, return_internal_reference&lt;&gt;())
+   .def("set_name", &amp;Foo::set_name)
+   .object();
+</pre>
+
+</p>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/class_hpp.py b/doc/v2/class_hpp.py
new file mode 100644
index 00000000..9af2cb5c
--- /dev/null
+++ b/doc/v2/class_hpp.py
@@ -0,0 +1,20 @@
+introduction = '''
+'''
+
+class boost(namespace): pass
+
+class python(boost):
+    
+    class class_(class_template):
+        T = type()
+        T.requires = 'a class type'
+        
+        Bases = concepts.mpl_sequence('class type')
+        HolderGenerator = concepts.HolderGenerator()
+        template_args = (T, Bases, HolderGenerator)
+
+        class def_1(function_template):
+            name = "def"
+            args = (('char const*', 'name'), ('F', 'f'))
+        
+class_template
diff --git a/doc/v2/configuration.html b/doc/v2/configuration.html
new file mode 100644
index 00000000..18b065d1
--- /dev/null
+++ b/doc/v2/configuration.html
@@ -0,0 +1,90 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Configuration</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Configuration</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="page-index">
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#app-defined">Application Defined Macros</a></dt>
+  <dt><a href="#lib-defined-public">Public Library Defined Macros</a></dt>
+  <dt><a href="#lib-defined-impl">Library Defined Implementation Macros</a></dt>
+</dl>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>Boost.Python uses several configuration macros in <a href="http://www.boost.org/libs/config/config.htm">&lt;boost/config.hpp&gt;</a>, 
+  as well as configuration macros meant to be supplied by the application. These 
+  macros are documented here.</p>
+<h2><a name="app-defined"></a>Application Defined Macros</h2>
+<p>These are the macros that may be defined by an application using Boost.Python.</p>
+<table summary="application defined macros" cellspacing="10" width="100%">
+  <tr>
+    <td><b>Macro</b></td>
+    <td><b>Meaning</b></td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+</table>
+<h2><a name="lib-defined-public"></a>Public Library Defined Macros</h2>
+<p>These macros are defined by Boost.Python but are expected to be used by application 
+  code.</p>
+<table summary="public library defined macros" cellspacing="10" width="100%">
+  <tr>
+    <td><b>Macro</b></td>
+    <td><b>Meaning</b></td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+</table>
+<h2><a name="lib-defined-impl"></a>Library Defined Implementation Macros</h2>
+<p>These macros are defined by Boost.Python and are implementation details of interest 
+  only to implementers.</p>
+<table summary="library defined implementation macros" cellspacing="10" width="100%">
+  <tr>
+    <td><b>Macro</b></td>
+    <td><b>Meaning</b></td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+  <tr>
+    <td>{{macro}}</td>
+	<td>{{meaning}}</td>
+  </tr>
+</table>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/copy_const_reference.html b/doc/v2/copy_const_reference.html
new file mode 100644
index 00000000..1ce94dbb
--- /dev/null
+++ b/doc/v2/copy_const_reference.html
@@ -0,0 +1,118 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/copy_const_reference.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/copy_const_reference.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+    <dt><a href="#copy_const_reference-spec">Class <code>copy_const_reference</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#copy_const_reference-spec-synopsis">Class <code>copy_const_reference</code> synopsis</a></dt>
+	  <dt><a href="#copy_const_reference-spec-metafunctions">Class <code>copy_const_reference</code> metafunctions</a></dt>
+	</dl>
+  </dl>
+
+  <dt><a href="#examples">Example</a></dt>
+</dl>
+<hr>
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="copy_const_reference-spec"></a>Class <code>copy_const_reference</code></h3>
+<p>
+<code>copy_const_reference</code> is a model of <a
+href="ResultConverterGenerator.html">ResultConverterGenerator</a>
+which can be used to wrap C++ functions returning a reference-to-const
+type such that the referenced value is copied into a new Python object. 
+</p>
+
+<h4><a name="copy_const_reference-spec-synopsis"></a>Class <code>copy_const_reference</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    struct copy_const_reference
+    {
+        template &lt;class T&gt; struct apply;
+    };
+}}
+</pre>
+<h4><a name="copy_const_reference-spec-metafunctions"></a>Class <code>copy_const_reference</code> metafunctions</h4>
+<pre>
+template &lt;class T&gt; struct apply
+</pre>
+<dl class="metafunction-semantics"> 
+  <dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for some <code>U</code>.</dt>
+  <dt><b>Returns:</b> <code>typedef <a href="to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt; type;</code></dt>
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p> In C++:
+
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/copy_const_reference.hpp&gt;
+#include &lt;boost/python/return_value_policy.hpp&gt;
+
+// classes to wrap
+struct Bar { int x; }
+
+struct Foo {
+   Foo(int x) : { b.x = x; }
+   Bar const&amp; get_bar() const { return b; }
+ private:
+   Bar b;
+};
+
+// Wrapper code
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(my_module)
+{
+   module m("my_module")
+      .add(
+         class_&lt;Bar&gt;()
+         )
+      .add(
+         class_&lt;Foo&gt;()
+            .def_init(args&lt;int&gt;())
+            .def("get_bar", &amp;Foo::get_bar
+                , return_value_policy&lt;copy_const_reference&gt;())
+         );
+}
+</pre>
+
+In Python:
+
+<pre>
+&gt;&gt;&gt; from my_module import *
+&gt;&gt;&gt; f = Foo(3)         # create a Foo object
+&gt;&gt;&gt; b = f.get_bar()    # make a copy of the internal Bar object
+</pre>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/copy_non_const_reference.html b/doc/v2/copy_non_const_reference.html
new file mode 100644
index 00000000..c1ed50a3
--- /dev/null
+++ b/doc/v2/copy_non_const_reference.html
@@ -0,0 +1,119 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/copy_non_const_reference.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/copy_non_const_reference.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+    <dt><a href="#copy_non_const_reference-spec">Class <code>copy_non_const_reference</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#copy_non_const_reference-spec-synopsis">Class <code>copy_non_const_reference</code> synopsis</a></dt>
+	  <dt><a href="#copy_non_const_reference-spec-metafunctions">Class <code>copy_non_const_reference</code> metafunctions</a></dt>
+	</dl>
+  </dl>
+
+  <dt><a href="#examples">Example</a></dt>
+</dl>
+<hr>
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="copy_non_const_reference-spec"></a>Class <code>copy_non_const_reference</code></h3>
+<p>
+<code>copy_non_const_reference</code> is a model of <a
+href="ResultConverterGenerator.html">ResultConverterGenerator</a>
+which can be used to wrap C++ functions returning a reference-to-non-const
+type such that the referenced value is copied into a new Python object. 
+</p>
+
+<h4><a name="copy_non_const_reference-spec-synopsis"></a>Class <code>copy_non_const_reference</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    struct copy_non_const_reference
+    {
+        template &lt;class T&gt; struct apply;
+    };
+}}
+</pre>
+
+<h4><a name="copy_non_const_reference-spec-metafunctions"></a>Class <code>copy_non_const_reference</code> metafunctions</h4>
+<pre>
+template &lt;class T&gt; struct apply
+</pre>
+<dl class="metafunction-semantics"> 
+  <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> for some non-const <code>U</code>.</dt>
+  <dt><b>Returns:</b> <code>typedef <a href="to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt; type;</code></dt>
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p> C++ code:
+
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/copy_non_const_reference.hpp&gt;
+#include &lt;boost/python/return_value_policy.hpp&gt;
+
+// classes to wrap
+struct Bar { int x; }
+
+struct Foo {
+   Foo(int x) : { b.x = x; }
+   Bar&amp; get_bar() { return b; }
+ private:
+   Bar b;
+};
+
+// Wrapper code
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(my_module)
+{
+   module m("my_module")
+      .add(
+         class_&lt;Bar&gt;()
+         )
+      .add(
+         class_&lt;Foo&gt;()
+            .def_init(args&lt;int&gt;())
+            .def("get_bar", &amp;Foo::get_bar
+                , return_value_policy&lt;copy_non_const_reference&gt;())
+         );
+}
+</pre>
+
+Python Code:
+
+<pre>
+&gt;&gt;&gt; from my_module import *
+&gt;&gt;&gt; f = Foo(3)         # create a Foo object
+&gt;&gt;&gt; b = f.get_bar()    # make a copy of the internal Bar object
+</pre>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/default_call_policies.html b/doc/v2/default_call_policies.html
new file mode 100644
index 00000000..3e60fcc8
--- /dev/null
+++ b/doc/v2/default_call_policies.html
@@ -0,0 +1,144 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/default_call_policies.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/default_call_policies.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+
+    <dt><a href="#default_call_policies-spec">Class <code>default_call_policies</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#default_call_policies-spec-synopsis">Class <code>default_call_policies</code> synopsis</a></dt>
+	  <dt><a href="#default_call_policies-spec-statics">Class <code>default_call_policies</code> static functions</a></dt>
+	</dl>
+
+    <dt><a href="#default_result_converter-spec">Class <code>default_result_converter</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#default_result_converter-spec-synopsis">Class <code>default_result_converter</code> synopsis</a></dt>
+	  <dt><a href="#default_result_converter-spec-metafunctions">Class <code>default_result_converter</code> metafunctions</a></dt>
+	</dl>
+
+  </dl>
+
+  <dt><a href="#examples">Example</a></dt>
+</dl>
+<hr>
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="default_call_policies-spec"></a>Class <code>default_call_policies</code></h3>
+<p>
+<code>default_call_policies</code> is a model of <a
+href="CallPolicies.html">CallPolicies</a> with no <code>precall</code>
+or <code>postcall</code> behavior and a <code>result_converter</code>
+which handles by-value returns. Wrapped C++ functions and member
+functions use <code>default_call_policies</code> unless otherwise
+specified. You may find it convenient to derive new models of <a
+href="CallPolicies.html">CallPolicies</a> from
+<code>default_call_policies</code>.
+</p>
+
+<h4><a name="default_call_policies-spec-synopsis"></a>Class <code>default_call_policies</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    struct default_call_policies
+    {
+        static bool precall(PyObject*);
+        static PyObject* postcall(PyObject*, PyObject* result);
+        typedef <a href="#default_result_converter-spec">default_result_converter</a> result_converter;
+    };
+}}
+</pre>
+
+<h4><a name="default_call_policies-spec-statics"></a>Class <code>default_call_policies</code> static functions</h4>
+<pre>
+bool precall(PyObject*);
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Returns:</b> <code>true</code></dt>
+  <dt><b>Throws:</b> nothing</dt>
+</dl>
+
+<pre>
+PyObject* postcall(PyObject*, PyObject* result);
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Returns:</b> <code>result</code></dt>
+  <dt><b>Throws:</b> nothing</dt>
+</dl>
+
+<h3><a name="default_result_converter-spec"></a>Class <code>default_result_converter</code></h3>
+<p>
+<code>default_result_converter</code> is a model of <a
+href="ResultConverterGenerator.html">ResultConverterGenerator</a>
+which can be used to wrap C++ functions returning non-pointer types,
+<code>char const*</code>, and <code>PyObject*</code>,
+by-value.
+</p>
+
+<h4><a name="default_result_converter-spec-synopsis"></a>Class <code>default_result_converter</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    struct default_result_converter
+    {
+        template &lt;class T&gt; struct apply;
+    };
+}}
+</pre>
+
+<h4><a name="default_result_converter-spec-metafunctions"></a>Class <code>default_result_converter</code> metafunctions</h4>
+<pre>
+template &lt;class T&gt; struct apply
+</pre>
+<dl class="metafunction-semantics"> 
+
+  <dt><b>Requires:</b> <code>T</code> is not a reference type. If
+  <code>T</code> is a pointer type, <code>T</code> is <code>const
+  char*</code> or <code>PyObject*</code>.</dt>
+
+  <dt><b>Returns:</b> <code>typedef <a href="to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T const&amp;&gt; type;</code></dt>
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p>This example comes from the Boost.Python implementation itself. Because the <a
+href="return_value_policy.html#return_value_policy-spec">return_value_policy</a>
+class template does not implement <code>precall</code> or
+<code>postcall</code> behavior, its default base class is <code>default_call_policies</code>:
+
+<pre>
+template &lt;class Handler, class Base = default_call_policies&gt;
+struct return_value_policy : Base
+{
+   typedef Handler result_converter;
+};
+</pre>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/definitions.html b/doc/v2/definitions.html
new file mode 100644
index 00000000..dd917434
--- /dev/null
+++ b/doc/v2/definitions.html
@@ -0,0 +1,34 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Definitions</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Definitions</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="definitions">
+  <dt><b>{{term}}:</b> {{definition}}</dt>
+  <dt><b>{{term}}:</b> {{definition}}</dt>
+</dl>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/errors.html b/doc/v2/errors.html
new file mode 100644
index 00000000..b46de25c
--- /dev/null
+++ b/doc/v2/errors.html
@@ -0,0 +1,223 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;{{header}}&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/errors.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+
+    <dt><a href="#class-spec">Class <code>error_already_set</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#error_already_set-spec-synopsis">Class <code>error_already_set</code> synopsis</a></dt>
+	</dl>
+
+  </dl>
+
+  <dt><a href="#functions">Functions</a></dt>
+  <dl class="page-index">
+
+    <dt><a href="#handle_exception-spec">handle_exception</a></dt>
+    <dt><a href="#expect_non_null-spec">expect_non_null</a></dt>
+
+  </dl>
+
+  <dt><a href="#examples">Examples</a></dt>
+</dl>
+<hr>
+
+<h2><a name="introduction"></a>Introduction</h2>
+<p><code>&lt;boost/python/errors.hpp&gt;</code> provides types and
+functions for managing and translating between Python and C++
+exceptions. This is relatively low-level functionality that is mostly
+used internally by Boost.Python. Users should seldom need it.
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="error_already_set-spec"></a>Class <code>error_already_set</code></h3>
+<p>
+<code>error_already_set</code> is an exception type which can be
+thrown to indicate that a Python error has occurred. If thrown, the
+precondition is that <a
+href="http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
+returns a value convertible to <code>true</code>.
+</p>
+
+<h4><a name="class-spec-synopsis"></a>Class error_already_set synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    class error_already_set&nbsp;{};
+}}
+</pre>
+
+
+<h2><a name="functions"></a>Functions</h2>
+<pre><a name="handle_exception-spec">template &lt;class T&gt; bool handle_exception</a>(T f) throw();
+
+void handle_exception() throw();
+</pre>
+<dl class="handle_exception-semantics"> 
+  <dt><b>Requires:</b> The first form requires that the expression
+  <code><a
+  href="../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
+  is valid. The second form requires that a C++ exception is currently
+  being handled (see section 15.1 in the C++ standard).
+</dt>
+
+  <dt><b>Effects:</b> The first form calls <code>f()</code> inside a
+  <code>try</code> block whose <code>catch</code> clauses set an
+  appropriate Python exception for the C++ exception caught, returning
+  <code>true</code> if an exception was caught, <code>false</code>
+  otherwise. The second form passes a function which rethrows the
+  exception currently being handled to the first form.</dt>
+
+  <dt><b>Postconditions:</b> No exception is being handled</dt>
+
+  <dt><b>Throws:</b> nothing</dt>
+
+  <dt><b>Rationale:</b> At inter-language boundaries it is important
+  to ensure that no C++ exceptions escape, since the calling language
+  usually doesn't have the equipment neccessary to properly unwind the
+  stack. Use <code>handle_exception</code> to manage exception
+  translation whenever your C++ code is called directly from the
+  Python API. This is done for you automatically by the usual function
+  wrapping facilities: <a
+  href="make_function.html#make_function-spec">make_function()</a>, <a
+  href="make_function.html#make_constructor-spec">make_constructor()</a>,
+  <a href="module.html#def-spec">module::def</a> and <a
+  href="class.html#def-spec">class_::def</a>). The second form can be
+  more convenient to use
+  (see the <a href="#examples">example</a> below), but various
+  compilers have problems when exceptions are rethrown from within an
+  enclosing <code>try</code> block.</dt>
+</dl>
+
+<pre>
+<a name="expect_non_null-spec">PyObject* expect_non_null(PyObject* x);</a>
+
+template &lt;class T&gt; T* expect_non_null(T* x);
+</pre>
+<dl class="expect_non_null-semantics"> 
+  <dt><b>Returns:</b> <code>x</code></dt>
+  <dt><b>Throws:</b> <code><a href="#error_already_set-spec">error_already_set()</a></code> iff <code>x == 0</code>.</dt>
+  <dt><b>Rationale:</b> Simplifies error-handling when calling many
+  functions in the <a
+  href="http://www.python.org/doc/current/api/api.html">Python/C
+  API</a>, which return 0 on error.</dt>
+</dl>
+
+<h2><a name="examples"></a>Examples</h2>
+<p>
+<pre>
+#include &lt;string&gt;
+#include &lt;boost/python/errors.hpp&gt;
+#include &lt;boost/python/reference.hpp&gt;
+
+// Returns a std::string which has the same value as obj's "__name__"
+// attribute.
+std::string get_name(boost::python::ref obj)
+{
+   // throws if there's no __name__ attribute
+   PyObject* p = boost::python::expect_non_null(
+      PyObject_GetAttrString(obj.get(), "__name__"));
+
+   // throws if it's not a Python string
+   std::string result(
+      boost::python::expect_non_null(
+         PyString_AsString(p)));
+
+   Py_XDECREF(p); // Done with p
+   
+   return result;
+}
+
+//
+// Demonstrate form 1 of handle_exception
+//
+
+// Place a Python Int object whose value is 1 if a and b have
+// identical "__name__" attributes, 0 otherwise.
+void same_name_impl(PyObject*&amp; result, PyObject* a, PyObject* b)
+{
+   result = PyInt_FromLong(
+      get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
+}
+
+// This is an example Python 'C' API interface function
+extern "C" PyObject*
+same_name(PyObject* args, PyObject* keywords)
+{
+   PyObject* a1;
+   PyObject* a2;
+   PyObject* result = 0;
+
+   if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
+      return 0;
+   
+   // Use boost::bind to make an object compatible with
+   // boost::Function0&lt;void&gt;
+   if (boost::python::handle_exception(
+         boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), a1, a2)))
+   {
+      // an exception was thrown; the Python error was set by
+      // handle_exception()
+      return 0;
+   }
+
+   return result;
+}
+
+//
+// Demonstrate form 2 of handle_exception. Not well-supported by all
+// compilers.
+//
+extern "C" PyObject*
+same_name2(PyObject* args, PyObject* keywords)
+{
+   PyObject* a1;
+   PyObject* a2;
+   PyObject* result = 0;
+
+   if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
+      return 0;
+   try {
+      return PyInt_FromLong(
+         get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
+   }
+   catch(...)
+   {
+      // If an exception was thrown, translate it to Python
+      boost::python::handle_exception();
+      return 0;
+   }
+}
+</pre>
+</p>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/faq.html b/doc/v2/faq.html
new file mode 100644
index 00000000..dae93fa5
--- /dev/null
+++ b/doc/v2/faq.html
@@ -0,0 +1,38 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - FAQ</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Frequently Asked Questions (FAQs)</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="page-index">
+  <dt><a href="#question1">{{question}}</a></dt>
+  <dt><a href="#question2">{{question}}</a></dt>
+</dl>
+<h2><a name="question1"></a>{{question}}</h2>
+<p>{{answer}}</p>
+<h2><a name="question2"></a>{{question}}</h2>
+<p>{{answer}}</p>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/foo.cpp b/doc/v2/foo.cpp
new file mode 100644
index 00000000..e92c2d72
--- /dev/null
+++ b/doc/v2/foo.cpp
@@ -0,0 +1,142 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+
+#include <boost/python/module.hpp>
+#include <boost/python/class.hpp>
+#include <boost/python/copy_const_reference.hpp>
+#include <boost/python/return_value_policy.hpp>
+
+class Bar { int x; }
+
+class Foo
+{
+ public:
+    Foo(int x) : b(x) {}
+    Bar const& get_bar() const { return b; }
+ private:
+    Bar b;
+};
+
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(my_module)
+{
+    module m("my_module")
+        .add(
+            class_<Bar>()
+            )
+        .add(
+            class_<Foo>()
+                .def_init(args<int>())
+                .def("get_bar", &Foo::get_bar
+                     , return_value_policy<copy_const_reference>())
+            )
+}
+
+using namespace boost::python;
+ref foo =
+class_<Foo,bases<Bar,Baz> >()
+    .def_init(args<int,char const*>())
+    .def_init(args<double>())
+    .def("get_name", &Foo::get_name, return_internal_reference<>())
+    .def("set_name", &Foo::set_name)
+    .object();
+
+
+<blockquote><pre>
+#include &lt;string&gt;
+#include &lt;boost/python/errors.hpp&gt;
+#include &lt;boost/python/reference.hpp&gt;
+
+// Returns a std::string which has the same value as obj's "__name__"
+// attribute.
+std::string get_name(boost::python::ref obj)
+{
+    // throws if there's no __name__ attribute
+    PyObject* p = boost::python::expect_non_null(
+        PyObject_GetAttrString(obj.get(), "__name__"));
+
+    // throws if it's not a Python string
+    std::string result(
+        boost::python::expect_non_null(
+            PyString_AsString(p)));
+
+    Py_XDECREF(p); // Done with p
+    
+    return result;
+}
+
+//
+// Demonstrate form 1 of handle_exception
+//
+
+// Place a Python Int object whose value is 1 if a and b have
+// identical "__name__" attributes, 0 otherwise.
+void same_name_impl(PyObject*&amp; result, PyObject* a, PyObject* b)
+{
+    result = PyInt_FromLong(
+        get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
+}
+
+// This is an example Python 'C' API interface function
+extern "C" PyObject*
+same_name(PyObject* args, PyObject* keywords)
+{
+    PyObject* a1;
+    PyObject* a2;
+    PyObject* result = 0;
+
+    if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
+        return 0;
+    
+    // Use boost::bind to make an object compatible with
+    // boost::Function0&lt;void&gt;
+    if (boost::python::handle_exception(
+            boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), a1, a2)))
+    {
+        // an exception was thrown; the Python error was set by
+        // handle_exception()
+        return 0;
+    }
+
+    return result;
+}
+
+//
+// Demonstrate form 2 of handle_exception. Not well-supported by all
+// compilers.
+//
+extern "C" PyObject*
+same_name2(PyObject* args, PyObject* keywords)
+{
+    PyObject* a1;
+    PyObject* a2;
+    PyObject* result = 0;
+
+    if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
+        return 0;
+    try {
+        return PyInt_FromLong(
+            get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
+    }
+    catch(...)
+    {
+        // If an exception was thrown, translate it to Python
+        boost::python::handle_exception();
+        return 0;
+    }
+}
+
+</pre></blockquote>
+
+
+template <class T>
+struct from_python
+{
+    from_python(PyObject*);
+    bool convertible() const;
+    X operator()(PyObject*) const;
+};
diff --git a/doc/v2/from_python.html b/doc/v2/from_python.html
new file mode 100644
index 00000000..94ae7019
--- /dev/null
+++ b/doc/v2/from_python.html
@@ -0,0 +1,156 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/from_python.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/from_python.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+
+    <dt><a href="#from_python-spec">Class Template<code>from_python</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#from_python-spec-synopsis">Class Template <code>from_python</code> synopsis</a></dt>
+	  <dt><a href="#from_python-spec-ctors">Class Template <code>from_python</code> constructor</a></dt>
+  	  <dt><a href="#from_python-spec-observers">Class Template <code>from_python</code> observer functions</a></dt>
+	</dl>
+  </dl>
+  <dt><a href="#examples">Example</a></dt>
+</dl>
+<hr>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>
+
+<code>&lt;boost/python/from_python.hpp&gt;</code> introduces a class
+template <code>from_python&lt;T&gt;</code> for extracting a C++ object
+of type <code>T</code> from a Python object.
+
+</p>
+
+
+<h2><a name="classes"></a>Classes</h2>
+<h3><a name="from_python-spec"></a>Class Template <code>from_python&lt;class T&gt;</code></h3>
+
+<p>
+<code>from_python&lt;T&gt;</code> is the type used internally by
+Boost.Python to extract C++ function arguments from a Python argument
+tuple when calling a wrapped function. It can also be used directly to
+make similar conversions in other contexts.
+</p>
+
+<h4><a name="from_python-spec-synopsis"></a>Class Template <code>from_python</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+   template &lt;class T&gt;
+   struct from_python : private <a href=
+   "../../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
+       // from_python&lt;T&gt; meets the <a href="NonCopyable.html">NonCopyable</a> requirements
+   {
+      from_python(PyObject*);
+      bool convertible() const;
+      <i>convertible-to-T</i> operator()(PyObject*) const;
+   };
+}
+</pre>
+
+<h4><a name="from_python-spec-ctors"></a>Class Template <code>from_python</code> constructor</h4>
+<pre>
+from_python(PyObject* p);
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> <code>p != 0</code></dt>
+
+  <dt><b>Effects:</b> Constructs a <code>from_python</code> object
+  suitable for extracting a C++ object of type <code>T</code> from
+  <code>p</code>.</dt>
+</dl>
+
+<h4><a name="from_python-spec-observers"></a>Class Template <code>from_python</code> observer functions</h4>
+
+<pre>
+bool convertible() const;
+</pre>
+<dl class="function-semantics"> 
+
+  <dt><b>Returns:</b> <code>false</code> if the conversion cannot succeed. This indicates that either:
+<ol>
+<li>No <code>from_python_converter</code> was registered for
+<code>T</code>, or
+
+<li>any such converter rejected the constructor argument
+<code>p</code> by returning <code>0</code> from its
+<code>convertible()</code> function
+</ol>
+
+Note that conversion may still fail in <code>operator()</code> due to an exception.
+
+</dt>
+
+  <dt><b>Throws:</b> nothing</dt>
+
+  <dt><b>Rationale:</b> Because <code>from_python&lt;&gt;</code> is used in
+  overload resolution, and throwing an exception can be slow, it is
+  useful to be able to rule out a broad class of unsuccessful
+  conversions without throwing an exception.</dt>
+</dl>
+
+<pre>
+<i>convertible-to-T</i> operator()(PyObject* p) const;
+</pre>
+<dl class="function-semantics"> 
+
+  <dt><b>Requires:</b> <code>*p</code> refers to the same object which
+  was passed to the constructor, and <code>convertible()</code>
+  returns <code>true</code>.</dt>
+
+  <dt><b>Effects:</b> performs the conversion</dt>
+  <dt><b>Returns:</b> an object convertible to <code>T</code>.</dt>
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p>
+<pre>
+#include &lt;string&gt;
+#include &lt;boost/python/from_python.hpp&gt;
+
+// If a std::string can be extracted from p, return its
+// length. Otherwise, return 0.
+std::size_t length_if_string(PyObject* p)
+{
+   from_python&lt;std::string&gt; converter(p);
+   if (!converter.convertible())
+      return 0;
+   else
+      return converter().size();
+}
+</pre>
+</p>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/header.html b/doc/v2/header.html
new file mode 100644
index 00000000..c0fa972f
--- /dev/null
+++ b/doc/v2/header.html
@@ -0,0 +1,181 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;{{header}}&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;{{header}}&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#macros">Macros</a></dt>
+  <dl class="page-index">
+    <dt><a href="#macro-spec">{{macro name}}</a></dt>
+  </dl>
+  <dt><a href="#values">Values</a></dt>
+  <dl class="page-index">
+    <dt><a href="#value-spec">{{value name}}</a></dt>
+  </dl>
+  <dt><a href="#types">Types</a></dt>
+  <dl class="page-index">
+    <dt><a href="#type-spec">{{type name}}</a></dt>
+  </dl>
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+    <dt><a href="#class-spec">Class <code>{{class name}}</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#class-spec-synopsis">Class <code>{{class name}}</code> synopsis</a></dt>
+	  <dt><a href="#class-spec-ctors">Class <code>{{class name}}</code> constructors and destructor</a></dt>
+  	  <dt><a href="#class-spec-comparisons">Class <code>{{class name}}</code> comparison functions</a></dt>
+  	  <dt><a href="#class-spec-modifiers">Class <code>{{class name}}</code> modifier functions</a></dt>
+  	  <dt><a href="#class-spec-observers">Class <code>{{class name}}</code> observer functions</a></dt>
+  	  <dt><a href="#class-spec-statics">Class <code>{{class name}}</code> static functions</a></dt>
+	</dl>
+  </dl>
+  <dt><a href="#functions">Functions</a></dt>
+  <dl class="page-index">
+    <dt><a href="#function-spec">{{function name}}</a></dt>
+  </dl>
+  <dt><a href="#objects">Objects</a></dt>
+  <dl class="page-index">
+    <dt><a href="#object-spec">{{object name}}</a></dt>
+  </dl>
+  <dt><a href="#examples">Example(s)</a></dt>
+</dl>
+<hr>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>{{Introductory text}}</p>
+<h2><a name="macros"></a>Macros</h2>
+<p><a name="macro-spec"></a>{{Macro specifications}}</p>
+<h2><a name="values"></a>Values</h2>
+<p><a name="value-spec"></a>{{Value specifications}}</p>
+<h2><a name="types"></a>Types</h2>
+<p><a name="type-spec"></a>{{Type specifications}}</p>
+<h2><a name="classes"></a>Classes</h2>
+<h3><a name="class-spec"></a>Class <code>{{name}}</code></h3>
+<p>{{class overview text}}</p>
+<h4><a name="class-spec-synopsis"></a>Class {{name}} synopsis</h4>
+<pre>
+namespace boost
+{
+    class {{name}}
+	{
+	};
+};
+</pre>
+<h4><a name="class-spec-ctors"></a>Class {{name}} constructors and destructor</h4>
+<pre>
+{{constructor}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<pre>
+{{destructor}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<h4><a name="class-spec-comparisons"></a>Class {{name}} comparison functions</h4>
+<pre>
+{{function}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<h4><a name="class-spec-modifiers"></a>Class {{name}} modifier functions</h4>
+<pre>
+{{function}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<h4><a name="class-spec-observers"></a>Class {{name}} observer functions</h4>
+<pre>
+{{function}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<h4><a name="class-spec-statics"></a>Class {{name}} static functions</h4>
+<pre>
+{{function}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<h2><a name="functions"></a>Functions</h2>
+<pre>
+<a name="function-spec"></a>{{function}}
+</pre>
+<dl class="function-semantics"> 
+  <dt><b>Requires:</b> {{text}}</dt>
+  <dt><b>Effects:</b> {{text}}</dt>
+  <dt><b>Postconditions:</b> {{text}}</dt>
+  <dt><b>Returns:</b> {{text}}</dt>
+  <dt><b>Throws:</b> {{text}}</dt>
+  <dt><b>Complexity:</b> {{text}}</dt>
+  <dt><b>Rationale:</b> {{text}}</dt>
+</dl>
+<h2><a name="objects"></a>Objects</h2>
+<p><a name="object-spec"></a>{{Object specifications}}</p>
+<h2><a name="examples"></a>Example(s)</h2>
+<p>{{Example(s)}}</p>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2001 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/index.html b/doc/v2/index.html
new file mode 100644
index 00000000..dea1db6e
--- /dev/null
+++ b/doc/v2/index.html
@@ -0,0 +1,41 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Index</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="index">
+  <dt><a href="overview.html">Overview</a></dt>
+  <dt><a href="reference.html">Reference</a></dt>
+  <dt><a href="configuration.html">Configuration Information</a></dt>
+  <dt><a href="rationale.html">Rationale</a></dt>
+  <dt><a href="definitions.html">Definitions</a></dt>
+  <dt><a href="faq.html">Frequently Asked Questions (FAQs)</a></dt>
+  <dt><a href="bibliography.html">Bibliography</a></dt>
+  <dt><a href="acknowledgments.html">Acknowledgments</a></dt>
+</dl>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/overview.html b/doc/v2/overview.html
new file mode 100644
index 00000000..57d0e36e
--- /dev/null
+++ b/doc/v2/overview.html
@@ -0,0 +1,47 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Overview</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Overview</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="index">
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#topic1">First topic</a></dt>
+  <dt><a href="#topic2">Second topic</a></dt>
+  <dt><a href="#footnotes">Footnotes</a></dt>
+</dl>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>{{text}}</p>
+<h2><a name="topic1"></a>First Topic</h2>
+<p>{{text}}</p>
+<h2><a name="topic2"></a>Second Topic</h2>
+<p>{{text}}</p>
+<h2><a name="footnotes"></a>Footnotes</h2>
+<dl>
+  <dt><a name="footnote1" class="footnote">(1)</a> {{text}}</dt>
+  <dt><a name="footnote2" class="footnote">(2)</a> {{text}}</dt>
+</dl>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/rationale.html b/doc/v2/rationale.html
new file mode 100644
index 00000000..da7e9217
--- /dev/null
+++ b/doc/v2/rationale.html
@@ -0,0 +1,47 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Rationale</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Rationale</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<dl class="index">
+  <dt><a href="#introduction">Introduction</a></dt>
+  <dt><a href="#topic1">First topic</a></dt>
+  <dt><a href="#topic2">Second topic</a></dt>
+  <dt><a href="#footnotes">Footnotes</a></dt>
+</dl>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>{{text}}</p>
+<h2><a name="topic1"></a>First Topic</h2>
+<p>{{text}}</p>
+<h2><a name="topic2"></a>Second Topic</h2>
+<p>{{text}}</p>
+<h2><a name="footnotes"></a>Footnotes</h2>
+<dl>
+  <dt><a name="footnote1" class="footnote">(1)</a> {{text}}</dt>
+  <dt><a name="footnote2" class="footnote">(2)</a> {{text}}</dt>
+</dl>
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/reference.html b/doc/v2/reference.html
new file mode 100644
index 00000000..0aa546e5
--- /dev/null
+++ b/doc/v2/reference.html
@@ -0,0 +1,271 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - Reference</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "reference">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Reference</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="Reference">
+  <dt><a href="#high_level">High Level Components</a></dt>
+  <dt><a href="#framework">Framework Elements</a></dt>
+  <dt><a href="#utilities">Utilities</a></dt>
+  <dt><a href="#by_name">Index By Name</a></dt>
+</dl>
+
+<a name="high_level"></a><h2>High Level Components</h2>
+  <dl class="index">
+
+<a name="general_purpose"></a><h3>General Purpose</h3>
+  <dl class="index">
+
+    <dt><a href="class.html">class.hpp/class_fwd.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="class.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="class.html#class_-spec">class_</a></dt>
+	    <dt><a href="class.html#bases-spec">bases</a></dt>
+	    <dt><a href="class.html#args-spec">args</a></dt>
+	  </dl>
+
+
+	</dl>
+
+    <dt><a href="errors.html">errors.hpp</a></dt>
+	<dl class="index">
+
+      <dt><a href="errors.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="errors.html#error_already_set-spec">error_already_set</a></dt>
+	  </dl>
+      <dt><a href="errors.html#functions">Functions</a></dt>
+	  <dl class="index">
+	    <dt><a href="errors.html#handle_exception-spec">handle_exception</a></dt>
+	    <dt><a href="errors.html#expect_non_null-spec">expect_non_null</a></dt>
+	  </dl>
+	</dl>
+
+    <dt><a href="make_function.html">make_function.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="make_function.html#classes">Functions</a></dt>
+	  <dl class="index">
+	    <dt><a href="make_function.html#make_function-spec">make_function</a></dt>
+	    <dt><a href="make_.html#make_constructor-spec">make_constructor</a></dt>
+	  </dl>
+	</dl>
+
+    <dt><a href="module.html">module.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="module.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="module.html#module-spec">module</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="objects.html">objects.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="objects.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="objects.html#xxx-spec">not yet documented</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="reference_hpp.html">reference.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="reference_hpp.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="reference_hpp.html#reference-spec">reference</a></dt>
+	  </dl>
+
+      <dt><a href="reference_hpp.html#types">Types</a></dt>
+	  <dl class="index">
+	    <dt><a href="reference_hpp.html#ref-spec">ref</a></dt>
+	  </dl>
+
+	</dl>
+
+
+      </dl>
+
+<a name="type_conversion"></a><h3>To/From Python Type Conversion</h3>
+  <dl class="index">
+
+    <dt><a href="from_python.html">from_python.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="from_python.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="from_python.html#from_python-spec">from_python</a></dt>
+	  </dl>
+	</dl>
+
+    <dt><a href="to_python_converter.html">to_python_converter.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="to_python_converter.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="to_python_converter.html#to_python_converter-spec">to_python_converter</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="to_python_indirect.html">to_python_indirect.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="to_python_indirect.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="to_python_value.html">to_python_value.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="to_python_value.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="to_python_value.html#to_python_value-spec">to_python_value</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="type_from_python.html">type_from_python.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="type_from_python.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="type_from_python.html#type_from_python-spec">type_from_python</a></dt>
+	  </dl>
+
+	</dl>
+
+
+    <dt><a href="value_from_python.html">value_from_python.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="value_from_python.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="value_from_python.html#value_from_python-spec">value_from_python</a></dt>
+	  </dl>
+
+	</dl>
+
+  </dl>
+
+
+<a name="models_of_call_policies"></a><h3>Models of CallPolicies</h3>
+  <dl class="index">
+
+    <dt><a href="default_call_policies.html">default_call_policies.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="default_call_policies.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="default_call_policies.html#default_call_policies-spec">default_call_policies</a></dt>
+	    <dt><a href="default_call_policies.html#default_result_converter-spec">default_result_converter</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="return_internal_reference.html">return_internal_reference.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="return_internal_reference.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="return_value_policy.html">return_value_policy.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="return_value_policy.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="return_value_policy.html#return_value_policy-spec">return_value_policy</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="with_custodian_and_ward.html">with_custodian_and_ward.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="with_custodian_and_ward.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="with_custodian_and_ward.html#with_custodian_and_ward-spec">with_custodian_and_ward</a></dt>
+	    <dt><a href="with_custodian_and_ward.html#with_custodian_and_ward_postcall-spec">with_custodian_and_ward_postcall</a></dt>
+	  </dl>
+
+	</dl>
+
+      </dl>
+
+<a name="return_handler_generators"></a><h3>Models of ReturnHandlerGenerator</h3>
+  <dl class="index">
+
+    <dt><a href="copy_const_reference.html">copy_const_reference.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="copy_const_reference.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="copy_const_reference.html#copy_const_reference-spec">copy_const_reference</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="copy_non_const_reference.html">copy_non_const_reference.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="copy_non_const_reference.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="copy_non_const_reference.html#copy_non_const_reference-spec">copy_non_const_reference</a></dt>
+	  </dl>
+
+	</dl>
+
+
+    <dt><a href="manage_new_object.html">manage_new_object.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="manage_new_object.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="manage_new_object.html#manage_new_object-spec">manage_new_object</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="reference_existing_object.html">reference_existing_object.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="reference_existing_object.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="reference_existing_object.html#reference_existing_object-spec">reference_existing_object</a></dt>
+	  </dl>
+
+	</dl>
+
+    <dt><a href="reference_from_python.html">reference_from_python.hpp</a></dt>
+	<dl class="index">
+      <dt><a href="reference_from_python.html#classes">Classes</a></dt>
+	  <dl class="index">
+	    <dt><a href="reference_from_python.html#reference_from_python-spec">reference_from_python</a></dt>
+	    <dt><a href="reference_from_python.html#get_member-spec">get_member</a></dt>
+	  </dl>
+
+	</dl>
+
+      </dl>
+
+  </dl>
+
+<hr>
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  05 November, 2002 
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>

From 08c909fd410df8ea9d837996034e0edb6edd3dce Mon Sep 17 00:00:00 2001
From: Rene Rivera <grafikrobot@gmail.com>
Date: Thu, 14 Feb 2002 04:08:20 +0000
Subject: [PATCH 274/369] Updated the basic Jamfiles for the new Boost.Build
 changes.

[SVN r12798]
---
 build/Jamfile | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/build/Jamfile b/build/Jamfile
index 7dd6ecfe..c9f6fa75 100644
--- a/build/Jamfile
+++ b/build/Jamfile
@@ -66,7 +66,7 @@ local PYTHON_PROPERTIES = $(PYTHON_PROPERTIES) <define>BOOST_PYTHON_DYNAMIC_LIB
 #######################
 rule bpl-test ( test-name : sources + )
 {
-    boost-python-test $(test-name) : $(sources) <lib>libboost_python ;
+    boost-python-test $(test-name) : $(sources) <dll>boost_python ;
 }
 
 #######################
@@ -81,14 +81,14 @@ local CPP_SOURCES =
   init_function module_builder objects cross_module errors
   ;
 
-lib libboost_python_static : ../src/$(CPP_SOURCES).cpp
+lib boost_python_static : ../src/$(CPP_SOURCES).cpp
     # requirements
     : $(BOOST_PYTHON_INCLUDES)
     <shared-linkable>true
       <define>BOOST_PYTHON_STATIC_LIB=1
     $(PYTHON_PROPERTIES) ;
 
-dll libboost_python
+dll boost_python
   # $(SUFDLL[1])
     : ../src/$(CPP_SOURCES).cpp
 	# requirements
@@ -104,7 +104,7 @@ bpl-test boost_python_test
       : ../test/comprehensive.cpp ;
 
 boost-python-runtest comprehensive
-         : ../test/comprehensive.py <lib>boost_python_test <lib>libboost_python ;
+         : ../test/comprehensive.py <pyd>boost_python_test <dll>boost_python ;
 
 ############# simple tests from ../example ############
 
@@ -114,7 +114,7 @@ rule boost-python-example-runtest ( name )
       : ../example/$(name).cpp ;
     
     boost-python-runtest $(name)
-      : ../example/test_$(name).py <lib>$(name) ;
+      : ../example/test_$(name).py <pyd>$(name) ;
 }
 
 
@@ -139,7 +139,7 @@ bpl-test noncopyable_import : ../example/noncopyable_import.cpp ;
 rule boost-python-multi-example-runtest ( test-name : modules + )
 {
     boost-python-runtest $(test-name)
-        : ../example/tst_$(test-name).py <lib>$(modules) <lib>libboost_python
+        : ../example/tst_$(test-name).py <pyd>$(modules) <dll>boost_python
         : : : $(PYTHON_VECT_ITERATIONS) ;
 }
 

From 12c798145089290c17f101e7de8e028f8a025f48 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 14 Feb 2002 15:57:40 +0000
Subject: [PATCH 275/369] *** empty log message ***

[SVN r12805]
---
 doc/v2/class.html                             |  17 +-
 doc/v2/errors.html                            |   2 +-
 doc/v2/foo.cpp                                | 142 ------------
 doc/v2/make_function.html                     | 155 +++++++++++++
 doc/v2/manage_new_object.html                 | 115 ++++++++++
 include/boost/python/call.hpp                 | 210 ------------------
 .../python/converter/builtin_converters.hpp   |   6 +-
 .../boost/python/converter/from_python.hpp    |   1 +
 include/boost/python/module.hpp               |   4 +-
 src/converter/builtin_converters.cpp          |  28 +++
 test/test_builtin_converters.cpp              |   2 +
 test/test_builtin_converters.py               |  12 +
 12 files changed, 331 insertions(+), 363 deletions(-)
 delete mode 100644 doc/v2/foo.cpp
 create mode 100644 doc/v2/make_function.html
 create mode 100644 doc/v2/manage_new_object.html
 delete mode 100644 include/boost/python/call.hpp

diff --git a/doc/v2/class.html b/doc/v2/class.html
index e6eee244..12ad5d23 100644
--- a/doc/v2/class.html
+++ b/doc/v2/class.html
@@ -76,19 +76,24 @@ first parameter. Its template arguments are:
     <table border="1" summary="class_ template parameters">
       <tr>
         <th>Parameter
-        <th>Description
+        <th>Requirements
         <th>Default
       <tr>
         <td><code>T</code>
-        <td>The class being exposed to Python
+        <td>A class type.
       <tr>
         <td><code>Bases</code>
-        <td>An <a href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++ base classes
+
+        <td>An <a href="../../../mpl/doc/Sequences.html">MPL
+        sequence</a> of C++ base classes of <code>T</code>.
+
         <td>An unspecified empty sequence
+
       <tr>
-        <td><a href="HolderGenerator.html">HolderGenerator</a></code>
-        <td>A type generator for the holder which
-maintains the C++ object inside the Python instance. 
+        <td><code>HolderGenerator</code>
+
+        <td>A model of <code><a href="HolderGenerator.html">HolderGenerator</a></code>.
+
         <td><code>boost::python::objects::value_holder_generator</code>
       </table>
 
diff --git a/doc/v2/errors.html b/doc/v2/errors.html
index b46de25c..e0bfa89d 100644
--- a/doc/v2/errors.html
+++ b/doc/v2/errors.html
@@ -78,7 +78,7 @@ void handle_exception() throw();
 <dl class="handle_exception-semantics"> 
   <dt><b>Requires:</b> The first form requires that the expression
   <code><a
-  href="../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
+  href="../../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
   is valid. The second form requires that a C++ exception is currently
   being handled (see section 15.1 in the C++ standard).
 </dt>
diff --git a/doc/v2/foo.cpp b/doc/v2/foo.cpp
deleted file mode 100644
index e92c2d72..00000000
--- a/doc/v2/foo.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-
-#include <boost/python/module.hpp>
-#include <boost/python/class.hpp>
-#include <boost/python/copy_const_reference.hpp>
-#include <boost/python/return_value_policy.hpp>
-
-class Bar { int x; }
-
-class Foo
-{
- public:
-    Foo(int x) : b(x) {}
-    Bar const& get_bar() const { return b; }
- private:
-    Bar b;
-};
-
-using namespace boost::python;
-BOOST_PYTHON_MODULE_INIT(my_module)
-{
-    module m("my_module")
-        .add(
-            class_<Bar>()
-            )
-        .add(
-            class_<Foo>()
-                .def_init(args<int>())
-                .def("get_bar", &Foo::get_bar
-                     , return_value_policy<copy_const_reference>())
-            )
-}
-
-using namespace boost::python;
-ref foo =
-class_<Foo,bases<Bar,Baz> >()
-    .def_init(args<int,char const*>())
-    .def_init(args<double>())
-    .def("get_name", &Foo::get_name, return_internal_reference<>())
-    .def("set_name", &Foo::set_name)
-    .object();
-
-
-<blockquote><pre>
-#include &lt;string&gt;
-#include &lt;boost/python/errors.hpp&gt;
-#include &lt;boost/python/reference.hpp&gt;
-
-// Returns a std::string which has the same value as obj's "__name__"
-// attribute.
-std::string get_name(boost::python::ref obj)
-{
-    // throws if there's no __name__ attribute
-    PyObject* p = boost::python::expect_non_null(
-        PyObject_GetAttrString(obj.get(), "__name__"));
-
-    // throws if it's not a Python string
-    std::string result(
-        boost::python::expect_non_null(
-            PyString_AsString(p)));
-
-    Py_XDECREF(p); // Done with p
-    
-    return result;
-}
-
-//
-// Demonstrate form 1 of handle_exception
-//
-
-// Place a Python Int object whose value is 1 if a and b have
-// identical "__name__" attributes, 0 otherwise.
-void same_name_impl(PyObject*&amp; result, PyObject* a, PyObject* b)
-{
-    result = PyInt_FromLong(
-        get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
-}
-
-// This is an example Python 'C' API interface function
-extern "C" PyObject*
-same_name(PyObject* args, PyObject* keywords)
-{
-    PyObject* a1;
-    PyObject* a2;
-    PyObject* result = 0;
-
-    if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
-        return 0;
-    
-    // Use boost::bind to make an object compatible with
-    // boost::Function0&lt;void&gt;
-    if (boost::python::handle_exception(
-            boost::bind&lt;void&gt;(same_name_impl, boost::ref(result), a1, a2)))
-    {
-        // an exception was thrown; the Python error was set by
-        // handle_exception()
-        return 0;
-    }
-
-    return result;
-}
-
-//
-// Demonstrate form 2 of handle_exception. Not well-supported by all
-// compilers.
-//
-extern "C" PyObject*
-same_name2(PyObject* args, PyObject* keywords)
-{
-    PyObject* a1;
-    PyObject* a2;
-    PyObject* result = 0;
-
-    if (!PyArg_ParseTuple(args, const_cast&lt;char*&gt;("OO"), &amp;a1, &amp;a2))
-        return 0;
-    try {
-        return PyInt_FromLong(
-            get_name(boost::python::ref(a1)) == get_name(boost::python::ref(a2)));
-    }
-    catch(...)
-    {
-        // If an exception was thrown, translate it to Python
-        boost::python::handle_exception();
-        return 0;
-    }
-}
-
-</pre></blockquote>
-
-
-template <class T>
-struct from_python
-{
-    from_python(PyObject*);
-    bool convertible() const;
-    X operator()(PyObject*) const;
-};
diff --git a/doc/v2/make_function.html b/doc/v2/make_function.html
new file mode 100644
index 00000000..e7c4b421
--- /dev/null
+++ b/doc/v2/make_function.html
@@ -0,0 +1,155 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/make_function.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/make_function.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#introduction">Introduction</a></dt>
+
+  <dt><a href="#functions">Functions</a></dt>
+  <dl class="page-index">
+    <dt><a href="#make_function-spec">make_function</a></dt>
+    <dt><a href="#make_constructor-spec">make_constructor</a></dt>
+  </dl>
+
+  <dt><a href="#examples">Example</a></dt>
+
+</dl>
+<hr>
+<h2><a name="introduction"></a>Introduction</h2>
+<p>
+
+<code><a href="#make_function-spec">make_function</a>()</code> and
+<code><a href="#make_constructor-spec">make_constructor</a>()</code>
+are the functions used internally by <code>class_&lt;&gt;::<a
+href="class.html#class_-spec-modifiers">def</a></code>,
+<code>class_&lt;&gt;::<a
+href="module.html#module-spec-modifiers">def</a></code>,
+and
+<code>class_&lt;&gt;::<a
+href="class.html#class_-spec-modifiers">def_init</a></code>
+to produce Python callable objects which wrap C++ functions and member
+functions.
+</p>
+
+<h2><a name="functions"></a>Functions</h2>
+
+<pre>
+<a name="make_function-spec">template &lt;class F&gt;
+objects::function* make_function(F f)&lt;/a&gt;
+
+template &lt;class F, class Policies&gt;
+objects::function* make_function(F f, Policies const&amp; policies)
+</pre>
+<dl class="function-semantics"> 
+
+  <dt><b>Requires:</b> <code>F</code> is a function pointer or member
+  function pointer type</dt>
+
+  <dt><b>Effects:</b> Creates a Python callable object which, when
+  called from Python, converts its arguments to C++ and calls
+  <code>f</code>. If <code>F</code> is a pointer-to-member-function
+  type, the target object of the function call (<code>*this</code>)
+  will be taken from the first Python argument, and subsequent Python
+  arguments will be used as the arguments to <code>f</code>. If
+  <code>policies</code> are supplied, it must be a model of <a
+  href="CallPolicies.html">CallPolicies</a>, and will be applied to
+  the function as described <a href="CallPolicies.html">here</a>.</dt>
+
+  <dt><b>Returns:</b> A pointer convertible to <code>PyObject*</code>
+  which refers to the new Python callable object.</dt>
+</dl>
+
+<pre>
+<a name="make_constructor-spec">template &lt;class T, class ArgList, class Generator&gt;
+objects::function* make_constructor();</a>
+</pre>
+<dl class="make_constructor-semantics"> 
+
+  <dt><b>Requires:</b> <code>T</code> is a class
+  type. <code>ArgList</code> is an <a
+  href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++
+  argument types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
+  <code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
+  <i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression
+  <code>new Generator::apply&lt;T&gt;::type(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>) is
+  valid. Generator is a model of <a
+  href="HolderGenerator.html">HolderGenerator</a>.
+</dt>
+
+  <dt><b>Effects:</b> Creates a Python callable object which, when
+  called from Python, expects its first argument to be a Boost.Python
+  extension class object. It converts its remaining its arguments to
+  C++ and passes them to the constructor of a dynamically-allocated
+  <code>Generator::apply&lt;T&gt;::type</code> object. The result is
+  installed in the extension class object.
+
+</dt>
+
+  <dt><b>Returns:</b> The new Python callable object</dt>
+
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p>C++ function exposed below returns a callable object wrapping one
+of two functions.
+
+<pre>
+#include &lt;boost/python/make_function.hpp&gt;
+#include &lt;boost/python/module.hpp&gt;
+
+char const* foo() { return "foo"; }
+char const* bar() { return "bar"; }
+
+PyObject* choose_function(bool selector)
+{
+    if (selector)
+        return boost::python::make_function(foo);
+    else
+        return boost::python::make_function(bar);
+}
+
+BOOST_PYTHON_MODULE_INIT(make_function_test)
+{
+    module("make_function_test")
+        .def("choose_function", choose_function);
+}
+</pre>
+</p>
+It can be used this way in Python:
+<pre>
+&gt;&gt;&gt; from make_function_test import *
+&gt;&gt;&gt; f = choose_function(1)
+&gt;&gt;&gt; g = choose_function(0)
+&gt;&gt;&gt; f()
+'foo'
+&gt;&gt;&gt; g()
+'bar'
+</pre>
+
+<p>
+<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+14 February 2002
+<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/doc/v2/manage_new_object.html b/doc/v2/manage_new_object.html
new file mode 100644
index 00000000..cc5aab2a
--- /dev/null
+++ b/doc/v2/manage_new_object.html
@@ -0,0 +1,115 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/manage_new_object.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/manage_new_object.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+    <dt><a href="#manage_new_object-spec">Class <code>manage_new_object</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#manage_new_object-spec-synopsis">Class <code>manage_new_object</code> synopsis</a></dt>
+	  <dt><a href="#manage_new_object-spec-metafunctions">Class <code>manage_new_object</code> metafunctions</a></dt>
+	</dl>
+  </dl>
+
+  <dt><a href="#examples">Example</a></dt>
+</dl>
+<hr>
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="manage_new_object-spec"></a>Class <code>manage_new_object</code></h3>
+<p>
+<code>manage_new_object</code> is a model of <a
+href="ResultConverterGenerator.html">ResultConverterGenerator</a>
+which can be used to wrap C++ functions which return a pointer to an
+object allocated with a <i>new-expression</i>, and expect the caller
+to take responsibility for deleting that object.
+</p>
+
+<h4><a name="manage_new_object-spec-synopsis"></a>Class <code>manage_new_object</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    struct manage_new_object
+    {
+        template &lt;class T&gt; struct apply;
+    };
+}}
+</pre>
+<h4><a name="manage_new_object-spec-metafunctions"></a>Class <code>manage_new_object</code> metafunctions</h4>
+<pre>
+template &lt;class T&gt; struct apply
+</pre>
+<dl class="metafunction-semantics"> 
+  <dt><b>Requires:</b> <code>T</code> is <code>U*</code> for some <code>U</code>.</dt>
+  <dt><b>Returns:</b> <code>typedef <a href="to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T&gt; type;</code></dt>
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p> In C++:
+
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/manage_new_object.hpp&gt;
+#include &lt;boost/python/return_value_policy.hpp&gt;
+
+
+struct Foo {
+   Foo(int x) : x(x){}
+   int get_x() { return x; }
+   int x;
+};
+
+Foo* make_foo(int x) { return new Foo(x); }
+
+// Wrapper code
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(my_module)
+{
+   module m("my_module")
+      .def(&quot;make_foo&quot;, make_foo)
+      .add(
+         class_&lt;Foo&gt;()
+            .def(&quot;get_x&quot;, &amp;Foo::get_x)
+         )
+}
+</pre>
+
+In Python:
+
+<pre>
+&gt;&gt;&gt; from my_module import *
+&gt;&gt;&gt; f = make_foo(3)     # create a Foo object
+&gt;&gt;&gt; f.get_x()
+3
+</pre>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  14 February 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>
diff --git a/include/boost/python/call.hpp b/include/boost/python/call.hpp
deleted file mode 100644
index b95a31d5..00000000
--- a/include/boost/python/call.hpp
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-//
-//  This work was funded in part by Lawrence Berkeley National Labs
-//
-//  This file generated for 5-argument member functions and 6-argument free
-//  functions by gen_call.py
-
-#ifndef CALL_DWA20011214_HPP
-# define CALL_DWA20011214_HPP
-
-# include <boost/python/detail/returning.hpp>
-
-namespace boost { namespace python { 
-
-template <class R>
-inline PyObject* call(R (*f)(), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-inline PyObject* call(R (*f)(A0), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-inline PyObject* call(R (*f)(A0, A1), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-inline PyObject* call(R (*f)(A0, A1, A2), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-inline PyObject* call(R (*f)(A0, A1, A2, A3), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-inline PyObject* call(R (*f)(A0, A1, A2, A3, A4), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-inline PyObject* call(R (*f)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-// Member functions
-template <class R, class A0>
-inline PyObject* call(R (A0::*f)(), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-inline PyObject* call(R (A0::*f)(A1), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-inline PyObject* call(R (A0::*f)(A1, A2), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-inline PyObject* call(R (A0::*f)(A1, A2, A3), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5), PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-inline PyObject* call(R (A0::*f)() const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-inline PyObject* call(R (A0::*f)(A1) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-inline PyObject* call(R (A0::*f)(A1, A2) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-inline PyObject* call(R (A0::*f)(A1, A2, A3) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-inline PyObject* call(R (A0::*f)() volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-inline PyObject* call(R (A0::*f)(A1) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-inline PyObject* call(R (A0::*f)(A1, A2) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-inline PyObject* call(R (A0::*f)(A1, A2, A3) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0>
-inline PyObject* call(R (A0::*f)() const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1>
-inline PyObject* call(R (A0::*f)(A1) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2>
-inline PyObject* call(R (A0::*f)(A1, A2) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3>
-inline PyObject* call(R (A0::*f)(A1, A2, A3) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-template <class R, class A0, class A1, class A2, class A3, class A4, class A5>
-inline PyObject* call(R (A0::*f)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject* keywords)
-{
-    return detail::returning<R>::call(f, args, keywords);
-}
-
-
-}} // namespace boost::python
-
-#endif // CALL_DWA20011214_HPP
-
diff --git a/include/boost/python/converter/builtin_converters.hpp b/include/boost/python/converter/builtin_converters.hpp
index a21fd27b..8293b0a7 100644
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -6,6 +6,7 @@
 #ifndef BUILTIN_CONVERTERS_DWA2002124_HPP
 # define BUILTIN_CONVERTERS_DWA2002124_HPP
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/detail/none.hpp>
 # include <string>
 
 namespace boost { namespace python {
@@ -44,18 +45,19 @@ namespace detail
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, PyInt_FromLong(x))
 
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(bool, PyInt_FromLong(x))
 BOOST_PYTHON_TO_INT(char)
 BOOST_PYTHON_TO_INT(short)
 BOOST_PYTHON_TO_INT(int)
 BOOST_PYTHON_TO_INT(long)
 # undef BOOST_TO_PYTHON_INT
 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, PyString_FromString(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, x ? PyString_FromString(x) : detail::none())
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x ? x : detail::none())
 
 namespace converter
 { 
diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index ee16a741..b6e1edc4 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -13,6 +13,7 @@
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/utility.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index 1d4fdd6d..11b0b6c7 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -30,7 +30,7 @@ class BOOST_PYTHON_DECL module_base
     void add_type(ref);
     
     // Return a reference to the Python module object being built
-    ref module() const;
+    ref object() const;
 
  private:
     ref m_module;
@@ -76,7 +76,7 @@ class module : public module_base
 //
 // inline implementations
 //
-inline ref module_base::module() const
+inline ref module_base::object() const
 {
     return m_module;
 }
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 33e1cb50..9cf5f110 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -150,6 +150,31 @@ namespace
       }
   };
 
+  extern "C" PyObject* identity_unaryfunc(PyObject* x)
+  {
+      Py_INCREF(x);
+      return x;
+  }
+  
+  unaryfunc non_null = identity_unaryfunc;
+  
+  struct convertible_to_bool
+  {
+      static unaryfunc* execute(PyObject* obj)
+      {
+          return &non_null;
+      }
+  };
+
+  struct py_object_as_bool
+  {
+      static bool execute(PyObject* obj)
+      {
+          return PyObject_IsTrue(obj);
+      }
+  };
+
+  
   struct convertible_to_double
   {
       static unaryfunc* execute(PyObject* obj)
@@ -203,6 +228,9 @@ namespace
 
 void initialize_builtin_converters()
 {
+    static scalar_from_python<
+        bool, convertible_to_bool, py_object_as_bool> bool_from_python;
+    
     REGISTER_INT_CONVERTERS2(char);
     REGISTER_INT_CONVERTERS2(short);
     REGISTER_INT_CONVERTERS2(int);
diff --git a/test/test_builtin_converters.cpp b/test/test_builtin_converters.cpp
index 7e21e046..f95ebe2b 100644
--- a/test/test_builtin_converters.cpp
+++ b/test/test_builtin_converters.cpp
@@ -29,6 +29,7 @@ BOOST_PYTHON_MODULE_INIT(builtin_converters_ext)
 {
     boost::python::module("builtin_converters_ext")
         
+        .def("rewrap_value_bool", by_value<bool>::rewrap)
         .def("rewrap_value_signed_char", by_value<signed char>::rewrap)
         .def("rewrap_value_unsigned_char", by_value<unsigned char>::rewrap)
         .def("rewrap_value_int", by_value<int>::rewrap)
@@ -44,6 +45,7 @@ BOOST_PYTHON_MODULE_INIT(builtin_converters_ext)
         .def("rewrap_value_cstring", by_value<char const*>::rewrap)
 
 
+        .def("rewrap_const_reference_bool", by_const_reference<bool>::rewrap)
         .def("rewrap_const_reference_signed_char", by_const_reference<signed char>::rewrap)
         .def("rewrap_const_reference_unsigned_char", by_const_reference<unsigned char>::rewrap)
         .def("rewrap_const_reference_int", by_const_reference<int>::rewrap)
diff --git a/test/test_builtin_converters.py b/test/test_builtin_converters.py
index 3941a29c..50b58ce6 100644
--- a/test/test_builtin_converters.py
+++ b/test/test_builtin_converters.py
@@ -1,5 +1,11 @@
 """
 >>> from builtin_converters_ext import *
+>>> rewrap_value_bool(None)
+0
+>>> rewrap_value_bool(0)
+0
+>>> rewrap_value_bool(33)
+1
 >>> rewrap_value_signed_char(42)
 42
 >>> rewrap_value_unsigned_char(42)
@@ -29,6 +35,12 @@
 >>> rewrap_value_string('yo, wassup?')
 'yo, wassup?'
 
+>>> rewrap_const_reference_bool(None)
+0
+>>> rewrap_const_reference_bool(0)
+0
+>>> rewrap_const_reference_bool('yes')
+1
 >>> rewrap_const_reference_signed_char(42)
 42
 >>> rewrap_const_reference_unsigned_char(42)

From 586b4db968d0951682125a9c8f8afc95192f1395 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 14 Feb 2002 18:12:50 +0000
Subject: [PATCH 276/369] initial checkin

[SVN r12807]
---
 doc/v2/module.html | 258 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 258 insertions(+)
 create mode 100644 doc/v2/module.html

diff --git a/doc/v2/module.html b/doc/v2/module.html
new file mode 100644
index 00000000..f39ff4e8
--- /dev/null
+++ b/doc/v2/module.html
@@ -0,0 +1,258 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/module.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;boost/python/module.hpp&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+      <dt><a href="#macros">Macros</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href=
+          "#BOOST_PYTHON_MODULE_INIT-spec">BOOST_PYTHON_MODULE_INIT</a>
+        </dl>
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#module-spec">Class <code>module</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#module-spec-synopsis">Class <code>module</code>
+              synopsis</a>
+
+              <dt><a href="#module-spec-ctors">Class <code>module</code>
+              constructor</a>
+
+              <dt><a href="#module-spec-modifiers">Class <code>module</code>
+              modifier functions</a>
+
+              <dt><a href="#module-spec-observers">Class <code>module</code>
+              observer functions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example(s)</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <p>{{Introductory text}}
+
+    <h2><a name="macros"></a>Macros</h2>
+
+    <p><a name=
+    "BOOST_PYTHON_MODULE_INIT-spec"><code>BOOST_PYTHON_MODULE_INIT(name)</code></a>
+    is used to declare Python <a href=
+    "http://www.python.org/doc/current/ext/methodTable.html#SECTION003400000000000000000">
+    module initialization functions</a>. The <code>name</code> argument must
+    exactly match the name of the module to be initialized, and must conform to
+    Python's <a href=
+    "http://www.python.org/doc/current/ref/identifiers.html">identifier naming
+    rules</a>. Where you would normally write
+<pre>
+void init<i>name</i>()
+{
+   ...
+</pre>
+    Boost.Python modules should be initialized with 
+<pre>
+BOOST_PYTHON_MODULE_INIT(<i>name</i>)
+{
+   ...
+</pre>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="module-spec">Class <code>module</code></a></h3>
+
+    <p>This class represents the Python extension module under construction. It
+    provides functions for adding attributes and for retrieving the underlying
+    Python module object.
+
+    <h4><a name="module-spec-synopsis"></a>Class <code>module</code>
+    synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+  class module : public module_base
+  {
+   public:
+      module(const char* name);
+
+      // modifier functions
+      module&amp; setattr(const char* name, PyObject*);
+      module&amp; setattr(const char* name, PyTypeObject*);
+      module&amp; setattr(const char* name, ref const&amp;);
+
+      module&amp; add(PyTypeObject* x);
+      template &lt;class T, class Bases, class HolderGenerator&gt;
+      module&amp; add(class_&lt;T,Bases,HolderGenerator&gt; const&amp; c);
+
+      template &lt;class Fn&gt;
+      module&amp; def(char const* name, Fn fn);
+      template &lt;class Fn, class ResultHandler&gt;
+      module&amp; def(char const* name, Fn fn, ResultHandler handler);
+
+      // observer function
+      ref object() const;
+  };
+
+}}
+</pre>
+
+    <h4><a name="module-spec-ctors">Class <code>module</code></a>
+    constructor</h4>
+<pre>
+module(const char* name);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>name</code> is a ntbs whose value matches the
+      argument passed to <a href=
+      "#BOOST_PYTHON_MODULE_INIT-spec">BOOST_PYTHON_MODULE_INIT</a>.
+
+      <dt><b>Effects:</b> Creates a <code>module</code> object representing a
+      Python module named <code>name</code>.
+    </dl>
+
+    <h4><a name="module-spec-modifiers">Class <code>module</code></a> modifier
+    functions</h4>
+<pre>
+module&amp; setattr(const char* name, PyObject* obj);
+module&amp; setattr(const char* name, PyTypeObject* obj);
+module&amp; setattr(const char* name, ref const&amp; r);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>name</code> is a ntbs which conforms to
+      Python's <a href=
+      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      naming rules</a>. In the first two forms, <code>obj</code> is non-null.
+      In the third form, <code>r.get()</code> is non-null.
+
+      <dt><b>Effects:</b> Adds the given Python object to the module. If the
+      object is a product of <code><a href=
+      "make_function.html#make_function-spec">make_function</a>()</code>, the
+      usual <a href="http:overloading.html">overloading procedure</a> applies.
+      In the first two forms, ownership of a reference to obj is transferred
+      from caller to callee, even if an exception is thrown.
+
+      <dt><b>Returns:</b> <code>*this</code>
+    </dl>
+<pre>
+module&amp; add(PyTypeObject* x);
+
+template &lt;class T, class Bases, class HolderGenerator&gt;
+module&amp; add(class_&lt;T,Bases,HolderGenerator&gt; const&amp; c);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> In the first form, <code>x</code> is non-null
+
+      <dt><b>Effects:</b> The first form adds the Python type object named by
+      <code>x</code> to the Python module under construction, with the name
+      given by the type's <code><a href=
+      "http://www.python.org/doc/current/ext/dnt-type-methods.html">tp_name</a></code>
+      field. The second form adds the extension class object being constructed
+      by <code>c</code> to the module, with the same name that was passed to
+      <code>c</code>'s constructor.
+
+      <dt><b>Returns:</b> <code>*this</code>
+
+      <dt><b>Rationale:</b> Provides a way to set type attributes in the module
+      without having to explicitly specify the name.
+    </dl>
+<pre>
+template &lt;class Fn&gt;
+module&amp; def(char const* name, Fn fn);
+
+template &lt;class Fn, class ResultHandler&gt;
+module&amp; def(char const* name, Fn fn, ResultHandler handler);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>f</code> is a non-null pointer-to-function or
+      pointer-to-member-function. <code>name</code> is a ntbs which conforms to
+      Python's <a href=
+      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      naming rules</a>. If supplied, <code>policy</code> conforms to the <a
+      href="CallPolicy.html">CallPolicy</a> concept requirements.
+
+      <dt><b>Effects:</b> Adds the result of <code><a href=
+      "make_function.html#make_function-spec">make_function</a>(f)</code> to
+      the extension module being defined, with the given <code>name</code>. If
+      the module already has an attribute named <code><i>name</i></code>, the
+      usual <a href="http:overloading.html">overloading procedure</a> applies.
+
+      <dt><b>Returns:</b> <code>*this</code>
+    </dl>
+
+    <h4><a name="module-spec-observers">Class <code>module</code></a> observer
+    functions</h4>
+<pre>
+ref object() const;
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> A <code>ref</code> object which holds a reference to
+      the Python module object created by the <code>module</code> constructor.
+    </dl>
+
+    <h2><a name="examples"></a>Example(s)</h2>
+
+    <p>C++ module definition:
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+
+char const* greet()
+{
+    return "hello, Boost.Python!";
+}
+
+BOOST_PYTHON_MODULE_INIT(boost_greet)
+{
+    module("boost_greet")
+        .def("greet", greet);
+}
+</pre>
+
+Interactive Python: 
+<pre>
+&gt;&gt;&gt; import boost_greet
+&gt;&gt;&gt; boost_greet.greet()
+'hello, Boost.Python!'
+</pre>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     14 February, 2002
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From ebc641440e076f581021621e2a4e809307e4f44b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 14 Feb 2002 19:44:11 +0000
Subject: [PATCH 277/369] initial checkin

[SVN r12808]
---
 doc/v2/reference_existing_object.html | 152 ++++++++++++++++++++++++++
 1 file changed, 152 insertions(+)
 create mode 100644 doc/v2/reference_existing_object.html

diff --git a/doc/v2/reference_existing_object.html b/doc/v2/reference_existing_object.html
new file mode 100644
index 00000000..3d19826a
--- /dev/null
+++ b/doc/v2/reference_existing_object.html
@@ -0,0 +1,152 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+<link rel="stylesheet" type="text/css" href="../boost.css">
+<title>Boost.Python - &lt;boost/python/reference_existing_object.hpp&gt;</title>
+</head>
+<body link="#0000ff" vlink="#800080">
+<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+  <tr> 
+    <td valign="top" width="300"> 
+      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+    </td>
+    <td valign="top"> 
+      <h1 align="center">Boost.Python</h1>
+      <h2 align="center">Header &lt;boost/python/reference_existing_object.hpp&gt;</h2>
+    </td>
+  </tr>
+</table>
+<hr>
+<h2>Contents</h2>
+<dl class="page-index"> 
+  <dt><a href="#classes">Classes</a></dt>
+  <dl class="page-index">
+    <dt><a href="#reference_existing_object-spec">Class <code>reference_existing_object</code></a></dt>
+	<dl class="page-index">
+	  <dt><a href="#reference_existing_object-spec-synopsis">Class <code>reference_existing_object</code> synopsis</a></dt>
+	  <dt><a href="#reference_existing_object-spec-metafunctions">Class <code>reference_existing_object</code> metafunctions</a></dt>
+	</dl>
+  </dl>
+
+  <dt><a href="#examples">Example</a></dt>
+</dl>
+<hr>
+
+<h2><a name="classes"></a>Classes</h2>
+
+<h3><a name="reference_existing_object-spec"></a>Class <code>reference_existing_object</code></h3>
+<p>
+<code>reference_existing_object</code> is a model of <a
+href="ResultConverterGenerator.html">ResultConverterGenerator</a>
+which can be used to wrap C++ functions which return a reference or
+pointer to a C++ object. When the wrapped function is called, the
+value referenced by its return value is not copied. A new Python
+object is created which contains a pointer to the referent, and no
+attempt is made to ensure that the lifetime of the referent is at
+least as long as that of the corresponding Python object. Thus, it can
+be <font color="#ff0000"><b>highly dangerous</b></font> to use
+<code>reference_existing_object</code> without additional lifetime
+management from such models of <a
+href="CallPolicies.html">CallPolicies</a> as <a
+href="with_custodian_and_ward.html#with_custodian_and_ward-spec"
+>with_custodian_and_ward</a>. This class is used in the implementation
+of <a
+href="return_internal_reference.html#return_internal_reference-spec"
+>return_internal_reference</a>.
+</p>
+
+<h4><a name="reference_existing_object-spec-synopsis"></a>Class <code>reference_existing_object</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+    struct reference_existing_object
+    {
+        template &lt;class T&gt; struct apply;
+    };
+}}
+</pre>
+<h4><a name="reference_existing_object-spec-metafunctions"></a>Class <code>reference_existing_object</code> metafunctions</h4>
+<pre>
+template &lt;class T&gt; struct apply
+</pre>
+<dl class="metafunction-semantics"> 
+  <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> or <code>U*</code>for some <code>U</code>.</dt>
+
+  <dt><b>Returns:</b> <code>typedef <a
+  href="to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T,V&gt;
+  type</code>, where <code>V</code> is a <a
+  href="to_python_indirect.html#HolderObjectGenerator"> which
+  constructs an instance holder containing an <i>unowned</i>
+  <code>U*</code> pointing to the referent of the wrapped function's
+  return value.</dt>
+
+</dl>
+
+<h2><a name="examples"></a>Example</h2>
+
+<p> In C++:
+
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/reference_existing_object.hpp&gt;
+#include &lt;boost/python/return_value_policy.hpp&gt;
+#include &lt;utility&gt;
+
+// classes to wrap
+struct Singleton
+{
+   Singleton() : x(0) {}
+
+   int exchange(int n)  // set x and return the old value
+   {
+        std::swap(n, x);
+        return n;
+   }
+
+   int x;
+};
+
+Singleton&amp; get_it()
+{
+   static Singleton just_one;
+   return just_one;
+}
+
+// Wrapper code
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(singleton)
+{
+   module m("singleton")
+      .def(&quot;get_it&quot;, get_it)
+      .add(
+         class_&lt;Singleton&gt;()
+            .def(&quot;exchange&quot;, &amp;Singleton::exchange)
+         );
+}
+</pre>
+
+In Python:
+
+<pre>
+&gt;&gt;&gt; import singleton
+&gt;&gt;&gt; s1 = singleton.get_it()  
+&gt;&gt;&gt; s2 = singleton.get_it()
+&gt;&gt;&gt; id(s1) == id(s2)  # s1 and s2 are not the same object
+0
+&gt;&gt;&gt; s1.exchange(42)   # but they reference the same C++ Singleton
+0
+&gt;&gt;&gt; s2.exchange(99)
+42
+</pre>
+
+<p>Revised 
+  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+  14 February 2002
+  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+</p>
+<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
+  2002. All Rights Reserved.</i></p>
+</body>
+</html>

From 70bb30b95af551390c3d9f5702dad1d6122b7386 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 14 Feb 2002 20:09:51 +0000
Subject: [PATCH 278/369] Tidy

[SVN r12810]
---
 doc/v2/class.html                     | 389 ++++++++--------
 doc/v2/copy_const_reference.html      | 136 +++---
 doc/v2/copy_non_const_reference.html  | 136 +++---
 doc/v2/default_call_policies.html     | 208 +++++----
 doc/v2/errors.html                    | 223 ++++-----
 doc/v2/from_python.html               | 204 ++++----
 doc/v2/header.html                    | 418 +++++++++++------
 doc/v2/make_function.html             | 191 ++++----
 doc/v2/manage_new_object.html         | 141 +++---
 doc/v2/reference.html                 | 640 +++++++++++++++-----------
 doc/v2/reference_existing_object.html | 173 +++----
 11 files changed, 1588 insertions(+), 1271 deletions(-)

diff --git a/doc/v2/class.html b/doc/v2/class.html
index 12ad5d23..85e24993 100644
--- a/doc/v2/class.html
+++ b/doc/v2/class.html
@@ -1,105 +1,127 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/class.hpp&gt;, &lt;boost/python/class_fwd.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/class.hpp&gt;,
+    &lt;boost/python/class_fwd.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Headers &lt;boost/python/class.hpp&gt;, &lt;boost/python/class_fwd.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#introduction">Introduction</a></dt>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#classes">Classes</a></dt>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-  <dl class="page-index">
+          <h2 align="center">Headers &lt;boost/python/class.hpp&gt;,
+          &lt;boost/python/class_fwd.hpp&gt;</h2>
+    </table>
+    <hr>
 
-    <dt><a href="#class_-spec">Class template <code>class_</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#class_-spec-synopsis">Class <code>class_</code> synopsis</a></dt>
-	  <dt><a href="#class_-spec-ctors">Class <code>class_</code> constructors</a></dt>
-  	  <dt><a href="#class_-spec-modifiers">Class <code>class_</code> modifier functions</a></dt>
-  	  <dt><a href="#class_-spec-observers">Class <code>class_</code> observer functions</a></dt>
-	</dl>
+    <h2>Contents</h2>
 
-    <dt><a href="#bases-spec">Class template <code>bases</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#bases-spec-synopsis">Class <code>bases</code> synopsis</a></dt>
-	</dl>
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
 
-    <dt><a href="#args-spec">Class template <code>args</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#args-spec-synopsis">Class <code>args</code> synopsis</a></dt>
-	</dl>
+      <dt><a href="#classes">Classes</a>
 
-  </dl>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#class_-spec">Class template <code>class_</code></a>
 
-  <dt><a href="#examples">Example(s)</a></dt>
-</dl>
-<hr>
-<h2><a name="introduction"></a>Introduction</h2>
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#class_-spec-synopsis">Class <code>class_</code>
+              synopsis</a>
 
-  <p><code>&lt;boost/python/class.hpp&gt;</code> defines the interface through
-  which users expose their C++ classes to Python. It declares the
-  <code>class_</code> class template, which is parameterized on the
-  class type being exposed, and the <code>args</code> and
-  <code>bases</code> utility class templates in the anonymous
-  namespace (the latter definitions will probably be moved in a future
-  release).
+              <dt><a href="#class_-spec-ctors">Class <code>class_</code>
+              constructors</a>
 
-  <p>
-  <code>&lt;boost/python/class_fwd.hpp&gt;</code>  contains a forward
-  declaration of the <code>class_</code> class template.
+              <dt><a href="#class_-spec-modifiers">Class <code>class_</code>
+              modifier functions</a>
+
+              <dt><a href="#class_-spec-observers">Class <code>class_</code>
+              observer functions</a>
+            </dl>
+
+          <dt><a href="#bases-spec">Class template <code>bases</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#bases-spec-synopsis">Class <code>bases</code>
+              synopsis</a>
+            </dl>
+
+          <dt><a href="#args-spec">Class template <code>args</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#args-spec-synopsis">Class <code>args</code>
+              synopsis</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example(s)</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <p><code>&lt;boost/python/class.hpp&gt;</code> defines the interface
+    through which users expose their C++ classes to Python. It declares the
+    <code>class_</code> class template, which is parameterized on the class
+    type being exposed, and the <code>args</code> and <code>bases</code>
+    utility class templates in the anonymous namespace (the latter definitions
+    will probably be moved in a future release).
+
+    <p><code>&lt;boost/python/class_fwd.hpp&gt;</code> contains a forward
+    declaration of the <code>class_</code> class template.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="class_-spec"></a>Class template <code>class_&lt;T, Bases, <a
+    href="HolderGenerator.html">HolderGenerator</a>&gt;</code></h3>
+
+    <p>Creates a Python class associated with the C++ type passed as its first
+    parameter. Its template arguments are:<br>
+    <br>
 
 
-<h2><a name="classes"></a>Classes</h2>
-
-<h3><a name="class_-spec">
-</a>Class template <code>class_&lt;T,&nbsp;Bases,&nbsp;<a
- href="HolderGenerator.html">HolderGenerator</a>&gt;</code></h3>
-
-<p>Creates a Python class associated with the C++ type passed as its
-first parameter. Its template arguments are:
-<br><br>
     <table border="1" summary="class_ template parameters">
       <tr>
         <th>Parameter
-        <th>Requirements
-        <th>Default
-      <tr>
-        <td><code>T</code>
-        <td>A class type.
-      <tr>
-        <td><code>Bases</code>
 
-        <td>An <a href="../../../mpl/doc/Sequences.html">MPL
-        sequence</a> of C++ base classes of <code>T</code>.
+        <th>Requirements
+
+        <th>Default
+
+      <tr>
+        <td><code>T</code> 
+
+        <td>A class type.
+
+      <tr>
+        <td><code>Bases</code> 
+
+        <td>An <a href="../../../mpl/doc/Sequences.html">MPL sequence</a> of
+        C++ base classes of <code>T</code>.
 
         <td>An unspecified empty sequence
 
       <tr>
-        <td><code>HolderGenerator</code>
+        <td><code>HolderGenerator</code> 
 
-        <td>A model of <code><a href="HolderGenerator.html">HolderGenerator</a></code>.
+        <td>A model of <code><a href=
+        "HolderGenerator.html">HolderGenerator</a></code>.
 
-        <td><code>boost::python::objects::value_holder_generator</code>
-      </table>
+        <td><code>boost::python::objects::value_holder_generator</code> 
+    </table>
 
-
-
-<h4><a name="class_-spec-synopsis"></a>Class template <code>class_</code> synopsis</h4>
+    <h4><a name="class_-spec-synopsis"></a>Class template <code>class_</code>
+    synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -128,44 +150,42 @@ namespace boost { namespace python
 }}
 </pre>
 
-<h4><a name="class_-spec-ctors"></a>Class template <code>class_</code> constructors</h4>
+    <h4><a name="class_-spec-ctors"></a>Class template <code>class_</code>
+    constructors</h4>
 <pre>
 class_()
 </pre>
-<dl class="function-semantics"> 
 
-  <dt><b>Requires:</b> The platform's
-  <code>std::type_info::name()</code> implementation produces a string
-  which corresponds to the type's declaration in C++</dt>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> The platform's <code>std::type_info::name()</code>
+      implementation produces a string which corresponds to the type's
+      declaration in C++
 
-  <dt><b>Effects:</b> Constructs a <code>class_</code> object which
-  generates a Boost.Python extension class with the same name as
-  <code>T</code>.</dt>
-
-  <dt><b>Rationale:</b> Many platforms can generate reasonable names
-  for Python classes without user intervention.</dt>
-
-</dl>
+      <dt><b>Effects:</b> Constructs a <code>class_</code> object which
+      generates a Boost.Python extension class with the same name as
+      <code>T</code>.
 
+      <dt><b>Rationale:</b> Many platforms can generate reasonable names for
+      Python classes without user intervention.
+    </dl>
 <pre>
 class_(char const* name)
 </pre>
-<dl class="function-semantics"> 
 
-  <dt><b>Requires:</b> Name is a ntbs which conforms to Python's <a
-  href="http://www.python.org/doc/current/ref/identifiers.html">identifier
-  naming rules</a>.</dt>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>name</code> is a ntbs which conforms to
+      Python's <a href=
+      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      naming rules</a>.
 
-  <dt><b>Effects:</b> Constructs a <code>class_</code> object which
-  generates a Boost.Python extension class named
-  <code>name</code>.</dt>
+      <dt><b>Effects:</b> Constructs a <code>class_</code> object which
+      generates a Boost.Python extension class named <code>name</code>.
 
-  <dt><b>Rationale:</b> Gives the user full control over class naming.</dt>
-
-</dl>
-
-<h4><a name="class_-spec-modifiers"></a>Class template <code>class_</code> modifier functions</h4>
+      <dt><b>Rationale:</b> Gives the user full control over class naming.
+    </dl>
 
+    <h4><a name="class_-spec-modifiers"></a>Class template <code>class_</code>
+    modifier functions</h4>
 <pre>
 template &lt;class F&gt;
 class_&amp; def(char const* name, F f)
@@ -174,32 +194,23 @@ template &lt;class Fn, class CallPolicy&gt;
 class_&amp; def(char const* name, Fn fn, CallPolicy policy)
 </pre>
 
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>f</code> is a non-null pointer-to-function or
+      pointer-to-member-function. <code>name</code> is a ntbs which conforms to
+      Python's <a href=
+      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      naming rules</a>. If supplied, <code>policy</code> conforms to the <a
+      href="CallPolicy.html">CallPolicy</a> concept requirements.
 
-    <code>f</code> is a non-null pointer-to-function or
-    pointer-to-member-function.
-
-    <code>name</code> is a ntbs which conforms to Python's <a
-    href="http://www.python.org/doc/current/ref/identifiers.html">identifier
-    naming rules</a>.
-
-    If supplied, <code>policy</code> conforms to the <a
-    href="CallPolicy.html">CallPolicy</a> concept requirements.
-</dt>
-
-  <dt><b>Effects:</b> Adds the result of <code><a
-  href="make_function.html#make_function-spec">make_function</a>(f)</code>
-  to the Boost.Python extension class being defined, with the given
-  <code>name</code>. If the extension class already has an attribute
-  named <code><i>name</i></code>, the usual <a
-  href="http:overloading.html">overloading procedure</a> applies.
-
-  </dt>
-
-  <dt><b>Returns:</b> <code>*this</code></dt>
-</dl>
+      <dt><b>Effects:</b> Adds the result of <code><a href=
+      "make_function.html#make_function-spec">make_function</a>(f)</code> to
+      the Boost.Python extension class being defined, with the given
+      <code>name</code>. If the extension class already has an attribute named
+      <code><i>name</i></code>, the usual <a href=
+      "http:overloading.html">overloading procedure</a> applies.
 
+      <dt><b>Returns:</b> <code>*this</code>
+    </dl>
 <pre>
 template &lt;class Args&gt;
 class_&amp; def_init(Args const&amp; argument_types)
@@ -207,61 +218,56 @@ class_&amp; def_init(Args const&amp; argument_types)
 class_&amp; def_init()
 </pre>
 
-<dl class="function-semantics"> 
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> in the first form, argument_types must be an <a
+      href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++ argument
+      types (<i>A1, A2,... AN</i>) such that if
+      <code>a1, a2</code>... <code>aN</code> are objects of type
+      <i>A1, A2,... AN</i> respectively, the expression
+      <code>T(a1, a2</code>... <code>aN</code>) is valid. In the second form,
+      the expression <code>T()</code> must be valid.
 
-  <dt><b>Requires:</b> in the first form, argument_types must be an <a
-  href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++
-  argument types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
-  <code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
-  <i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression
-  <code>T(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>) is
-  valid. In the second form, the expression <code>T()</code> must be
-  valid.
-</dt>
+      <dt><b>Effects:</b> Adds the result of <code><a href=
+      "make_function.html#make_constructor-spec">make_constructor</a>&lt;T,Args,HolderGenerator&gt;()</code>
+      to the Boost.Python extension class being defined with the name
+      "__init__". If the 2nd form is used, an unspecified empty <a href=
+      "../../../mpl/doc/Sequences.html">MPL sequence</a> type is substituted
+      for <code>Args</code>. If the extension class already has an "__init__"
+      attribute, the usual <a href="http:overloading.html">overloading
+      procedure</a> applies.
 
-  <dt><b>Effects:</b> Adds the result of <code><a
-  href="make_function.html#make_constructor-spec">
-  make_constructor</a>&lt;T,Args,HolderGenerator&gt;()</code> to the
-  Boost.Python extension class being defined with the name
-  &quot;__init__&quot;. If the 2nd form is used, an unspecified empty
-  <a href="../../../mpl/doc/Sequences.html">MPL sequence</a> type is
-  substituted for <code>Args</code>.
-  If the extension class already has an
-   &quot;__init__&quot; attribute, the usual <a
-  href="http:overloading.html">overloading procedure</a> applies.
+      <dt><b>Returns:</b> <code>*this</code>
 
-  <dt><b>Returns:</b> <code>*this</code></dt>
+      <dt><b>Rationale:</b> Allows users to easily expose a class' constructor
+      to Python.
+    </dl>
 
-  <dt><b>Rationale:</b> Allows users to easily expose a class'
-  constructor to Python.</dt>
-</dl>
-
-
-<h4><a name="class_-spec-observers"></a>Class template <code>class_</code> observer
-functions</h4>
+    <h4><a name="class_-spec-observers"></a>Class template <code>class_</code>
+    observer functions</h4>
 <pre>
 ref object() const;
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Returns:</b> A <code>ref</code> object which holds a
-  reference to the Boost.Python extension class object created by the
-  <code>class_</code> constructor.</dt>
 
-  <dt><b>Rationale:</b> Mostly not needed by users, since <code><a
-  href="module.html#add-spec">module::add</a>()</code> uses this to
-  insert the extension class in the module.</dt>
-</dl>
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> A <code>ref</code> object which holds a reference to
+      the Boost.Python extension class object created by the
+      <code>class_</code> constructor.
 
+      <dt><b>Rationale:</b> Mostly not needed by users, since <code><a href=
+      "module.html#add-spec">module::add</a>()</code> uses this to insert the
+      extension class in the module.
+    </dl>
 
-<h3><a name="args-spec">
-</a>Class template <code>args&lt;T1,&nbsp;T2,</code>...<code>TN&gt;</code></h3>
+    <h3><a name="args-spec"></a>Class template
+    <code>args&lt;T1, T2,</code>...<code>TN&gt;</code></h3>
 
-<p>Essentially an alias for <code>boost::mpl::type_list</code> which
-users can use in <code>def_init</code> calls to make their code more
-readable. Currently it is in the global unnammed namespace, but that
-will probably change.
+    <p>Essentially an alias for <code>boost::mpl::type_list</code> which users
+    can use in <code>def_init</code> calls to make their code more readable.
+    Currently it is in the global unnammed namespace, but that will probably
+    change.
 
-<h4><a name="args-spec-synopsis"></a>Class template <code>args</code> synopsis</h4>
+    <h4><a name="args-spec-synopsis"></a>Class template <code>args</code>
+    synopsis</h4>
 <pre>
 namespace
 {
@@ -271,15 +277,16 @@ namespace
 }
 </pre>
 
-<h3><a name="bases-spec">
-</a>Class template <code>bases&lt;T1,&nbsp;T2,</code>...<code>TN&gt;</code></h3>
+    <h3><a name="bases-spec"></a>Class template
+    <code>bases&lt;T1, T2,</code>...<code>TN&gt;</code></h3>
 
-<p>Essentially an alias for <code>boost::mpl::type_list</code> which
-users can use in <code>class_&lt;</code>...<code>&gt;</code>
-instantiations to make their code more readable. Currently it is in
-the global unnammed namespace, but that will probably change.
+    <p>Essentially an alias for <code>boost::mpl::type_list</code> which users
+    can use in <code>class_&lt;</code>...<code>&gt;</code> instantiations to
+    make their code more readable. Currently it is in the global unnammed
+    namespace, but that will probably change.
 
-<h4><a name="bases-spec-synopsis"></a>Class template <code>bases</code> synopsis</h4>
+    <h4><a name="bases-spec-synopsis"></a>Class template <code>bases</code>
+    synopsis</h4>
 <pre>
 namespace
 {
@@ -289,10 +296,9 @@ namespace
 }
 </pre>
 
-<h2><a name="examples"></a>Example(s)</h2>
-
-<p>Given a C++ class declaration:
+    <h2><a name="examples"></a>Example(s)</h2>
 
+    <p>Given a C++ class declaration:
 <pre>
 class Foo : public Bar, public Baz
 {
@@ -306,9 +312,7 @@ class Foo : public Bar, public Baz
    ...
 };
 </pre>
-
-A corresponding Boost.Python extension class can be created with:
-
+    A corresponding Boost.Python extension class can be created with: 
 <pre>
 using namespace boost::python;
 ref foo =
@@ -319,15 +323,12 @@ class_&lt;Foo,bases&lt;Bar,Baz&gt; &gt;()
    .def("set_name", &amp;Foo::set_name)
    .object();
 </pre>
+    Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+     
 
-</p>
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
diff --git a/doc/v2/copy_const_reference.html b/doc/v2/copy_const_reference.html
index 1ce94dbb..f80db61f 100644
--- a/doc/v2/copy_const_reference.html
+++ b/doc/v2/copy_const_reference.html
@@ -1,49 +1,61 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/copy_const_reference.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/copy_const_reference.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/copy_const_reference.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
-    <dt><a href="#copy_const_reference-spec">Class <code>copy_const_reference</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#copy_const_reference-spec-synopsis">Class <code>copy_const_reference</code> synopsis</a></dt>
-	  <dt><a href="#copy_const_reference-spec-metafunctions">Class <code>copy_const_reference</code> metafunctions</a></dt>
-	</dl>
-  </dl>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#examples">Example</a></dt>
-</dl>
-<hr>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-<h2><a name="classes"></a>Classes</h2>
+          <h2 align="center">Header
+          &lt;boost/python/copy_const_reference.hpp&gt;</h2>
+    </table>
+    <hr>
 
-<h3><a name="copy_const_reference-spec"></a>Class <code>copy_const_reference</code></h3>
-<p>
-<code>copy_const_reference</code> is a model of <a
-href="ResultConverterGenerator.html">ResultConverterGenerator</a>
-which can be used to wrap C++ functions returning a reference-to-const
-type such that the referenced value is copied into a new Python object. 
-</p>
+    <h2>Contents</h2>
 
-<h4><a name="copy_const_reference-spec-synopsis"></a>Class <code>copy_const_reference</code> synopsis</h4>
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#copy_const_reference-spec">Class
+          <code>copy_const_reference</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#copy_const_reference-spec-synopsis">Class
+              <code>copy_const_reference</code> synopsis</a>
+
+              <dt><a href="#copy_const_reference-spec-metafunctions">Class
+              <code>copy_const_reference</code> metafunctions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="copy_const_reference-spec"></a>Class
+    <code>copy_const_reference</code></h3>
+
+    <p><code>copy_const_reference</code> is a model of <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions returning a reference-to-const type such that
+    the referenced value is copied into a new Python object.
+
+    <h4><a name="copy_const_reference-spec-synopsis"></a>Class
+    <code>copy_const_reference</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -53,19 +65,25 @@ namespace boost { namespace python
     };
 }}
 </pre>
-<h4><a name="copy_const_reference-spec-metafunctions"></a>Class <code>copy_const_reference</code> metafunctions</h4>
+
+    <h4><a name="copy_const_reference-spec-metafunctions"></a>Class
+    <code>copy_const_reference</code> metafunctions</h4>
 <pre>
 template &lt;class T&gt; struct apply
 </pre>
-<dl class="metafunction-semantics"> 
-  <dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for some <code>U</code>.</dt>
-  <dt><b>Returns:</b> <code>typedef <a href="to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt; type;</code></dt>
-</dl>
 
-<h2><a name="examples"></a>Example</h2>
+    <dl class="metafunction-semantics">
+      <dt><b>Requires:</b> <code>T</code> is <code>U const&amp;</code> for some
+      <code>U</code>.
 
-<p> In C++:
+      <dt><b>Returns:</b> <code>typedef <a href=
+      "to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt;
+      type;</code>
+    </dl>
 
+    <h2><a name="examples"></a>Example</h2>
+
+    <p>In C++:
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -98,21 +116,19 @@ BOOST_PYTHON_MODULE_INIT(my_module)
          );
 }
 </pre>
-
-In Python:
-
+    In Python: 
 <pre>
 &gt;&gt;&gt; from my_module import *
 &gt;&gt;&gt; f = Foo(3)         # create a Foo object
 &gt;&gt;&gt; b = f.get_bar()    # make a copy of the internal Bar object
 </pre>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/copy_non_const_reference.html b/doc/v2/copy_non_const_reference.html
index c1ed50a3..ea2a99c7 100644
--- a/doc/v2/copy_non_const_reference.html
+++ b/doc/v2/copy_non_const_reference.html
@@ -1,49 +1,62 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/copy_non_const_reference.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python -
+    &lt;boost/python/copy_non_const_reference.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/copy_non_const_reference.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
-    <dt><a href="#copy_non_const_reference-spec">Class <code>copy_non_const_reference</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#copy_non_const_reference-spec-synopsis">Class <code>copy_non_const_reference</code> synopsis</a></dt>
-	  <dt><a href="#copy_non_const_reference-spec-metafunctions">Class <code>copy_non_const_reference</code> metafunctions</a></dt>
-	</dl>
-  </dl>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#examples">Example</a></dt>
-</dl>
-<hr>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-<h2><a name="classes"></a>Classes</h2>
+          <h2 align="center">Header
+          &lt;boost/python/copy_non_const_reference.hpp&gt;</h2>
+    </table>
+    <hr>
 
-<h3><a name="copy_non_const_reference-spec"></a>Class <code>copy_non_const_reference</code></h3>
-<p>
-<code>copy_non_const_reference</code> is a model of <a
-href="ResultConverterGenerator.html">ResultConverterGenerator</a>
-which can be used to wrap C++ functions returning a reference-to-non-const
-type such that the referenced value is copied into a new Python object. 
-</p>
+    <h2>Contents</h2>
 
-<h4><a name="copy_non_const_reference-spec-synopsis"></a>Class <code>copy_non_const_reference</code> synopsis</h4>
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#copy_non_const_reference-spec">Class
+          <code>copy_non_const_reference</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#copy_non_const_reference-spec-synopsis">Class
+              <code>copy_non_const_reference</code> synopsis</a>
+
+              <dt><a href="#copy_non_const_reference-spec-metafunctions">Class
+              <code>copy_non_const_reference</code> metafunctions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="copy_non_const_reference-spec"></a>Class
+    <code>copy_non_const_reference</code></h3>
+
+    <p><code>copy_non_const_reference</code> is a model of <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions returning a reference-to-non-const type such
+    that the referenced value is copied into a new Python object.
+
+    <h4><a name="copy_non_const_reference-spec-synopsis"></a>Class
+    <code>copy_non_const_reference</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -54,19 +67,24 @@ namespace boost { namespace python
 }}
 </pre>
 
-<h4><a name="copy_non_const_reference-spec-metafunctions"></a>Class <code>copy_non_const_reference</code> metafunctions</h4>
+    <h4><a name="copy_non_const_reference-spec-metafunctions"></a>Class
+    <code>copy_non_const_reference</code> metafunctions</h4>
 <pre>
 template &lt;class T&gt; struct apply
 </pre>
-<dl class="metafunction-semantics"> 
-  <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> for some non-const <code>U</code>.</dt>
-  <dt><b>Returns:</b> <code>typedef <a href="to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt; type;</code></dt>
-</dl>
 
-<h2><a name="examples"></a>Example</h2>
+    <dl class="metafunction-semantics">
+      <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> for some
+      non-const <code>U</code>.
 
-<p> C++ code:
+      <dt><b>Returns:</b> <code>typedef <a href=
+      "to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T&gt;
+      type;</code>
+    </dl>
 
+    <h2><a name="examples"></a>Example</h2>
+
+    <p>C++ code:
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -99,21 +117,19 @@ BOOST_PYTHON_MODULE_INIT(my_module)
          );
 }
 </pre>
-
-Python Code:
-
+    Python Code: 
 <pre>
 &gt;&gt;&gt; from my_module import *
 &gt;&gt;&gt; f = Foo(3)         # create a Foo object
 &gt;&gt;&gt; b = f.get_bar()    # make a copy of the internal Bar object
 </pre>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/default_call_policies.html b/doc/v2/default_call_policies.html
index 3e60fcc8..876baf7a 100644
--- a/doc/v2/default_call_policies.html
+++ b/doc/v2/default_call_policies.html
@@ -1,61 +1,78 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/default_call_policies.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python -
+    &lt;boost/python/default_call_policies.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/default_call_policies.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-    <dt><a href="#default_call_policies-spec">Class <code>default_call_policies</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#default_call_policies-spec-synopsis">Class <code>default_call_policies</code> synopsis</a></dt>
-	  <dt><a href="#default_call_policies-spec-statics">Class <code>default_call_policies</code> static functions</a></dt>
-	</dl>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-    <dt><a href="#default_result_converter-spec">Class <code>default_result_converter</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#default_result_converter-spec-synopsis">Class <code>default_result_converter</code> synopsis</a></dt>
-	  <dt><a href="#default_result_converter-spec-metafunctions">Class <code>default_result_converter</code> metafunctions</a></dt>
-	</dl>
+          <h2 align="center">Header
+          &lt;boost/python/default_call_policies.hpp&gt;</h2>
+    </table>
+    <hr>
 
-  </dl>
+    <h2>Contents</h2>
 
-  <dt><a href="#examples">Example</a></dt>
-</dl>
-<hr>
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a>
 
-<h2><a name="classes"></a>Classes</h2>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#default_call_policies-spec">Class
+          <code>default_call_policies</code></a>
 
-<h3><a name="default_call_policies-spec"></a>Class <code>default_call_policies</code></h3>
-<p>
-<code>default_call_policies</code> is a model of <a
-href="CallPolicies.html">CallPolicies</a> with no <code>precall</code>
-or <code>postcall</code> behavior and a <code>result_converter</code>
-which handles by-value returns. Wrapped C++ functions and member
-functions use <code>default_call_policies</code> unless otherwise
-specified. You may find it convenient to derive new models of <a
-href="CallPolicies.html">CallPolicies</a> from
-<code>default_call_policies</code>.
-</p>
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#default_call_policies-spec-synopsis">Class
+              <code>default_call_policies</code> synopsis</a>
 
-<h4><a name="default_call_policies-spec-synopsis"></a>Class <code>default_call_policies</code> synopsis</h4>
+              <dt><a href="#default_call_policies-spec-statics">Class
+              <code>default_call_policies</code> static functions</a>
+            </dl>
+
+          <dt><a href="#default_result_converter-spec">Class
+          <code>default_result_converter</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#default_result_converter-spec-synopsis">Class
+              <code>default_result_converter</code> synopsis</a>
+
+              <dt><a href="#default_result_converter-spec-metafunctions">Class
+              <code>default_result_converter</code> metafunctions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="default_call_policies-spec"></a>Class
+    <code>default_call_policies</code></h3>
+
+    <p><code>default_call_policies</code> is a model of <a href=
+    "CallPolicies.html">CallPolicies</a> with no <code>precall</code> or
+    <code>postcall</code> behavior and a <code>result_converter</code> which
+    handles by-value returns. Wrapped C++ functions and member functions use
+    <code>default_call_policies</code> unless otherwise specified. You may find
+    it convenient to derive new models of <a href=
+    "CallPolicies.html">CallPolicies</a> from
+    <code>default_call_policies</code>.
+
+    <h4><a name="default_call_policies-spec-synopsis"></a>Class
+    <code>default_call_policies</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -63,38 +80,43 @@ namespace boost { namespace python
     {
         static bool precall(PyObject*);
         static PyObject* postcall(PyObject*, PyObject* result);
-        typedef <a href="#default_result_converter-spec">default_result_converter</a> result_converter;
+        typedef <a href=
+"#default_result_converter-spec">default_result_converter</a> result_converter;
     };
 }}
 </pre>
 
-<h4><a name="default_call_policies-spec-statics"></a>Class <code>default_call_policies</code> static functions</h4>
+    <h4><a name="default_call_policies-spec-statics"></a>Class
+    <code>default_call_policies</code> static functions</h4>
 <pre>
 bool precall(PyObject*);
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Returns:</b> <code>true</code></dt>
-  <dt><b>Throws:</b> nothing</dt>
-</dl>
 
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> <code>true</code>
+
+      <dt><b>Throws:</b> nothing
+    </dl>
 <pre>
 PyObject* postcall(PyObject*, PyObject* result);
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Returns:</b> <code>result</code></dt>
-  <dt><b>Throws:</b> nothing</dt>
-</dl>
 
-<h3><a name="default_result_converter-spec"></a>Class <code>default_result_converter</code></h3>
-<p>
-<code>default_result_converter</code> is a model of <a
-href="ResultConverterGenerator.html">ResultConverterGenerator</a>
-which can be used to wrap C++ functions returning non-pointer types,
-<code>char const*</code>, and <code>PyObject*</code>,
-by-value.
-</p>
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> <code>result</code>
 
-<h4><a name="default_result_converter-spec-synopsis"></a>Class <code>default_result_converter</code> synopsis</h4>
+      <dt><b>Throws:</b> nothing
+    </dl>
+
+    <h3><a name="default_result_converter-spec"></a>Class
+    <code>default_result_converter</code></h3>
+
+    <p><code>default_result_converter</code> is a model of <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions returning non-pointer types, <code>char
+    const*</code>, and <code>PyObject*</code>, by-value.
+
+    <h4><a name="default_result_converter-spec-synopsis"></a>Class
+    <code>default_result_converter</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -105,26 +127,30 @@ namespace boost { namespace python
 }}
 </pre>
 
-<h4><a name="default_result_converter-spec-metafunctions"></a>Class <code>default_result_converter</code> metafunctions</h4>
+    <h4><a name="default_result_converter-spec-metafunctions"></a>Class
+    <code>default_result_converter</code> metafunctions</h4>
 <pre>
 template &lt;class T&gt; struct apply
 </pre>
-<dl class="metafunction-semantics"> 
 
-  <dt><b>Requires:</b> <code>T</code> is not a reference type. If
-  <code>T</code> is a pointer type, <code>T</code> is <code>const
-  char*</code> or <code>PyObject*</code>.</dt>
+    <dl class="metafunction-semantics">
+      <dt><b>Requires:</b> <code>T</code> is not a reference type. If
+      <code>T</code> is a pointer type, <code>T</code> is <code>const
+      char*</code> or <code>PyObject*</code>.
 
-  <dt><b>Returns:</b> <code>typedef <a href="to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T const&amp;&gt; type;</code></dt>
-</dl>
+      <dt><b>Returns:</b> <code>typedef <a href=
+      "to_python_value.html#to_python_value-spec">to_python_value</a>&lt;T
+      const&amp;&gt; type;</code>
+    </dl>
 
-<h2><a name="examples"></a>Example</h2>
-
-<p>This example comes from the Boost.Python implementation itself. Because the <a
-href="return_value_policy.html#return_value_policy-spec">return_value_policy</a>
-class template does not implement <code>precall</code> or
-<code>postcall</code> behavior, its default base class is <code>default_call_policies</code>:
+    <h2><a name="examples"></a>Example</h2>
 
+    <p>This example comes from the Boost.Python implementation itself. Because
+    the <a href=
+    "return_value_policy.html#return_value_policy-spec">return_value_policy</a>
+    class template does not implement <code>precall</code> or
+    <code>postcall</code> behavior, its default base class is
+    <code>default_call_policies</code>:
 <pre>
 template &lt;class Handler, class Base = default_call_policies&gt;
 struct return_value_policy : Base
@@ -133,12 +159,12 @@ struct return_value_policy : Base
 };
 </pre>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/errors.html b/doc/v2/errors.html
index e0bfa89d..e52f29f7 100644
--- a/doc/v2/errors.html
+++ b/doc/v2/errors.html
@@ -1,132 +1,141 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;{{header}}&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;{{header}}&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/errors.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#introduction">Introduction</a></dt>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-    <dt><a href="#class-spec">Class <code>error_already_set</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#error_already_set-spec-synopsis">Class <code>error_already_set</code> synopsis</a></dt>
-	</dl>
+          <h2 align="center">Header &lt;boost/python/errors.hpp&gt;</h2>
+    </table>
+    <hr>
 
-  </dl>
+    <h2>Contents</h2>
 
-  <dt><a href="#functions">Functions</a></dt>
-  <dl class="page-index">
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
 
-    <dt><a href="#handle_exception-spec">handle_exception</a></dt>
-    <dt><a href="#expect_non_null-spec">expect_non_null</a></dt>
+      <dt><a href="#classes">Classes</a>
 
-  </dl>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#class-spec">Class <code>error_already_set</code></a>
 
-  <dt><a href="#examples">Examples</a></dt>
-</dl>
-<hr>
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#error_already_set-spec-synopsis">Class
+              <code>error_already_set</code> synopsis</a>
+            </dl>
+        </dl>
 
-<h2><a name="introduction"></a>Introduction</h2>
-<p><code>&lt;boost/python/errors.hpp&gt;</code> provides types and
-functions for managing and translating between Python and C++
-exceptions. This is relatively low-level functionality that is mostly
-used internally by Boost.Python. Users should seldom need it.
+      <dt><a href="#functions">Functions</a>
 
-<h2><a name="classes"></a>Classes</h2>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#handle_exception-spec">handle_exception</a>
 
-<h3><a name="error_already_set-spec"></a>Class <code>error_already_set</code></h3>
-<p>
-<code>error_already_set</code> is an exception type which can be
-thrown to indicate that a Python error has occurred. If thrown, the
-precondition is that <a
-href="http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
-returns a value convertible to <code>true</code>.
-</p>
+          <dt><a href="#expect_non_null-spec">expect_non_null</a>
+        </dl>
 
-<h4><a name="class-spec-synopsis"></a>Class error_already_set synopsis</h4>
+      <dt><a href="#examples">Examples</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <p><code>&lt;boost/python/errors.hpp&gt;</code> provides types and
+    functions for managing and translating between Python and C++ exceptions.
+    This is relatively low-level functionality that is mostly used internally
+    by Boost.Python. Users should seldom need it.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="error_already_set-spec"></a>Class
+    <code>error_already_set</code></h3>
+
+    <p><code>error_already_set</code> is an exception type which can be thrown
+    to indicate that a Python error has occurred. If thrown, the precondition
+    is that <a href=
+    "http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
+    returns a value convertible to <code>true</code>.
+
+    <h4><a name="class-spec-synopsis"></a>Class error_already_set synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
-    class error_already_set&nbsp;{};
+    class error_already_set {};
 }}
 </pre>
 
-
-<h2><a name="functions"></a>Functions</h2>
-<pre><a name="handle_exception-spec">template &lt;class T&gt; bool handle_exception</a>(T f) throw();
+    <h2><a name="functions"></a>Functions</h2>
+<pre>
+<a name=
+"handle_exception-spec">template &lt;class T&gt; bool handle_exception</a>(T f) throw();
 
 void handle_exception() throw();
 </pre>
-<dl class="handle_exception-semantics"> 
-  <dt><b>Requires:</b> The first form requires that the expression
-  <code><a
-  href="../../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
-  is valid. The second form requires that a C++ exception is currently
-  being handled (see section 15.1 in the C++ standard).
-</dt>
 
-  <dt><b>Effects:</b> The first form calls <code>f()</code> inside a
-  <code>try</code> block whose <code>catch</code> clauses set an
-  appropriate Python exception for the C++ exception caught, returning
-  <code>true</code> if an exception was caught, <code>false</code>
-  otherwise. The second form passes a function which rethrows the
-  exception currently being handled to the first form.</dt>
+    <dl class="handle_exception-semantics">
+      <dt><b>Requires:</b> The first form requires that the expression <code><a
+      href=
+      "../../../function/doc/reference.html#functionN">function0</a>&lt;void&gt;(f)</code>
+      is valid. The second form requires that a C++ exception is currently
+      being handled (see section 15.1 in the C++ standard).
 
-  <dt><b>Postconditions:</b> No exception is being handled</dt>
+      <dt><b>Effects:</b> The first form calls <code>f()</code> inside a
+      <code>try</code> block whose <code>catch</code> clauses set an
+      appropriate Python exception for the C++ exception caught, returning
+      <code>true</code> if an exception was caught, <code>false</code>
+      otherwise. The second form passes a function which rethrows the exception
+      currently being handled to the first form.
 
-  <dt><b>Throws:</b> nothing</dt>
+      <dt><b>Postconditions:</b> No exception is being handled
 
-  <dt><b>Rationale:</b> At inter-language boundaries it is important
-  to ensure that no C++ exceptions escape, since the calling language
-  usually doesn't have the equipment neccessary to properly unwind the
-  stack. Use <code>handle_exception</code> to manage exception
-  translation whenever your C++ code is called directly from the
-  Python API. This is done for you automatically by the usual function
-  wrapping facilities: <a
-  href="make_function.html#make_function-spec">make_function()</a>, <a
-  href="make_function.html#make_constructor-spec">make_constructor()</a>,
-  <a href="module.html#def-spec">module::def</a> and <a
-  href="class.html#def-spec">class_::def</a>). The second form can be
-  more convenient to use
-  (see the <a href="#examples">example</a> below), but various
-  compilers have problems when exceptions are rethrown from within an
-  enclosing <code>try</code> block.</dt>
-</dl>
+      <dt><b>Throws:</b> nothing
 
+      <dt><b>Rationale:</b> At inter-language boundaries it is important to
+      ensure that no C++ exceptions escape, since the calling language usually
+      doesn't have the equipment neccessary to properly unwind the stack. Use
+      <code>handle_exception</code> to manage exception translation whenever
+      your C++ code is called directly from the Python API. This is done for
+      you automatically by the usual function wrapping facilities: <a href=
+      "make_function.html#make_function-spec">make_function()</a>, <a href=
+      "make_function.html#make_constructor-spec">make_constructor()</a>, <a
+      href="module.html#def-spec">module::def</a> and <a href=
+      "class.html#def-spec">class_::def</a>). The second form can be more
+      convenient to use (see the <a href="#examples">example</a> below), but
+      various compilers have problems when exceptions are rethrown from within
+      an enclosing <code>try</code> block.
+    </dl>
 <pre>
 <a name="expect_non_null-spec">PyObject* expect_non_null(PyObject* x);</a>
 
 template &lt;class T&gt; T* expect_non_null(T* x);
 </pre>
-<dl class="expect_non_null-semantics"> 
-  <dt><b>Returns:</b> <code>x</code></dt>
-  <dt><b>Throws:</b> <code><a href="#error_already_set-spec">error_already_set()</a></code> iff <code>x == 0</code>.</dt>
-  <dt><b>Rationale:</b> Simplifies error-handling when calling many
-  functions in the <a
-  href="http://www.python.org/doc/current/api/api.html">Python/C
-  API</a>, which return 0 on error.</dt>
-</dl>
 
-<h2><a name="examples"></a>Examples</h2>
-<p>
+    <dl class="expect_non_null-semantics">
+      <dt><b>Returns:</b> <code>x</code>
+
+      <dt><b>Throws:</b> <code><a href=
+      "#error_already_set-spec">error_already_set()</a></code> iff <code>x ==
+      0</code>.
+
+      <dt><b>Rationale:</b> Simplifies error-handling when calling many
+      functions in the <a href=
+      "http://www.python.org/doc/current/api/api.html">Python/C API</a>, which
+      return 0 on error.
+    </dl>
+
+    <h2><a name="examples"></a>Examples</h2>
 <pre>
 #include &lt;string&gt;
 #include &lt;boost/python/errors.hpp&gt;
@@ -211,13 +220,13 @@ same_name2(PyObject* args, PyObject* keywords)
    }
 }
 </pre>
-</p>
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/from_python.html b/doc/v2/from_python.html
index 94ae7019..d888bb38 100644
--- a/doc/v2/from_python.html
+++ b/doc/v2/from_python.html
@@ -1,68 +1,79 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/from_python.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/from_python.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/from_python.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#introduction">Introduction</a></dt>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-    <dt><a href="#from_python-spec">Class Template<code>from_python</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#from_python-spec-synopsis">Class Template <code>from_python</code> synopsis</a></dt>
-	  <dt><a href="#from_python-spec-ctors">Class Template <code>from_python</code> constructor</a></dt>
-  	  <dt><a href="#from_python-spec-observers">Class Template <code>from_python</code> observer functions</a></dt>
-	</dl>
-  </dl>
-  <dt><a href="#examples">Example</a></dt>
-</dl>
-<hr>
-<h2><a name="introduction"></a>Introduction</h2>
-<p>
+          <h2 align="center">Header &lt;boost/python/from_python.hpp&gt;</h2>
+    </table>
+    <hr>
 
-<code>&lt;boost/python/from_python.hpp&gt;</code> introduces a class
-template <code>from_python&lt;T&gt;</code> for extracting a C++ object
-of type <code>T</code> from a Python object.
+    <h2>Contents</h2>
 
-</p>
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
 
+      <dt><a href="#classes">Classes</a>
 
-<h2><a name="classes"></a>Classes</h2>
-<h3><a name="from_python-spec"></a>Class Template <code>from_python&lt;class T&gt;</code></h3>
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#from_python-spec">Class
+          Template<code>from_python</code></a>
 
-<p>
-<code>from_python&lt;T&gt;</code> is the type used internally by
-Boost.Python to extract C++ function arguments from a Python argument
-tuple when calling a wrapped function. It can also be used directly to
-make similar conversions in other contexts.
-</p>
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#from_python-spec-synopsis">Class Template
+              <code>from_python</code> synopsis</a>
 
-<h4><a name="from_python-spec-synopsis"></a>Class Template <code>from_python</code> synopsis</h4>
+              <dt><a href="#from_python-spec-ctors">Class Template
+              <code>from_python</code> constructor</a>
+
+              <dt><a href="#from_python-spec-observers">Class Template
+              <code>from_python</code> observer functions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <p><code>&lt;boost/python/from_python.hpp&gt;</code> introduces a class
+    template <code>from_python&lt;T&gt;</code> for extracting a C++ object of
+    type <code>T</code> from a Python object.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="from_python-spec"></a>Class Template
+    <code>from_python&lt;class T&gt;</code></h3>
+
+    <p><code>from_python&lt;T&gt;</code> is the type used internally by
+    Boost.Python to extract C++ function arguments from a Python argument tuple
+    when calling a wrapped function. It can also be used directly to make
+    similar conversions in other contexts.
+
+    <h4><a name="from_python-spec-synopsis"></a>Class Template
+    <code>from_python</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
    template &lt;class T&gt;
    struct from_python : private <a href=
-   "../../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
-       // from_python&lt;T&gt; meets the <a href="NonCopyable.html">NonCopyable</a> requirements
+"../../../utility/utility.htm#Class noncopyable">boost::noncopyable</a> // Exposition only.
+       // from_python&lt;T&gt; meets the <a href=
+"NonCopyable.html">NonCopyable</a> requirements
    {
       from_python(PyObject*);
       bool convertible() const;
@@ -71,63 +82,63 @@ namespace boost { namespace python
 }
 </pre>
 
-<h4><a name="from_python-spec-ctors"></a>Class Template <code>from_python</code> constructor</h4>
+    <h4><a name="from_python-spec-ctors"></a>Class Template
+    <code>from_python</code> constructor</h4>
 <pre>
 from_python(PyObject* p);
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> <code>p != 0</code></dt>
 
-  <dt><b>Effects:</b> Constructs a <code>from_python</code> object
-  suitable for extracting a C++ object of type <code>T</code> from
-  <code>p</code>.</dt>
-</dl>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>p != 0</code>
 
-<h4><a name="from_python-spec-observers"></a>Class Template <code>from_python</code> observer functions</h4>
+      <dt><b>Effects:</b> Constructs a <code>from_python</code> object suitable
+      for extracting a C++ object of type <code>T</code> from <code>p</code>.
+    </dl>
 
+    <h4><a name="from_python-spec-observers"></a>Class Template
+    <code>from_python</code> observer functions</h4>
 <pre>
 bool convertible() const;
 </pre>
-<dl class="function-semantics"> 
 
-  <dt><b>Returns:</b> <code>false</code> if the conversion cannot succeed. This indicates that either:
-<ol>
-<li>No <code>from_python_converter</code> was registered for
-<code>T</code>, or
+    <dl class="function-semantics">
+      <dt><b>Returns:</b> <code>false</code> if the conversion cannot succeed.
+      This indicates that either:
 
-<li>any such converter rejected the constructor argument
-<code>p</code> by returning <code>0</code> from its
-<code>convertible()</code> function
-</ol>
+      <dd>
+        <ol>
+          <li>No <code>from_python_converter</code> was registered for
+          <code>T</code>, or
 
-Note that conversion may still fail in <code>operator()</code> due to an exception.
+          <li>any such converter rejected the constructor argument
+          <code>p</code> by returning <code>0</code> from its
+          <code>convertible()</code> function
+        </ol>
+        Note that conversion may still fail in <code>operator()</code> due to
+        an exception. 
 
-</dt>
-
-  <dt><b>Throws:</b> nothing</dt>
-
-  <dt><b>Rationale:</b> Because <code>from_python&lt;&gt;</code> is used in
-  overload resolution, and throwing an exception can be slow, it is
-  useful to be able to rule out a broad class of unsuccessful
-  conversions without throwing an exception.</dt>
-</dl>
+      <dt><b>Throws:</b> nothing
 
+      <dt><b>Rationale:</b> Because <code>from_python&lt;&gt;</code> is used in
+      overload resolution, and throwing an exception can be slow, it is useful
+      to be able to rule out a broad class of unsuccessful conversions without
+      throwing an exception.
+    </dl>
 <pre>
 <i>convertible-to-T</i> operator()(PyObject* p) const;
 </pre>
-<dl class="function-semantics"> 
 
-  <dt><b>Requires:</b> <code>*p</code> refers to the same object which
-  was passed to the constructor, and <code>convertible()</code>
-  returns <code>true</code>.</dt>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>*p</code> refers to the same object which was
+      passed to the constructor, and <code>convertible()</code> returns
+      <code>true</code>.
 
-  <dt><b>Effects:</b> performs the conversion</dt>
-  <dt><b>Returns:</b> an object convertible to <code>T</code>.</dt>
-</dl>
+      <dt><b>Effects:</b> performs the conversion
 
-<h2><a name="examples"></a>Example</h2>
+      <dt><b>Returns:</b> an object convertible to <code>T</code>.
+    </dl>
 
-<p>
+    <h2><a name="examples"></a>Example</h2>
 <pre>
 #include &lt;string&gt;
 #include &lt;boost/python/from_python.hpp&gt;
@@ -143,14 +154,13 @@ std::size_t length_if_string(PyObject* p)
       return converter().size();
 }
 </pre>
-</p>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/header.html b/doc/v2/header.html
index c0fa972f..7b36a65c 100644
--- a/doc/v2/header.html
+++ b/doc/v2/header.html
@@ -1,181 +1,293 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;{{header}}&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;{{header}}&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;{{header}}&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#introduction">Introduction</a></dt>
-  <dt><a href="#macros">Macros</a></dt>
-  <dl class="page-index">
-    <dt><a href="#macro-spec">{{macro name}}</a></dt>
-  </dl>
-  <dt><a href="#values">Values</a></dt>
-  <dl class="page-index">
-    <dt><a href="#value-spec">{{value name}}</a></dt>
-  </dl>
-  <dt><a href="#types">Types</a></dt>
-  <dl class="page-index">
-    <dt><a href="#type-spec">{{type name}}</a></dt>
-  </dl>
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
-    <dt><a href="#class-spec">Class <code>{{class name}}</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#class-spec-synopsis">Class <code>{{class name}}</code> synopsis</a></dt>
-	  <dt><a href="#class-spec-ctors">Class <code>{{class name}}</code> constructors and destructor</a></dt>
-  	  <dt><a href="#class-spec-comparisons">Class <code>{{class name}}</code> comparison functions</a></dt>
-  	  <dt><a href="#class-spec-modifiers">Class <code>{{class name}}</code> modifier functions</a></dt>
-  	  <dt><a href="#class-spec-observers">Class <code>{{class name}}</code> observer functions</a></dt>
-  	  <dt><a href="#class-spec-statics">Class <code>{{class name}}</code> static functions</a></dt>
-	</dl>
-  </dl>
-  <dt><a href="#functions">Functions</a></dt>
-  <dl class="page-index">
-    <dt><a href="#function-spec">{{function name}}</a></dt>
-  </dl>
-  <dt><a href="#objects">Objects</a></dt>
-  <dl class="page-index">
-    <dt><a href="#object-spec">{{object name}}</a></dt>
-  </dl>
-  <dt><a href="#examples">Example(s)</a></dt>
-</dl>
-<hr>
-<h2><a name="introduction"></a>Introduction</h2>
-<p>{{Introductory text}}</p>
-<h2><a name="macros"></a>Macros</h2>
-<p><a name="macro-spec"></a>{{Macro specifications}}</p>
-<h2><a name="values"></a>Values</h2>
-<p><a name="value-spec"></a>{{Value specifications}}</p>
-<h2><a name="types"></a>Types</h2>
-<p><a name="type-spec"></a>{{Type specifications}}</p>
-<h2><a name="classes"></a>Classes</h2>
-<h3><a name="class-spec"></a>Class <code>{{name}}</code></h3>
-<p>{{class overview text}}</p>
-<h4><a name="class-spec-synopsis"></a>Class {{name}} synopsis</h4>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;{{header}}&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+      <dt><a href="#macros">Macros</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#macro-spec">{{macro name}}</a>
+        </dl>
+
+      <dt><a href="#values">Values</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#value-spec">{{value name}}</a>
+        </dl>
+
+      <dt><a href="#types">Types</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#type-spec">{{type name}}</a>
+        </dl>
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#class-spec">Class <code>{{class name}}</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#class-spec-synopsis">Class <code>{{class
+              name}}</code> synopsis</a>
+
+              <dt><a href="#class-spec-ctors">Class <code>{{class name}}</code>
+              constructors and destructor</a>
+
+              <dt><a href="#class-spec-comparisons">Class <code>{{class
+              name}}</code> comparison functions</a>
+
+              <dt><a href="#class-spec-modifiers">Class <code>{{class
+              name}}</code> modifier functions</a>
+
+              <dt><a href="#class-spec-observers">Class <code>{{class
+              name}}</code> observer functions</a>
+
+              <dt><a href="#class-spec-statics">Class <code>{{class
+              name}}</code> static functions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#functions">Functions</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#function-spec">{{function name}}</a>
+        </dl>
+
+      <dt><a href="#objects">Objects</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#object-spec">{{object name}}</a>
+        </dl>
+
+      <dt><a href="#examples">Example(s)</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <p>{{Introductory text}}
+
+    <h2><a name="macros"></a>Macros</h2>
+
+    <p><a name="macro-spec"></a>{{Macro specifications}}
+
+    <h2><a name="values"></a>Values</h2>
+
+    <p><a name="value-spec"></a>{{Value specifications}}
+
+    <h2><a name="types"></a>Types</h2>
+
+    <p><a name="type-spec"></a>{{Type specifications}}
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="class-spec"></a>Class <code>{{name}}</code></h3>
+
+    <p>{{class overview text}}
+
+    <h4><a name="class-spec-synopsis"></a>Class {{name}} synopsis</h4>
 <pre>
 namespace boost
 {
     class {{name}}
-	{
-	};
+  {
+  };
 };
 </pre>
-<h4><a name="class-spec-ctors"></a>Class {{name}} constructors and destructor</h4>
+
+    <h4><a name="class-spec-ctors"></a>Class {{name}} constructors and
+    destructor</h4>
 <pre>
 {{constructor}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
 <pre>
 {{destructor}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
-<h4><a name="class-spec-comparisons"></a>Class {{name}} comparison functions</h4>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
+
+    <h4><a name="class-spec-comparisons"></a>Class {{name}} comparison
+    functions</h4>
 <pre>
 {{function}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
-<h4><a name="class-spec-modifiers"></a>Class {{name}} modifier functions</h4>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
+
+    <h4><a name="class-spec-modifiers"></a>Class {{name}} modifier
+    functions</h4>
 <pre>
 {{function}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
-<h4><a name="class-spec-observers"></a>Class {{name}} observer functions</h4>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
+
+    <h4><a name="class-spec-observers"></a>Class {{name}} observer
+    functions</h4>
 <pre>
 {{function}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
-<h4><a name="class-spec-statics"></a>Class {{name}} static functions</h4>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
+
+    <h4><a name="class-spec-statics"></a>Class {{name}} static functions</h4>
 <pre>
 {{function}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
-<h2><a name="functions"></a>Functions</h2>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
+
+    <h2><a name="functions"></a>Functions</h2>
 <pre>
+
+
 <a name="function-spec"></a>{{function}}
 </pre>
-<dl class="function-semantics"> 
-  <dt><b>Requires:</b> {{text}}</dt>
-  <dt><b>Effects:</b> {{text}}</dt>
-  <dt><b>Postconditions:</b> {{text}}</dt>
-  <dt><b>Returns:</b> {{text}}</dt>
-  <dt><b>Throws:</b> {{text}}</dt>
-  <dt><b>Complexity:</b> {{text}}</dt>
-  <dt><b>Rationale:</b> {{text}}</dt>
-</dl>
-<h2><a name="objects"></a>Objects</h2>
-<p><a name="object-spec"></a>{{Object specifications}}</p>
-<h2><a name="examples"></a>Example(s)</h2>
-<p>{{Example(s)}}</p>
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2001 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> {{text}}
+
+      <dt><b>Effects:</b> {{text}}
+
+      <dt><b>Postconditions:</b> {{text}}
+
+      <dt><b>Returns:</b> {{text}}
+
+      <dt><b>Throws:</b> {{text}}
+
+      <dt><b>Complexity:</b> {{text}}
+
+      <dt><b>Rationale:</b> {{text}}
+    </dl>
+
+    <h2><a name="objects"></a>Objects</h2>
+
+    <p><a name="object-spec"></a>{{Object specifications}}
+
+    <h2><a name="examples"></a>Example(s)</h2>
+
+    <p>{{Example(s)}}
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/make_function.html b/doc/v2/make_function.html
index e7c4b421..7f40703b 100644
--- a/doc/v2/make_function.html
+++ b/doc/v2/make_function.html
@@ -1,116 +1,109 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/make_function.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/make_function.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/make_function.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#introduction">Introduction</a></dt>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#functions">Functions</a></dt>
-  <dl class="page-index">
-    <dt><a href="#make_function-spec">make_function</a></dt>
-    <dt><a href="#make_constructor-spec">make_constructor</a></dt>
-  </dl>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-  <dt><a href="#examples">Example</a></dt>
+          <h2 align="center">Header &lt;boost/python/make_function.hpp&gt;</h2>
+    </table>
+    <hr>
 
-</dl>
-<hr>
-<h2><a name="introduction"></a>Introduction</h2>
-<p>
+    <h2>Contents</h2>
 
-<code><a href="#make_function-spec">make_function</a>()</code> and
-<code><a href="#make_constructor-spec">make_constructor</a>()</code>
-are the functions used internally by <code>class_&lt;&gt;::<a
-href="class.html#class_-spec-modifiers">def</a></code>,
-<code>class_&lt;&gt;::<a
-href="module.html#module-spec-modifiers">def</a></code>,
-and
-<code>class_&lt;&gt;::<a
-href="class.html#class_-spec-modifiers">def_init</a></code>
-to produce Python callable objects which wrap C++ functions and member
-functions.
-</p>
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
 
-<h2><a name="functions"></a>Functions</h2>
+      <dt><a href="#functions">Functions</a>
 
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#make_function-spec">make_function</a>
+
+          <dt><a href="#make_constructor-spec">make_constructor</a>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <p><code><a href="#make_function-spec">make_function</a>()</code> and
+    <code><a href="#make_constructor-spec">make_constructor</a>()</code> are
+    the functions used internally by <code>class_&lt;&gt;::<a href=
+    "class.html#class_-spec-modifiers">def</a></code>, <code>class_&lt;&gt;::<a
+    href="module.html#module-spec-modifiers">def</a></code>, and
+    <code>class_&lt;&gt;::<a href=
+    "class.html#class_-spec-modifiers">def_init</a></code> to produce Python
+    callable objects which wrap C++ functions and member functions.
+
+    <h2><a name="functions"></a>Functions</h2>
 <pre>
-<a name="make_function-spec">template &lt;class F&gt;
+<a name="make_function-spec">template &lt;class F&gt;</a>
 objects::function* make_function(F f)&lt;/a&gt;
 
 template &lt;class F, class Policies&gt;
 objects::function* make_function(F f, Policies const&amp; policies)
 </pre>
-<dl class="function-semantics"> 
 
-  <dt><b>Requires:</b> <code>F</code> is a function pointer or member
-  function pointer type</dt>
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code>F</code> is a function pointer or member
+      function pointer type
 
-  <dt><b>Effects:</b> Creates a Python callable object which, when
-  called from Python, converts its arguments to C++ and calls
-  <code>f</code>. If <code>F</code> is a pointer-to-member-function
-  type, the target object of the function call (<code>*this</code>)
-  will be taken from the first Python argument, and subsequent Python
-  arguments will be used as the arguments to <code>f</code>. If
-  <code>policies</code> are supplied, it must be a model of <a
-  href="CallPolicies.html">CallPolicies</a>, and will be applied to
-  the function as described <a href="CallPolicies.html">here</a>.</dt>
-
-  <dt><b>Returns:</b> A pointer convertible to <code>PyObject*</code>
-  which refers to the new Python callable object.</dt>
-</dl>
+      <dt><b>Effects:</b> Creates a Python callable object which, when called
+      from Python, converts its arguments to C++ and calls <code>f</code>. If
+      <code>F</code> is a pointer-to-member-function type, the target object of
+      the function call (<code>*this</code>) will be taken from the first
+      Python argument, and subsequent Python arguments will be used as the
+      arguments to <code>f</code>. If <code>policies</code> are supplied, it
+      must be a model of <a href="CallPolicies.html">CallPolicies</a>, and will
+      be applied to the function as described <a href=
+      "CallPolicies.html">here</a>.
 
+      <dt><b>Returns:</b> A pointer convertible to <code>PyObject*</code> which
+      refers to the new Python callable object.
+    </dl>
 <pre>
-<a name="make_constructor-spec">template &lt;class T, class ArgList, class Generator&gt;
+<a name=
+"make_constructor-spec">template &lt;class T, class ArgList, class Generator&gt;
 objects::function* make_constructor();</a>
 </pre>
-<dl class="make_constructor-semantics"> 
 
-  <dt><b>Requires:</b> <code>T</code> is a class
-  type. <code>ArgList</code> is an <a
-  href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++
-  argument types (<i>A1,&nbsp;A2,...&nbsp;AN</i>) such that if
-  <code>a1,&nbsp;a2</code>...&nbsp;<code>aN</code> are objects of type
-  <i>A1,&nbsp;A2,...&nbsp;AN</i> respectively, the expression
-  <code>new Generator::apply&lt;T&gt;::type(a1,&nbsp;a2</code>...&nbsp;<code>aN</code>) is
-  valid. Generator is a model of <a
-  href="HolderGenerator.html">HolderGenerator</a>.
-</dt>
+    <dl class="make_constructor-semantics">
+      <dt><b>Requires:</b> <code>T</code> is a class type. <code>ArgList</code>
+      is an <a href="../../../mpl/doc/Sequences.html">MPL sequence</a> of C++
+      argument types (<i>A1, A2,... AN</i>) such that if
+      <code>a1, a2</code>... <code>aN</code> are objects of type
+      <i>A1, A2,... AN</i> respectively, the expression <code>new
+      Generator::apply&lt;T&gt;::type(a1, a2</code>... <code>aN</code>) is
+      valid. Generator is a model of <a href=
+      "HolderGenerator.html">HolderGenerator</a>.
 
-  <dt><b>Effects:</b> Creates a Python callable object which, when
-  called from Python, expects its first argument to be a Boost.Python
-  extension class object. It converts its remaining its arguments to
-  C++ and passes them to the constructor of a dynamically-allocated
-  <code>Generator::apply&lt;T&gt;::type</code> object. The result is
-  installed in the extension class object.
+      <dt><b>Effects:</b> Creates a Python callable object which, when called
+      from Python, expects its first argument to be a Boost.Python extension
+      class object. It converts its remaining its arguments to C++ and passes
+      them to the constructor of a dynamically-allocated
+      <code>Generator::apply&lt;T&gt;::type</code> object. The result is
+      installed in the extension class object.
 
-</dt>
+      <dt><b>Returns:</b> The new Python callable object
+    </dl>
 
-  <dt><b>Returns:</b> The new Python callable object</dt>
-
-</dl>
-
-<h2><a name="examples"></a>Example</h2>
-
-<p>C++ function exposed below returns a callable object wrapping one
-of two functions.
+    <h2><a name="examples"></a>Example</h2>
 
+    <p>C++ function exposed below returns a callable object wrapping one of two
+    functions.
 <pre>
 #include &lt;boost/python/make_function.hpp&gt;
 #include &lt;boost/python/module.hpp&gt;
@@ -132,8 +125,7 @@ BOOST_PYTHON_MODULE_INIT(make_function_test)
         .def("choose_function", choose_function);
 }
 </pre>
-</p>
-It can be used this way in Python:
+    It can be used this way in Python: 
 <pre>
 &gt;&gt;&gt; from make_function_test import *
 &gt;&gt;&gt; f = choose_function(1)
@@ -144,12 +136,11 @@ It can be used this way in Python:
 'bar'
 </pre>
 
-<p>
-<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-14 February 2002
-<!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+    14 February 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/manage_new_object.html b/doc/v2/manage_new_object.html
index cc5aab2a..112e540f 100644
--- a/doc/v2/manage_new_object.html
+++ b/doc/v2/manage_new_object.html
@@ -1,50 +1,62 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/manage_new_object.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/manage_new_object.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/manage_new_object.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
-    <dt><a href="#manage_new_object-spec">Class <code>manage_new_object</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#manage_new_object-spec-synopsis">Class <code>manage_new_object</code> synopsis</a></dt>
-	  <dt><a href="#manage_new_object-spec-metafunctions">Class <code>manage_new_object</code> metafunctions</a></dt>
-	</dl>
-  </dl>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#examples">Example</a></dt>
-</dl>
-<hr>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-<h2><a name="classes"></a>Classes</h2>
+          <h2 align="center">Header
+          &lt;boost/python/manage_new_object.hpp&gt;</h2>
+    </table>
+    <hr>
 
-<h3><a name="manage_new_object-spec"></a>Class <code>manage_new_object</code></h3>
-<p>
-<code>manage_new_object</code> is a model of <a
-href="ResultConverterGenerator.html">ResultConverterGenerator</a>
-which can be used to wrap C++ functions which return a pointer to an
-object allocated with a <i>new-expression</i>, and expect the caller
-to take responsibility for deleting that object.
-</p>
+    <h2>Contents</h2>
 
-<h4><a name="manage_new_object-spec-synopsis"></a>Class <code>manage_new_object</code> synopsis</h4>
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#manage_new_object-spec">Class
+          <code>manage_new_object</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#manage_new_object-spec-synopsis">Class
+              <code>manage_new_object</code> synopsis</a>
+
+              <dt><a href="#manage_new_object-spec-metafunctions">Class
+              <code>manage_new_object</code> metafunctions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="manage_new_object-spec"></a>Class
+    <code>manage_new_object</code></h3>
+
+    <p><code>manage_new_object</code> is a model of <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions which return a pointer to an object allocated
+    with a <i>new-expression</i>, and expect the caller to take responsibility
+    for deleting that object.
+
+    <h4><a name="manage_new_object-spec-synopsis"></a>Class
+    <code>manage_new_object</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -54,19 +66,25 @@ namespace boost { namespace python
     };
 }}
 </pre>
-<h4><a name="manage_new_object-spec-metafunctions"></a>Class <code>manage_new_object</code> metafunctions</h4>
+
+    <h4><a name="manage_new_object-spec-metafunctions"></a>Class
+    <code>manage_new_object</code> metafunctions</h4>
 <pre>
 template &lt;class T&gt; struct apply
 </pre>
-<dl class="metafunction-semantics"> 
-  <dt><b>Requires:</b> <code>T</code> is <code>U*</code> for some <code>U</code>.</dt>
-  <dt><b>Returns:</b> <code>typedef <a href="to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T&gt; type;</code></dt>
-</dl>
 
-<h2><a name="examples"></a>Example</h2>
+    <dl class="metafunction-semantics">
+      <dt><b>Requires:</b> <code>T</code> is <code>U*</code> for some
+      <code>U</code>.
 
-<p> In C++:
+      <dt><b>Returns:</b> <code>typedef <a href=
+      "to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T&gt;
+      type;</code>
+    </dl>
 
+    <h2><a name="examples"></a>Example</h2>
+
+    <p>In C++:
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -87,16 +105,14 @@ using namespace boost::python;
 BOOST_PYTHON_MODULE_INIT(my_module)
 {
    module m("my_module")
-      .def(&quot;make_foo&quot;, make_foo)
+      .def("make_foo", make_foo)
       .add(
          class_&lt;Foo&gt;()
-            .def(&quot;get_x&quot;, &amp;Foo::get_x)
+            .def("get_x", &amp;Foo::get_x)
          )
 }
 </pre>
-
-In Python:
-
+In Python: 
 <pre>
 &gt;&gt;&gt; from my_module import *
 &gt;&gt;&gt; f = make_foo(3)     # create a Foo object
@@ -104,12 +120,11 @@ In Python:
 3
 </pre>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  14 February 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     14 February 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+
diff --git a/doc/v2/reference.html b/doc/v2/reference.html
index 0aa546e5..5e2e4463 100644
--- a/doc/v2/reference.html
+++ b/doc/v2/reference.html
@@ -1,271 +1,383 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - Reference</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - Reference</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "reference">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="http://www.boost.org"><img height="86" width="277" alt="C++ Boost" src="../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Reference</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="Reference">
-  <dt><a href="#high_level">High Level Components</a></dt>
-  <dt><a href="#framework">Framework Elements</a></dt>
-  <dt><a href="#utilities">Utilities</a></dt>
-  <dt><a href="#by_name">Index By Name</a></dt>
-</dl>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="http://www.boost.org"><img height="86" width="277" alt=
+          "C++ Boost" src="../c++boost.gif" border="0"></a></h3>
 
-<a name="high_level"></a><h2>High Level Components</h2>
-  <dl class="index">
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-<a name="general_purpose"></a><h3>General Purpose</h3>
-  <dl class="index">
+          <h2 align="center">Reference</h2>
+    </table>
+    <hr>
 
-    <dt><a href="class.html">class.hpp/class_fwd.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="class.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="class.html#class_-spec">class_</a></dt>
-	    <dt><a href="class.html#bases-spec">bases</a></dt>
-	    <dt><a href="class.html#args-spec">args</a></dt>
-	  </dl>
+    <h2>Contents</h2>
+
+    <dl class="Reference">
+      <dt><a href="#high_level">High Level Components</a>
+
+      <dt><a href="#framework">Framework Elements</a>
+
+      <dt><a href="#utilities">Utilities</a>
+
+      <dt><a href="#by_name">Index By Name</a>
+    </dl>
+    <a name="high_level"></a>
+
+    <h2>High Level Components</h2>
+
+    <dl class="index">
+      <dd>
+        <a name="general_purpose"></a>
+
+        <h3>General Purpose</h3>
+
+        <dl class="index">
+          <dt><a href="class.html">class.hpp/class_fwd.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="class.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href="class.html#class_-spec">class_</a>
+
+                  <dt><a href="class.html#bases-spec">bases</a>
+
+                  <dt><a href="class.html#args-spec">args</a>
+                </dl>
+            </dl>
+
+          <dt><a href="errors.html">errors.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="errors.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "errors.html#error_already_set-spec">error_already_set</a>
+                </dl>
+
+              <dt><a href="errors.html#functions">Functions</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "errors.html#handle_exception-spec">handle_exception</a>
+
+                  <dt><a href=
+                  "errors.html#expect_non_null-spec">expect_non_null</a>
+                </dl>
+            </dl>
+
+          <dt><a href="make_function.html">make_function.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="make_function.html#classes">Functions</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "make_function.html#make_function-spec">make_function</a>
+
+                  <dt><a href=
+                  "make_.html#make_constructor-spec">make_constructor</a>
+                </dl>
+            </dl>
+
+          <dt><a href="module.html">module.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="module.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href="module.html#module-spec">module</a>
+                </dl>
+            </dl>
+
+          <dt><a href="objects.html">objects.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="objects.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href="objects.html#xxx-spec">not yet documented</a>
+                </dl>
+            </dl>
+
+          <dt><a href="reference_hpp.html">reference.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="reference_hpp.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href="reference_hpp.html#reference-spec">reference</a>
+                </dl>
+
+              <dt><a href="reference_hpp.html#types">Types</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href="reference_hpp.html#ref-spec">ref</a>
+                </dl>
+            </dl>
+        </dl>
+        <a name="type_conversion"></a>
+
+        <h3>To/From Python Type Conversion</h3>
+
+        <dl class="index">
+          <dt><a href="from_python.html">from_python.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="from_python.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "from_python.html#from_python-spec">from_python</a>
+                </dl>
+            </dl>
+
+          <dt><a href="to_python_converter.html">to_python_converter.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="to_python_converter.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "to_python_converter.html#to_python_converter-spec">to_python_converter</a>
+                </dl>
+            </dl>
+
+          <dt><a href="to_python_indirect.html">to_python_indirect.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="to_python_indirect.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>
+                </dl>
+            </dl>
+
+          <dt><a href="to_python_value.html">to_python_value.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="to_python_value.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "to_python_value.html#to_python_value-spec">to_python_value</a>
+                </dl>
+            </dl>
+
+          <dt><a href="type_from_python.html">type_from_python.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="type_from_python.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "type_from_python.html#type_from_python-spec">type_from_python</a>
+                </dl>
+            </dl>
+
+          <dt><a href="value_from_python.html">value_from_python.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="value_from_python.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "value_from_python.html#value_from_python-spec">value_from_python</a>
+                </dl>
+            </dl>
+        </dl>
+        <a name="models_of_call_policies"></a>
+
+        <h3>Models of CallPolicies</h3>
+
+        <dl class="index">
+          <dt><a href=
+          "default_call_policies.html">default_call_policies.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="default_call_policies.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "default_call_policies.html#default_call_policies-spec">default_call_policies</a>
+
+                  <dt><a href=
+                  "default_call_policies.html#default_result_converter-spec">default_result_converter</a>
+                </dl>
+            </dl>
+
+          <dt><a href=
+          "return_internal_reference.html">return_internal_reference.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="return_internal_reference.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "return_internal_reference.html#return_internal_reference-spec">
+                  return_internal_reference</a>
+                </dl>
+            </dl>
+
+          <dt><a href="return_value_policy.html">return_value_policy.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="return_value_policy.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "return_value_policy.html#return_value_policy-spec">return_value_policy</a>
+                </dl>
+            </dl>
+
+          <dt><a href=
+          "with_custodian_and_ward.html">with_custodian_and_ward.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="with_custodian_and_ward.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "with_custodian_and_ward.html#with_custodian_and_ward-spec">with_custodian_and_ward</a>
+
+                  <dt><a href=
+                  "with_custodian_and_ward.html#with_custodian_and_ward_postcall-spec">
+                  with_custodian_and_ward_postcall</a>
+                </dl>
+            </dl>
+        </dl>
+        <a name="return_handler_generators"></a>
+
+        <h3>Models of ReturnHandlerGenerator</h3>
+
+        <dl class="index">
+          <dt><a href="copy_const_reference.html">copy_const_reference.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="copy_const_reference.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "copy_const_reference.html#copy_const_reference-spec">copy_const_reference</a>
+                </dl>
+            </dl>
+
+          <dt><a href=
+          "copy_non_const_reference.html">copy_non_const_reference.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="copy_non_const_reference.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "copy_non_const_reference.html#copy_non_const_reference-spec">
+                  copy_non_const_reference</a>
+                </dl>
+            </dl>
+
+          <dt><a href="manage_new_object.html">manage_new_object.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="manage_new_object.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "manage_new_object.html#manage_new_object-spec">manage_new_object</a>
+                </dl>
+            </dl>
+
+          <dt><a href=
+          "reference_existing_object.html">reference_existing_object.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="reference_existing_object.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "reference_existing_object.html#reference_existing_object-spec">
+                  reference_existing_object</a>
+                </dl>
+            </dl>
+
+          <dt><a href=
+          "reference_from_python.html">reference_from_python.hpp</a>
+
+          <dd>
+            <dl class="index">
+              <dt><a href="reference_from_python.html#classes">Classes</a>
+
+              <dd>
+                <dl class="index">
+                  <dt><a href=
+                  "reference_from_python.html#reference_from_python-spec">reference_from_python</a>
+
+                  <dt><a href=
+                  "reference_from_python.html#get_member-spec">get_member</a>
+                </dl>
+            </dl>
+        </dl>
+    </dl>
+    <hr>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2002 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
-	</dl>
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
 
-    <dt><a href="errors.html">errors.hpp</a></dt>
-	<dl class="index">
-
-      <dt><a href="errors.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="errors.html#error_already_set-spec">error_already_set</a></dt>
-	  </dl>
-      <dt><a href="errors.html#functions">Functions</a></dt>
-	  <dl class="index">
-	    <dt><a href="errors.html#handle_exception-spec">handle_exception</a></dt>
-	    <dt><a href="errors.html#expect_non_null-spec">expect_non_null</a></dt>
-	  </dl>
-	</dl>
-
-    <dt><a href="make_function.html">make_function.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="make_function.html#classes">Functions</a></dt>
-	  <dl class="index">
-	    <dt><a href="make_function.html#make_function-spec">make_function</a></dt>
-	    <dt><a href="make_.html#make_constructor-spec">make_constructor</a></dt>
-	  </dl>
-	</dl>
-
-    <dt><a href="module.html">module.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="module.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="module.html#module-spec">module</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="objects.html">objects.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="objects.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="objects.html#xxx-spec">not yet documented</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="reference_hpp.html">reference.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="reference_hpp.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="reference_hpp.html#reference-spec">reference</a></dt>
-	  </dl>
-
-      <dt><a href="reference_hpp.html#types">Types</a></dt>
-	  <dl class="index">
-	    <dt><a href="reference_hpp.html#ref-spec">ref</a></dt>
-	  </dl>
-
-	</dl>
-
-
-      </dl>
-
-<a name="type_conversion"></a><h3>To/From Python Type Conversion</h3>
-  <dl class="index">
-
-    <dt><a href="from_python.html">from_python.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="from_python.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="from_python.html#from_python-spec">from_python</a></dt>
-	  </dl>
-	</dl>
-
-    <dt><a href="to_python_converter.html">to_python_converter.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="to_python_converter.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="to_python_converter.html#to_python_converter-spec">to_python_converter</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="to_python_indirect.html">to_python_indirect.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="to_python_indirect.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="to_python_value.html">to_python_value.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="to_python_value.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="to_python_value.html#to_python_value-spec">to_python_value</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="type_from_python.html">type_from_python.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="type_from_python.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="type_from_python.html#type_from_python-spec">type_from_python</a></dt>
-	  </dl>
-
-	</dl>
-
-
-    <dt><a href="value_from_python.html">value_from_python.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="value_from_python.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="value_from_python.html#value_from_python-spec">value_from_python</a></dt>
-	  </dl>
-
-	</dl>
-
-  </dl>
-
-
-<a name="models_of_call_policies"></a><h3>Models of CallPolicies</h3>
-  <dl class="index">
-
-    <dt><a href="default_call_policies.html">default_call_policies.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="default_call_policies.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="default_call_policies.html#default_call_policies-spec">default_call_policies</a></dt>
-	    <dt><a href="default_call_policies.html#default_result_converter-spec">default_result_converter</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="return_internal_reference.html">return_internal_reference.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="return_internal_reference.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="return_value_policy.html">return_value_policy.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="return_value_policy.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="return_value_policy.html#return_value_policy-spec">return_value_policy</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="with_custodian_and_ward.html">with_custodian_and_ward.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="with_custodian_and_ward.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="with_custodian_and_ward.html#with_custodian_and_ward-spec">with_custodian_and_ward</a></dt>
-	    <dt><a href="with_custodian_and_ward.html#with_custodian_and_ward_postcall-spec">with_custodian_and_ward_postcall</a></dt>
-	  </dl>
-
-	</dl>
-
-      </dl>
-
-<a name="return_handler_generators"></a><h3>Models of ReturnHandlerGenerator</h3>
-  <dl class="index">
-
-    <dt><a href="copy_const_reference.html">copy_const_reference.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="copy_const_reference.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="copy_const_reference.html#copy_const_reference-spec">copy_const_reference</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="copy_non_const_reference.html">copy_non_const_reference.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="copy_non_const_reference.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="copy_non_const_reference.html#copy_non_const_reference-spec">copy_non_const_reference</a></dt>
-	  </dl>
-
-	</dl>
-
-
-    <dt><a href="manage_new_object.html">manage_new_object.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="manage_new_object.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="manage_new_object.html#manage_new_object-spec">manage_new_object</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="reference_existing_object.html">reference_existing_object.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="reference_existing_object.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="reference_existing_object.html#reference_existing_object-spec">reference_existing_object</a></dt>
-	  </dl>
-
-	</dl>
-
-    <dt><a href="reference_from_python.html">reference_from_python.hpp</a></dt>
-	<dl class="index">
-      <dt><a href="reference_from_python.html#classes">Classes</a></dt>
-	  <dl class="index">
-	    <dt><a href="reference_from_python.html#reference_from_python-spec">reference_from_python</a></dt>
-	    <dt><a href="reference_from_python.html#get_member-spec">get_member</a></dt>
-	  </dl>
-
-	</dl>
-
-      </dl>
-
-  </dl>
-
-<hr>
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  05 November, 2002 
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
diff --git a/doc/v2/reference_existing_object.html b/doc/v2/reference_existing_object.html
index 3d19826a..c5d39756 100644
--- a/doc/v2/reference_existing_object.html
+++ b/doc/v2/reference_existing_object.html
@@ -1,62 +1,72 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-<link rel="stylesheet" type="text/css" href="../boost.css">
-<title>Boost.Python - &lt;boost/python/reference_existing_object.hpp&gt;</title>
-</head>
-<body link="#0000ff" vlink="#800080">
-<table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python -
+    &lt;boost/python/reference_existing_object.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
     "header">
-  <tr> 
-    <td valign="top" width="300"> 
-      <h3><a href="../../../../index.htm"><img height="86" width="277" alt="C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
-    </td>
-    <td valign="top"> 
-      <h1 align="center">Boost.Python</h1>
-      <h2 align="center">Header &lt;boost/python/reference_existing_object.hpp&gt;</h2>
-    </td>
-  </tr>
-</table>
-<hr>
-<h2>Contents</h2>
-<dl class="page-index"> 
-  <dt><a href="#classes">Classes</a></dt>
-  <dl class="page-index">
-    <dt><a href="#reference_existing_object-spec">Class <code>reference_existing_object</code></a></dt>
-	<dl class="page-index">
-	  <dt><a href="#reference_existing_object-spec-synopsis">Class <code>reference_existing_object</code> synopsis</a></dt>
-	  <dt><a href="#reference_existing_object-spec-metafunctions">Class <code>reference_existing_object</code> metafunctions</a></dt>
-	</dl>
-  </dl>
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
 
-  <dt><a href="#examples">Example</a></dt>
-</dl>
-<hr>
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
 
-<h2><a name="classes"></a>Classes</h2>
+          <h2 align="center">Header
+          &lt;boost/python/reference_existing_object.hpp&gt;</h2>
+    </table>
+    <hr>
 
-<h3><a name="reference_existing_object-spec"></a>Class <code>reference_existing_object</code></h3>
-<p>
-<code>reference_existing_object</code> is a model of <a
-href="ResultConverterGenerator.html">ResultConverterGenerator</a>
-which can be used to wrap C++ functions which return a reference or
-pointer to a C++ object. When the wrapped function is called, the
-value referenced by its return value is not copied. A new Python
-object is created which contains a pointer to the referent, and no
-attempt is made to ensure that the lifetime of the referent is at
-least as long as that of the corresponding Python object. Thus, it can
-be <font color="#ff0000"><b>highly dangerous</b></font> to use
-<code>reference_existing_object</code> without additional lifetime
-management from such models of <a
-href="CallPolicies.html">CallPolicies</a> as <a
-href="with_custodian_and_ward.html#with_custodian_and_ward-spec"
->with_custodian_and_ward</a>. This class is used in the implementation
-of <a
-href="return_internal_reference.html#return_internal_reference-spec"
->return_internal_reference</a>.
-</p>
+    <h2>Contents</h2>
 
-<h4><a name="reference_existing_object-spec-synopsis"></a>Class <code>reference_existing_object</code> synopsis</h4>
+    <dl class="page-index">
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#reference_existing_object-spec">Class
+          <code>reference_existing_object</code></a>
+
+          <dd>
+            <dl class="page-index">
+              <dt><a href="#reference_existing_object-spec-synopsis">Class
+              <code>reference_existing_object</code> synopsis</a>
+
+              <dt><a href="#reference_existing_object-spec-metafunctions">Class
+              <code>reference_existing_object</code> metafunctions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="reference_existing_object-spec"></a>Class
+    <code>reference_existing_object</code></h3>
+
+    <p><code>reference_existing_object</code> is a model of <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a> which can be
+    used to wrap C++ functions which return a reference or pointer to a C++
+    object. When the wrapped function is called, the value referenced by its
+    return value is not copied. A new Python object is created which contains a
+    pointer to the referent, and no attempt is made to ensure that the lifetime
+    of the referent is at least as long as that of the corresponding Python
+    object. Thus, it can be <font color="#ff0000"><b>highly
+    dangerous</b></font> to use <code>reference_existing_object</code> without
+    additional lifetime management from such models of <a href=
+    "CallPolicies.html">CallPolicies</a> as <a href=
+    "with_custodian_and_ward.html#with_custodian_and_ward-spec">with_custodian_and_ward</a>.
+    This class is used in the implementation of <a href=
+    "return_internal_reference.html#return_internal_reference-spec">return_internal_reference</a>.
+
+    <h4><a name="reference_existing_object-spec-synopsis"></a>Class
+    <code>reference_existing_object</code> synopsis</h4>
 <pre>
 namespace boost { namespace python
 {
@@ -66,27 +76,29 @@ namespace boost { namespace python
     };
 }}
 </pre>
-<h4><a name="reference_existing_object-spec-metafunctions"></a>Class <code>reference_existing_object</code> metafunctions</h4>
+
+    <h4><a name="reference_existing_object-spec-metafunctions"></a>Class
+    <code>reference_existing_object</code> metafunctions</h4>
 <pre>
 template &lt;class T&gt; struct apply
 </pre>
-<dl class="metafunction-semantics"> 
-  <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> or <code>U*</code>for some <code>U</code>.</dt>
 
-  <dt><b>Returns:</b> <code>typedef <a
-  href="to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T,V&gt;
-  type</code>, where <code>V</code> is a <a
-  href="to_python_indirect.html#HolderObjectGenerator"> which
-  constructs an instance holder containing an <i>unowned</i>
-  <code>U*</code> pointing to the referent of the wrapped function's
-  return value.</dt>
+    <dl class="metafunction-semantics">
+      <dt><b>Requires:</b> <code>T</code> is <code>U&amp;</code> or
+      <code>U*</code>for some <code>U</code>.
 
-</dl>
+      <dt><b>Returns:</b> <code>typedef <a href=
+      "to_python_indirect.html#to_python_indirect-spec">to_python_indirect</a>&lt;T,V&gt;
+      type</code>, where <code>V</code> is a <a href=
+      "to_python_indirect.html#HolderObjectGenerator">HolderObjectGenerator</a>
+      which constructs an instance holder containing an <i>unowned</i>
+      <code>U*</code> pointing to the referent of the wrapped function's return
+      value.
+    </dl>
 
-<h2><a name="examples"></a>Example</h2>
-
-<p> In C++:
+    <h2><a name="examples"></a>Example</h2>
 
+    <p>In C++:
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -119,16 +131,14 @@ using namespace boost::python;
 BOOST_PYTHON_MODULE_INIT(singleton)
 {
    module m("singleton")
-      .def(&quot;get_it&quot;, get_it)
+      .def("get_it", get_it)
       .add(
          class_&lt;Singleton&gt;()
-            .def(&quot;exchange&quot;, &amp;Singleton::exchange)
+            .def("exchange", &amp;Singleton::exchange)
          );
 }
 </pre>
-
-In Python:
-
+    In Python: 
 <pre>
 &gt;&gt;&gt; import singleton
 &gt;&gt;&gt; s1 = singleton.get_it()  
@@ -141,12 +151,11 @@ In Python:
 42
 </pre>
 
-<p>Revised 
-  <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-  14 February 2002
-  <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
-</p>
-<p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave Abrahams</a> 
-  2002. All Rights Reserved.</i></p>
-</body>
-</html>
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     14 February 2002 <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From 4481c3badae4cca6d0acc7d1e516b374378baa2b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Feb 2002 16:20:22 +0000
Subject: [PATCH 279/369] initial checkin

[SVN r12818]
---
 doc/v2/lvalue_from_python.html | 278 +++++++++++++++++++++++++++++++++
 1 file changed, 278 insertions(+)
 create mode 100644 doc/v2/lvalue_from_python.html

diff --git a/doc/v2/lvalue_from_python.html b/doc/v2/lvalue_from_python.html
new file mode 100644
index 00000000..74e94a23
--- /dev/null
+++ b/doc/v2/lvalue_from_python.html
@@ -0,0 +1,278 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/lvalue_from_python.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;boost/python/lvalue_from_python.hpp&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#lvalue_from_python-spec">Class Template <code>lvalue_from_python</code></a>
+
+          <dd>
+            <dl class="page-index">
+
+              <dt><a href="#lvalue_from_python-spec-synopsis">Class Template
+              <code>lvalue_from_python</code> synopsis</a>
+
+              <dt><a href="#lvalue_from_python-spec-ctors">Class Template
+              <code>lvalue_from_python</code> constructor</a>
+            </dl>
+        </dl>
+
+        <dl class="page-index">
+          <dt><a href="#get_member-spec">Class Template <code>get_member</code></a>
+
+          <dd>
+            <dl class="page-index">
+
+              <dt><a href="#get_member-spec-synopsis">Class Template
+              <code>get_member</code> synopsis</a>
+
+              <dt><a href="#get_member-spec-statics">Class Template
+              <code>get_member</code> static functions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <code>&lt;boost/python/lvalue_from_python.hpp&gt;</code> supplies
+    a facility for extracting C++ objects from within instances of a
+    given Python type. This is typically useful for dealing with
+    &quot;traditional&quot; Python extension types.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="lvalue_from_python-spec"></a>Class template <code>lvalue_from_python</code></h3>
+
+    <p>Class template <code>lvalue_from_python</code> will register
+    from_python converters which extract a references and pointers to
+    a C++ type which is held within an object of a given Python
+    type. Its template arguments are:
+
+    <p>
+
+
+    <table border="1" summary="lvalue_from_python template parameters">
+      <caption>
+        <b><code>lvalue_from_python</code> Requirements</b><br>
+
+        In the table below, <b><code>x</code></b> denotes an object of type <code>PythonObject&amp;</code>
+
+      </caption>
+      <tr>
+        <th>Parameter
+        
+        <th>Requirements
+
+        <th>Description
+
+        <th>Default
+
+      <tr>
+        <td><code>python_type</code> 
+
+        <td>A compile-time constant PyTypeObject*
+
+        <td>The Python type of instances convertible by this
+        converter. Python subtypes are also convertible.
+
+      <tr>
+        <td><code>Value</code> 
+
+        <td>A non-reference type.
+
+        <td>The C++ type to be extracted
+
+      <tr>
+        <td><code>PythonObject</code> 
+
+        <td>initial <code>sizeof(PyObject)</code> bytes are
+        layout-compatible with <code>PyObject</code>.
+
+        <td>The C++ type used to hold Python instances of
+        <code>python_type</code>.
+
+        <td><code>Value</code> 
+
+      <tr>
+        <td><code>Extract</code> 
+
+        <td><code>Value&amp; v = Extract::execute(x);</code> 
+
+        <td>A type whose static <code>execute</code> function extracts a <code>Value</code> reference from within an object of type <code>PythonObject</code>.
+
+        <td>An unspecified type whose <code>execute</code> function consists of <code>return&nbsp;x;</code>
+    </table>
+
+    If only the first two template arguments are supplied, these
+    converters extract the entire <code>PythonObject</code> as a
+    whole.
+
+    <p>
+
+    If the lifetime of the <code>lvalue_from_python</code> object ends
+    before the last attempt to convert to one its target types, the
+    behavior is undefined. The easiest way to ensure correct behavior
+    is to declare an <code>lvalue_from_python</code> instance as a
+    static local in a <a
+    href="module.html#BOOST_PYTHON_MODULE_INIT-spec">module init
+    function</a>, as shown in the <a href="#examples">example</a>
+    below.
+
+    <h4><a name="lvalue_from_python-spec-synopsis"></a>Class template <code>lvalue_from_python</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+   template &lt;
+      PyTypeObject const* python_type
+      , class Value
+      , class PythonObject = Value
+      , class Extract = <i>unspecified</i>
+      &gt;
+   class lvalue_from_python
+   {
+      lvalue_from_python();
+   };
+}}
+</pre>
+
+    <h4><a name="lvalue_from_python-spec-ctors"></a>Class template <code>lvalue_from_python</code> constructor</h4>
+<pre>
+lvalue_from_python();
+</pre>
+
+    <dl class="function-semantics">
+
+      <dt><b>Effects:</b> Registers from_python converters which
+      extract
+      <code>Value&amp;</code>, <code>Value const&amp;</code>,
+      <code>Value*</code>, or <code>Value const*</code> from Python
+      objects of type <code>python_type</code> using
+      <code>Extract::execute()</code>.
+
+    </dl>
+
+    <h3><a name="get_member-spec"></a>Class template <code>get_member</code></h3>
+
+    <p><code>get_member</code> can be used with
+    <code>lvalue_from_python</code> in the common case where the C++
+    type to be extracted is a member of the Python object.
+
+    <h4><a name="get_member-spec-synopsis"></a>Class template <code>get_member</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+  template &lt;class Class, class Member, Member (Class::*mp)&gt;
+  struct get_member
+  {
+     static Member&amp; execute(Class&amp; c);
+  };
+}}
+</pre>
+
+    <h4><a name="get_member-spec-statics"></a>Class template <code>get_member</code> static functions</h4>
+<pre>
+Member&amp; execute(Class&amp; c);
+</pre>
+
+    <dl class="function-semantics">
+
+      <dt><b>Returns:</b> <code>c.*mp</code>
+
+    </dl>
+
+
+    <h2><a name="examples"></a>Example(s)</h2>
+
+This example presumes that someone has implemented the standard <a
+href="http://www.python.org/doc/current/ext/dnt-basics.html">noddy
+example module</a> from the Python documentation, and we want to build
+a module which manipulates <code>Noddy</code>s. Since
+<code>noddy_NoddyObject</code> is so simple that it carries no
+interesting information, the example is a bit contrived: it assumes
+you want to keep track of one particular object for some reason.
+
+<h3>C++ module definition</h3>
+
+<pre>
+#include &lt;boost/python/reference.hpp&gt;
+#include &lt;boost/python/module.hpp&gt;
+
+// definition lifted from the Python docs
+typedef struct {
+   PyObject_HEAD
+} noddy_NoddyObject;
+
+using namespace boost::python;
+static ref cache;
+
+bool is_cached(noddy_NoddyObject* x)
+{
+   return x == cache.get();
+}
+
+void set_cache(noddy_NoddyObject* x)
+{
+   cache.reset((PyObject*)x, ref::increment_count);
+}
+
+BOOST_PYTHON_MODULE_INIT(noddy_cache)
+{
+   module noddy_cache(&quot;noddy_cache&quot;)
+      .def(&quot;is_cached&quot;, is_cached)
+      .def(&quot;set_cache&quot;, set_cache)
+      ;
+}
+</pre>
+
+<h3>Python code</h3>
+
+<pre>
+&gt;&gt;&gt; import noddy
+&gt;&gt;&gt; n = noddy.new_noddy()
+&gt;&gt;&gt; import noddy_cache
+&gt;&gt;&gt; noddy_cache.is_cached(n)
+0
+&gt;&gt;&gt; noddy_cache.set_cache(n)
+&gt;&gt;&gt; noddy_cache.is_cached(n)
+1
+&gt;&gt;&gt; noddy_cache.is_cached(noddy.new_noddy())
+0
+</pre>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From 371723a5d4d2b3e94c57163a6adf0ed59bce6c43 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Feb 2002 16:37:00 +0000
Subject: [PATCH 280/369] little fixes

[SVN r12819]
---
 doc/v2/lvalue_from_python.html | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/doc/v2/lvalue_from_python.html b/doc/v2/lvalue_from_python.html
index 74e94a23..03af54f8 100644
--- a/doc/v2/lvalue_from_python.html
+++ b/doc/v2/lvalue_from_python.html
@@ -98,7 +98,8 @@
       <tr>
         <td><code>python_type</code> 
 
-        <td>A compile-time constant PyTypeObject*
+        <td>A compile-time constant <code><a
+        href="http://www.python.org/doc/current/ext/dnt-type-methods.html">PyTypeObject</a>*</code>
 
         <td>The Python type of instances convertible by this
         converter. Python subtypes are also convertible.
@@ -209,7 +210,7 @@ Member&amp; execute(Class&amp; c);
     </dl>
 
 
-    <h2><a name="examples"></a>Example(s)</h2>
+    <h2><a name="examples"></a>Example</h2>
 
 This example presumes that someone has implemented the standard <a
 href="http://www.python.org/doc/current/ext/dnt-basics.html">noddy

From b303d49634423240d8a8e0190eb6d7ffcf620b4a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Feb 2002 16:59:39 +0000
Subject: [PATCH 281/369] remove defunct code

[SVN r12820]
---
 .../python/return_internal_reference.hpp      | 25 -------------------
 1 file changed, 25 deletions(-)

diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
index d696c7fa..2f567e55 100644
--- a/include/boost/python/return_internal_reference.hpp
+++ b/include/boost/python/return_internal_reference.hpp
@@ -7,36 +7,11 @@
 # define RETURN_INTERNAL_REFERENCE_DWA2002131_HPP
 
 # include <boost/python/default_call_policies.hpp>
-# include <boost/type_traits/object_traits.hpp>
 # include <boost/python/reference_existing_object.hpp>
-# include <boost/python/to_python_indirect.hpp>
 # include <boost/python/with_custodian_and_ward.hpp>
 
 namespace boost { namespace python { 
 
-namespace detail
-{
-  template <class T>
-  struct return_internal_reference_requires_a_pointer_or_reference_return_type
-# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
-  {}
-# endif
-  ;
-}
-
-struct internal_reference_to_python_generator
-{
-    template <class T>
-    struct apply
-    {
-        typedef typename mpl::select_type<
-            is_object<T>::value
-            , detail::return_internal_reference_requires_a_pointer_or_reference_return_type<T>
-            , to_python_indirect<T, detail::make_reference_holder>
-        >::type type;
-    };
-};
-
 template <std::size_t owner_arg = 1, class Base = default_call_policies>
 struct return_internal_reference
     : with_custodian_and_ward_postcall<0, owner_arg, Base>

From 09d012a10b5b5c024743bc63faf7082668d3fb4a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Feb 2002 18:31:22 +0000
Subject: [PATCH 282/369] *** empty log message ***

[SVN r12823]
---
 doc/v2/class.html                     |   9 +-
 doc/v2/header.html                    |  31 ++--
 doc/v2/module.html                    |  12 +-
 doc/v2/reference.html                 |   8 +-
 doc/v2/return_internal_reference.html | 205 ++++++++++++++++++++++++++
 5 files changed, 236 insertions(+), 29 deletions(-)
 create mode 100644 doc/v2/return_internal_reference.html

diff --git a/doc/v2/class.html b/doc/v2/class.html
index 85e24993..fc64eabd 100644
--- a/doc/v2/class.html
+++ b/doc/v2/class.html
@@ -191,7 +191,7 @@ template &lt;class F&gt;
 class_&amp; def(char const* name, F f)
 
 template &lt;class Fn, class CallPolicy&gt;
-class_&amp; def(char const* name, Fn fn, CallPolicy policy)
+class_&amp; def(char const* name, Fn f, CallPolicy policy)
 </pre>
 
     <dl class="function-semantics">
@@ -199,8 +199,11 @@ class_&amp; def(char const* name, Fn fn, CallPolicy policy)
       pointer-to-member-function. <code>name</code> is a ntbs which conforms to
       Python's <a href=
       "http://www.python.org/doc/current/ref/identifiers.html">identifier
-      naming rules</a>. If supplied, <code>policy</code> conforms to the <a
-      href="CallPolicy.html">CallPolicy</a> concept requirements.
+      naming rules</a>. In the first form, the return type of
+      <code>f</code> is not a reference and is not a pointer other
+      than <code>char const*</code> or <code>PyObject*</code>. In the
+      second form <code>policy</code> is a model of <a
+      href="CallPolicies.html">CallPolicies</a>.
 
       <dt><b>Effects:</b> Adds the result of <code><a href=
       "make_function.html#make_function-spec">make_function</a>(f)</code> to
diff --git a/doc/v2/header.html b/doc/v2/header.html
index 7b36a65c..7b65547d 100644
--- a/doc/v2/header.html
+++ b/doc/v2/header.html
@@ -49,27 +49,22 @@
 
       <dd>
         <dl class="page-index">
-          <dt><a href="#class-spec">Class <code>{{class name}}</code></a>
+          <dt><a href="#class-spec">Class <code>{{name}}</code></a>
 
           <dd>
             <dl class="page-index">
-              <dt><a href="#class-spec-synopsis">Class <code>{{class
-              name}}</code> synopsis</a>
+              <dt><a href="#class-spec-synopsis">Class <code>{{name}}</code> synopsis</a>
 
-              <dt><a href="#class-spec-ctors">Class <code>{{class name}}</code>
+              <dt><a href="#class-spec-ctors">Class <code>{{name}}</code>
               constructors and destructor</a>
 
-              <dt><a href="#class-spec-comparisons">Class <code>{{class
-              name}}</code> comparison functions</a>
+              <dt><a href="#class-spec-comparisons">Class <code>{{name}}</code> comparison functions</a>
 
-              <dt><a href="#class-spec-modifiers">Class <code>{{class
-              name}}</code> modifier functions</a>
+              <dt><a href="#class-spec-modifiers">Class <code>{{name}}</code> modifier functions</a>
 
-              <dt><a href="#class-spec-observers">Class <code>{{class
-              name}}</code> observer functions</a>
+              <dt><a href="#class-spec-observers">Class <code>{{name}}</code> observer functions</a>
 
-              <dt><a href="#class-spec-statics">Class <code>{{class
-              name}}</code> static functions</a>
+              <dt><a href="#class-spec-statics">Class <code>{{name}}</code> static functions</a>
             </dl>
         </dl>
 
@@ -113,7 +108,7 @@
 
     <p>{{class overview text}}
 
-    <h4><a name="class-spec-synopsis"></a>Class {{name}} synopsis</h4>
+    <h4><a name="class-spec-synopsis"></a>Class <code>{{name}}</code> synopsis</h4>
 <pre>
 namespace boost
 {
@@ -123,7 +118,7 @@ namespace boost
 };
 </pre>
 
-    <h4><a name="class-spec-ctors"></a>Class {{name}} constructors and
+    <h4><a name="class-spec-ctors"></a>Class <code>{{name}}</code> constructors and
     destructor</h4>
 <pre>
 {{constructor}}
@@ -164,7 +159,7 @@ namespace boost
       <dt><b>Rationale:</b> {{text}}
     </dl>
 
-    <h4><a name="class-spec-comparisons"></a>Class {{name}} comparison
+    <h4><a name="class-spec-comparisons"></a>Class <code>{{name}}</code> comparison
     functions</h4>
 <pre>
 {{function}}
@@ -186,7 +181,7 @@ namespace boost
       <dt><b>Rationale:</b> {{text}}
     </dl>
 
-    <h4><a name="class-spec-modifiers"></a>Class {{name}} modifier
+    <h4><a name="class-spec-modifiers"></a>Class <code>{{name}}</code> modifier
     functions</h4>
 <pre>
 {{function}}
@@ -208,7 +203,7 @@ namespace boost
       <dt><b>Rationale:</b> {{text}}
     </dl>
 
-    <h4><a name="class-spec-observers"></a>Class {{name}} observer
+    <h4><a name="class-spec-observers"></a>Class <code>{{name}}</code> observer
     functions</h4>
 <pre>
 {{function}}
@@ -230,7 +225,7 @@ namespace boost
       <dt><b>Rationale:</b> {{text}}
     </dl>
 
-    <h4><a name="class-spec-statics"></a>Class {{name}} static functions</h4>
+    <h4><a name="class-spec-statics"></a>Class <code>{{name}}</code> static functions</h4>
 <pre>
 {{function}}
 </pre>
diff --git a/doc/v2/module.html b/doc/v2/module.html
index f39ff4e8..0e3516ed 100644
--- a/doc/v2/module.html
+++ b/doc/v2/module.html
@@ -188,19 +188,23 @@ module&amp; add(class_&lt;T,Bases,HolderGenerator&gt; const&amp; c);
     </dl>
 <pre>
 template &lt;class Fn&gt;
-module&amp; def(char const* name, Fn fn);
+module&amp; def(char const* name, Fn f);
 
 template &lt;class Fn, class ResultHandler&gt;
-module&amp; def(char const* name, Fn fn, ResultHandler handler);
+module&amp; def(char const* name, Fn f, ResultHandler handler);
 </pre>
 
     <dl class="function-semantics">
+
       <dt><b>Requires:</b> <code>f</code> is a non-null pointer-to-function or
       pointer-to-member-function. <code>name</code> is a ntbs which conforms to
       Python's <a href=
       "http://www.python.org/doc/current/ref/identifiers.html">identifier
-      naming rules</a>. If supplied, <code>policy</code> conforms to the <a
-      href="CallPolicy.html">CallPolicy</a> concept requirements.
+      naming rules</a>. In the first form, the return type of
+      <code>f</code> is not a reference and is not a pointer other
+      than <code>char const*</code> or <code>PyObject*</code>. In the
+      second form <code>policy</code> is a model of <a
+      href="CallPolicy.html">CallPolicy</a>.
 
       <dt><b>Effects:</b> Adds the result of <code><a href=
       "make_function.html#make_function-spec">make_function</a>(f)</code> to
diff --git a/doc/v2/reference.html b/doc/v2/reference.html
index 5e2e4463..5f82fe4d 100644
--- a/doc/v2/reference.html
+++ b/doc/v2/reference.html
@@ -353,19 +353,19 @@
             </dl>
 
           <dt><a href=
-          "reference_from_python.html">reference_from_python.hpp</a>
+          "lvalue_from_python.html">reference_from_python.hpp</a>
 
           <dd>
             <dl class="index">
-              <dt><a href="reference_from_python.html#classes">Classes</a>
+              <dt><a href="lvalue_from_python.html#classes">Classes</a>
 
               <dd>
                 <dl class="index">
                   <dt><a href=
-                  "reference_from_python.html#reference_from_python-spec">reference_from_python</a>
+                  "lvalue_from_python.html#reference_from_python-spec">reference_from_python</a>
 
                   <dt><a href=
-                  "reference_from_python.html#get_member-spec">get_member</a>
+                  "lvalue_from_python.html#get_member-spec">get_member</a>
                 </dl>
             </dl>
         </dl>
diff --git a/doc/v2/return_internal_reference.html b/doc/v2/return_internal_reference.html
new file mode 100644
index 00000000..c1b62a56
--- /dev/null
+++ b/doc/v2/return_internal_reference.html
@@ -0,0 +1,205 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/return_internal_reference.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;boost/python/return_internal_reference.hpp&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#return_internal_reference-spec">Class Template <code>return_internal_reference</code></a>
+
+          <dd>
+            <dl class="page-index">
+
+              <dt><a href="#return_internal_reference-spec-synopsis">Class Template
+              <code>return_internal_reference</code> synopsis</a>
+
+              <dt><a href="#return_internal_reference-spec-statics">Class
+              <code>return_internal_reference</code> static functions</a>
+            </dl>
+        </dl>
+
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <code>return_internal_reference</code> instantiations are models of <a href=
+    "CallPolicies.html">CallPolicies</a> which allow pointers and
+    references to objects held internally by a free or member function
+    argument or from the target of a member function to be returned
+    safely without making a copy of the referent. The default for its
+    first template argument handles the common case where the
+    containing object is the target (<code>*this</code>) of a wrapped member function.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="return_internal_reference-spec"></a>Class template <code>return_internal_reference</code></h3>
+
+
+    <table border="1" summary="return_internal_reference template parameters">
+      <caption>
+        <b><code>return_internal_reference</code> template parameters</b>
+      </caption>
+      <tr>
+        <th>Parameter
+        
+        <th>Requirements
+
+        <th>Description
+
+        <th>Default
+
+      <tr>
+        <td><code>owner_arg</code> 
+
+        <td>A positive compile-time constant of type
+        <code>std::size_t</code>.
+
+        <td>The index of the parameter which contains the object to
+        which the reference or pointer is being returned. If used to
+        wrap a member function, parameter 1 is the target object
+        (<code>*this</code>).
+
+        <td>1
+
+      <tr>
+        <td><code>Base</code> 
+
+        <td>A model of <a href="CallPolicies.html">CallPolicies</a>
+
+        <td>Used for policy composition. Any
+        <code>result_converter</code> it supplies will be overridden by
+        <code>return_internal_reference</code>, but its
+        <code>precall</code> and <code>postcall</code> policies are
+        composed as described here <a
+        href="CallPolicies.html#composition">CallPolicies</a>.
+
+        <td><code><a href="default_call_policies.html#default_call_policies-spec">default_call_policies</a></code>
+
+    </table>
+
+    <h4><a name="return_internal_reference-spec-synopsis"></a>Class template <code>return_internal_reference</code> synopsis</h4>
+<pre>
+namespace boost { namespace python {
+   template &lt;std::size_t owner_arg = 1, class Base = default_call_policies&gt;
+   struct return_internal_reference : Base
+   {
+      static PyObject* postcall(PyObject*, PyObject* result);
+      typedef <a href="reference_existing_object.html#reference_existing_object-spec">reference_existing_object</a> result_converter;
+   };
+}}
+</pre>
+
+    <h4><a name="default_call_policies-spec-statics"></a>Class
+    <code>default_call_policies</code> static functions</h4>
+
+<pre>
+PyObject* postcall(PyObject* args, PyObject* result);
+</pre>
+
+    <dl class="function-semantics">
+      <dt><b>Requires:</b> <code><a href="http://www.python.org/doc/current/api/tupleObjects.html#l2h-476">PyTuple_Check</a>(args) != 0</code>
+
+      <dt><b>Returns:</b> <code><a href="make_custodian_and_ward.html#make_custodian_and_ward_postcall-spec-statics">make_custodian_and_ward_postcall::postcall(args, result)</a></code>
+    </dl>
+
+
+    <h2><a name="examples"></a>Example</h2>
+
+<h3>C++ module definition</h3>
+
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/return_internal_reference.hpp&gt;
+
+class Bar
+{
+   Bar(int x) : x(x) {}
+   int get_x() const { return x; }
+   void set_x(int x) { this-&gt;x = x; }
+ private:
+   int x;
+}
+
+class Foo
+{
+ public:
+   Foo(int x) : b(x) {}
+
+   // Returns an internal reference
+   Bar const&amp; get_bar() const { return b; }
+
+ private:
+   Bar b;
+};
+
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(internal_refs)
+{
+   module m(&quot;internal_refs&quot;)
+      .add(
+         class_&lt;Bar&gt;()
+            .def(&quot;get_x&quot;, &amp;Bar::get_x)
+            .def(&quot;set_x&quot;, &amp;Bar::set_x)
+         )
+      .add(
+         class_&lt;Foo&gt;()
+            .def_init(args&lt;int&gt;())
+            .def(&quot;get_bar&quot;, &amp;Foo::get_bar
+                , return_internal_reference&lt;&gt;())
+         )
+      ;
+}
+</pre>
+
+<h3>Python code</h3>
+
+<pre>
+&gt;&gt;&gt; from internal_refs import *
+&gt;&gt;&gt; f = Foo(3)
+&gt;&gt;&gt; b1 = f.get_bar()
+&gt;&gt;&gt; b2 = f.get_bar()
+&gt;&gt;&gt; b1.get_x()
+3
+&gt;&gt;&gt; b2.get_x()
+3
+&gt;&gt;&gt; b1.set_x(42)
+&gt;&gt;&gt; b2.get_x()
+42
+</pre>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+    15 February, 2002
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From 607631604f065cbb5d038ea8fc14d2e29a2c1ad4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Feb 2002 18:32:57 +0000
Subject: [PATCH 283/369] *** empty log message ***

[SVN r12824]
---
 doc/v2/return_internal_reference.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/v2/return_internal_reference.html b/doc/v2/return_internal_reference.html
index c1b62a56..8cbfc167 100644
--- a/doc/v2/return_internal_reference.html
+++ b/doc/v2/return_internal_reference.html
@@ -106,7 +106,8 @@
 
     <h4><a name="return_internal_reference-spec-synopsis"></a>Class template <code>return_internal_reference</code> synopsis</h4>
 <pre>
-namespace boost { namespace python {
+namespace boost { namespace python
+{
    template &lt;std::size_t owner_arg = 1, class Base = default_call_policies&gt;
    struct return_internal_reference : Base
    {

From f697d2daa17746ef6aee87c5e8317bd5d02ecc28 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Feb 2002 18:53:55 +0000
Subject: [PATCH 284/369] *** empty log message ***

[SVN r12825]
---
 doc/v2/copy_const_reference.html |   9 +-
 doc/v2/return_value_policy.html  | 148 +++++++++++++++++++++++++++++++
 2 files changed, 153 insertions(+), 4 deletions(-)
 create mode 100644 doc/v2/return_value_policy.html

diff --git a/doc/v2/copy_const_reference.html b/doc/v2/copy_const_reference.html
index f80db61f..ec76fa1a 100644
--- a/doc/v2/copy_const_reference.html
+++ b/doc/v2/copy_const_reference.html
@@ -83,7 +83,7 @@ template &lt;class T&gt; struct apply
 
     <h2><a name="examples"></a>Example</h2>
 
-    <p>In C++:
+<h3>C++ Module Definition</h3>
 <pre>
 #include &lt;boost/python/module.hpp&gt;
 #include &lt;boost/python/class.hpp&gt;
@@ -113,10 +113,11 @@ BOOST_PYTHON_MODULE_INIT(my_module)
             .def_init(args&lt;int&gt;())
             .def("get_bar", &amp;Foo::get_bar
                 , return_value_policy&lt;copy_const_reference&gt;())
-         );
+         )
+       ;
 }
 </pre>
-    In Python: 
+<h3>Python Code</h3>
 <pre>
 &gt;&gt;&gt; from my_module import *
 &gt;&gt;&gt; f = Foo(3)         # create a Foo object
@@ -125,7 +126,7 @@ BOOST_PYTHON_MODULE_INIT(my_module)
 
     <p>Revised 
     <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
-     05 November, 2001 
+     15 February, 2002
     <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
 
 
diff --git a/doc/v2/return_value_policy.html b/doc/v2/return_value_policy.html
new file mode 100644
index 00000000..5741be8f
--- /dev/null
+++ b/doc/v2/return_value_policy.html
@@ -0,0 +1,148 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/return_value_policy.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;boost/python/return_value_policy.hpp&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#return_value_policy-spec">Class Template <code>return_value_policy</code></a>
+
+          <dd>
+            <dl class="page-index">
+
+              <dt><a href="#return_value_policy-spec-synopsis">Class Template
+              <code>return_value_policy</code> synopsis</a>
+            </dl>
+        </dl>
+
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <code>return_value_policy</code> instantiations are simply models
+    of <a href=
+    "CallPolicies.html">CallPolicies</a> which are composed of a <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a> and optional <code>Base</code> <a href=
+    "CallPolicies.html">CallPolicies</a>.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="return_value_policy-spec"></a>Class template <code>return_value_policy</code></h3>
+
+
+    <table border="1" summary="return_value_policy template parameters">
+      <caption>
+        <b><code>return_value_policy</code> template parameters</b>
+      </caption>
+      <tr>
+        <th>Parameter
+        
+        <th>Requirements
+
+        <th>Default
+
+      <tr>
+        <td><code>ResultConverterGenerator</code> 
+
+        <td>A model of <a href=
+    "ResultConverterGenerator.html">ResultConverterGenerator</a>.
+
+      <tr>
+        <td><code>Base</code> 
+
+        <td>A model of <a href="CallPolicies.html">CallPolicies</a>
+
+        <td><code><a href="default_call_policies.html#default_call_policies-spec">default_call_policies</a></code>
+
+    </table>
+
+    <h4><a name="return_value_policy-spec-synopsis"></a>Class template <code>return_value_policy</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+  template &lt;class ResultConverterGenerator, class Base = default_call_policies&gt;
+  struct return_value_policy : Base
+  {
+      typedef ResultConverterGenerator result_converter;
+  };
+}}
+</pre>
+
+    <h2><a name="examples"></a>Example</h2>
+
+<h3>C++ Module Definition</h3>
+<pre>
+#include &lt;boost/python/module.hpp&gt;
+#include &lt;boost/python/class.hpp&gt;
+#include &lt;boost/python/copy_const_reference.hpp&gt;
+#include &lt;boost/python/return_value_policy.hpp&gt;
+
+// classes to wrap
+struct Bar { int x; }
+
+struct Foo {
+   Foo(int x) : { b.x = x; }
+   Bar const&amp; get_bar() const { return b; }
+ private:
+   Bar b;
+};
+
+// Wrapper code
+using namespace boost::python;
+BOOST_PYTHON_MODULE_INIT(my_module)
+{
+   module m("my_module")
+      .add(
+         class_&lt;Bar&gt;()
+         )
+      .add(
+         class_&lt;Foo&gt;()
+            .def_init(args&lt;int&gt;())
+            .def("get_bar", &amp;Foo::get_bar
+                , return_value_policy&lt;copy_const_reference&gt;())
+         )
+       ;
+}
+</pre>
+<h3>Python Code</h3>
+<pre>
+&gt;&gt;&gt; from my_module import *
+&gt;&gt;&gt; f = Foo(3)         # create a Foo object
+&gt;&gt;&gt; b = f.get_bar()    # make a copy of the internal Bar object
+</pre>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+    15 February, 2002
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From 39646acf5bab3252b1ca14bc60c20404171741c4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 16 Feb 2002 00:25:16 +0000
Subject: [PATCH 285/369] updates to be compatible with Rene's new system

[SVN r12831]
---
 Jamfile | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Jamfile b/Jamfile
index ac32456b..aa804505 100644
--- a/Jamfile
+++ b/Jamfile
@@ -31,39 +31,39 @@ PYTHON_PROPERTIES
         ;
 
     # -------- general test -------
-    extension m1 : test/m1.cpp <lib>bpl
+    extension m1 : test/m1.cpp <dll>bpl
       : 
       : debug-python
       ;
 
-    extension m2 : test/m2.cpp <lib>bpl
+    extension m2 : test/m2.cpp <dll>bpl
       : 
       : debug-python ;
 
-    boost-python-runtest try : test/newtest.py <lib>m1 <lib>m2 : : debug-python ;
+    boost-python-runtest try : test/newtest.py <pyd>m1 <pyd>m2 : : debug-python ;
 
     # ----------- builtin converters -----------
     
-    extension builtin_converters_ext : test/test_builtin_converters.cpp <lib>bpl
+    extension builtin_converters_ext : test/test_builtin_converters.cpp <dll>bpl
       :
       : debug-python
       ;
 
     boost-python-runtest test_builtin_converters : test/test_builtin_converters.py
-      <lib>builtin_converters_ext
+      <pyd>builtin_converters_ext
       :
       : debug-python
       ;
     
     # ----------- pointer adoption -----------
     
-    extension test_pointer_adoption_ext : test/test_pointer_adoption.cpp <lib>bpl
+    extension test_pointer_adoption_ext : test/test_pointer_adoption.cpp <dll>bpl
       :
       : debug-python
       ;
 
     boost-python-runtest test_pointer_adoption : test/test_pointer_adoption.py
-      <lib>test_pointer_adoption_ext
+      <pyd>test_pointer_adoption_ext
       :
       : debug-python
       ;

From edd93c80a1f15c35b9a2b0dfd550d66b8eb9e521 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 16 Feb 2002 15:42:09 +0000
Subject: [PATCH 286/369] inital checkin

[SVN r12835]
---
 doc/v2/to_python_converter.html | 189 ++++++++++++++++++++++++++++++++
 1 file changed, 189 insertions(+)
 create mode 100644 doc/v2/to_python_converter.html

diff --git a/doc/v2/to_python_converter.html b/doc/v2/to_python_converter.html
new file mode 100644
index 00000000..63db8c71
--- /dev/null
+++ b/doc/v2/to_python_converter.html
@@ -0,0 +1,189 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/to_python_converter.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;boost/python/to_python_converter.hpp&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#to_python_converter-spec">Class Template <code>to_python_converter</code></a>
+
+          <dd>
+            <dl class="page-index">
+
+              <dt><a href="#to_python_converter-spec-synopsis">Class Template
+              <code>to_python_converter</code> synopsis</a>
+
+              <dt><a href="#to_python_converter-spec-ctors">Class Template
+              <code>to_python_converter</code> constructor</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <code>to_python_converter</code> registers a conversion from
+    objects of a given C++ type into a Python object.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="to_python_converter-spec"></a>Class template <code>to_python_converter</code></h3>
+
+    <code>to_python_converter</code> adds a wrapper around a static
+    member function of its second template parameter, handling
+    low-level details such as insertion into the converter registry.
+
+    <table border="1" summary="to_python_converter template parameters">
+      <caption>
+        <b><code>to_python_converter</code> template parameters</b><br>
+In the table below, <b><code>x</code></b> denotes an object of type <code>T</code>
+      </caption>
+      <tr>
+        <th>Parameter
+        
+        <th>Requirements
+
+        <th>Description
+
+      <tr>
+        <td><code>T</code> 
+
+        <td>
+
+        <td>The C++ type of the source object in the conversion
+
+      <tr>
+        <td><code>Conversion</code> 
+
+        <td><code>PyObject*&nbsp;p&nbsp;=&nbsp;Conversion::convert(x)</code>,<br>
+        if <code>p&nbsp;==&nbsp;0</code>, <code><a href="http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred</a>()&nbsp;!=&nbsp;0</code>.
+
+        <td>A class type whose static member function
+        <code>convert</code> does the real work of the conversion.
+
+      <tr>
+    </table>
+
+    <h4><a name="to_python_converter-spec-synopsis"></a>Class template <code>to_python_converter</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+  template &lt;class T, class Conversion&gt;
+  struct to_python_converter
+  {
+      to_python_converter();
+  };
+}}
+</pre>
+
+    <h4><a name="to_python_converter-spec-ctors"></a>Class template <code>to_python_converter</code> constructor</h4>
+<pre>
+to_python_converter();
+</pre>
+
+    <dl class="function-semantics">
+
+      <dt><b>Effects:</b> Registers a to_python converter which uses
+      <code>Conversion::convert()</code> to do its work.
+
+    </dl>
+
+    <h2><a name="examples"></a>Example</h2>
+
+This example presumes that someone has implemented the standard <a
+href="http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy example
+module</a> from the Python documentation, and placed the corresponding
+declarations in <code>&quot;noddy.h&quot;</code>.  Because
+<code>noddy_NoddyObject</code> is the ultimate trivial extension type,
+the example is a bit contrived: it wraps a function for which all
+information is contained in the <i>type</i> of its return value.
+
+<h3>C++ module definition</h3>
+
+<pre>
+#include &lt;boost/python/reference.hpp&gt;
+#include &lt;boost/python/module.hpp&gt;
+#include &quot;noddy.h&quot;
+
+struct tag {};
+tag make_tag() { return tag(); }
+
+using namespace boost::python;
+
+struct tag_to_noddy
+{
+    static PyObject* convert(tag const&amp; x)
+    {
+        return PyObject_New(noddy_NoddyObject, &amp;noddy_NoddyType);
+    }
+};
+
+BOOST_PYTHON_MODULE_INIT(to_python_converter)
+{
+    module to_python(&quot;to_python_converter&quot;)
+        .def(&quot;make_tag&quot;, make_tag)
+        ;
+    to_python_converter&lt;tag, tag_to_noddy&gt;();
+}
+</pre>
+
+<h3>Python code</h3>
+
+<pre>
+&gt;&gt;&gt; import to_python_converter
+&gt;&gt;&gt; def always_none():
+...     return None
+...
+&gt;&gt;&gt; def choose_function(x):
+...     if (x % 2 != 0):
+...         return to_python_converter.make_tag
+...     else:
+...         return always_none
+...
+&gt;&gt;&gt; a = [ choose_function(x) for x in range(5) ]
+&gt;&gt;&gt; b = [ f() for f in a ]
+&gt;&gt;&gt; type(b[0])
+&lt;type 'NoneType'&gt;
+&gt;&gt;&gt; type(b[1])
+&lt;type 'Noddy'&gt;
+&gt;&gt;&gt; type(b[2])
+&lt;type 'NoneType'&gt;
+&gt;&gt;&gt; type(b[3])
+&lt;type 'Noddy'&gt;
+</pre>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     05 November, 2001 
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From 80effaa541f56a973a8f03e03b444500d1af4ece Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 16 Feb 2002 16:01:37 +0000
Subject: [PATCH 287/369] *** empty log message ***

[SVN r12836]
---
 doc/boost.css | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/boost.css b/doc/boost.css
index c382d4c6..cf5c8a97 100644
--- a/doc/boost.css
+++ b/doc/boost.css
@@ -23,10 +23,12 @@ BODY
 PRE
 {
     MARGIN-LEFT: 2pc;
+    FONT-SIZE: 80%;
     BACKGROUND-COLOR: #dfffff
 }
 CODE
 {
+    FONT-SIZE: 95%;
      white-space: pre
 }
 .index

From dcae0eadd5af2bdc631d0428ff0c5dfc2ede0c4d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 16 Feb 2002 16:42:26 +0000
Subject: [PATCH 288/369] *** empty log message ***

[SVN r12839]
---
 doc/v2/return_internal_reference.html | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/doc/v2/return_internal_reference.html b/doc/v2/return_internal_reference.html
index 8cbfc167..42b8c97e 100644
--- a/doc/v2/return_internal_reference.html
+++ b/doc/v2/return_internal_reference.html
@@ -55,7 +55,8 @@
     argument or from the target of a member function to be returned
     safely without making a copy of the referent. The default for its
     first template argument handles the common case where the
-    containing object is the target (<code>*this</code>) of a wrapped member function.
+    containing object is the target (<code>*this</code>) of a wrapped
+    member function.
 
     <h2><a name="classes"></a>Classes</h2>
 
@@ -84,7 +85,10 @@
         <td>The index of the parameter which contains the object to
         which the reference or pointer is being returned. If used to
         wrap a member function, parameter 1 is the target object
-        (<code>*this</code>).
+        (<code>*this</code>). Note that if the target Python object
+        type doesn't support weak references, a Python
+        <code>TypeError</code> exception will be raised when the
+        function being wrapped is called.
 
         <td>1
 
@@ -125,7 +129,7 @@ PyObject* postcall(PyObject* args, PyObject* result);
 </pre>
 
     <dl class="function-semantics">
-      <dt><b>Requires:</b> <code><a href="http://www.python.org/doc/current/api/tupleObjects.html#l2h-476">PyTuple_Check</a>(args) != 0</code>
+      <dt><b>Requires:</b> <code><a href="http://www.python.org/doc/2.2/api/tupleObjects.html#l2h-476">PyTuple_Check</a>(args) != 0</code>
 
       <dt><b>Returns:</b> <code><a href="make_custodian_and_ward.html#make_custodian_and_ward_postcall-spec-statics">make_custodian_and_ward_postcall::postcall(args, result)</a></code>
     </dl>

From aeccf45d4e0041c6a4a56ce31d4e8fc2f1ef8fce Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 16 Feb 2002 18:10:30 +0000
Subject: [PATCH 289/369] *** empty log message ***

[SVN r12840]
---
 doc/v2/to_python_indirect.html | 194 +++++++++++++++++++++++++++++++++
 1 file changed, 194 insertions(+)
 create mode 100644 doc/v2/to_python_indirect.html

diff --git a/doc/v2/to_python_indirect.html b/doc/v2/to_python_indirect.html
new file mode 100644
index 00000000..8910cd97
--- /dev/null
+++ b/doc/v2/to_python_indirect.html
@@ -0,0 +1,194 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+    <meta name="generator" content="HTML Tidy, see www.w3.org">
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+    <link rel="stylesheet" type="text/css" href="../boost.css">
+
+    <title>Boost.Python - &lt;boost/python/to_python_indirect.hpp&gt;</title>
+
+    <table border="0" cellpadding="7" cellspacing="0" width="100%" summary=
+    "header">
+      <tr>
+        <td valign="top" width="300">
+          <h3><a href="../../../../index.htm"><img height="86" width="277" alt=
+          "C++ Boost" src="../../../../c++boost.gif" border="0"></a></h3>
+
+        <td valign="top">
+          <h1 align="center">Boost.Python</h1>
+
+          <h2 align="center">Header &lt;boost/python/to_python_indirect.hpp&gt;</h2>
+    </table>
+    <hr>
+
+    <h2>Contents</h2>
+
+    <dl class="page-index">
+      <dt><a href="#introduction">Introduction</a>
+
+
+      <dt><a href="#classes">Classes</a>
+
+      <dd>
+        <dl class="page-index">
+          <dt><a href="#to_python_indirect-spec">Class Template <code>to_python_indirect</code></a>
+
+          <dd>
+            <dl class="page-index">
+
+              <dt><a href="#to_python_indirect-spec-synopsis">Class Template
+              <code>to_python_indirect</code> synopsis</a>
+
+              <dt><a href="#to_python_indirect-spec-observers">Class Template
+              <code>to_python_indirect</code> observer functions</a>
+
+              <dt><a href="#to_python_indirect-spec-statics">Class Template
+              <code>to_python_indirect</code> static functions</a>
+            </dl>
+        </dl>
+
+      <dt><a href="#examples">Example</a>
+    </dl>
+    <hr>
+
+    <h2><a name="introduction"></a>Introduction</h2>
+
+    <code>&lt;boost/python/to_python_indirect.hpp&gt;</code> supplies
+    a way to construct new Python objects that hold wrapped C++ class
+    instances via a pointer or smart pointer.
+
+    <h2><a name="classes"></a>Classes</h2>
+
+    <h3><a name="to_python_indirect-spec"></a>Class template <code>to_python_indirect</code></h3>
+    <p>Class template <code>to_python_indirect</code> converts objects
+of its first argument type to python as extension class instances, using the ownership policy provided by its 2nd argument.
+
+    <p>
+
+
+    <table border="1" summary="to_python_indirect template parameters">
+      <caption>
+        <b><code>to_python_indirect</code> Requirements</b><br>
+
+        In the table below, <b><code>x</code></b> denotes an object of
+        type <code>T</code>, <b><code>h</code></b> denotes an
+        object of type
+        <code>boost::python::objects::instance_holder*</code>, and
+        <b><code>p</code></b> denotes an object of type
+        <code>U*</code>.
+
+      </caption>
+      <tr>
+        <th>Parameter
+        
+        <th>Requirements
+
+        <th>Description
+
+      <tr>
+        <td><code>T</code> 
+
+        <td>Either <code>U</code>&nbsp;<i>cv</i><code>&amp;</code>
+        (where <i>cv</i> is any optional cv-qualification) or a <a
+        href="Dereferenceable.html">Dereferenceable</a> type such that
+        <code>*x</code> is convertible to <code>U const&amp;</code>, where
+        <code>U</code> is a class type.
+
+        <td>A type deferencing a C++ class exposed to Python using
+        class template <code><a
+        href="class.html#class_-spec">class_</a></code>.
+
+      <tr>
+        <td><code>MakeHolder</code> 
+
+        <td>h = MakeHolder::execute(p);
+
+        <td>A class whose static <code>execute()</code> creates an
+        <code>instance_holder</code>.
+
+    </table>
+
+    Instantiations of <code>to_python_indirect</code> are models of <a
+    href="ResultConverter.html">ResultConverter</a>.
+
+
+    <h4><a name="to_python_indirect-spec-synopsis"></a>Class template <code>to_python_indirect</code> synopsis</h4>
+<pre>
+namespace boost { namespace python
+{
+  template &lt;class T, class MakeHolder&gt;
+  struct to_python_indirect
+  {
+     static bool convertible();
+     PyObject* operator()(T ptr_or_reference) const;
+   private:
+     static PyTypeObject* type();
+  };
+}}
+</pre>
+
+    <h4><a name="to_python_indirect-spec-observers"></a>Class template <code>to_python_indirect</code> observers</h4>
+<pre>
+PyObject* operator()(T x) const;
+</pre>
+
+    <dl class="function-semantics">
+
+      <dt><b>Requires:</b> <code>x</code> refers to an object (if it
+      is a pointer type, it is non-null). <code>convertible() ==
+      true</code>.
+
+      <dt><b>Effects:</b> Creates an appropriately-typed Boost.Python
+      extension class instance, uses <code>MakeHolder</code> to create
+      an <code>instance_holder</code> from <code>x</code>, installs
+      the <code>instance_holder</code> in the new extension class
+      instance, and returns a pointer to it.
+
+    </dl>
+
+
+    <h4><a name="to_python_indirect-spec-statics"></a>Class template <code>to_python_indirect</code> statics</h4>
+<pre>
+bool convertible();
+</pre>
+
+      <dt><b>Effects:</b> Returns <code>true</code> iff any module has
+      registered a Python type corresponding to <code>U</code>.
+
+    <h2><a name="examples"></a>Example</h2>
+
+This example replicates the functionality of <a
+href="reference_existing_object.html#reference_existing_object-spec">reference_existing_object</a>,
+but without some of the compile-time error checking.
+
+
+<pre>
+
+struct make_reference_holder
+{
+   typedef boost::python::objects::instance_holder* result_type;
+   template &lt;class T&gt;
+   static result_type execute(T* p)
+   {
+      return new boost::python::objects::pointer_holder&lt;T*, T&gt;(p);
+   }
+};
+
+struct reference_existing_object
+{
+   // metafunction returning the <a href="ResultConverter.html">ResultConverter</a>
+   template &lt;class T&gt;
+   struct apply
+   {
+      typedef boost::python::to_python_indirect&lt;T,make_reference_holder&gt; type;
+   };
+};
+</pre>
+
+    <p>Revised 
+    <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan -->
+     16 February, 2002
+    <!--webbot bot="Timestamp" endspan i-checksum="39359" -->
+
+
+    <p><i>&copy; Copyright <a href="../../../../people/dave_abrahams.htm">Dave
+    Abrahams</a> 2002. All Rights Reserved.</i>
+

From ca872af3c8147c8fc3eef2594698b08a8b147a7d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 16 Feb 2002 18:11:24 +0000
Subject: [PATCH 290/369] HolderGenerator renamed to MakeHolder

[SVN r12841]
---
 include/boost/python/to_python_indirect.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/boost/python/to_python_indirect.hpp b/include/boost/python/to_python_indirect.hpp
index e68eced0..306b3246 100644
--- a/include/boost/python/to_python_indirect.hpp
+++ b/include/boost/python/to_python_indirect.hpp
@@ -14,7 +14,7 @@
 
 namespace boost { namespace python {
 
-template <class T, class HolderGenerator>
+template <class T, class MakeHolder>
 struct to_python_indirect
 {
     static bool convertible();
@@ -61,14 +61,14 @@ namespace detail
   };
 }
 
-template <class T, class HolderGenerator>
-inline bool to_python_indirect<T,HolderGenerator>::convertible()
+template <class T, class MakeHolder>
+inline bool to_python_indirect<T,MakeHolder>::convertible()
 {
     return type() != 0;
 }
 
-template <class T, class HolderGenerator>
-inline PyObject* to_python_indirect<T,HolderGenerator>::operator()(T x) const
+template <class T, class MakeHolder>
+inline PyObject* to_python_indirect<T,MakeHolder>::operator()(T x) const
 {
     PyObject* raw_result = type()->tp_alloc(type(), 0);
 
@@ -82,7 +82,7 @@ inline PyObject* to_python_indirect<T,HolderGenerator>::operator()(T x) const
     // Build a value_holder to contain the object using the copy
     // constructor
     objects::instance_holder* p =
-        detail::unwind_type<HolderGenerator>(x);
+        detail::unwind_type<MakeHolder>(x);
 
     // Install it in the instance
     p->install(raw_result);
@@ -91,8 +91,8 @@ inline PyObject* to_python_indirect<T,HolderGenerator>::operator()(T x) const
     return result.release();
 }
 
-template <class T, class HolderGenerator>
-inline PyTypeObject* to_python_indirect<T,HolderGenerator>::type()
+template <class T, class MakeHolder>
+inline PyTypeObject* to_python_indirect<T,MakeHolder>::type()
 {
     return detail::unwind_type<detail::get_pointer_class,T>();
 }

From 8af49161fbe031ebe59458123c133fe37bd4ef87 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 17 Feb 2002 04:37:35 +0000
Subject: [PATCH 291/369] no message

[SVN r12845]
---
 doc/v2/class.html              |  4 ++--
 doc/v2/class_hpp.py            | 20 --------------------
 doc/v2/errors.html             |  4 ++--
 doc/v2/lvalue_from_python.html |  4 ++--
 doc/v2/module.html             | 10 +++++-----
 5 files changed, 11 insertions(+), 31 deletions(-)
 delete mode 100644 doc/v2/class_hpp.py

diff --git a/doc/v2/class.html b/doc/v2/class.html
index fc64eabd..393510eb 100644
--- a/doc/v2/class.html
+++ b/doc/v2/class.html
@@ -175,7 +175,7 @@ class_(char const* name)
     <dl class="function-semantics">
       <dt><b>Requires:</b> <code>name</code> is a ntbs which conforms to
       Python's <a href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      "http://www.python.org/doc/2.2/ref/identifiers.html">identifier
       naming rules</a>.
 
       <dt><b>Effects:</b> Constructs a <code>class_</code> object which
@@ -198,7 +198,7 @@ class_&amp; def(char const* name, Fn f, CallPolicy policy)
       <dt><b>Requires:</b> <code>f</code> is a non-null pointer-to-function or
       pointer-to-member-function. <code>name</code> is a ntbs which conforms to
       Python's <a href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      "http://www.python.org/doc/2.2/ref/identifiers.html">identifier
       naming rules</a>. In the first form, the return type of
       <code>f</code> is not a reference and is not a pointer other
       than <code>char const*</code> or <code>PyObject*</code>. In the
diff --git a/doc/v2/class_hpp.py b/doc/v2/class_hpp.py
deleted file mode 100644
index 9af2cb5c..00000000
--- a/doc/v2/class_hpp.py
+++ /dev/null
@@ -1,20 +0,0 @@
-introduction = '''
-'''
-
-class boost(namespace): pass
-
-class python(boost):
-    
-    class class_(class_template):
-        T = type()
-        T.requires = 'a class type'
-        
-        Bases = concepts.mpl_sequence('class type')
-        HolderGenerator = concepts.HolderGenerator()
-        template_args = (T, Bases, HolderGenerator)
-
-        class def_1(function_template):
-            name = "def"
-            args = (('char const*', 'name'), ('F', 'f'))
-        
-class_template
diff --git a/doc/v2/errors.html b/doc/v2/errors.html
index e52f29f7..603bd28b 100644
--- a/doc/v2/errors.html
+++ b/doc/v2/errors.html
@@ -65,7 +65,7 @@
     <p><code>error_already_set</code> is an exception type which can be thrown
     to indicate that a Python error has occurred. If thrown, the precondition
     is that <a href=
-    "http://www.python.org/doc/current/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
+    "http://www.python.org/doc/2.2/api/exceptionHandling.html#l2h-71">PyErr_Occurred()</a>
     returns a value convertible to <code>true</code>.
 
     <h4><a name="class-spec-synopsis"></a>Class error_already_set synopsis</h4>
@@ -131,7 +131,7 @@ template &lt;class T&gt; T* expect_non_null(T* x);
 
       <dt><b>Rationale:</b> Simplifies error-handling when calling many
       functions in the <a href=
-      "http://www.python.org/doc/current/api/api.html">Python/C API</a>, which
+      "http://www.python.org/doc/2.2/api/api.html">Python/C API</a>, which
       return 0 on error.
     </dl>
 
diff --git a/doc/v2/lvalue_from_python.html b/doc/v2/lvalue_from_python.html
index 03af54f8..a0591128 100644
--- a/doc/v2/lvalue_from_python.html
+++ b/doc/v2/lvalue_from_python.html
@@ -99,7 +99,7 @@
         <td><code>python_type</code> 
 
         <td>A compile-time constant <code><a
-        href="http://www.python.org/doc/current/ext/dnt-type-methods.html">PyTypeObject</a>*</code>
+        href="http://www.python.org/doc/2.2/ext/dnt-type-methods.html">PyTypeObject</a>*</code>
 
         <td>The Python type of instances convertible by this
         converter. Python subtypes are also convertible.
@@ -213,7 +213,7 @@ Member&amp; execute(Class&amp; c);
     <h2><a name="examples"></a>Example</h2>
 
 This example presumes that someone has implemented the standard <a
-href="http://www.python.org/doc/current/ext/dnt-basics.html">noddy
+href="http://www.python.org/doc/2.2/ext/dnt-basics.html">noddy
 example module</a> from the Python documentation, and we want to build
 a module which manipulates <code>Noddy</code>s. Since
 <code>noddy_NoddyObject</code> is so simple that it carries no
diff --git a/doc/v2/module.html b/doc/v2/module.html
index 0e3516ed..847ff017 100644
--- a/doc/v2/module.html
+++ b/doc/v2/module.html
@@ -67,11 +67,11 @@
     <p><a name=
     "BOOST_PYTHON_MODULE_INIT-spec"><code>BOOST_PYTHON_MODULE_INIT(name)</code></a>
     is used to declare Python <a href=
-    "http://www.python.org/doc/current/ext/methodTable.html#SECTION003400000000000000000">
+    "http://www.python.org/doc/2.2/ext/methodTable.html#SECTION003400000000000000000">
     module initialization functions</a>. The <code>name</code> argument must
     exactly match the name of the module to be initialized, and must conform to
     Python's <a href=
-    "http://www.python.org/doc/current/ref/identifiers.html">identifier naming
+    "http://www.python.org/doc/2.2/ref/identifiers.html">identifier naming
     rules</a>. Where you would normally write
 <pre>
 void init<i>name</i>()
@@ -150,7 +150,7 @@ module&amp; setattr(const char* name, ref const&amp; r);
     <dl class="function-semantics">
       <dt><b>Requires:</b> <code>name</code> is a ntbs which conforms to
       Python's <a href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      "http://www.python.org/doc/2.2/ref/identifiers.html">identifier
       naming rules</a>. In the first two forms, <code>obj</code> is non-null.
       In the third form, <code>r.get()</code> is non-null.
 
@@ -176,7 +176,7 @@ module&amp; add(class_&lt;T,Bases,HolderGenerator&gt; const&amp; c);
       <dt><b>Effects:</b> The first form adds the Python type object named by
       <code>x</code> to the Python module under construction, with the name
       given by the type's <code><a href=
-      "http://www.python.org/doc/current/ext/dnt-type-methods.html">tp_name</a></code>
+      "http://www.python.org/doc/2.2/ext/dnt-type-methods.html">tp_name</a></code>
       field. The second form adds the extension class object being constructed
       by <code>c</code> to the module, with the same name that was passed to
       <code>c</code>'s constructor.
@@ -199,7 +199,7 @@ module&amp; def(char const* name, Fn f, ResultHandler handler);
       <dt><b>Requires:</b> <code>f</code> is a non-null pointer-to-function or
       pointer-to-member-function. <code>name</code> is a ntbs which conforms to
       Python's <a href=
-      "http://www.python.org/doc/current/ref/identifiers.html">identifier
+      "http://www.python.org/doc/2.2/ref/identifiers.html">identifier
       naming rules</a>. In the first form, the return type of
       <code>f</code> is not a reference and is not a pointer other
       than <code>char const*</code> or <code>PyObject*</code>. In the

From b75d11da3ac1165a607633624963b615abcce54c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 17 Feb 2002 22:29:43 +0000
Subject: [PATCH 292/369] Bug fix thanks to Min Xu

[SVN r12849]
---
 src/object/class.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/object/class.cpp b/src/object/class.cpp
index 6a839fb2..60a803f9 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -205,7 +205,7 @@ namespace
       std::vector<entry>::const_iterator p
           = boost::detail::lower_bound(start, finish, id);
 
-      if (p == finish && p->key != id)
+      if (p == finish || p->key != id)
       {
           string report("extension class wrapper for base class ");
           (report += id.name()) += " has not been created yet";

From 622ff9d764e8ddbc94af41260f579a1525ed0b62 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 18 Feb 2002 23:00:06 +0000
Subject: [PATCH 293/369] *** empty log message ***

[SVN r12855]
---
 doc/v2/class.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/v2/class.html b/doc/v2/class.html
index 393510eb..c28f0317 100644
--- a/doc/v2/class.html
+++ b/doc/v2/class.html
@@ -210,7 +210,7 @@ class_&amp; def(char const* name, Fn f, CallPolicy policy)
       the Boost.Python extension class being defined, with the given
       <code>name</code>. If the extension class already has an attribute named
       <code><i>name</i></code>, the usual <a href=
-      "http:overloading.html">overloading procedure</a> applies.
+      "overloading.html">overloading procedure</a> applies.
 
       <dt><b>Returns:</b> <code>*this</code>
     </dl>

From 266923d9e8fbdaa65bdb2e63850a41f37393c5cc Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:12:47 +0000
Subject: [PATCH 294/369] Removed useless default arg -- it was confusing MSVC

[SVN r12860]
---
 include/boost/python/class.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 978a226a..8dede0e3 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -122,7 +122,7 @@ class class_ : private objects::class_base
     // Define the constructor with the given Args, which should be an
     // MPL sequence of types.
     template <class Args>
-    self& def_init(Args const& = Args())
+    self& def_init(Args const&)
     {
         def("__init__", make_constructor<T,Args,HolderGenerator>());
         return *this;

From 07abc9fac480b6674702a8317186ee718e9b20c6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:13:24 +0000
Subject: [PATCH 295/369] initial checkin

[SVN r12861]
---
 include/boost/python/lvalue_from_python.hpp | 96 +++++++++++++++++++++
 1 file changed, 96 insertions(+)
 create mode 100644 include/boost/python/lvalue_from_python.hpp

diff --git a/include/boost/python/lvalue_from_python.hpp b/include/boost/python/lvalue_from_python.hpp
new file mode 100644
index 00000000..c5d09ff5
--- /dev/null
+++ b/include/boost/python/lvalue_from_python.hpp
@@ -0,0 +1,96 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef LVALUE_FROM_PYTHON_DWA2002130_HPP
+# define LVALUE_FROM_PYTHON_DWA2002130_HPP
+
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/type_from_python.hpp>
+
+namespace boost { namespace python { 
+
+// Utility which produces a member extractor function on platforms
+// other than VC6.
+template <class Class, class Member, Member (Class::*mp)>
+struct get_member
+{
+    static Member& execute(Class& c)
+    {
+        return c.*mp;
+    }
+};
+
+namespace detail
+{
+  template <class Class>
+  struct extract_identity
+  {
+      static Class& execute(Class& c)
+      {
+          return c;
+      }
+  };
+}
+
+template <
+    PyTypeObject const* python_type
+    , class Value
+    , class PythonObject = Value
+    , class Extract = detail::extract_identity<Value>
+    >
+class lvalue_from_python
+{
+    typedef type_from_python<python_type> convertible_t;
+ public:
+    
+    lvalue_from_python()
+        : m_mutable_converter(
+            &convertible_t::convertible, convert_mutable)
+        
+        , m_const_converter(
+            &convertible_t::convertible, convert_const)
+
+        , m_mutable_pointer_converter(
+            &convertible_t::convertible, convert_mutable_pointer)
+        
+        , m_const_pointer_converter(
+            &convertible_t::convertible, convert_const_pointer)
+    {}
+    
+ private:
+    static Value& convert_mutable(PyObject* op, converter::from_python_data&)
+    {
+        return Extract::execute(*(PythonObject*)op);
+    }
+    
+    static Value const& convert_const(PyObject* op, converter::from_python_data&)
+    {
+        return Extract::execute(*(PythonObject*)op);
+    }
+    
+    static Value* convert_mutable_pointer(PyObject* op, converter::from_python_data&)
+    {
+        return &Extract::execute(*(PythonObject*)op);
+    }
+    
+    static Value const* convert_const_pointer(PyObject* op, converter::from_python_data&)
+    {
+        return &Extract::execute(*(PythonObject*)op);
+    }
+    
+    typedef converter::from_python_converter<Value&> mutable_converter;
+    typedef converter::from_python_converter<Value const&> const_converter;
+    typedef converter::from_python_converter<Value*> mutable_pointer_converter;
+    typedef converter::from_python_converter<Value const*> const_pointer_converter;
+    
+    mutable_converter m_mutable_converter;
+    const_converter m_const_converter;
+    mutable_pointer_converter m_mutable_pointer_converter;
+    const_pointer_converter m_const_pointer_converter;
+};
+
+}} // namespace boost::python
+
+#endif // LVALUE_FROM_PYTHON_DWA2002130_HPP

From 47c1c6288ccd4a92fbb6f856ddf484640897c094 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:14:41 +0000
Subject: [PATCH 296/369] Added error checking

[SVN r12862]
---
 .../python/return_internal_reference.hpp      | 20 ++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/return_internal_reference.hpp b/include/boost/python/return_internal_reference.hpp
index 2f567e55..356bc9ed 100644
--- a/include/boost/python/return_internal_reference.hpp
+++ b/include/boost/python/return_internal_reference.hpp
@@ -9,14 +9,32 @@
 # include <boost/python/default_call_policies.hpp>
 # include <boost/python/reference_existing_object.hpp>
 # include <boost/python/with_custodian_and_ward.hpp>
+# include <boost/mpl/select_type.hpp>
 
 namespace boost { namespace python { 
 
+namespace detail
+{
+  template <std::size_t>
+  struct return_internal_reference_owner_arg_must_be_greater_than_zero
+# if defined(__GNUC__) && __GNUC__ >= 3 || defined(__EDG__)
+  {}
+# endif
+  ;
+}
+
 template <std::size_t owner_arg = 1, class Base = default_call_policies>
 struct return_internal_reference
     : with_custodian_and_ward_postcall<0, owner_arg, Base>
 {
-    typedef reference_existing_object result_converter;
+ private:
+    BOOST_STATIC_CONSTANT(bool, legal = owner_arg > 0);
+ public:
+    typedef typename mpl::select_type<
+        legal
+        , reference_existing_object
+        , detail::return_internal_reference_owner_arg_must_be_greater_than_zero<owner_arg>
+    >::type result_converter;
 };
 
 }} // namespace boost::python

From 361455678a781b9629c1730ef1b2e490d1c2d93d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:15:14 +0000
Subject: [PATCH 297/369] updated concept names

[SVN r12864]
---
 include/boost/python/return_value_policy.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/return_value_policy.hpp b/include/boost/python/return_value_policy.hpp
index 0beec47b..6a2036d7 100644
--- a/include/boost/python/return_value_policy.hpp
+++ b/include/boost/python/return_value_policy.hpp
@@ -9,10 +9,10 @@
 
 namespace boost { namespace python { 
 
-template <class Handler, class Base = default_call_policies>
+template <class ResultConverterGenerator, class Base = default_call_policies>
 struct return_value_policy : Base
 {
-    typedef Handler result_converter;
+    typedef ResultConverterGenerator result_converter;
 };
 
 }} // namespace boost::python

From 7f420361b1efa72126ce74632dea921677ad542e Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:15:40 +0000
Subject: [PATCH 298/369] updated template parameter names

[SVN r12865]
---
 include/boost/python/to_python_converter.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/boost/python/to_python_converter.hpp b/include/boost/python/to_python_converter.hpp
index 6bea9822..7e46c505 100644
--- a/include/boost/python/to_python_converter.hpp
+++ b/include/boost/python/to_python_converter.hpp
@@ -12,7 +12,7 @@
 
 namespace boost { namespace python { 
 
-template <class T, class Derived>
+template <class T, class Conversion>
 struct to_python_converter
 {
     to_python_converter();
@@ -22,11 +22,11 @@ struct to_python_converter
 // implementation
 //
 
-template <class T, class Derived>
-to_python_converter<T,Derived>::to_python_converter()
+template <class T, class Conversion>
+to_python_converter<T,Conversion>::to_python_converter()
 {
     typedef converter::as_to_python_value_function<
-        T, Derived
+        T, Conversion
         > normalized;
         
     converter::registry::insert(

From 43bcbf771e822acffe8244edf96e42e13f06909b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:18:12 +0000
Subject: [PATCH 299/369] added more-rigorous tests

[SVN r12866]
---
 test/m1.cpp     | 40 ++++++++++++++++++++++++++++++++++++----
 test/newtest.py | 12 ++++++++++++
 2 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/test/m1.cpp b/test/m1.cpp
index b42742ab..723b471d 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -15,7 +15,7 @@
 #include <boost/python/copy_const_reference.hpp>
 #include <boost/python/return_value_policy.hpp>
 #include <boost/python/converter/class.hpp>
-#include <boost/python/reference_from_python.hpp>
+#include <boost/python/lvalue_from_python.hpp>
 #include <boost/python/to_python_converter.hpp>
 #include <boost/python/value_from_python.hpp>
 #include <boost/python/errors.hpp>
@@ -141,6 +141,26 @@ int f(simple const& s)
     return strlen(s.s);
 }
 
+int f_mutable_ref(simple& s)
+{
+    return strlen(s.s);
+}
+
+int f_mutable_ptr(simple* s)
+{
+    return strlen(s->s);
+}
+
+int f_const_ptr(simple const* s)
+{
+    return strlen(s->s);
+}
+
+int f2(SimpleObject const& s)
+{
+    return strlen(s.x.s);
+}
+
 // A trivial passthru function for simple objects
 simple const& g(simple const& x)
 {
@@ -188,7 +208,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
     using boost::python::module;
     using boost::python::class_;
     using boost::python::converter::from_python_converter;
-    using boost::python::reference_from_python;
+    using boost::python::lvalue_from_python;
     using boost::python::value_from_python;
     using boost::python::type_from_python;
     using boost::python::get_member;
@@ -205,14 +225,21 @@ BOOST_PYTHON_MODULE_INIT(m1)
     static from_python_converter<int&> c3(
         &(boost::python::type_from_python<&NoddyType>::convertible), noddy_to_int_ref);
 
-    static boost::python::reference_from_python<
+    static boost::python::lvalue_from_python<
         &SimpleType
         , simple
         , SimpleObject
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+        , boost::python::get_member<SimpleObject, simple, &SimpleObject::x>
+#else 
         , extract_simple_object
+#endif 
         >
         unwrap_simple;
 
+    static boost::python::lvalue_from_python<&SimpleType, SimpleObject>
+        unwrap_simple2;
+    
     module m1("m1");
 
     typedef boost::python::objects::pointer_holder_generator<
@@ -229,9 +256,14 @@ BOOST_PYTHON_MODULE_INIT(m1)
       .def("new_noddy", new_noddy)
       .def("new_simple", new_simple)
 
-      // Expose f()
+      // Expose f() in all its variations
       .def("f", f)
+      .def("f_mutable_ref", f_mutable_ref)
+      .def("f_mutable_ptr", f_mutable_ptr)
+      .def("f_const_ptr", f_const_ptr)
 
+      .def("f2", f2)
+        
       // Expose g()
       .def("g", g , return_value_policy<copy_const_reference>()
           )
diff --git a/test/newtest.py b/test/newtest.py
index 4e6de142..b89764d1 100644
--- a/test/newtest.py
+++ b/test/newtest.py
@@ -57,6 +57,18 @@ try: wrap_int_ref(n)
 >>> f(g(s))
 12
 
+>>> f_mutable_ref(g(s))
+12
+
+>>> f_const_ptr(g(s))
+12
+
+>>> f_mutable_ptr(g(s))
+12
+
+>>> f2(g(s))
+12
+
 Create an extension class which wraps "complicated" (init1 and get_n)
 are a complicated constructor and member function, respectively.
 

From d660c12a745d840c6a81221b2da7a562275158f2 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Feb 2002 05:19:39 +0000
Subject: [PATCH 300/369] editorial fix

[SVN r12867]
---
 doc/v2/return_internal_reference.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/v2/return_internal_reference.html b/doc/v2/return_internal_reference.html
index 42b8c97e..347db88c 100644
--- a/doc/v2/return_internal_reference.html
+++ b/doc/v2/return_internal_reference.html
@@ -131,7 +131,7 @@ PyObject* postcall(PyObject* args, PyObject* result);
     <dl class="function-semantics">
       <dt><b>Requires:</b> <code><a href="http://www.python.org/doc/2.2/api/tupleObjects.html#l2h-476">PyTuple_Check</a>(args) != 0</code>
 
-      <dt><b>Returns:</b> <code><a href="make_custodian_and_ward.html#make_custodian_and_ward_postcall-spec-statics">make_custodian_and_ward_postcall::postcall(args, result)</a></code>
+      <dt><b>Returns:</b> <code><a href="with_custodian_and_ward.html#with_custodian_and_ward_postcall-spec-statics">with_custodian_and_ward_postcall::postcall(args, result)</a></code>
     </dl>
 
 

From d965b41bddee5db615ff7c10d87baa7d1c05c00c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 21 Feb 2002 01:24:28 +0000
Subject: [PATCH 301/369] Fix GC problems

[SVN r12869]
---
 src/object/class.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/object/class.cpp b/src/object/class.cpp
index 60a803f9..d35a7b5e 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -45,8 +45,8 @@ PyTypeObject class_metatype_object = {
         0,                                      /* tp_getattro */
         0,                                      /* tp_setattro */
         0,                                      /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
-		Py_TPFLAGS_BASETYPE,		/* tp_flags */
+    Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
+		| Py_TPFLAGS_BASETYPE,		/* tp_flags */
         0,                                      /* tp_doc */
         0,                                      /* tp_traverse */
         0,                                      /* tp_clear */
@@ -119,8 +119,8 @@ PyTypeObject class_type_object = {
         0,                                      /* tp_getattro */
         0,                                      /* tp_setattro */
         0,                                      /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
-		Py_TPFLAGS_BASETYPE,		/* tp_flags */
+    Py_TPFLAGS_DEFAULT // | Py_TPFLAGS_HAVE_GC
+		| Py_TPFLAGS_BASETYPE,		/* tp_flags */
         0,                                      /* tp_doc */
         0,                                      /* tp_traverse */
         0,                                      /* tp_clear */

From 6c7d3e1eab3b1b166c8f1ea5ed96373e0a84fb62 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 23 Feb 2002 21:26:55 +0000
Subject: [PATCH 302/369] inital checkin

[SVN r12915]
---
 .../python/converter/pointer_type_id.hpp      | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 include/boost/python/converter/pointer_type_id.hpp

diff --git a/include/boost/python/converter/pointer_type_id.hpp b/include/boost/python/converter/pointer_type_id.hpp
new file mode 100644
index 00000000..79a30b02
--- /dev/null
+++ b/include/boost/python/converter/pointer_type_id.hpp
@@ -0,0 +1,69 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef POINTER_TYPE_ID_DWA2002222_HPP
+# define POINTER_TYPE_ID_DWA2002222_HPP
+
+# include <boost/python/converter/type_id.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <bool is_ref = false>
+  struct pointer_typeid_select
+  {
+      template <class T>
+      static inline undecorated_type_id_t execute(T*(*)() = 0)
+      {
+          return undecorated_type_id<T>();
+      }
+  };
+
+  template <>
+  struct pointer_typeid_select<true>
+  {
+      template <class T>
+      static inline undecorated_type_id_t execute(T* const volatile&(*)() = 0)
+      {
+          return undecorated_type_id<T>();
+      }
+    
+      template <class T>
+      static inline undecorated_type_id_t execute(T*volatile&(*)() = 0)
+      {
+          return undecorated_type_id<T>();
+      }
+    
+      template <class T>
+      static inline undecorated_type_id_t execute(T*const&(*)() = 0)
+      {
+          return undecorated_type_id<T>();
+      }
+
+      template <class T>
+      static inline undecorated_type_id_t execute(T*&(*)() = 0)
+      {
+          return undecorated_type_id<T>();
+      }
+  };
+}
+
+// Usage: pointer_type_id<T>()
+//
+// Returns an undecorated_type_id_t associated with the type pointed
+// to by T, which may be a pointer or a reference to a pointer.
+template <class T>
+undecorated_type_id_t pointer_type_id(T(*)() = 0)
+{
+    return detail::pointer_typeid_select<
+          is_reference<T>::value
+        >::execute((T(*)())0);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // POINTER_TYPE_ID_DWA2002222_HPP

From a04cbd111c85a64acf4f4a70d2f1b8589765636b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Feb 2002 04:47:48 +0000
Subject: [PATCH 303/369] bug fix

[SVN r12922]
---
 include/boost/python/detail/indirect_traits.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/boost/python/detail/indirect_traits.hpp b/include/boost/python/detail/indirect_traits.hpp
index 41681719..8c096a2f 100644
--- a/include/boost/python/detail/indirect_traits.hpp
+++ b/include/boost/python/detail/indirect_traits.hpp
@@ -27,13 +27,13 @@ struct is_reference_to_const<T const&>
 template <class T>
 struct is_reference_to_non_const
 {
-    BOOST_STATIC_CONSTANT(bool, value = false);
-};
-
-template <class T>
-struct is_reference_to_non_const<T&>
-{
-    BOOST_STATIC_CONSTANT(bool, value = true);
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            ::boost::type_traits::ice_and<
+            ::boost::is_reference<T>::value
+            , !::boost::python::detail::is_reference_to_const<T>::value
+            >::value)
+        );
 };
 
 template <class T>

From e11b457b79093b038ee1edcf0ec6ed021cf6a067 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Feb 2002 05:24:48 +0000
Subject: [PATCH 304/369] Major rearchitecture of from_python mechanism

[SVN r12924]
---
 Jamfile                                       |  34 +-
 doc/v2/module.html                            |   2 +-
 include/boost/python/converter/body.hpp       |  62 ---
 include/boost/python/converter/class.hpp      |  75 ----
 .../python/converter/find_from_python.hpp     |  25 ++
 .../boost/python/converter/from_python.hpp    | 386 +++++++++++-------
 .../python/converter/from_python_data.hpp     |  89 ++--
 .../python/converter/from_python_function.hpp |   9 +-
 .../converter/from_python_stage1_data.hpp     |  21 +
 .../boost/python/converter/registrations.hpp  |  28 ++
 include/boost/python/converter/registry.hpp   |  19 +-
 include/boost/python/converter/target.hpp     | 191 ---------
 .../boost/python/converter/unwrapper_base.hpp |  36 --
 include/boost/python/detail/destroy.hpp       |  83 ++++
 include/boost/python/from_python.hpp          |   5 +-
 include/boost/python/lvalue_from_python.hpp   |  96 -----
 include/boost/python/object/class.hpp         |  18 +-
 .../boost/python/object/class_converters.hpp  |   7 +-
 .../boost/python/object/pointer_holder.hpp    |   8 +-
 include/boost/python/object/value_holder.hpp  |   6 +-
 .../boost/python/reference_from_python.hpp    |  62 ---
 include/boost/python/type_from_python.hpp     |  87 +++-
 include/boost/python/value_from_python.hpp    |  73 ----
 src/converter/body.cpp                        |  18 -
 src/converter/builtin_converters.cpp          | 247 +++++------
 src/converter/from_python.cpp                 |  43 +-
 src/converter/handle.cpp                      |  35 --
 src/converter/registry.cpp                    |  53 ++-
 src/converter/unwrap.cpp                      |  36 --
 src/converter/unwrapper.cpp                   |  31 --
 src/converter/wrapper.cpp                     |  41 --
 src/object/class.cpp                          |   2 +-
 test/destroy_test.cpp                         |  81 ++++
 test/indirect_traits_test.cpp                 |  48 +++
 test/m1.cpp                                   |  51 +--
 test/pointer_type_id_test.cpp                 |  39 ++
 36 files changed, 929 insertions(+), 1218 deletions(-)
 delete mode 100644 include/boost/python/converter/body.hpp
 delete mode 100644 include/boost/python/converter/class.hpp
 create mode 100644 include/boost/python/converter/find_from_python.hpp
 create mode 100644 include/boost/python/converter/from_python_stage1_data.hpp
 create mode 100644 include/boost/python/converter/registrations.hpp
 delete mode 100644 include/boost/python/converter/target.hpp
 delete mode 100644 include/boost/python/converter/unwrapper_base.hpp
 create mode 100644 include/boost/python/detail/destroy.hpp
 delete mode 100644 include/boost/python/lvalue_from_python.hpp
 delete mode 100644 include/boost/python/reference_from_python.hpp
 delete mode 100644 include/boost/python/value_from_python.hpp
 delete mode 100644 src/converter/body.cpp
 delete mode 100644 src/converter/handle.cpp
 delete mode 100644 src/converter/unwrap.cpp
 delete mode 100644 src/converter/unwrapper.cpp
 delete mode 100644 src/converter/wrapper.cpp
 create mode 100644 test/destroy_test.cpp
 create mode 100644 test/indirect_traits_test.cpp
 create mode 100644 test/pointer_type_id_test.cpp

diff --git a/Jamfile b/Jamfile
index aa804505..79dfd9e5 100644
--- a/Jamfile
+++ b/Jamfile
@@ -4,14 +4,18 @@ subproject libs/python ;
 SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
 include <module@>python.jam ;
 
-PYTHON_PROPERTIES 
-  += <metrowerks><*><cxxflags>"-inline deferred" 
-  <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
-    <define>BOOST_PYTHON_DYNAMIC_LIB
-    <define>BOOST_PYTHON_V2
-    ;
 
 {
+    local BOOST_PYTHON_V2_PROPERTIES 
+      = $(PYTHON_PROPERTIES)
+        <metrowerks><*><cxxflags>"-inline deferred" 
+        <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
+          <define>BOOST_PYTHON_DYNAMIC_LIB
+          <define>BOOST_PYTHON_V2
+          ;
+    
+    local PYTHON_PROPERTIES = $(BOOST_PYTHON_V2_PROPERTIES) ;
+    
     dll bpl
       : 
       src/converter/from_python.cpp
@@ -26,7 +30,7 @@ PYTHON_PROPERTIES
       src/objects.cpp
       src/converter/builtin_converters.cpp
       :
-      $(PYTHON_PROPERTIES)
+      $(BOOST_PYTHON_V2_PROPERTIES)
         <define>BOOST_PYTHON_SOURCE
         ;
 
@@ -67,4 +71,20 @@ PYTHON_PROPERTIES
       :
       : debug-python
       ;
+    
 }
+
+unit-test indirect_traits_test
+  : test/indirect_traits_test.cpp : <include>$(BOOST_ROOT)  ;
+unit-test destroy_test
+  : test/destroy_test.cpp : <include>$(BOOST_ROOT)  ;
+unit-test pointer_type_id_test
+  : test/pointer_type_id_test.cpp : <include>$(BOOST_ROOT)  ;
+
+unit-test select_from_python_test
+  : test/select_from_python_test.cpp
+  src/converter/type_id.cpp
+  src/converter/registry.cpp # MWerks needs this for some reason
+  : $(PYTHON_PROPERTIES)
+    ;
+
diff --git a/doc/v2/module.html b/doc/v2/module.html
index 847ff017..3775e4d1 100644
--- a/doc/v2/module.html
+++ b/doc/v2/module.html
@@ -157,7 +157,7 @@ module&amp; setattr(const char* name, ref const&amp; r);
       <dt><b>Effects:</b> Adds the given Python object to the module. If the
       object is a product of <code><a href=
       "make_function.html#make_function-spec">make_function</a>()</code>, the
-      usual <a href="http:overloading.html">overloading procedure</a> applies.
+      usual <a href="overloading.html">overloading procedure</a> applies.
       In the first two forms, ownership of a reference to obj is transferred
       from caller to callee, even if an exception is thrown.
 
diff --git a/include/boost/python/converter/body.hpp b/include/boost/python/converter/body.hpp
deleted file mode 100644
index d9170839..00000000
--- a/include/boost/python/converter/body.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef BODY_DWA2001127_HPP
-# define BODY_DWA2001127_HPP
-# include <boost/python/detail/config.hpp>
-# include <boost/python/converter/type_id.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-namespace registry
-{
-  class entry;
-}
-
-struct BOOST_PYTHON_DECL body
-{
- public:
-    body(type_id_t key);
-    virtual ~body() {}
-
-    type_id_t key() const;
-
- protected:
-    // true iff the registry is still alive
-    bool can_unregister() const;
-    
- private:
-    // called when the registry is destroyed, to prevent it from being
-    // unregistered.
-    void do_not_unregister();
-    friend class registry::entry;
-    
- private:
-    type_id_t m_key;
-    bool m_can_unregister;
-};
-
-//
-// implementations
-//
-inline body::body(type_id_t key)
-    : m_key(key)
-    , m_can_unregister(true)
-{
-}
-
-inline type_id_t body::key() const
-{
-    return m_key;
-}
-
-inline bool body::can_unregister() const
-{
-    return m_can_unregister;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // BODY_DWA2001127_HPP
diff --git a/include/boost/python/converter/class.hpp b/include/boost/python/converter/class.hpp
deleted file mode 100644
index 67de6fad..00000000
--- a/include/boost/python/converter/class.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef CLASS_DWA20011215_HPP
-# define CLASS_DWA20011215_HPP
-
-# include <boost/python/object/class.hpp>
-# include <boost/python/converter/from_python.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T>
-struct class_from_python_converter
-{
-    class_from_python_converter();
-    
-    static void* convertible(PyObject*);
-    static T& convert_ref(PyObject*, from_python_data&);
-    static T const& convert_cref(PyObject*, from_python_data&);
-    static T* convert_ptr(PyObject*, from_python_data&);
-    static T const* convert_cptr(PyObject*, from_python_data&);
-
-    from_python_converter<T&> to_ref;
-    from_python_converter<T const&> to_cref;
-    from_python_converter<T*> to_ptr;
-    from_python_converter<T const*> to_cptr;
-};
-
-//
-// implementations
-//
-template <class T>
-class_from_python_converter<T>::class_from_python_converter()
-    : to_ref(convertible, convert_ref)
-      , to_cref(convertible, convert_cref)
-      , to_ptr(convertible, convert_ptr)
-      , to_cptr(convertible, convert_cptr)
-{}
-
-template <class T>
-T& class_from_python_converter<T>::convert_ref(PyObject*, from_python_data& x)
-{
-    return *static_cast<T*>(x.stage1);
-}
-
-template <class T>
-T const& class_from_python_converter<T>::convert_cref(PyObject*, from_python_data& x)
-{
-    return *static_cast<T*>(x.stage1);
-}
-    
-
-template <class T>
-T* class_from_python_converter<T>::convert_ptr(PyObject*, from_python_data& x)
-{
-    return static_cast<T*>(x.stage1);
-}
-
-template <class T>
-T const* class_from_python_converter<T>::convert_cptr(PyObject*, from_python_data& x)
-{
-    return static_cast<T*>(x.stage1);
-}
-
-template <class T>
-void* class_from_python_converter<T>::convertible(PyObject* p)
-{
-    return objects::find_instance<T>(p);
-}
-
-}}} // namespace boost::python::converter
-
-#endif // CLASS_DWA20011215_HPP
diff --git a/include/boost/python/converter/find_from_python.hpp b/include/boost/python/converter/find_from_python.hpp
new file mode 100644
index 00000000..863c44a6
--- /dev/null
+++ b/include/boost/python/converter/find_from_python.hpp
@@ -0,0 +1,25 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FIND_FROM_PYTHON_DWA2002223_HPP
+# define FIND_FROM_PYTHON_DWA2002223_HPP
+
+# include <boost/python/detail/config.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct lvalue_from_python_registration;
+struct rvalue_from_python_registration;
+struct rvalue_stage1_data;
+
+BOOST_PYTHON_DECL void* find(
+    PyObject* source, lvalue_from_python_registration const*);
+BOOST_PYTHON_DECL void* find(
+    PyObject* source, rvalue_from_python_registration const*, rvalue_stage1_data&);
+
+}}} // namespace boost::python::converter
+
+#endif // FIND_FROM_PYTHON_DWA2002223_HPP
diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index b6e1edc4..0881a06a 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -6,193 +6,279 @@
 #ifndef FROM_PYTHON_DWA2002127_HPP
 # define FROM_PYTHON_DWA2002127_HPP
 
-# include <boost/python/detail/config.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/converter/from_python_function.hpp>
-# include <boost/python/converter/from_python_data.hpp>
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/find_from_python.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/utility.hpp>
+# include <boost/python/detail/destroy.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+# include <boost/python/converter/from_python_data.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/python/converter/registry.hpp>
 
-namespace boost { namespace python { namespace converter { 
+namespace boost { namespace python { namespace converter {
 
-// The type of convertibility checking functions
-typedef void* (*from_python_check)(PyObject*);
-typedef void (*from_python_destructor)(from_python_data&);
-
-// forward declaration
-template <class T> struct from_python_lookup;
-
-// from_python --
-//    A body class representing a conversion from python to C++.
-
-struct BOOST_PYTHON_DECL from_python_converter_base : body
+struct from_python_base
 {
-    from_python_converter_base(type_id_t, from_python_check); // registers
+ public: // member functions
+    from_python_base(void* result);
+    from_python_base(PyObject*, lvalue_from_python_registration const* chain);
+    bool convertible() const;
+    
+ protected: // member functions
+    void*const& result() const;
+    
+ private: // data members
+    void* m_result;
+};
 
-    // Must return non-null iff the conversion will be successful. Any
-    // non-null pointer is acceptable, and will be passed on to the
-    // convert() function, so useful data can be stored there.
-    inline void* convertible(PyObject*) const;
-
-    // Given the head of a from_python converter chain, find the
-    // converter which can convert p, leaving its intermediate data in
-    // data.
-    inline static from_python_converter_base const*
-    find(from_python_converter_base const*chain, PyObject* p, void*& data);
+// Used when T == U*const&
+template <class T>
+struct pointer_const_reference_from_python
+{
+    pointer_const_reference_from_python(PyObject*);
+    T operator()(PyObject*) const;
+    bool convertible() const;
     
  private:
-    from_python_check m_convertible;
-    from_python_converter_base* m_next;
+    detail::referent_storage<T>::type m_result;
+    
+    static lvalue_from_python_registration*& chain;
 };
 
-
+// Used when T == U* 
 template <class T>
-struct from_python_converter : from_python_converter_base
+struct pointer_from_python : from_python_base
 {
- public: // types
-    typedef typename from_python_function<T>::type conversion_function;
+    pointer_from_python(PyObject*);
+    T operator()(PyObject*) const;
     
- public: // member functions    
-    from_python_converter(from_python_check, conversion_function, from_python_destructor = 0);
-    T convert(PyObject*, from_python_data&) const;
-    void destroy(from_python_data&) const;
-
-    // Find a converter for converting p to a T.
-    static from_python_converter<T> const* find(PyObject* p, void*& data);
-    
- private: // data members
-    conversion_function m_convert;
-    from_python_destructor m_destroy;
-
-    // Keeps the chain of converters which convert from PyObject* to T
-    static from_python_converter_base*const& chain;
+    static lvalue_from_python_registration*& chain;
 };
 
-// Initialized to refer to a common place in the registry.
+// Used when T == U& and (T != V const& or T == W volatile&)
 template <class T>
-from_python_converter_base*const&
-from_python_converter<T>::chain = registry::from_python_chain(type_id<T>());
-
-// -------------------------------------------------------------------------
-
-// A class which implements from_python with a registry lookup.
-template <class T>
-struct from_python_lookup // : from_python_base
+struct reference_from_python : from_python_base
 {
- public: // types
+    reference_from_python(PyObject*);
+    T operator()(PyObject*) const;
     
- public: // member functions
-    from_python_lookup(PyObject* source);
-    ~from_python_lookup();
+    static lvalue_from_python_registration*& chain;
+};
 
+// ------- rvalue converters ---------
+
+// Used for the case where T is a non-pointer, non-reference type OR
+// is a const non-volatile reference to a non-pointer type.
+template <class T>
+class rvalue_from_python
+{
+    typedef typename boost::add_reference<
+        typename boost::add_const<T>::type
+    >::type result_type;
+    
+ public:
+    rvalue_from_python(PyObject*);
+    ~rvalue_from_python();
     bool convertible() const;
-    T operator()(PyObject*);
-
- public: // functions for use by conversion implementations
-    // Get the converter object
-    from_python_converter<T> const* converter() const;
     
- private: // data members
-    typedef typename from_python_intermediate_data<T>::type intermediate_t;
-    mutable intermediate_t m_intermediate_data;
-    from_python_converter<T> const* m_converter;
+    result_type operator()(PyObject*);
+    
+ private:
+    rvalue_data<result_type> m_data;
+    static rvalue_from_python_registration*& chain;
+};
+
+template <class T>
+struct select_from_python
+{
+    BOOST_STATIC_CONSTANT(
+        bool, ptr = is_pointer<T>::value);
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ptr_cref
+            = boost::python::detail::is_reference_to_pointer<T>::value
+            && boost::python::detail::is_reference_to_const<T>::value
+            && !boost::python::detail::is_reference_to_volatile<T>::value);
+    
+    
+    BOOST_STATIC_CONSTANT(
+        bool, ref =
+        boost::python::detail::is_reference_to_non_const<T>::value
+        || boost::python::detail::is_reference_to_volatile<T>::value);
+
+    typedef typename mpl::select_type<
+        ptr
+        , pointer_from_python<T>
+        , typename mpl::select_type<
+             ptr_cref
+             , pointer_const_reference_from_python<T>
+             , typename mpl::select_type<
+                   ref
+                   , reference_from_python<T>
+                   , rvalue_from_python<T>
+                >::type
+          >::type
+    >::type type;
 };
 
 //
 // implementations
 //
-inline void* from_python_converter_base::convertible(PyObject* o) const
+inline from_python_base::from_python_base(void* result)
+    : m_result(result)
 {
-    return m_convertible(o);
 }
 
-inline from_python_converter_base const*
-from_python_converter_base::find(
-    from_python_converter_base const* chain, PyObject* p, void*& data)
+inline from_python_base::from_python_base(
+    PyObject* const source
+    , lvalue_from_python_registration const* chain)
+    : m_result(find(source, chain))
 {
-    for (from_python_converter_base const* q = chain; q != 0 ; q = q->m_next)
-    {
-        void* d = q->convertible(p);
-        if (d != 0)
-        {
-            data = d;
-            return q;
-        }
-    }
-    return 0;
+}
+
+inline bool from_python_base::convertible() const
+{
+    return m_result != 0;
+}
+
+inline void*const& from_python_base::result() const
+{
+    return m_result;
+}
+
+// --------
+
+namespace detail
+{
+  template <class U>
+  inline U& void_ptr_to_reference(void const volatile* p, U&(*)())
+  {
+      return *(U*)p;
+  }
+
+  template <class T>
+  struct null_ptr_owner
+  {
+      static T value;
+  };
+  template <class T> T null_ptr_owner<T>::value = 0;
+  
+  template <class U>
+  inline U& null_ptr_reference(U&(*)())
+  {
+      return null_ptr_owner<U>::value;
+  }
+
+  template <class T>
+  inline void write_void_ptr(void const volatile* storage, void* ptr, T*)
+  {
+      *(T**)storage = (T*)ptr;
+  }
+
+  // writes U(ptr) into the storage
+  template <class U>
+  inline void write_void_ptr_reference(void const volatile* storage, void* ptr, U&(*)())
+  {
+      write_void_ptr(storage, ptr, U(0));
+  }
 }
 
 template <class T>
-inline from_python_converter<T>::from_python_converter(
-     from_python_check checker
-    , conversion_function converter
-    , from_python_destructor destructor // = 0
-    )
-    : from_python_converter_base(type_id<T>(), checker)
-    , m_convert(converter)
-    , m_destroy(destructor)
+inline pointer_const_reference_from_python<T>::pointer_const_reference_from_python(PyObject* p)
 {
+    detail::write_void_ptr_reference(
+        m_result.bytes
+        , p == Py_None ? p : find(p, chain)
+        , (T(*)())0);
+}
+
+template <class T>
+inline bool pointer_const_reference_from_python<T>::convertible() const
+{
+    return detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
+}
+template <class T>
+inline T pointer_const_reference_from_python<T>::operator()(PyObject* p) const
+{
+    return (p == Py_None)
+        ? detail::null_ptr_reference((T(*)())0)
+        : detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
+}
+
+template <class T>
+lvalue_from_python_registration*& pointer_const_reference_from_python<T>::chain
+        = registry::lvalue_converters(pointer_type_id<T>());
+
+// --------
+
+template <class T>
+inline pointer_from_python<T>::pointer_from_python(PyObject* p)
+    : from_python_base(p == Py_None ? p : find(p, chain))
+{
+}
+
+template <class T>
+inline T pointer_from_python<T>::operator()(PyObject* p) const
+{
+    return (p == Py_None) ? 0 : T(result());
+}
+
+template <class T>
+lvalue_from_python_registration*& pointer_from_python<T>::chain
+        = registry::lvalue_converters(pointer_type_id<T>());
+
+// --------
+
+template <class T>
+inline reference_from_python<T>::reference_from_python(PyObject* p)
+    : from_python_base(find(p,chain))
+{
+}
+
+template <class T>
+inline T reference_from_python<T>::operator()(PyObject*) const
+{
+    return detail::void_ptr_to_reference(result(), (T(*)())0);
+}
+
+template <class T>
+lvalue_from_python_registration*& reference_from_python<T>::chain
+        = registry::lvalue_converters(undecorated_type_id<T>());
+
+// -------
+
+template <class T>
+inline rvalue_from_python<T>::rvalue_from_python(PyObject* obj)
+{
+    find(obj, chain, m_data.stage1);
+}
+
+template <class T>
+inline rvalue_from_python<T>::~rvalue_from_python()
+{
+    if (m_data.stage1.convertible == m_data.storage.bytes)
+        python::detail::destroy_reference<result_type>(m_data.storage.bytes);
+}
+
+template <class T>
+inline bool rvalue_from_python<T>::convertible() const
+{
+    return m_data.stage1.convertible != 0;
+}
+
+template <class T>
+inline typename rvalue_from_python<T>::result_type
+rvalue_from_python<T>::operator()(PyObject* p)
+{
+    if (m_data.stage1.construct != 0)
+        m_data.stage1.construct(p, &m_data.stage1);
     
+    return detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
 }
 
 template <class T>
-inline from_python_converter<T> const*
-from_python_converter<T>::find(PyObject* p, void*& data)
-{
-    return static_cast<from_python_converter<T> const*>(
-        from_python_converter_base::find(chain, p, data));
-}
-
-template <class T>
-inline T from_python_converter<T>::convert(PyObject* src, from_python_data& data) const
-{
-    return this->m_convert(src, data);
-}
-
-template <class T>
-inline void from_python_converter<T>::destroy(from_python_data& data) const
-{
-    if (this->m_destroy)
-    {
-        this->m_destroy(data);
-    }
-}
-
-template <class T>
-inline from_python_lookup<T>::from_python_lookup(PyObject* src)
-    : m_converter(
-        from_python_converter<T>::find(
-            src, m_intermediate_data.stage1))
-{
-}
-
-template <class T>
-inline from_python_lookup<T>::~from_python_lookup()
-{
-    if (m_converter != 0)
-        m_converter->destroy(m_intermediate_data);
-}
-
-template <class T>
-inline bool from_python_lookup<T>::convertible() const
-{
-    return this->m_converter != 0;
-}
-
-template <class T>
-inline T from_python_lookup<T>::operator()(PyObject* obj)
-{
-    return this->m_converter->convert(obj, m_intermediate_data);
-}
-
-template <class T>
-inline from_python_converter<T> const*
-from_python_lookup<T>::converter() const
-{
-    return this->m_converter;
-}
+rvalue_from_python_registration*& rvalue_from_python<T>::chain
+        = registry::rvalue_converters(undecorated_type_id<T>());
 
 }}} // namespace boost::python::converter
 
diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index 3edcbad7..57a3d76e 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -9,26 +9,20 @@
 # include <boost/python/detail/char_array.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/type_traits/same_traits.hpp>
-# include <boost/type.hpp>
+# include <boost/type_traits/alignment_traits.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/static_assert.hpp>
+# include <boost/python/converter/from_python_stage1_data.hpp>
 
 // Keep these for the metaprogram which EDG is choking on.
 # if !defined(__EDG__) || (__EDG_VERSION__ > 245)
 #  include <boost/mpl/type_list.hpp>
 #  include <boost/mpl/for_each.hpp>
-#  include <boost/type_traits/alignment_traits.hpp>
 #  include <boost/type_traits/composite_traits.hpp>
 # endif 
 
 namespace boost { namespace python { namespace converter { 
 
-// A POD which is layout-compatible with the real intermediate data
-// for all from_python conversions. There may be additional storage if
-// we are converting a reference type.
-struct from_python_data
-{
-    void* stage1;
-};
-
 namespace detail
 {
   template <class T> struct referent_alignment;
@@ -74,8 +68,8 @@ namespace detail
   
   template <class T> struct referent_size
   {
-      static T t;
-      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(t));
+      static T f();
+      BOOST_STATIC_CONSTANT(std::size_t, value = sizeof(f()));
   };
   
 # endif
@@ -130,17 +124,13 @@ namespace detail
 #endif // EDG is too slow
   
   template <class Align, std::size_t size>
-  struct aligned_storage
+  union aligned_storage
   {
-      typedef Align align_t;
-      union 
-      {
-          Align align;
-          char bytes[size
-                     // this is just a STATIC_ASSERT. For some reason
-                     // MSVC was barfing on the boost one.
-              - (is_same<align_t,unknown_alignment>::value ? size : 0)];
-      };
+      Align align;
+      char bytes[size
+                 // this is just a STATIC_ASSERT. For some reason
+                 // MSVC was barfing on the boost one.
+                 - (is_same<Align,unknown_alignment>::value ? size : 0)];
   };
 
   template <class Reference>
@@ -151,56 +141,39 @@ namespace detail
       typedef mpl::for_each<
           align_types
           , unknown_alignment
-          , best_alignment_type<referent_alignment<Reference>::value>
+          , best_alignment_type<
+          referent_alignment<Reference>::value
+      >
       > loop;
+    
       typedef typename loop::state align_t;
 #else
       // The Python source makes the assumption that double has
       // maximal alignment anyway
       typedef double align_t;
-#endif 
-
+    
+#endif
+      BOOST_STATIC_CONSTANT(std::size_t, alignment1 = alignment_of<align_t>::value);
+      BOOST_STATIC_CONSTANT(std::size_t, alignment2 = referent_alignment<Reference>::value);
+    
+      BOOST_STATIC_ASSERT(alignment1 >= alignment2);
+      BOOST_STATIC_ASSERT(alignment1 % alignment2 == 0);
+    
       typedef aligned_storage<align_t,referent_size<Reference>::value> type;
   };
-
-  template <class T>
-  struct intermediate_data : from_python_data
-  {
-      typename referent_storage<T>::type stage2;
-  };
-
-  template <>
-  struct intermediate_data<void> : from_python_data
-  {
-  };
-
+  
 }
 
-// -------------------------------------------------------------------------
-// Auxiliary POD storage where the convertible and/or convert functions of a
-// from_python object may place arbitrary data.
-//
-// Always starts with a void*
-//
-// For references, we produce additional aligned storage sufficient to
-// store the referent
-
 template <class T>
-struct from_python_intermediate_data
+struct rvalue_data
 {
-    typedef typename mpl::select_type<
-        is_reference<T>::value, T, void>::type just_reference_t;
-
-    typedef detail::intermediate_data<just_reference_t> type;
+    rvalue_stage1_data stage1;
+    
+    typename detail::referent_storage<
+        typename add_reference<T>::type
+    >::type storage;
 };
 
-template <class T>
-void* get_storage(from_python_data& x, boost::type<T>* = 0)
-{
-    typedef typename from_python_intermediate_data<T>::type layout;
-    return static_cast<layout*>(&x)->stage2.bytes;
-}
-
 }}} // namespace boost::python::converter
 
 #endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP
diff --git a/include/boost/python/converter/from_python_function.hpp b/include/boost/python/converter/from_python_function.hpp
index 0cf90459..eea96372 100644
--- a/include/boost/python/converter/from_python_function.hpp
+++ b/include/boost/python/converter/from_python_function.hpp
@@ -10,13 +10,8 @@
 
 namespace boost { namespace python { namespace converter { 
 
-struct from_python_data;
-
-template <class T>
-struct from_python_function
-{
-    typedef T (*type)(PyObject*, from_python_data&);
-};
+struct rvalue_stage1_data;
+typedef void (*constructor_function)(PyObject* source, rvalue_stage1_data*);
 
 }}} // namespace boost::python::converter
 
diff --git a/include/boost/python/converter/from_python_stage1_data.hpp b/include/boost/python/converter/from_python_stage1_data.hpp
new file mode 100644
index 00000000..50fd74ad
--- /dev/null
+++ b/include/boost/python/converter/from_python_stage1_data.hpp
@@ -0,0 +1,21 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
+# define FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
+
+# include <boost/python/converter/from_python_function.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct rvalue_stage1_data
+{
+    void* convertible;
+    constructor_function construct;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // FROM_PYTHON_STAGE1_DATA_DWA2002223_HPP
diff --git a/include/boost/python/converter/registrations.hpp b/include/boost/python/converter/registrations.hpp
new file mode 100644
index 00000000..8a27741c
--- /dev/null
+++ b/include/boost/python/converter/registrations.hpp
@@ -0,0 +1,28 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef REGISTRATIONS_DWA2002223_HPP
+# define REGISTRATIONS_DWA2002223_HPP
+
+# include <boost/python/converter/from_python_function.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+struct lvalue_from_python_registration
+{
+    void* (*convert)(PyObject* source);
+    lvalue_from_python_registration* next;
+};
+
+struct rvalue_from_python_registration
+{
+    void* (*convertible)(PyObject*);
+    constructor_function construct;
+    rvalue_from_python_registration* next;
+};
+
+}}} // namespace boost::python::converter
+
+#endif // REGISTRATIONS_DWA2002223_HPP
diff --git a/include/boost/python/converter/registry.hpp b/include/boost/python/converter/registry.hpp
index bdb64254..a511a1a4 100644
--- a/include/boost/python/converter/registry.hpp
+++ b/include/boost/python/converter/registry.hpp
@@ -9,20 +9,33 @@
 # include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/from_python_function.hpp>
 
 namespace boost { namespace python { namespace converter {
 
-struct BOOST_PYTHON_DECL from_python_converter_base;
+struct lvalue_from_python_registration;
+struct rvalue_from_python_registration;
 
 // This namespace acts as a sort of singleton
 namespace registry
 {
+  BOOST_PYTHON_DECL lvalue_from_python_registration*& lvalue_converters(undecorated_type_id_t);
+  BOOST_PYTHON_DECL rvalue_from_python_registration*& rvalue_converters(undecorated_type_id_t);
+  
   BOOST_PYTHON_DECL to_python_value_function const&
   to_python_function(undecorated_type_id_t);
   
   BOOST_PYTHON_DECL void insert(to_python_value_function, undecorated_type_id_t);
-  
-  BOOST_PYTHON_DECL from_python_converter_base*& from_python_chain(type_id_t);
+
+  // Insert an lvalue from_python converter
+  BOOST_PYTHON_DECL void insert(void* (*convert)(PyObject*), undecorated_type_id_t);
+
+  // Insert an rvalue from_python converter
+  BOOST_PYTHON_DECL void insert(
+      void* (*convertible)(PyObject*)
+      , constructor_function
+      , undecorated_type_id_t
+      );
   
   BOOST_PYTHON_DECL PyTypeObject*& class_object(undecorated_type_id_t key);
 }
diff --git a/include/boost/python/converter/target.hpp b/include/boost/python/converter/target.hpp
deleted file mode 100644
index f8f33171..00000000
--- a/include/boost/python/converter/target.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-//  Copyright David Abrahams 2001. Permission to copy, use,
-//  modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies. This software is provided
-//  "as is" without express or implied warranty, and with no claim as
-//  to its suitability for any purpose.
-
-#ifndef TARGET_DWA20011119_HPP
-# define TARGET_DWA20011119_HPP
-# include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/transform_traits.hpp>
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/mpl/select_type.hpp>
-# include <boost/type_traits/same_traits.hpp>
-
-namespace boost { namespace python { namespace converter {
-
-// target --
-//
-//    This type generator (see
-//    ../../../more/generic_programming.html#type_generator) is used
-//    to select the return type of the appropriate converter for
-//    unwrapping a given type.
-
-// Strategy:
-//
-// 1. reduce everything to a common, un-cv-qualified reference
-//    type where possible. This will save on registering many different
-//    converter types.
-//
-// 2. Treat built-in types specially: when unwrapping a value or
-//    constant reference to one of these, use a value for the target
-//    type. It will bind to a const reference if neccessary, and more
-//    importantly, avoids having to dynamically allocate room for
-//    an lvalue of types which can be cheaply copied.
-//
-
-// Target                Source
-// int                   int
-// int const&            int
-// int&                  int&
-// int volatile&         int volatile&
-// int const volatile&   int const volatile&
-
-// On compilers supporting partial specialization:
-//
-// Target                Source
-// T                     T const&
-// T&                    T&
-// T const&              T const&
-// T volatile            T&
-// T const volatile&     T const&
-// T*                    T*
-// T const*              T const*
-// T volatile            T*
-// T const volatile*     T const*
-// T cv*const&           same as T cv*
-// T cv*&                T*& <- should this be legal?
-// T cv*volatile&        T*& <- should this be legal?
-// T cv*const volatile&  T*& <- should this be legal?
-
-// On others:
-//
-// Target                Source
-// T                     T&
-// T cv&                 T cv&
-// T cv*                 T cv*
-// T cv*cv&              T cv*cv&
-
-// As you can see, in order to handle the same range of types without
-// partial specialization, more converters need to be registered.
-
-template <class T>
-struct target
-{
-    // Some pointer types are handled in a more sophisticated way on
-    // compilers supporting partial specialization.
-    BOOST_STATIC_CONSTANT(bool, use_identity = (::boost::is_scalar<T>::value));
-
-    typedef typename mpl::select_type<
-        use_identity
-        , T
-        , typename add_reference<
-                typename add_const<
-                        typename remove_volatile<T>::type
-                >::type
-          >::type
-    >::type type;
-};
-
-// When partial specialization is not present, we'll simply need to
-// register many more converters.
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-template <class T>
-struct target<T&>
-{
-    typedef typename remove_volatile<T>::type& type;
-};
-
-template <class T>
-struct target<T const&>
-{
-    typedef typename boost::mpl::select_type<
-        is_scalar<T>::value
-        , typename remove_cv<T>::type
-        , typename remove_volatile<T>::type const&
-    >::type type;
-};
-
-template <class T>
-struct target<T*>
-{
-    typedef typename remove_volatile<T>::type* type;
-};
-
-// Handle T*-cv for completeness. Function arguments in a signature
-// are never actually cv-qualified, but who knows how these converters
-// might be used, or whether compiler bugs lurk which make it seem
-// otherwise?
-template <class T>
-struct target<T* const>
-{
-    typedef typename remove_volatile<T>::type* type;
-};
-
-template <class T>
-struct target<T* volatile>
-{
-    typedef typename remove_volatile<T>::type* type;
-};
-
-template <class T>
-struct target<T* const volatile>
-{
-    typedef typename remove_volatile<T>::type* type;
-};
-
-// non-const references to pointers should be handled by the
-// specialization for T&, above.
-template <class T>
-struct target<T* const&>
-{
-    typedef typename remove_volatile<T>::type* type;
-};
-# endif
-
-// Fortunately, we can handle T const& where T is an arithmetic type
-// by explicit specialization. These specializations will cause value
-// and const& arguments to be converted to values, rather than to
-// references.
-# define  BOOST_PYTHON_UNWRAP_VALUE(T)  \
-template <>                             \
-struct target<T>                        \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T const>                  \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T volatile>               \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T const volatile>         \
-{                                       \
-    typedef T type;                     \
-};                                      \
-template <>                             \
-struct target<T const&>                 \
-{                                       \
-    typedef T type;                     \
-}
-
-BOOST_PYTHON_UNWRAP_VALUE(char);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned char);
-BOOST_PYTHON_UNWRAP_VALUE(signed char);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned int);
-BOOST_PYTHON_UNWRAP_VALUE(signed int);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned short);
-BOOST_PYTHON_UNWRAP_VALUE(signed short);
-BOOST_PYTHON_UNWRAP_VALUE(unsigned long);
-BOOST_PYTHON_UNWRAP_VALUE(signed long);
-BOOST_PYTHON_UNWRAP_VALUE(char const*);
-
-}}} // namespace boost::python::converter
-
-#endif // TARGET_DWA20011119_HPP
diff --git a/include/boost/python/converter/unwrapper_base.hpp b/include/boost/python/converter/unwrapper_base.hpp
deleted file mode 100644
index ea437eb2..00000000
--- a/include/boost/python/converter/unwrapper_base.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAPPER_BASE_DWA20011215_HPP
-# define UNWRAPPER_BASE_DWA20011215_HPP
-# include <boost/python/converter/type_id.hpp>
-# include <boost/python/converter/body.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_DECL unwrapper_base : body
-{
- public:
-    unwrapper_base(type_id_t); // registers
-    ~unwrapper_base();         // unregisters
-
-    // Must return non-null iff the conversion will be successful. Any
-    // non-null pointer is acceptable, and will be passed on to the
-    // convert() function, so useful data can be stored there.
-    virtual void* can_convert(PyObject*) const = 0;
-    
- protected:
-    // this is an arbitrary non-null pointer you can use to indicate success
-    static void* const non_null;
-    
- private: // body required interface implementation
-    void destroy_handle(handle*) const {}
-};
-
-}}} // namespace boost::python::converter
-
-#endif // UNWRAPPER_BASE_DWA20011215_HPP
diff --git a/include/boost/python/detail/destroy.hpp b/include/boost/python/detail/destroy.hpp
new file mode 100644
index 00000000..07738e2f
--- /dev/null
+++ b/include/boost/python/detail/destroy.hpp
@@ -0,0 +1,83 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef DESTROY_DWA2002221_HPP
+# define DESTROY_DWA2002221_HPP
+
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/object_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <bool array, bool trivial_destructor> struct value_destroyer;
+
+template <>
+struct value_destroyer<false,false>
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        p->T::~T();
+    }
+};
+
+template <>
+struct value_destroyer<true,false>
+{
+    template <class A, class T>
+    static void execute(A*, T const volatile* const first)
+    {
+        for (T const volatile* p = first; p != first + sizeof(A)/sizeof(T); ++p)
+            value_destroyer<
+                boost::is_array<T>::value
+                ,boost::has_trivial_destructor<T>::value
+                >::execute(p);
+    }
+    
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        execute(p, *p);
+    }
+};
+
+template <>
+struct value_destroyer<true,true>
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+    }
+};
+
+template <>
+struct value_destroyer<false,true>
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+    }
+};
+
+template <class T>
+inline void destroy_reference_impl(void* p, T& (*)())
+{
+    // note: cv-qualification needed for MSVC6
+    // must come *before* T for metrowerks
+    value_destroyer<
+        (boost::is_array<T>::value)
+        , (boost::has_trivial_destructor<T>::value)
+        >::execute((const volatile T*)p);
+}
+
+template <class T>
+inline void destroy_reference(void* p, T(*)() = 0)
+{
+    destroy_reference_impl(p, (T(*)())0);
+}
+
+}}} // namespace boost::python::detail
+
+#endif // DESTROY_DWA2002221_HPP
diff --git a/include/boost/python/from_python.hpp b/include/boost/python/from_python.hpp
index 995f7877..62b340f1 100644
--- a/include/boost/python/from_python.hpp
+++ b/include/boost/python/from_python.hpp
@@ -7,15 +7,14 @@
 # define FROM_PYTHON_DWA2002128_HPP
 
 # include <boost/python/converter/from_python.hpp>
-# include <boost/python/converter/target.hpp>
 
 namespace boost { namespace python { 
 
 template <class T>
 struct from_python
-    : converter::from_python_lookup<typename converter::target<T>::type>
+    : converter::select_from_python<T>::type
 {
-    typedef converter::from_python_lookup<typename converter::target<T>::type> base;
+    typedef typename converter::select_from_python<T>::type base;
     from_python(PyObject*);
 };
 
diff --git a/include/boost/python/lvalue_from_python.hpp b/include/boost/python/lvalue_from_python.hpp
deleted file mode 100644
index c5d09ff5..00000000
--- a/include/boost/python/lvalue_from_python.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef LVALUE_FROM_PYTHON_DWA2002130_HPP
-# define LVALUE_FROM_PYTHON_DWA2002130_HPP
-
-# include <boost/python/converter/from_python.hpp>
-# include <boost/python/type_from_python.hpp>
-
-namespace boost { namespace python { 
-
-// Utility which produces a member extractor function on platforms
-// other than VC6.
-template <class Class, class Member, Member (Class::*mp)>
-struct get_member
-{
-    static Member& execute(Class& c)
-    {
-        return c.*mp;
-    }
-};
-
-namespace detail
-{
-  template <class Class>
-  struct extract_identity
-  {
-      static Class& execute(Class& c)
-      {
-          return c;
-      }
-  };
-}
-
-template <
-    PyTypeObject const* python_type
-    , class Value
-    , class PythonObject = Value
-    , class Extract = detail::extract_identity<Value>
-    >
-class lvalue_from_python
-{
-    typedef type_from_python<python_type> convertible_t;
- public:
-    
-    lvalue_from_python()
-        : m_mutable_converter(
-            &convertible_t::convertible, convert_mutable)
-        
-        , m_const_converter(
-            &convertible_t::convertible, convert_const)
-
-        , m_mutable_pointer_converter(
-            &convertible_t::convertible, convert_mutable_pointer)
-        
-        , m_const_pointer_converter(
-            &convertible_t::convertible, convert_const_pointer)
-    {}
-    
- private:
-    static Value& convert_mutable(PyObject* op, converter::from_python_data&)
-    {
-        return Extract::execute(*(PythonObject*)op);
-    }
-    
-    static Value const& convert_const(PyObject* op, converter::from_python_data&)
-    {
-        return Extract::execute(*(PythonObject*)op);
-    }
-    
-    static Value* convert_mutable_pointer(PyObject* op, converter::from_python_data&)
-    {
-        return &Extract::execute(*(PythonObject*)op);
-    }
-    
-    static Value const* convert_const_pointer(PyObject* op, converter::from_python_data&)
-    {
-        return &Extract::execute(*(PythonObject*)op);
-    }
-    
-    typedef converter::from_python_converter<Value&> mutable_converter;
-    typedef converter::from_python_converter<Value const&> const_converter;
-    typedef converter::from_python_converter<Value*> mutable_pointer_converter;
-    typedef converter::from_python_converter<Value const*> const_pointer_converter;
-    
-    mutable_converter m_mutable_converter;
-    const_converter m_const_converter;
-    mutable_pointer_converter m_mutable_pointer_converter;
-    const_pointer_converter m_const_pointer_converter;
-};
-
-}} // namespace boost::python
-
-#endif // LVALUE_FROM_PYTHON_DWA2002130_HPP
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 35280074..04f0e992 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -53,7 +53,7 @@ struct BOOST_PYTHON_DECL instance_holder : private noncopyable
     // return the next holder in a chain
     instance_holder* next() const;
 
-    virtual void* holds(converter::type_id_t) = 0;
+    virtual void* holds(converter::undecorated_type_id_t) = 0;
 
     void install(PyObject* inst) throw();
     
@@ -85,15 +85,19 @@ struct instance
     instance_holder* objects;
 };
 
-// Given a type_id, find the instance data which corresponds to it, or
-// return 0 in case no such type is held.
-BOOST_PYTHON_DECL void* find_instance_impl(PyObject*, converter::type_id_t);
+// Given an undecorated type_id, find the instance data which
+// corresponds to it, or return 0 in case no such type is held.
+BOOST_PYTHON_DECL void* find_instance_impl(PyObject*, converter::undecorated_type_id_t);
 
+// This produces a function with the right signature for use in from_python conversions
 template <class T>
-T* find_instance(PyObject* p, T* = 0)
+struct instance_finder
 {
-    return static_cast<T*>(find_instance_impl(p, converter::type_id<T>()));
-}
+    static inline void* execute(PyObject* p)
+    {
+        return find_instance_impl(p, converter::undecorated_type_id<T>());
+    }
+};
 
 BOOST_PYTHON_DECL ref class_metatype();
 BOOST_PYTHON_DECL ref class_type();
diff --git a/include/boost/python/object/class_converters.hpp b/include/boost/python/object/class_converters.hpp
index d5978af7..540565bf 100644
--- a/include/boost/python/object/class_converters.hpp
+++ b/include/boost/python/object/class_converters.hpp
@@ -6,10 +6,10 @@
 #ifndef CLASS_CONVERTERS_DWA2002119_HPP
 # define CLASS_CONVERTERS_DWA2002119_HPP
 
-# include <boost/python/converter/class.hpp>
 # include <boost/python/object/class_wrapper.hpp>
 # include <boost/mpl/for_each.hpp>
 # include <boost/python/reference.hpp>
+# include <boost/python/converter/registry.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -24,7 +24,6 @@ struct class_converters
     class_converters(ref const& python_class);
 
  private: // data members
-    converter::class_from_python_converter<Derived> m_unwrapper;
     class_wrapper<Derived> m_wrapper;
 };
 
@@ -90,6 +89,10 @@ template <class Derived, class Bases>
 class_converters<Derived,Bases>::class_converters(ref const& type_object)
     : m_wrapper(type_object)
 {
+    converter::registry::insert(
+        &instance_finder<Derived>::execute
+        , converter::undecorated_type_id<Derived>());
+    
     // register all up/downcasts here
     register_dynamic_id<Derived>();
 
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index 21fe8e96..c307f019 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -139,7 +139,7 @@ struct pointer_holder : instance_holder
     {}
 
  private: // required holder implementation
-    void* holds(converter::type_id_t);
+    void* holds(converter::undecorated_type_id_t);
 
  private: // data members
     Pointer m_p;
@@ -186,12 +186,12 @@ pointer_holder<Pointer,Value>::pointer_holder(Pointer p)
 }
 
 template <class Pointer, class Value>
-void* pointer_holder<Pointer, Value>::holds(converter::type_id_t dst_t)
+void* pointer_holder<Pointer, Value>::holds(converter::undecorated_type_id_t dst_t)
 {
-    if (dst_t == converter::type_id<Pointer>())
+    if (dst_t == converter::undecorated_type_id<Pointer>())
         return &this->m_p;
 
-    converter::type_id_t src_t = converter::type_id<Value>();
+    converter::type_id_t src_t = converter::undecorated_type_id<Value>();
     return src_t == dst_t ? &*this->m_p
         : find_dynamic_type(&*this->m_p, src_t, dst_t);
 }
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index 01431370..6533bc39 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -134,7 +134,7 @@ struct value_holder : instance_holder
     {}
 
  private: // required holder implementation
-    void* holds(converter::type_id_t);
+    void* holds(converter::undecorated_type_id_t);
 
  private: // data members
     Held m_held;
@@ -151,9 +151,9 @@ struct value_holder_generator
 };
 
 template <class Held>
-void* value_holder<Held>::holds(converter::type_id_t dst_t)
+void* value_holder<Held>::holds(converter::undecorated_type_id_t dst_t)
 {
-    converter::type_id_t src_t = converter::type_id<Held>();
+    converter::undecorated_type_id_t src_t = converter::undecorated_type_id<Held>();
     return src_t == dst_t ? &m_held
         : find_static_type(&m_held, src_t, dst_t);
 }
diff --git a/include/boost/python/reference_from_python.hpp b/include/boost/python/reference_from_python.hpp
deleted file mode 100644
index a9631dc5..00000000
--- a/include/boost/python/reference_from_python.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef REFERENCE_FROM_PYTHON_DWA2002130_HPP
-# define REFERENCE_FROM_PYTHON_DWA2002130_HPP
-
-# include <boost/python/converter/from_python.hpp>
-# include <boost/python/type_from_python.hpp>
-
-namespace boost { namespace python { 
-
-// Utility which produces a member extractor function on platforms
-// other than VC6.
-template <class Class, class Member, Member (Class::*mp)>
-struct get_member
-{
-    static Member& execute(Class* c)
-    {
-        return c->*mp;
-    }
-};
-
-template <
-    PyTypeObject const* python_type
-    , class Value
-    , class PythonObject
-    , class Extract
-    >
-struct reference_from_python
-{
-    typedef type_from_python<python_type> convertible_t;
-    
-    reference_from_python()
-        : m_mutable_converter(
-            &convertible_t::convertible, convert_mutable)
-        
-        , m_const_converter(
-            &convertible_t::convertible, convert_const)
-    {}
-    
-    static Value& convert_mutable(PyObject* op, converter::from_python_data&)
-    {
-        return Extract::execute(*(PythonObject*)op);
-    }
-    
-    static Value const& convert_const(PyObject* op, converter::from_python_data&)
-    {
-        return Extract::execute(*(PythonObject*)op);
-    }
-    
- private:
-    typedef converter::from_python_converter<Value&> mutable_converter;
-    typedef converter::from_python_converter<Value const&> const_converter;
-    mutable_converter m_mutable_converter;
-    const_converter m_const_converter;
-};
-
-}} // namespace boost::python
-
-#endif // REFERENCE_FROM_PYTHON_DWA2002130_HPP
diff --git a/include/boost/python/type_from_python.hpp b/include/boost/python/type_from_python.hpp
index 46d59d13..16b8da81 100644
--- a/include/boost/python/type_from_python.hpp
+++ b/include/boost/python/type_from_python.hpp
@@ -6,15 +6,94 @@
 #ifndef TYPE_FROM_PYTHON_DWA2002130_HPP
 # define TYPE_FROM_PYTHON_DWA2002130_HPP
 
+# include <boost/python/converter/registry.hpp>
+
 namespace boost { namespace python {
 
-template <PyTypeObject const* python_type>
+namespace detail
+{
+  // Given a pointer-to-function of 1 parameter returning a reference
+  // type, return the type_id of the function's return type.
+  template <class T, class U>
+  inline converter::undecorated_type_id_t extractor_type_id(T&(*)(U))
+  {
+      return converter::undecorated_type_id<T>();
+  }
+
+  // A function generator whose static execute() function is an lvalue
+  // from_python converter using the given Extractor. U is exepcted to
+  // be the actual type of the PyObject instance from which the result
+  // is being extracted.
+  template <class Extractor, class U>
+  struct normalized_extractor
+  {
+      static inline void* execute(PyObject* op)
+      {
+          typedef typename boost::add_reference<U>::type param;
+          return &Extractor::execute(
+              boost::python::converter::detail::void_ptr_to_reference(
+                  op, (param(*)())0 )
+              );
+      }
+  };
+
+  // Given an Extractor type and a pointer to its execute function,
+  // return a new object whose static execute function does the same
+  // job but is a conforming lvalue from_python conversion function.
+  //
+  // usage: normalize<Extractor>(&Extractor::execute)
+  template <class Extractor, class T, class U>
+  inline normalized_extractor<Extractor,U>
+  normalize(T(*)(U), Extractor* = 0)
+  {
+      return normalized_extractor<Extractor, U>();
+  }
+}
+
+// An Extractor which extracts the given member from a Python object
+// whose instances are stored as InstanceType.
+template <class InstanceType, class MemberType, MemberType (InstanceType::*member)>
+struct member_extractor
+{
+    static MemberType& execute(InstanceType& c)
+    {
+        (void)c.ob_type; // static assertion
+        return c.*member;
+    }
+};
+
+// An Extractor which simply extracts the entire python object
+// instance of InstanceType.
+template <class InstanceType>
+struct identity_extractor
+{
+    static InstanceType& execute(InstanceType& c)
+    {
+        (void)c.ob_type; // static assertion
+        return c;
+    }
+};
+
+// Registers a from_python conversion which extracts lvalues using
+// Extractor's static execute function from Python objects whose type
+// object is python_type.
+template <PyTypeObject const* python_type, class Extractor>
 struct type_from_python
 {
-    static void* convertible(PyObject* op)
+    type_from_python()
     {
-        return PyObject_TypeCheck(
-            op, const_cast<PyTypeObject*>(python_type)) ? op : 0;
+        converter::registry::insert(
+            &extract, detail::extractor_type_id(&Extractor::execute));
+    }
+    
+    static void* extract(PyObject* op)
+    {
+        return PyObject_TypeCheck(op, const_cast<PyTypeObject*>(python_type))
+            ? const_cast<void*>(
+                static_cast<void const volatile*>(
+                    detail::normalize<Extractor>(&Extractor::execute).execute(op)))
+            : 0
+            ;
     }
 };
 
diff --git a/include/boost/python/value_from_python.hpp b/include/boost/python/value_from_python.hpp
deleted file mode 100644
index c835de45..00000000
--- a/include/boost/python/value_from_python.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef VALUE_FROM_PYTHON_DWA2002130_HPP
-# define VALUE_FROM_PYTHON_DWA2002130_HPP
-
-# include <boost/python/converter/from_python.hpp>
-# include <boost/type_traits/object_traits.hpp>
-# include <boost/mpl/select_type.hpp>
-# include <boost/static_assert.hpp>
-
-namespace boost { namespace python { 
-
-template <typename T, class Derived>
-struct value_from_python
-{
-    typedef value_from_python<T,Derived> self;
-    typedef converter::from_python_check from_python_check;
-    
-    value_from_python(from_python_check convertible)
-        : m_converter(
-            convertible
-            , &Derived::convert
-            
-            // Change this to a compile-time check later to avoid
-            // generating destroy function
-            , has_trivial_destructor<T>::value ? 0 : &Derived::destroy
-            )
-    {
-    }
-
-    value_from_python()
-        : m_converter(
-            &Derived::convertible
-            , &Derived::convert
-            
-            // Change this to a compile-time check later to avoid
-            // generating destroy function
-            , has_trivial_destructor<T>::value ? 0 : &Derived::destroy
-            )
-    {
-    }
-
-    static void* get_storage(converter::from_python_data& data)
-    {
-        return converter::get_storage<T const&>(data);
-    }
-
-    // Mark successful construction
-    static void constructed(converter::from_python_data& data)
-    {
-        data.stage1 = self::get_storage(data);
-    }
-    
-    inline static void destroy(converter::from_python_data& data)
-    {
-        // Get the location of the storage for
-        void* storage = self::get_storage(data);
-
-        // Check for successful construction
-        if (data.stage1 == storage)
-            static_cast<T*>(storage)->~T();
-    }
-
- private:
-    converter::from_python_converter<T const&> m_converter;
-};
-
-}} // namespace boost::python
-
-#endif // VALUE_FROM_PYTHON_DWA2002130_HPP
diff --git a/src/converter/body.cpp b/src/converter/body.cpp
deleted file mode 100644
index 637f8c3e..00000000
--- a/src/converter/body.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#include <boost/python/converter/body.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-// default implementation is a no-op. Most handles will not hold any
-// data that needs to be managed. Unwrap objects which convert
-// by-value are an exception. Fortunately, the concrete body subclass
-// has that knowledge.
-void body::destroy_handle(handle*) const
-{
-}
-
-}}} // namespace boost::python::converter
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 9cf5f110..8db20586 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -7,177 +7,120 @@
 #include <boost/python/detail/config.hpp>
 #include <boost/python/detail/wrap_python.hpp>
 #include <boost/python/converter/builtin_converters.hpp>
-#include <boost/python/converter/target.hpp>
-#include <boost/python/value_from_python.hpp>
 #include <boost/python/converter/from_python_data.hpp>
+#include <boost/python/converter/registry.hpp>
 #include <boost/python/reference.hpp>
 #include <boost/cast.hpp>
-//#include <boost/mpl/type_list.hpp>
 #include <string>
 
 namespace boost { namespace python { namespace converter {
 
 namespace
 {
-  // Only an object which we know is holding a char const* can be
-  // converted to one
-  struct convertible_to_cstring
+  // An lvalue conversion function which extracts a char const* from a
+  // Python String.
+  void* convert_to_cstring(PyObject* obj)
   {
-      static unaryfunc* execute(PyObject* obj)
-      {
-          return PyString_Check(obj) ? &obj->ob_type->tp_str : 0;
-      }
-  };
+      return PyString_Check(obj) ? PyString_AsString(obj) : 0;
+  }
 
-  struct extract_cstring
+  // Given a target type and a SlotPolicy describing how to perform a
+  // given conversion, registers from_python converters which use the
+  // SlotPolicy to extract the type.
+  template <class T, class SlotPolicy>
+  struct slot_rvalue_from_python
   {
-      static char const* execute(PyObject* obj)
-      {
-          return PyString_AsString(obj);
-      }
-  };
-
-  // Any object which can be converted to a Python string can also be
-  // converted to a C++ string, since the latter owns its bytes.
-  struct convertible_to_string
-  {
-      static unaryfunc* execute(PyObject* obj)
-      {
-          return obj->ob_type->tp_str ? &obj->ob_type->tp_str : 0;
-      }
-  };
-  
-  // Transform a function returning a unaryfunc* into one that returns a void*
-  template <class F>
-  struct return_void_ptr
-  {
-      static void* execute(PyObject* p) { return F::execute(p); }
-  };
-  
-  template <
-      class T                   // The target type
-      , class Convertible       // returns a pointer to a unaryfunc producing an object
-      , class TExtract          // ...from which TExtract extracts T's constructor argument
-      >
-  struct tp_scalar_from_python
-      : from_python_converter<T>
-  {
-   private:
-      typedef return_void_ptr<Convertible> convertible_fn;
-      
    public:
-      tp_scalar_from_python()
-          : from_python_converter<T>(
-              &convertible_fn::execute
-              , convert)
-      {}
-      
-      static T convert(PyObject* obj, from_python_data& data)
+      slot_rvalue_from_python()
       {
-          unaryfunc converter = *(unaryfunc*)data.stage1;
-          ref converted(converter(obj));
-          return TExtract::execute(converted.get());
+          registry::insert(
+              &slot_rvalue_from_python<T,SlotPolicy>::convertible
+              , &slot_rvalue_from_python<T,SlotPolicy>::construct
+              , undecorated_type_id<T>()
+              );
       }
-  };
-
-  // Extract a reference to T using the functions in the source
-  // object's type slots
-  template <
-      class T                   // The target type
-      , class Convertible       // returns a pointer to a unaryfunc producing an object
-      , class TExtract          // ...from which TExtract extracts T's constructor argument
-      >
-  struct tp_cref_from_python
-      : value_from_python<T, tp_cref_from_python<T,Convertible,TExtract> >
-  {
+      
    private:
-      typedef tp_cref_from_python<T,Convertible,TExtract> self;
-      typedef value_from_python<T,tp_cref_from_python<T,Convertible,TExtract> > base;
-      
-   public:
-      tp_cref_from_python()
-          : base(&return_void_ptr<Convertible>::execute)
-      {}
-      
-      static T const& convert(PyObject* obj, from_python_data& data)
+      static void* convertible(PyObject* obj)
       {
-          unaryfunc converter = *(unaryfunc*)data.stage1;
-          
-          void* storage = self::get_storage(data);
-          
-          ref converted(converter(obj));
-              
-          T* const p = new (storage) T(TExtract::execute(converted.get()));
-          
-          // note that construction is successful.
-          data.stage1 = p;
-          
-          return *p;
+          unaryfunc* slot = SlotPolicy::get_slot(obj);
+          return slot && *slot ? slot : 0;
+      }
+
+      static void construct(PyObject* obj, rvalue_stage1_data* data)
+      {
+          // Get the (intermediate) source object
+          unaryfunc creator = *static_cast<unaryfunc*>(data->convertible);
+          ref intermediate(creator(obj));
+
+          // Get the location in which to construct
+          void* storage = ((rvalue_data<T>*)data)->storage.bytes;
+          new (storage) T(SlotPolicy::extract(intermediate.get()));
+
+          // record successful construction
+          data->convertible = storage;
       }
   };
 
-  struct convertible_to_int
+  // A SlotPolicy for extracting integer types from Python objects
+  struct int_rvalue_from_python
   {
-      static unaryfunc* execute(PyObject* obj)
+      static unaryfunc* get_slot(PyObject* obj)
       {
           PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
           if (number_methods == 0)
               return 0;
 
           // For floating types, return the float conversion slot to avoid
-          // creating a new object. We'll handle that in
-          // py_int_or_float_as_long, below
+          // creating a new object. We'll handle that below
           if (PyObject_TypeCheck(obj, &PyFloat_Type) && number_methods->nb_float)
               return &number_methods->nb_float;
       
-          return number_methods && number_methods->nb_int
-              ? &number_methods->nb_int : 0;
+          return &number_methods->nb_int;
       }
-  };
-
-  struct py_int_or_float_as_long
-  {
-      static long execute(PyObject* obj)
+      
+      static long extract(PyObject* intermediate)
       {
-          if (PyObject_TypeCheck(obj, &PyFloat_Type))
+          if (PyObject_TypeCheck(intermediate, &PyFloat_Type))
           {
-              return numeric_cast<long>(PyFloat_AS_DOUBLE(obj));
+              return numeric_cast<long>(PyFloat_AS_DOUBLE(intermediate));
           }
           else
           {
-              return PyInt_AS_LONG(obj);
+              return PyInt_AS_LONG(intermediate);
           }
       }
   };
 
+
+  // identity_unaryfunc/non_null -- manufacture a unaryfunc "slot"
+  // which just returns its argument. Used for bool conversions, since
+  // all Python objects are directly convertible to bool
   extern "C" PyObject* identity_unaryfunc(PyObject* x)
   {
       Py_INCREF(x);
       return x;
   }
-  
   unaryfunc non_null = identity_unaryfunc;
-  
-  struct convertible_to_bool
+
+  // A SlotPolicy for extracting bool from a Python object
+  struct bool_rvalue_from_python
   {
-      static unaryfunc* execute(PyObject* obj)
+      static unaryfunc* get_slot(PyObject*)
       {
           return &non_null;
       }
-  };
-
-  struct py_object_as_bool
-  {
-      static bool execute(PyObject* obj)
+      
+      static bool extract(PyObject* intermediate)
       {
-          return PyObject_IsTrue(obj);
+          return PyObject_IsTrue(intermediate);
       }
   };
 
-  
-  struct convertible_to_double
+  // A SlotPolicy for extracting floating types from Python objects.
+  struct float_rvalue_from_python
   {
-      static unaryfunc* execute(PyObject* obj)
+      static unaryfunc* get_slot(PyObject* obj)
       {
           PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
           if (number_methods == 0)
@@ -189,67 +132,63 @@ namespace
           if (PyObject_TypeCheck(obj, &PyInt_Type) && number_methods->nb_int)
               return &number_methods->nb_int;
       
-          return number_methods && number_methods->nb_float
-              ? &number_methods->nb_float : 0;
+          return &number_methods->nb_float;
       }
-  };
-
-  struct py_float_or_int_as_double
-  {
-      static double execute(PyObject* obj)
+      
+      static double extract(PyObject* intermediate)
       {
-          if (PyObject_TypeCheck(obj, &PyInt_Type))
+          if (PyObject_TypeCheck(intermediate, &PyInt_Type))
           {
-              return PyInt_AS_LONG(obj);
+              return PyInt_AS_LONG(intermediate);
           }
           else
           {
-              return PyFloat_AS_DOUBLE(obj);
+              return PyFloat_AS_DOUBLE(intermediate);
           }
       }
   };
 
-  template <class T, class Convertible, class Convert>
-  struct scalar_from_python
+  // A SlotPolicy for extracting C++ strings from Python objects.
+  struct string_rvalue_from_python
   {
-      tp_cref_from_python<T,Convertible,Convert> cref_converter;
-      tp_scalar_from_python<T,Convertible,Convert> value_converter;
-  };
-  
-  template <class T>
-  void register_int_converters(T* = 0)
-  {
-      static scalar_from_python<T, convertible_to_int, py_int_or_float_as_long> x;
-  }
-}    
+      // If the underlying object is "string-able" this will succeed
+      static unaryfunc* get_slot(PyObject* obj)
+      {
+          return &obj->ob_type->tp_str;
+      };
 
-#define REGISTER_INT_CONVERTERS(U) register_int_converters<U>()
+      // Remember that this will be used to construct the result object 
+      static char const* extract(PyObject* intermediate)
+      {
+          return PyString_AsString(intermediate);
+      }
+  };
+} 
+
+#define REGISTER_INT_CONVERTERS(U) slot_rvalue_from_python<U,int_rvalue_from_python>()
 #define REGISTER_INT_CONVERTERS2(U) REGISTER_INT_CONVERTERS(signed U); REGISTER_INT_CONVERTERS(unsigned U)  
 
 void initialize_builtin_converters()
 {
-    static scalar_from_python<
-        bool, convertible_to_bool, py_object_as_bool> bool_from_python;
-    
+    // booleans
+    slot_rvalue_from_python<bool,bool_rvalue_from_python>();
+
+    // integer types
     REGISTER_INT_CONVERTERS2(char);
     REGISTER_INT_CONVERTERS2(short);
     REGISTER_INT_CONVERTERS2(int);
     REGISTER_INT_CONVERTERS2(long);
 
-    static scalar_from_python<
-        float,convertible_to_double,py_float_or_int_as_double> float_from_python;
+    // floating types
+    slot_rvalue_from_python<float,float_rvalue_from_python>();
+    slot_rvalue_from_python<double,float_rvalue_from_python>();
+    slot_rvalue_from_python<long double,float_rvalue_from_python>();
     
-    static scalar_from_python<
-        double,convertible_to_double,py_float_or_int_as_double> double_from_python;
-    
-    static scalar_from_python<
-        long double,convertible_to_double,py_float_or_int_as_double> long_double_from_python;
-    
-    static scalar_from_python<
-        char const*, convertible_to_cstring, extract_cstring> cstring_from_python;
+    // Add an lvalue converter for char which gets us char const*
+    registry::insert(convert_to_cstring,undecorated_type_id<char>());
 
-    static tp_cref_from_python<
-        std::string, convertible_to_string, extract_cstring> string_from_python;
+    // Register by-value converters to std::string
+    slot_rvalue_from_python<std::string, string_rvalue_from_python>();
 }
 
 }}} // namespace boost::python::converter
diff --git a/src/converter/from_python.cpp b/src/converter/from_python.cpp
index 2e844acf..0650fcbb 100644
--- a/src/converter/from_python.cpp
+++ b/src/converter/from_python.cpp
@@ -4,23 +4,40 @@
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
 
-#include <boost/python/converter/from_python.hpp>
-#include <boost/python/converter/registry.hpp>
+#include <boost/python/converter/find_from_python.hpp>
+#include <boost/python/converter/registrations.hpp>
+#include <boost/python/converter/from_python_data.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-from_python_converter_base::from_python_converter_base(
-    type_id_t type
-    , from_python_check checker
-    )
-    : body(type)
-    , m_convertible(checker)
-
+BOOST_PYTHON_DECL void* find(
+    PyObject* source
+    , rvalue_from_python_registration const* chain
+    , rvalue_stage1_data& data)
 {
-    // Insert this in the converter chain.
-    from_python_converter_base*& head = registry::from_python_chain(type);
-    m_next = head;
-    head = this;
+    for (;chain != 0; chain = chain->next)
+    {
+        void* r = chain->convertible(source);
+        if (r != 0)
+        {
+            data.construct = chain->construct;
+            return data.convertible = r;
+        }
+    }
+    return data.convertible = 0;
+}
+
+BOOST_PYTHON_DECL void* find(
+    PyObject* const source
+    , lvalue_from_python_registration const* chain)
+{
+    for (;chain != 0; chain = chain->next)
+    {
+        void* r = chain->convert(source);
+        if (r != 0)
+            return r;
+    }
+    return 0;
 }
 
 }}} // namespace boost::python::converter
diff --git a/src/converter/handle.cpp b/src/converter/handle.cpp
deleted file mode 100644
index 1a2b8c31..00000000
--- a/src/converter/handle.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#include <boost/python/converter/handle.hpp>
-#include <boost/python/converter/body.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-bool handle::convertible() const
-{
-    for (handle const* p = this; p != 0; p = p->m_next)
-    {
-        if (p->m_body == 0)
-            return false;
-    }
-    return true;
-}
-
-void handle::destroy()
-{
-    // Recurse down the chain releasing from tail to head
-    if (m_next != 0)
-        m_next->destroy();
-
-    // Our body knows how to destroy us. If we never got a body,
-    // there's nothing to do.
-    if (m_body)
-        m_body->destroy_handle(this);
-}
-
-// void handle::dummy::nonnull() {}
-
-}}} // namespace boost::python::converter
diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
index c90d709d..bdfa1c8a 100644
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -4,6 +4,7 @@
 //  "as is" without express or implied warranty, and with no claim as
 //  to its suitability for any purpose.
 #include <boost/python/converter/registry.hpp>
+#include <boost/python/converter/registrations.hpp>
 #include <boost/python/converter/builtin_converters.hpp>
 #include <map>
 #include <stdexcept>
@@ -19,20 +20,23 @@ namespace // <unnamed>
       
       // The unique to_python converter for the associated C++ type.
       to_python_value_function m_to_python_converter;
-
+      
       // The collection of from_python converters for the associated
       // C++ type.
-      from_python_converter_base* m_from_python_converters;
+      lvalue_from_python_registration* m_lvalue_from_python;
+      rvalue_from_python_registration* m_rvalue_from_python;
 
       // The class object associated with this type
       PyTypeObject* m_class_object;
   };
   
-  typedef std::map<type_id_t, entry> registry_t;
+  typedef std::map<undecorated_type_id_t, entry> registry_t;
   
   registry_t& entries()
   {
       static registry_t registry;
+      
+#ifdef BOOST_PYTHON_DYNAMIC_LIB // this conditional should go away eventually.
       static bool builtin_converters_initialized = false;
       if (!builtin_converters_initialized)
       {
@@ -42,17 +46,19 @@ namespace // <unnamed>
           
           initialize_builtin_converters();
       }
+#endif 
       return registry;
   }
 
-  entry* find(type_id_t type)
+  entry* find(undecorated_type_id_t type)
   {
       return &entries()[type];
   }
 
   entry::entry()
       : m_to_python_converter(0)
-        , m_from_python_converters(0)
+        , m_lvalue_from_python(0)
+        , m_rvalue_from_python(0)
         , m_class_object(0)
   {
   }
@@ -78,15 +84,46 @@ namespace registry
       slot = f;
   }
 
-  from_python_converter_base*& from_python_chain(type_id_t key)
+  // Insert an lvalue from_python converter
+  void insert(void* (*convert)(PyObject*), undecorated_type_id_t key)
   {
-      return find(key)->m_from_python_converters;
+      entry* found = find(key);
+      lvalue_from_python_registration *registration = new lvalue_from_python_registration;
+      registration->convert = convert;
+      registration->next = found->m_lvalue_from_python;
+      found->m_lvalue_from_python = registration;
+      
+      insert(convert, 0, key);
   }
-  
+
+  // Insert an rvalue from_python converter
+  void insert(void* (*convertible)(PyObject*)
+              , constructor_function construct
+              , undecorated_type_id_t key)
+  {
+      entry* found = find(key);
+      rvalue_from_python_registration *registration = new rvalue_from_python_registration;
+      registration->convertible = convertible;
+      registration->construct = construct;
+      registration->next = found->m_rvalue_from_python;
+      found->m_rvalue_from_python = registration;
+  }
+
   PyTypeObject*& class_object(undecorated_type_id_t key)
   {
       return find(key)->m_class_object;
   }
+
+  lvalue_from_python_registration*& lvalue_converters(undecorated_type_id_t key)
+  {
+      return find(key)->m_lvalue_from_python;
+  }
+  
+  rvalue_from_python_registration*& rvalue_converters(undecorated_type_id_t key)
+  {
+      return find(key)->m_rvalue_from_python;
+  }
+  
 } // namespace registry
 
 }}} // namespace boost::python::converter
diff --git a/src/converter/unwrap.cpp b/src/converter/unwrap.cpp
deleted file mode 100644
index 6a72ab77..00000000
--- a/src/converter/unwrap.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-#include <boost/python/converter/unwrap.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-namespace
-{
-  struct pyobject_unwrapper : unwrapper_base
-  {
-      pyobject_unwrapper();
-      void* can_convert(PyObject*) const;
-  };
-  
-  pyobject_unwrapper static_unwrapper;
-  std::pair<unwrapper_base*,void*> unwrapper_pair(&static_unwrapper,&static_unwrapper);  
-
-  pyobject_unwrapper::pyobject_unwrapper()
-      : unwrapper_base(type_id<PyObject*>())
-  {
-  }
-      
-  void* pyobject_unwrapper::can_convert(PyObject*) const
-  {
-      return non_null;
-  }
-}
-
-BOOST_PYTHON_DECL std::pair<unwrapper_base*,void*>&
-unwrap_more_<PyObject*>::m_unwrapper = unwrapper_pair;
-
-}}} // namespace boost::python::converter
diff --git a/src/converter/unwrapper.cpp b/src/converter/unwrapper.cpp
deleted file mode 100644
index 6279febf..00000000
--- a/src/converter/unwrapper.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#include <boost/python/converter/unwrapper.hpp>
-#include <boost/python/converter/registry.hpp>
-#include <boost/type_traits/same_traits.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-unwrapper_base::unwrapper_base(type_id_t key)
-    : body(key)
-{
-    registry::insert(*this);
-}
-
-unwrapper_base::~unwrapper_base()
-{
-    if (can_unregister())
-        registry::remove(*this);
-}
-
-namespace
-{
-  int arbitrary;
-}
-
-void* const unwrapper_base::non_null = &arbitrary;
-
-}}} // namespace boost::python::converter
diff --git a/src/converter/wrapper.cpp b/src/converter/wrapper.cpp
deleted file mode 100644
index 567ff99d..00000000
--- a/src/converter/wrapper.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-#include <boost/python/converter/registry.hpp>
-#include <boost/python/converter/wrapper.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-wrapper_base::wrapper_base(type_id_t type)
-    : body(type)
-{
-    registry::insert(*this);
-}
-
-wrapper_base::~wrapper_base()
-{
-    if (can_unregister())
-        registry::remove(*this);
-}
-
-namespace
-{
-  // This doesn't actually get called, but we need something to fill
-  // in the slot in the wrap<PyObject*> class.
-  struct identity_wrapper_t : wrapper<PyObject*>
-  {
-      PyObject* convert(PyObject* source) const
-      {
-          return source;
-      }
-  };
-
-  identity_wrapper_t identity_wrapper_object;
-}
-
-BOOST_PYTHON_DECL body& identity_wrapper = identity_wrapper_object;
-
-}}} // namespace boost::python::converter
diff --git a/src/object/class.cpp b/src/object/class.cpp
index d35a7b5e..8186f9be 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -163,7 +163,7 @@ void instance_holder::install(PyObject* self) throw()
 }
 
 BOOST_PYTHON_DECL void*
-find_instance_impl(PyObject* inst, converter::type_id_t type)
+find_instance_impl(PyObject* inst, converter::undecorated_type_id_t type)
 {
     if (inst->ob_type->ob_type != &class_metatype_object)
         return 0;
diff --git a/test/destroy_test.cpp b/test/destroy_test.cpp
new file mode 100644
index 00000000..c6be42fc
--- /dev/null
+++ b/test/destroy_test.cpp
@@ -0,0 +1,81 @@
+#include <boost/python/detail/destroy.hpp>
+#include <cassert>
+
+struct bar;
+
+namespace boost
+{
+  // lie to the library about bar so we can show that it's destructor is optimized away.
+  template <>
+  struct has_trivial_destructor<bar>
+  {
+      BOOST_STATIC_CONSTANT(bool, value=true);
+  };
+}
+
+
+int count;
+int marks[] = {
+    -1
+    , -1, -1
+    , -1, -1, -1, -1
+    , -1
+};
+int* kills = marks;
+
+struct foo
+{
+    foo() : n(count++) {}
+    ~foo()
+    {
+        *kills++ = n;
+    }
+    int n;
+};
+
+struct bar : foo {};
+
+void assert_destructions(int n)
+{
+    for (int i = 0; i < n; ++i)
+        assert(marks[i] == i);
+    assert(marks[n] == -1);
+}
+
+int main()
+{
+    assert_destructions(0);
+    typedef int a[2];
+    
+    foo* f1 = new foo;
+    boost::python::detail::destroy_reference<foo const volatile&>(f1);
+    assert_destructions(1);
+    
+    foo* f2 = new foo[2];
+    typedef foo x[2];
+    
+    boost::python::detail::destroy_reference<x const&>(f2);
+    assert_destructions(3);
+
+    typedef foo y[2][2];
+    x* f3 = new y;
+    boost::python::detail::destroy_reference<y&>(f3);
+    assert_destructions(7);
+
+    bar* b1 = new bar;
+    boost::python::detail::destroy_reference<bar&>(b1);
+    assert_destructions(7);
+    
+    bar* b2 = new bar[2];
+    typedef bar xb[2];
+    
+    boost::python::detail::destroy_reference<xb&>(b2);
+    assert_destructions(7);
+
+    typedef bar yb[2][2];
+    xb* b3 = new yb;
+    boost::python::detail::destroy_reference<yb&>(b3);
+    assert_destructions(7);
+
+    return 0;
+}
diff --git a/test/indirect_traits_test.cpp b/test/indirect_traits_test.cpp
new file mode 100644
index 00000000..a15e7f85
--- /dev/null
+++ b/test/indirect_traits_test.cpp
@@ -0,0 +1,48 @@
+//#include <stdio.h>
+#include <cassert>
+#include <boost/python/detail/indirect_traits.hpp>
+
+//#define print(expr) printf("%s ==> %s\n", #expr, expr)
+
+int main()
+{
+using namespace boost::python::detail;
+
+    assert(is_reference_to_pointer<int*&>::value);
+    assert(is_reference_to_pointer<int* const&>::value);
+    assert(is_reference_to_pointer<int*volatile&>::value);
+    assert(is_reference_to_pointer<int*const volatile&>::value);
+    
+    assert(!is_reference_to_pointer<int const volatile>::value);
+    assert(!is_reference_to_pointer<int>::value);
+    assert(!is_reference_to_pointer<int*>::value);
+
+    assert(!is_reference_to_const<int*&>::value);
+    assert(is_reference_to_const<int* const&>::value);
+    assert(!is_reference_to_const<int*volatile&>::value);
+    assert(is_reference_to_const<int*const volatile&>::value);
+    
+    assert(!is_reference_to_const<int const volatile>::value);
+    assert(!is_reference_to_const<int>::value);
+    assert(!is_reference_to_const<int*>::value);
+
+    assert(is_reference_to_non_const<int*&>::value);
+    assert(!is_reference_to_non_const<int* const&>::value);
+    assert(is_reference_to_non_const<int*volatile&>::value);
+    assert(!is_reference_to_non_const<int*const volatile&>::value);
+    
+    assert(!is_reference_to_non_const<int const volatile>::value);
+    assert(!is_reference_to_non_const<int>::value);
+    assert(!is_reference_to_non_const<int*>::value);
+    
+    assert(!is_reference_to_volatile<int*&>::value);
+    assert(!is_reference_to_volatile<int* const&>::value);
+    assert(is_reference_to_volatile<int*volatile&>::value);
+    assert(is_reference_to_volatile<int*const volatile&>::value);
+    
+    assert(!is_reference_to_volatile<int const volatile>::value);
+    assert(!is_reference_to_volatile<int>::value);
+    assert(!is_reference_to_volatile<int*>::value);
+    
+    return 0;
+}
diff --git a/test/m1.cpp b/test/m1.cpp
index 723b471d..439d58e2 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -9,15 +9,13 @@
 #include "complicated.hpp"
 #include <boost/python/module.hpp>
 #include <boost/python/class.hpp>
+#include <boost/python/type_from_python.hpp>
 #include <boost/python/object/value_holder.hpp>
 #include <boost/python/object/pointer_holder.hpp>
 #include <boost/python/object/class.hpp>
 #include <boost/python/copy_const_reference.hpp>
 #include <boost/python/return_value_policy.hpp>
-#include <boost/python/converter/class.hpp>
-#include <boost/python/lvalue_from_python.hpp>
 #include <boost/python/to_python_converter.hpp>
-#include <boost/python/value_from_python.hpp>
 #include <boost/python/errors.hpp>
 #include <boost/mpl/type_list.hpp>
 #include <string.h>
@@ -105,7 +103,6 @@ PyObject* new_simple()
 // description of how the type parameters to wrapper<> and unwrapper<>
 // are selected.
 //
-using boost::python::converter::from_python_data;
 using boost::python::to_python_converter;
 
 // Wrap a simple by copying it into a Simple
@@ -120,16 +117,13 @@ struct simple_to_python
     }
 };
 
-int noddy_to_int(PyObject* p, from_python_data&)
+struct int_from_noddy_extractor
 {
-    return static_cast<NoddyObject*>(p)->x;
-}
-
-// Extract a mutable reference to an int from a Noddy.
-int& noddy_to_int_ref(PyObject* p, from_python_data&) 
-{
-    return static_cast<NoddyObject*>(p)->x;
-}
+    static int& execute(NoddyObject& p)
+    {
+        return p.x;
+    }
+};
 
 //
 // Some C++ functions to expose to Python
@@ -205,40 +199,23 @@ D take_d(D const& d) { return d; }
     
 BOOST_PYTHON_MODULE_INIT(m1)
 {
-    using boost::python::module;
-    using boost::python::class_;
-    using boost::python::converter::from_python_converter;
-    using boost::python::lvalue_from_python;
-    using boost::python::value_from_python;
-    using boost::python::type_from_python;
-    using boost::python::get_member;
-    using boost::python::copy_const_reference;
-    using boost::python::return_value_policy;
+    using namespace boost::python;
     using boost::mpl::type_list;
     
-    // Create the converters; they are self-registering/unregistering.
-    static simple_to_python c1;
+    simple_to_python();
 
-    static from_python_converter<int> c2(
-        &(boost::python::type_from_python<&NoddyType>::convertible), noddy_to_int);
-    
-    static from_python_converter<int&> c3(
-        &(boost::python::type_from_python<&NoddyType>::convertible), noddy_to_int_ref);
+    type_from_python<&NoddyType,int_from_noddy_extractor>();
 
-    static boost::python::lvalue_from_python<
+    boost::python::type_from_python<
         &SimpleType
-        , simple
-        , SimpleObject
 #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-        , boost::python::get_member<SimpleObject, simple, &SimpleObject::x>
+        , member_extractor<SimpleObject, simple, &SimpleObject::x>
 #else 
         , extract_simple_object
 #endif 
-        >
-        unwrap_simple;
+        >();
 
-    static boost::python::lvalue_from_python<&SimpleType, SimpleObject>
-        unwrap_simple2;
+    type_from_python<&SimpleType, identity_extractor<SimpleObject> >();
     
     module m1("m1");
 
diff --git a/test/pointer_type_id_test.cpp b/test/pointer_type_id_test.cpp
new file mode 100644
index 00000000..24035709
--- /dev/null
+++ b/test/pointer_type_id_test.cpp
@@ -0,0 +1,39 @@
+#include <boost/python/converter/type_id.hpp>
+#include <cassert>
+#include <boost/python/converter/pointer_type_id.hpp>
+
+int main()
+{
+    using namespace boost::python::converter;
+    
+    undecorated_type_id_t x
+        = undecorated_type_id<int>();
+    
+
+    assert(pointer_type_id<int*>() == x);
+    assert(pointer_type_id<int const*>() == x);
+    assert(pointer_type_id<int volatile*>() == x);
+    assert(pointer_type_id<int const volatile*>() == x);
+    
+    assert(pointer_type_id<int*&>() == x);
+    assert(pointer_type_id<int const*&>() == x);
+    assert(pointer_type_id<int volatile*&>() == x);
+    assert(pointer_type_id<int const volatile*&>() == x);
+    
+    assert(pointer_type_id<int*const&>() == x);
+    assert(pointer_type_id<int const*const&>() == x);
+    assert(pointer_type_id<int volatile*const&>() == x);
+    assert(pointer_type_id<int const volatile*const&>() == x);
+    
+    assert(pointer_type_id<int*volatile&>() == x);
+    assert(pointer_type_id<int const*volatile&>() == x);
+    assert(pointer_type_id<int volatile*volatile&>() == x);
+    assert(pointer_type_id<int const volatile*volatile&>() == x);
+    
+    assert(pointer_type_id<int*const volatile&>() == x);
+    assert(pointer_type_id<int const*const volatile&>() == x);
+    assert(pointer_type_id<int volatile*const volatile&>() == x);
+    assert(pointer_type_id<int const volatile*const volatile&>() == x);
+    
+    return 0;
+}

From 389968468698765dcfb1c9a20a98e3ea78150d98 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Feb 2002 05:28:48 +0000
Subject: [PATCH 305/369] inital checkin

[SVN r12925]
---
 test/select_from_python_test.cpp | 148 +++++++++++++++++++++++++++++++
 1 file changed, 148 insertions(+)
 create mode 100644 test/select_from_python_test.cpp

diff --git a/test/select_from_python_test.cpp b/test/select_from_python_test.cpp
new file mode 100644
index 00000000..7063767e
--- /dev/null
+++ b/test/select_from_python_test.cpp
@@ -0,0 +1,148 @@
+#include <boost/python/converter/from_python.hpp>
+//#include <cassert>
+//#include <boost/type_traits.hpp>
+#include <boost/python/converter/type_id.hpp>
+#include <iostream>
+
+int result;
+
+#define ASSERT_SAME(T1,T2) \
+       if (!is_same< T1, T2 >::value) { \
+             std::cout << "*********************\n"; \
+             std::cout << type_id< T1 >() << " != " << type_id< T2 >() << "\n"; \
+             std::cout << "*********************\n"; \
+             result = 1; \
+       }
+
+int main()
+{
+    using namespace boost::python::converter;
+    using namespace boost;
+
+
+    ASSERT_SAME(
+        select_from_python<int>::type, rvalue_from_python<int>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const>::type, rvalue_from_python<int const>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile>::type, rvalue_from_python<int volatile>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile>::type, rvalue_from_python<int const volatile>
+        );
+
+
+
+    ASSERT_SAME(
+        select_from_python<int*>::type, pointer_from_python<int*>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const*>::type, pointer_from_python<int const*>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile*>::type, pointer_from_python<int volatile*>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile*>::type, pointer_from_python<int const volatile*>
+        );
+
+
+
+
+    ASSERT_SAME(
+        select_from_python<int&>::type, reference_from_python<int&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const&>::type, rvalue_from_python<int const&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile&>::type, reference_from_python<int volatile&>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile&>::type, reference_from_python<int const volatile&>
+        );
+
+
+
+    ASSERT_SAME(
+        select_from_python<int*&>::type, reference_from_python<int*&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const*&>::type, reference_from_python<int const*&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile*&>::type, reference_from_python<int volatile*&>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile*&>::type, reference_from_python<int const volatile*&>
+        );
+
+
+
+    ASSERT_SAME(
+        select_from_python<int* const&>::type, pointer_const_reference_from_python<int*const&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const* const&>::type, pointer_const_reference_from_python<int const*const&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile* const&>::type, pointer_const_reference_from_python<int volatile*const&>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile* const&>::type, pointer_const_reference_from_python<int const volatile*const&>
+        );
+
+
+
+    ASSERT_SAME(
+        select_from_python<int*volatile&>::type, reference_from_python<int*volatile&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const*volatile&>::type, reference_from_python<int const*volatile&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile*volatile&>::type, reference_from_python<int volatile*volatile&>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile*volatile&>::type, reference_from_python<int const volatile*volatile&>
+        );
+
+
+
+    ASSERT_SAME(
+        select_from_python<int*const volatile&>::type, reference_from_python<int*const volatile&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int const*const volatile&>::type, reference_from_python<int const*const volatile&>
+        );
+    
+    ASSERT_SAME(
+        select_from_python<int volatile*const volatile&>::type, reference_from_python<int volatile*const volatile&>
+        );
+
+    ASSERT_SAME(
+        select_from_python<int const volatile*const volatile&>::type, reference_from_python<int const volatile*const volatile&>
+        );
+    return result;
+}

From e0147657977f5693a3af72f031ac84b4a3144d39 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Feb 2002 20:18:46 +0000
Subject: [PATCH 306/369] More use of ice_xxx for old EDG compilers

[SVN r12929]
---
 include/boost/python/detail/indirect_traits.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/indirect_traits.hpp b/include/boost/python/detail/indirect_traits.hpp
index 8c096a2f..f925eaee 100644
--- a/include/boost/python/detail/indirect_traits.hpp
+++ b/include/boost/python/detail/indirect_traits.hpp
@@ -31,7 +31,8 @@ struct is_reference_to_non_const
         bool, value = (
             ::boost::type_traits::ice_and<
             ::boost::is_reference<T>::value
-            , !::boost::python::detail::is_reference_to_const<T>::value
+            , ::boost::type_traits::ice_not<
+                ::boost::python::detail::is_reference_to_const<T>::value>::value
             >::value)
         );
 };

From f6381e7e5e6809062d209b960efe266ed2bd0af5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 25 Feb 2002 21:20:05 +0000
Subject: [PATCH 307/369] Added complex support, and support for user-defined
 conversions of classic instances

[SVN r12938]
---
 .../python/converter/builtin_converters.hpp   |  4 +
 src/converter/builtin_converters.cpp          | 97 ++++++++++++++++---
 test/test_builtin_converters.cpp              |  8 +-
 test/test_builtin_converters.py               | 36 +++++++
 4 files changed, 132 insertions(+), 13 deletions(-)

diff --git a/include/boost/python/converter/builtin_converters.hpp b/include/boost/python/converter/builtin_converters.hpp
index 8293b0a7..7ae7a357 100644
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -8,6 +8,7 @@
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/none.hpp>
 # include <string>
+# include <complex>
 
 namespace boost { namespace python {
 
@@ -58,6 +59,9 @@ BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x ? x : detail::none())
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, PyComplex_FromDoubles(x.real(), x.imag()))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, PyComplex_FromDoubles(x.real(), x.imag()))
 
 namespace converter
 { 
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 8db20586..2e9bcbec 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -10,8 +10,10 @@
 #include <boost/python/converter/from_python_data.hpp>
 #include <boost/python/converter/registry.hpp>
 #include <boost/python/reference.hpp>
+#include <boost/python/errors.hpp>
 #include <boost/cast.hpp>
 #include <string>
+#include <complex>
 
 namespace boost { namespace python { namespace converter {
 
@@ -73,15 +75,18 @@ namespace
 
           // For floating types, return the float conversion slot to avoid
           // creating a new object. We'll handle that below
-          if (PyObject_TypeCheck(obj, &PyFloat_Type) && number_methods->nb_float)
+          if (PyFloat_Check(obj))
               return &number_methods->nb_float;
-      
+
+          if (PyInstance_Check(obj) && !PyObject_HasAttrString(obj, "__int__"))
+              return 0;
+          
           return &number_methods->nb_int;
       }
       
       static long extract(PyObject* intermediate)
       {
-          if (PyObject_TypeCheck(intermediate, &PyFloat_Type))
+          if (PyFloat_Check(intermediate))
           {
               return numeric_cast<long>(PyFloat_AS_DOUBLE(intermediate));
           }
@@ -93,22 +98,23 @@ namespace
   };
 
 
-  // identity_unaryfunc/non_null -- manufacture a unaryfunc "slot"
-  // which just returns its argument. Used for bool conversions, since
-  // all Python objects are directly convertible to bool
+  // identity_unaryfunc/py_object_identity -- manufacture a unaryfunc
+  // "slot" which just returns its argument. Used for bool
+  // conversions, since all Python objects are directly convertible to
+  // bool
   extern "C" PyObject* identity_unaryfunc(PyObject* x)
   {
       Py_INCREF(x);
       return x;
   }
-  unaryfunc non_null = identity_unaryfunc;
+  unaryfunc py_object_identity = identity_unaryfunc;
 
   // A SlotPolicy for extracting bool from a Python object
   struct bool_rvalue_from_python
   {
       static unaryfunc* get_slot(PyObject*)
       {
-          return &non_null;
+          return &py_object_identity;
       }
       
       static bool extract(PyObject* intermediate)
@@ -127,17 +133,19 @@ namespace
               return 0;
 
           // For integer types, return the tp_int conversion slot to avoid
-          // creating a new object. We'll handle that in
-          // py_float_or_int_as_double, below
-          if (PyObject_TypeCheck(obj, &PyInt_Type) && number_methods->nb_int)
+          // creating a new object. We'll handle that below
+          if (PyInt_Check(obj))
               return &number_methods->nb_int;
       
+          if (PyInstance_Check(obj) && !PyObject_HasAttrString(obj, "__float__"))
+              return 0;
+          
           return &number_methods->nb_float;
       }
       
       static double extract(PyObject* intermediate)
       {
-          if (PyObject_TypeCheck(intermediate, &PyInt_Type))
+          if (PyInt_Check(intermediate))
           {
               return PyInt_AS_LONG(intermediate);
           }
@@ -154,6 +162,9 @@ namespace
       // If the underlying object is "string-able" this will succeed
       static unaryfunc* get_slot(PyObject* obj)
       {
+          if (PyInstance_Check(obj) && !PyObject_HasAttrString(obj, "__str__"))
+              return 0;
+          
           return &obj->ob_type->tp_str;
       };
 
@@ -163,6 +174,64 @@ namespace
           return PyString_AsString(intermediate);
       }
   };
+
+
+  // identity_unaryfunc/non_null -- manufacture a unaryfunc "slot"
+  // which just returns its argument. Used for bool conversions, since
+  // all Python objects are directly convertible to bool
+  extern "C" PyObject* to_complex_unaryfunc(PyObject* x)
+  {
+      return PyObject_CallMethod(x, "__complex__", const_cast<char*>("()"));
+  }
+  unaryfunc py_object_to_complex = to_complex_unaryfunc;
+
+  struct complex_rvalue_from_python
+  {
+      static unaryfunc* get_slot(PyObject* obj)
+      {
+
+          if (PyComplex_Check(obj))
+              return &py_object_identity;
+
+          PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
+          
+          // For integer types, return the tp_int conversion slot to avoid
+          // creating a new object. We'll handle that below
+          if (PyInt_Check(obj) && number_methods)
+              return &number_methods->nb_int;
+      
+          if (PyFloat_Check(obj) && number_methods)
+              return &number_methods->nb_float;
+      
+          if (!PyObject_HasAttrString((PyObject*)obj, "__complex__"))
+              return 0;
+          
+          return &py_object_to_complex;
+      }
+      
+      static std::complex<double> extract(PyObject* intermediate)
+      {
+          if (PyComplex_Check(intermediate))
+          {
+              return std::complex<double>(
+                  PyComplex_RealAsDouble(intermediate)
+                  , PyComplex_ImagAsDouble(intermediate));
+          }
+          else if (PyInt_Check(intermediate))
+          {
+              return PyInt_AS_LONG(intermediate);
+          }
+          else if (PyFloat_Check(intermediate))
+          {
+              return PyFloat_AS_DOUBLE(intermediate);
+          }
+          else
+          {
+              PyErr_SetString(PyExc_TypeError, "__complex__ method did not return a Complex object");
+              throw error_already_set();
+          }
+      }
+  };
 } 
 
 #define REGISTER_INT_CONVERTERS(U) slot_rvalue_from_python<U,int_rvalue_from_python>()
@@ -184,6 +253,10 @@ void initialize_builtin_converters()
     slot_rvalue_from_python<double,float_rvalue_from_python>();
     slot_rvalue_from_python<long double,float_rvalue_from_python>();
     
+    slot_rvalue_from_python<std::complex<float>,complex_rvalue_from_python>();
+    slot_rvalue_from_python<std::complex<double>,complex_rvalue_from_python>();
+    slot_rvalue_from_python<std::complex<long double>,complex_rvalue_from_python>();
+    
     // Add an lvalue converter for char which gets us char const*
     registry::insert(convert_to_cstring,undecorated_type_id<char>());
 
diff --git a/test/test_builtin_converters.cpp b/test/test_builtin_converters.cpp
index f95ebe2b..4c07d9f4 100644
--- a/test/test_builtin_converters.cpp
+++ b/test/test_builtin_converters.cpp
@@ -5,7 +5,7 @@
 // to its suitability for any purpose.
 #include <string>
 #include <boost/python/module.hpp>
-
+#include <complex>
 
 template <class T>
 struct by_value
@@ -41,6 +41,9 @@ BOOST_PYTHON_MODULE_INIT(builtin_converters_ext)
         .def("rewrap_value_float", by_value<float>::rewrap)
         .def("rewrap_value_double", by_value<double>::rewrap)
         .def("rewrap_value_long_double", by_value<long double>::rewrap)
+        .def("rewrap_value_complex_float", by_value<std::complex<float> >::rewrap)
+        .def("rewrap_value_complex_double", by_value<std::complex<double> >::rewrap)
+        .def("rewrap_value_complex_long_double", by_value<std::complex<long double> >::rewrap)
         .def("rewrap_value_string", by_value<std::string>::rewrap)
         .def("rewrap_value_cstring", by_value<char const*>::rewrap)
 
@@ -57,6 +60,9 @@ BOOST_PYTHON_MODULE_INIT(builtin_converters_ext)
         .def("rewrap_const_reference_float", by_const_reference<float>::rewrap)
         .def("rewrap_const_reference_double", by_const_reference<double>::rewrap)
         .def("rewrap_const_reference_long_double", by_const_reference<long double>::rewrap)
+        .def("rewrap_const_reference_complex_float", by_const_reference<std::complex<float> >::rewrap)
+        .def("rewrap_const_reference_complex_double", by_const_reference<std::complex<double> >::rewrap)
+        .def("rewrap_const_reference_complex_long_double", by_const_reference<std::complex<long double> >::rewrap)
         .def("rewrap_const_reference_string", by_const_reference<std::string>::rewrap)
         .def("rewrap_const_reference_cstring", by_const_reference<char const*>::rewrap)
         
diff --git a/test/test_builtin_converters.py b/test/test_builtin_converters.py
index 50b58ce6..3a4722c7 100644
--- a/test/test_builtin_converters.py
+++ b/test/test_builtin_converters.py
@@ -30,6 +30,13 @@
 >>> rewrap_value_long_double(4.2) - 4.2
 0.0
 
+>>> abs(rewrap_value_complex_float(4+.2j) - (4+.2j)) < .000001
+1
+>>> abs(rewrap_value_complex_double(4+.2j) - (4+.2j)) < .000001
+1
+>>> abs(rewrap_value_complex_long_double(4+.2j) - (4+.2j)) < .000001
+1
+
 >>> rewrap_value_cstring('hello, world')
 'hello, world'
 >>> rewrap_value_string('yo, wassup?')
@@ -57,6 +64,7 @@
 42
 >>> rewrap_const_reference_unsigned_long(42)
 42
+
 >>> abs(rewrap_const_reference_float(4.2) - 4.2) < .000001
 1
 >>> rewrap_const_reference_double(4.2) - 4.2
@@ -64,6 +72,13 @@
 >>> rewrap_const_reference_long_double(4.2) - 4.2
 0.0
 
+>>> abs(rewrap_const_reference_complex_float(4+.2j) - (4+.2j)) < .000001
+1
+>>> abs(rewrap_const_reference_complex_double(4+.2j) - (4+.2j)) < .000001
+1
+>>> abs(rewrap_const_reference_complex_long_double(4+.2j) - (4+.2j)) < .000001
+1
+
 >>> rewrap_const_reference_cstring('hello, world')
 'hello, world'
 >>> rewrap_const_reference_string('yo, wassup?')
@@ -83,6 +98,27 @@ Now check implicit conversions between floating/integer types
 >>> rewrap_value_int(42.0)
 42
 
+Check that classic classes also work
+
+>>> class FortyTwo:
+...     def __int__(self):
+...         return 42
+...     def __float__(self):
+...         return 42.0
+...     def __complex__(self):
+...         return complex(4+.2j)
+...     def __str__(self):
+...         return '42'
+
+>>> rewrap_const_reference_float(FortyTwo())
+42.0
+>>> rewrap_value_int(FortyTwo())
+42
+>>> rewrap_const_reference_string(FortyTwo())
+'42'
+>>> abs(rewrap_value_complex_double(FortyTwo()) - (4+.2j)) < .000001
+1
+
 """
 def run(args = None):
     import sys

From a16ff296389a88375cc908186aa679eb13fc403f Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 27 Feb 2002 17:29:01 +0000
Subject: [PATCH 308/369] Fixed generation

[SVN r12957]
---
 include/boost/python/detail/returning.hpp | 1339 ++++++++++++---------
 src/gen_returning.py                      |   60 +-
 2 files changed, 777 insertions(+), 622 deletions(-)

diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index 599e5d37..d7e98cd8 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -1,5 +1,5 @@
-//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
+//  (C) Copyright David Abrahams 2001,2002. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
@@ -23,10 +23,10 @@ template <class R>
 struct returning
 {
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
@@ -34,20 +34,20 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                ) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
 
         // find the result converter
@@ -55,22 +55,22 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
 
         // find the result converter
@@ -78,24 +78,25 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
 
         // find the result converter
@@ -103,26 +104,28 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
 
         // find the result converter
@@ -130,28 +133,31 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
 
         // find the result converter
@@ -159,19 +165,23 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
 
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)() const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
@@ -179,20 +189,20 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                ) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
 
         // find the result converter
@@ -200,22 +210,22 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
 
         // find the result converter
@@ -223,24 +233,25 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
 
         // find the result converter
@@ -248,26 +259,28 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
 
         // find the result converter
@@ -275,28 +288,31 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
 
         // find the result converter
@@ -304,19 +320,23 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
 
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
@@ -324,20 +344,20 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                ) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
 
         // find the result converter
@@ -345,22 +365,22 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
 
         // find the result converter
@@ -368,24 +388,25 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
 
         // find the result converter
@@ -393,26 +414,28 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
 
         // find the result converter
@@ -420,28 +443,31 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
 
         // find the result converter
@@ -449,22 +475,26 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
 
 
 // missing const volatile type traits
 #  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
@@ -472,20 +502,20 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                ) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)() );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
 
         // find the result converter
@@ -493,22 +523,22 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
 
         // find the result converter
@@ -516,24 +546,25 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
 
         // find the result converter
@@ -541,26 +572,28 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
 
         // find the result converter
@@ -568,28 +601,31 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
 
         // find the result converter
@@ -597,176 +633,193 @@ struct returning
         typename eval<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
+
+        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5))) );
         
-        PyObject* result = cr( ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        return policies.postcall(args_, result);
     }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-  
+            
     template <class P>
-    static PyObject* call(R (*pf)(), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(), PyObject* args_, PyObject*, P const& policies)
     {
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c0;
-        if (!c0.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c0( (*pf)() );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                ) );
+                
+        return policies.postcall(args_, result);
     }
-  
     template <class P, class A0>
-    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c1;
-        if (!c1.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c1( (*pf)(c0(PyTuple_GET_ITEM(args, 0))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))) );
+                
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c2;
-        if (!c2.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c2( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))) );
+                
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c3;
-        if (!c3.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c3( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))) );
+                
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c4;
-        if (!c4.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c4( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))) );
+                
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c5;
-        if (!c5.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c5( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))) );
+                
+        return policies.postcall(args_, result);
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type c6;
-        if (!c6.convertible()) return 0;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
         
-        if (!policies.precall(args)) return 0;
+        if (!policies.precall(args_)) return 0;
         
-        PyObject* result = c6( (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5))) );
-        
-        if (!result) return 0;
-        return policies.postcall(args, result);
+        PyObject* result = cr( (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5))) );
+                
+        return policies.postcall(args_, result);
     }
 };
                            
@@ -775,560 +828,646 @@ struct returning<void>
 {
     typedef void R;
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)(), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                );
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
 
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)() const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)() const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                );
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
 
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)() volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                );
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
 
 
 // missing const volatile type traits
 #  ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     template <class P, class A0>
-    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)() const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                );
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)();
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (A0::*pmf)(A1, A2, A3, A4, A5) const volatile, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0 const volatile&> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0 const volatile*> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
+
+        ((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5)));
         
-        if (!policies.precall(args)) return 0;
-        
-        ((c0(PyTuple_GET_ITEM(args, 0))).*pmf)(c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        
-        return policies.postcall(args, detail::none());
+        return policies.postcall(args_, detail::none());
     }
 
 #  endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
+            
     template <class P>
-    static PyObject* call(R (*pf)(), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(), PyObject* args_, PyObject*, P const& policies)
     {
-        (*pf)();
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                );
+                
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0>
-    static PyObject* call(R (*pf)(A0), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
         
-        if (!policies.precall(args)) return 0;
-        
-        (*pf)(c0(PyTuple_GET_ITEM(args, 0)));
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0)));
+                
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1>
-    static PyObject* call(R (*pf)(A0, A1), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
         
-        if (!policies.precall(args)) return 0;
-        
-        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)));
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1)));
+                
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2>
-    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
         
-        if (!policies.precall(args)) return 0;
-        
-        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)));
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2)));
+                
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2, A3), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
         
-        if (!policies.precall(args)) return 0;
-        
-        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)));
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3)));
+                
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
         
-        if (!policies.precall(args)) return 0;
-        
-        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)));
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4)));
+                
+        return policies.postcall(args_, detail::none());
     }
     template <class P, class A0, class A1, class A2, class A3, class A4, class A5>
-    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args, PyObject*, P const& policies)
+    static PyObject* call(R (*pf)(A0, A1, A2, A3, A4, A5), PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        from_python<A0> c0(PyTuple_GET_ITEM(args, 0));
+        from_python<A0> c0(PyTuple_GET_ITEM(args_, 0));
         if (!c0.convertible()) return 0;
-        from_python<A1> c1(PyTuple_GET_ITEM(args, 1));
+        from_python<A1> c1(PyTuple_GET_ITEM(args_, 1));
         if (!c1.convertible()) return 0;
-        from_python<A2> c2(PyTuple_GET_ITEM(args, 2));
+        from_python<A2> c2(PyTuple_GET_ITEM(args_, 2));
         if (!c2.convertible()) return 0;
-        from_python<A3> c3(PyTuple_GET_ITEM(args, 3));
+        from_python<A3> c3(PyTuple_GET_ITEM(args_, 3));
         if (!c3.convertible()) return 0;
-        from_python<A4> c4(PyTuple_GET_ITEM(args, 4));
+        from_python<A4> c4(PyTuple_GET_ITEM(args_, 4));
         if (!c4.convertible()) return 0;
-        from_python<A5> c5(PyTuple_GET_ITEM(args, 5));
+        from_python<A5> c5(PyTuple_GET_ITEM(args_, 5));
         if (!c5.convertible()) return 0;
+
+        if (!policies.precall(args_)) return 0;
         
-        if (!policies.precall(args)) return 0;
-        
-        (*pf)(c0(PyTuple_GET_ITEM(args, 0)), c1(PyTuple_GET_ITEM(args, 1)), c2(PyTuple_GET_ITEM(args, 2)), c3(PyTuple_GET_ITEM(args, 3)), c4(PyTuple_GET_ITEM(args, 4)), c5(PyTuple_GET_ITEM(args, 5)));
-        
-        return policies.postcall(args, detail::none());
+        (*pf)(
+                c0(PyTuple_GET_ITEM(args_, 0))
+                , c1(PyTuple_GET_ITEM(args_, 1))
+                , c2(PyTuple_GET_ITEM(args_, 2))
+                , c3(PyTuple_GET_ITEM(args_, 3))
+                , c4(PyTuple_GET_ITEM(args_, 4))
+                , c5(PyTuple_GET_ITEM(args_, 5)));
+                
+        return policies.postcall(args_, detail::none());
     }
 };
 
diff --git a/src/gen_returning.py b/src/gen_returning.py
index 80e3342b..8f7c866c 100644
--- a/src/gen_returning.py
+++ b/src/gen_returning.py
@@ -1,4 +1,4 @@
-#  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
+#  (C) Copyright David Abrahams 2001,2002. Permission to copy, use, modify, sell and
 #  distribute this software is granted provided this copyright notice appears
 #  in all copies. This software is provided "as is" without express or implied
 #  warranty, and with no claim as to its suitability for any purpose.
@@ -8,8 +8,8 @@
 from gen_function import *
 import string
 
-header = '''//  (C) Copyright David Abrahams 2001. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
+header = '''//  (C) Copyright David Abrahams 2001,2002. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright notice appears
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
@@ -24,11 +24,10 @@ body_sections = (
 #ifndef RETURNING_DWA20011201_HPP
 # define RETURNING_DWA20011201_HPP
 
-//# include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/config.hpp>
-# include <boost/python/convert.hpp>
 # include <boost/python/detail/none.hpp>
+# include <boost/python/from_python.hpp>
 
 namespace boost { namespace python { namespace detail {
 
@@ -62,32 +61,49 @@ struct returning<void>
 
 #'
 
-member_function = '''    template <class A0%(, class A%+%)>
-    static PyObject* call(R (A0::*pmf)(%(A%+%:, %))%1, PyObject* args, PyObject* /* keywords */ )
+member_function = '''    template <class P, class A0%(, class A%+%)>
+    static PyObject* call(R (A0::*pmf)(%(A%+%:, %))%1, PyObject* args_, PyObject*, P const& policies)
     {
         // check that each of the arguments is convertible
-        unwrap<A0%1&> c0(PyTuple_GET_ITEM(args, 0));
-%(        unwrap_more<A%+> c%+(PyTuple_GET_ITEM(args, %+), c%n);
+        from_python<A0%1*> c0(PyTuple_GET_ITEM(args_, 0));
+        if (!c0.convertible()) return 0;
+%(        from_python<A%+> c%+(PyTuple_GET_ITEM(args_, %+));
+        if (!c%+.convertible()) return 0;
 %)
 %[r%:        // find the result converter
-        wrap_more<R> r(c%n);
-%]        if (!c0) return 0;
-        %[r%:return r( %]((*c0).*pmf)(%(*c%+%:, %))%[r%: )%];%[v%:
-        return detail::none();%]
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+%]        if (!policies.precall(args_)) return 0;
+
+        %[r%:PyObject* result = cr( %]((c0(PyTuple_GET_ITEM(args_, 0)))->*pmf)(
+                %(c%+(PyTuple_GET_ITEM(args_, %+))%:
+                , %))%[r%: )%];
+        
+        return policies.postcall(args_, %[r%:result%]%[v%:detail::none()%]);
     }
 ''' 
         
-free_function = '''%{    template <%(class A%n%:, %)>
-%}    static PyObject* call(R (*pf)(%(A%n%:, %)), PyObject*%{ args%}, PyObject* /* keywords */ )
+free_function = '''    template <class P%(, class A%n%%)>
+    static PyObject* call(R (*pf)(%(A%n%:, %)), PyObject* args_, PyObject*, P const& policies)
     {%{
         // check that each of the arguments is convertible
-%}%(        unwrap%{_more%}<A%n> c%n(PyTuple_GET_ITEM(args, %n)%{, c%-%});
-%)%[r%:
-        // find the result converter
-        wrap%{_more%}<R> c%n%{(c%-)%};%]%[not-void-and-0-arg%:
-        if (!c0) return 0;%]
-        %[r%:return c%n( %](*pf)(%(*c%n%:, %))%[r%: )%];%[v%:
-        return detail::none();%]
+%}%(        from_python<A%n> c%n(PyTuple_GET_ITEM(args_, %n));
+        if (!c%n.convertible()) return 0;
+%)
+%[r%:        // find the result converter
+        typedef typename P::result_converter result_converter;
+        typename eval<result_converter,R>::type cr;
+        if (!cr.convertible()) return 0;
+        
+%]%[not-void-and-0-arg%:        if (!policies.precall(args_)) return 0;
+        
+%]        %[r%:PyObject* result = cr( %](*pf)(
+                %(c%n(PyTuple_GET_ITEM(args_, %n))%:
+                , %))%[r%: )%];
+                
+        return policies.postcall(args_, %[r%:result%]%[v%:detail::none()%]);
     }
 ''' 
 

From 8a956bcdf63cfc329732e0bc67609e0149d88f87 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 27 Feb 2002 21:12:52 +0000
Subject: [PATCH 309/369] missing typename fix

[SVN r12960]
---
 include/boost/python/converter/from_python.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index 0881a06a..4fe240ce 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -40,7 +40,7 @@ struct pointer_const_reference_from_python
     bool convertible() const;
     
  private:
-    detail::referent_storage<T>::type m_result;
+    typename detail::referent_storage<T>::type m_result;
     
     static lvalue_from_python_registration*& chain;
 };

From 0ef39e4440113748831aebd103c5e63f2c86e095 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 27 Feb 2002 21:13:02 +0000
Subject: [PATCH 310/369] improvements for EDG

[SVN r12961]
---
 .../python/converter/from_python_data.hpp     | 36 ++++++++++++++-----
 1 file changed, 27 insertions(+), 9 deletions(-)

diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index 57a3d76e..d88eb90e 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -19,6 +19,8 @@
 #  include <boost/mpl/type_list.hpp>
 #  include <boost/mpl/for_each.hpp>
 #  include <boost/type_traits/composite_traits.hpp>
+# else
+#  include <boost/type_traits/cv_traits.hpp>
 # endif 
 
 namespace boost { namespace python { namespace converter { 
@@ -105,24 +107,23 @@ namespace detail
               bool, choose_t2 = (
                   aligned2 && (
                       is_same<T1,unknown_alignment>::value
-                      | (align2 < alignment_of<T1>::value)
+                      | (align2 < align1)
                       | (sizeof(T2) < sizeof(T1)))
                   ));
           
-          typedef mpl::select_type<choose_t2, T2, T1>::type type;
+          typedef typename mpl::select_type<choose_t2, T2, T1>::type type;
       };
   };
 
   typedef mpl::type_list<
-      char,short,int,long,float,double,long double
+      char,short,int,long, float,double,long double
       ,void*
       ,void(*)()
       ,void (alignment_dummy::*)()
       , char (alignment_dummy::*)
-  >
+  >::type
   align_types;
-#endif // EDG is too slow
-  
+#endif // EDG is too slow  
   template <class Align, std::size_t size>
   union aligned_storage
   {
@@ -148,10 +149,27 @@ namespace detail
     
       typedef typename loop::state align_t;
 #else
+      typedef typename remove_cv<typename remove_reference<Reference>::type>::type referent;
+      
       // The Python source makes the assumption that double has
-      // maximal alignment anyway
-      typedef double align_t;
-    
+      // maximal alignment, but that fails on some platforms
+      BOOST_STATIC_CONSTANT(
+          std::size_t, target_align = alignment_of<referent>::value);
+
+      // Here we make some assumptions and leave out some possible
+      // types worth checking, but this should work most of the time.
+      typedef typename mpl::select_type<
+          is_POD<referent>::value
+          , referent
+          , typename mpl::select_type< 
+              alignment_of<long>::value >= target_align
+              , long
+              , typename mpl::select_type<
+                  alignment_of<double>::value >= target_align
+                  , double
+                  , long double>::type
+          >::type
+      >::type align_t;
 #endif
       BOOST_STATIC_CONSTANT(std::size_t, alignment1 = alignment_of<align_t>::value);
       BOOST_STATIC_CONSTANT(std::size_t, alignment2 = referent_alignment<Reference>::value);

From bbc49e1ba3ecc87f644483c480e4f382f522e6e1 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 27 Feb 2002 21:13:34 +0000
Subject: [PATCH 311/369] go with debug build by default

[SVN r12962]
---
 Jamfile | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/Jamfile b/Jamfile
index 79dfd9e5..9bf18e2e 100644
--- a/Jamfile
+++ b/Jamfile
@@ -14,7 +14,13 @@ include <module@>python.jam ;
           <define>BOOST_PYTHON_V2
           ;
     
-    local PYTHON_PROPERTIES = $(BOOST_PYTHON_V2_PROPERTIES) ;
+    local gcc-release-properties
+      = <optimization>speed <cxxflags>-fomit-frame-pointer
+      <inlining>on <cxxflags>-foptimize-sibling-calls
+      ;
+    
+    local PYTHON_PROPERTIES = $(BOOST_PYTHON_V2_PROPERTIES) <gcc><release>$(gcc-release-properties)
+;
     
     dll bpl
       : 
@@ -37,39 +43,39 @@ include <module@>python.jam ;
     # -------- general test -------
     extension m1 : test/m1.cpp <dll>bpl
       : 
-      : debug-python
+      : 
       ;
 
     extension m2 : test/m2.cpp <dll>bpl
       : 
-      : debug-python ;
+      :  ;
 
-    boost-python-runtest try : test/newtest.py <pyd>m1 <pyd>m2 : : debug-python ;
+    boost-python-runtest try : test/newtest.py <pyd>m1 <pyd>m2 : :  ;
 
     # ----------- builtin converters -----------
     
     extension builtin_converters_ext : test/test_builtin_converters.cpp <dll>bpl
       :
-      : debug-python
+      : 
       ;
 
     boost-python-runtest test_builtin_converters : test/test_builtin_converters.py
       <pyd>builtin_converters_ext
       :
-      : debug-python
+      : 
       ;
     
     # ----------- pointer adoption -----------
     
     extension test_pointer_adoption_ext : test/test_pointer_adoption.cpp <dll>bpl
       :
-      : debug-python
+      : 
       ;
 
     boost-python-runtest test_pointer_adoption : test/test_pointer_adoption.py
       <pyd>test_pointer_adoption_ext
       :
-      : debug-python
+      : 
       ;
     
 }

From 493ff9c6850aab69ad9b250fec9f24d007c361ed Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 27 Feb 2002 23:18:08 +0000
Subject: [PATCH 312/369] Intel 5 compatibility

[SVN r12963]
---
 include/boost/python/to_python_indirect.hpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/to_python_indirect.hpp b/include/boost/python/to_python_indirect.hpp
index 306b3246..7b77f5ff 100644
--- a/include/boost/python/to_python_indirect.hpp
+++ b/include/boost/python/to_python_indirect.hpp
@@ -10,6 +10,7 @@
 # include <boost/python/object/pointer_holder.hpp>
 # include <boost/python/object/class_object.hpp>
 # include <boost/python/detail/unwind_type.hpp>
+# include <boost/shared_ptr.hpp>
 # include <memory>
 
 namespace boost { namespace python {
@@ -34,8 +35,15 @@ namespace detail
       template <class T>
       static result_type execute(T* p)
       {
-          return new objects::pointer_holder<std::auto_ptr<T>, T>(
-              std::auto_ptr<T>(p));
+          // can't use auto_ptr with Intel 5 for some reason
+# if defined(__ICL) && __ICL < 600 
+          typedef boost::shared_ptr<T> smart_pointer;
+# else 
+          typedef std::auto_ptr<T> smart_pointer;
+# endif 
+          
+          return new objects::pointer_holder<smart_pointer, T>(
+              smart_pointer(p));
       }
   };
 

From ee26e13beab1f3ac9277241fbf6d5e8a70e3a6c5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 00:05:00 +0000
Subject: [PATCH 313/369] Added missing PyObject*const& converter

[SVN r12966]
---
 include/boost/python/from_python.hpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/include/boost/python/from_python.hpp b/include/boost/python/from_python.hpp
index 62b340f1..8c3f94bb 100644
--- a/include/boost/python/from_python.hpp
+++ b/include/boost/python/from_python.hpp
@@ -27,6 +27,14 @@ struct from_python<PyObject*>
     PyObject* operator()(PyObject* source) const { return source; }
 };
 
+template <>
+struct from_python<PyObject* const&>
+{
+    from_python(PyObject*) {}
+    bool convertible() const { return true; }
+    PyObject*const& operator()(PyObject*const& source) const { return source; }
+};
+
 //
 // implementations
 //

From ccb7a8f94feb0713b6b2a19bf29d50b8126b99fd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 00:18:07 +0000
Subject: [PATCH 314/369] Make cxx 6.5 bugs happy

[SVN r12967]
---
 src/converter/from_python.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/converter/from_python.cpp b/src/converter/from_python.cpp
index 0650fcbb..57aee355 100644
--- a/src/converter/from_python.cpp
+++ b/src/converter/from_python.cpp
@@ -28,7 +28,7 @@ BOOST_PYTHON_DECL void* find(
 }
 
 BOOST_PYTHON_DECL void* find(
-    PyObject* const source
+    PyObject* source
     , lvalue_from_python_registration const* chain)
 {
     for (;chain != 0; chain = chain->next)

From 412a00249f24e2b0017a88d49559c31ee7cc2a8c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 00:24:06 +0000
Subject: [PATCH 315/369] Move module_base to detail, avoiding recompilation
 dependencies

[SVN r12970]
---
 include/boost/python/detail/module_base.hpp | 44 +++++++++++++++++++++
 include/boost/python/module.hpp             | 31 +--------------
 include/boost/python/object/class.hpp       |  1 -
 src/module.cpp                              |  7 ++--
 src/object/class.cpp                        |  3 +-
 5 files changed, 51 insertions(+), 35 deletions(-)
 create mode 100644 include/boost/python/detail/module_base.hpp

diff --git a/include/boost/python/detail/module_base.hpp b/include/boost/python/detail/module_base.hpp
new file mode 100644
index 00000000..e8a00ba6
--- /dev/null
+++ b/include/boost/python/detail/module_base.hpp
@@ -0,0 +1,44 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MODULE_BASE_DWA2002227_HPP
+# define MODULE_BASE_DWA2002227_HPP
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/reference.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+class BOOST_PYTHON_DECL module_base
+{
+ public:
+    // Create a module. REQUIRES: only one module is created per module.
+    module_base(const char* name);
+    ~module_base();
+
+    // Add elements to the module
+    void setattr(const char* name, PyObject*);
+    void setattr(const char* name, ref const&);
+    void add(PyTypeObject* x); // just use the type's name
+    void add_type(ref);
+    
+    // Return a reference to the Python module object being built
+    inline ref object() const;
+
+ private:
+    ref m_module;
+    static PyMethodDef initial_methods[1];
+};
+
+//
+// inline implementations
+//
+inline ref module_base::object() const
+{
+    return m_module;
+}
+
+}}} // namespace boost::python::detail
+
+#endif // MODULE_BASE_DWA2002227_HPP
diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp
index 11b0b6c7..7df183d5 100644
--- a/include/boost/python/module.hpp
+++ b/include/boost/python/module.hpp
@@ -8,36 +8,14 @@
 
 # include <boost/python/errors.hpp>
 # include <boost/python/detail/config.hpp>
-# include <boost/python/reference.hpp>
 # include <boost/python/make_function.hpp>
 # include <boost/python/objects.hpp>
-# include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/class_fwd.hpp>
+# include <boost/python/detail/module_base.hpp>
 
 namespace boost { namespace python {
 
-class BOOST_PYTHON_DECL module_base
-{
- public:
-    // Create a module. REQUIRES: only one module is created per module.
-    module_base(const char* name);
-    ~module_base();
-
-    // Add elements to the module
-    void setattr(const char* name, PyObject*);
-    void setattr(const char* name, ref const&);
-    void add(PyTypeObject* x); // just use the type's name
-    void add_type(ref);
-    
-    // Return a reference to the Python module object being built
-    ref object() const;
-
- private:
-    ref m_module;
-    static PyMethodDef initial_methods[1];
-};
-
-class module : public module_base
+class module : public detail::module_base
 {
  public:
     module(const char* name)
@@ -76,11 +54,6 @@ class module : public module_base
 //
 // inline implementations
 //
-inline ref module_base::object() const
-{
-    return m_module;
-}
-
 inline module& module::setattr(const char* name, PyObject* x)
 {
     this->module_base::setattr(name, x);
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 04f0e992..0d5210c7 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -6,7 +6,6 @@
 #ifndef CLASS_DWA20011214_HPP
 # define CLASS_DWA20011214_HPP
 
-# include <boost/python/module.hpp>
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/config.hpp>
 # include <boost/utility.hpp>
diff --git a/src/module.cpp b/src/module.cpp
index dbc81729..0291c9c1 100644
--- a/src/module.cpp
+++ b/src/module.cpp
@@ -6,9 +6,10 @@
 //  The author gratefully acknowleges the support of Dragon Systems, Inc., in
 //  producing this work.
 
-#include <boost/python/module.hpp>
+#include <boost/python/detail/module_base.hpp>
+#include <boost/python/object/function.hpp>
 
-namespace boost { namespace python {
+namespace boost { namespace python { namespace detail {
 
 module_base::module_base(const char* name)
     : m_module(
@@ -46,4 +47,4 @@ void module_base::add_type(ref x)
 
 PyMethodDef module_base::initial_methods[] = { { 0, 0, 0, 0 } };
 
-}} // namespace boost::python
+}}} // namespace boost::python::detail
diff --git a/src/object/class.cpp b/src/object/class.cpp
index 8186f9be..b9deb98f 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -3,8 +3,7 @@
 // copyright notice appears in all copies. This software is provided
 // "as is" without express or implied warranty, and with no claim as
 // to its suitability for any purpose.
-#include <boost/python/detail/config.hpp>
-#include <boost/python/detail/wrap_python.hpp>
+#include <boost/python/converter/registry.hpp>
 #include <boost/python/object/class.hpp>
 #include <boost/python/objects.hpp>
 #include <boost/python/detail/map_entry.hpp>

From db9fb22cf445a226c503f139496a8c6bffcb4921 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 00:24:52 +0000
Subject: [PATCH 316/369] Tests for NULL == None

[SVN r12971]
---
 test/test_builtin_converters.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/test_builtin_converters.py b/test/test_builtin_converters.py
index 3a4722c7..50d436e5 100644
--- a/test/test_builtin_converters.py
+++ b/test/test_builtin_converters.py
@@ -84,6 +84,17 @@
 >>> rewrap_const_reference_string('yo, wassup?')
 'yo, wassup?'
 
+
+Check that None <==> NULL
+
+>>> rewrap_const_reference_cstring(None)
+
+But when converted to a string rvalue, None becomes 'None':
+
+>>> rewrap_const_reference_string(None)
+'None'
+
+
 Now check implicit conversions between floating/integer types
 
 >>> rewrap_const_reference_float(42)

From a2dec7a05dd8f92591e12a7cf0972d3506a44d92 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 00:48:48 +0000
Subject: [PATCH 317/369] Make cxx 6.5 bugs happy

[SVN r12973]
---
 include/boost/python/converter/from_python.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index 4fe240ce..f2680ef3 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -130,7 +130,7 @@ inline from_python_base::from_python_base(void* result)
 }
 
 inline from_python_base::from_python_base(
-    PyObject* const source
+    PyObject* source
     , lvalue_from_python_registration const* chain)
     : m_result(find(source, chain))
 {

From b28dc5523752d79df1f524f872c9fd9ab12e74f6 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 06:08:27 +0000
Subject: [PATCH 318/369] suppress warnings with CWPro7

[SVN r12977]
---
 src/converter/builtin_converters.cpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 2e9bcbec..fe6708e6 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -221,15 +221,13 @@ namespace
           {
               return PyInt_AS_LONG(intermediate);
           }
-          else if (PyFloat_Check(intermediate))
-          {
-              return PyFloat_AS_DOUBLE(intermediate);
-          }
-          else
+          else if (!PyFloat_Check(intermediate)) 
           {
               PyErr_SetString(PyExc_TypeError, "__complex__ method did not return a Complex object");
               throw error_already_set();
           }
+          
+          return PyFloat_AS_DOUBLE(intermediate);
       }
   };
 } 

From 0e597f576875670c699fe33da9191ed74d9e1cc2 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 28 Feb 2002 15:38:21 +0000
Subject: [PATCH 319/369] Suppress some warnings on older EDGs

[SVN r12984]
---
 include/boost/python/converter/from_python.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index f2680ef3..f9192be2 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -10,6 +10,7 @@
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/destroy.hpp>
 # include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
 # include <boost/python/converter/pointer_type_id.hpp>
 # include <boost/python/converter/from_python_data.hpp>
 # include <boost/mpl/select_type.hpp>
@@ -179,7 +180,9 @@ namespace detail
   template <class U>
   inline void write_void_ptr_reference(void const volatile* storage, void* ptr, U&(*)())
   {
-      write_void_ptr(storage, ptr, U(0));
+      // stripping CV qualification suppresses warnings on older EDGs
+      typedef typename remove_cv<U>::type u_stripped; 
+      write_void_ptr(storage, ptr, u_stripped(0));
   }
 }
 

From edad2a1ee5cbc379e1862cc92e219a331a731a36 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 1 Mar 2002 20:33:04 +0000
Subject: [PATCH 320/369] *** empty log message ***

[SVN r12999]
---
 .../python/converter/from_python_data.hpp     | 154 ++++++++----------
 include/boost/python/detail/eval.hpp          |   2 +
 2 files changed, 66 insertions(+), 90 deletions(-)

diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index d88eb90e..fe026172 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -13,15 +13,12 @@
 # include <boost/type_traits/transform_traits.hpp>
 # include <boost/static_assert.hpp>
 # include <boost/python/converter/from_python_stage1_data.hpp>
-
-// Keep these for the metaprogram which EDG is choking on.
-# if !defined(__EDG__) || (__EDG_VERSION__ > 245)
-#  include <boost/mpl/type_list.hpp>
-#  include <boost/mpl/for_each.hpp>
-#  include <boost/type_traits/composite_traits.hpp>
-# else
-#  include <boost/type_traits/cv_traits.hpp>
-# endif 
+# include <boost/type_traits/composite_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+//# include <boost/python/detail/eval.hpp>
+# include <boost/preprocessor/list/for_each_i.hpp>
+# include <boost/preprocessor/tuple/to_list.hpp>
+# include <boost/preprocessor/cat.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -75,111 +72,88 @@ namespace detail
   };
   
 # endif
-
-  struct unknown_alignment
-  {
-      void* p;
-  };
-  
-// EDG is too slow to handle this metaprogram :(  
-#if !defined(__EDG__) || (__EDG_VERSION__ > 245)
   struct alignment_dummy;
+  typedef void (*function_ptr)();
+  typedef int (alignment_dummy::*member_ptr);
+  typedef int (alignment_dummy::*member_function_ptr)();
 
-  template <std::size_t target_alignment>
-  struct best_alignment_type
+# define BOOST_PYTHON_ALIGNMENT_TYPES BOOST_PP_TUPLE_TO_LIST( \
+        11, ( \
+        char, short, int, long, float, double, long double \
+        , void*, function_ptr, member_ptr, member_function_ptr))
+
+# define BOOST_PYTHON_CHOOSE_LOWER_ALIGNMENT(R,P,I,T) \
+        typename mpl::select_type< \
+           alignment_of<T>::value <= target, T, char>::type BOOST_PP_CAT(t,I);
+
+# define BOOST_PYTHON_CHOOSE_LOWER_SIZE(R,P,I,T) \
+        typename mpl::select_type< \
+           sizeof(T) <= target, T, char>::type BOOST_PP_CAT(t,I);
+           
+# define BOOST_PYTHON_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I);
+           
+  template <std::size_t target>
+  union lower_alignment
   {
-      template <class T1, class T2>
-      struct apply
-      {
-          BOOST_STATIC_CONSTANT(
-              std::size_t, align1 = alignment_of<T1>::value);
-          
-          BOOST_STATIC_CONSTANT(
-              std::size_t, align2 = alignment_of<T2>::value);
-          
-          BOOST_STATIC_CONSTANT(
-              bool, aligned2 = (
-                  (align2 >= target_alignment)
-                  & (align2 % target_alignment == 0))
-              );
-          
-          BOOST_STATIC_CONSTANT(
-              bool, choose_t2 = (
-                  aligned2 && (
-                      is_same<T1,unknown_alignment>::value
-                      | (align2 < align1)
-                      | (sizeof(T2) < sizeof(T1)))
-                  ));
-          
-          typedef typename mpl::select_type<choose_t2, T2, T1>::type type;
-      };
+      BOOST_PP_LIST_FOR_EACH_I(
+          BOOST_PYTHON_CHOOSE_LOWER_ALIGNMENT
+          , ignored, BOOST_PYTHON_ALIGNMENT_TYPES)
   };
 
-  typedef mpl::type_list<
-      char,short,int,long, float,double,long double
-      ,void*
-      ,void(*)()
-      ,void (alignment_dummy::*)()
-      , char (alignment_dummy::*)
-  >::type
-  align_types;
-#endif // EDG is too slow  
+  template <std::size_t target>
+  union lower_size
+  {
+      BOOST_PP_LIST_FOR_EACH_I(
+          BOOST_PYTHON_CHOOSE_LOWER_SIZE
+          , ignored, BOOST_PYTHON_ALIGNMENT_TYPES)
+  };
+
+  union max_align
+  {
+      BOOST_PP_LIST_FOR_EACH_I(
+          BOOST_PYTHON_CHOOSE_T
+          , ignored, BOOST_PYTHON_ALIGNMENT_TYPES)
+          };
+  
   template <class Align, std::size_t size>
   union aligned_storage
   {
       Align align;
-      char bytes[size
-                 // this is just a STATIC_ASSERT. For some reason
-                 // MSVC was barfing on the boost one.
-                 - (is_same<Align,unknown_alignment>::value ? size : 0)];
+      char bytes[size];
   };
 
   template <class Reference>
   struct referent_storage
   {
-// EDG is too slow to handle this metaprogram :(  
-#if !defined(__EDG__) || (__EDG_VERSION__ > 245)
-      typedef mpl::for_each<
-          align_types
-          , unknown_alignment
-          , best_alignment_type<
-          referent_alignment<Reference>::value
-      >
-      > loop;
-    
-      typedef typename loop::state align_t;
-#else
       typedef typename remove_cv<typename remove_reference<Reference>::type>::type referent;
-      
-      // The Python source makes the assumption that double has
-      // maximal alignment, but that fails on some platforms
-      BOOST_STATIC_CONSTANT(
-          std::size_t, target_align = alignment_of<referent>::value);
 
-      // Here we make some assumptions and leave out some possible
-      // types worth checking, but this should work most of the time.
+      BOOST_STATIC_CONSTANT(std::size_t, target = referent_alignment<Reference>::value);
+      typedef lower_alignment<target> t1;
+      typedef lower_size<referent_size<Reference>::value> t2;
+
       typedef typename mpl::select_type<
-          is_POD<referent>::value
-          , referent
+          ::boost::detail::ice_and<
+              alignment_of<t1>::value >= target
+              , alignment_of<t1>::value % target == 0
+          >::value
+          , t1
           , typename mpl::select_type< 
-              alignment_of<long>::value >= target_align
-              , long
-              , typename mpl::select_type<
-                  alignment_of<double>::value >= target_align
-                  , double
-                  , long double>::type
+              ::boost::detail::ice_and<
+                  alignment_of<t2>::value >= target
+                  , alignment_of<t2>::value % target == 0
+              >::value
+              , t2
+              , max_align
           >::type
       >::type align_t;
-#endif
-      BOOST_STATIC_CONSTANT(std::size_t, alignment1 = alignment_of<align_t>::value);
-      BOOST_STATIC_CONSTANT(std::size_t, alignment2 = referent_alignment<Reference>::value);
+
+      BOOST_STATIC_CONSTANT(std::size_t, found = alignment_of<align_t>::value);
     
-      BOOST_STATIC_ASSERT(alignment1 >= alignment2);
-      BOOST_STATIC_ASSERT(alignment1 % alignment2 == 0);
+      BOOST_STATIC_ASSERT(found >= target);
+      BOOST_STATIC_ASSERT(found % target == 0);
     
       typedef aligned_storage<align_t,referent_size<Reference>::value> type;
   };
-  
 }
 
 template <class T>
diff --git a/include/boost/python/detail/eval.hpp b/include/boost/python/detail/eval.hpp
index 3e799507..8699f701 100644
--- a/include/boost/python/detail/eval.hpp
+++ b/include/boost/python/detail/eval.hpp
@@ -6,6 +6,8 @@
 #ifndef EVAL_DWA2002124_HPP
 # define EVAL_DWA2002124_HPP
 
+# include <boost/mpl/apply.hpp>
+
 namespace boost { namespace python { namespace detail { 
 
 template <class T> struct undefined;

From 71cbe1cf50d6d93d298b6d2744aa06848cb1d036 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 1 Mar 2002 21:24:49 +0000
Subject: [PATCH 321/369] quick fixes for KCC

[SVN r13000]
---
 .../python/converter/from_python_data.hpp     | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index fe026172..9b418957 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -15,7 +15,7 @@
 # include <boost/python/converter/from_python_stage1_data.hpp>
 # include <boost/type_traits/composite_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
-//# include <boost/python/detail/eval.hpp>
+# include <boost/type_traits/ice.hpp>
 # include <boost/preprocessor/list/for_each_i.hpp>
 # include <boost/preprocessor/tuple/to_list.hpp>
 # include <boost/preprocessor/cat.hpp>
@@ -129,19 +129,23 @@ namespace detail
 
       BOOST_STATIC_CONSTANT(std::size_t, target = referent_alignment<Reference>::value);
       typedef lower_alignment<target> t1;
+
+      BOOST_STATIC_CONSTANT(bool, t1_aligned =
+                            (alignment_of<t1>::value >= target)
+                            & (alignment_of<t1>::value % target == 0));
+
       typedef lower_size<referent_size<Reference>::value> t2;
 
+      BOOST_STATIC_CONSTANT(bool, t2_aligned =
+                            (alignment_of<t2>::value >= target)
+                            & (alignment_of<t2>::value % target == 0));
+
+
       typedef typename mpl::select_type<
-          ::boost::detail::ice_and<
-              alignment_of<t1>::value >= target
-              , alignment_of<t1>::value % target == 0
-          >::value
+          t1_aligned
           , t1
           , typename mpl::select_type< 
-              ::boost::detail::ice_and<
-                  alignment_of<t2>::value >= target
-                  , alignment_of<t2>::value % target == 0
-              >::value
+              t2_aligned
               , t2
               , max_align
           >::type

From 9644610e049ae06b52b63e9545ae32b62fc13679 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Mar 2002 01:33:55 +0000
Subject: [PATCH 322/369] obsolete

[SVN r13004]
---
 include/boost/python/converter/handle.hpp | 108 ----------------------
 1 file changed, 108 deletions(-)
 delete mode 100644 include/boost/python/converter/handle.hpp

diff --git a/include/boost/python/converter/handle.hpp b/include/boost/python/converter/handle.hpp
deleted file mode 100644
index 82e085b0..00000000
--- a/include/boost/python/converter/handle.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef HANDLE_DWA20011130_HPP
-# define HANDLE_DWA20011130_HPP
-# include <boost/python/detail/config.hpp>
-# include <boost/utility.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { namespace converter { 
-
-struct BOOST_PYTHON_DECL body;
-
-// The common base class for unwrap_ and wrap_ handle objects. They
-// share a common base so that handles can be linked into a chain
-// within a function wrapper which is managed by a single object.
-struct BOOST_PYTHON_DECL handle : private boost::noncopyable
-{
- public: // member functions
-
-    // All constructors take a body* passed from the derived class.
-    //
-    // Constructors taking a handle links this into a chain of
-    // handles, for more efficient management in function wrappers
-    handle();
-    handle(body* body);
-    handle(body* body, handle& prev);
-
-    // returns true iff all handles in the chain can convert their
-    // arguments
-    bool convertible() const;
-
-    // safe_bool idiom from Peter Dimov: provides handles to/from
-    // bool without enabling handles to integer types/void*.
- private:
-    struct dummy { inline void nonnull() {} };
-    typedef void (dummy::*safe_bool)();
- public:
-    inline operator safe_bool() const;
-    inline safe_bool operator!() const;
-    
- protected: // member functions for derived classes
-    // Get the body we hold
-    inline body* get_body() const;
-
-    inline void set_body(body*);
-    inline void set_prev(handle&);
-    
-    // Release all bodies in the chain, in reverse order of
-    // initialization. Only actually called for the head of the chain.
-    void destroy();
-    
- private:
-    // Holds implementation
-    body* m_body;
-    
-    // handle for next argument, if any.
-    handle* m_next;
-};
-
-//
-// implementations
-// 
-inline handle::handle()
-    : m_next(0)
-{}
-
-inline handle::handle(body* body, handle& prev)
-    : m_body(body), m_next(0)
-{
-    prev.m_next = this;
-}
-
-inline handle::handle(body* body)
-    : m_body(body), m_next(0)
-{
-}
-
-inline handle::operator handle::safe_bool() const
-{
-    return convertible() ? &dummy::nonnull : 0;
-}
-
-inline handle::safe_bool handle::operator!() const
-{
-    return convertible() ? 0 : &dummy::nonnull;
-}
-
-inline body* handle::get_body() const
-{
-    return m_body;
-}
-
-inline void handle::set_body(body* body)
-{
-    m_body = body;
-}
-
-inline void handle::set_prev(handle& prev)
-{
-    prev.m_next = this;
-}
-
-}}} // namespace boost::python::converter
-
-#endif // HANDLE_DWA20011130_HPP

From a437af44f8b6ea4ea8d16e5845d70d9823cfd157 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Mar 2002 01:52:38 +0000
Subject: [PATCH 323/369] obsolete

[SVN r13005]
---
 .../python/converter/unwrapper_select.hpp     | 33 -------------------
 1 file changed, 33 deletions(-)
 delete mode 100644 include/boost/python/converter/unwrapper_select.hpp

diff --git a/include/boost/python/converter/unwrapper_select.hpp b/include/boost/python/converter/unwrapper_select.hpp
deleted file mode 100644
index d60923af..00000000
--- a/include/boost/python/converter/unwrapper_select.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright David Abrahams 2001. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef UNWRAPPER_SELECT_DWA20011229_HPP
-# define UNWRAPPER_SELECT_DWA20011229_HPP
-
-namespace boost { namespace python { namespace converter { 
-
-template <class T> struct unwrapper;
-
-// Select the type returned by unwrapper objects when unwrapping a
-// given type. When unwrapping T const&, the unwrapper returns T&, so
-// that the same unwrapper object can be used for both conversions (on
-// a conforming compiler).
-template <class T>
-struct unwrapper_select
-{
-    typedef unwrapper<T> type;
-};
-
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-template <class T>
-struct unwrapper_select<T const&>
-{
-    typedef unwrapper<T&> type;
-};
-# endif 
-
-}}} // namespace boost::python::converter
-
-#endif // UNWRAPPER_SELECT_DWA20011229_HPP

From 1257b32464f60490c366bc26802a27f922c6ba32 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Mar 2002 02:29:06 +0000
Subject: [PATCH 324/369] added missing 'inline'

[SVN r13006]
---
 include/boost/python/from_python.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/python/from_python.hpp b/include/boost/python/from_python.hpp
index 8c3f94bb..726928ac 100644
--- a/include/boost/python/from_python.hpp
+++ b/include/boost/python/from_python.hpp
@@ -39,7 +39,7 @@ struct from_python<PyObject* const&>
 // implementations
 //
 template <class T>
-from_python<T>::from_python(PyObject* source)
+inline from_python<T>::from_python(PyObject* source)
     : base(source)
 {
 }

From 087f09e9a6dd68bfd5af5e6591824a6074fb24f3 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 2 Mar 2002 02:52:36 +0000
Subject: [PATCH 325/369] flotsam removal

[SVN r13007]
---
 include/boost/python/with_custodian_and_ward.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/include/boost/python/with_custodian_and_ward.hpp b/include/boost/python/with_custodian_and_ward.hpp
index 4ae975af..517d690f 100644
--- a/include/boost/python/with_custodian_and_ward.hpp
+++ b/include/boost/python/with_custodian_and_ward.hpp
@@ -11,8 +11,6 @@
 
 namespace boost { namespace python { 
 
-enum custodial_timing { pre_call, post_call };
-                        
 template <std::size_t custodian, std::size_t ward, class Base = default_call_policies>
 struct with_custodian_and_ward : Base
 {

From bd9df7e6199c7e0ad5b0b32f27c13a611d7b568c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 3 Mar 2002 20:46:06 +0000
Subject: [PATCH 326/369] Apply patch due to Craig Rodriguez

[SVN r13049]
---
 include/boost/python/detail/init_function.hpp | 110 +++++++++---------
 src/gen_init_function.py                      |   2 +-
 2 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/include/boost/python/detail/init_function.hpp b/include/boost/python/detail/init_function.hpp
index ed34f9be..3c6f2380 100644
--- a/include/boost/python/detail/init_function.hpp
+++ b/include/boost/python/detail/init_function.hpp
@@ -175,106 +175,106 @@ struct init_function
     template <class A1>
     static init* create(signature1<A1>) {
         return new init1<T,
-                       detail::parameter_traits<A1>::const_reference>;
+                       typename 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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference>;
     }
 
     template <class A1, class A2, class A3>
     static init* create(signature3<A1, A2, A3>) {
         return new init3<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4>
     static init* create(signature4<A1, A2, A3, A4>) {
         return new init4<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4, class A5>
     static init* create(signature5<A1, A2, A3, A4, A5>) {
         return new init5<T,
-                       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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     static init* create(signature6<A1, A2, A3, A4, A5, A6>) {
         return new init6<T,
-                       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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     static init* create(signature7<A1, A2, A3, A4, A5, A6, A7>) {
         return new init7<T,
-                       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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     static init* create(signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
         return new init8<T,
-                       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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference,
+                       typename detail::parameter_traits<A8>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     static init* create(signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
         return new init9<T,
-                       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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference,
+                       typename detail::parameter_traits<A8>::const_reference,
+                       typename detail::parameter_traits<A9>::const_reference>;
     }
 
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     static init* create(signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
         return new init10<T,
-                       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>;
+                       typename detail::parameter_traits<A1>::const_reference,
+                       typename detail::parameter_traits<A2>::const_reference,
+                       typename detail::parameter_traits<A3>::const_reference,
+                       typename detail::parameter_traits<A4>::const_reference,
+                       typename detail::parameter_traits<A5>::const_reference,
+                       typename detail::parameter_traits<A6>::const_reference,
+                       typename detail::parameter_traits<A7>::const_reference,
+                       typename detail::parameter_traits<A8>::const_reference,
+                       typename detail::parameter_traits<A9>::const_reference,
+                       typename detail::parameter_traits<A10>::const_reference>;
     }
 };
 
diff --git a/src/gen_init_function.py b/src/gen_init_function.py
index ff294dbb..94e8041a 100644
--- a/src/gen_init_function.py
+++ b/src/gen_init_function.py
@@ -169,7 +169,7 @@ struct init_function
     template <%(class A%n%:, %)>
 %}    static init* create(signature%x%{<%(A%n%:, %)>%}) {
         return new init%x<T%(,
-                       detail::parameter_traits<A%n>::const_reference%)>;
+                       typename detail::parameter_traits<A%n>::const_reference%)>;
     }
 """, args)+"""};
 

From 97825fb2c7b2d77c2c0611eb609eb2a77b8ac315 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 6 Mar 2002 01:33:46 +0000
Subject: [PATCH 327/369] Kill some Intel5 warnings

[SVN r13108]
---
 include/boost/python/detail/config.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index c488cb64..efd1500b 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -33,10 +33,15 @@
 #   define BOOST_MSVC6_OR_EARLIER 1
 #  endif
 
-# pragma warning (disable : 4786)
+#  pragma warning (disable : 4786)
+
+# elif defined(__ICL) && __ICL < 600 // Intel C++ 5
+
+#  pragma warning(disable: 985) // identifier was truncated in debug information
 
 # 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.

From e79a66851c02c061be6678d3a7118907d7305596 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Mar 2002 14:56:39 +0000
Subject: [PATCH 328/369] Beginning of callback implementation

[SVN r13135]
---
 Jamfile                                       | 104 +++---------------
 .../python/converter/builtin_converters.hpp   |  24 +++-
 .../converter/callback_to_python_base.hpp     |  45 ++++++++
 .../python/converter/find_from_python.hpp     |   7 +-
 .../boost/python/converter/from_python.hpp    |  42 +------
 .../python/converter/from_python_data.hpp     |  37 ++++++-
 .../converter/lvalue_from_python_chain.hpp    |  67 +++++++++++
 include/boost/python/converter/registry.hpp   |   8 +-
 .../python/converter/to_python_function.hpp   |  44 +++++---
 .../converter/to_python_function_type.hpp     |  30 +++++
 include/boost/python/to_python_converter.hpp  |   2 +-
 include/boost/python/to_python_value.hpp      |  16 +--
 src/converter/builtin_converters.cpp          |   2 +-
 src/converter/from_python.cpp                 |  12 +-
 src/converter/registry.cpp                    |   8 +-
 src/object/function.cpp                       |  30 ++++-
 test/Jamfile                                  |  75 +++++++++++++
 test/test_builtin_converters.cpp              |   4 +-
 test/test_builtin_converters.py               |   2 +-
 19 files changed, 381 insertions(+), 178 deletions(-)
 create mode 100644 include/boost/python/converter/callback_to_python_base.hpp
 create mode 100644 include/boost/python/converter/lvalue_from_python_chain.hpp
 create mode 100644 include/boost/python/converter/to_python_function_type.hpp
 create mode 100644 test/Jamfile

diff --git a/Jamfile b/Jamfile
index 9bf18e2e..4a1af66f 100644
--- a/Jamfile
+++ b/Jamfile
@@ -4,93 +4,21 @@ subproject libs/python ;
 SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
 include <module@>python.jam ;
 
-
-{
-    local BOOST_PYTHON_V2_PROPERTIES 
-      = $(PYTHON_PROPERTIES)
-        <metrowerks><*><cxxflags>"-inline deferred" 
-        <cxx><*><include>$(BOOST_ROOT)/boost/compatibility/cpp_c_headers
-          <define>BOOST_PYTHON_DYNAMIC_LIB
-          <define>BOOST_PYTHON_V2
-          ;
-    
-    local gcc-release-properties
-      = <optimization>speed <cxxflags>-fomit-frame-pointer
-      <inlining>on <cxxflags>-foptimize-sibling-calls
-      ;
-    
-    local PYTHON_PROPERTIES = $(BOOST_PYTHON_V2_PROPERTIES) <gcc><release>$(gcc-release-properties)
-;
-    
-    dll bpl
-      : 
-      src/converter/from_python.cpp
-      src/converter/registry.cpp
-      src/converter/type_id.cpp
-      src/object/class.cpp
-      src/object/function.cpp
-      src/object/inheritance.cpp
-      src/object/life_support.cpp
-      src/errors.cpp
-      src/module.cpp
-      src/objects.cpp
-      src/converter/builtin_converters.cpp
-      :
-      $(BOOST_PYTHON_V2_PROPERTIES)
-        <define>BOOST_PYTHON_SOURCE
-        ;
-
-    # -------- general test -------
-    extension m1 : test/m1.cpp <dll>bpl
-      : 
-      : 
-      ;
-
-    extension m2 : test/m2.cpp <dll>bpl
-      : 
-      :  ;
-
-    boost-python-runtest try : test/newtest.py <pyd>m1 <pyd>m2 : :  ;
-
-    # ----------- builtin converters -----------
-    
-    extension builtin_converters_ext : test/test_builtin_converters.cpp <dll>bpl
-      :
-      : 
-      ;
-
-    boost-python-runtest test_builtin_converters : test/test_builtin_converters.py
-      <pyd>builtin_converters_ext
-      :
-      : 
-      ;
-    
-    # ----------- pointer adoption -----------
-    
-    extension test_pointer_adoption_ext : test/test_pointer_adoption.cpp <dll>bpl
-      :
-      : 
-      ;
-
-    boost-python-runtest test_pointer_adoption : test/test_pointer_adoption.py
-      <pyd>test_pointer_adoption_ext
-      :
-      : 
-      ;
-    
-}
-
-unit-test indirect_traits_test
-  : test/indirect_traits_test.cpp : <include>$(BOOST_ROOT)  ;
-unit-test destroy_test
-  : test/destroy_test.cpp : <include>$(BOOST_ROOT)  ;
-unit-test pointer_type_id_test
-  : test/pointer_type_id_test.cpp : <include>$(BOOST_ROOT)  ;
-
-unit-test select_from_python_test
-  : test/select_from_python_test.cpp
+dll bpl
+  : 
+  src/converter/from_python.cpp
+  src/converter/registry.cpp
   src/converter/type_id.cpp
-  src/converter/registry.cpp # MWerks needs this for some reason
-  : $(PYTHON_PROPERTIES)
+  src/object/class.cpp
+  src/object/function.cpp
+  src/object/inheritance.cpp
+  src/object/life_support.cpp
+  src/errors.cpp
+  src/module.cpp
+  src/objects.cpp
+  src/converter/builtin_converters.cpp
+  src/converter/callback.cpp
+  :
+  $(BOOST_PYTHON_V2_PROPERTIES)
+    <define>BOOST_PYTHON_SOURCE
     ;
-
diff --git a/include/boost/python/converter/builtin_converters.hpp b/include/boost/python/converter/builtin_converters.hpp
index 7ae7a357..4db0eb9c 100644
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -7,6 +7,7 @@
 # define BUILTIN_CONVERTERS_DWA2002124_HPP
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/python/detail/none.hpp>
+# include <boost/python/reference.hpp>
 # include <string>
 # include <complex>
 
@@ -23,6 +24,11 @@ namespace detail
   };
 }
 
+namespace converter
+{
+  template <class T> struct callback_to_python;
+}
+
 # define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)   \
     template <> struct to_python_value<T&>          \
         : detail::builtin_to_python                 \
@@ -39,7 +45,19 @@ namespace detail
         {                                           \
             return (expr);                          \
         }                                           \
-    };
+    };                                              \
+    namespace converter                             \
+    {                                               \
+      template <> struct callback_to_python< T >    \
+      {                                             \
+          callback_to_python(T const& x)            \
+            : m_held(expr) {}                       \
+          PyObject* get() const                     \
+            { return m_held.get(); }                \
+       private:                                     \
+          ref m_held;                               \
+      };                                            \
+    }                                               
 
 
 # define BOOST_PYTHON_TO_INT(T)                                         \
@@ -53,12 +71,12 @@ BOOST_PYTHON_TO_INT(int)
 BOOST_PYTHON_TO_INT(long)
 # undef BOOST_TO_PYTHON_INT
 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, x ? PyString_FromString(x) : detail::none())
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, x ? PyString_FromString(x) : boost::python::detail::none())
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, x ? x : detail::none())
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, (x ? x : boost::python::detail::none()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, PyComplex_FromDoubles(x.real(), x.imag()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, PyComplex_FromDoubles(x.real(), x.imag()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, PyComplex_FromDoubles(x.real(), x.imag()))
diff --git a/include/boost/python/converter/callback_to_python_base.hpp b/include/boost/python/converter/callback_to_python_base.hpp
new file mode 100644
index 00000000..c878850e
--- /dev/null
+++ b/include/boost/python/converter/callback_to_python_base.hpp
@@ -0,0 +1,45 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
+# define CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/reference.hpp>
+
+namespace boost { namespace python { namespace converter {
+
+namespace detail
+{
+  struct callback_to_python_holder
+  {
+      callback_to_python_holder(PyObject* obj);
+      inline PyObject* get() const;
+   private:
+      ref m_held;
+  };
+  
+  struct BOOST_PYTHON_DECL callback_to_python_base : callback_to_python_holder
+  {
+      callback_to_python_base(void const volatile* source, to_python_function_t);
+  };
+
+  //
+  // implmentation
+  //
+  inline callback_to_python_holder::callback_to_python_holder(PyObject* obj)
+      : m_held(obj)
+  {
+  }
+  
+  inline PyObject* callback_to_python_holder::get() const
+  {
+      return m_held.get();
+  }
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_TO_PYTHON_BASE_DWA200237_HPP
diff --git a/include/boost/python/converter/find_from_python.hpp b/include/boost/python/converter/find_from_python.hpp
index 863c44a6..e7f7ca81 100644
--- a/include/boost/python/converter/find_from_python.hpp
+++ b/include/boost/python/converter/find_from_python.hpp
@@ -8,17 +8,18 @@
 
 # include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
+# include <boost/python/converter/from_python_stage1_data.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
 struct lvalue_from_python_registration;
 struct rvalue_from_python_registration;
-struct rvalue_stage1_data;
 
 BOOST_PYTHON_DECL void* find(
     PyObject* source, lvalue_from_python_registration const*);
-BOOST_PYTHON_DECL void* find(
-    PyObject* source, rvalue_from_python_registration const*, rvalue_stage1_data&);
+
+BOOST_PYTHON_DECL rvalue_stage1_data find(
+    PyObject* source, rvalue_from_python_registration const*);
 
 }}} // namespace boost::python::converter
 
diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index f9192be2..5fe8901a 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -8,13 +8,14 @@
 
 # include <boost/python/converter/find_from_python.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/destroy.hpp>
 # include <boost/type_traits/transform_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/python/converter/pointer_type_id.hpp>
 # include <boost/python/converter/from_python_data.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/lvalue_from_python_chain.hpp>
+# include <boost/python/converter/rvalue_from_python_chain.hpp>
 
 namespace boost { namespace python { namespace converter {
 
@@ -42,8 +43,6 @@ struct pointer_const_reference_from_python
     
  private:
     typename detail::referent_storage<T>::type m_result;
-    
-    static lvalue_from_python_registration*& chain;
 };
 
 // Used when T == U* 
@@ -52,8 +51,6 @@ struct pointer_from_python : from_python_base
 {
     pointer_from_python(PyObject*);
     T operator()(PyObject*) const;
-    
-    static lvalue_from_python_registration*& chain;
 };
 
 // Used when T == U& and (T != V const& or T == W volatile&)
@@ -62,8 +59,6 @@ struct reference_from_python : from_python_base
 {
     reference_from_python(PyObject*);
     T operator()(PyObject*) const;
-    
-    static lvalue_from_python_registration*& chain;
 };
 
 // ------- rvalue converters ---------
@@ -79,14 +74,12 @@ class rvalue_from_python
     
  public:
     rvalue_from_python(PyObject*);
-    ~rvalue_from_python();
     bool convertible() const;
     
     result_type operator()(PyObject*);
     
  private:
     rvalue_data<result_type> m_data;
-    static rvalue_from_python_registration*& chain;
 };
 
 template <class T>
@@ -191,7 +184,7 @@ inline pointer_const_reference_from_python<T>::pointer_const_reference_from_pyth
 {
     detail::write_void_ptr_reference(
         m_result.bytes
-        , p == Py_None ? p : find(p, chain)
+        , p == Py_None ? p : find(p, lvalue_from_python_chain<T>::value)
         , (T(*)())0);
 }
 
@@ -208,15 +201,11 @@ inline T pointer_const_reference_from_python<T>::operator()(PyObject* p) const
         : detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
 }
 
-template <class T>
-lvalue_from_python_registration*& pointer_const_reference_from_python<T>::chain
-        = registry::lvalue_converters(pointer_type_id<T>());
-
 // --------
 
 template <class T>
 inline pointer_from_python<T>::pointer_from_python(PyObject* p)
-    : from_python_base(p == Py_None ? p : find(p, chain))
+    : from_python_base(p == Py_None ? p : find(p, lvalue_from_python_chain<T>::value))
 {
 }
 
@@ -226,15 +215,11 @@ inline T pointer_from_python<T>::operator()(PyObject* p) const
     return (p == Py_None) ? 0 : T(result());
 }
 
-template <class T>
-lvalue_from_python_registration*& pointer_from_python<T>::chain
-        = registry::lvalue_converters(pointer_type_id<T>());
-
 // --------
 
 template <class T>
 inline reference_from_python<T>::reference_from_python(PyObject* p)
-    : from_python_base(find(p,chain))
+    : from_python_base(find(p,lvalue_from_python_chain<T>::value))
 {
 }
 
@@ -244,23 +229,12 @@ inline T reference_from_python<T>::operator()(PyObject*) const
     return detail::void_ptr_to_reference(result(), (T(*)())0);
 }
 
-template <class T>
-lvalue_from_python_registration*& reference_from_python<T>::chain
-        = registry::lvalue_converters(undecorated_type_id<T>());
-
 // -------
 
 template <class T>
 inline rvalue_from_python<T>::rvalue_from_python(PyObject* obj)
+    : m_data(find(obj, rvalue_from_python_chain<T>::value))
 {
-    find(obj, chain, m_data.stage1);
-}
-
-template <class T>
-inline rvalue_from_python<T>::~rvalue_from_python()
-{
-    if (m_data.stage1.convertible == m_data.storage.bytes)
-        python::detail::destroy_reference<result_type>(m_data.storage.bytes);
 }
 
 template <class T>
@@ -279,10 +253,6 @@ rvalue_from_python<T>::operator()(PyObject* p)
     return detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
 }
 
-template <class T>
-rvalue_from_python_registration*& rvalue_from_python<T>::chain
-        = registry::rvalue_converters(undecorated_type_id<T>());
-
 }}} // namespace boost::python::converter
 
 #endif // FROM_PYTHON_DWA2002127_HPP
diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index 9b418957..9fa9410a 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -16,6 +16,7 @@
 # include <boost/type_traits/composite_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
 # include <boost/type_traits/ice.hpp>
+# include <boost/python/detail/destroy.hpp>
 # include <boost/preprocessor/list/for_each_i.hpp>
 # include <boost/preprocessor/tuple/to_list.hpp>
 # include <boost/preprocessor/cat.hpp>
@@ -161,7 +162,7 @@ namespace detail
 }
 
 template <class T>
-struct rvalue_data
+struct rvalue_base_data
 {
     rvalue_stage1_data stage1;
     
@@ -170,6 +171,40 @@ struct rvalue_data
     >::type storage;
 };
 
+template <class T>
+struct rvalue_data : rvalue_base_data<T>
+{
+    rvalue_data(rvalue_stage1_data const&);
+    rvalue_data(void*);
+    ~rvalue_data();
+};
+
+//
+// Implementataions
+//
+template <class T>
+inline rvalue_data<T>::rvalue_data(rvalue_stage1_data const& stage1)
+{
+    this->stage1 = stage1;
+}
+
+template <class T>
+inline rvalue_data<T>::rvalue_data(void* convertible)
+{
+    this->stage1.convertible = convertible;
+}
+
+template <class T>
+inline rvalue_data<T>::~rvalue_data()
+{
+    if (this->stage1.convertible == this->storage.bytes)
+        python::detail::destroy_reference<
+            add_reference<
+                add_cv<T>::type
+            >::type
+        >(storage.bytes);
+}
+
 }}} // namespace boost::python::converter
 
 #endif // FROM_PYTHON_AUX_DATA_DWA2002128_HPP
diff --git a/include/boost/python/converter/lvalue_from_python_chain.hpp b/include/boost/python/converter/lvalue_from_python_chain.hpp
new file mode 100644
index 00000000..f1417460
--- /dev/null
+++ b/include/boost/python/converter/lvalue_from_python_chain.hpp
@@ -0,0 +1,67 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# define LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+
+# include <boost/python/converter/pointer_type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// Given T == U*cv&, T == U*, or T == U&, lvalue_from_python_chain<T>
+// declares a "templated global reference" to the lvalue from_python
+// converter chain for U
+namespace detail
+{
+  template <class T>
+  struct ptr_or_ptr_ref_lvalue_from_python_chain
+  {
+      static lvalue_from_python_registration*const& value;
+  };
+    
+  template <class T>
+  lvalue_from_python_registration*const&
+  ptr_or_ptr_ref_lvalue_from_python_chain<T>::value
+     = registry::lvalue_converters(pointer_type_id<T>());
+
+  template <class T>
+  struct ref_lvalue_from_python_chain
+  {
+      static lvalue_from_python_registration*const& value;
+  };
+
+  template <class T>
+  lvalue_from_python_registration*const&
+  ref_lvalue_from_python_chain<T>::value
+     = registry::lvalue_converters(undecorated_type_id<T>());
+
+  template <class T>
+  struct select_lvalue_from_python_chain
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = boost::python::detail::is_reference_to_pointer<T>::value
+                      || is_pointer<T>::value);
+
+      typedef typename add_reference<typename add_cv<T>::type>::type normalized;
+
+      typedef typename mpl::select_type<
+          ptr
+          , ptr_or_ptr_ref_lvalue_from_python_chain<normalized>
+          , ref_lvalue_from_python_chain<normalized>
+          >::type type;
+  };
+}
+
+template <class T>
+struct lvalue_from_python_chain
+    : detail::select_lvalue_from_python_chain<T>::type
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // LVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
diff --git a/include/boost/python/converter/registry.hpp b/include/boost/python/converter/registry.hpp
index a511a1a4..1c8dba24 100644
--- a/include/boost/python/converter/registry.hpp
+++ b/include/boost/python/converter/registry.hpp
@@ -8,7 +8,7 @@
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/detail/config.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
 # include <boost/python/converter/from_python_function.hpp>
 
 namespace boost { namespace python { namespace converter {
@@ -22,10 +22,10 @@ namespace registry
   BOOST_PYTHON_DECL lvalue_from_python_registration*& lvalue_converters(undecorated_type_id_t);
   BOOST_PYTHON_DECL rvalue_from_python_registration*& rvalue_converters(undecorated_type_id_t);
   
-  BOOST_PYTHON_DECL to_python_value_function const&
-  to_python_function(undecorated_type_id_t);
+  BOOST_PYTHON_DECL to_python_function_t const&
+  get_to_python_function(undecorated_type_id_t);
   
-  BOOST_PYTHON_DECL void insert(to_python_value_function, undecorated_type_id_t);
+  BOOST_PYTHON_DECL void insert(to_python_function_t, undecorated_type_id_t);
 
   // Insert an lvalue from_python converter
   BOOST_PYTHON_DECL void insert(void* (*convert)(PyObject*), undecorated_type_id_t);
diff --git a/include/boost/python/converter/to_python_function.hpp b/include/boost/python/converter/to_python_function.hpp
index a438ce0c..ff3891e2 100644
--- a/include/boost/python/converter/to_python_function.hpp
+++ b/include/boost/python/converter/to_python_function.hpp
@@ -8,23 +8,41 @@
 
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
-// The type of stored function pointers which actually do conversion
-// by-value. The void* points to the object to be converted, and
-// type-safety is preserved through runtime registration.
-typedef PyObject* (*to_python_value_function)(void const*);
-
-// Given a typesafe to_python conversion function, produces a
-// to_python_value_function which can be registered in the usual way.
-template <class T, class ToPython>
-struct as_to_python_value_function
+// to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(undecorated_type_id<T>());
+}
+
+template <class T>
+struct to_python_function
+    : detail::to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
 {
-    static PyObject* convert(void const* x)
-    {
-        return ToPython::convert(*(T const*)x);
-    }
 };
 
 }}} // namespace boost::python::converter
diff --git a/include/boost/python/converter/to_python_function_type.hpp b/include/boost/python/converter/to_python_function_type.hpp
new file mode 100644
index 00000000..197654e5
--- /dev/null
+++ b/include/boost/python/converter/to_python_function_type.hpp
@@ -0,0 +1,30 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# define TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
+# include <boost/python/detail/wrap_python.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// The type of stored function pointers which actually do conversion
+// by-value. The void* points to the object to be converted, and
+// type-safety is preserved through runtime registration.
+typedef PyObject* (*to_python_function_t)(void const*);
+
+// Given a typesafe to_python conversion function, produces a
+// to_python_function_t which can be registered in the usual way.
+template <class T, class ToPython>
+struct as_to_python_function
+{
+    static PyObject* convert(void const* x)
+    {
+        return ToPython::convert(*(T const*)x);
+    }
+};
+
+}}} // namespace boost::python::converter
+
+#endif // TO_PYTHON_FUNCTION_TYPE_DWA200236_HPP
diff --git a/include/boost/python/to_python_converter.hpp b/include/boost/python/to_python_converter.hpp
index 7e46c505..47473419 100644
--- a/include/boost/python/to_python_converter.hpp
+++ b/include/boost/python/to_python_converter.hpp
@@ -25,7 +25,7 @@ struct to_python_converter
 template <class T, class Conversion>
 to_python_converter<T,Conversion>::to_python_converter()
 {
-    typedef converter::as_to_python_value_function<
+    typedef converter::as_to_python_function<
         T, Conversion
         > normalized;
         
diff --git a/include/boost/python/to_python_value.hpp b/include/boost/python/to_python_value.hpp
index ecff5808..ffb68ada 100644
--- a/include/boost/python/to_python_value.hpp
+++ b/include/boost/python/to_python_value.hpp
@@ -23,25 +23,14 @@ struct to_python_value
     
     static bool convertible();
     PyObject* operator()(argument_type) const;
-
- private:
-    // Note that this is a pointer to a function pointer
-    static converter::to_python_value_function const* fconvert;
 };
 
 
-template <class T>
-converter::to_python_value_function const*
-to_python_value<T>::fconvert
-        = &converter::registry::to_python_function(converter::undecorated_type_id<T>());
-
-
 template <class T>
 bool to_python_value<T>::convertible()
 {
     // if this assert fires, our static variable hasn't been set up yet.
-    assert(fconvert != 0);
-    return *fconvert != 0;
+    return converter::to_python_function<argument_type>::value != 0;
 }
 
 template <class T>
@@ -49,8 +38,7 @@ PyObject* to_python_value<T>::operator()(argument_type x) const
 {
     // This might be further optimized on platforms which dynamically
     // link without specific imports/exports
-    converter::to_python_value_function f = *fconvert;
-    return f(&x);
+    return converter::to_python_function<argument_type>::value(&x);
 }
 
 }} // namespace boost::python
diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index fe6708e6..87d0d7b4 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -56,7 +56,7 @@ namespace
           ref intermediate(creator(obj));
 
           // Get the location in which to construct
-          void* storage = ((rvalue_data<T>*)data)->storage.bytes;
+          void* storage = ((rvalue_base_data<T>*)data)->storage.bytes;
           new (storage) T(SlotPolicy::extract(intermediate.get()));
 
           // record successful construction
diff --git a/src/converter/from_python.cpp b/src/converter/from_python.cpp
index 57aee355..8a68cc44 100644
--- a/src/converter/from_python.cpp
+++ b/src/converter/from_python.cpp
@@ -10,21 +10,23 @@
 
 namespace boost { namespace python { namespace converter { 
 
-BOOST_PYTHON_DECL void* find(
+BOOST_PYTHON_DECL rvalue_stage1_data find(
     PyObject* source
-    , rvalue_from_python_registration const* chain
-    , rvalue_stage1_data& data)
+    , rvalue_from_python_registration const* chain)
 {
+    rvalue_stage1_data data;
+    data.convertible = 0;
     for (;chain != 0; chain = chain->next)
     {
         void* r = chain->convertible(source);
         if (r != 0)
         {
+            data.convertible = r;
             data.construct = chain->construct;
-            return data.convertible = r;
+            break;
         }
     }
-    return data.convertible = 0;
+    return data;
 }
 
 BOOST_PYTHON_DECL void* find(
diff --git a/src/converter/registry.cpp b/src/converter/registry.cpp
index bdfa1c8a..2d104b01 100644
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -19,7 +19,7 @@ namespace // <unnamed>
       entry();
       
       // The unique to_python converter for the associated C++ type.
-      to_python_value_function m_to_python_converter;
+      to_python_function_t m_to_python_converter;
       
       // The collection of from_python converters for the associated
       // C++ type.
@@ -66,15 +66,15 @@ namespace // <unnamed>
 
 namespace registry
 {
-  to_python_value_function const& to_python_function(
+  to_python_function_t const& get_to_python_function(
       undecorated_type_id_t key)
   {
       return find(key)->m_to_python_converter;
   }
   
-  void insert(to_python_value_function f, undecorated_type_id_t source_t)
+  void insert(to_python_function_t f, undecorated_type_id_t source_t)
   {
-      to_python_value_function& slot = find(source_t)->m_to_python_converter;
+      to_python_function_t& slot = find(source_t)->m_to_python_converter;
       assert(slot == 0); // we have a problem otherwise
       if (slot != 0)
       {
diff --git a/src/object/function.cpp b/src/object/function.cpp
index a30e9f15..a9f0c94d 100644
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -112,6 +112,30 @@ void function::add_to_namespace(
         throw error_already_set();
 }
 
+namespace
+{
+  struct bind_return
+  {
+      bind_return(PyObject*& result, function const* f, PyObject* args, PyObject* keywords)
+          : m_result(result)
+            , m_f(f)
+            , m_args(args)
+            , m_keywords(keywords)
+      {}
+
+      void operator()() const
+      {
+          m_result = m_f->call(m_args, m_keywords);
+      }
+      
+   private:
+      PyObject*& m_result;
+      function const* m_f;
+      PyObject* m_args;
+      PyObject* m_keywords;
+  };
+}
+
 extern "C"
 {
     // Stolen from Python's funcobject.c
@@ -130,9 +154,11 @@ extern "C"
     }
 
     static PyObject *
-    function_call(PyObject *func, PyObject *arg, PyObject *kw)
+    function_call(PyObject *func, PyObject *args, PyObject *kw)
     {
-        return static_cast<function*>(func)->call(arg, kw);
+        PyObject* result = 0;
+        handle_exception(bind_return(result, static_cast<function*>(func), args, kw));
+        return result;
     }
 }
 
diff --git a/test/Jamfile b/test/Jamfile
new file mode 100644
index 00000000..767b07e6
--- /dev/null
+++ b/test/Jamfile
@@ -0,0 +1,75 @@
+subproject libs/python/test ;
+
+# bring in the rules for python
+SEARCH on <module@>python.jam = $(BOOST_BUILD_PATH) ;
+include <module@>python.jam ;
+
+local PYTHON_V1_PROPERTIES = $(PYTHON_PROPERTIES) ;
+local PYTHON_PROPERTIES = $(BOOST_PYTHON_V2_PROPERTIES) ;
+
+#
+rule bpl-test ( name ? : files * )
+{
+    files ?= $(name).py $(name).cpp ;
+    
+    local modules ;
+    local py ;
+    for local f in $(files)
+    {
+        if $(f:S) = .py
+        {
+            if $(py)
+            {
+                EXIT too many python drivers specified: "$(py)" "$(f)" ;
+            }
+            py = $(f) ;
+        }
+    }
+    
+    name ?= $(py:S=) ;
+
+    for local f in $(files)
+    {
+        if $(f:S) != .py
+        {
+            local m = $(f:S=) ;
+            
+            if $(m) = $(py:S=)
+            {
+                m = $(name) ;
+                
+                if $(m) = $(py:S=)
+                {
+                    m = $(m)_ext ;
+                }
+            }
+            extension $(m) : $(f) <dll>../bpl ;
+            modules += $(m) ;
+        }
+    }
+    
+    boost-python-runtest $(name) : $(py) <pyd>$(modules) ;
+}
+
+bpl-test try : newtest.py m1.cpp m2.cpp ;
+bpl-test builtin_converters : test_builtin_converters.py test_builtin_converters.cpp ;
+bpl-test test_pointer_adoption ;
+bpl-test callbacks ;
+
+# --- unit tests of library components ---
+unit-test indirect_traits_test
+  : indirect_traits_test.cpp : <include>$(BOOST_ROOT)  ;
+unit-test destroy_test
+  : destroy_test.cpp : <include>$(BOOST_ROOT)  ;
+unit-test pointer_type_id_test
+  : pointer_type_id_test.cpp : <include>$(BOOST_ROOT)  ;
+
+unit-test select_from_python_test
+  : select_from_python_test.cpp 
+    ../src/converter/type_id.cpp
+    # ../src/converter/registry.cpp # MWerks needs this for some reason
+
+  : <include>$(BOOST_ROOT) <define>BOOST_PYTHON_STATIC_LIB
+    $(PYTHON_V1_PROPERTIES)
+    ;
+
diff --git a/test/test_builtin_converters.cpp b/test/test_builtin_converters.cpp
index 4c07d9f4..939f9dc4 100644
--- a/test/test_builtin_converters.cpp
+++ b/test/test_builtin_converters.cpp
@@ -25,9 +25,9 @@ struct by_const_reference
     }
 };
 
-BOOST_PYTHON_MODULE_INIT(builtin_converters_ext)
+BOOST_PYTHON_MODULE_INIT(builtin_converters)
 {
-    boost::python::module("builtin_converters_ext")
+    boost::python::module("builtin_converters")
         
         .def("rewrap_value_bool", by_value<bool>::rewrap)
         .def("rewrap_value_signed_char", by_value<signed char>::rewrap)
diff --git a/test/test_builtin_converters.py b/test/test_builtin_converters.py
index 50d436e5..3958c15a 100644
--- a/test/test_builtin_converters.py
+++ b/test/test_builtin_converters.py
@@ -1,5 +1,5 @@
 """
->>> from builtin_converters_ext import *
+>>> from builtin_converters import *
 >>> rewrap_value_bool(None)
 0
 >>> rewrap_value_bool(0)

From 532833ff705f4446aeeda0029a2bd5de56c9ed23 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Mar 2002 15:29:39 +0000
Subject: [PATCH 329/369] initial checkin

[SVN r13136]
---
 src/converter/callback.cpp | 69 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 src/converter/callback.cpp

diff --git a/src/converter/callback.cpp b/src/converter/callback.cpp
new file mode 100644
index 00000000..b3158500
--- /dev/null
+++ b/src/converter/callback.cpp
@@ -0,0 +1,69 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+
+#include <boost/python/converter/callback_to_python_base.hpp>
+#include <boost/python/errors.hpp>
+#include <boost/python/converter/find_from_python.hpp>
+#include <boost/python/reference.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+
+  namespace
+  {
+    inline PyObject* convert(void const volatile* source, to_python_function_t converter)
+    {
+        if (converter == 0)
+        {
+            PyErr_SetString(
+                PyExc_TypeError
+                , const_cast<char*>("no to_python (by-value) converter found for type"));
+            throw error_already_set();
+        }
+        return converter(const_cast<void*>(source));
+    }
+  }
+  
+  callback_to_python_base::callback_to_python_base(
+      void const volatile* source, to_python_function_t converter)
+      : callback_to_python_holder(convert(source, converter))
+  {
+  }
+
+  BOOST_PYTHON_DECL void throw_if_not_registered(rvalue_stage1_data const& data)
+  {
+      if (!data.convertible)
+      {
+          PyErr_SetString(
+              PyExc_TypeError
+              , const_cast<char*>("no from_python (by-value) converters found for type"));
+          throw error_already_set();
+      }
+  }
+  
+  BOOST_PYTHON_DECL void* convert_rvalue(PyObject* src, rvalue_stage1_data& data, void* storage)
+  {
+      ref holder(src);
+      
+      data = find(src, static_cast<rvalue_from_python_registration*>(data.convertible));
+      
+      if (!data.convertible)
+      {
+          PyErr_SetString(
+              PyExc_TypeError
+              , const_cast<char*>("no registered from_python (by-value) converter was able to convert type"));
+          throw error_already_set();
+      }
+      if (data.construct != 0)
+          data.construct(src, &data);
+      
+      return data.convertible;
+  }
+}   
+
+}}} // namespace boost::python::converter

From a25021d215d3801f5c671ccdaa299d4f18bac161 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Mar 2002 15:32:32 +0000
Subject: [PATCH 330/369] Initial checkin

[SVN r13137]
---
 .../converter/rvalue_from_python_chain.hpp    | 39 ++++++++++
 test/callbacks.cpp                            | 71 +++++++++++++++++++
 test/callbacks.py                             | 43 +++++++++++
 3 files changed, 153 insertions(+)
 create mode 100644 include/boost/python/converter/rvalue_from_python_chain.hpp
 create mode 100644 test/callbacks.cpp
 create mode 100644 test/callbacks.py

diff --git a/include/boost/python/converter/rvalue_from_python_chain.hpp b/include/boost/python/converter/rvalue_from_python_chain.hpp
new file mode 100644
index 00000000..c57ef564
--- /dev/null
+++ b/include/boost/python/converter/rvalue_from_python_chain.hpp
@@ -0,0 +1,39 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# define RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
+# include <boost/python/converter/registry.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T>
+  struct rvalue_from_python_chain_impl
+  {
+      static rvalue_from_python_registration*const& value;
+  };
+
+  template <class T>
+  rvalue_from_python_registration*const& rvalue_from_python_chain_impl<T>::value
+      = registry::rvalue_converters(undecorated_type_id<T>());
+}
+
+template <class T>
+struct rvalue_from_python_chain
+    : detail::rvalue_from_python_chain_impl<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // RVALUE_FROM_PYTHON_CHAIN_DWA200237_HPP
diff --git a/test/callbacks.cpp b/test/callbacks.cpp
new file mode 100644
index 00000000..9991e41f
--- /dev/null
+++ b/test/callbacks.cpp
@@ -0,0 +1,71 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/module.hpp>
+#include <boost/python/returning.hpp>
+#include <boost/python/class.hpp>
+#include <boost/ref.hpp>
+
+using namespace boost::python;
+
+int apply_int_int(PyObject* f, int x)
+{
+    return returning<int>::call(f, x);
+}
+
+void apply_void_int(PyObject* f, int x)
+{
+    returning<void>::call(f, x);
+}
+
+struct X
+{
+    explicit X(int x) : x(x), magic(7654321) { ++counter; }
+    X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
+    ~X() { assert(magic == 7654321); magic = 6666666; x = 9999; --counter; }
+
+    void set(int x) { assert(magic == 7654321); this->x = x; }
+    int value() const { assert(magic == 7654321); return x; }
+    static int count() { return counter; }
+ private:
+    void operator=(X const&);
+ private:
+    int x;
+    long magic;
+    static int counter;
+};
+
+X apply_X_X(PyObject* f, X x)
+{
+    return returning<X>::call(f, x);
+}
+
+void apply_void_X_ref(PyObject* f, X x)
+{
+    returning<X>::call(f, boost::ref(x));
+}
+
+int X::counter;
+
+BOOST_PYTHON_MODULE_INIT(callbacks_ext)
+{
+    boost::python::module("callbacks_ext")
+        .def("apply_int_int", apply_int_int)
+        .def("apply_void_int", apply_void_int)
+        .def("apply_X_X", apply_X_X)
+        .def("apply_void_X_ref", apply_void_X_ref)
+        .add(
+            class_<X>("X")
+            .def_init(args<int>())
+            .def_init(args<X const&>())
+            .def("value", &X::value)
+            .def("set", &X::set)
+            )
+        .def("x_count", &X::count)
+        ;
+}
+
+
+
diff --git a/test/callbacks.py b/test/callbacks.py
new file mode 100644
index 00000000..16c5be94
--- /dev/null
+++ b/test/callbacks.py
@@ -0,0 +1,43 @@
+'''
+>>> from callbacks_ext import *
+
+>>> def double(x):
+...     return x + x
+...
+>>> apply_int_int(double, 42)
+84
+>>> apply_void_int(double, 42)
+
+>>> def identity(x):
+...     return x
+
+>>> x = apply_X_X(identity, X(42))
+>>> x.value()
+42
+>>> x_count()
+1
+>>> del x
+>>> x_count()
+0
+
+>>> def increment(x):
+...     x.set(x.value() + 1)
+...
+>>> x = X(42)
+>>> apply_void_X_ref(increment, x)
+>>> x.value()
+43
+'''
+
+def run(args = None):
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    return doctest.testmod(sys.modules.get(__name__))
+    
+if __name__ == '__main__':
+    print "running..."
+    import sys
+    sys.exit(run()[0])

From 305469472619b2f22dae6c43a9fdb0e40c661ba7 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Mar 2002 16:05:17 +0000
Subject: [PATCH 331/369] conformance fix

[SVN r13138]
---
 include/boost/python/converter/from_python_data.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index 9fa9410a..dd0a0282 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -197,12 +197,10 @@ inline rvalue_data<T>::rvalue_data(void* convertible)
 template <class T>
 inline rvalue_data<T>::~rvalue_data()
 {
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
+
     if (this->stage1.convertible == this->storage.bytes)
-        python::detail::destroy_reference<
-            add_reference<
-                add_cv<T>::type
-            >::type
-        >(storage.bytes);
+        python::detail::destroy_reference<ref_type>(this->storage.bytes);
 }
 
 }}} // namespace boost::python::converter

From 7e76c855356009ceb5d589a9fe8bcb382169d498 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Mar 2002 16:13:32 +0000
Subject: [PATCH 332/369] initial checkin

[SVN r13139]
---
 include/boost/python/converter/callback.hpp | 113 ++++++++++++++
 include/boost/python/returning.hpp          | 159 ++++++++++++++++++++
 2 files changed, 272 insertions(+)
 create mode 100644 include/boost/python/converter/callback.hpp
 create mode 100644 include/boost/python/returning.hpp

diff --git a/include/boost/python/converter/callback.hpp b/include/boost/python/converter/callback.hpp
new file mode 100644
index 00000000..3e1e462e
--- /dev/null
+++ b/include/boost/python/converter/callback.hpp
@@ -0,0 +1,113 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CALLBACK_DWA2002228_HPP
+# define CALLBACK_DWA2002228_HPP
+
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/python/converter/callback_to_python_base.hpp>
+# include <boost/python/converter/callback_from_python_base.hpp>
+# include <boost/python/converter/builtin_converters.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  template <class T>
+  struct pointer_callback_from_python
+  {
+      pointer_callback_from_python();
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct reference_callback_from_python
+  {
+      reference_callback_from_python();
+      T operator()(PyObject*) const;
+  };
+  
+  template <class T>
+  struct rvalue_callback_from_python
+  {
+      rvalue_callback_from_python();
+      T const& operator()(PyObject*);
+   private:
+      rvalue_data<T> m_data;
+  };
+  
+  template <class T>
+  struct select_callback_from_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+    
+      BOOST_STATIC_CONSTANT(
+          bool, ref = is_reference<T>::value);
+
+      typedef typename mpl::select_type<
+          ptr
+          , pointer_callback_from_python<T>
+          , typename mpl::select_type<
+              ref
+              , reference_callback_from_python<T>
+              , rvalue_callback_from_python<T>
+            >::type
+          >::type type;
+  };
+
+
+  template <class T>
+  struct reference_callback_to_python
+  {
+      
+  };
+}
+
+template <class T>
+struct callback_from_python
+    : detail::select_callback_from_python<T>::type
+{
+};
+
+template <class T>
+struct callback_to_python : detail::callback_to_python_base
+{
+ public: // member functions
+    // Throw an exception if the conversion can't succeed
+    callback_to_python(T const&);
+};
+
+//
+// Implementations
+//
+namespace detail
+{
+  template <class T>
+  rvalue_callback_from_python<T>::rvalue_callback_from_python()
+      : m_data(rvalue_from_python_chain<T>::value)
+  {
+      throw_if_not_registered(m_data.stage1);
+  }
+  
+  template <class T>
+  T const& rvalue_callback_from_python<T>::operator()(PyObject* obj)
+  {
+      return *(T*)convert_rvalue(obj, m_data.stage1, m_data.storage.bytes);
+  }
+}
+
+template <class T>
+callback_to_python<T>::callback_to_python(T const& x)
+    : callback_to_python_base(&x, to_python_function<T>::value)
+{
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_DWA2002228_HPP
diff --git a/include/boost/python/returning.hpp b/include/boost/python/returning.hpp
new file mode 100644
index 00000000..c34f97f6
--- /dev/null
+++ b/include/boost/python/returning.hpp
@@ -0,0 +1,159 @@
+//  (C) Copyright David Abrahams 2001,2002. Permission to copy, use, modify, sell
+//  and distribute this software is granted provided this copyright notice appears
+//  in all copies. This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+//  This work was funded in part by Lawrence Berkeley National Labs
+//
+//  This file generated for 5-argument member functions and 6-argument free
+//  functions by gen_returning.py
+
+#ifndef RETURNING_DWA20020228_HPP
+# define RETURNING_DWA20020228_HPP
+
+# include <boost/config.hpp>
+# include <boost/python/converter/callback.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/reference.hpp>
+
+namespace boost { namespace python {
+
+// Calling C++ from Python
+template <class R>
+struct returning
+{
+    static R call(char const* name, PyObject* self)
+    {
+        converter::callback_from_python<R> cr;
+        return cr(PyEval_CallMethod(
+                      self
+                      , const_cast<char*>(name)
+                      , const_cast<char*>("()")
+                      ));
+    }
+    
+    static R call(PyObject* self)
+    {
+        converter::callback_from_python<R> cr;
+        return cr(PyEval_CallFunction(self, const_cast<char*>("()")
+                      ));
+    }
+
+    template <class A1>
+    static R call_method(PyObject* self, const char* name, A1 const& a1)
+    {
+        converter::callback_from_python<R> cr;
+        return cr(PyEval_CallMethod(
+                      self
+                      , const_cast<char*>(name)
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      ));
+    }
+
+    template <class A1>
+    static R call(PyObject* self, A1 const& a1)
+    {
+        converter::callback_from_python<R> cr;
+        return cr(PyEval_CallFunction(
+                      self
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      ));
+    }
+
+    template <class A1, class A2>
+    static R call_method(PyObject* self, const char* name, A1 const& a1, A2 const& a2)
+    {
+        converter::callback_from_python<R> cr;
+        return cr(PyEval_CallMethod(
+                      self
+                      , const_cast<char*>(name)
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      , converter::callback_to_python<A2>(a2).get()
+                      ));
+    }
+
+    template <class A1, class A2>
+    static R call(PyObject* self, A1 const& a1, A2 const& a2)
+    {
+        converter::callback_from_python<R> cr;
+        return cr(PyEval_CallFunction(
+                      self
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      , converter::callback_to_python<A2>(a2).get()
+                      ));
+    }
+
+};
+                           
+template <>
+struct returning<void>
+{
+    typedef void R;
+    static R call(char const* name, PyObject* self)
+    {
+        ref x(PyEval_CallMethod(
+                      self
+                      , const_cast<char*>(name)
+                      , const_cast<char*>("()")
+                      ));
+    }
+    
+    static R call(PyObject* self)
+    {
+        ref x(PyEval_CallFunction(self, const_cast<char*>("()")
+                      ));
+    }
+
+    template <class A1>
+    static R call_method(PyObject* self, const char* name, A1 const& a1)
+    {
+        ref x(PyEval_CallMethod(
+                      self
+                      , const_cast<char*>(name)
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      ));
+    }
+
+    template <class A1>
+    static R call(PyObject* self, A1 const& a1)
+    {
+        ref x(PyEval_CallFunction(
+                      self
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      ));
+    }
+
+    template <class A1, class A2>
+    static R call_method(PyObject* self, const char* name, A1 const& a1, A2 const& a2)
+    {
+        ref x(PyEval_CallMethod(
+                      self
+                      , const_cast<char*>(name)
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      , converter::callback_to_python<A2>(a2).get()
+                      ));
+    }
+
+    template <class A1, class A2>
+    static R call(PyObject* self, A1 const& a1, A2 const& a2)
+    {
+        ref x(PyEval_CallFunction(
+                      self
+                      , const_cast<char*>("(O)")
+                      , converter::callback_to_python<A1>(a1).get()
+                      , converter::callback_to_python<A2>(a2).get()
+                      ));
+    }
+};
+
+}} // namespace boost::python
+
+#endif // RETURNING_DWA20020228_HPP
+

From a16d9f91eea41c8cb1dbe1b2a77aa1d84bd6454a Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 8 Mar 2002 16:14:26 +0000
Subject: [PATCH 333/369] Initial checkin

[SVN r13140]
---
 .../converter/callback_from_python_base.hpp   | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 include/boost/python/converter/callback_from_python_base.hpp

diff --git a/include/boost/python/converter/callback_from_python_base.hpp b/include/boost/python/converter/callback_from_python_base.hpp
new file mode 100644
index 00000000..0eeccb0e
--- /dev/null
+++ b/include/boost/python/converter/callback_from_python_base.hpp
@@ -0,0 +1,20 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
+# define CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP
+
+namespace boost { namespace python { namespace converter { 
+
+namespace detail
+{
+  // Throw an exception
+  BOOST_PYTHON_DECL void throw_if_not_registered(rvalue_stage1_data const&);
+  BOOST_PYTHON_DECL void* convert_rvalue(PyObject*, rvalue_stage1_data& data, void* storage);
+}
+
+}}} // namespace boost::python::converter
+
+#endif // CALLBACK_FROM_PYTHON_BASE_DWA200237_HPP

From 7c009e2443e210fa9fffc53d080c68a6d14dd63d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 20:51:43 +0000
Subject: [PATCH 334/369] Added static assertion to be sure it's not used on
 values

[SVN r13146]
---
 include/boost/python/to_python_indirect.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/boost/python/to_python_indirect.hpp b/include/boost/python/to_python_indirect.hpp
index 7b77f5ff..fbbfc6f7 100644
--- a/include/boost/python/to_python_indirect.hpp
+++ b/include/boost/python/to_python_indirect.hpp
@@ -72,6 +72,7 @@ namespace detail
 template <class T, class MakeHolder>
 inline bool to_python_indirect<T,MakeHolder>::convertible()
 {
+    BOOST_STATIC_ASSERT(is_pointer<T>::value || is_reference<T>::value);
     return type() != 0;
 }
 

From 0301d4462b8c9a90a7b157c9cfe2da336e94373b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 21:01:36 +0000
Subject: [PATCH 335/369] Added reference, deep and shallow pointer to_python
 conversions

[SVN r13147]
---
 include/boost/python/converter/callback.hpp | 121 ++++++++++++++++++--
 1 file changed, 112 insertions(+), 9 deletions(-)

diff --git a/include/boost/python/converter/callback.hpp b/include/boost/python/converter/callback.hpp
index 3e1e462e..756466e3 100644
--- a/include/boost/python/converter/callback.hpp
+++ b/include/boost/python/converter/callback.hpp
@@ -8,11 +8,15 @@
 
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/converter/to_python_function.hpp>
+# include <boost/python/converter/pointee_to_python_function.hpp>
 # include <boost/python/converter/from_python.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/python/converter/callback_to_python_base.hpp>
 # include <boost/python/converter/callback_from_python_base.hpp>
 # include <boost/python/converter/builtin_converters.hpp>
+# include <boost/python/to_python_indirect.hpp>
+# include <boost/python/detail/none.hpp>
+# include <boost/python/ptr.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -63,9 +67,64 @@ namespace detail
 
 
   template <class T>
-  struct reference_callback_to_python
+  struct reference_callback_to_python : callback_to_python_holder
   {
+      reference_callback_to_python(T& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct value_callback_to_python : callback_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      value_callback_to_python(T const&);
+  };
+
+  template <class Ptr>
+  struct pointer_deep_callback_to_python : callback_to_python_base
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_deep_callback_to_python(Ptr);
+  };
+
+  template <class Ptr>
+  struct pointer_shallow_callback_to_python : callback_to_python_holder
+  {
+      // Throw an exception if the conversion can't succeed
+      pointer_shallow_callback_to_python(Ptr);
+   private:
+      static PyObject* get_object(Ptr p);
+  };
+
+  template <class T>
+  struct select_callback_to_python
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
       
+      BOOST_STATIC_CONSTANT(
+          bool, ref_wrapper = is_reference_wrapper<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr_wrapper = is_pointer_wrapper<T>::value);
+
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::select_type<
+          ptr
+          , pointer_deep_callback_to_python<T>
+          , typename mpl::select_type<
+              ptr_wrapper
+              , pointer_shallow_callback_to_python<unwrapped_ptr>
+              , typename mpl::select_type<
+                  ref_wrapper
+                  , reference_callback_to_python<unwrapped_referent>
+                  , value_callback_to_python<T>
+                >::type
+            >::type
+        >::type type;
   };
 }
 
@@ -76,11 +135,13 @@ struct callback_from_python
 };
 
 template <class T>
-struct callback_to_python : detail::callback_to_python_base
+struct callback_to_python
+    : detail::select_callback_to_python<T>::type
 {
+    typedef typename detail::select_callback_to_python<T>::type base;
  public: // member functions
     // Throw an exception if the conversion can't succeed
-    callback_to_python(T const&);
+    callback_to_python(T const& x);
 };
 
 //
@@ -89,24 +150,66 @@ struct callback_to_python : detail::callback_to_python_base
 namespace detail
 {
   template <class T>
-  rvalue_callback_from_python<T>::rvalue_callback_from_python()
+  inline rvalue_callback_from_python<T>::rvalue_callback_from_python()
       : m_data(rvalue_from_python_chain<T>::value)
   {
       throw_if_not_registered(m_data.stage1);
   }
   
   template <class T>
-  T const& rvalue_callback_from_python<T>::operator()(PyObject* obj)
+  inline T const& rvalue_callback_from_python<T>::operator()(PyObject* obj)
   {
       return *(T*)convert_rvalue(obj, m_data.stage1, m_data.storage.bytes);
   }
+
+  BOOST_PYTHON_DECL void throw_no_class_registered();
+
+  template <class T>
+  inline value_callback_to_python<T>::value_callback_to_python(T const& x)
+      : callback_to_python_base(&x, to_python_function<T>::value)
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_deep_callback_to_python<Ptr>::pointer_deep_callback_to_python(Ptr x)
+      : callback_to_python_base(x, pointee_to_python_function<Ptr>::value)
+  {
+  }
+
+  template <class T>
+  inline PyObject* reference_callback_to_python<T>::get_object(T& x)
+  {
+      to_python_indirect<T&,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return convert(x);
+  }
+
+  template <class T>
+  inline reference_callback_to_python<T>::reference_callback_to_python(T& x)
+      : callback_to_python_holder(get_object(x))
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_shallow_callback_to_python<Ptr>::pointer_shallow_callback_to_python(Ptr x)
+      : callback_to_python_holder(get_object(x))
+  {}
+
+  template <class Ptr>
+  inline PyObject* pointer_shallow_callback_to_python<Ptr>::get_object(Ptr x)
+  {
+      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
+      if (!convert.convertible())
+          throw_no_class_registered();
+      return x ? convert(x) : python::detail::none();
+  }
 }
 
 template <class T>
-callback_to_python<T>::callback_to_python(T const& x)
-    : callback_to_python_base(&x, to_python_function<T>::value)
-{
-}
+inline callback_to_python<T>::callback_to_python(T const& x)
+    : base(x)
+{}
 
 }}} // namespace boost::python::converter
 

From 69d7011baf1ed100df3bc5585278c27c00f8d1c5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 21:02:18 +0000
Subject: [PATCH 336/369] Killed bogus #include

[SVN r13148]
---
 include/boost/python/converter/from_python.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index 5fe8901a..03bfcb26 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -10,7 +10,6 @@
 # include <boost/python/detail/wrap_python.hpp>
 # include <boost/type_traits/transform_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
-# include <boost/python/converter/pointer_type_id.hpp>
 # include <boost/python/converter/from_python_data.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/python/converter/registry.hpp>

From 74fe5bc4dd45dcb852a2d4c2487f799e522a3aea Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 21:05:18 +0000
Subject: [PATCH 337/369] Killed bogus #include msvc6 workaround

[SVN r13149]
---
 include/boost/python/converter/from_python_data.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/include/boost/python/converter/from_python_data.hpp b/include/boost/python/converter/from_python_data.hpp
index dd0a0282..1ce8bd7a 100644
--- a/include/boost/python/converter/from_python_data.hpp
+++ b/include/boost/python/converter/from_python_data.hpp
@@ -15,7 +15,6 @@
 # include <boost/python/converter/from_python_stage1_data.hpp>
 # include <boost/type_traits/composite_traits.hpp>
 # include <boost/type_traits/cv_traits.hpp>
-# include <boost/type_traits/ice.hpp>
 # include <boost/python/detail/destroy.hpp>
 # include <boost/preprocessor/list/for_each_i.hpp>
 # include <boost/preprocessor/tuple/to_list.hpp>
@@ -177,6 +176,8 @@ struct rvalue_data : rvalue_base_data<T>
     rvalue_data(rvalue_stage1_data const&);
     rvalue_data(void*);
     ~rvalue_data();
+ private:
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
 };
 
 //
@@ -197,8 +198,6 @@ inline rvalue_data<T>::rvalue_data(void* convertible)
 template <class T>
 inline rvalue_data<T>::~rvalue_data()
 {
-    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
-
     if (this->stage1.convertible == this->storage.bytes)
         python::detail::destroy_reference<ref_type>(this->storage.bytes);
 }

From 22f66123541e90f825519712ed7c13a25e9312ad Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 21:08:04 +0000
Subject: [PATCH 338/369] Killed ambiguity-causing overload

[SVN r13150]
---
 include/boost/python/detail/unwind_type.hpp | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/include/boost/python/detail/unwind_type.hpp b/include/boost/python/detail/unwind_type.hpp
index e8ccd0c8..72ebef71 100644
--- a/include/boost/python/detail/unwind_type.hpp
+++ b/include/boost/python/detail/unwind_type.hpp
@@ -68,13 +68,6 @@ struct unwind_helper<false>
     }
 };
 
-template <class Generator, class U>
-inline typename Generator::result_type
-unwind_type(U& p, Generator* = 0)
-{
-    return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
-}
-
 template <class Generator, class U>
 inline typename Generator::result_type
 unwind_type(U const& p, Generator* = 0)

From f271726cd8687370551587e95a92a6b977d136d9 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 21:13:09 +0000
Subject: [PATCH 339/369] Added reference, deep and shallow pointer to_python
 conversions

[SVN r13152]
---
 .../converter/pointee_to_python_function.hpp  | 51 +++++++++++++++++++
 src/converter/callback.cpp                    | 14 ++++-
 test/callbacks.cpp                            | 26 ++++++++--
 test/callbacks.py                             | 39 ++++++++++++++
 4 files changed, 125 insertions(+), 5 deletions(-)
 create mode 100644 include/boost/python/converter/pointee_to_python_function.hpp

diff --git a/include/boost/python/converter/pointee_to_python_function.hpp b/include/boost/python/converter/pointee_to_python_function.hpp
new file mode 100644
index 00000000..0f1ae99e
--- /dev/null
+++ b/include/boost/python/converter/pointee_to_python_function.hpp
@@ -0,0 +1,51 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+# define POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
+
+# include <boost/python/detail/wrap_python.hpp>
+# include <boost/type_traits/transform_traits.hpp>
+# include <boost/type_traits/cv_traits.hpp>
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+# include <boost/python/converter/to_python_function_type.hpp>
+# include <boost/python/converter/pointer_type_id.hpp>
+
+namespace boost { namespace python { namespace converter { 
+
+// pointee_to_python_function --
+//
+// essentially a "templated global reference" which holds the
+// converter for converting a type to Python by-value. We "normalize"
+// T by adding "const volatile&" so that fewer global variables and
+// associated static initializations are generated.
+namespace detail
+{
+  template <class T>
+  struct pointee_to_python_function_base
+  {
+      static to_python_function_t const& value;
+  };
+  
+  template <class T>
+  to_python_function_t const&
+  pointee_to_python_function_base<T>::value
+        = converter::registry::get_to_python_function(pointer_type_id<T>());
+}
+
+template <class T>
+struct pointee_to_python_function
+    : detail::pointee_to_python_function_base<
+        typename add_reference<
+          typename add_cv<T>::type
+        >::type
+      >
+{
+};
+
+}}} // namespace boost::python::converter
+
+#endif // POINTEE_TO_PYTHON_FUNCTION_DWA2002128_HPP
diff --git a/src/converter/callback.cpp b/src/converter/callback.cpp
index b3158500..a248f1ad 100644
--- a/src/converter/callback.cpp
+++ b/src/converter/callback.cpp
@@ -8,6 +8,7 @@
 #include <boost/python/errors.hpp>
 #include <boost/python/converter/find_from_python.hpp>
 #include <boost/python/reference.hpp>
+#include <boost/python/detail/none.hpp>
 
 namespace boost { namespace python { namespace converter { 
 
@@ -25,7 +26,10 @@ namespace detail
                 , const_cast<char*>("no to_python (by-value) converter found for type"));
             throw error_already_set();
         }
-        return converter(const_cast<void*>(source));
+        
+        return source == 0
+            ? python::detail::none()
+            : converter(const_cast<void*>(source));
     }
   }
   
@@ -45,6 +49,14 @@ namespace detail
           throw error_already_set();
       }
   }
+
+  BOOST_PYTHON_DECL void throw_no_class_registered()
+  {
+      PyErr_SetString(
+          PyExc_TypeError
+          , const_cast<char*>("class not registered for to_python type"));
+      throw error_already_set();
+  }
   
   BOOST_PYTHON_DECL void* convert_rvalue(PyObject* src, rvalue_stage1_data& data, void* storage)
   {
diff --git a/test/callbacks.cpp b/test/callbacks.cpp
index 9991e41f..2bf285b5 100644
--- a/test/callbacks.cpp
+++ b/test/callbacks.cpp
@@ -7,6 +7,7 @@
 #include <boost/python/returning.hpp>
 #include <boost/python/class.hpp>
 #include <boost/ref.hpp>
+#include <boost/python/ptr.hpp>
 
 using namespace boost::python;
 
@@ -42,9 +43,24 @@ X apply_X_X(PyObject* f, X x)
     return returning<X>::call(f, x);
 }
 
-void apply_void_X_ref(PyObject* f, X x)
+void apply_void_X_ref(PyObject* f, X& x)
 {
-    returning<X>::call(f, boost::ref(x));
+    returning<void>::call(f, boost::ref(x));
+}
+
+void apply_void_X_cref(PyObject* f, X const& x)
+{
+    returning<void>::call(f, boost::cref(x));
+}
+
+void apply_void_X_ptr(PyObject* f, X* x)
+{
+    returning<void>::call(f, ptr(x));
+}
+
+void apply_void_X_deep_ptr(PyObject* f, X* x)
+{
+    returning<void>::call(f, x);
 }
 
 int X::counter;
@@ -56,6 +72,9 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)
         .def("apply_void_int", apply_void_int)
         .def("apply_X_X", apply_X_X)
         .def("apply_void_X_ref", apply_void_X_ref)
+        .def("apply_void_X_cref", apply_void_X_cref)
+        .def("apply_void_X_ptr", apply_void_X_ptr)
+        .def("apply_void_X_deep_ptr", apply_void_X_deep_ptr)
         .add(
             class_<X>("X")
             .def_init(args<int>())
@@ -67,5 +86,4 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)
         ;
 }
 
-
-
+#include "module_tail.cpp"
diff --git a/test/callbacks.py b/test/callbacks.py
index 16c5be94..810aad53 100644
--- a/test/callbacks.py
+++ b/test/callbacks.py
@@ -27,6 +27,45 @@
 >>> apply_void_X_ref(increment, x)
 >>> x.value()
 43
+
+>>> apply_void_X_cref(increment, x) 
+>>> x.value()  # const-ness is not respected, sorry!
+44
+
+>>> last_x = 1
+>>> def decrement(x):
+...     global last_x
+...     last_x = x
+...     if x is not None:
+...         x.set(x.value() - 1)
+
+>>> apply_void_X_ptr(decrement, x)
+>>> x.value()
+43
+>>> last_x.value()
+43
+>>> increment(last_x)
+>>> x.value()
+44
+>>> last_x.value()
+44
+
+>>> apply_void_X_ptr(decrement, None)
+>>> assert last_x is None
+>>> x.value()
+44
+
+>>> last_x = 1
+>>> apply_void_X_deep_ptr(decrement, None)
+>>> assert last_x is None
+>>> x.value()
+44
+
+>>> apply_void_X_deep_ptr(decrement, x)
+>>> x.value()
+44
+>>> last_x.value()
+43
 '''
 
 def run(args = None):

From 5da8206915a4d4fabc0659f88c8b1a620eef85d7 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 21:13:26 +0000
Subject: [PATCH 340/369] initial checkin

[SVN r13153]
---
 include/boost/python/ptr.hpp | 127 +++++++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 include/boost/python/ptr.hpp

diff --git a/include/boost/python/ptr.hpp b/include/boost/python/ptr.hpp
new file mode 100644
index 00000000..4e0f067e
--- /dev/null
+++ b/include/boost/python/ptr.hpp
@@ -0,0 +1,127 @@
+#ifndef BOOST_PTR_HPP_INCLUDED
+# define BOOST_PTR_HPP_INCLUDED
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+//
+// Based on boost/ref.hpp, thus:
+//  Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 2001 Peter Dimov
+
+# if _MSC_VER+0 >= 1020
+#  pragma once
+# endif
+
+# include <boost/config.hpp>
+
+namespace boost { namespace python {
+
+template<class Ptr> class pointer_wrapper
+{ 
+ public:
+    typedef Ptr type;
+    
+    explicit pointer_wrapper(Ptr x): p_(x) {}
+    operator Ptr() const { return p_; }
+    Ptr get() const { return p_; }
+ private:
+    Ptr p_;
+};
+
+template<class T>
+inline pointer_wrapper<T> ptr(T t)
+{ 
+    return pointer_wrapper<T>(t);
+}
+
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<typename T>
+class is_pointer_wrapper
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = false); 
+};
+
+template<typename T>
+class is_pointer_wrapper<pointer_wrapper<T> >
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+
+template<typename T>
+class unwrap_pointer
+{
+ public:
+    typedef T type;
+};
+
+template<typename T>
+class unwrap_pointer<pointer_wrapper<T> >
+{
+ public:
+    typedef T type;
+};
+# else // no partial specialization
+
+}} // namespace boost::python
+
+#include <boost/type.hpp>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  typedef char (&yes_pointer_wrapper_t)[1];
+  typedef char (&no_pointer_wrapper_t)[2];
+      
+  no_pointer_wrapper_t is_pointer_wrapper_test(...);
+
+  template<typename T>
+  yes_pointer_wrapper_t is_pointer_wrapper_test(type< pointer_wrapper<T> >);
+
+  template<bool wrapped>
+  struct pointer_unwrapper
+  {
+      template <class T>
+      struct apply
+      {
+          typedef T type;
+      };
+  };
+
+  template<>
+  struct pointer_unwrapper<true>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::type type;
+      };
+  };
+}
+
+template<typename T>
+class is_pointer_wrapper
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_pointer_wrapper_test(type<T>()))
+            == sizeof(detail::yes_pointer_wrapper_t)));
+};
+
+template <typename T>
+class unwrap_pointer
+    : public detail::pointer_unwrapper<
+        is_pointer_wrapper<T>::value
+      >::template apply<T>
+{};
+
+# endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+}} // namespace boost::python
+
+#endif // #ifndef BOOST_PTR_HPP_INCLUDED

From 74078552df235f7adf34d8f397387d072bd2608b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sat, 9 Mar 2002 23:59:04 +0000
Subject: [PATCH 341/369] Improved error messages Added support for
 pointer/reference returns

[SVN r13154]
---
 src/converter/callback.cpp | 43 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/src/converter/callback.cpp b/src/converter/callback.cpp
index a248f1ad..68ea32f1 100644
--- a/src/converter/callback.cpp
+++ b/src/converter/callback.cpp
@@ -45,11 +45,50 @@ namespace detail
       {
           PyErr_SetString(
               PyExc_TypeError
-              , const_cast<char*>("no from_python (by-value) converters found for type"));
+              , const_cast<char*>("no from_python rvalue or lvalue converters found for type"));
           throw error_already_set();
       }
   }
 
+  BOOST_PYTHON_DECL void throw_if_not_registered(lvalue_from_python_registration*const& x)
+  {
+      if (!x)
+      {
+          PyErr_SetString(
+              PyExc_TypeError
+              , const_cast<char*>("no from_python lvalue converters found for type"));
+          throw error_already_set();
+      }
+  }
+
+  BOOST_PYTHON_DECL void* callback_convert_reference(
+      PyObject* source
+      , lvalue_from_python_registration*const& converters)
+  {
+      ref holder(source);
+      void* result = find(source, converters);
+      if (!result)
+      {
+          PyErr_SetString(
+              PyExc_TypeError
+              , const_cast<char*>("no registered from_python lvalue converter was able to convert object"));
+          throw error_already_set();
+      }
+      return result;
+  }
+  
+  BOOST_PYTHON_DECL void* callback_convert_pointer(
+      PyObject* source
+      , lvalue_from_python_registration*const& converters)
+  {
+      if (source == Py_None)
+      {
+          Py_DECREF(source);
+          return 0;
+      }
+      return callback_convert_reference(source, converters);
+  }
+  
   BOOST_PYTHON_DECL void throw_no_class_registered()
   {
       PyErr_SetString(
@@ -68,7 +107,7 @@ namespace detail
       {
           PyErr_SetString(
               PyExc_TypeError
-              , const_cast<char*>("no registered from_python (by-value) converter was able to convert type"));
+              , const_cast<char*>("no registered from_python lvalue or rvalue converter was able to convert object"));
           throw error_already_set();
       }
       if (data.construct != 0)

From ae1c1b3a47e7a76d572ce13e8aa473d5c8ff9e06 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:25:09 +0000
Subject: [PATCH 342/369] Improved None <==> NULL correspondence

[SVN r13155]
---
 include/boost/python/to_python_indirect.hpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/include/boost/python/to_python_indirect.hpp b/include/boost/python/to_python_indirect.hpp
index fbbfc6f7..a636ff66 100644
--- a/include/boost/python/to_python_indirect.hpp
+++ b/include/boost/python/to_python_indirect.hpp
@@ -67,6 +67,22 @@ namespace detail
           return python::objects::class_object<T>::reference;
       }
   };
+
+  // null_pointer_to_none -- return none() for null pointers and 0 for all other types/values
+  // 
+  // Uses simulated partial ordering
+  template <class T>
+  inline PyObject* null_pointer_to_none(T&, int)
+  {
+      return 0;
+  }
+
+  // overload for pointers
+  template <class T>
+  inline PyObject* null_pointer_to_none(T* x, long)
+  {
+      return x == 0 ? python::detail::none() : 0;
+  }
 }
 
 template <class T, class MakeHolder>
@@ -79,6 +95,10 @@ inline bool to_python_indirect<T,MakeHolder>::convertible()
 template <class T, class MakeHolder>
 inline PyObject* to_python_indirect<T,MakeHolder>::operator()(T x) const
 {
+    PyObject* const null_result = detail::null_pointer_to_none(x, 1L);
+    if (null_result != 0)
+        return null_result;
+    
     PyObject* raw_result = type()->tp_alloc(type(), 0);
 
     if (raw_result == 0)

From 7eb42dc36b02149979fac59a28a3477b758cae51 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:26:11 +0000
Subject: [PATCH 343/369] factored out void_ptr manipulations

[SVN r13156]
---
 include/boost/python/type_from_python.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/boost/python/type_from_python.hpp b/include/boost/python/type_from_python.hpp
index 16b8da81..d5b9faed 100644
--- a/include/boost/python/type_from_python.hpp
+++ b/include/boost/python/type_from_python.hpp
@@ -7,6 +7,7 @@
 # define TYPE_FROM_PYTHON_DWA2002130_HPP
 
 # include <boost/python/converter/registry.hpp>
+# include <boost/python/detail/void_ptr.hpp>
 
 namespace boost { namespace python {
 
@@ -31,7 +32,7 @@ namespace detail
       {
           typedef typename boost::add_reference<U>::type param;
           return &Extractor::execute(
-              boost::python::converter::detail::void_ptr_to_reference(
+              boost::python::detail::void_ptr_to_reference(
                   op, (param(*)())0 )
               );
       }

From 688c64ce2118e2231a93adbfe75a8c8cf81a644f Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:29:05 +0000
Subject: [PATCH 344/369] char conversions Handle dangling references

[SVN r13157]
---
 .../python/converter/builtin_converters.hpp   | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/include/boost/python/converter/builtin_converters.hpp b/include/boost/python/converter/builtin_converters.hpp
index 4db0eb9c..c0d2ba09 100644
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -27,9 +27,13 @@ namespace detail
 namespace converter
 {
   template <class T> struct callback_to_python;
+  BOOST_PYTHON_DECL PyObject* do_call_to_python(char);
+  BOOST_PYTHON_DECL PyObject* do_call_to_python(char const*);
+  BOOST_PYTHON_DECL PyObject* do_call_to_python(PyObject*);
+  BOOST_PYTHON_DECL PyObject* do_callback_to_python(PyObject*);
 }
 
-# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)   \
+# define BOOST_PYTHON_CALL_TO_PYTHON_BY_VALUE(T, expr)   \
     template <> struct to_python_value<T&>          \
         : detail::builtin_to_python                 \
     {                                               \
@@ -45,7 +49,9 @@ namespace converter
         {                                           \
             return (expr);                          \
         }                                           \
-    };                                              \
+    };
+
+# define BOOST_PYTHON_CALLBACK_TO_PYTHON_BY_VALUE(T, expr)   \
     namespace converter                             \
     {                                               \
       template <> struct callback_to_python< T >    \
@@ -57,8 +63,11 @@ namespace converter
        private:                                     \
           ref m_held;                               \
       };                                            \
-    }                                               
+    } 
 
+# define BOOST_PYTHON_TO_PYTHON_BY_VALUE(T, expr)   \
+        BOOST_PYTHON_CALL_TO_PYTHON_BY_VALUE(T,expr) \
+        BOOST_PYTHON_CALLBACK_TO_PYTHON_BY_VALUE(T,expr)
 
 # define BOOST_PYTHON_TO_INT(T)                                         \
     BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, PyInt_FromLong(x))        \
@@ -71,12 +80,14 @@ BOOST_PYTHON_TO_INT(int)
 BOOST_PYTHON_TO_INT(long)
 # undef BOOST_TO_PYTHON_INT
 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, x ? PyString_FromString(x) : boost::python::detail::none())
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_call_to_python(x))
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_call_to_python(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, PyString_FromString(x.c_str()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, PyFloat_FromDouble(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(long double, PyFloat_FromDouble(x))
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(PyObject*, (x ? x : boost::python::detail::none()))
+BOOST_PYTHON_CALL_TO_PYTHON_BY_VALUE(PyObject*, converter::do_call_to_python(x))
+BOOST_PYTHON_CALLBACK_TO_PYTHON_BY_VALUE(PyObject*, converter::do_callback_to_python(x))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<float>, PyComplex_FromDoubles(x.real(), x.imag()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<double>, PyComplex_FromDoubles(x.real(), x.imag()))
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::complex<long double>, PyComplex_FromDoubles(x.real(), x.imag()))

From 3447aaa8c67c3a648f2af72473bd2ac7c7f542df Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:32:07 +0000
Subject: [PATCH 345/369] Pointer/reference from_python callback conversions

[SVN r13158]
---
 include/boost/python/converter/callback.hpp   | 26 +++++++++++++++++++
 .../converter/callback_from_python_base.hpp   |  5 ++++
 2 files changed, 31 insertions(+)

diff --git a/include/boost/python/converter/callback.hpp b/include/boost/python/converter/callback.hpp
index 756466e3..a8fceb53 100644
--- a/include/boost/python/converter/callback.hpp
+++ b/include/boost/python/converter/callback.hpp
@@ -164,6 +164,32 @@ namespace detail
 
   BOOST_PYTHON_DECL void throw_no_class_registered();
 
+  template <class T>
+  inline reference_callback_from_python<T>::reference_callback_from_python()
+  {
+      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
+  }
+  
+  template <class T>
+  inline T reference_callback_from_python<T>::operator()(PyObject* obj) const
+  {
+      return python::detail::void_ptr_to_reference(
+          callback_convert_reference(obj, lvalue_from_python_chain<T,true>::value)
+          , (T(*)())0);
+  }
+
+  template <class T>
+  inline pointer_callback_from_python<T>::pointer_callback_from_python()
+  {
+      detail::throw_if_not_registered(lvalue_from_python_chain<T,true>::value);
+  }
+  
+  template <class T>
+  inline T pointer_callback_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(callback_convert_pointer(obj, lvalue_from_python_chain<T,true>::value));
+  }
+
   template <class T>
   inline value_callback_to_python<T>::value_callback_to_python(T const& x)
       : callback_to_python_base(&x, to_python_function<T>::value)
diff --git a/include/boost/python/converter/callback_from_python_base.hpp b/include/boost/python/converter/callback_from_python_base.hpp
index 0eeccb0e..117ba145 100644
--- a/include/boost/python/converter/callback_from_python_base.hpp
+++ b/include/boost/python/converter/callback_from_python_base.hpp
@@ -10,9 +10,14 @@ namespace boost { namespace python { namespace converter {
 
 namespace detail
 {
+
   // Throw an exception
   BOOST_PYTHON_DECL void throw_if_not_registered(rvalue_stage1_data const&);
   BOOST_PYTHON_DECL void* convert_rvalue(PyObject*, rvalue_stage1_data& data, void* storage);
+  
+  BOOST_PYTHON_DECL void throw_if_not_registered(lvalue_from_python_registration*const&);
+  BOOST_PYTHON_DECL void* callback_convert_reference(PyObject*, lvalue_from_python_registration*const&);
+  BOOST_PYTHON_DECL void* callback_convert_pointer(PyObject*, lvalue_from_python_registration*const&);
 }
 
 }}} // namespace boost::python::converter

From 948cde1a312e2a777d5fcf2fd1c24f2cfd9cf6fd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:33:13 +0000
Subject: [PATCH 346/369] factored out void_ptr manipulations

[SVN r13159]
---
 .../boost/python/converter/from_python.hpp    | 32 ++++---------------
 1 file changed, 6 insertions(+), 26 deletions(-)

diff --git a/include/boost/python/converter/from_python.hpp b/include/boost/python/converter/from_python.hpp
index 03bfcb26..1c6a8b3c 100644
--- a/include/boost/python/converter/from_python.hpp
+++ b/include/boost/python/converter/from_python.hpp
@@ -15,6 +15,7 @@
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/converter/lvalue_from_python_chain.hpp>
 # include <boost/python/converter/rvalue_from_python_chain.hpp>
+# include <boost/python/detail/void_ptr.hpp>
 
 namespace boost { namespace python { namespace converter {
 
@@ -143,12 +144,6 @@ inline void*const& from_python_base::result() const
 
 namespace detail
 {
-  template <class U>
-  inline U& void_ptr_to_reference(void const volatile* p, U&(*)())
-  {
-      return *(U*)p;
-  }
-
   template <class T>
   struct null_ptr_owner
   {
@@ -161,27 +156,12 @@ namespace detail
   {
       return null_ptr_owner<U>::value;
   }
-
-  template <class T>
-  inline void write_void_ptr(void const volatile* storage, void* ptr, T*)
-  {
-      *(T**)storage = (T*)ptr;
-  }
-
-  // writes U(ptr) into the storage
-  template <class U>
-  inline void write_void_ptr_reference(void const volatile* storage, void* ptr, U&(*)())
-  {
-      // stripping CV qualification suppresses warnings on older EDGs
-      typedef typename remove_cv<U>::type u_stripped; 
-      write_void_ptr(storage, ptr, u_stripped(0));
-  }
 }
 
 template <class T>
 inline pointer_const_reference_from_python<T>::pointer_const_reference_from_python(PyObject* p)
 {
-    detail::write_void_ptr_reference(
+    python::detail::write_void_ptr_reference(
         m_result.bytes
         , p == Py_None ? p : find(p, lvalue_from_python_chain<T>::value)
         , (T(*)())0);
@@ -190,14 +170,14 @@ inline pointer_const_reference_from_python<T>::pointer_const_reference_from_pyth
 template <class T>
 inline bool pointer_const_reference_from_python<T>::convertible() const
 {
-    return detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
+    return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
 }
 template <class T>
 inline T pointer_const_reference_from_python<T>::operator()(PyObject* p) const
 {
     return (p == Py_None)
         ? detail::null_ptr_reference((T(*)())0)
-        : detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
+        : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
 }
 
 // --------
@@ -225,7 +205,7 @@ inline reference_from_python<T>::reference_from_python(PyObject* p)
 template <class T>
 inline T reference_from_python<T>::operator()(PyObject*) const
 {
-    return detail::void_ptr_to_reference(result(), (T(*)())0);
+    return python::detail::void_ptr_to_reference(result(), (T(*)())0);
 }
 
 // -------
@@ -249,7 +229,7 @@ rvalue_from_python<T>::operator()(PyObject* p)
     if (m_data.stage1.construct != 0)
         m_data.stage1.construct(p, &m_data.stage1);
     
-    return detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
+    return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
 }
 
 }}} // namespace boost::python::converter

From e589d7f1e1a791b2a554b7a6097140f9c4ee89b8 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:35:59 +0000
Subject: [PATCH 347/369] adjustments for use with callbacks

[SVN r13161]
---
 .../python/converter/lvalue_from_python_chain.hpp | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/include/boost/python/converter/lvalue_from_python_chain.hpp b/include/boost/python/converter/lvalue_from_python_chain.hpp
index f1417460..2a86bcfa 100644
--- a/include/boost/python/converter/lvalue_from_python_chain.hpp
+++ b/include/boost/python/converter/lvalue_from_python_chain.hpp
@@ -14,7 +14,9 @@ namespace boost { namespace python { namespace converter {
 
 // Given T == U*cv&, T == U*, or T == U&, lvalue_from_python_chain<T>
 // declares a "templated global reference" to the lvalue from_python
-// converter chain for U
+// converter chain for U. The optional bool second argument callback,
+// when true, removes special treatment for T == U*cv& so that the
+// converter for U* is found.
 namespace detail
 {
   template <class T>
@@ -39,12 +41,13 @@ namespace detail
   ref_lvalue_from_python_chain<T>::value
      = registry::lvalue_converters(undecorated_type_id<T>());
 
-  template <class T>
+  template <class T, bool callback>
   struct select_lvalue_from_python_chain
   {
       BOOST_STATIC_CONSTANT(
-          bool, ptr = boost::python::detail::is_reference_to_pointer<T>::value
-                      || is_pointer<T>::value);
+          bool, ptr
+          = !callback && boost::python::detail::is_reference_to_pointer<T>::value
+            || is_pointer<T>::value);
 
       typedef typename add_reference<typename add_cv<T>::type>::type normalized;
 
@@ -56,9 +59,9 @@ namespace detail
   };
 }
 
-template <class T>
+template <class T, bool callback = false>
 struct lvalue_from_python_chain
-    : detail::select_lvalue_from_python_chain<T>::type
+    : detail::select_lvalue_from_python_chain<T,callback>::type
 {
 };
 

From a56f66e721476e199d917fb1d23d58a795dabddd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:37:58 +0000
Subject: [PATCH 348/369] Factor to_python guts

[SVN r13162]
---
 src/converter/builtin_converters.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/converter/builtin_converters.cpp b/src/converter/builtin_converters.cpp
index 87d0d7b4..0ded9c78 100644
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -232,6 +232,30 @@ namespace
   };
 } 
 
+BOOST_PYTHON_DECL PyObject* do_call_to_python(char x)
+{
+    return PyString_FromStringAndSize(&x, 1);
+}
+  
+BOOST_PYTHON_DECL PyObject* do_call_to_python(char const* x)
+{
+    return x ? PyString_FromString(x) : boost::python::detail::none();
+}
+  
+BOOST_PYTHON_DECL PyObject* do_call_to_python(PyObject* x)
+{
+    return x ? x : boost::python::detail::none();
+}
+  
+BOOST_PYTHON_DECL PyObject* do_callback_to_python(PyObject* x)
+{
+    if (x == 0)
+        return boost::python::detail::none();
+      
+    Py_INCREF(x);
+    return x;
+}
+
 #define REGISTER_INT_CONVERTERS(U) slot_rvalue_from_python<U,int_rvalue_from_python>()
 #define REGISTER_INT_CONVERTERS2(U) REGISTER_INT_CONVERTERS(signed U); REGISTER_INT_CONVERTERS(unsigned U)  
 

From be6016a97200d651198a187d1321f16475b907fa Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:38:50 +0000
Subject: [PATCH 349/369] Prevent dangling reference returns

[SVN r13163]
---
 src/converter/callback.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/converter/callback.cpp b/src/converter/callback.cpp
index 68ea32f1..0ff0c29a 100644
--- a/src/converter/callback.cpp
+++ b/src/converter/callback.cpp
@@ -66,6 +66,13 @@ namespace detail
       , lvalue_from_python_registration*const& converters)
   {
       ref holder(source);
+      if (source->ob_refcnt <= 2)
+      {
+          PyErr_SetString(
+              PyExc_ReferenceError
+              , const_cast<char*>("Attempt to return dangling internal reference"));
+          throw error_already_set();
+      }
       void* result = find(source, converters);
       if (!result)
       {

From c170b1b83ee11ebc77b54ee2fef01cf98b15e257 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:41:04 +0000
Subject: [PATCH 350/369] char conversions Handle dangling references

[SVN r13164]
---
 test/callbacks.cpp | 38 ++++++++++++++++++++++++++++++++++++++
 test/callbacks.py  | 40 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 78 insertions(+)

diff --git a/test/callbacks.cpp b/test/callbacks.cpp
index 2bf285b5..6d1b8fba 100644
--- a/test/callbacks.cpp
+++ b/test/callbacks.cpp
@@ -8,6 +8,8 @@
 #include <boost/python/class.hpp>
 #include <boost/ref.hpp>
 #include <boost/python/ptr.hpp>
+#include <boost/python/return_value_policy.hpp>
+#include <boost/python/reference_existing_object.hpp>
 
 using namespace boost::python;
 
@@ -48,6 +50,16 @@ void apply_void_X_ref(PyObject* f, X& x)
     returning<void>::call(f, boost::ref(x));
 }
 
+X& apply_X_ref_pyobject(PyObject* f, PyObject* obj)
+{
+    return returning<X&>::call(f, obj);
+}
+
+X* apply_X_ptr_pyobject(PyObject* f, PyObject* obj)
+{
+    return returning<X*>::call(f, obj);
+}
+
 void apply_void_X_cref(PyObject* f, X const& x)
 {
     returning<void>::call(f, boost::cref(x));
@@ -63,6 +75,21 @@ void apply_void_X_deep_ptr(PyObject* f, X* x)
     returning<void>::call(f, x);
 }
 
+char const* apply_cstring_cstring(PyObject* f, char const* s)
+{
+    return returning <char const*>::call(f, s);
+}
+
+char const* apply_cstring_pyobject(PyObject* f, PyObject* s)
+{
+    return returning <char const*>::call(f, s);
+}
+
+char apply_char_char(PyObject* f, char c)
+{
+    return returning <char>::call(f, c);
+}
+
 int X::counter;
 
 BOOST_PYTHON_MODULE_INIT(callbacks_ext)
@@ -75,6 +102,17 @@ BOOST_PYTHON_MODULE_INIT(callbacks_ext)
         .def("apply_void_X_cref", apply_void_X_cref)
         .def("apply_void_X_ptr", apply_void_X_ptr)
         .def("apply_void_X_deep_ptr", apply_void_X_deep_ptr)
+        
+        .def("apply_X_ptr_pyobject", apply_X_ptr_pyobject
+             , return_value_policy<reference_existing_object>())
+        
+        .def("apply_X_ref_pyobject", apply_X_ref_pyobject
+             , return_value_policy<reference_existing_object>())
+        
+        .def("apply_cstring_cstring", apply_cstring_cstring)
+        .def("apply_cstring_pyobject", apply_cstring_pyobject)
+        .def("apply_char_char", apply_char_char)
+        
         .add(
             class_<X>("X")
             .def_init(args<int>())
diff --git a/test/callbacks.py b/test/callbacks.py
index 810aad53..71ad3fb7 100644
--- a/test/callbacks.py
+++ b/test/callbacks.py
@@ -66,6 +66,46 @@
 44
 >>> last_x.value()
 43
+
+>>> y = apply_X_ref_pyobject(identity, x)
+>>> assert y.value() == x.value()
+>>> increment(x)
+>>> assert y.value() == x.value()
+
+>>> y = apply_X_ptr_pyobject(identity, x)
+>>> assert y.value() == x.value()
+>>> increment(x)
+>>> assert y.value() == x.value()
+
+>>> y = apply_X_ptr_pyobject(identity, None)
+>>> y
+
+>>> def new_x(ignored):
+...     return X(666)
+...
+>>> try: apply_X_ref_pyobject(new_x, 1)
+... except ReferenceError: pass
+... else: print 'no error'
+
+>>> try: apply_X_ptr_pyobject(new_x, 1)
+... except ReferenceError: pass
+... else: print 'no error'
+
+>>> try: apply_cstring_cstring(identity, 'hello')
+... except ReferenceError: pass
+... else: print 'no error'
+
+>>> apply_char_char(identity, 'x')
+'x'
+
+>>> apply_cstring_pyobject(identity, 'hello')
+'hello'
+
+>>> apply_cstring_pyobject(identity, None)
+
+
+>>> apply_char_char(identity, 'x')
+'x'
 '''
 
 def run(args = None):

From 2fa0910547a92a6a1cf0cb7cb11e5b4f6242e3c8 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 10 Mar 2002 06:41:40 +0000
Subject: [PATCH 351/369] initial checkin

[SVN r13165]
---
 include/boost/python/detail/void_ptr.hpp | 34 ++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 include/boost/python/detail/void_ptr.hpp

diff --git a/include/boost/python/detail/void_ptr.hpp b/include/boost/python/detail/void_ptr.hpp
new file mode 100644
index 00000000..676a5cac
--- /dev/null
+++ b/include/boost/python/detail/void_ptr.hpp
@@ -0,0 +1,34 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VOID_PTR_DWA200239_HPP
+# define VOID_PTR_DWA200239_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+template <class U>
+inline U& void_ptr_to_reference(void const volatile* p, U&(*)())
+{
+    return *(U*)p;
+}
+
+template <class T>
+inline void write_void_ptr(void const volatile* storage, void* ptr, T*)
+{
+    *(T**)storage = (T*)ptr;
+}
+
+// writes U(ptr) into the storage
+template <class U>
+inline void write_void_ptr_reference(void const volatile* storage, void* ptr, U&(*)())
+{
+    // stripping CV qualification suppresses warnings on older EDGs
+    typedef typename remove_cv<U>::type u_stripped; 
+    write_void_ptr(storage, ptr, u_stripped(0));
+}
+
+}}} // namespace boost::python::detail
+
+#endif // VOID_PTR_DWA200239_HPP

From bccd85467654e28d29be4427ea94277d52f0f02b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 11 Mar 2002 18:43:02 +0000
Subject: [PATCH 352/369] Initial work for virtual function support

[SVN r13175]
---
 include/boost/python/class.hpp                |   7 +-
 include/boost/python/class_fwd.hpp            |   8 +-
 include/boost/python/object/class.hpp         |  19 --
 include/boost/python/object/make_holder.hpp   |  14 +-
 .../boost/python/object/pointer_holder.hpp    | 182 +++++++++++++++++-
 include/boost/python/object/value_holder.hpp  | 158 ++++++++++++++-
 .../boost/python/object/value_holder_fwd.hpp  |  17 ++
 src/object/class.cpp                          |   4 +-
 8 files changed, 360 insertions(+), 49 deletions(-)
 create mode 100644 include/boost/python/object/value_holder_fwd.hpp

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 8dede0e3..7f31df88 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -9,6 +9,7 @@
 # include <boost/python/class_fwd.hpp>
 # include <boost/python/reference.hpp>
 # include <boost/python/object/class.hpp>
+# include <boost/python/object/value_holder_fwd.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/detail/wrap_function.hpp>
 # include <boost/mpl/type_list.hpp>
@@ -32,12 +33,6 @@ namespace // put some convenience classes into the unnamed namespace for the use
 
 namespace boost { namespace python { 
 
-// Forward declarations
-namespace objects
-{
-  struct value_holder_generator;
-}
-
 namespace detail
 {
   // This is an mpl BinaryMetaFunction object with a runtime behavior,
diff --git a/include/boost/python/class_fwd.hpp b/include/boost/python/class_fwd.hpp
index 6faf7aae..bef2e250 100644
--- a/include/boost/python/class_fwd.hpp
+++ b/include/boost/python/class_fwd.hpp
@@ -5,6 +5,7 @@
 // to its suitability for any purpose.
 #ifndef CLASS_FWD_DWA200222_HPP
 # define CLASS_FWD_DWA200222_HPP
+# include <boost/python/object/value_holder_fwd.hpp>
 
 namespace boost { namespace python { 
 
@@ -13,15 +14,10 @@ namespace detail
   struct empty_list;
 }
 
-namespace objects
-{
-  struct value_holder_generator;
-}
-
 template <
     class T // class being wrapped
     , class Bases = detail::empty_list
-    , class HolderGenerator = objects::value_holder_generator
+    , class HolderGenerator = objects::value_holder_generator<>
     >
 class class_;
 
diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index 0d5210c7..d453967c 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -11,7 +11,6 @@
 # include <boost/utility.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/reference.hpp>
-# include <boost/iterator_adaptors.hpp>
 # include <cstddef>
 
 namespace boost { namespace python {
@@ -55,24 +54,6 @@ struct BOOST_PYTHON_DECL instance_holder : private noncopyable
     virtual void* holds(converter::undecorated_type_id_t) = 0;
 
     void install(PyObject* inst) throw();
-    
-    struct iterator_policies : default_iterator_policies
-    {
-        template <class Iterator>
-        void increment(Iterator& p)
-        {
-            p.base() = p.base()->next();
-        }
-    };
-    
-    typedef iterator_adaptor<
-        instance_holder*
-        , iterator_policies
-        , value_type_is<noncopyable>
-        , reference_is<instance_holder&>
-        , pointer_is<instance_holder*>
-        , iterator_category_is<std::input_iterator_tag> > iterator;
-    
  private:
     instance_holder* m_next;
 };
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 825e02b0..1ba6f932 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -22,7 +22,7 @@ struct make_holder<0>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         static void execute(
             PyObject* p)
         {
@@ -38,7 +38,7 @@ struct make_holder<1>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         
@@ -57,7 +57,7 @@ struct make_holder<2>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -77,7 +77,7 @@ struct make_holder<3>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -99,7 +99,7 @@ struct make_holder<4>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -123,7 +123,7 @@ struct make_holder<5>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -149,7 +149,7 @@ struct make_holder<6>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename detail::eval<Generator,T>::type holder;
+        typedef typename python::detail::eval<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index c307f019..2722ae85 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -12,6 +12,7 @@
 # include <boost/python/detail/eval.hpp>
 # include <boost/ref.hpp>
 # include <boost/type.hpp>
+# include <boost/mpl/select_type.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -145,7 +146,137 @@ struct pointer_holder : instance_holder
     Pointer m_p;
 };
 
-}}}
+template <class Pointer, class Value, class BackReferenceType>
+struct pointer_holder_back_reference : instance_holder
+{
+    pointer_holder_back_reference(Pointer);
+    
+    // Forward construction to the held object
+    pointer_holder_back_reference(PyObject* p)
+        : m_p(new Value(p)) {}
+
+    
+    template <class A1>
+    pointer_holder_back_reference(PyObject* p, A1 a1)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+                  ))
+    {}
+    
+    template <class A1, class A2>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            )) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            )) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
+            ))
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
+        : m_p(new Value(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
+            , (typename unwrap_reference<A10>::type&)(a10)
+            ))
+    {}
+
+ private: // required holder implementation
+    void* holds(converter::undecorated_type_id_t);
+
+ private: // data members
+    Pointer m_p;
+};
+
+}}} // namespace boost::python::objects
 
 // back to namespace boost for this forward declaration
 namespace boost
@@ -164,19 +295,54 @@ struct shared_ptr_generator
     };
 };
 
+struct no_back_reference;
+
+// Workaround lack of partial specialization
+namespace detail
+{
+  template <class BackReferenceType, class PointerGenerator>
+  struct pointer_holder_back_reference_generator
+  {
+      template <class Held>
+      struct apply
+      {
+          typedef typename boost::python::detail::eval<
+              PointerGenerator,BackReferenceType
+              >::type pointer;
+              
+          typedef pointer_holder_back_reference<pointer,Held,BackReferenceType> type;
+      };
+  };
+
+  template <class PointerGenerator>
+  struct plain_pointer_holder_generator
+  {
+      template <class Held>
+      struct apply
+      {
+          typedef typename boost::python::detail::eval<
+              PointerGenerator,Held
+              >::type pointer;
+              
+          typedef pointer_holder<pointer, Held> type;
+      };
+  };
+}
+
 // A generator metafunction which can be passed to make_holder
 // PointerGenerator should be another generator metafunction which
 // makes the appropriate (smart) pointer type to hold the argument to
 // pointer_holder_generator.
-template <class PointerGenerator>
+template <class PointerGenerator, class BackReferenceType = no_back_reference>
 struct pointer_holder_generator
+    : mpl::select_type<
+          is_same<BackReferenceType,no_back_reference>::value
+          , detail::plain_pointer_holder_generator<
+                PointerGenerator>
+          , detail::pointer_holder_back_reference_generator<
+                BackReferenceType,PointerGenerator>
+      >::type
 {
-    template <class Held>
-    struct apply
-    {
-        typedef typename detail::eval<PointerGenerator,Held>::type pointer;
-        typedef pointer_holder<pointer, Held> type;
-    };
 };
 
 template <class Pointer, class Value>
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index 6533bc39..62222a23 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -6,6 +6,7 @@
 #ifndef VALUE_HOLDER_DWA20011215_HPP
 # define VALUE_HOLDER_DWA20011215_HPP
 
+# include <boost/python/object/value_holder_fwd.hpp>
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/object/inheritance.hpp>
@@ -140,8 +141,136 @@ struct value_holder : instance_holder
     Held m_held;
 };
 
+template <class Held,class BackReferenceType>
+struct value_holder_back_reference : instance_holder
+{
+    // Forward construction to the held object
+    value_holder_back_reference(PyObject* p)
+        : m_held() {}
+    
+    template <class A1>
+    value_holder_back_reference(PyObject* p, A1 a1)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            )
+    {}
+    
+    template <class A1, class A2>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            )
+    {}
+    
+    template <class A1, class A2, class A3>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            )
+    {}
+    
+    template <class A1, class A2, class A3, class A4>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            )
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            ) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            ) {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            )
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            )
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
+            )
+    {}
+    
+    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
+    value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
+        : m_held(p
+            , (typename unwrap_reference<A1>::type&)(a1)
+            , (typename unwrap_reference<A2>::type&)(a2)
+            , (typename unwrap_reference<A3>::type&)(a3)
+            , (typename unwrap_reference<A4>::type&)(a4)
+            , (typename unwrap_reference<A5>::type&)(a5)
+            , (typename unwrap_reference<A6>::type&)(a6)
+            , (typename unwrap_reference<A7>::type&)(a7)
+            , (typename unwrap_reference<A8>::type&)(a8)
+            , (typename unwrap_reference<A9>::type&)(a9)
+            , (typename unwrap_reference<A10>::type&)(a10)
+            )
+    {}
+
+ private: // required holder implementation
+    void* holds(converter::undecorated_type_id_t);
+
+ private: // data members
+    BackReferenceType m_held;
+};
+
 // A generator metafunction which can be passed to make_holder
-struct value_holder_generator
+template <>
+struct value_holder_generator<no_back_reference>
 {
     template <class Held>
     struct apply
@@ -150,6 +279,16 @@ struct value_holder_generator
     };
 };
 
+template <class BackReferenceType>
+struct value_holder_generator
+{
+    template <class Held>
+    struct apply
+    {
+        typedef value_holder_back_reference<Held,BackReferenceType> type;
+    };
+};
+
 template <class Held>
 void* value_holder<Held>::holds(converter::undecorated_type_id_t dst_t)
 {
@@ -158,6 +297,23 @@ void* value_holder<Held>::holds(converter::undecorated_type_id_t dst_t)
         : find_static_type(&m_held, src_t, dst_t);
 }
 
+template <class Held, class BackReferenceType>
+void* value_holder_back_reference<Held,BackReferenceType>::holds(
+    converter::undecorated_type_id_t dst_t)
+{
+    converter::undecorated_type_id_t src_t = converter::undecorated_type_id<Held>();
+    if (src_t == dst_t)
+    {
+        Held* x = &m_held;
+        return x;
+    }
+
+    src_t = converter::undecorated_type_id<BackReferenceType>();
+    return src_t == dst_t
+        ? &m_held
+        :  find_static_type(&m_held, src_t, dst_t);
+}
+
 }}} // namespace boost::python::objects
 
 #endif // VALUE_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/object/value_holder_fwd.hpp b/include/boost/python/object/value_holder_fwd.hpp
new file mode 100644
index 00000000..6cb2a0f5
--- /dev/null
+++ b/include/boost/python/object/value_holder_fwd.hpp
@@ -0,0 +1,17 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef VALUE_HOLDER_FWD_DWA2002311_HPP
+# define VALUE_HOLDER_FWD_DWA2002311_HPP
+
+namespace boost { namespace python { namespace objects { 
+
+struct no_back_reference;
+
+template <class CallbackType = no_back_reference> struct value_holder_generator;
+
+}}} // namespace boost::python::object
+
+#endif // VALUE_HOLDER_FWD_DWA2002311_HPP
diff --git a/src/object/class.cpp b/src/object/class.cpp
index b9deb98f..dc3a42af 100644
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -169,9 +169,9 @@ find_instance_impl(PyObject* inst, converter::undecorated_type_id_t type)
     
     instance* self = reinterpret_cast<instance*>(inst);
 
-    for (instance_holder::iterator match(self->objects), end(0); match != end; ++match)
+    for (instance_holder* match = self->objects; match != 0; match = match->next())
     {
-        void* const found = (*match).holds(type);
+        void* const found = match->holds(type);
         if (found)
             return found;
     }

From 23769371bc8bd2baa16c6fb5ef14f37ad18cb05d Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Mon, 11 Mar 2002 18:57:45 +0000
Subject: [PATCH 353/369] Elimination of boost/python/detail/eval.hpp; using
 mpl::apply instead

[SVN r13176]
---
 include/boost/python/detail/caller.hpp        |  1 -
 include/boost/python/detail/eval.hpp          | 40 ------------
 include/boost/python/detail/returning.hpp     | 63 ++++++++++---------
 include/boost/python/object/make_holder.hpp   | 16 ++---
 .../boost/python/object/pointer_holder.hpp    |  6 +-
 5 files changed, 43 insertions(+), 83 deletions(-)
 delete mode 100644 include/boost/python/detail/eval.hpp

diff --git a/include/boost/python/detail/caller.hpp b/include/boost/python/detail/caller.hpp
index d0b01b6e..68da40e6 100644
--- a/include/boost/python/detail/caller.hpp
+++ b/include/boost/python/detail/caller.hpp
@@ -7,7 +7,6 @@
 # define CALLER_DWA20011214_HPP
 
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/eval.hpp>
 # include <boost/python/detail/returning.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/type_traits/composite_traits.hpp>
diff --git a/include/boost/python/detail/eval.hpp b/include/boost/python/detail/eval.hpp
deleted file mode 100644
index 8699f701..00000000
--- a/include/boost/python/detail/eval.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright David Abrahams 2002. Permission to copy, use,
-// modify, sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-#ifndef EVAL_DWA2002124_HPP
-# define EVAL_DWA2002124_HPP
-
-# include <boost/mpl/apply.hpp>
-
-namespace boost { namespace python { namespace detail { 
-
-template <class T> struct undefined;
-template <class UnaryMetaFunction, class T>
-struct eval
-{
-# if defined(BOOST_MSVC) && BOOST_MSVC <= 1200
-   // based on the (non-conforming) MSVC trick from MPL
-    template<bool>
-    struct unarymetafunction_vc : UnaryMetaFunction {};
-
-    // illegal C++ which causes VC to admit that unarymetafunction_vc
-    // can have a nested template:
-    template<>
-    struct unarymetafunction_vc<true>
-    {
-        template<class> struct apply;
-    };
-
-    typedef typename unarymetafunction_vc<
-        ::boost::mpl::detail::msvc_never_true<UnaryMetaFunction>::value
-    >::template apply<T>::type type;
-# else
-    typedef typename UnaryMetaFunction::template apply<T>::type type;
-# endif
-};
-
-}}} // namespace boost::python::detail
-
-#endif // EVAL_DWA2002124_HPP
diff --git a/include/boost/python/detail/returning.hpp b/include/boost/python/detail/returning.hpp
index d7e98cd8..2c5d8c4f 100644
--- a/include/boost/python/detail/returning.hpp
+++ b/include/boost/python/detail/returning.hpp
@@ -15,6 +15,7 @@
 # include <boost/config.hpp>
 # include <boost/python/detail/none.hpp>
 # include <boost/python/from_python.hpp>
+# include <boost/mpl/apply.hpp>
 
 namespace boost { namespace python { namespace detail {
 
@@ -31,7 +32,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -52,7 +53,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -75,7 +76,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -101,7 +102,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -130,7 +131,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -162,7 +163,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -186,7 +187,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -207,7 +208,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -230,7 +231,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -256,7 +257,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -285,7 +286,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -317,7 +318,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -341,7 +342,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -362,7 +363,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -385,7 +386,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -411,7 +412,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -440,7 +441,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -472,7 +473,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -499,7 +500,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -520,7 +521,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -543,7 +544,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -569,7 +570,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -598,7 +599,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -630,7 +631,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -652,7 +653,7 @@ struct returning
     {
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -671,7 +672,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -692,7 +693,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -716,7 +717,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -743,7 +744,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -773,7 +774,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
@@ -806,7 +807,7 @@ struct returning
 
         // find the result converter
         typedef typename P::result_converter result_converter;
-        typename eval<result_converter,R>::type cr;
+        typename mpl::apply1<result_converter,R>::type cr;
         if (!cr.convertible()) return 0;
         
         if (!policies.precall(args_)) return 0;
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 1ba6f932..871ed059 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -10,7 +10,7 @@
 # include <boost/python/object/forward.hpp>
 # include <boost/python/object/class.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/eval.hpp>
+# include <boost/mpl/apply.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -22,7 +22,7 @@ struct make_holder<0>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         static void execute(
             PyObject* p)
         {
@@ -38,7 +38,7 @@ struct make_holder<1>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         
@@ -57,7 +57,7 @@ struct make_holder<2>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -77,7 +77,7 @@ struct make_holder<3>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -99,7 +99,7 @@ struct make_holder<4>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -123,7 +123,7 @@ struct make_holder<5>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -149,7 +149,7 @@ struct make_holder<6>
     template <class T, class Generator, class ArgList>
     struct apply
     {
-        typedef typename python::detail::eval<Generator,T>::type holder;
+        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index 2722ae85..57cb6b47 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -9,10 +9,10 @@
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/object/inheritance.hpp>
-# include <boost/python/detail/eval.hpp>
 # include <boost/ref.hpp>
 # include <boost/type.hpp>
 # include <boost/mpl/select_type.hpp>
+# include <boost/mpl/apply.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -306,7 +306,7 @@ namespace detail
       template <class Held>
       struct apply
       {
-          typedef typename boost::python::detail::eval<
+          typedef typename mpl::apply1<
               PointerGenerator,BackReferenceType
               >::type pointer;
               
@@ -320,7 +320,7 @@ namespace detail
       template <class Held>
       struct apply
       {
-          typedef typename boost::python::detail::eval<
+          typedef typename mpl::apply1<
               PointerGenerator,Held
               >::type pointer;
               

From 0bdf3542e451e1e4d5725cfb7b616956b27c53cd Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 12 Mar 2002 20:43:42 +0000
Subject: [PATCH 354/369] factored out find_instance

[SVN r13181]
---
 include/boost/python/object/class.hpp            | 14 --------------
 include/boost/python/object/class_converters.hpp |  5 ++---
 2 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp
index d453967c..468240c0 100644
--- a/include/boost/python/object/class.hpp
+++ b/include/boost/python/object/class.hpp
@@ -65,20 +65,6 @@ struct instance
     instance_holder* objects;
 };
 
-// Given an undecorated type_id, find the instance data which
-// corresponds to it, or return 0 in case no such type is held.
-BOOST_PYTHON_DECL void* find_instance_impl(PyObject*, converter::undecorated_type_id_t);
-
-// This produces a function with the right signature for use in from_python conversions
-template <class T>
-struct instance_finder
-{
-    static inline void* execute(PyObject* p)
-    {
-        return find_instance_impl(p, converter::undecorated_type_id<T>());
-    }
-};
-
 BOOST_PYTHON_DECL ref class_metatype();
 BOOST_PYTHON_DECL ref class_type();
 
diff --git a/include/boost/python/object/class_converters.hpp b/include/boost/python/object/class_converters.hpp
index 540565bf..5c2a35ae 100644
--- a/include/boost/python/object/class_converters.hpp
+++ b/include/boost/python/object/class_converters.hpp
@@ -10,6 +10,7 @@
 # include <boost/mpl/for_each.hpp>
 # include <boost/python/reference.hpp>
 # include <boost/python/converter/registry.hpp>
+# include <boost/python/object/find_instance.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -89,9 +90,7 @@ template <class Derived, class Bases>
 class_converters<Derived,Bases>::class_converters(ref const& type_object)
     : m_wrapper(type_object)
 {
-    converter::registry::insert(
-        &instance_finder<Derived>::execute
-        , converter::undecorated_type_id<Derived>());
+    (void)instance_finder<Derived>::registration;
     
     // register all up/downcasts here
     register_dynamic_id<Derived>();

From 3caa91cc36bc04cf1bbe0726a6d8b2fdf20949d9 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 12 Mar 2002 21:07:26 +0000
Subject: [PATCH 355/369] More fixes

[SVN r13182]
---
 include/boost/python/class.hpp                | 15 +++-
 include/boost/python/object/find_instance.hpp | 37 +++++++++
 .../boost/python/object/pointer_holder.hpp    | 76 ++++++++++++++-----
 include/boost/python/object/value_holder.hpp  | 55 +++++++++++---
 test/Jamfile                                  |  1 +
 5 files changed, 150 insertions(+), 34 deletions(-)
 create mode 100644 include/boost/python/object/find_instance.hpp

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 7f31df88..0a9c5d87 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -12,6 +12,7 @@
 # include <boost/python/object/value_holder_fwd.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/detail/wrap_function.hpp>
+# include <boost/python/detail/member_function_cast.hpp>
 # include <boost/mpl/type_list.hpp>
 # include <boost/python/object/class_converters.hpp>
 # include <boost/mpl/size.hpp>
@@ -103,14 +104,24 @@ class class_ : private objects::class_base
         // Use function::add_to_namespace to achieve overloading if
         // appropriate.
         objects::function::add_to_namespace(
-            this->object(), name, ref(detail::wrap_function(f)));
+            this->object(), name,
+            ref(detail::wrap_function(
+                    // This bit of nastiness casts F to a member function of T if possible. 
+                    detail::member_function_cast<T,F>::stage1(f).stage2((T*)0).stage3(f)
+                    )));
         return *this;
     }
 
     template <class Fn, class CallPolicy>
     self& def(char const* name, Fn fn, CallPolicy policy)
     {
-        this->def(name, boost::python::make_function(fn, policy));
+        this->def(name
+                  , boost::python::make_function(
+                      // This bit of nastiness casts F to a member function of T if possible. 
+                      detail::member_function_cast<T,Fn>::stage1(fn).stage2((T*)0).stage3(fn)
+                      , policy)
+            );
+        
         return *this;
     }
     
diff --git a/include/boost/python/object/find_instance.hpp b/include/boost/python/object/find_instance.hpp
new file mode 100644
index 00000000..c60a82f7
--- /dev/null
+++ b/include/boost/python/object/find_instance.hpp
@@ -0,0 +1,37 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef FIND_INSTANCE_DWA2002312_HPP
+# define FIND_INSTANCE_DWA2002312_HPP
+
+namespace boost { namespace python { namespace objects { 
+
+// Given an undecorated type_id, find the instance data which
+// corresponds to it, or return 0 in case no such type is held.
+BOOST_PYTHON_DECL void* find_instance_impl(PyObject*, converter::undecorated_type_id_t);
+
+// This produces a function with the right signature for use in from_python conversions
+template <class T>
+struct instance_finder
+{
+    instance_finder()
+    {
+        converter::registry::insert(&execute, converter::undecorated_type_id<T>());
+    }
+
+    static instance_finder const registration;
+ private:
+    static inline void* execute(PyObject* p)
+    {
+        return find_instance_impl(p, converter::undecorated_type_id<T>());
+    }
+};
+
+template <class T>
+instance_finder<T> const instance_finder<T>::registration;
+
+}}} // namespace boost::python::objects
+
+#endif // FIND_INSTANCE_DWA2002312_HPP
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index 57cb6b47..84700299 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -9,6 +9,7 @@
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/object/inheritance.hpp>
+# include <boost/python/object/find_instance.hpp>
 # include <boost/ref.hpp>
 # include <boost/type.hpp>
 # include <boost/mpl/select_type.hpp>
@@ -153,67 +154,88 @@ struct pointer_holder_back_reference : instance_holder
     
     // Forward construction to the held object
     pointer_holder_back_reference(PyObject* p)
-        : m_p(new Value(p)) {}
+        : m_p(new BackReferenceType(p)) {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
 
     
     template <class A1>
     pointer_holder_back_reference(PyObject* p, A1 a1)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
                   ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             , (typename unwrap_reference<A5>::type&)(a5)
-            )) {}
+            )) {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             , (typename unwrap_reference<A5>::type&)(a5)
             , (typename unwrap_reference<A6>::type&)(a6)
-            )) {}
+            )) {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -222,11 +244,14 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A6>::type&)(a6)
             , (typename unwrap_reference<A7>::type&)(a7)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -236,11 +261,14 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A7>::type&)(a7)
             , (typename unwrap_reference<A8>::type&)(a8)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -251,11 +279,14 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A8>::type&)(a8)
             , (typename unwrap_reference<A9>::type&)(a9)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_p(new Value(p
+        : m_p(new BackReferenceType(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -267,7 +298,10 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A9>::type&)(a9)
             , (typename unwrap_reference<A10>::type&)(a10)
             ))
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
 
  private: // required holder implementation
     void* holds(converter::undecorated_type_id_t);
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index 62222a23..c0a5c580 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -10,6 +10,7 @@
 # include <boost/python/object/class.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/object/inheritance.hpp>
+# include <boost/python/object/find_instance.hpp>
 # include <boost/ref.hpp>
 
 namespace boost { namespace python { namespace objects { 
@@ -146,14 +147,20 @@ struct value_holder_back_reference : instance_holder
 {
     // Forward construction to the held object
     value_holder_back_reference(PyObject* p)
-        : m_held() {}
+        : m_held() {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1>
     value_holder_back_reference(PyObject* p, A1 a1)
         : m_held(p
             , (typename unwrap_reference<A1>::type&)(a1)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2)
@@ -161,7 +168,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
@@ -170,7 +180,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
@@ -180,7 +193,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
@@ -190,7 +206,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             , (typename unwrap_reference<A5>::type&)(a5)
-            ) {}
+            ) {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
@@ -201,7 +220,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A4>::type&)(a4)
             , (typename unwrap_reference<A5>::type&)(a5)
             , (typename unwrap_reference<A6>::type&)(a6)
-            ) {}
+            ) {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
@@ -214,7 +236,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A6>::type&)(a6)
             , (typename unwrap_reference<A7>::type&)(a7)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
@@ -228,7 +253,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A7>::type&)(a7)
             , (typename unwrap_reference<A8>::type&)(a8)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
@@ -243,7 +271,10 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A8>::type&)(a8)
             , (typename unwrap_reference<A9>::type&)(a9)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
+
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     value_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
@@ -259,7 +290,9 @@ struct value_holder_back_reference : instance_holder
             , (typename unwrap_reference<A9>::type&)(a9)
             , (typename unwrap_reference<A10>::type&)(a10)
             )
-    {}
+    {
+        (void)instance_finder<BackReferenceType>::registration;
+    }
 
  private: // required holder implementation
     void* holds(converter::undecorated_type_id_t);
diff --git a/test/Jamfile b/test/Jamfile
index 767b07e6..1f5de1e9 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -55,6 +55,7 @@ bpl-test try : newtest.py m1.cpp m2.cpp ;
 bpl-test builtin_converters : test_builtin_converters.py test_builtin_converters.cpp ;
 bpl-test test_pointer_adoption ;
 bpl-test callbacks ;
+bpl-test virtual_functions ;
 
 # --- unit tests of library components ---
 unit-test indirect_traits_test

From c18d8fa9677dfde9501bd01f2dabd4827705973c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 12 Mar 2002 21:14:03 +0000
Subject: [PATCH 356/369] added first virtual function tests

[SVN r13183]
---
 test/virtual_functions.cpp | 118 +++++++++++++++++++++++++++++++++++++
 test/virtual_functions.py  | 100 +++++++++++++++++++++++++++++++
 2 files changed, 218 insertions(+)
 create mode 100644 test/virtual_functions.cpp
 create mode 100644 test/virtual_functions.py

diff --git a/test/virtual_functions.cpp b/test/virtual_functions.cpp
new file mode 100644
index 00000000..ab05fe3c
--- /dev/null
+++ b/test/virtual_functions.cpp
@@ -0,0 +1,118 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/class.hpp>
+#include <boost/python/module.hpp>
+#include <boost/python/returning.hpp>
+#include <boost/ref.hpp>
+
+using namespace boost::python;
+
+struct X
+{
+    explicit X(int x) : x(x), magic(7654321) { ++counter; }
+    X(X const& rhs) : x(rhs.x), magic(7654321) { ++counter; }
+    virtual ~X() { assert(magic == 7654321); magic = 6666666; x = 9999; --counter; }
+
+    void set(int x) { assert(magic == 7654321); this->x = x; }
+    int value() const { assert(magic == 7654321); return x; }
+    static int count() { return counter; }
+ private:
+    void operator=(X const&);
+ private:
+    int x;
+    long magic;
+    static int counter;
+};
+
+struct Y : X
+{
+    Y(int x) : X(x) {};
+};
+
+struct abstract : X
+{
+    abstract(int x) : X(x) {};
+    int call_f(Y const& y) { return f(y); }
+    virtual int f(Y const& y) = 0;
+};
+
+struct concrete : X
+{
+    concrete(int x) : X(x) {};
+    int call_f(Y const& y) { return f(y); }
+    virtual int f(Y const& y) { set(y.value()); return y.value(); }
+};
+
+struct abstract_callback : abstract
+{
+    abstract_callback(PyObject* p, int x)
+        : abstract(x), self(p)
+    {}
+
+    int f(Y const& y)
+    {
+        return returning<int>::call_method(self, "f", boost::ref(y));
+    }
+
+    PyObject* self;
+};
+
+struct concrete_callback : concrete
+{
+    concrete_callback(PyObject* p, int x)
+        : concrete(x), self(p)
+    {}
+
+    int f(Y const& y)
+    {
+        return returning<int>::call_method(self, "f", boost::ref(y));
+    }
+
+    int f_impl(Y const& y)
+    {
+        return this->concrete::f(y);
+    }
+    
+    PyObject* self;
+};
+
+int X::counter;
+
+BOOST_PYTHON_MODULE_INIT(virtual_functions_ext)
+{
+    module("virtual_functions_ext")
+        .add(
+            class_<concrete, bases<>, objects::value_holder_generator<concrete_callback> >("concrete")
+            .def_init(args<int>())
+            .def("value", &concrete::value)
+            .def("set", &concrete::set)
+            .def("call_f", &concrete::call_f)
+            .def("f", &concrete_callback::f_impl))
+        
+#if 0
+        .add(
+            class_<abstract, bases<>
+            , objects::pointer_holder_generator<
+                boost::python::objects::shared_ptr_generator
+                , abstract_callback>
+            >("abstract")
+            
+            .def_init(args<int>())
+            .def("value", &abstract::value)
+            .def("call_f", &abstract::call_f)
+            .def("set", &abstract::set))
+#endif 
+        
+        .add(
+            class_<Y>("Y")
+            .def_init(args<int>())
+            .def("value", &Y::value)
+            .def("set", &Y::set)
+            )
+        ;
+}
+
+#include "module_tail.cpp"
diff --git a/test/virtual_functions.py b/test/virtual_functions.py
new file mode 100644
index 00000000..8ea992c5
--- /dev/null
+++ b/test/virtual_functions.py
@@ -0,0 +1,100 @@
+'''
+>>> from virtual_functions_ext import *
+
+>>> class C1(concrete):
+...     def f(self, y):
+...         return concrete.f(self, Y(-y.value()))
+
+>>> class C2(concrete):
+...     pass
+
+<<<>>> class A1(abstract):
+<<<...     def f(self, y):
+<<<...         return abstract.f(self, Y(-y.value()))
+<<<
+<<<>>> class A2(abstract):
+<<<...     pass
+<<<
+
+>>> y1 = Y(16)
+>>> y2 = Y(17)
+
+
+
+#
+# Test abstract with f overridden
+#
+<<<>>> a1 = A1(42)
+<<<>>> a1.value()
+<<<42
+<<<
+<<<# Call f indirectly from C++
+<<<>>> a1.call_f(y1)
+<<<-16
+<<<
+<<<# Call f directly from Python
+<<<>>> a1.f(y2)
+<<<-17
+<<<
+<<<#
+<<<# Test abstract with f not overridden
+<<<#
+<<<>>> a2 = A2(42)
+<<<>>> A2.value()
+<<<42
+<<<
+<<<# Call f indirectly from C++
+<<<>>> c1.call_f(y1)
+<<<16
+<<<
+<<<# Call f directly from Python
+<<<>>> c1.f(y2)
+<<<17
+<<<
+############# Concrete Tests ############
+
+#
+# Test concrete with f overridden
+#
+>>> c1 = C1(42)
+>>> c1.value()
+42
+
+# Call f indirectly from C++
+>>> c1.call_f(y1)
+-16
+
+# Call f directly from Python
+>>> c1.f(y2)
+-17
+
+#
+# Test concrete with f not overridden
+#
+>>> c2 = C2(42)
+>>> c2.value()
+42
+
+# Call f indirectly from C++
+>>> c2.call_f(y1)
+16
+
+# Call f directly from Python
+>>> c2.f(y2)
+17
+
+
+'''
+
+def run(args = None):
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    return doctest.testmod(sys.modules.get(__name__))
+    
+if __name__ == '__main__':
+    print "running..."
+    import sys
+    sys.exit(run()[0])

From 81a07899ae2451bcb7cd2cc677e76444990f2f9b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Tue, 12 Mar 2002 21:15:28 +0000
Subject: [PATCH 357/369] initial checkin

[SVN r13184]
---
 .../python/detail/member_function_cast.hpp    | 231 ++++++++++++++++++
 1 file changed, 231 insertions(+)
 create mode 100644 include/boost/python/detail/member_function_cast.hpp

diff --git a/include/boost/python/detail/member_function_cast.hpp b/include/boost/python/detail/member_function_cast.hpp
new file mode 100644
index 00000000..3d965021
--- /dev/null
+++ b/include/boost/python/detail/member_function_cast.hpp
@@ -0,0 +1,231 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef MEMBER_FUNCTION_CAST_DWA2002311_HPP
+# define MEMBER_FUNCTION_CAST_DWA2002311_HPP
+# include <boost/mpl/select_type.hpp>
+# include <boost/type_traits/composite_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class S, class FT>
+struct cast_helper
+{
+    struct yes_helper
+    {
+        static FT stage3(FT x) { return x; }
+    };
+
+    struct no_helper
+    {
+        template <class T>
+        static T stage3(T x) { return x; }
+    };
+
+    static yes_helper stage2(S*) { return yes_helper(); }
+    static no_helper stage2(void*) { return no_helper(); }
+};
+
+struct non_member_function_cast_impl
+{
+    template <class T>
+    static non_member_function_cast_impl stage1(T) { return non_member_function_cast_impl(); }
+
+    template <class T>
+    static non_member_function_cast_impl stage2(T) { return non_member_function_cast_impl(); }
+
+    template <class T>
+    T stage3(T x) { return x; }
+};
+
+template <class T>
+struct member_function_cast_impl
+{
+    template <class S, class R>
+    static cast_helper<S,R(T::*)()> stage1(R (S::*)())
+    {
+        return cast_helper<S,R(T::*)()>();
+    }
+
+    template <class S, class R, class A0>
+    static cast_helper<S,R(T::*)(A0)> stage1(R (S::*)(A0))
+    {
+        return cast_helper<S,R(T::*)(A0)>();
+    }
+
+    template <class S, class R, class A0, class A1>
+    static cast_helper<R(S::*)(A0,A1),R(T::*)(A0,A1) > stage1(R (S::*)(A0,A1))
+    {
+        return cast_helper<R(S::*)(A0,A1),R(T::*)(A0,A1) >();
+    }
+
+    template <class S, class R, class A0, class A1,class A2>
+    static cast_helper<R(S::*)(A0,A1,A2),R(T::*)(A0,A1,A2) > stage1(R (S::*)(A0,A1,A2))
+    {
+        return cast_helper<R(S::*)(A0,A1,A2),R(T::*)(A0,A1,A2) >();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3)> stage1(R (S::*)(A0,A1,A2,A3))
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3)>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)> stage1(R (S::*)(A0,A1,A2,A3,A4))
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)> stage1(R (S::*)(A0,A1,A2,A3,A4,A5))
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)>();
+    }
+
+# if 1
+    template <class S, class R>
+    static cast_helper<S,R(T::*)()const> stage1(R (S::*)()const)
+    {
+        return cast_helper<S,R(T::*)()const>();
+    }
+
+    template <class S, class R, class A0>
+    static cast_helper<S,R(T::*)(A0)const> stage1(R (S::*)(A0)const)
+    {
+        return cast_helper<S,R(T::*)(A0)const>();
+    }
+
+    template <class S, class R, class A0, class A1>
+    static cast_helper<S,R(T::*)(A0,A1)const> stage1(R (S::*)(A0,A1)const)
+    {
+        return cast_helper<S,R(T::*)(A0,A1)const>();
+    }
+
+    template <class S, class R, class A0, class A1,class A2>
+    static cast_helper<S,R(T::*)(A0,A1,A2)const> stage1(R (S::*)(A0,A1,A2)const)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2)const>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3)const> stage1(R (S::*)(A0,A1,A2,A3)const)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3)const>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)const> stage1(R (S::*)(A0,A1,A2,A3,A4)const)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)const>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)const> stage1(R (S::*)(A0,A1,A2,A3,A4,A5)const)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)const>();
+    }
+
+    template <class S, class R>
+    static cast_helper<S,R(T::*)()volatile> stage1(R (S::*)()volatile)
+    {
+        return cast_helper<S,R(T::*)()volatile>();
+    }
+
+    template <class S, class R, class A0>
+    static cast_helper<S,R(T::*)(A0)volatile> stage1(R (S::*)(A0)volatile)
+    {
+        return cast_helper<S,R(T::*)(A0)volatile>();
+    }
+
+    template <class S, class R, class A0, class A1>
+    static cast_helper<S,R(T::*)(A0,A1)volatile> stage1(R (S::*)(A0,A1)volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1)volatile>();
+    }
+
+    template <class S, class R, class A0, class A1,class A2>
+    static cast_helper<S,R(T::*)(A0,A1,A2)volatile> stage1(R (S::*)(A0,A1,A2)volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2)volatile>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3)volatile> stage1(R (S::*)(A0,A1,A2,A3)volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3)volatile>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)volatile> stage1(R (S::*)(A0,A1,A2,A3,A4)volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)volatile>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)volatile> stage1(R (S::*)(A0,A1,A2,A3,A4,A5)volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)volatile>();
+    }
+
+// # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class S, class R>
+    static cast_helper<S,R(T::*)()const volatile> stage1(R (S::*)()const volatile)
+    {
+        return cast_helper<S,R(T::*)()const volatile>();
+    }
+
+    template <class S, class R, class A0>
+    static cast_helper<S,R(T::*)(A0)const volatile> stage1(R (S::*)(A0)const volatile)
+    {
+        return cast_helper<S,R(T::*)(A0)const volatile>();
+    }
+
+    template <class S, class R, class A0, class A1>
+    static cast_helper<S,R(T::*)(A0,A1)const volatile> stage1(R (S::*)(A0,A1)const volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1)const volatile>();
+    }
+
+    template <class S, class R, class A0, class A1,class A2>
+    static cast_helper<S,R(T::*)(A0,A1,A2)const volatile> stage1(R (S::*)(A0,A1,A2)const volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2)const volatile>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3)const volatile> stage1(R (S::*)(A0,A1,A2,A3)const volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3)const volatile>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)const volatile> stage1(R (S::*)(A0,A1,A2,A3,A4)const volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4)const volatile>();
+    }
+
+    template <class S, class R, class A0, class A1, class A2, class A3, class A4, class A5>
+    static cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)const volatile> stage1(R (S::*)(A0,A1,A2,A3,A4,A5)const volatile)
+    {
+        return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)const volatile>();
+    }
+# endif 
+};
+
+
+template <class T, class SF>
+struct member_function_cast
+    : mpl::select_type<
+        is_member_function_pointer<SF>::value
+        , member_function_cast_impl<T>
+        , non_member_function_cast_impl
+    >::type
+{
+};
+
+}}} // namespace boost::python::detail
+
+#endif // MEMBER_FUNCTION_CAST_DWA2002311_HPP

From 6528bd0e4fa0f22368e08ef2b4152056e8504ef4 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Thu, 14 Mar 2002 18:43:36 +0000
Subject: [PATCH 358/369] Fixes for VC7

[SVN r13194]
---
 src/object/inheritance.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/object/inheritance.cpp b/src/object/inheritance.cpp
index 7efc980c..5b95e478 100644
--- a/src/object/inheritance.cpp
+++ b/src/object/inheritance.cpp
@@ -109,7 +109,7 @@ namespace
                               make_iterator_property_map(
                                   to_target
                                   , get(vertex_index, reverse_topology)
-# ifdef BOOST_MSVC_STD_ITERATOR
+# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
                                   , *to_target
 # endif 
                                   )

From fbbc1981cabf54cdb37b15c15b119365b009d578 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Mar 2002 00:25:26 +0000
Subject: [PATCH 359/369] Bug fix (thanks, VC7!)

[SVN r13200]
---
 include/boost/python/detail/member_function_cast.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/python/detail/member_function_cast.hpp b/include/boost/python/detail/member_function_cast.hpp
index 3d965021..52718390 100644
--- a/include/boost/python/detail/member_function_cast.hpp
+++ b/include/boost/python/detail/member_function_cast.hpp
@@ -56,13 +56,13 @@ struct member_function_cast_impl
     }
 
     template <class S, class R, class A0, class A1>
-    static cast_helper<R(S::*)(A0,A1),R(T::*)(A0,A1) > stage1(R (S::*)(A0,A1))
+    static cast_helper<S,R(T::*)(A0,A1) > stage1(R (S::*)(A0,A1))
     {
         return cast_helper<R(S::*)(A0,A1),R(T::*)(A0,A1) >();
     }
 
     template <class S, class R, class A0, class A1,class A2>
-    static cast_helper<R(S::*)(A0,A1,A2),R(T::*)(A0,A1,A2) > stage1(R (S::*)(A0,A1,A2))
+    static cast_helper<S,R(T::*)(A0,A1,A2) > stage1(R (S::*)(A0,A1,A2))
     {
         return cast_helper<R(S::*)(A0,A1,A2),R(T::*)(A0,A1,A2) >();
     }

From aa705b07f3f7812a6ebc2a2b3eae92a57758d4ea Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Mar 2002 00:25:43 +0000
Subject: [PATCH 360/369] VC7 workaround

[SVN r13201]
---
 include/boost/python/object/make_holder.hpp | 58 +++++++++++++--------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 871ed059..5268bde4 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -14,6 +14,22 @@
 
 namespace boost { namespace python { namespace objects { 
 
+namespace detail
+{
+  // Use of this workaround as opposed to straightforward mpl::at
+  // needed for vc7, for some reason.
+  template <unsigned N, class Sequence>
+  struct at
+  {
+   private:
+      typedef typename mpl::at_algorithm_traits< 
+          typename mpl::sequence_traits<Sequence>::sequence_category
+      >::template algorithm<N, Sequence>::type base;
+   public:
+      typedef typename base::type type;
+  };
+}
+
 template <int nargs> struct make_holder;
 
 template <>
@@ -39,7 +55,7 @@ struct make_holder<1>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename detail::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         
         static void execute(
@@ -58,9 +74,9 @@ struct make_holder<2>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename detail::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename detail::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
         
         static void execute(
@@ -78,11 +94,11 @@ struct make_holder<3>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename detail::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename detail::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename detail::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
         
         static void execute(
@@ -100,13 +116,13 @@ struct make_holder<4>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename detail::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename detail::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename detail::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
-        typedef typename mpl::at<3,ArgList>::type t3;
+        typedef typename detail::at<3,ArgList>::type t3;
         typedef typename forward<t3>::type f3;
         
         static void execute(
@@ -124,15 +140,15 @@ struct make_holder<5>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename detail::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename detail::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename detail::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
-        typedef typename mpl::at<3,ArgList>::type t3;
+        typedef typename detail::at<3,ArgList>::type t3;
         typedef typename forward<t3>::type f3;
-        typedef typename mpl::at<4,ArgList>::type t4;
+        typedef typename detail::at<4,ArgList>::type t4;
         typedef typename forward<t4>::type f4;
         
         static void execute(
@@ -150,17 +166,17 @@ struct make_holder<6>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename mpl::at<0,ArgList>::type t0;
+        typedef typename detail::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename mpl::at<1,ArgList>::type t1;
+        typedef typename detail::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename mpl::at<2,ArgList>::type t2;
+        typedef typename detail::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
-        typedef typename mpl::at<3,ArgList>::type t3;
+        typedef typename detail::at<3,ArgList>::type t3;
         typedef typename forward<t3>::type f3;
-        typedef typename mpl::at<4,ArgList>::type t4;
+        typedef typename detail::at<4,ArgList>::type t4;
         typedef typename forward<t4>::type f4;
-        typedef typename mpl::at<5,ArgList>::type t5;
+        typedef typename detail::at<5,ArgList>::type t5;
         typedef typename forward<t5>::type f5;
         
         static void execute(

From a2071feeb11685a4aed5a67c042edb70fbe6b174 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Mar 2002 12:47:04 +0000
Subject: [PATCH 361/369] Roll back vc7 workarounds; Aleksey has folded them
 into the MPL code

[SVN r13207]
---
 include/boost/python/object/make_holder.hpp | 58 ++++++++-------------
 1 file changed, 21 insertions(+), 37 deletions(-)

diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 5268bde4..871ed059 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -14,22 +14,6 @@
 
 namespace boost { namespace python { namespace objects { 
 
-namespace detail
-{
-  // Use of this workaround as opposed to straightforward mpl::at
-  // needed for vc7, for some reason.
-  template <unsigned N, class Sequence>
-  struct at
-  {
-   private:
-      typedef typename mpl::at_algorithm_traits< 
-          typename mpl::sequence_traits<Sequence>::sequence_category
-      >::template algorithm<N, Sequence>::type base;
-   public:
-      typedef typename base::type type;
-  };
-}
-
 template <int nargs> struct make_holder;
 
 template <>
@@ -55,7 +39,7 @@ struct make_holder<1>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename detail::at<0,ArgList>::type t0;
+        typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         
         static void execute(
@@ -74,9 +58,9 @@ struct make_holder<2>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename detail::at<0,ArgList>::type t0;
+        typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename detail::at<1,ArgList>::type t1;
+        typedef typename mpl::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
         
         static void execute(
@@ -94,11 +78,11 @@ struct make_holder<3>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename detail::at<0,ArgList>::type t0;
+        typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename detail::at<1,ArgList>::type t1;
+        typedef typename mpl::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename detail::at<2,ArgList>::type t2;
+        typedef typename mpl::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
         
         static void execute(
@@ -116,13 +100,13 @@ struct make_holder<4>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename detail::at<0,ArgList>::type t0;
+        typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename detail::at<1,ArgList>::type t1;
+        typedef typename mpl::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename detail::at<2,ArgList>::type t2;
+        typedef typename mpl::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
-        typedef typename detail::at<3,ArgList>::type t3;
+        typedef typename mpl::at<3,ArgList>::type t3;
         typedef typename forward<t3>::type f3;
         
         static void execute(
@@ -140,15 +124,15 @@ struct make_holder<5>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename detail::at<0,ArgList>::type t0;
+        typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename detail::at<1,ArgList>::type t1;
+        typedef typename mpl::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename detail::at<2,ArgList>::type t2;
+        typedef typename mpl::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
-        typedef typename detail::at<3,ArgList>::type t3;
+        typedef typename mpl::at<3,ArgList>::type t3;
         typedef typename forward<t3>::type f3;
-        typedef typename detail::at<4,ArgList>::type t4;
+        typedef typename mpl::at<4,ArgList>::type t4;
         typedef typename forward<t4>::type f4;
         
         static void execute(
@@ -166,17 +150,17 @@ struct make_holder<6>
     struct apply
     {
         typedef typename mpl::apply1<Generator,T>::type holder;
-        typedef typename detail::at<0,ArgList>::type t0;
+        typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
-        typedef typename detail::at<1,ArgList>::type t1;
+        typedef typename mpl::at<1,ArgList>::type t1;
         typedef typename forward<t1>::type f1;
-        typedef typename detail::at<2,ArgList>::type t2;
+        typedef typename mpl::at<2,ArgList>::type t2;
         typedef typename forward<t2>::type f2;
-        typedef typename detail::at<3,ArgList>::type t3;
+        typedef typename mpl::at<3,ArgList>::type t3;
         typedef typename forward<t3>::type f3;
-        typedef typename detail::at<4,ArgList>::type t4;
+        typedef typename mpl::at<4,ArgList>::type t4;
         typedef typename forward<t4>::type f4;
-        typedef typename detail::at<5,ArgList>::type t5;
+        typedef typename mpl::at<5,ArgList>::type t5;
         typedef typename forward<t5>::type f5;
         
         static void execute(

From a8d6f40794fee484ec07f1d13c2514a687889779 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Fri, 15 Mar 2002 14:16:31 +0000
Subject: [PATCH 362/369] *** empty log message ***

[SVN r13210]
---
 .../python/detail/member_function_cast.hpp    | 14 ++++-
 include/boost/python/detail/wrap_function.hpp |  5 ++
 src/object/inheritance.cpp                    |  2 +-
 test/Jamfile                                  |  7 ++-
 test/member_function_cast.cpp                 | 55 +++++++++++++++++++
 test/module_tail.cpp                          |  3 +
 6 files changed, 80 insertions(+), 6 deletions(-)
 create mode 100644 test/member_function_cast.cpp

diff --git a/include/boost/python/detail/member_function_cast.hpp b/include/boost/python/detail/member_function_cast.hpp
index 52718390..6e3f18c4 100644
--- a/include/boost/python/detail/member_function_cast.hpp
+++ b/include/boost/python/detail/member_function_cast.hpp
@@ -43,6 +43,13 @@ struct non_member_function_cast_impl
 template <class T>
 struct member_function_cast_impl
 {
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    template <class U>
+    static non_member_function_cast_impl stage1(U)
+    {
+        return non_member_function_cast_impl();
+    }
+# endif 
     template <class S, class R>
     static cast_helper<S,R(T::*)()> stage1(R (S::*)())
     {
@@ -85,7 +92,6 @@ struct member_function_cast_impl
         return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)>();
     }
 
-# if 1
     template <class S, class R>
     static cast_helper<S,R(T::*)()const> stage1(R (S::*)()const)
     {
@@ -170,7 +176,6 @@ struct member_function_cast_impl
         return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)volatile>();
     }
 
-// # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
     template <class S, class R>
     static cast_helper<S,R(T::*)()const volatile> stage1(R (S::*)()const volatile)
     {
@@ -212,17 +217,20 @@ struct member_function_cast_impl
     {
         return cast_helper<S,R(T::*)(A0,A1,A2,A3,A4,A5)const volatile>();
     }
-# endif 
 };
 
 
 template <class T, class SF>
 struct member_function_cast
+# ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+    : member_function_cast_impl<T>
+# else 
     : mpl::select_type<
         is_member_function_pointer<SF>::value
         , member_function_cast_impl<T>
         , non_member_function_cast_impl
     >::type
+# endif 
 {
 };
 
diff --git a/include/boost/python/detail/wrap_function.hpp b/include/boost/python/detail/wrap_function.hpp
index 0424183d..682b3e89 100644
--- a/include/boost/python/detail/wrap_function.hpp
+++ b/include/boost/python/detail/wrap_function.hpp
@@ -45,9 +45,14 @@ template <class F>
 PyObject* wrap_function(F f)
 {
     return wrap_function_select<
+# if 1
+        type_traits::ice_not<
+                is_pointer<F>::value
+# else 
               type_traits::ice_or<
                  is_function<F>::value
                  , is_member_function_pointer<F>::value
+# endif 
         >::value >::execute(f);
 }
 
diff --git a/src/object/inheritance.cpp b/src/object/inheritance.cpp
index 5b95e478..91a37f02 100644
--- a/src/object/inheritance.cpp
+++ b/src/object/inheritance.cpp
@@ -109,7 +109,7 @@ namespace
                               make_iterator_property_map(
                                   to_target
                                   , get(vertex_index, reverse_topology)
-# ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+# ifdef BOOST_NO_STD_ITERATOR_TRAITS
                                   , *to_target
 # endif 
                                   )
diff --git a/test/Jamfile b/test/Jamfile
index 1f5de1e9..a01efdde 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -59,11 +59,14 @@ bpl-test virtual_functions ;
 
 # --- unit tests of library components ---
 unit-test indirect_traits_test
-  : indirect_traits_test.cpp : <include>$(BOOST_ROOT)  ;
+  : indirect_traits_test.cpp : <include>$(BOOST_ROOT) ;
 unit-test destroy_test
   : destroy_test.cpp : <include>$(BOOST_ROOT)  ;
 unit-test pointer_type_id_test
-  : pointer_type_id_test.cpp : <include>$(BOOST_ROOT)  ;
+  : pointer_type_id_test.cpp : <include>$(BOOST_ROOT) ;
+
+unit-test member_function_cast
+  : member_function_cast.cpp : <include>$(BOOST_ROOT) ;
 
 unit-test select_from_python_test
   : select_from_python_test.cpp 
diff --git a/test/member_function_cast.cpp b/test/member_function_cast.cpp
new file mode 100644
index 00000000..986d87b5
--- /dev/null
+++ b/test/member_function_cast.cpp
@@ -0,0 +1,55 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/detail/member_function_cast.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/type.hpp>
+#include <boost/static_assert.hpp>
+
+using namespace boost;
+
+template <class T, class S>
+void assert_same(S, type<T>* = 0)
+{
+    BOOST_STATIC_ASSERT((is_same<T,S>::value));
+}
+
+template <class Expected, class Target, class F>
+void assert_mf_cast(F f, type<Expected>* = 0, type<Target>* = 0)
+{
+    assert_same<Expected>(
+        python::detail::member_function_cast<Target,F>::stage1(f).stage2((Target*)0).stage3(f)
+        );
+}
+
+struct X
+{
+    int f() const { return 0; }
+    void g(char*) {}
+};
+
+struct Y : X
+{
+    
+};
+
+struct Z : Y
+{
+    int f() const { return 0; }
+    void g(char*) {}
+};
+
+int main()
+{
+    assert_mf_cast<int (Y::*)() const, Y>(&X::f);
+    assert_mf_cast<void (Y::*)(char*), Y>(&X::g);
+
+    assert_mf_cast<int (Z::*)() const, Y>(&Z::f);
+    assert_mf_cast<void (Z::*)(char*), Y>(&Z::g);
+
+    assert_mf_cast<int, Y>(3);
+    assert_mf_cast<X, Y>(X());
+    return 0;
+};
diff --git a/test/module_tail.cpp b/test/module_tail.cpp
index 6849bf83..763e7dff 100644
--- a/test/module_tail.cpp
+++ b/test/module_tail.cpp
@@ -16,10 +16,13 @@
 extern "C" BOOL WINAPI DllMain ( HINSTANCE hInst, DWORD wDataSeg, LPVOID lpvReserved );
 
 # ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable:4297)
 extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
 {
     throw;
 }
+#  pragma warning(pop)
 # endif
 
 BOOL WINAPI DllMain(

From 08ac2877261938a38136c4f1edd087e560e63a0b Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Mar 2002 07:04:28 +0000
Subject: [PATCH 363/369] warning suppression for vc7

[SVN r13229]
---
 test/comprehensive.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index 6c7cc4d3..d4617181 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -1225,6 +1225,9 @@ extern "C" BOOL WINAPI DllMain ( HINSTANCE hInst, DWORD wDataSeg, LPVOID lpvRese
 
 # ifdef BOOST_MSVC
 extern "C" void structured_exception_translator(unsigned int, EXCEPTION_POINTERS*)
+#  if BOOST_MSVC > 1200
+    throw(...)
+#  endif 
 {
     throw;
 }

From 3b8dc924c3c0aae4b066c9254685b3bd4cb1c81c Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Mar 2002 07:06:09 +0000
Subject: [PATCH 364/369] Removed defunct workarounds

[SVN r13230]
---
 src/conversions.cpp | 19 ++-----------------
 1 file changed, 2 insertions(+), 17 deletions(-)

diff --git a/src/conversions.cpp b/src/conversions.cpp
index e6b6161a..e180af67 100644
--- a/src/conversions.cpp
+++ b/src/conversions.cpp
@@ -19,9 +19,7 @@
 #include <boost/function.hpp>
 #include <typeinfo>
 #include <exception>
-#ifndef BOOST_NO_LIMITS
-# include <boost/cast.hpp>
-#endif
+#include <boost/cast.hpp>
 
 BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
 
@@ -53,19 +51,11 @@ T integer_from_python(PyObject* p, boost::python::type<T>)
 {
     const long long_result = from_python(p, boost::python::type<long>());
 
-#ifndef BOOST_NO_LIMITS
     try
     {
         return boost::numeric_cast<T>(long_result);
     }
     catch(const boost::bad_numeric_cast&)
-#else
-    if (static_cast<T>(long_result) == long_result)
-    {
-        return static_cast<T>(long_result);
-    }
-    else
-#endif
     {
         char buffer[256];
         const char message[] = "%ld out of range for %s";
@@ -73,7 +63,7 @@ T integer_from_python(PyObject* p, boost::python::type<T>)
         PyErr_SetString(PyExc_ValueError, buffer);
         throw boost::python::argument_error();
     }
-#if defined(__MWERKS__) && __MWERKS__ <= 0x2406
+#if defined(__MWERKS__) && __MWERKS__ <= 0x2407
     return 0; // Not smart enough to know that the catch clause always rethrows
 #endif
 }
@@ -83,16 +73,11 @@ PyObject* integer_to_python(T value)
 {
     long value_as_long;
 
-#ifndef BOOST_NO_LIMITS
     try
     {
         value_as_long = boost::numeric_cast<long>(value);
     }
     catch(const boost::bad_numeric_cast&)
-#else
-    value_as_long = static_cast<long>(value);
-    if (value_as_long != value)
-#endif
     {
         const char message[] = "value out of range for Python int";
         PyErr_SetString(PyExc_ValueError, message);

From d72128107ee45312b23c18bb32b0b59ad3dcc7ab Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Wed, 20 Mar 2002 07:16:06 +0000
Subject: [PATCH 365/369] no comment

[SVN r13231]
---
 include/boost/python/conversions.hpp          | 7 +++----
 include/boost/python/detail/init_function.hpp | 6 ++++++
 src/extension_class.cpp                       | 3 +--
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/include/boost/python/conversions.hpp b/include/boost/python/conversions.hpp
index 24ac5614..f328981e 100644
--- a/include/boost/python/conversions.hpp
+++ b/include/boost/python/conversions.hpp
@@ -157,16 +157,15 @@ BOOST_PYTHON_DECL PyObject* to_python(unsigned char);
 BOOST_PYTHON_DECL unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
 unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
 
+BOOST_PYTHON_DECL float from_python(PyObject*, boost::python::type<float>);
+BOOST_PYTHON_DECL double from_python(PyObject*, boost::python::type<double>);
+
 # ifndef BOOST_MSVC6_OR_EARLIER
 PyObject* to_python(float);
-float from_python(PyObject*, boost::python::type<float>);
 PyObject* to_python(double);
-double from_python(PyObject*, boost::python::type<double>);
 # else
 BOOST_PYTHON_DECL PyObject* to_python(float);
-BOOST_PYTHON_DECL float from_python(PyObject*, boost::python::type<float>);
 BOOST_PYTHON_DECL PyObject* to_python(double);
-BOOST_PYTHON_DECL double from_python(PyObject*, boost::python::type<double>);
 # endif 
 float from_python(PyObject*, boost::python::type<const float&>);
     
diff --git a/include/boost/python/detail/init_function.hpp b/include/boost/python/detail/init_function.hpp
index 3c6f2380..048c90dd 100644
--- a/include/boost/python/detail/init_function.hpp
+++ b/include/boost/python/detail/init_function.hpp
@@ -168,6 +168,9 @@ template <class T, class A1, class A2, class A3, class A4, class A5, class A6, c
 template <class T>
 struct init_function
 {
+# ifdef BOOST_MSVC6_OR_EARLIER
+#  define typename
+# endif 
     static init* create(signature0) {
         return new init0<T>;
     }
@@ -276,6 +279,9 @@ struct init_function
                        typename detail::parameter_traits<A9>::const_reference,
                        typename detail::parameter_traits<A10>::const_reference>;
     }
+#ifdef BOOST_MSVC6_OR_EARLIER
+# undef typename
+#endif 
 };
 
 class BOOST_PYTHON_DECL init : public function
diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index cc784ca6..98505347 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -11,7 +11,6 @@
 
 #define BOOST_PYTHON_SOURCE
 
-#include <boost/python/detail/extension_class.hpp>
 #include <boost/python/detail/extension_class.hpp>
 #include <boost/python/detail/call_object.hpp>
 #include <boost/utility.hpp>
@@ -178,7 +177,7 @@ extension_instance::~extension_instance()
     }
 }
     
-meta_class<extension_instance>* extension_meta_class()
+BOOST_PYTHON_DECL meta_class<extension_instance>* extension_meta_class()
 {
     static meta_class<extension_instance> result;
     return &result;

From 0ce8ab7bcec74ee7f0ed19079e511445dfe18099 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Mar 2002 14:52:30 +0000
Subject: [PATCH 366/369] Full virtual function and abstract base support; new
 class interface.

[SVN r13253]
---
 include/boost/python/class.hpp                | 190 +++++++++++-------
 include/boost/python/class_fwd.hpp            |   7 +-
 .../boost/python/detail/arg_tuple_size.hpp    |   2 +-
 include/boost/python/detail/msvc_typeinfo.hpp |  31 +--
 include/boost/python/make_function.hpp        |   6 +-
 .../boost/python/object/class_converters.hpp  |  25 +--
 include/boost/python/object/class_wrapper.hpp |  11 +-
 include/boost/python/object/find_instance.hpp |   3 +
 include/boost/python/object/make_holder.hpp   |  36 ++--
 .../boost/python/object/pointer_holder.hpp    | 142 +++++--------
 include/boost/python/object/select_holder.hpp |  70 +++++++
 include/boost/python/object/value_holder.hpp  |  23 +--
 test/Jamfile                                  |  15 ++
 test/m1.cpp                                   |  13 +-
 test/select_holder.cpp                        |  77 +++++++
 test/virtual_functions.cpp                    |  14 +-
 test/virtual_functions.py                     |  70 +++----
 17 files changed, 430 insertions(+), 305 deletions(-)
 create mode 100644 include/boost/python/object/select_holder.hpp
 create mode 100644 test/select_holder.cpp

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index 0a9c5d87..cff0adf9 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -7,55 +7,50 @@
 # define CLASS_DWA200216_HPP
 
 # include <boost/python/class_fwd.hpp>
+# include <boost/python/bases.hpp>
+# include <boost/python/args.hpp>
 # include <boost/python/reference.hpp>
 # include <boost/python/object/class.hpp>
-# include <boost/python/object/value_holder_fwd.hpp>
 # include <boost/python/converter/type_id.hpp>
 # include <boost/python/detail/wrap_function.hpp>
 # include <boost/python/detail/member_function_cast.hpp>
-# include <boost/mpl/type_list.hpp>
 # include <boost/python/object/class_converters.hpp>
+# include <boost/type_traits/ice.hpp>
+# include <boost/type_traits/same_traits.hpp>
 # include <boost/mpl/size.hpp>
 # include <boost/mpl/for_each.hpp>
-# include <boost/python/detail/type_list.hpp>
-
-namespace // put some convenience classes into the unnamed namespace for the user
-{
-  // A type list for specifying bases
-  template < BOOST_MPL_LIST_DEFAULT_PARAMETERS(typename B, ::boost::mpl::null_argument) >
-  struct bases : ::boost::mpl::type_list< BOOST_MPL_LIST_PARAMETERS(B) >::type
-  {};
-
-  // A type list for specifying arguments
-  template < BOOST_MPL_LIST_DEFAULT_PARAMETERS(typename A, ::boost::mpl::null_argument) >
-  struct args : ::boost::mpl::type_list< BOOST_MPL_LIST_PARAMETERS(A) >::type
-  {};
-}
+# include <boost/mpl/bool_t.hpp>
+# include <boost/python/object/select_holder.hpp>
+# include <boost/python/object/class_wrapper.hpp>
+# include <boost/utility.hpp>
 
 namespace boost { namespace python { 
 
 namespace detail
 {
-  // This is an mpl BinaryMetaFunction object with a runtime behavior,
-  // which is to write the id of the type which is passed as its 2nd
-  // compile-time argument into the iterator pointed to by its runtime
-  // argument
-  struct write_type_id
-  {
-      // The first argument is Ignored because mpl::for_each is still
-      // currently an accumulate (reduce) implementation.
-      template <class Ignored, class T> struct apply
-      {
-          // also an artifact of accumulate-based for_each
-          typedef void type;
+  struct write_type_id;
+  
+  template <class T, class Prev = detail::not_specified>
+  struct select_held_type;
+  
+  template <class T1, class T2, class T3>
+  struct has_noncopyable;
 
-          // Here's the runtime behavior
-          static void execute(converter::undecorated_type_id_t** p)
-          {
-              *(*p)++ = converter::undecorated_type_id<T>();
-          }
-      };
-  };
+  // Register a to_python converter for a class T, depending on the
+  // type of the first (tag) argument. The 2nd argument is a pointer
+  // to the type of holder that must be created. The 3rd argument is a
+  // reference to the Python type object to be created.
+  template <class T, class Holder>
+  static inline void register_copy_constructor(mpl::bool_t<true> const&, Holder*, ref const& obj, T* = 0)
+  {
+      objects::class_wrapper<T,Holder> x(obj);
+  }
+
+  // Tag dispatched to have no effect.
+  template <class T, class Holder>
+  static inline void register_copy_constructor(mpl::bool_t<false> const&, Holder*, ref const&, T* = 0)
+  {
+  }
 }
 
 //
@@ -64,27 +59,24 @@ namespace detail
 //      This is the primary mechanism through which users will expose
 //      C++ classes to Python. The three template arguments are:
 //
-//        T - The class being exposed to Python
-//
-//        Bases - An MPL sequence of base classes
-//
-//        HolderGenerator -
-//           An optional type generator for the "holder" which
-//           maintains the C++ object inside the Python instance. The
-//           default just holds the object "by-value", but other
-//           holders can be substituted which will hold the C++ object
-//           by smart pointer, for example.
-//
 template <
     class T // class being wrapped
-    , class Bases
-    , class HolderGenerator
+    , class X1 // = detail::not_specified
+    , class X2 // = detail::not_specified
+    , class X3 // = detail::not_specified
     >
 class class_ : private objects::class_base
 {
-    typedef class_<T,Bases,HolderGenerator> self;
+    typedef class_<T,X1,X2,X3> self;
+    BOOST_STATIC_CONSTANT(bool, is_copyable = (!detail::has_noncopyable<X1,X2,X3>::value));
+    
+    typedef typename detail::select_held_type<
+        X1, typename detail::select_held_type<
+        X2, typename detail::select_held_type<
+        X3
+    >::type>::type>::type held_type;
+    
  public:
-
     // Automatically derive the class name - only works on some
     // compilers because type_info::name is sometimes mangled (gcc)
     class_();
@@ -130,7 +122,12 @@ class class_ : private objects::class_base
     template <class Args>
     self& def_init(Args const&)
     {
-        def("__init__", make_constructor<T,Args,HolderGenerator>());
+        def("__init__",
+            make_constructor<Args>(
+                // Using runtime type selection works around a CWPro7 bug.
+                objects::select_holder<T,held_type>((held_type*)0).get()
+                )
+            );
         return *this;
     }
 
@@ -147,6 +144,12 @@ class class_ : private objects::class_base
  private: // types
     typedef objects::class_id class_id;
     
+    typedef typename detail::select_bases<X1
+            , typename detail::select_bases<X2
+              , typename boost::python::detail::select_bases<X3>::type
+              >::type
+            >::type bases;
+    
     // A helper class which will contain an array of id objects to be
     // passed to the base class constructor
     struct id_vector
@@ -159,50 +162,97 @@ class class_ : private objects::class_base
     
             // Write the rest of the elements into succeeding positions.
             class_id* p = ids + 1;
-            mpl::for_each<Bases, void, detail::write_type_id>::execute(&p);
+            mpl::for_each<bases, void, detail::write_type_id>::execute(&p);
         }
         
         BOOST_STATIC_CONSTANT(
-            std::size_t, size = mpl::size<Bases>::value + 1);
+            std::size_t, size = mpl::size<bases>::value + 1);
         class_id ids[size];
     };
-
- private: // helper functions
-    void initialize_converters();
 };
 
 
 //
 // implementations
 //
-template <class T, class Bases, class HolderGenerator>
-inline class_<T, Bases, HolderGenerator>::class_()
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_()
     : class_base(typeid(T).name(), id_vector::size, id_vector().ids)
 {
-    // Bring the class converters into existence. This static object
-    // will survive until the shared library this module lives in is
-    // unloaded (that doesn't happen until Python terminates).
-    static objects::class_converters<T,Bases> converters(object());
+    // register converters
+    objects::register_class_from_python<T,bases>();
+    
+    detail::register_copy_constructor<T>(
+        mpl::bool_t<is_copyable>()
+        , objects::select_holder<T,held_type>((held_type*)0).get()
+        , this->object());
 }
 
-template <class T, class Bases, class HolderGenerator>
-inline class_<T, Bases, HolderGenerator>::class_(char const* name)
+template <class T, class X1, class X2, class X3>
+inline class_<T,X1,X2,X3>::class_(char const* name)
     : class_base(name, id_vector::size, id_vector().ids)
 {
-    // Bring the class converters into existence. This static object
-    // will survive until the shared library this module lives in is
-    // unloaded (that doesn't happen until Python terminates).
-    static objects::class_converters<T,Bases> converters(object());
+    // register converters
+    objects::register_class_from_python<T,bases>();
+    
+    detail::register_copy_constructor<T>(
+        mpl::bool_t<is_copyable>()
+        , objects::select_holder<T,held_type>((held_type*)0).get()
+        , this->object());
 }
 
-template <class T, class Bases, class HolderGenerator>
-inline ref class_<T, Bases, HolderGenerator>::object() const
+template <class T, class X1, class X2, class X3>
+inline ref class_<T,X1,X2,X3>::object() const
 {
     typedef objects::class_base base;
     
     return this->base::object();
 }
 
+namespace detail
+{
+  // This is an mpl BinaryMetaFunction object with a runtime behavior,
+  // which is to write the id of the type which is passed as its 2nd
+  // compile-time argument into the iterator pointed to by its runtime
+  // argument
+  struct write_type_id
+  {
+      // The first argument is Ignored because mpl::for_each is still
+      // currently an accumulate (reduce) implementation.
+      template <class Ignored, class T> struct apply
+      {
+          // also an artifact of accumulate-based for_each
+          typedef void type;
+
+          // Here's the runtime behavior
+          static void execute(converter::undecorated_type_id_t** p)
+          {
+              *(*p)++ = converter::undecorated_type_id<T>();
+          }
+      };
+  };
+
+
+  template <class T1, class T2, class T3>
+  struct has_noncopyable
+      : type_traits::ice_or<
+        is_same<T1,noncopyable>::value
+      , is_same<T2,noncopyable>::value
+      , is_same<T3,noncopyable>::value>
+  {};
+
+
+    template <class T, class Prev>
+    struct select_held_type
+        : mpl::select_type<
+        !(specifies_bases<T>::value  | is_same<T,noncopyable>::value)
+                , T
+                , Prev
+          >
+    {
+    };
+}
+
 }} // namespace boost::python
 
 #endif // CLASS_DWA200216_HPP
diff --git a/include/boost/python/class_fwd.hpp b/include/boost/python/class_fwd.hpp
index bef2e250..1ef941aa 100644
--- a/include/boost/python/class_fwd.hpp
+++ b/include/boost/python/class_fwd.hpp
@@ -5,7 +5,7 @@
 // to its suitability for any purpose.
 #ifndef CLASS_FWD_DWA200222_HPP
 # define CLASS_FWD_DWA200222_HPP
-# include <boost/python/object/value_holder_fwd.hpp>
+# include <boost/python/detail/not_specified.hpp>
 
 namespace boost { namespace python { 
 
@@ -16,8 +16,9 @@ namespace detail
 
 template <
     class T // class being wrapped
-    , class Bases = detail::empty_list
-    , class HolderGenerator = objects::value_holder_generator<>
+    , class X1 = detail::not_specified
+    , class X2 = detail::not_specified
+    , class X3 = detail::not_specified
     >
 class class_;
 
diff --git a/include/boost/python/detail/arg_tuple_size.hpp b/include/boost/python/detail/arg_tuple_size.hpp
index 04bca0af..fa38a4a9 100644
--- a/include/boost/python/detail/arg_tuple_size.hpp
+++ b/include/boost/python/detail/arg_tuple_size.hpp
@@ -103,7 +103,7 @@ struct arg_tuple_size<R (A0::*)(A1, A2, A3, A4, A5)>
 
 
 // Metrowerks thinks this creates ambiguities
-# if !defined(__MWERKS__) || __MWERKS__ > 0x2406
+# if !defined(__MWERKS__) || __MWERKS__ > 0x2407
 
 template <class R, class A0>
 struct arg_tuple_size<R (A0::*)() const>
diff --git a/include/boost/python/detail/msvc_typeinfo.hpp b/include/boost/python/detail/msvc_typeinfo.hpp
index 2473023a..3da411f0 100644
--- a/include/boost/python/detail/msvc_typeinfo.hpp
+++ b/include/boost/python/detail/msvc_typeinfo.hpp
@@ -8,7 +8,8 @@
 
 #include <boost/type.hpp>
 #include <typeinfo>
-
+#include <boost/type_traits/array_traits.hpp>
+#include <boost/type_traits/reference_traits.hpp>
 //
 // Fix for MSVC's broken typeid() implementation which doesn't strip
 // decoration. This fix doesn't handle cv-qualified array types. It
@@ -62,35 +63,35 @@ inline typeinfo typeid_nonref(boost::type<T>* = 0)
 }
 
 template <class T>
-inline typeinfo typeid_ref(boost::type<T>*, ...) 
-{
-    return typeid_nonref<T>();
-}
-
-template <class U, class T>
-inline typeinfo typeid_ref(boost::type<U>*, T& (*)()) 
+inline typeinfo typeid_ref(T&(*)()) 
 {
     return typeid_nonref<T>();
 }
 
 template <class T>
-inline typeinfo typeid_array(bool_t<false>, boost::type<T>* = 0)
+inline typeinfo array_ref_typeid(bool_t<true>, bool_t<false>, boost::type<T>* = 0)
 {
-    typedef T (*x)();
-    return typeid_ref((boost::type<T>*)0, x(0));
+    return typeid_ref((T&(*)())0);
 }
 
 template <class T>
-inline typeinfo typeid_array(bool_t<true>, boost::type<T>* = 0)
+inline typeinfo array_ref_typeid(bool_t<false>, bool_t<true>, boost::type<T>* = 0)
 {
-    return typeid_nonref<T>();
+    return typeid_ref((T(*)())0);
+}
+
+template <class T>
+inline typeinfo array_ref_typeid(bool_t<false>, bool_t<false>, boost::type<T>* = 0)
+{
+    return typeid_ref((T&(*)())0);
 }
 
 template <class T>
 inline typeinfo msvc_typeid(boost::type<T>* = 0)
 {
-    typedef bool_t<is_array<T>::value> tag;
-    return typeid_array(tag(), (boost::type<T>*)0);
+    typedef bool_t<is_array<T>::value> array_tag;
+    typedef bool_t<is_reference<T>::value> ref_tag;
+    return array_ref_typeid(array_tag(), ref_tag(), (boost::type<T>*)0);
 }
 
 }}} // namespace boost::python::detail
diff --git a/include/boost/python/make_function.hpp b/include/boost/python/make_function.hpp
index 2943d96c..6e7f1661 100644
--- a/include/boost/python/make_function.hpp
+++ b/include/boost/python/make_function.hpp
@@ -35,8 +35,8 @@ objects::function* make_function(F f, Policies const& policies)
         , detail::arg_tuple_size<F>::value);
 }
 
-template <class T, class ArgList, class Generator>
-objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
+template <class ArgList, class Holder>
+objects::function* make_constructor(Holder* = 0, ArgList* = 0)
 {
     enum { nargs = mpl::size<ArgList>::value };
     
@@ -44,7 +44,7 @@ objects::function* make_constructor(T* = 0, ArgList* = 0, Generator* = 0)
         objects::py_function(
             ::boost::bind<PyObject*>(detail::caller(),
                  objects::make_holder<nargs>
-                            ::template apply<T,Generator,ArgList>::execute
+                            ::template apply<Holder,ArgList>::execute
                  , _1, _2, default_call_policies()))
         , nargs + 1);
 }
diff --git a/include/boost/python/object/class_converters.hpp b/include/boost/python/object/class_converters.hpp
index 5c2a35ae..8f2786f3 100644
--- a/include/boost/python/object/class_converters.hpp
+++ b/include/boost/python/object/class_converters.hpp
@@ -11,27 +11,10 @@
 # include <boost/python/reference.hpp>
 # include <boost/python/converter/registry.hpp>
 # include <boost/python/object/find_instance.hpp>
+# include <boost/python/object/inheritance.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
-// Instantiating this class brings into existence all converters
-// associated with a class Bases is expected to be an mpl sequence of
-// base types.
-template <class Derived, class Bases>
-struct class_converters
-{
- public: // member functions
-    // Constructor takes the python class object associated with T
-    class_converters(ref const& python_class);
-
- private: // data members
-    class_wrapper<Derived> m_wrapper;
-};
-
-//
-// Implementation details
-//
-
 //////////////////////////////////////////////////////////////////////
 //
 // register_base_of<T> -
@@ -86,9 +69,11 @@ struct register_base_of
     };
 };
 
+
+// Brings into existence all converters associated with a class Bases
+// is expected to be an mpl sequence of base types.
 template <class Derived, class Bases>
-class_converters<Derived,Bases>::class_converters(ref const& type_object)
-    : m_wrapper(type_object)
+inline void register_class_from_python(Derived* = 0, Bases* = 0)
 {
     (void)instance_finder<Derived>::registration;
     
diff --git a/include/boost/python/object/class_wrapper.hpp b/include/boost/python/object/class_wrapper.hpp
index f8702205..577d1012 100644
--- a/include/boost/python/object/class_wrapper.hpp
+++ b/include/boost/python/object/class_wrapper.hpp
@@ -6,15 +6,14 @@
 #ifndef CLASS_WRAPPER_DWA20011221_HPP
 # define CLASS_WRAPPER_DWA20011221_HPP
 
-# include <boost/python/object/value_holder.hpp>
 # include <boost/python/reference.hpp>
 # include <boost/python/to_python_converter.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
-template <class T>
+template <class T, class Holder>
 struct class_wrapper
-    : to_python_converter<T, class_wrapper<T> >
+    : to_python_converter<T,class_wrapper<T,Holder> >
 {
     class_wrapper(ref const& type_)
         : m_class_object_keeper(type_)
@@ -39,7 +38,7 @@ struct class_wrapper
 
         // Build a value_holder to contain the object using the copy
         // constructor
-        value_holder<T>* p = new value_holder<T>(raw_result, cref(x));
+        Holder* p = new Holder(raw_result, cref(x));
 
         // Install it in the instance
         p->install(raw_result);
@@ -53,8 +52,8 @@ struct class_wrapper
     static PyTypeObject* m_class_object;
 };
 
-template <class T>
-PyTypeObject* class_wrapper<T>::m_class_object;
+template <class T, class Holder>
+PyTypeObject* class_wrapper<T,Holder>::m_class_object;
 
 }}} // namespace boost::python::objects
 
diff --git a/include/boost/python/object/find_instance.hpp b/include/boost/python/object/find_instance.hpp
index c60a82f7..3db670fc 100644
--- a/include/boost/python/object/find_instance.hpp
+++ b/include/boost/python/object/find_instance.hpp
@@ -6,6 +6,9 @@
 #ifndef FIND_INSTANCE_DWA2002312_HPP
 # define FIND_INSTANCE_DWA2002312_HPP
 
+# include <boost/python/converter/type_id.hpp>
+# include <boost/python/converter/registry.hpp>
+
 namespace boost { namespace python { namespace objects { 
 
 // Given an undecorated type_id, find the instance data which
diff --git a/include/boost/python/object/make_holder.hpp b/include/boost/python/object/make_holder.hpp
index 871ed059..59043317 100644
--- a/include/boost/python/object/make_holder.hpp
+++ b/include/boost/python/object/make_holder.hpp
@@ -10,7 +10,6 @@
 # include <boost/python/object/forward.hpp>
 # include <boost/python/object/class.hpp>
 # include <boost/python/detail/wrap_python.hpp>
-# include <boost/mpl/apply.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -19,14 +18,13 @@ template <int nargs> struct make_holder;
 template <>
 struct make_holder<0>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         static void execute(
             PyObject* p)
         {
-            (new holder(p))->install(p);
+            (new Holder(p))->install(p);
         }
     };
 };
@@ -35,10 +33,9 @@ struct make_holder<0>
 template <>
 struct make_holder<1>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         
@@ -46,7 +43,7 @@ struct make_holder<1>
             PyObject* p
             , t0 a0)
         {
-            (new holder(p, f0(a0)))->install(p);
+            (new Holder(p, f0(a0)))->install(p);
         }
     };
 };
@@ -54,10 +51,9 @@ struct make_holder<1>
 template <>
 struct make_holder<2>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -66,7 +62,7 @@ struct make_holder<2>
         static void execute(
             PyObject* p, t0 a0, t1 a1)
         {
-            (new holder(p, f0(a0), f1(a1)))->install(p);
+            (new Holder(p, f0(a0), f1(a1)))->install(p);
         }
     };
 };
@@ -74,10 +70,9 @@ struct make_holder<2>
 template <>
 struct make_holder<3>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -88,7 +83,7 @@ struct make_holder<3>
         static void execute(
             PyObject* p, t0 a0, t1 a1, t2 a2)
         {
-            (new holder(p, f0(a0), f1(a1), f2(a2)))->install(p);
+            (new Holder(p, f0(a0), f1(a1), f2(a2)))->install(p);
         }
     };
 };
@@ -96,10 +91,9 @@ struct make_holder<3>
 template <>
 struct make_holder<4>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -112,7 +106,7 @@ struct make_holder<4>
         static void execute(
             PyObject* p, t0 a0, t1 a1, t2 a2, t3 a3)
         {
-            (new holder(p, f0(a0), f1(a1), f2(a2), f3(a3)))->install(p);
+            (new Holder(p, f0(a0), f1(a1), f2(a2), f3(a3)))->install(p);
         }
     };
 };
@@ -120,10 +114,9 @@ struct make_holder<4>
 template <>
 struct make_holder<5>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -138,7 +131,7 @@ struct make_holder<5>
         static void execute(
             PyObject* p, t0 a0, t1 a1, t2 a2, t3 a3, t4 a4)
         {
-            (new holder(p, f0(a0), f1(a1), f2(a2), f3(a3), f4(a4)))->install(p);
+            (new Holder(p, f0(a0), f1(a1), f2(a2), f3(a3), f4(a4)))->install(p);
         }
     };
 };
@@ -146,10 +139,9 @@ struct make_holder<5>
 template <>
 struct make_holder<6>
 {
-    template <class T, class Generator, class ArgList>
+    template <class Holder, class ArgList>
     struct apply
     {
-        typedef typename mpl::apply1<Generator,T>::type holder;
         typedef typename mpl::at<0,ArgList>::type t0;
         typedef typename forward<t0>::type f0;
         typedef typename mpl::at<1,ArgList>::type t1;
@@ -166,7 +158,7 @@ struct make_holder<6>
         static void execute(
             PyObject* p, t0 a0, t1 a1, t2 a2, t3 a3, t4 a4, t5 a5)
         {
-            (new holder(p, f0(a0), f1(a1), f2(a2), f3(a3), f4(a4), f5(a5)))->install(p);
+            (new Holder(p, f0(a0), f1(a1), f2(a2), f3(a3), f4(a4), f5(a5)))->install(p);
         }
     };
 };
diff --git a/include/boost/python/object/pointer_holder.hpp b/include/boost/python/object/pointer_holder.hpp
index 84700299..8bce39bd 100644
--- a/include/boost/python/object/pointer_holder.hpp
+++ b/include/boost/python/object/pointer_holder.hpp
@@ -14,6 +14,7 @@
 # include <boost/type.hpp>
 # include <boost/mpl/select_type.hpp>
 # include <boost/mpl/apply.hpp>
+# include <boost/python/detail/pointee.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -147,81 +148,83 @@ struct pointer_holder : instance_holder
     Pointer m_p;
 };
 
-template <class Pointer, class Value, class BackReferenceType>
+template <class Pointer, class Value>
 struct pointer_holder_back_reference : instance_holder
 {
+ private:
+    typedef typename python::detail::pointee<Pointer>::type held_type;
+ public:
+    
     pointer_holder_back_reference(Pointer);
     
     // Forward construction to the held object
     pointer_holder_back_reference(PyObject* p)
-        : m_p(new BackReferenceType(p)) {
-        (void)instance_finder<BackReferenceType>::registration;
+        : m_p(new held_type(p)) {
+        (void)instance_finder<held_type>::registration;
     }
 
-
-    
     template <class A1>
     pointer_holder_back_reference(PyObject* p, A1 a1)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
                   ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4, class A5>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
             , (typename unwrap_reference<A4>::type&)(a4)
             , (typename unwrap_reference<A5>::type&)(a5)
             )) {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4, class A5, class A6>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -229,13 +232,13 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A5>::type&)(a5)
             , (typename unwrap_reference<A6>::type&)(a6)
             )) {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -245,13 +248,13 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A7>::type&)(a7)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -262,13 +265,13 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A8>::type&)(a8)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -280,13 +283,13 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A9>::type&)(a9)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
     
     template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
     pointer_holder_back_reference(PyObject* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10)
-        : m_p(new BackReferenceType(p
+        : m_p(new held_type(p
             , (typename unwrap_reference<A1>::type&)(a1)
             , (typename unwrap_reference<A2>::type&)(a2)
             , (typename unwrap_reference<A3>::type&)(a3)
@@ -299,7 +302,7 @@ struct pointer_holder_back_reference : instance_holder
             , (typename unwrap_reference<A10>::type&)(a10)
             ))
     {
-        (void)instance_finder<BackReferenceType>::registration;
+        (void)instance_finder<held_type>::registration;
     }
 
 
@@ -310,81 +313,18 @@ struct pointer_holder_back_reference : instance_holder
     Pointer m_p;
 };
 
-}}} // namespace boost::python::objects
-
-// back to namespace boost for this forward declaration
-namespace boost
-{
-  template <class T> class shared_ptr;
-}
-
-namespace boost { namespace python { namespace objects {
-
-struct shared_ptr_generator
-{
-    template <class T>
-    struct apply
-    {
-        typedef boost::shared_ptr<T> type;
-    };
-};
-
-struct no_back_reference;
-
-// Workaround lack of partial specialization
-namespace detail
-{
-  template <class BackReferenceType, class PointerGenerator>
-  struct pointer_holder_back_reference_generator
-  {
-      template <class Held>
-      struct apply
-      {
-          typedef typename mpl::apply1<
-              PointerGenerator,BackReferenceType
-              >::type pointer;
-              
-          typedef pointer_holder_back_reference<pointer,Held,BackReferenceType> type;
-      };
-  };
-
-  template <class PointerGenerator>
-  struct plain_pointer_holder_generator
-  {
-      template <class Held>
-      struct apply
-      {
-          typedef typename mpl::apply1<
-              PointerGenerator,Held
-              >::type pointer;
-              
-          typedef pointer_holder<pointer, Held> type;
-      };
-  };
-}
-
-// A generator metafunction which can be passed to make_holder
-// PointerGenerator should be another generator metafunction which
-// makes the appropriate (smart) pointer type to hold the argument to
-// pointer_holder_generator.
-template <class PointerGenerator, class BackReferenceType = no_back_reference>
-struct pointer_holder_generator
-    : mpl::select_type<
-          is_same<BackReferenceType,no_back_reference>::value
-          , detail::plain_pointer_holder_generator<
-                PointerGenerator>
-          , detail::pointer_holder_back_reference_generator<
-                BackReferenceType,PointerGenerator>
-      >::type
-{
-};
-
 template <class Pointer, class Value>
 pointer_holder<Pointer,Value>::pointer_holder(Pointer p)
     : m_p(p)
 {
 }
 
+template <class Pointer, class Value>
+pointer_holder_back_reference<Pointer,Value>::pointer_holder_back_reference(Pointer p)
+    : m_p(p)
+{
+}
+
 template <class Pointer, class Value>
 void* pointer_holder<Pointer, Value>::holds(converter::undecorated_type_id_t dst_t)
 {
@@ -396,6 +336,20 @@ void* pointer_holder<Pointer, Value>::holds(converter::undecorated_type_id_t dst
         : find_dynamic_type(&*this->m_p, src_t, dst_t);
 }
 
+template <class Pointer, class Value>
+void* pointer_holder_back_reference<Pointer, Value>::holds(converter::undecorated_type_id_t dst_t)
+{
+    if (dst_t == converter::undecorated_type_id<Pointer>())
+        return &this->m_p;
+
+    if (dst_t == converter::undecorated_type_id<held_type>())
+        return &*this->m_p;
+
+    converter::type_id_t src_t = converter::undecorated_type_id<Value>();
+    Value* p = &*this->m_p;
+    return src_t == dst_t ? p : find_dynamic_type(p, src_t, dst_t);
+}
+
 }}} // namespace boost::python::objects
 
 #endif // POINTER_HOLDER_DWA20011215_HPP
diff --git a/include/boost/python/object/select_holder.hpp b/include/boost/python/object/select_holder.hpp
new file mode 100644
index 00000000..39d50c0a
--- /dev/null
+++ b/include/boost/python/object/select_holder.hpp
@@ -0,0 +1,70 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef SELECT_HOLDER_DWA2002322_HPP
+# define SELECT_HOLDER_DWA2002322_HPP
+
+# include <boost/python/has_back_reference.hpp>
+# include <boost/python/detail/not_specified.hpp>
+# include <boost/python/detail/pointee.hpp>
+# include <boost/python/detail/if_else.hpp>
+# include <boost/python/object/value_holder.hpp>
+# include <boost/python/object/pointer_holder.hpp>
+# include <boost/type.hpp>
+# include <boost/mpl/select_type.hpp>
+
+namespace boost { namespace python { namespace objects {
+
+namespace detail
+{
+  template <class T, class Held>
+  struct select_value_holder
+  {
+      typedef typename mpl::select_type<
+          (!is_same<T,Held>::value) | has_back_reference<T>::value
+          , value_holder_back_reference<T,Held>
+          , value_holder<T>
+      >::type holder;
+
+      static holder* get() { return 0; }
+  };
+
+  template <class T,class Ptr>
+  struct select_pointer_holder
+  {
+      typedef typename python::detail::pointee<Ptr>::type pointee;
+      
+      typedef typename mpl::select_type<
+          (!is_same<pointee,T>::value) | has_back_reference<T>::value
+          , pointer_holder_back_reference<Ptr,T>
+          , pointer_holder<Ptr,T>
+      >::type holder;
+      
+      static holder* get() { return 0; }
+  };
+}
+
+template <class T, class NotSpecified>
+inline detail::select_value_holder<T,T> select_holder(python::detail::not_specified*, T* = 0, NotSpecified* = 0)
+{
+    return detail::select_value_holder<T,T>();
+}
+
+template <class T, class Held>
+inline detail::select_value_holder<T, Held> select_holder(T*, Held* = 0)
+{
+    return detail::select_value_holder<T, Held>();
+}
+
+
+template <class T, class Ptr>
+detail::select_pointer_holder<T,Ptr> select_holder(void*, Ptr* = 0, T* = 0)
+{
+    return detail::select_pointer_holder<T,Ptr>();
+}
+
+}}} // namespace boost::python::objects
+
+#endif // SELECT_HOLDER_DWA2002322_HPP
diff --git a/include/boost/python/object/value_holder.hpp b/include/boost/python/object/value_holder.hpp
index c0a5c580..4154a7e8 100644
--- a/include/boost/python/object/value_holder.hpp
+++ b/include/boost/python/object/value_holder.hpp
@@ -142,7 +142,7 @@ struct value_holder : instance_holder
     Held m_held;
 };
 
-template <class Held,class BackReferenceType>
+template <class Held, class BackReferenceType>
 struct value_holder_back_reference : instance_holder
 {
     // Forward construction to the held object
@@ -301,27 +301,6 @@ struct value_holder_back_reference : instance_holder
     BackReferenceType m_held;
 };
 
-// A generator metafunction which can be passed to make_holder
-template <>
-struct value_holder_generator<no_back_reference>
-{
-    template <class Held>
-    struct apply
-    {
-        typedef value_holder<Held> type;
-    };
-};
-
-template <class BackReferenceType>
-struct value_holder_generator
-{
-    template <class Held>
-    struct apply
-    {
-        typedef value_holder_back_reference<Held,BackReferenceType> type;
-    };
-};
-
 template <class Held>
 void* value_holder<Held>::holds(converter::undecorated_type_id_t dst_t)
 {
diff --git a/test/Jamfile b/test/Jamfile
index a01efdde..6db104fb 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -68,6 +68,20 @@ unit-test pointer_type_id_test
 unit-test member_function_cast
   : member_function_cast.cpp : <include>$(BOOST_ROOT) ;
 
+unit-test bases
+  : bases.cpp : <include>$(BOOST_ROOT) ;
+
+unit-test if_else
+  : if_else.cpp : <include>$(BOOST_ROOT) ;
+
+unit-test pointee
+  : pointee.cpp : <include>$(BOOST_ROOT) ;
+
+unit-test select_holder
+  : select_holder.cpp
+  : <include>$(BOOST_ROOT) <define>BOOST_PYTHON_STATIC_LIB $(PYTHON_PROPERTIES)
+;
+
 unit-test select_from_python_test
   : select_from_python_test.cpp 
     ../src/converter/type_id.cpp
@@ -77,3 +91,4 @@ unit-test select_from_python_test
     $(PYTHON_V1_PROPERTIES)
     ;
 
+
diff --git a/test/m1.cpp b/test/m1.cpp
index 439d58e2..cbaaf8db 100644
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -201,6 +201,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
 {
     using namespace boost::python;
     using boost::mpl::type_list;
+    using boost::shared_ptr;
     
     simple_to_python();
 
@@ -219,10 +220,6 @@ BOOST_PYTHON_MODULE_INIT(m1)
     
     module m1("m1");
 
-    typedef boost::python::objects::pointer_holder_generator<
-        boost::python::objects::shared_ptr_generator
-    > use_shared_ptr;
-
     m1
       // Insert the metaclass for all extension classes
       .setattr("xclass", boost::python::objects::class_metatype())
@@ -251,7 +248,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
       .def("take_d", take_d)
 
       .add(
-          class_<A, bases<>, use_shared_ptr>("A")
+          class_<A, shared_ptr<A> >("A")
           .def_init()
           .def("name", &A::name)
           )
@@ -262,13 +259,13 @@ BOOST_PYTHON_MODULE_INIT(m1)
     // or "C" below if we make them part of the same chain
     m1
         .add(
-            class_<B,bases<A>, use_shared_ptr>("B")
+            class_<B,bases<A>, shared_ptr<B> >("B")
             .def_init()
             .def("name", &B::name)
             )
         
         .add(
-            class_<C,bases<A>, use_shared_ptr>("C")
+            class_<C,bases<A>, shared_ptr<C> >("C")
             .def_init()
             .def("name", &C::name)
             )
@@ -276,7 +273,7 @@ BOOST_PYTHON_MODULE_INIT(m1)
 
     m1
         .add(
-            class_<D,bases<B,C>, use_shared_ptr>("D")
+            class_<D,shared_ptr<D>, bases<B,C> >("D")
             .def_init()
             .def("name", &D::name)
             )
diff --git a/test/select_holder.cpp b/test/select_holder.cpp
new file mode 100644
index 00000000..cb8fd640
--- /dev/null
+++ b/test/select_holder.cpp
@@ -0,0 +1,77 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/same_traits.hpp>
+#include <boost/python/object/select_holder.hpp>
+#include <boost/python/has_back_reference.hpp>
+#include <boost/python/detail/not_specified.hpp>
+#include <memory>
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+struct BR {};
+
+struct Base {};
+struct Derived : Base {};
+
+namespace boost { namespace python
+{
+  // specialization
+  template <>
+  struct has_back_reference<BR>
+  {
+      BOOST_STATIC_CONSTANT(bool, value = true);
+  };
+}} // namespace boost::python
+
+template <class T, class U>
+void assert_same(U* = 0, T* = 0)
+{
+    BOOST_TEST((boost::is_same<T,U>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<T,U>::value));
+    
+}
+
+template <class T, class Held, class Holder>
+void assert_holder(T* = 0, Held* = 0, Holder* = 0)
+{
+    assert_same<Holder>(boost::python::objects::select_holder<T,Held>((Held*)0).get());
+}
+
+int test_main(int, char * [])
+{
+    using namespace boost::python::detail;
+    using namespace boost::python::objects;
+
+    assert_holder<Base,not_specified,value_holder<Base> >();
+
+    assert_holder<BR,not_specified,value_holder_back_reference<BR,BR> >();
+    assert_holder<Base,Base,value_holder<Base> >();
+    assert_holder<BR,BR,value_holder_back_reference<BR,BR> >();
+
+    assert_holder<Base,Derived
+        ,value_holder_back_reference<Base,Derived> >();
+
+    assert_holder<Base,std::auto_ptr<Base>
+        ,pointer_holder<std::auto_ptr<Base>,Base> >();
+    
+    assert_holder<Base,std::auto_ptr<Derived>
+        ,pointer_holder_back_reference<std::auto_ptr<Derived>,Base> >();
+
+    assert_holder<BR,std::auto_ptr<BR>
+        ,pointer_holder_back_reference<std::auto_ptr<BR>,BR> > ();
+
+    return 0;
+}
+
+#if defined(__GNUC__) && __GNUC__ <= 3
+// This definition is needed for MinGW 2.95.2 for some reason
+namespace boost { namespace python
+{
+  bool handle_exception_impl(boost::function0<void>) { return false; }
+}}
+#endif 
diff --git a/test/virtual_functions.cpp b/test/virtual_functions.cpp
index ab05fe3c..586048d5 100644
--- a/test/virtual_functions.cpp
+++ b/test/virtual_functions.cpp
@@ -7,6 +7,7 @@
 #include <boost/python/module.hpp>
 #include <boost/python/returning.hpp>
 #include <boost/ref.hpp>
+#include <boost/utility.hpp>
 
 using namespace boost::python;
 
@@ -66,6 +67,10 @@ struct concrete_callback : concrete
         : concrete(x), self(p)
     {}
 
+    concrete_callback(PyObject* p, concrete const& x)
+        : concrete(x), self(p)
+    {}
+
     int f(Y const& y)
     {
         return returning<int>::call_method(self, "f", boost::ref(y));
@@ -85,26 +90,21 @@ BOOST_PYTHON_MODULE_INIT(virtual_functions_ext)
 {
     module("virtual_functions_ext")
         .add(
-            class_<concrete, bases<>, objects::value_holder_generator<concrete_callback> >("concrete")
+            class_<concrete, concrete_callback>("concrete")
             .def_init(args<int>())
             .def("value", &concrete::value)
             .def("set", &concrete::set)
             .def("call_f", &concrete::call_f)
             .def("f", &concrete_callback::f_impl))
         
-#if 0
         .add(
-            class_<abstract, bases<>
-            , objects::pointer_holder_generator<
-                boost::python::objects::shared_ptr_generator
-                , abstract_callback>
+            class_<abstract, boost::noncopyable, boost::shared_ptr<abstract_callback>
             >("abstract")
             
             .def_init(args<int>())
             .def("value", &abstract::value)
             .def("call_f", &abstract::call_f)
             .def("set", &abstract::set))
-#endif 
         
         .add(
             class_<Y>("Y")
diff --git a/test/virtual_functions.py b/test/virtual_functions.py
index 8ea992c5..9b074b1a 100644
--- a/test/virtual_functions.py
+++ b/test/virtual_functions.py
@@ -8,13 +8,13 @@
 >>> class C2(concrete):
 ...     pass
 
-<<<>>> class A1(abstract):
-<<<...     def f(self, y):
-<<<...         return abstract.f(self, Y(-y.value()))
-<<<
-<<<>>> class A2(abstract):
-<<<...     pass
-<<<
+>>> class A1(abstract):
+...     def f(self, y):
+...         return y.value() * 2
+
+>>> class A2(abstract):
+...     pass
+
 
 >>> y1 = Y(16)
 >>> y2 = Y(17)
@@ -24,33 +24,35 @@
 #
 # Test abstract with f overridden
 #
-<<<>>> a1 = A1(42)
-<<<>>> a1.value()
-<<<42
-<<<
-<<<# Call f indirectly from C++
-<<<>>> a1.call_f(y1)
-<<<-16
-<<<
-<<<# Call f directly from Python
-<<<>>> a1.f(y2)
-<<<-17
-<<<
-<<<#
-<<<# Test abstract with f not overridden
-<<<#
-<<<>>> a2 = A2(42)
-<<<>>> A2.value()
-<<<42
-<<<
-<<<# Call f indirectly from C++
-<<<>>> c1.call_f(y1)
-<<<16
-<<<
-<<<# Call f directly from Python
-<<<>>> c1.f(y2)
-<<<17
-<<<
+>>> a1 = A1(42)
+>>> a1.value()
+42
+
+# Call f indirectly from C++
+>>> a1.call_f(y1)
+32
+
+# Call f directly from Python
+>>> a1.f(y2)
+34
+
+#
+# Test abstract with f not overridden
+#
+>>> a2 = A2(42)
+>>> a2.value()
+42
+
+# Call f indirectly from C++
+>>> try: a2.call_f(y1)
+... except AttributeError: pass
+... else: print 'no exception'
+
+# Call f directly from Python
+>>> try: a2.call_f(y2)
+... except AttributeError: pass
+... else: print 'no exception'
+
 ############# Concrete Tests ############
 
 #

From 453fbbed1bf3ece47d97e3b2fd903b5e0bb186e5 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Mar 2002 15:05:58 +0000
Subject: [PATCH 367/369] initial checkin

[SVN r13255]
---
 include/boost/python/detail/not_specified.hpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 include/boost/python/detail/not_specified.hpp

diff --git a/include/boost/python/detail/not_specified.hpp b/include/boost/python/detail/not_specified.hpp
new file mode 100644
index 00000000..ce1b280d
--- /dev/null
+++ b/include/boost/python/detail/not_specified.hpp
@@ -0,0 +1,15 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef NOT_SPECIFIED_DWA2002321_HPP
+# define NOT_SPECIFIED_DWA2002321_HPP
+
+namespace boost { namespace python { namespace detail { 
+
+  struct not_specified {};
+
+}}} // namespace boost::python::detail
+
+#endif // NOT_SPECIFIED_DWA2002321_HPP

From 9d3d50c654f7a976cbcd9d2ad9543271a8ae6b79 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Mar 2002 15:19:56 +0000
Subject: [PATCH 368/369] initial checkin

[SVN r13256]
---
 include/boost/python/args.hpp               |  19 ++++
 include/boost/python/bases.hpp              |  58 ++++++++++
 include/boost/python/detail/if_else.hpp     | 117 ++++++++++++++++++++
 include/boost/python/detail/pointee.hpp     |  36 ++++++
 include/boost/python/has_back_reference.hpp |  22 ++++
 test/bases.cpp                              |  63 +++++++++++
 test/if_else.cpp                            |  61 ++++++++++
 test/pointee.cpp                            |  35 ++++++
 8 files changed, 411 insertions(+)
 create mode 100644 include/boost/python/args.hpp
 create mode 100644 include/boost/python/bases.hpp
 create mode 100644 include/boost/python/detail/if_else.hpp
 create mode 100644 include/boost/python/detail/pointee.hpp
 create mode 100644 include/boost/python/has_back_reference.hpp
 create mode 100644 test/bases.cpp
 create mode 100644 test/if_else.cpp
 create mode 100644 test/pointee.cpp

diff --git a/include/boost/python/args.hpp b/include/boost/python/args.hpp
new file mode 100644
index 00000000..b584506b
--- /dev/null
+++ b/include/boost/python/args.hpp
@@ -0,0 +1,19 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef ARGS_DWA2002323_HPP
+# define ARGS_DWA2002323_HPP
+# include <boost/mpl/type_list.hpp>
+
+namespace boost { namespace python { 
+
+// A type list for specifying arguments
+template < BOOST_MPL_LIST_DEFAULT_PARAMETERS(typename A, ::boost::mpl::null_argument) >
+struct args : ::boost::mpl::type_list< BOOST_MPL_LIST_PARAMETERS(A) >::type
+{};
+
+}} // namespace boost::python
+
+#endif // ARGS_DWA2002323_HPP
diff --git a/include/boost/python/bases.hpp b/include/boost/python/bases.hpp
new file mode 100644
index 00000000..468c6744
--- /dev/null
+++ b/include/boost/python/bases.hpp
@@ -0,0 +1,58 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef BASES_DWA2002321_HPP
+# define BASES_DWA2002321_HPP
+# include <boost/type_traits/object_traits.hpp>
+# include <boost/mpl/type_list.hpp>
+# include <boost/mpl/select_type.hpp>
+# include <boost/mpl/identity/identity.hpp>
+
+namespace boost { namespace python { 
+  // A type list for specifying bases
+  template < BOOST_MPL_LIST_DEFAULT_PARAMETERS(typename B, ::boost::mpl::null_argument) >
+  struct bases : ::boost::mpl::type_list< BOOST_MPL_LIST_PARAMETERS(B) >::type
+  {};
+
+  namespace detail
+  {
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template <class T> struct specifies_bases
+    {
+        BOOST_STATIC_CONSTANT(bool, value = false);
+    };
+    template < BOOST_MPL_LIST_PARAMETERS(class B) >
+    struct specifies_bases< bases< BOOST_MPL_LIST_PARAMETERS(B) > >
+    {
+        BOOST_STATIC_CONSTANT(bool, value = true);
+    };
+# else
+    template < BOOST_MPL_LIST_PARAMETERS(class B) >
+    static char is_bases_helper(bases< BOOST_MPL_LIST_PARAMETERS(B) > const&);
+    
+    static char (& is_bases_helper(...) )[256];
+
+    template <class T> struct specifies_bases
+    {
+     private:
+        static typename add_reference<T>::type make();
+        BOOST_STATIC_CONSTANT(bool, non_ref = !is_reference<T>::value);
+     public:
+        BOOST_STATIC_CONSTANT(bool, value = non_ref & (sizeof(is_bases_helper(make())) == 1));
+    };
+# endif
+    template <class T, class Prev = bases<> >
+    struct select_bases
+        : mpl::select_type<
+                specifies_bases<T>::value
+                , T
+                , Prev
+          >
+    {
+    };
+  }
+}} // namespace boost::python
+
+#endif // BASES_DWA2002321_HPP
diff --git a/include/boost/python/detail/if_else.hpp b/include/boost/python/detail/if_else.hpp
new file mode 100644
index 00000000..6668617c
--- /dev/null
+++ b/include/boost/python/detail/if_else.hpp
@@ -0,0 +1,117 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef IF_ELSE_DWA2002322_HPP
+# define IF_ELSE_DWA2002322_HPP
+# include <boost/config.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <class T> struct elif_selected;
+
+template <class T>
+struct if_selected
+{
+    template <bool b>
+    struct elif : elif_selected<T>
+    {
+    };
+
+    template <class U>
+    struct else_
+    {
+        typedef T type;
+    };
+};
+
+# if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+namespace msvc70_aux {
+
+template< bool > struct inherit_from
+{
+    template< typename T > struct result
+    {
+        typedef T type;
+    };
+};
+
+template<> struct inherit_from<true>
+{
+    template< typename T > struct result
+    {
+        struct type {};
+    };
+};
+
+template< typename T >
+struct never_true
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+} // namespace msvc70_aux
+
+#endif // # if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+
+template <class T>
+struct elif_selected
+{
+# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+    template <class U> class then;
+# elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
+    template <class U>
+    struct then : msvc70_aux::inherit_from< msvc70_aux::never_true<U>::value >
+        ::template result< if_selected<T> >::type
+    {
+    };
+# else
+    template <class U>
+    struct then : if_selected<T>
+    {
+    };
+# endif 
+};
+
+# if !(defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__MWERKS__) && __MWERKS__ <= 0x2407)
+template <class T>
+template <class U>
+class elif_selected<T>::then : public if_selected<T>
+{
+};
+# endif 
+
+template <bool b> struct if_
+{
+    template <class T>
+    struct then : if_selected<T>
+    {
+    };
+};
+
+struct if_unselected
+{
+    template <bool b> struct elif : if_<b>
+    {
+    };
+
+    template <class U>
+    struct else_
+    {
+        typedef U type;
+    };
+};
+
+template <>
+struct if_<false>
+{
+    template <class T>
+    struct then : if_unselected
+    {
+    };
+};
+
+}}} // namespace boost::python::detail
+
+#endif // IF_ELSE_DWA2002322_HPP
diff --git a/include/boost/python/detail/pointee.hpp b/include/boost/python/detail/pointee.hpp
new file mode 100644
index 00000000..2af1535f
--- /dev/null
+++ b/include/boost/python/detail/pointee.hpp
@@ -0,0 +1,36 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef POINTEE_DWA2002323_HPP
+# define POINTEE_DWA2002323_HPP
+
+# include <boost/type_traits/object_traits.hpp>
+
+namespace boost { namespace python { namespace detail { 
+
+template <bool is_ptr = true>
+struct pointee_impl
+{
+    template <class T> struct apply : remove_pointer<T> {};
+};
+
+template <>
+struct pointee_impl<false>
+{
+    template <class T> struct apply
+    {
+        typedef typename T::element_type type;
+    };
+};
+
+template <class T>
+struct pointee
+    : pointee_impl<is_pointer<T>::value>::template apply<T>
+{
+};
+
+}}} // namespace boost::python::detail
+
+#endif // POINTEE_DWA2002323_HPP
diff --git a/include/boost/python/has_back_reference.hpp b/include/boost/python/has_back_reference.hpp
new file mode 100644
index 00000000..95a3ae9a
--- /dev/null
+++ b/include/boost/python/has_back_reference.hpp
@@ -0,0 +1,22 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#ifndef HAS_BACK_REFERENCE_DWA2002323_HPP
+# define HAS_BACK_REFERENCE_DWA2002323_HPP
+
+namespace boost { namespace python { 
+
+// traits class which users can specialize to indicate that a class
+// contains a back-reference to its owning PyObject*
+template <class T>
+struct has_back_reference
+{
+    BOOST_STATIC_CONSTANT(bool, value = false);
+};
+
+
+}} // namespace boost::python
+
+#endif // HAS_BACK_REFERENCE_DWA2002323_HPP
diff --git a/test/bases.cpp b/test/bases.cpp
new file mode 100644
index 00000000..e4f91990
--- /dev/null
+++ b/test/bases.cpp
@@ -0,0 +1,63 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/bases.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/same_traits.hpp>
+
+struct A;
+struct B;
+
+template <class X, class Y, class Z>
+struct choose_bases
+    : boost::python::detail::select_bases<
+    X
+    , typename boost::python::detail::select_bases<
+        Y
+        , typename boost::python::detail::select_bases<Z>::type
+    >::type>
+{
+    
+};
+
+int main()
+{
+    BOOST_STATIC_ASSERT((boost::python::detail::specifies_bases<
+                         boost::python::bases<A,B> >::value));
+
+    BOOST_STATIC_ASSERT((!boost::python::detail::specifies_bases<
+                         boost::python::bases<A,B>& >::value));
+
+    BOOST_STATIC_ASSERT((!boost::python::detail::specifies_bases<
+                         void* >::value));
+
+    BOOST_STATIC_ASSERT((!boost::python::detail::specifies_bases<
+                         int >::value));
+
+    BOOST_STATIC_ASSERT((!boost::python::detail::specifies_bases<
+                         int[5] >::value));
+
+    typedef boost::python::detail::select_bases<
+        int
+        , boost::python::detail::select_bases<char*>::type > collected1;
+
+    BOOST_STATIC_ASSERT((boost::is_same<collected1::type,boost::python::bases<> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<choose_bases<int,char*,long>::type,boost::python::bases<> >::value));
+    
+    typedef boost::python::detail::select_bases<
+        int
+        , boost::python::detail::select_bases<
+                boost::python::bases<A,B>
+                , boost::python::detail::select_bases<
+                        A
+            >::type
+         >::type
+     > collected2;
+
+    BOOST_STATIC_ASSERT((boost::is_same<collected2::type,boost::python::bases<A,B> >::value));
+    BOOST_STATIC_ASSERT((boost::is_same<choose_bases<int,boost::python::bases<A,B>,long>::type,boost::python::bases<A,B> >::value));
+    
+    return 0;
+}
diff --git a/test/if_else.cpp b/test/if_else.cpp
new file mode 100644
index 00000000..d8bd34ca
--- /dev/null
+++ b/test/if_else.cpp
@@ -0,0 +1,61 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/static_assert.hpp>
+#include <boost/python/detail/if_else.hpp>
+#include <boost/type_traits/same_traits.hpp>
+
+    typedef char c1;
+    typedef char c2[2];
+    typedef char c3[3];
+    typedef char c4[4];
+
+template <unsigned size>
+struct choose
+{
+#if 1
+    typedef typename boost::python::detail::if_<
+        (sizeof(c1) == size)
+    >::template then<
+        c1
+    >::template elif<
+        (sizeof(c2) == size)
+    >::template then<
+        c2
+    >::template elif<
+        (sizeof(c3) == size)
+    >::template then<
+        c3
+    >::template elif<
+        (sizeof(c4) == size)
+    >::template then<
+        c4
+    >::template else_<void*>::type type;
+#else
+    typedef typename boost::python::detail::if_<
+        (sizeof(c1) == size)
+        , c1
+    >::template elif<
+        (sizeof(c2) == size)
+        , c2
+    >::template elif<
+        (sizeof(c3) == size)
+        , c3
+    >::template elif<
+        (sizeof(c4) == size)
+        , c4
+    >::template else_<void*>::type type;
+#endif 
+};
+
+int main()
+{
+    BOOST_STATIC_ASSERT((boost::is_same<choose<1>::type,c1>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<choose<2>::type,c2>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<choose<3>::type,c3>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<choose<4>::type,c4>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<choose<5>::type,void*>::value));
+    return 0;
+}
diff --git a/test/pointee.cpp b/test/pointee.cpp
new file mode 100644
index 00000000..7935e897
--- /dev/null
+++ b/test/pointee.cpp
@@ -0,0 +1,35 @@
+// Copyright David Abrahams 2002. Permission to copy, use,
+// modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided
+// "as is" without express or implied warranty, and with no claim as
+// to its suitability for any purpose.
+#include <boost/python/detail/pointee.hpp>
+#include <boost/type_traits/same_traits.hpp>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <boost/static_assert.hpp>
+
+struct A;
+
+int main()
+{
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<
+                boost::python::detail::pointee<std::auto_ptr<char**> >::type
+                , char**
+         >::value));
+    
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<
+             boost::python::detail::pointee<boost::shared_ptr<A> >::type
+             , A>::value));
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    BOOST_STATIC_ASSERT(
+        (boost::is_same<
+                boost::python::detail::pointee<char*>::type
+                , char
+         >::value));
+#endif 
+    return 0;
+}

From 516f30a307f5b4785e1a45cd619339d55a487035 Mon Sep 17 00:00:00 2001
From: Dave Abrahams <dave@boostpro.com>
Date: Sun, 24 Mar 2002 15:51:50 +0000
Subject: [PATCH 369/369] fixes for older KCCs

[SVN r13258]
---
 include/boost/python/class.hpp                | 9 ++++++---
 include/boost/python/object/select_holder.hpp | 7 +++++--
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp
index cff0adf9..166ced73 100644
--- a/include/boost/python/class.hpp
+++ b/include/boost/python/class.hpp
@@ -245,9 +245,12 @@ namespace detail
     template <class T, class Prev>
     struct select_held_type
         : mpl::select_type<
-        !(specifies_bases<T>::value  | is_same<T,noncopyable>::value)
-                , T
-                , Prev
+            type_traits::ice_or<
+                type_traits::ice_not<specifies_bases<T>::value>::value
+               , is_same<T,noncopyable>::value
+            >::value
+            , T
+            , Prev
           >
     {
     };
diff --git a/include/boost/python/object/select_holder.hpp b/include/boost/python/object/select_holder.hpp
index 39d50c0a..72446358 100644
--- a/include/boost/python/object/select_holder.hpp
+++ b/include/boost/python/object/select_holder.hpp
@@ -22,8 +22,10 @@ namespace detail
   template <class T, class Held>
   struct select_value_holder
   {
+      BOOST_STATIC_CONSTANT(bool, selector = (!is_same<T,Held>::value) | has_back_reference<T>::value);
+  
       typedef typename mpl::select_type<
-          (!is_same<T,Held>::value) | has_back_reference<T>::value
+          selector
           , value_holder_back_reference<T,Held>
           , value_holder<T>
       >::type holder;
@@ -35,9 +37,10 @@ namespace detail
   struct select_pointer_holder
   {
       typedef typename python::detail::pointee<Ptr>::type pointee;
+      BOOST_STATIC_CONSTANT(bool, selector = (!is_same<T,pointee>::value) | has_back_reference<T>::value);
       
       typedef typename mpl::select_type<
-          (!is_same<pointee,T>::value) | has_back_reference<T>::value
+          selector
           , pointer_holder_back_reference<Ptr,T>
           , pointer_holder<Ptr,T>
       >::type holder;