diff --git a/include/boost/python/module_builder.hpp b/include/boost/python/module_builder.hpp
deleted file mode 100644
index 222b28d7..00000000
--- a/include/boost/python/module_builder.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef MODULE_DWA051000_H_
-# define MODULE_DWA051000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/reference.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <boost/python/detail/module_init.hpp>
-
-namespace boost { namespace python {
-
-class BOOST_PYTHON_DECL module_builder_base
-{
- public:
-    // Create a module. REQUIRES: only one module_builder is created per module.
-    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);
-
-    // 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_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_base::module() const
-{
-    return m_module;
-}
-
-}} // namespace boost::python
-
-#endif
diff --git a/include/boost/python/objects.hpp b/include/boost/python/objects.hpp
deleted file mode 100644
index f2adb65b..00000000
--- a/include/boost/python/objects.hpp
+++ /dev/null
@@ -1,396 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef OBJECTS_DWA051100_H_
-# define OBJECTS_DWA051100_H_
-
-# ifdef BOOST_PYTHON_V2
-# error obsolete 
-# else
-#  include <boost/python/detail/wrap_python.hpp>
-#  include <boost/python/detail/config.hpp>
-#  include <boost/python/reference.hpp>
-#  include "boost/operators.hpp"
-#  include <utility>
-
-namespace boost { namespace python {
-
-class BOOST_PYTHON_DECL object
-{
- public:
-    explicit object(ref p);
-    
-    // Return a reference to the held object
-    ref reference() const;
-
-    // Return a raw pointer to the held object
-    PyObject* get() const;
-    
- private:
-    ref m_p;
-};
-
-class tuple;
-
-class BOOST_PYTHON_DECL tuple_base : public object
-{
- public:
-    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)
-        : tuple_base(ref(PyTuple_New(2)))
-    {
-        set_item(0, x.first);
-        set_item(1, x.second);
-    }
-    
-    template <class First, class Second>
-    tuple(const First& first, const Second& second)
-        : tuple_base(ref(PyTuple_New(2)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-    }
-    
-    template <class First, class Second, class Third>
-    tuple(const First& first, const Second& second, const Third& third)
-        : tuple_base(ref(PyTuple_New(3)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-        set_item(2, third);
-    }
-    
-    template <class First, class Second, class Third, class Fourth>
-    tuple(const First& first, const Second& second, const Third& third, const Fourth& fourth)
-        : tuple_base(ref(PyTuple_New(4)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-        set_item(2, third);
-        set_item(3, fourth);
-    }
-    
-    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_base::set_item(pos, rhs);
-    }
-};
-
-class list;
-
-struct BOOST_PYTHON_DECL list_proxy;
-struct BOOST_PYTHON_DECL list_slice_proxy;
-
-class BOOST_PYTHON_DECL list_base : public object
-{
- protected:
-    typedef list_proxy proxy;
-    typedef list_slice_proxy slice_proxy;
- public:
-    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;
-    ref operator[](std::size_t pos) const;
-    proxy operator[](std::size_t pos);
-    ref get_item(std::size_t pos) const;
-
-    void set_item(std::size_t pos, const ref& );
-    
-//    void set_item(std::size_t pos, const object& );
-
-    void insert(std::size_t index, const ref& item);
-
-    void push_back(const ref& item);
-    
-    void append(const ref& item);
-    
-    list slice(int low, int high) const;
-    slice_proxy slice(int low, int high);
-    void sort();
-    void reverse();
-    tuple as_tuple() const;
-};
-
-class 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:
-    // Construct from an owned PyObject*.
-    // Precondition: p must point to a python string.
-    explicit string(ref p);
-    explicit string(const char* s);
-    string(const char* s, std::size_t length);
-    string(const string& rhs);
-
-    enum interned_t { interned };
-    string(const char* s, interned_t);
-    
-    // Get the type object for Strings
-    static PyTypeObject* type_obj();
-
-    // Return true if the given object is a python string
-    static bool accepts(ref o);
-
-    // Return the length of the string.
-    std::size_t size() const;
-
-    // Returns a null-terminated representation of the contents of string.
-    // The pointer refers to the internal buffer of string, not a copy.
-    // The data must not be modified in any way. It must not be de-allocated. 
-    const char* c_str() const;
-
-    string& operator*=(unsigned int repeat_count);
-    string& operator+=(const string& rhs);
-    friend string operator+(string x, string y);
-    string& operator+=(const char* rhs);
-    friend string operator+(string x, const char* y);
-    friend string operator+(const char* x, string y);
-
-    void intern();
-
-    friend string operator%(const string& format, const tuple& args);
-};
-
-class dictionary;
-
-struct BOOST_PYTHON_DECL dictionary_proxy;
-
-class BOOST_PYTHON_DECL dictionary_base : public object
-{
- protected:
-    typedef dictionary_proxy proxy;
-    
- public:
-    explicit dictionary_base(ref p);
-    dictionary_base();
-    void clear();
-
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    
- public:
-    proxy operator[](ref key);
-    ref operator[](ref key) const;
-    ref get_item(const ref& key) const;
-    ref get_item(const ref& key, const ref& default_) const;
-    
-    void set_item(const ref& key, const ref& value);
-
-    void erase(ref key);
-
-//    proxy operator[](const object& key);
-//    ref operator[](const object& key) const;
-
-//    ref get_item(const object& key, ref default_ = ref()) const;
-//    void set_item(const object& key, const ref& value);
-        
-//    void erase(const object& key);
-
-    list items() const;
-    list keys() const;
-    list values() const;
-
-    std::size_t size() const;
-    // TODO: iterator support
-};
-
-struct BOOST_PYTHON_DECL dictionary_proxy
-{
-    template <class T>
-    const ref& operator=(const T& rhs)
-        { return (*this) = make_ref(rhs); }
-    const ref& operator=(const ref& rhs);
-
-    operator ref() const;
- private:
-    friend class dictionary_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 dictionary_proxy&); // Not actually implemented
- private:
-    ref m_dict;
-    ref m_key;
-};
-
-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)
-        { return (*this) = make_ref(rhs); }
-    const ref& operator=(const ref& rhs);
-    
-    operator ref() const;
-    
- private:
-    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 list_proxy&); // Not actually implemented
- private:
-    list m_list;
-    std::size_t m_index;
-};
-
-struct BOOST_PYTHON_DECL list_slice_proxy
-{
-    const list& operator=(const list& rhs);
-    operator ref() const;
-    operator list() const;
-    std::size_t size() const;
-    ref operator[](std::size_t pos) const;
- private:
-    friend class list_base;
-    list_slice_proxy(const ref& list, int low, int high);
- private:
-    ref m_list;
-    int m_low, m_high;
-};
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-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>());
-}
-
-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>());
-}
-
-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>());
-}
-
-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&>)
-{
-    return from_python(p, boost::python::type<boost::python::dictionary>());
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-# endif // !BOOST_PYTHON_V2 
-#endif // OBJECTS_DWA051100_H_
diff --git a/include/boost/python/operators.hpp b/include/boost/python/operators.hpp
deleted file mode 100644
index df401f85..00000000
--- a/include/boost/python/operators.hpp
+++ /dev/null
@@ -1,555 +0,0 @@
-//  (C) Copyright Ullrich Koethe and David Abrahams 2000-2001. Permission to
-//  copy, use, modify, sell and distribute this software is granted provided
-//  this copyright notice appears in all copies. This software is provided "as
-//  is" without express or implied warranty, and with no claim as to its
-//  suitability for any purpose.
-//
-//  The authors gratefully acknowlege the support of Dragon Systems, Inc., in
-//  producing this work.
-//
-//  Revision History:
-//  23 Jan 2001 - Another stupid typo fix by Ralf W. Grosse-Kunstleve (David Abrahams)
-//  20 Jan 2001 - Added a fix from Ralf W. Grosse-Kunstleve (David Abrahams)
-#ifndef OPERATORS_UK112000_H_
-# define OPERATORS_UK112000_H_
-# ifdef BOOST_PYTHON_V2
-
-#  include <boost/python/operators2.hpp>
-
-# else 
-
-#  include <boost/python/reference.hpp>
-#  include <boost/python/detail/functions.hpp>
-
-// When STLport is used with native streams, _STL::ostringstream().str() is not
-// _STL::string, but std::string. This confuses to_python(), so we'll use
-// strstream instead. Also, GCC 2.95.2 doesn't have sstream.
-#  if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
-#   define BOOST_PYTHON_USE_SSTREAM
-#  endif
-
-# if defined(BOOST_PYTHON_USE_SSTREAM)
-#   include <sstream>
-#  else
-#   include <strstream>
-#  endif
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_DECL tuple standard_coerce(ref l, ref r);
-
-namespace detail {
-  
-  // helper class for automatic operand type detection
-  // during operator wrapping.
-  struct auto_operand {};
-}
-
-// Define operator ids that can be or'ed together
-// (boost::python::op_add | boost::python::op_sub | boost::python::op_mul).
-// This allows to wrap several operators in one line.
-enum operator_id
-{ 
-    op_add = 0x1, 
-    op_sub = 0x2, 
-    op_mul = 0x4, 
-    op_div = 0x8, 
-    op_mod = 0x10, 
-    op_divmod =0x20, 
-    op_pow = 0x40, 
-    op_lshift = 0x80, 
-    op_rshift = 0x100, 
-    op_and = 0x200, 
-    op_xor = 0x400, 
-    op_or = 0x800, 
-    op_neg = 0x1000, 
-    op_pos = 0x2000, 
-    op_abs = 0x4000, 
-    op_invert = 0x8000, 
-    op_int = 0x10000, 
-    op_long = 0x20000, 
-    op_float = 0x40000, 
-    op_str = 0x80000,
-    op_cmp = 0x100000,
-    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:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>());
-template <long which, class operand = boost::python::detail::auto_operand>
-struct operators {};
-
-// Wrap heterogeneous operators with given left operand type. Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-//                 boost::python::left_operand<int>());
-template <class T>
-struct left_operand {};
-
-// Wrap heterogeneous operators with given right operand type. Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-//                 boost::python::right_operand<int>());
-template <class T>
-struct right_operand {};
-
-namespace detail
-{
-  template <class Specified>
-  struct operand_select
-  {
-      template <class wrapped_type>
-      struct wrapped
-      {
-          typedef Specified type;
-      };
-  };
-
-  template <>
-  struct operand_select<auto_operand>
-  {
-      template <class wrapped_type>
-      struct wrapped
-      {
-          typedef const wrapped_type& type;
-      };
-  };
-
-  template <long> struct define_operator;
-
-  // Base class which grants access to extension_class_base::add_method() to its derived classes
-  struct add_operator_base
-  {
-   protected:
-      static inline void add_method(extension_class_base* target, function* method, const char* name)
-          { target->add_method(method, name); }
-  };
-
-//
-// choose_op, choose_unary_op, and choose_rop
-//
-// These templates use "poor man's partial specialization" to generate the
-// appropriate add_method() call (if any) for a given operator and argument set.
-//
-//  Usage:
-//      choose_op<(which & op_add)>::template args<left_t,right_t>::add(ext_class);
-// 
-// (see extension_class<>::def_operators() for more examples).
-//
-  template <long op_selector>
-  struct choose_op
-  {
-      template <class Left, class Right = Left>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template operator_function<Left, Right>(),
-                         def_op::name());
-          }
-
-      };
-  };
-
-  // specialization for 0 has no effect
-  template <>
-  struct choose_op<0>
-  {
-      template <class Left, class Right = Left>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-  
-  template <long op_selector>
-  struct choose_unary_op
-  {
-      template <class Operand>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template operator_function<Operand>(),
-                         def_op::name());
-          }
-
-      };
-  };
-  
-  // specialization for 0 has no effect
-  template <>
-  struct choose_unary_op<0>
-  {
-      template <class Operand>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-  
-  template <long op_selector>
-  struct choose_rop
-  {
-      template <class Left, class Right = Left>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template roperator_function<Right, Left>(),
-                         def_op::rname());
-          }
-
-      };
-  };
-  
-  // specialization for 0 has no effect
-  template <>
-  struct choose_rop<0>
-  {
-      template <class Left, class Right = Left>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-
-
-// Fully specialize define_operator for all operators defined in operator_id above.
-// Every specialization defines one function object for normal operator calls and one
-// for operator calls with operands reversed ("__r*__" function variants).
-// Specializations for most operators follow a standard pattern: execute the expression
-// that uses the operator in question. This standard pattern is realized by the following 
-// macros so that the actual specialization can be done by just calling a macro.
-# define PY_DEFINE_BINARY_OPERATORS(id, oper)                                            \
-  template <>                                                                           \
-  struct define_operator<op_##id>                                                       \
-  {                                                                                     \
-      template <class Left, class Right = Left>                                         \
-      struct operator_function : function                                               \
-      {                                                                                 \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
-          {                                                                             \
-              tuple args(ref(arguments, ref::increment_count));                                 \
-                                                                                        \
-              return BOOST_PYTHON_CONVERSION::to_python(                                          \
-                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) oper      \
-                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()));        \
-          }                                                                             \
-                                                                                        \
-          const char* description() const                                               \
-              { return "__" #id "__"; }                                                 \
-      };                                                                                \
-                                                                                        \
-      template <class Right, class Left>                                                \
-      struct roperator_function : function                                              \
-      {                                                                                 \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
-          {                                                                             \
-              tuple args(ref(arguments, ref::increment_count));                                 \
-                                                                                        \
-              return BOOST_PYTHON_CONVERSION::to_python(                                          \
-                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) oper      \
-                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()));        \
-          }                                                                             \
-                                                                                        \
-          const char* description() const                                               \
-              { return "__r" #id "__"; }                                                \
-                                                                                        \
-      };                                                                                \
-                                                                                        \
-      static const char * name() { return "__" #id "__"; }                              \
-      static const char * rname() { return "__r" #id "__"; }                            \
-  }
-
-# define PY_DEFINE_UNARY_OPERATORS(id, oper) \
-  template <>                                                                                   \
-  struct define_operator<op_##id>                                                               \
-  {                                                                                             \
-      template <class operand>                                                                  \
-      struct operator_function : function                                                       \
-      {                                                                                         \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const                \
-          {                                                                                     \
-              tuple args(ref(arguments, ref::increment_count));                                         \
-                                                                                                \
-              return BOOST_PYTHON_CONVERSION::to_python(                                                  \
-                  oper(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>())));        \
-          }                                                                                     \
-                                                                                                \
-          const char* description() const                                                       \
-              { return "__" #id "__"; }                                                         \
-      };                                                                                        \
-                                                                                                \
-      static const char * name() { return "__" #id "__"; }                                      \
-  }
-
-  PY_DEFINE_BINARY_OPERATORS(add, +);
-  PY_DEFINE_BINARY_OPERATORS(sub, -);
-  PY_DEFINE_BINARY_OPERATORS(mul, *);
-  PY_DEFINE_BINARY_OPERATORS(div, /);
-  PY_DEFINE_BINARY_OPERATORS(mod, %);
-  PY_DEFINE_BINARY_OPERATORS(lshift, <<);
-  PY_DEFINE_BINARY_OPERATORS(rshift, >>);
-  PY_DEFINE_BINARY_OPERATORS(and, &);
-  PY_DEFINE_BINARY_OPERATORS(xor, ^);
-  PY_DEFINE_BINARY_OPERATORS(or, |);
-  PY_DEFINE_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, +);
-  PY_DEFINE_UNARY_OPERATORS(abs, abs);
-  PY_DEFINE_UNARY_OPERATORS(invert, ~);
-  PY_DEFINE_UNARY_OPERATORS(int, long);
-  PY_DEFINE_UNARY_OPERATORS(long, PyLong_FromLong);
-  PY_DEFINE_UNARY_OPERATORS(float, double);
-
-# undef PY_DEFINE_BINARY_OPERATORS
-# undef PY_DEFINE_UNARY_OPERATORS
-
-// Some operators need special treatment, e.g. because there is no corresponding 
-// expression in C++. These are specialized manually.
-
-// pow(): Manual specialization needed because an error message is required if this 
-// function is called with three arguments. The "power modulo" operator is not  
-// supported by define_operator, but can be wrapped manually (see special.html).
-  template <>
-  struct define_operator<op_pow>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
-              {
-                  PyErr_SetString(PyExc_TypeError, "expected 2 arguments, got 3");
-                  throw_argument_error();
-              }
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  pow(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()),
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()))); 
-          }
-
-          const char* description() const
-              { return "__pow__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
-              {
-                  PyErr_SetString(PyExc_TypeError, "bad operand type(s) for pow()");
-                  throw_argument_error();
-              }
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  pow(BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()),
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()))); 
-          }
-
-          const char* description() const
-              { return "__rpow__"; }
-
-      };
-
-      static const char * name() { return "__pow__"; }
-      static const char * rname() { return "__rpow__"; }
-  };
-
-// divmod(): Manual specialization needed because we must actually call two operators and
-// return a tuple containing both results
-  template <>
-  struct define_operator<op_divmod>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-              PyObject * res = PyTuple_New(2);
-
-              PyTuple_SET_ITEM(res, 0,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) /
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()))); 
-              PyTuple_SET_ITEM(res, 1,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) %
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>())));
-
-              return res; 
-          }
-
-          const char* description() const
-              { return "__divmod__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-              PyObject * res = PyTuple_New(2);
-
-              PyTuple_SET_ITEM(res, 0,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) /
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()))); 
-              PyTuple_SET_ITEM(res, 1,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) %
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>())));
-
-              return res; 
-          }
-
-          const char* description() const
-              { return "__rdivmod__"; }
-
-      };
-
-      static const char * name() { return "__divmod__"; }
-      static const char * rname() { return "__rdivmod__"; }
-  };
-
-// cmp(): Manual specialization needed because there is no three-way compare in C++.
-// It is implemented by two one-way comparisons with operators reversed in the second.
-  template <>
-  struct define_operator<op_cmp>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) <
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>())) ?
-                       - 1 :
-                       (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()) <
-                       BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>())) ?
-                           1 :
-                           0) ; 
-          }
-
-          const char* description() const
-              { return "__cmp__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) <
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>())) ?
-                       - 1 :
-                       (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()) <
-                       BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>())) ?
-                           1 :
-                           0) ; 
-          }
-
-          const char* description() const
-              { return "__rcmp__"; }
-
-      };
-
-      static const char * name() { return "__cmp__"; }
-      static const char * rname() { return "__rcmp__"; }
-  };
-
-#  ifndef BOOST_PYTHON_USE_SSTREAM
-  class unfreezer {
-   public:
-      unfreezer(std::ostrstream& s) : m_stream(s) {}
-      ~unfreezer() { m_stream.freeze(false); }
-   private:
-      std::ostrstream& m_stream;
-  };
-#  endif
-  
-// str(): Manual specialization needed because the string conversion does not follow
-// the standard pattern relized by the macros.
-  template <>
-  struct define_operator<op_str>
-  {
-      template <class operand>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject*) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-// When STLport is used with native streams, _STL::ostringstream().str() is not
-// _STL::string, but std::string.
-#  ifdef BOOST_PYTHON_USE_SSTREAM
-              std::ostringstream s;
-              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>());
-              return BOOST_PYTHON_CONVERSION::to_python(s.str()); 
-#  else
-              std::ostrstream s;
-              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>()) << char();
-              auto unfreezer unfreeze(s);
-              return BOOST_PYTHON_CONVERSION::to_python(const_cast<char const *>(s.str())); 
-#  endif
-          }
-
-          const char* description() const
-              { return "__str__"; }
-
-      };
-
-      static const char * name() { return "__str__"; }
-  };
-
-
-} // namespace detail
-
-}} // namespace boost::python
-
-#  undef BOOST_PYTHON_USE_SSTREAM
-# endif 
-#endif /* OPERATORS_UK112000_H_ */
diff --git a/include/boost/python/reference.hpp b/include/boost/python/reference.hpp
deleted file mode 100644
index f070f114..00000000
--- a/include/boost/python/reference.hpp
+++ /dev/null
@@ -1,236 +0,0 @@
-//  (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and
-//  distribute this software is granted provided this copyright notice appears
-//  in all copies. This software is provided "as is" without express or implied
-//  warranty, and with no claim as to its suitability for any purpose.
-//
-//  The author gratefully acknowleges the support of Dragon Systems, Inc., in
-//  producing this work.
-
-#ifndef PYPTR_DWA050400_H_
-# define PYPTR_DWA050400_H_
-
-# ifdef BOOST_PYTHON_V2
-
-#  error obsolete 
-
-# else
-
-# include <boost/python/detail/config.hpp>
-# include <boost/operators.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/cast.hpp>
-# include <cassert>
-# include <cstddef>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/errors.hpp>
-# include <boost/python/detail/cast.hpp>
-
-#  include <boost/python/conversions.hpp>
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-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&>)
-        { return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
-
-    inline friend T from_python(PyObject* x, boost::python::type<T>)
-        { return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
-    
-    inline friend PyObject* to_python(T x)
-        { return boost::python::as_object(x.release()); }
-    
-};
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
-
-template <class T>
-class reference
-    : public py_ptr_conversions<reference<T>, T>
-{
-public:
-    typedef T value_type;
-    
-    reference(const reference& rhs)
-        : m_p(rhs.m_p)
-    {
-        assert(m_p == 0 || m_p->ob_refcnt > 0);
-        Py_XINCREF(m_p);
-    }
-
-    reference() : m_p(0) {}
-    
-    // These are two ways of spelling the same thing, that we need to increment
-    // the reference count on the pointer when we're initialized.
-    enum increment_count_t { increment_count };
-
-    enum allow_null { null_ok };
-    
-    template <class T2>
-    explicit reference(T2* x)
-        : m_p(expect_non_null(x))
-    {
-        assert(m_p->ob_refcnt > 0);
-    }
-
-    template <class T2>
-    reference(T2* x, increment_count_t)
-        : 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)
-    {
-        assert(m_p == 0 || m_p->ob_refcnt > 0);
-    }
-
-    template <class T2>
-    reference(T2* x, allow_null, increment_count_t)
-        : 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)
-    {
-        assert(m_p == 0 || m_p->ob_refcnt > 0);
-        Py_XINCREF(m_p);
-    }
-    
-    reference& operator=(const reference& rhs)
-    {
-        assert(rhs.m_p == 0 || rhs.m_p->ob_refcnt > 0);
-        Py_XINCREF(static_cast<PyObject*>(rhs.m_p));
-        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
-    {
-        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
-    {
-        assert(m_p == 0 || m_p->ob_refcnt > 0);
-        return &**this;
-    } 
-    
-    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()
-    {
-        assert(m_p == 0 || m_p->ob_refcnt > 0);
-        Py_XDECREF(m_p);
-        m_p = 0;
-    }
-    
-    template <class T2>
-    void reset(T2* 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)
-    {
-        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);
-    }
-    
-    template <class T2>
-    void reset(T2* x, allow_null)
-    {
-        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)
-    {
-        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);
-    }
-    
-    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);
-    }
-    
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-private:
-    template<typename Y> friend class shared_ptr;
-#endif
-
-    inline PyObject* object() const
-        {
-            return as_object(m_p);
-        }
-
-    T* m_p;
-};
-
-typedef reference<PyObject> ref;
-
-template <class T>
-ref make_ref(const T& x)
-{
-    return ref(to_python(x));
-}
-
-}} // namespace boost::python
-
-#endif // BOOST_PYTHON_V2
-
-#endif // PYPTR_DWA050400_H_