Phoenix Reloaded

[SVN r53348]
Fixed most tab and min/max issues from trunk inspection report
2026-01-20 04:42:28 +00:00 · 2009-05-28 17:15:17 +00:00 · 2009-05-20 19:19:00 +00:00 · 2009-05-09 22:57:30 +00:00 · 2009-04-26 14:46:18 +00:00 · 2009-04-09 17:30:13 +00:00
68 changed files with 687 additions and 989 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,66 @@
+if (PYTHON_LIBRARIES)
+  include_directories(${PYTHON_INCLUDE_PATH})
+
+  # Determine extra libraries we need to link against to build Python
+  # extension modules.
+  if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "dl")
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
+    endif(CMAKE_COMPILER_IS_GNUCXX)
+  elseif(CMAKE_SYSTEM_NAME MATCHES ".*BSD")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "DragonFly")
+    # DragonFly is a variant of FreeBSD
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread")
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "OSF")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
+    endif(CMAKE_COMPILER_IS_GNUCXX)    
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "QNX")
+    # No options necessary for QNX
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+    # No options necessary for Mac OS X
+  elseif(CMAKE_SYSTEM_NAME STREQUAL "HP-UX")
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "rt")
+  elseif(UNIX)
+    # Assume -pthread and -ldl on all other variants
+    set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "pthread" "dl")
+    if(CMAKE_COMPILER_IS_GNUCXX)
+      set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} "util")
+    endif(CMAKE_COMPILER_IS_GNUCXX)    
+  endif(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+
+################################################################################
+#-- Macro for building Boost.Python extension modules
+  macro(boost_python_extension MODULE_NAME)
+    parse_arguments(BPL_EXT 
+      "" 
+      "" 
+      ${ARGN})
+      
+    boost_add_single_library(
+      ${MODULE_NAME}
+      ${BPL_EXT_DEFAULT_ARGS}
+      MODULE
+      LINK_LIBS ${PYTHON_LIBRARIES}
+      DEPENDS boost_python
+      SHARED
+    )
+       
+  endmacro(boost_python_extension)
+#--
+################################################################################
+
+
+  boost_library_project(
+    Python
+    SRCDIRS src
+    TESTDIRS test
+    HEADERS python.hpp python
+    MODULARIZED
+    DESCRIPTION "A framework for interfacing Python and C++. It allows you to quickly and seamlessly expose C++ classes functions and objects to Python, and vice-versa, using no special tools -- just your C++ compiler."
+    AUTHORS "David Abrahams <dave -at- boostpro.com>"
+    )
+endif (PYTHON_LIBRARIES)
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -4,7 +4,6 @@

 import os ;
 import modules ;
-import feature ;

 import python ;

@@ -23,22 +22,6 @@ if ! [ python.configured ] && ! ( --without-python in  [ modules.peek : ARGV ] )
    }
 }

-rule find-py3-version
-{
-    local versions = [ feature.values python ] ;
-    local py3ver ;
-    for local v in $(versions)
-    {
-        if $(v) >= 3.0
-        {
-            py3ver = $(v) ;
-        }
-    }
-    return $(py3ver) ;
-}
-
-py3-version = [ find-py3-version ] ;
-
 project boost/python
  : source-location ../src
  ;
@@ -46,79 +29,66 @@ project boost/python
 rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { return $(no) ; } }
 rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }

-rule lib_boost_python ( is-py3 ? )
-{
+lib boost_python
+    : # sources
+    numeric.cpp
+    list.cpp
+    long.cpp
+    dict.cpp
+    tuple.cpp
+    str.cpp
+    slice.cpp

-    lib [ cond $(is-py3) : boost_python3 : boost_python ]
-        : # sources
-        numeric.cpp
-        list.cpp
-        long.cpp
-        dict.cpp
-        tuple.cpp
-        str.cpp
-        slice.cpp
+    converter/from_python.cpp
+    converter/registry.cpp
+    converter/type_id.cpp
+    object/enum.cpp
+    object/class.cpp
+    object/function.cpp
+    object/inheritance.cpp
+    object/life_support.cpp
+    object/pickle_support.cpp
+    errors.cpp
+    module.cpp
+    converter/builtin_converters.cpp
+    converter/arg_to_python_base.cpp
+    object/iterator.cpp
+    object/stl_iterator.cpp
+    object_protocol.cpp
+    object_operators.cpp
+    wrapper.cpp
+    import.cpp
+    exec.cpp
+    object/function_doc_signature.cpp
+    :   # requirements
+        <link>static:<define>BOOST_PYTHON_STATIC_LIB 
+        <define>BOOST_PYTHON_SOURCE
+      
+        # On Windows, all code using Python has to link to the Python
+        # import library.
+        #
+        # On *nix we never link libboost_python to libpython.  When
+        # extending Python, all Python symbols are provided by the
+        # Python interpreter executable.  When embedding Python, the
+        # client executable is expected to explicitly link to
+        # /python//python (the target representing libpython) itself.
+        #
+        # python_for_extensions is a target defined by Boost.Build to
+        # provide the Python include paths, and on Windows, the Python
+        # import library, as usage requirements.
+        [ cond [ python.configured ] : <library>/python//python_for_extensions ]
+        
+        # we prevent building when there is no python available
+        # as it's not possible anyway, and to cause dependents to
+        # fail to build
+        [ unless [ python.configured ] : <build>no ]

-        converter/from_python.cpp
-        converter/registry.cpp
-        converter/type_id.cpp
-        object/enum.cpp
-        object/class.cpp
-        object/function.cpp
-        object/inheritance.cpp
-        object/life_support.cpp
-        object/pickle_support.cpp
-        errors.cpp
-        module.cpp
-        converter/builtin_converters.cpp
-        converter/arg_to_python_base.cpp
-        object/iterator.cpp
-        object/stl_iterator.cpp
-        object_protocol.cpp
-        object_operators.cpp
-        wrapper.cpp
-        import.cpp
-        exec.cpp
-        object/function_doc_signature.cpp
-        :   # requirements
-            <link>static:<define>BOOST_PYTHON_STATIC_LIB 
-            <define>BOOST_PYTHON_SOURCE
-          
-            # On Windows, all code using Python has to link to the Python
-            # import library.
-            #
-            # On *nix we never link libboost_python to libpython.  When
-            # extending Python, all Python symbols are provided by the
-            # Python interpreter executable.  When embedding Python, the
-            # client executable is expected to explicitly link to
-            # /python//python (the target representing libpython) itself.
-            #
-            # python_for_extensions is a target defined by Boost.Build to
-            # provide the Python include paths, and on Windows, the Python
-            # import library, as usage requirements.
-            [ cond [ python.configured ] : <library>/python//python_for_extensions ]
-            
-            # we prevent building when there is no python available
-            # as it's not possible anyway, and to cause dependents to
-            # fail to build
-            [ unless [ python.configured ] : <build>no ]
+        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+    :   # default build
+        <link>shared
+    :   # usage requirements
+        <link>static:<define>BOOST_PYTHON_STATIC_LIB
+        <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+    ;

-            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-            [ cond $(is-py3) : <python>$(py3-version) ]
-        :   # default build
-            <link>shared
-        :   # usage requirements
-            <link>static:<define>BOOST_PYTHON_STATIC_LIB
-            <python-debugging>on:<define>BOOST_DEBUG_PYTHON
-        ;
-
-}
-
-lib_boost_python ;
 boost-install boost_python ;
-
-if $(py3-version)
-{
-    lib_boost_python yes ;
-    boost-install boost_python3 ;
-}
--- a/doc/news.html
+++ b/doc/news.html
@@ -32,43 +32,7 @@
  <hr>

  <dl class="page-index">
-
    <dt>Current SVN</dt>
-    <dd>
-      <ul>
-        <li>Python 3 support:</li>
-          <ul>
-              <li>All the current Boost.Python test cases passed. Extension modules using 
-                  Boost.Python expected to support Python 3 smoothly.</li>
-              <li>Introduced <code>object.contains</code> where <code>x.contains(y)</code>
-                   is equivalent to Python code <code>y in x</code>. 
-                  Now <code>dict.has_key</code> is just a wrapper of <code>object.contains</code>.
-              </li>
-              <li>When building against Python 3, <code>str.decode</code> will be removed.</li>
-              <li>When building against Python 3, the original signature of <code>list.sort</code>, which is:
-                  <pre>void sort(object_cref cmpfunc);</pre>
-                  will change to:
-                  <pre>void sort(args_proxy const &args, kwds_proxy const &kwds);</pre>
-
-                  This is because in Python 3 <code>list.sort</code> requires all its arguments be keyword arguments.
-                  So you should call it like this:
-                  <pre>x.sort(*tuple(), **dict(make_tuple(make_tuple("reverse", true))));</pre>
-
-              </li>
-              <li>According to <a href="http://www.python.org/dev/peps/pep-3123/">PEP 3123</a>, 
-                  when building Boost.Python against Python older than 2.6, the following macros will
-                  be defined in Boost.Python header:
-                <pre>
-# define Py_TYPE(o)    (((PyObject*)(o))->ob_type)
-# define Py_REFCNT(o)  (((PyObject*)(o))->ob_refcnt)
-# define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)</pre>
-                  So extension writers can use these macro directly, to make code clean and compatible with Python 3.
-              </li>
-          </ul> 
-      </ul>
-    </dd>
-
-    <dt>1.39.0 Release</dt>

    <dd>
      <ul>
--- a/doc/tutorial/doc/tutorial.qbk
+++ b/doc/tutorial/doc/tutorial.qbk
@@ -186,6 +186,10 @@ And so on... Finally:
 Or something similar. If all is well, you should now have built the DLLs and
 run the Python program.

+[note Starting from Boost 1.35, bjam erases the generated executables
+(e.g. pyd file) after the test has concluded to conserve disk space.
+To keep bjam from doing that, pass --preserve-test-targets to bjam.]
+
 [:[*There you go... Have fun!]]

 [endsect]
--- a/example/tutorial/Jamroot
+++ b/example/tutorial/Jamroot
@@ -2,15 +2,6 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-import python ;
-
-if ! [ python.configured ]
-{
-    ECHO "notice: no Python configured in user-config.jam" ;
-    ECHO "notice: will use default configuration" ;
-    using python ;
-}
-
 # Specify the path to the Boost project.  If you move this project,
 # adjust this path to refer to the Boost root directory.
 use-project boost
--- a/include/boost/python/converter/builtin_converters.hpp
+++ b/include/boost/python/converter/builtin_converters.hpp
@@ -90,14 +90,6 @@ namespace detail
        BOOST_PYTHON_ARG_TO_PYTHON_BY_VALUE(T,expr)

 // Specialize converters for signed and unsigned T to Python Int
-#if PY_VERSION_HEX >= 0x03000000
-
-# define BOOST_PYTHON_TO_INT(T)                                         \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyLong_FromLong(x), &PyLong_Type)      \
-    BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned T, ::PyLong_FromUnsignedLong(x), &PyLong_Type)
-
-#else
-
 # define BOOST_PYTHON_TO_INT(T)                                         \
    BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed T, ::PyInt_FromLong(x), &PyInt_Type)      \
    BOOST_PYTHON_TO_PYTHON_BY_VALUE(                                    \
@@ -106,7 +98,6 @@ namespace detail
                (std::numeric_limits<long>::max)())                     \
        ? ::PyLong_FromUnsignedLong(x)                                  \
        : ::PyInt_FromLong(x), &PyInt_Type)
-#endif

 // Bool is not signed.
 #if PY_VERSION_HEX >= 0x02030000
@@ -125,24 +116,17 @@ BOOST_PYTHON_TO_INT(long)
 // using Python's macro instead of Boost's - we don't seem to get the
 // config right all the time.
 # ifdef HAVE_LONG_LONG 
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x), &PyLong_Type)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x), &PyLong_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(signed BOOST_PYTHON_LONG_LONG, ::PyLong_FromLongLong(x), &PyInt_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(unsigned BOOST_PYTHON_LONG_LONG, ::PyLong_FromUnsignedLongLong(x), &PyInt_Type)
 # endif
    
 # undef BOOST_TO_PYTHON_INT

-#if PY_VERSION_HEX >= 0x03000000
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x), &PyUnicode_Type)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x), &PyUnicode_Type)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyUnicode_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size())), &PyUnicode_Type)
-#else
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char, converter::do_return_to_python(x), &PyString_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(char const*, converter::do_return_to_python(x), &PyString_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::string, ::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size())), &PyString_Type)
-#endif
-
 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
-BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size())), &PyUnicode_Type)
+BOOST_PYTHON_TO_PYTHON_BY_VALUE(std::wstring, ::PyUnicode_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size())), &PyString_Type)
 # endif 
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(float, ::PyFloat_FromDouble(x), &PyFloat_Type)
 BOOST_PYTHON_TO_PYTHON_BY_VALUE(double, ::PyFloat_FromDouble(x), &PyFloat_Type)
--- a/include/boost/python/converter/pyobject_traits.hpp
+++ b/include/boost/python/converter/pyobject_traits.hpp
@@ -34,9 +34,7 @@ struct pyobject_traits<PyObject>
 // This is not an exhaustive list; should be expanded.
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Type);
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(List);
-#if PY_VERSION_HEX < 0x03000000
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Int);
-#endif
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Long);
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Dict);
 BOOST_PYTHON_BUILTIN_OBJECT_TRAITS(Tuple);
--- a/include/boost/python/detail/decorated_type_id.hpp
+++ b/include/boost/python/detail/decorated_type_id.hpp
@@ -55,8 +55,8 @@ inline decorated_type_info::decorated_type_info(type_info base_t, decoration dec
 inline bool decorated_type_info::operator<(decorated_type_info const& rhs) const
 {
    return m_decoration < rhs.m_decoration
-      || (m_decoration == rhs.m_decoration
-          && m_base_type < rhs.m_base_type);
+        || m_decoration == rhs.m_decoration
+           && m_base_type < rhs.m_base_type;
 }

 inline bool decorated_type_info::operator==(decorated_type_info const& rhs) const
--- a/include/boost/python/detail/operator_id.hpp
+++ b/include/boost/python/detail/operator_id.hpp
@@ -47,11 +47,7 @@ enum operator_id
    op_ixor,
    op_ior,
    op_complex,
-#if PY_VERSION_HEX >= 0x03000000
-    op_bool,
-#else
    op_nonzero,
-#endif
    op_repr
 };

--- a/include/boost/python/detail/translate_exception.hpp
+++ b/include/boost/python/detail/translate_exception.hpp
@@ -2,15 +2,13 @@
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
-#ifndef TRANSLATE_EXCEPTION_TDS20091020_HPP
-# define TRANSLATE_EXCEPTION_TDS20091020_HPP
+#ifndef TRANSLATE_EXCEPTION_DWA2002810_HPP
+# define TRANSLATE_EXCEPTION_DWA2002810_HPP

 # include <boost/python/detail/exception_handler.hpp>

 # include <boost/call_traits.hpp>
 # include <boost/type_traits/add_const.hpp>
-# include <boost/type_traits/add_reference.hpp>
-# include <boost/type_traits/remove_reference.hpp>

 # include <boost/function/function0.hpp>

--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -175,19 +175,6 @@ typedef int pid_t;
        ( (op)->ob_type = (typeobj), _Py_NewReference((PyObject *)(op)), (op) )
 #endif

-// Define Python 3 macros for Python 2.x
-#if PY_VERSION_HEX < 0x02060000
-
-# define Py_TYPE(o)    (((PyObject*)(o))->ob_type)
-# define Py_REFCNT(o)  (((PyObject*)(o))->ob_refcnt)
-# define Py_SIZE(o)    (((PyVarObject*)(o))->ob_size)
-
-# define PyVarObject_HEAD_INIT(type, size)	\
-  	PyObject_HEAD_INIT(type) size,
-
-#endif
-
-
 #ifdef __MWERKS__
 # pragma warn_possunwant off
 #elif _MSC_VER
--- a/include/boost/python/enum.hpp
+++ b/include/boost/python/enum.hpp
@@ -79,11 +79,7 @@ void* enum_<T>::convertible_from_python(PyObject* obj)
 template <class T>
 void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)
 {
-#if PY_VERSION_HEX >= 0x03000000
-    T x = static_cast<T>(PyLong_AS_LONG(obj));
-#else
    T x = static_cast<T>(PyInt_AS_LONG(obj));
-#endif
    void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
    new (storage) T(x);
    data->convertible = storage;
--- a/include/boost/python/exec.hpp
+++ b/include/boost/python/exec.hpp
@@ -20,13 +20,6 @@ object
 BOOST_PYTHON_DECL
 eval(str string, object global = object(), object local = object());

-// Execute an individual python statement from str.
-// global and local are the global and local scopes respectively,
-// used during execution.
-object 
-BOOST_PYTHON_DECL
-exec_statement(str string, object global = object(), object local = object());
-
 // Execute python source code from str.
 // global and local are the global and local scopes respectively,
 // used during execution.
--- a/include/boost/python/list.hpp
+++ b/include/boost/python/list.hpp
@@ -19,7 +19,7 @@ namespace detail
  {
      void append(object_cref); // append object to end

-      ssize_t count(object_cref value) const; // return number of occurrences of value
+      long count(object_cref value) const; // return number of occurrences of value

      void extend(object_cref sequence); // extend list by appending sequence elements
    
@@ -37,12 +37,8 @@ namespace detail
      void reverse(); // reverse *IN PLACE*

      void sort(); //  sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1
-#if PY_VERSION_HEX >= 0x03000000
-      void sort(args_proxy const &args, 
-                 kwds_proxy const &kwds);
-#else
      void sort(object_cref cmpfunc);
-#endif
+

   protected:
      list_base(); // new list
@@ -117,15 +113,13 @@ class list : public detail::list_base
        base::remove(object(value));
    }

-#if PY_VERSION_HEX <= 0x03000000
    void sort() { base::sort(); }
-
+    
    template <class T>
    void sort(T const& value)
    {
        base::sort(object(value));
    }
-#endif
    
 public: // implementation detail -- for internal use only
    BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(list, base)
--- a/include/boost/python/lvalue_from_pytype.hpp
+++ b/include/boost/python/lvalue_from_pytype.hpp
@@ -63,7 +63,7 @@ struct extract_member
 {
    static MemberType& execute(InstanceType& c)
    {
-        (void)Py_TYPE(&c); // static assertion
+        (void)c.ob_type; // static assertion
        return c.*member;
    }
 };
@@ -75,7 +75,7 @@ struct extract_identity
 {
    static InstanceType& execute(InstanceType& c)
    {
-        (void)Py_TYPE(&c); // static assertion
+        (void)c.ob_type; // static assertion
        return c;
    }
 };
--- a/include/boost/python/module_init.hpp
+++ b/include/boost/python/module_init.hpp
@@ -11,49 +11,40 @@

 namespace boost { namespace python { namespace detail {

-BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
+BOOST_PYTHON_DECL void init_module(char const* name, void(*)());

 }}}

-#  if PY_VERSION_HEX >= 0x03000000
+#  if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(BOOST_PYTHON_STATIC_MODULE)

-#   define _BOOST_PYTHON_MODULE_INIT(name)              \
-PyObject* PyInit_##name()      \
-{                                                       \
-    return boost::python::detail::init_module(          \
-            #name,&init_module_##name);                 \
-}                                                       \
-void init_module_##name()
-
-#  else
-
-#   define _BOOST_PYTHON_MODULE_INIT(name)              \
-void init##name()                                       \
+#   define BOOST_PYTHON_MODULE_INIT(name)               \
+void init_module_##name();                              \
+extern "C" __declspec(dllexport) void init##name()      \
 {                                                       \
    boost::python::detail::init_module(                 \
        #name,&init_module_##name);                     \
 }                                                       \
 void init_module_##name()

-#  endif
-
-#  if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(BOOST_PYTHON_STATIC_MODULE)
-
-#   define BOOST_PYTHON_MODULE_INIT(name)                           \
-void init_module_##name();                                          \
-extern "C" __declspec(dllexport) _BOOST_PYTHON_MODULE_INIT(name)
-
 #  elif BOOST_PYTHON_USE_GCC_SYMBOL_VISIBILITY

 #   define BOOST_PYTHON_MODULE_INIT(name)                               \
 void init_module_##name();                                              \
-extern "C" __attribute__ ((visibility("default"))) _BOOST_PYTHON_MODULE_INIT(name)
+extern "C" __attribute__ ((visibility("default"))) void init##name()    \
+{                                                                       \
+    boost::python::detail::init_module(#name, &init_module_##name);     \
+}                                                                       \
+void init_module_##name()

 #  else

 #   define BOOST_PYTHON_MODULE_INIT(name)                               \
 void init_module_##name();                                              \
-extern "C" _BOOST_PYTHON_MODULE_INIT(name)
+extern "C"  void init##name()                                           \
+{                                                                       \
+    boost::python::detail::init_module(#name, &init_module_##name);     \
+}                                                                       \
+void init_module_##name()

 #  endif

--- a/include/boost/python/object/iterator.hpp
+++ b/include/boost/python/object/iterator.hpp
@@ -129,11 +129,7 @@ namespace detail
      return class_<range_>(name, no_init)
          .def("__iter__", identity_function())
          .def(
-#if PY_VERSION_HEX >= 0x03000000
-              "__next__"
-#else
              "next"
-#endif
            , make_function(
                next_fn()
              , policies
--- a/include/boost/python/object/make_instance.hpp
+++ b/include/boost/python/object/make_instance.hpp
@@ -43,7 +43,7 @@ struct make_instance_impl
              
            // Note the position of the internally-stored Holder,
            // for the sake of destruction
-            Py_SIZE(instance) = offsetof(instance_t, storage);
+            instance->ob_size = offsetof(instance_t, storage);

            // Release ownership of the python object
            protect.cancel();
--- a/include/boost/python/object_core.hpp
+++ b/include/boost/python/object_core.hpp
@@ -126,10 +126,6 @@ namespace api
      const_object_objattribute attr(object const&) const;
      object_objattribute attr(object const&);

-      // Wrap 'in' operator (aka. __contains__)
-      template <class T>
-      object contains(T const& key) const;
-      
      // item access
      //
      const_object_item operator[](object_cref) const;
@@ -487,15 +483,6 @@ object api::object_operators<U>::operator()(detail::args_proxy const &args,
 
 }  

-
-template <typename U>
-template <class T>
-object api::object_operators<U>::contains(T const& key) const
-{
-    return this->attr("__contains__")(object(key));
-}
-
-
 inline object::object()
    : object_base(python::incref(Py_None))
 {}
--- a/include/boost/python/object_operators.hpp
+++ b/include/boost/python/object_operators.hpp
@@ -60,9 +60,7 @@ inline
 object_operators<U>::operator bool_type() const
 {
    object_cref2 x = *static_cast<U const*>(this);
-    int is_true = PyObject_IsTrue(x.ptr());
-    if (is_true < 0) throw_error_already_set();
-    return is_true ? &object::ptr : 0;
+    return PyObject_IsTrue(x.ptr()) ? &object::ptr : 0;
 }

 template <class U>
@@ -70,9 +68,7 @@ inline bool
 object_operators<U>::operator!() const
 {
    object_cref2 x = *static_cast<U const*>(this);
-    int is_true = PyObject_IsTrue(x.ptr());
-    if (is_true < 0) throw_error_already_set();
-    return !is_true;
+    return !PyObject_IsTrue(x.ptr());
 }

 # define BOOST_PYTHON_COMPARE_OP(op, opid)                              \
--- a/include/boost/python/opaque_pointer_converter.hpp
+++ b/include/boost/python/opaque_pointer_converter.hpp
@@ -121,7 +121,8 @@ opaque<Pointee> opaque<Pointee>::instance;
 template <class Pointee>
 PyTypeObject opaque<Pointee>::type_object =
 {
-    PyVarObject_HEAD_INIT(NULL, 0)
+    PyObject_HEAD_INIT(0)
+    0,
    0,
    sizeof( BOOST_DEDUCED_TYPENAME opaque<Pointee>::python_instance ),
    0,
--- a/include/boost/python/operators.hpp
+++ b/include/boost/python/operators.hpp
@@ -341,11 +341,7 @@ BOOST_PYTHON_UNARY_OPERATOR(neg, -, operator-)
 BOOST_PYTHON_UNARY_OPERATOR(pos, +, operator+)
 BOOST_PYTHON_UNARY_OPERATOR(abs, abs, abs)
 BOOST_PYTHON_UNARY_OPERATOR(invert, ~, operator~)
-#if PY_VERSION_HEX >= 0x03000000
-BOOST_PYTHON_UNARY_OPERATOR(bool, !!, operator!)
-#else
 BOOST_PYTHON_UNARY_OPERATOR(nonzero, !!, operator!)
-#endif
 BOOST_PYTHON_UNARY_OPERATOR(int, long, int_)
 BOOST_PYTHON_UNARY_OPERATOR(long, PyLong_FromLong, long_)
 BOOST_PYTHON_UNARY_OPERATOR(float, double, float_)
--- a/include/boost/python/str.hpp
+++ b/include/boost/python/str.hpp
@@ -37,12 +37,10 @@ namespace detail
    
      long count(object_cref sub, object_cref start, object_cref end) const;

-#if PY_VERSION_HEX < 0x03000000
      object decode() const;
      object decode(object_cref encoding) const;

      object decode(object_cref encoding, object_cref errors) const;
-#endif

      object encode() const;
      object encode(object_cref encoding) const;
@@ -187,7 +185,6 @@ class str : public detail::str_base
        return base::count(object(sub), object(start));
    }

-#if PY_VERSION_HEX < 0x03000000
    object decode() const { return base::decode(); }
    
    template<class T>
@@ -201,7 +198,6 @@ class str : public detail::str_base
    {
        return base::decode(object(encoding),object(errors));
    }
-#endif

    object encode() const { return base::encode(); }

@@ -408,11 +404,7 @@ namespace converter
 {
  template <>
  struct object_manager_traits<str>
-#if PY_VERSION_HEX >= 0x03000000
-      : pytype_object_manager_traits<&PyUnicode_Type,str>
-#else
      : pytype_object_manager_traits<&PyString_Type,str>
-#endif
  {
  };
 }
--- a/module.cmake
+++ b/module.cmake
@@ -0,0 +1,3 @@
+boost_module(python DEPENDS graph numeric)
+
+# numeric is there because of boost/cast.hpp from libs/python/src/errors.cpp:11
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -0,0 +1,64 @@
+if (PYTHON_DEBUG_LIBRARIES AND BUILD_BOOST_PYTHON)
+  # We have detected that there might be Python debug libraries
+  # available, but check for ourselves whether this is true by trying
+  # to compile/link a program against them.
+  set(CMAKE_REQUIRED_DEFINITIONS "-DBOOST_DEBUG_PYTHON -DPy_DEBUG")
+  get_directory_property(CMAKE_REQUIRED_INCLUDES INCLUDE_DIRECTORIES)
+  set(CMAKE_REQUIRED_LIBRARIES ${PYTHON_DEBUG_LIBRARIES})
+  set(CHECK_PYDEBUG_SOURCE
+    "#include <boost/python/object.hpp>")
+  check_cxx_source_compiles(
+    "#include <boost/python/object.hpp>
+    void check(PyObject *obj) { Py_INCREF(obj); } int main() { }" 
+    PYDEBUG_CAN_BUILD)
+
+  # Setup an option to enable/disable building variants with Python
+  # debugging. If we were able to link against the debug libraries,
+  # default to ON; otherwise, default to OFF.
+  option(BUILD_PYTHON_DEBUG
+    "Build an additional Boost.Python library with Python debugging enabled"
+    ${PYDEBUG_CAN_BUILD})
+endif (PYTHON_DEBUG_LIBRARIES AND BUILD_BOOST_PYTHON)
+
+# Always build the non-debug variants of the boost_python library
+set(BUILD_PYTHON_NODEBUG ON)
+
+boost_add_library(boost_python
+  numeric.cpp 
+  list.cpp 
+  long.cpp 
+  dict.cpp 
+  tuple.cpp 
+  str.cpp 
+  slice.cpp
+  converter/from_python.cpp 
+  converter/registry.cpp
+  converter/type_id.cpp
+  object/enum.cpp
+  object/class.cpp
+  object/function.cpp
+  object/inheritance.cpp
+  object/life_support.cpp
+  object/pickle_support.cpp
+  errors.cpp
+  module.cpp
+  converter/builtin_converters.cpp
+  converter/arg_to_python_base.cpp
+  object/iterator.cpp
+  object/stl_iterator.cpp
+  object_protocol.cpp
+  object_operators.cpp
+  wrapper.cpp
+  import.cpp
+  exec.cpp
+  object/function_doc_signature.cpp
+
+  STATIC_COMPILE_FLAGS "-DBOOST_PYTHON_SOURCE -DBOOST_PYTHON_STATIC_LIB"
+  SHARED_COMPILE_FLAGS "-DBOOST_PYTHON_SOURCE"
+  PYTHON_NODEBUG_LINK_LIBS "${PYTHON_LIBRARIES}"
+
+  # Support for Python debugging
+  EXTRA_VARIANTS PYTHON_NODEBUG:PYTHON_DEBUG
+  PYTHON_DEBUG_COMPILE_FLAGS "-DBOOST_DEBUG_PYTHON -DPy_DEBUG"
+  PYTHON_DEBUG_LINK_LIBS "${PYTHON_DEBUG_LIBRARIES}"
+  )
--- a/src/converter/builtin_converters.cpp
+++ b/src/converter/builtin_converters.cpp
@@ -37,20 +37,12 @@ void shared_ptr_deleter::operator()(void const*)

 namespace
 {
-
  // An lvalue conversion function which extracts a char const* from a
  // Python String.
-#if PY_VERSION_HEX < 0x03000000
  void* convert_to_cstring(PyObject* obj)
  {
      return PyString_Check(obj) ? PyString_AsString(obj) : 0;
  }
-#else
-  void* convert_to_cstring(PyObject* obj)
-  {
-      return PyUnicode_Check(obj) ? _PyUnicode_AsString(obj) : 0;
-  }
-#endif

  // Given a target type and a SlotPolicy describing how to perform a
  // given conversion, registers from_python converters which use the
@@ -98,52 +90,6 @@ namespace
      }
  };

-  // identity_unaryfunc/py_object_identity -- manufacture a unaryfunc
-  // "slot" which just returns its argument. 
-  extern "C" PyObject* identity_unaryfunc(PyObject* x)
-  {
-      Py_INCREF(x);
-      return x;
-  }
-  unaryfunc py_object_identity = identity_unaryfunc;
-
-#if PY_VERSION_HEX >= 0x03000000
-  // As in Python 3 there is only one integer type, we can have much
-  // simplified logic.
-  // XXX(bhy) maybe the code will work with 2.6 or even 2.5?
-  struct int_rvalue_from_python_base
-  {
-      static unaryfunc* get_slot(PyObject* obj)
-      {
-          return PyLong_Check(obj) ? &py_object_identity : 0;
-      }
-      static PyTypeObject const* get_pytype() {return &PyLong_Type;}
-  };
-
-  template <class T>
-  struct signed_int_rvalue_from_python : int_rvalue_from_python_base
-  {
-      static T extract(PyObject* intermediate)
-      {
-          long x = PyLong_AsLong(intermediate);
-          if (PyErr_Occurred())
-              throw_error_already_set();
-          return numeric_cast<T>(x);
-      }
-  };
-
-  template <class T>
-  struct unsigned_int_rvalue_from_python : int_rvalue_from_python_base
-  {
-      static T extract(PyObject* intermediate)
-      {
-          unsigned long x = PyLong_AsUnsignedLong(intermediate);
-          if (PyErr_Occurred())
-              throw_error_already_set();
-          return numeric_cast<T>(x);
-      }
-  };
-#else // PY_VERSION_HEX >= 0x03000000
  // A SlotPolicy for extracting signed integer types from Python objects
  struct signed_int_rvalue_from_python_base
  {
@@ -175,7 +121,16 @@ namespace
          return numeric_cast<T>(x);
      }
  };
-  
+
+  // identity_unaryfunc/py_object_identity -- manufacture a unaryfunc
+  // "slot" which just returns its argument. 
+  extern "C" PyObject* identity_unaryfunc(PyObject* x)
+  {
+      Py_INCREF(x);
+      return x;
+  }
+  unaryfunc py_object_identity = identity_unaryfunc;
+
  // A SlotPolicy for extracting unsigned integer types from Python objects
  struct unsigned_int_rvalue_from_python_base
  {
@@ -200,30 +155,12 @@ namespace
  {
      static T extract(PyObject* intermediate)
      {
-          if (PyLong_Check(intermediate)) {
-              // PyLong_AsUnsignedLong() checks for negative overflow, so no
-              // need to check it here.
-              unsigned long result = PyLong_AsUnsignedLong(intermediate);
-              if (PyErr_Occurred())
-                  throw_error_already_set();
-              return numeric_cast<T>(result);
-          } else {
-              // None of PyInt_AsUnsigned*() functions check for negative
-              // overflow, so use PyInt_AS_LONG instead and check if number is
-              // negative, issuing the exception appropriately.
-              long result = PyInt_AS_LONG(intermediate);
-              if (PyErr_Occurred())
-                  throw_error_already_set();
-              if (result < 0) {
-                  PyErr_SetString(PyExc_OverflowError, "can't convert negative"
-                                  " value to unsigned");
-                  throw_error_already_set();
-              }
-              return numeric_cast<T>(result);
-          }
+          return numeric_cast<T>(
+              PyLong_Check(intermediate)
+              ? PyLong_AsUnsignedLong(intermediate)
+              : PyInt_AS_LONG(intermediate));
      }
  };
-#endif // PY_VERSION_HEX >= 0x03000000

 // Checking Python's macro instead of Boost's - we don't seem to get
 // the config right all the time. Furthermore, Python's is defined
@@ -236,9 +173,6 @@ namespace
  {
      static unaryfunc* get_slot(PyObject* obj)
      {
-#if PY_VERSION_HEX >= 0x03000000
-          return PyLong_Check(obj) ? &py_object_identity : 0;
-#else
          PyNumberMethods* number_methods = obj->ob_type->tp_as_number;
          if (number_methods == 0)
              return 0;
@@ -251,22 +185,19 @@ namespace
              return &number_methods->nb_long;
          else
              return 0;
-#endif
      }
-      static PyTypeObject const* get_pytype() { return &PyLong_Type;}
+      static PyTypeObject const* get_pytype() { return &PyInt_Type;}
  };
  
  struct long_long_rvalue_from_python : long_long_rvalue_from_python_base
  {
      static BOOST_PYTHON_LONG_LONG extract(PyObject* intermediate)
      {
-#if PY_VERSION_HEX < 0x03000000
          if (PyInt_Check(intermediate))
          {
              return PyInt_AS_LONG(intermediate);
          }
          else
-#endif
          {
              BOOST_PYTHON_LONG_LONG result = PyLong_AsLongLong(intermediate);
              
@@ -282,13 +213,11 @@ namespace
  {
      static unsigned BOOST_PYTHON_LONG_LONG extract(PyObject* intermediate)
      {
-#if PY_VERSION_HEX < 0x03000000
          if (PyInt_Check(intermediate))
          {
              return numeric_cast<unsigned BOOST_PYTHON_LONG_LONG>(PyInt_AS_LONG(intermediate));
          }
          else
-#endif
          {
              unsigned BOOST_PYTHON_LONG_LONG result = PyLong_AsUnsignedLongLong(intermediate);
              
@@ -306,9 +235,7 @@ namespace
  {
      static unaryfunc* get_slot(PyObject* obj)
      {
-#if PY_VERSION_HEX >= 0x03000000
-          return obj == Py_None || PyLong_Check(obj) ? &py_object_identity : 0;
-#elif PY_VERSION_HEX >= 0x02040000 && defined(BOOST_PYTHON_BOOL_INT_STRICT)
+#if PY_VERSION_HEX >= 0x02040000 && defined(BOOST_PYTHON_BOOL_INT_STRICT)
          return obj == Py_None || PyBool_Check(obj) ? &py_object_identity : 0;
 #else
          return obj == Py_None || PyInt_Check(obj) ? &py_object_identity : 0;
@@ -341,10 +268,8 @@ namespace

          // For integer types, return the tp_int conversion slot to avoid
          // creating a new object. We'll handle that below
-#if PY_VERSION_HEX < 0x03000000
          if (PyInt_Check(obj))
              return &number_methods->nb_int;
-#endif

          return (PyLong_Check(obj) || PyFloat_Check(obj))
              ? &number_methods->nb_float : 0;
@@ -352,13 +277,11 @@ namespace
      
      static double extract(PyObject* intermediate)
      {
-#if PY_VERSION_HEX < 0x03000000
          if (PyInt_Check(intermediate))
          {
              return PyInt_AS_LONG(intermediate);
          }
          else
-#endif
          {
              return PyFloat_AS_DOUBLE(intermediate);
          }
@@ -366,36 +289,22 @@ namespace
      static PyTypeObject const* get_pytype() { return &PyFloat_Type;}
  };

-  unaryfunc py_unicode_as_string_unaryfunc = PyUnicode_AsUTF8String;
-
  // A SlotPolicy for extracting C++ strings from Python objects.
  struct string_rvalue_from_python
  {
      // If the underlying object is "string-able" this will succeed
      static unaryfunc* get_slot(PyObject* obj)
      {
-#if PY_VERSION_HEX >= 0x03000000
-          return (PyUnicode_Check(obj)) ? &py_unicode_as_string_unaryfunc : 0;
-#else
-          return (PyString_Check(obj)) ? &obj->ob_type->tp_str : 0;
-
-#endif
+          return (PyString_Check(obj))
+              ? &obj->ob_type->tp_str : 0;
      };

      // Remember that this will be used to construct the result object 
-#if PY_VERSION_HEX >= 0x03000000
-      static std::string extract(PyObject* intermediate)
-      {
-          return std::string(PyBytes_AsString(intermediate),PyBytes_Size(intermediate));
-      }
-      static PyTypeObject const* get_pytype() { return &PyUnicode_Type;}
-#else
      static std::string extract(PyObject* intermediate)
      {
          return std::string(PyString_AsString(intermediate),PyString_Size(intermediate));
      }
      static PyTypeObject const* get_pytype() { return &PyString_Type;}
-#endif
  };

 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
@@ -415,11 +324,7 @@ namespace
      {
          return PyUnicode_Check(obj)
              ? &py_object_identity
-#if PY_VERSION_HEX >= 0x03000000
-            : PyBytes_Check(obj)
-#else
            : PyString_Check(obj)
-#endif
              ? &py_encode_string
            : 0;
      };
@@ -462,12 +367,10 @@ namespace
                  PyComplex_RealAsDouble(intermediate)
                  , PyComplex_ImagAsDouble(intermediate));
          }
-#if PY_VERSION_HEX < 0x03000000
          else if (PyInt_Check(intermediate))
          {
              return PyInt_AS_LONG(intermediate);
          }
-#endif
          else
          {
              return PyFloat_AS_DOUBLE(intermediate);
@@ -479,20 +382,12 @@ namespace

 BOOST_PYTHON_DECL PyObject* do_return_to_python(char x)
 {
-#if PY_VERSION_HEX >= 0x03000000
-    return PyUnicode_FromStringAndSize(&x, 1);
-#else
    return PyString_FromStringAndSize(&x, 1);
-#endif
 }
  
 BOOST_PYTHON_DECL PyObject* do_return_to_python(char const* x)
 {
-#if PY_VERSION_HEX >= 0x03000000
-    return x ? PyUnicode_FromString(x) : boost::python::detail::none();
-#else
    return x ? PyString_FromString(x) : boost::python::detail::none();
-#endif
 }
  
 BOOST_PYTHON_DECL PyObject* do_return_to_python(PyObject* x)
@@ -547,18 +442,13 @@ void initialize_builtin_converters()
    slot_rvalue_from_python<std::complex<long double>,complex_rvalue_from_python>();
    
    // Add an lvalue converter for char which gets us char const*
-#if PY_VERSION_HEX < 0x03000000
    registry::insert(convert_to_cstring,type_id<char>(),&converter::wrap_pytype<&PyString_Type>::get_pytype);
-#else
-    registry::insert(convert_to_cstring,type_id<char>(),&converter::wrap_pytype<&PyUnicode_Type>::get_pytype);
-#endif

    // Register by-value converters to std::string, std::wstring
 #if defined(Py_USING_UNICODE) && !defined(BOOST_NO_STD_WSTRING)
    slot_rvalue_from_python<std::wstring, wstring_rvalue_from_python>();
 # endif 
    slot_rvalue_from_python<std::string, string_rvalue_from_python>();
-
 }

 }}} // namespace boost::python::converter
--- a/src/converter/from_python.cpp
+++ b/src/converter/from_python.cpp
@@ -96,12 +96,7 @@ BOOST_PYTHON_DECL void* rvalue_from_python_stage2(
    if (!data.convertible)
    {
        handle<> msg(
-#if PY_VERSION_HEX >= 0x03000000
-            ::PyUnicode_FromFormat
-#else
-            ::PyString_FromFormat
-#endif
-                (
+            ::PyString_FromFormat(
                "No registered converter was able to produce a C++ rvalue of type %s from this Python object of type %s"
                , converters.target_type.name()
                , source->ob_type->tp_name
@@ -201,12 +196,7 @@ namespace
  void throw_no_lvalue_from_python(PyObject* source, registration const& converters, char const* ref_type)
  {
      handle<> msg(
-#if PY_VERSION_HEX >= 0x03000000
-          ::PyUnicode_FromFormat
-#else
-          ::PyString_FromFormat
-#endif
-              (
+          ::PyString_FromFormat(
              "No registered converter was able to extract a C++ %s to type %s"
              " from this Python object of type %s"
              , ref_type
@@ -228,12 +218,7 @@ namespace
      if (source->ob_refcnt <= 1)
      {
          handle<> msg(
-#if PY_VERSION_HEX >= 0x3000000
-              ::PyUnicode_FromFormat
-#else
-              ::PyString_FromFormat
-#endif
-                  (
+              ::PyString_FromFormat(
                  "Attempt to return dangling %s to object of type: %s"
                  , ref_type
                  , converters.target_type.name()));
--- a/src/converter/registry.cpp
+++ b/src/converter/registry.cpp
@@ -70,12 +70,7 @@ BOOST_PYTHON_DECL PyObject* registration::to_python(void const volatile* source)
    if (this->m_to_python == 0)
    {
        handle<> msg(
-#if PY_VERSION_HEX >= 0x3000000
-            ::PyUnicode_FromFormat
-#else
-            ::PyString_FromFormat
-#endif
-            (
+            ::PyString_FromFormat(
                "No to_python (by-value) converter found for C++ type: %s"
                , this->target_type.name()
                )
--- a/src/dict.cpp
+++ b/src/dict.cpp
@@ -84,7 +84,7 @@ object dict_base::get(object_cref k, object_cref d) const

 bool dict_base::has_key(object_cref k) const
 {
-    return extract<bool>(this->contains(k)); 
+    return extract<bool>(this->attr("has_key")(k)); 
 }

 list dict_base::items() const
--- a/src/exec.cpp
+++ b/src/exec.cpp
@@ -5,7 +5,6 @@

 #include <boost/python/exec.hpp>
 #include <boost/python/borrowed.hpp>
-#include <boost/python/dict.hpp>
 #include <boost/python/extract.hpp>
 #include <boost/python/handle.hpp>

@@ -16,16 +15,6 @@ namespace python

 object BOOST_PYTHON_DECL eval(str string, object global, object local)
 {
-  // Set suitable default values for global and local dicts.
-  object none;
-  if (global.ptr() == none.ptr())
-  {
-    if (PyObject *g = PyEval_GetGlobals())
-      global = object(detail::borrowed_reference(g));
-    else
-      global = dict();
-  }
-  if (local.ptr() == none.ptr()) local = global;
  // should be 'char const *' but older python versions don't use 'const' yet.
  char *s = python::extract<char *>(string);
  PyObject* result = PyRun_String(s, Py_eval_input, global.ptr(), local.ptr());
@@ -35,16 +24,6 @@ object BOOST_PYTHON_DECL eval(str string, object global, object local)

 object BOOST_PYTHON_DECL exec(str string, object global, object local)
 {
-  // Set suitable default values for global and local dicts.
-  object none;
-  if (global.ptr() == none.ptr())
-  {
-    if (PyObject *g = PyEval_GetGlobals())
-      global = object(detail::borrowed_reference(g));
-    else
-      global = dict();
-  }
-  if (local.ptr() == none.ptr()) local = global;
  // should be 'char const *' but older python versions don't use 'const' yet.
  char *s = python::extract<char *>(string);
  PyObject* result = PyRun_String(s, Py_file_input, global.ptr(), local.ptr());
@@ -52,55 +31,18 @@ object BOOST_PYTHON_DECL exec(str string, object global, object local)
  return object(detail::new_reference(result));
 }

-object BOOST_PYTHON_DECL exec_statement(str string, object global, object local)
-{
-  // Set suitable default values for global and local dicts.
-  object none;
-  if (global.ptr() == none.ptr())
-  {
-    if (PyObject *g = PyEval_GetGlobals())
-      global = object(detail::borrowed_reference(g));
-    else
-      global = dict();
-  }
-  if (local.ptr() == none.ptr()) local = global;
-  // should be 'char const *' but older python versions don't use 'const' yet.
-  char *s = python::extract<char *>(string);
-  PyObject* result = PyRun_String(s, Py_single_input, global.ptr(), local.ptr());
-  if (!result) throw_error_already_set();
-  return object(detail::new_reference(result));
-}
-
 // Execute python source code from file filename.
 // global and local are the global and local scopes respectively,
 // used during execution.
 object BOOST_PYTHON_DECL exec_file(str filename, object global, object local)
 {
-  // Set suitable default values for global and local dicts.
-  object none;
-  if (global.ptr() == none.ptr())
-  {
-    if (PyObject *g = PyEval_GetGlobals())
-      global = object(detail::borrowed_reference(g));
-    else
-      global = dict();
-  }
-  if (local.ptr() == none.ptr()) local = global;
  // should be 'char const *' but older python versions don't use 'const' yet.
  char *f = python::extract<char *>(filename);
-#if PY_VERSION_HEX >= 0x03000000
-  // TODO(bhy) temporary workaround for Python 3.
-  // should figure out a way to avoid binary incompatibilities as the Python 2
-  // version did.
-  FILE *fs = fopen(f, "r");
-#else
  // Let python open the file to avoid potential binary incompatibilities.
  PyObject *pyfile = PyFile_FromString(f, const_cast<char*>("r"));
  if (!pyfile) throw std::invalid_argument(std::string(f) + " : no such file");
  python::handle<> file(pyfile);
-  FILE *fs = PyFile_AsFile(file.get());
-#endif
-  PyObject* result = PyRun_File(fs,
+  PyObject* result = PyRun_File(PyFile_AsFile(file.get()),
                f,
                Py_file_input,
                global.ptr(), local.ptr());
--- a/src/list.cpp
+++ b/src/list.cpp
@@ -48,11 +48,7 @@ void list_base::extend(object_cref sequence)
 long list_base::index(object_cref value) const
 {
    object result_obj(this->attr("index")(value));
-#if PY_VERSION_HEX >= 0x03000000
-    ssize_t result = PyLong_AsSsize_t(result_obj.ptr());
-#else
    long result = PyInt_AsLong(result_obj.ptr());
-#endif
    if (result == -1)
        throw_error_already_set();
    return result;
@@ -73,11 +69,7 @@ void list_base::insert(ssize_t index, object_cref item)

 void list_base::insert(object const& index, object_cref x)
 {
-#if PY_VERSION_HEX >= 0x03000000
-    ssize_t index_ = PyLong_AsSsize_t(index.ptr());
-#else
    long index_ = PyInt_AsLong(index.ptr());
-#endif
    if (index_ == -1 && PyErr_Occurred())
        throw_error_already_set();
    this->insert(index_, x);
@@ -129,29 +121,17 @@ void list_base::sort()
    }
 }

-#if PY_VERSION_HEX >= 0x03000000
-void list_base::sort(args_proxy const &args, 
-                     kwds_proxy const &kwds)
-{
-    this->attr("sort")(args, kwds);
-}
-#else
 void list_base::sort(object_cref cmpfunc)
 {
    this->attr("sort")(cmpfunc);
 }
-#endif

 // For some reason, moving this to the end of the TU suppresses an ICE
 // with vc6.
-ssize_t list_base::count(object_cref value) const
+long list_base::count(object_cref value) const
 {
    object result_obj(this->attr("count")(value));
-#if PY_VERSION_HEX >= 0x03000000
-    ssize_t result = PyLong_AsSsize_t(result_obj.ptr());
-#else
    long result = PyInt_AsLong(result_obj.ptr());
-#endif
    if (result == -1)
        throw_error_already_set();
    return result;
--- a/src/module.cpp
+++ b/src/module.cpp
@@ -24,25 +24,11 @@ namespace
  PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } };
 }

-BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*init_function)())
+BOOST_PYTHON_DECL void init_module(char const* name, void(*init_function)())
 {
-#if PY_VERSION_HEX >= 0x03000000
-    static struct PyModuleDef moduledef = {
-        PyModuleDef_HEAD_INIT,
-        name,
-        0, /* m_doc */
-        -1, /* m_size */
-        initial_methods,
-        0,  /* m_reload */
-        0, /* m_traverse */
-        0, /* m_clear */
-        0,  /* m_free */
-    };
-    PyObject* m = PyModule_Create(&moduledef);
-#else
+    
    PyObject* m
        = Py_InitModule(const_cast<char*>(name), initial_methods);
-#endif

    if (m != 0)
    {
@@ -52,7 +38,6 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*init_function)()
        
        handle_exception(init_function);
    }
-    return m;
 }

 }}} // namespace boost::python::detail
--- a/src/object/class.cpp
+++ b/src/object/class.cpp
@@ -67,44 +67,8 @@ extern "C"
      PyObject *prop_set;
      PyObject *prop_del;
      PyObject *prop_doc;
-      int getter_doc;
  } propertyobject;

-  // Copied from Python source and removed the part for setting docstring,
-  // since we don't have a setter for __doc__ and trying to set it will
-  // cause the init fail.
-  static int property_init(PyObject *self, PyObject *args, PyObject *kwds)
-  {
-      PyObject *get = NULL, *set = NULL, *del = NULL, *doc = NULL;
-      static char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};
-      propertyobject *prop = (propertyobject *)self;
-
-      if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",
-                  kwlist, &get, &set, &del, &doc))
-          return -1;
-
-      if (get == Py_None)
-          get = NULL;
-      if (set == Py_None)
-          set = NULL;
-      if (del == Py_None)
-          del = NULL;
-
-      Py_XINCREF(get);
-      Py_XINCREF(set);
-      Py_XINCREF(del);
-      Py_XINCREF(doc);
-
-      prop->prop_get = get;
-      prop->prop_set = set;
-      prop->prop_del = del;
-      prop->prop_doc = doc;
-      prop->getter_doc = 0;
-
-      return 0;
-  }
-
- 
  static PyObject *
  static_data_descr_get(PyObject *self, PyObject * /*obj*/, PyObject * /*type*/)
  {
@@ -142,9 +106,10 @@ extern "C"
 }

 static PyTypeObject static_data_object = {
-    PyVarObject_HEAD_INIT(NULL, 0)
+    PyObject_HEAD_INIT(0)//&PyType_Type)
+    0,
    const_cast<char*>("Boost.Python.StaticProperty"),
-    sizeof(propertyobject),
+    PyType_Type.tp_basicsize,
    0,
    0,                                      /* tp_dealloc */
    0,                                      /* tp_print */
@@ -178,11 +143,11 @@ static PyTypeObject static_data_object = {
    static_data_descr_get,                                      /* tp_descr_get */
    static_data_descr_set,                                      /* tp_descr_set */
    0,                                      /* tp_dictoffset */
-    property_init,                                      /* tp_init */
+    0,                                      /* tp_init */
    0,                                      /* tp_alloc */
    0, // filled in with type_new           /* tp_new */
    0, // filled in with __PyObject_GC_Del  /* tp_free */
-    0,                                      /* tp_is_gc */
+    (inquiry)type_is_gc,                    /* tp_is_gc */
    0,                                      /* tp_bases */
    0,                                      /* tp_mro */
    0,                                      /* tp_cache */
@@ -195,20 +160,17 @@ static PyTypeObject static_data_object = {

 namespace objects
 {
-#if PY_VERSION_HEX < 0x03000000
-  // XXX Not sure why this run into compiling error in Python 3
  extern "C"
  {
      // This declaration needed due to broken Python 2.2 headers
      extern DL_IMPORT(PyTypeObject) PyProperty_Type;
  }
-#endif

  BOOST_PYTHON_DECL PyObject* static_data()
  {
      if (static_data_object.tp_dict == 0)
      {
-          Py_TYPE(&static_data_object) = &PyType_Type;
+          static_data_object.ob_type = &PyType_Type;
          static_data_object.tp_base = &PyProperty_Type;
          if (PyType_Ready(&static_data_object))
              return 0;
@@ -241,14 +203,15 @@ extern "C"
        // If we found a static data descriptor, call it directly to
        // force it to set the static data member
        if (a != 0 && PyObject_IsInstance(a, objects::static_data()))
-            return Py_TYPE(a)->tp_descr_set(a, obj, value);
+            return a->ob_type->tp_descr_set(a, obj, value);
        else
            return PyType_Type.tp_setattro(obj, name, value);
    }
 }

 static PyTypeObject class_metatype_object = {
-    PyVarObject_HEAD_INIT(NULL, 0)
+    PyObject_HEAD_INIT(0)//&PyType_Type)
+    0,
    const_cast<char*>("Boost.Python.class"),
    PyType_Type.tp_basicsize,
    0,
@@ -303,7 +266,7 @@ static PyTypeObject class_metatype_object = {
 // object.
 void instance_holder::install(PyObject* self) throw()
 {
-    assert(Py_TYPE(Py_TYPE(self)) == &class_metatype_object);
+    assert(self->ob_type->ob_type == &class_metatype_object);
    m_next = ((objects::instance<>*)self)->objects;
    ((objects::instance<>*)self)->objects = this;
 }
@@ -316,7 +279,7 @@ namespace objects
  {
      if (class_metatype_object.tp_dict == 0)
      {
-          Py_TYPE(&class_metatype_object) = &PyType_Type;
+          class_metatype_object.ob_type = &PyType_Type;
          class_metatype_object.tp_base = &PyType_Type;
          if (PyType_Ready(&class_metatype_object))
              return type_handle();
@@ -345,7 +308,7 @@ namespace objects

          Py_XDECREF(kill_me->dict);
          
-          Py_TYPE(inst)->tp_free(inst);
+          inst->ob_type->tp_free(inst);
      }

      static PyObject *
@@ -355,12 +318,7 @@ namespace objects
          PyObject* d = type_->tp_dict;
          PyObject* instance_size_obj = PyObject_GetAttrString(d, const_cast<char*>("__instance_size__"));

-          ssize_t instance_size = instance_size_obj ? 
-#if PY_VERSION_HEX >= 0x03000000
-              PyLong_AsSsize_t(instance_size_obj) : 0;
-#else
-              PyInt_AsLong(instance_size_obj) : 0;
-#endif
+          long instance_size = instance_size_obj ? PyInt_AsLong(instance_size_obj) : 0;
          
          if (instance_size < 0)
              instance_size = 0;
@@ -374,12 +332,7 @@ namespace objects
              // like, so we'll store the total size of the object
              // there. A negative number indicates that the extra
              // instance memory is not yet allocated to any holders.
-#if PY_VERSION_HEX >= 0x02060000
-              Py_SIZE(result) =
-#else
-              result->ob_size =
-#endif
-                  -(static_cast<int>(offsetof(instance<>,storage) + instance_size));
+              result->ob_size = -(static_cast<int>(offsetof(instance<>,storage) + instance_size));
          }
          return (PyObject*)result;
      }
@@ -415,7 +368,8 @@ namespace objects
  };

  static PyTypeObject class_type_object = {
-      PyVarObject_HEAD_INIT(NULL, 0)
+      PyObject_HEAD_INIT(0) //&class_metatype_object)
+      0,
      const_cast<char*>("Boost.Python.instance"),
      offsetof(instance<>,storage),           /* tp_basicsize */
      1,                                      /* tp_itemsize */
@@ -470,7 +424,7 @@ namespace objects
  {
      if (class_type_object.tp_dict == 0)
      {
-          Py_TYPE(&class_type_object) = incref(class_metatype().get());
+          class_type_object.ob_type = incref(class_metatype().get());
          class_type_object.tp_base = &PyBaseObject_Type;
          if (PyType_Ready(&class_type_object))
              return type_handle();
@@ -482,7 +436,7 @@ namespace objects
  BOOST_PYTHON_DECL void*
  find_instance_impl(PyObject* inst, type_info type, bool null_shared_ptr_only)
  {
-      if (Py_TYPE(Py_TYPE(inst)) != &class_metatype_object)
+      if (inst->ob_type->ob_type != &class_metatype_object)
          return 0;
    
      instance<>* self = reinterpret_cast<instance<>*>(inst);
@@ -552,12 +506,13 @@ namespace objects
      // Build a tuple of the base Python type objects. If no bases
      // were declared, we'll use our class_type() as the single base
      // class.
-      ssize_t const num_bases = (std::max)(num_types - 1, static_cast<std::size_t>(1));
-      handle<> bases(PyTuple_New(num_bases));
+      std::size_t const num_bases = (std::max)(num_types - 1, static_cast<std::size_t>(1));
+      assert(num_bases <= ssize_t_max);
+      handle<> bases(PyTuple_New(static_cast<ssize_t>(num_bases)));

-      for (ssize_t i = 1; i <= num_bases; ++i)
+      for (std::size_t i = 1; i <= num_bases; ++i)
      {
-          type_handle c = (i >= static_cast<ssize_t>(num_types)) ? class_type() : get_class(types[i]);
+          type_handle c = (i >= num_types) ? class_type() : get_class(types[i]);
          // PyTuple_SET_ITEM steals this reference
          PyTuple_SET_ITEM(bases.get(), static_cast<ssize_t>(i - 1), upcast<PyObject>(c.release()));
      }
@@ -572,7 +527,7 @@ namespace objects
          d["__doc__"] = doc;
      
      object result = object(class_metatype())(name, bases, d);
-      assert(PyType_IsSubtype(Py_TYPE(result.ptr()), &PyType_Type));
+      assert(PyType_IsSubtype(result.ptr()->ob_type, &PyType_Type));
      
      if (scope().ptr() != Py_None)
          scope().attr(name) = result;
@@ -635,9 +590,8 @@ namespace objects
  void class_base::add_static_property(char const* name, object const& fget)
  {
      object property(
-          (python::detail::new_reference) 
-          PyObject_CallFunction(static_data(), const_cast<char*>("O"), fget.ptr())
-          );
+          (python::detail::new_reference)
+          PyObject_CallFunction(static_data(), const_cast<char*>("O"), fget.ptr()));
      
      this->setattr(name, property);
  }
@@ -697,7 +651,7 @@ namespace objects
        ::PyErr_Format(
            PyExc_TypeError
          , const_cast<char*>("staticmethod expects callable object; got an object of type %s, which is not callable")
-            , Py_TYPE(callable)->tp_name
+            , callable->ob_type->tp_name
            );
        
        throw_error_already_set();
@@ -727,18 +681,18 @@ namespace objects

 void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std::size_t holder_size)
 {
-    assert(Py_TYPE(Py_TYPE(self_)) == &class_metatype_object);
+    assert(self_->ob_type->ob_type == &class_metatype_object);
    objects::instance<>* self = (objects::instance<>*)self_;
    
    int total_size_needed = holder_offset + holder_size;
    
-    if (-Py_SIZE(self) >= total_size_needed)
+    if (-self->ob_size >= total_size_needed)
    {
        // holder_offset should at least point into the variable-sized part
        assert(holder_offset >= offsetof(objects::instance<>,storage));

        // Record the fact that the storage is occupied, noting where it starts
-        Py_SIZE(self) = holder_offset;
+        self->ob_size = holder_offset;
        return (char*)self + holder_offset;
    }
    else
@@ -752,9 +706,9 @@ void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std:

 void instance_holder::deallocate(PyObject* self_, void* storage) throw()
 {
-    assert(Py_TYPE(Py_TYPE(self_)) == &class_metatype_object);
+    assert(self_->ob_type->ob_type == &class_metatype_object);
    objects::instance<>* self = (objects::instance<>*)self_;
-    if (storage != (char*)self + Py_SIZE(self))
+    if (storage != (char*)self + self->ob_size)
    {
        PyMem_Free(storage);
    }
--- a/src/object/enum.cpp
+++ b/src/object/enum.cpp
@@ -14,15 +14,11 @@
 #include <boost/python/object_protocol.hpp>
 #include <structmember.h>

-namespace boost { namespace python { namespace objects {
+namespace boost { namespace python { namespace objects { 

 struct enum_object
 {
-#if PY_VERSION_HEX >= 0x03000000
-    PyLongObject base_object;
-#else
    PyIntObject base_object;
-#endif
    PyObject* name;
 };

@@ -36,32 +32,19 @@ extern "C"
 {
    static PyObject* enum_repr(PyObject* self_)
    {
-        // XXX(bhy) Potentional memory leak here since PyObject_GetAttrString returns a new reference
-        // const char *mod = PyString_AsString(PyObject_GetAttrString( self_, const_cast<char*>("__module__")));
-        PyObject *mod = PyObject_GetAttrString( self_, "__module__");
+        const char *mod = PyString_AsString(PyObject_GetAttrString( self_, const_cast<char*>("__module__")));
        enum_object* self = downcast<enum_object>(self_);
        if (!self->name)
        {
-            return
-#if PY_VERSION_HEX >= 0x03000000
-                PyUnicode_FromFormat("%S.%s(%ld)", mod, self_->ob_type->tp_name, PyLong_AsLong(self_));
-#else
-                PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AS_LONG(self_));
-#endif
+            return PyString_FromFormat("%s.%s(%ld)", mod, self_->ob_type->tp_name, PyInt_AS_LONG(self_));
        }
        else
        {
-            PyObject* name = self->name;
+            char* name = PyString_AsString(self->name);
            if (name == 0)
                return 0;
-
-            return
-#if PY_VERSION_HEX >= 0x03000000
-                PyUnicode_FromFormat("%S.%s.%S", mod, self_->ob_type->tp_name, name);
-#else
-                PyString_FromFormat("%s.%s.%s", 
-                        PyString_AsString(mod), self_->ob_type->tp_name, PyString_AsString(name));
-#endif
+            
+            return PyString_FromFormat("%s.%s.%s", mod, self_->ob_type->tp_name, name);
        }
    }

@@ -70,11 +53,7 @@ extern "C"
        enum_object* self = downcast<enum_object>(self_);
        if (!self->name)
        {
-#if PY_VERSION_HEX >= 0x03000000
-            return PyLong_Type.tp_str(self_);
-#else
            return PyInt_Type.tp_str(self_);
-#endif
        }
        else
        {
@@ -84,7 +63,8 @@ extern "C"
 }

 static PyTypeObject enum_type_object = {
-    PyVarObject_HEAD_INIT(NULL, 0) // &PyType_Type
+    PyObject_HEAD_INIT(0) // &PyType_Type
+    0,
    const_cast<char*>("Boost.Python.enum"),
    sizeof(enum_object),                    /* tp_basicsize */
    0,                                      /* tp_itemsize */
@@ -104,9 +84,7 @@ static PyTypeObject enum_type_object = {
    0,                                      /* tp_setattro */
    0,                                      /* tp_as_buffer */
    Py_TPFLAGS_DEFAULT
-#if PY_VERSION_HEX < 0x03000000
    | Py_TPFLAGS_CHECKTYPES
-#endif
    | Py_TPFLAGS_HAVE_GC
    | Py_TPFLAGS_BASETYPE,                  /* tp_flags */
    0,                                      /* tp_doc */
@@ -147,12 +125,8 @@ namespace
  {
      if (enum_type_object.tp_dict == 0)
      {
-          Py_TYPE(&enum_type_object) = incref(&PyType_Type);
-#if PY_VERSION_HEX >= 0x03000000
-          enum_type_object.tp_base = &PyLong_Type;
-#else
+          enum_type_object.ob_type = incref(&PyType_Type);
          enum_type_object.tp_base = &PyInt_Type;
-#endif
          if (PyType_Ready(&enum_type_object))
              throw_error_already_set();
      }
@@ -165,16 +139,15 @@ namespace
      dict d;
      d["__slots__"] = tuple();
      d["values"] = dict();
-      d["names"] = dict();

      object module_name = module_prefix();
      if (module_name)
         d["__module__"] = module_name;
      if (doc)
         d["__doc__"] = doc;
-
+      
      object result = (object(metatype))(name, make_tuple(base), d);
-
+      
      scope().attr(name) = result;

      return result;
@@ -194,7 +167,7 @@ enum_base::enum_base(
    converter::registration& converters
        = const_cast<converter::registration&>(
            converter::registry::lookup(id));
-
+            
    converters.m_class_object = downcast<PyTypeObject>(this->ptr());
    converter::registry::insert(to_python, id);
    converter::registry::insert(convertible, construct, id);
@@ -213,24 +186,23 @@ void enum_base::add_value(char const* name_, long value)

    dict d = extract<dict>(this->attr("values"))();
    d[value] = x;
-
+    
    // Set the name field in the new enum instanec
    enum_object* p = downcast<enum_object>(x.ptr());
    Py_XDECREF(p->name);
    p->name = incref(name.ptr());
-
-    dict names_dict = extract<dict>(this->attr("names"))();
-    names_dict[x.attr("name")] = x;
 }

 void enum_base::export_values()
 {
-    dict d = extract<dict>(this->attr("names"))();
-    list items = d.items();
+    dict d = extract<dict>(this->attr("values"))();
+    list values = d.values();
    scope current;
-
-    for (unsigned i = 0, max = len(items); i < max; ++i)
-        api::setattr(current, items[i][0], items[i][1]);
+    
+    for (unsigned i = 0, max = len(values); i < max; ++i)
+    {
+        api::setattr(current, object(values[i].attr("name")), values[i]);
+    }
 }

 PyObject* enum_base::to_python(PyTypeObject* type_, long x)
--- a/src/object/function.cpp
+++ b/src/object/function.cpp
@@ -105,9 +105,9 @@ function::function(
    }
    
    PyObject* p = this;
-    if (Py_TYPE(&function_type) == 0)
+    if (function_type.ob_type == 0)
    {
-        Py_TYPE(&function_type) = &PyType_Type;
+        function_type.ob_type = &PyType_Type;
        ::PyType_Ready(&function_type);
    }
    
@@ -166,7 +166,7 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
                    else
                    {
                        // build a new arg tuple, will adjust its size later
-                        assert(max_arity <= static_cast<std::size_t>(ssize_t_max));
+                        assert(max_arity <= ssize_t_max);
                        inner_args = handle<>(
                            PyTuple_New(static_cast<ssize_t>(max_arity)));

@@ -435,13 +435,9 @@ void function::add_to_namespace(
        function* new_func = downcast<function>(attribute.ptr());
        PyObject* dict = 0;
        
-#if PY_VERSION_HEX < 0x03000000
-        // Old-style class gone in Python 3
        if (PyClass_Check(ns))
            dict = ((PyClassObject*)ns)->cl_dict;
-        else
-#endif        
-        if (PyType_Check(ns))
+        else if (PyType_Check(ns))
            dict = ((PyTypeObject*)ns)->tp_dict;
        else    
            dict = PyObject_GetAttrString(ns, const_cast<char*>("__dict__"));
@@ -599,18 +595,9 @@ extern "C"
    static PyObject *
    function_descr_get(PyObject *func, PyObject *obj, PyObject *type_)
    {
-#if PY_VERSION_HEX >= 0x03000000
-        // The implement is different in Python 3 because of the removal of unbound method
-        if (obj == Py_None || obj == NULL) {
-            Py_INCREF(func);
-            return func;
-        }
-        return PyMethod_New(func, obj);
-#else
        if (obj == Py_None)
            obj = NULL;
        return PyMethod_New(func, obj, type_);
-#endif
    }

    static void
@@ -654,11 +641,7 @@ extern "C"
    {
        function* f = downcast<function>(op);
        if (f->name().ptr() == Py_None)
-#if PY_VERSION_HEX >= 0x03000000
-            return PyUnicode_InternFromString("<unnamed Boost.Python function>");
-#else
            return PyString_InternFromString("<unnamed Boost.Python function>");
-#endif
        else
            return python::incref(f->name().ptr());
    }
@@ -682,7 +665,8 @@ static PyGetSetDef function_getsetlist[] = {
 };

 PyTypeObject function_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
+    PyObject_HEAD_INIT(0)
+    0,
    const_cast<char*>("Boost.Python.function"),
    sizeof(function),
    0,
--- a/src/object/function_doc_signature.cpp
+++ b/src/object/function_doc_signature.cpp
@@ -3,9 +3,6 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-// boost::python::make_tuple below are for gcc 4.4 -std=c++0x compatibility
-// (Intel C++ 10 and 11 with -std=c++0x don't need the full qualification).
-
 #include <boost/python/converter/registrations.hpp>
 #include <boost/python/object/function_doc_signature.hpp>
 #include <boost/python/errors.hpp>
@@ -15,6 +12,7 @@

 #include <boost/python/detail/signature.hpp>

+
 #include <vector>

 namespace boost { namespace python { namespace objects {
@@ -54,9 +52,9 @@ namespace boost { namespace python { namespace objects {
            //check if the argument default values are the same
            bool f1_has_names = bool(f1->m_arg_names);
            bool f2_has_names = bool(f2->m_arg_names);
-            if ( (f1_has_names && f2_has_names && f2->m_arg_names[i-1]!=f1->m_arg_names[i-1])
-                 || (f1_has_names && !f2_has_names)
-                 || (!f1_has_names && f2_has_names && f2->m_arg_names[i-1]!=python::object())
+            if ( f1_has_names && f2_has_names && f2->m_arg_names[i-1]!=f1->m_arg_names[i-1]
+                || f1_has_names && !f2_has_names
+                || !f1_has_names && f2_has_names && f2->m_arg_names[i-1]!=python::object()
                )
                return false;
        }
@@ -230,7 +228,7 @@ namespace boost { namespace python { namespace objects {
        {
            return str(
                "%s %s(%s%s%s%s)"
-                % boost::python::make_tuple // workaround, see top
+                % make_tuple
                ( ret_type
                    , f->m_name
                    , str(",").join(formal_params.slice(0,arity-n_overloads))
@@ -241,7 +239,7 @@ namespace boost { namespace python { namespace objects {
        }else{
            return str(
                "%s(%s%s%s%s) -> %s"
-                % boost::python::make_tuple // workaround, see top
+                % make_tuple
                ( f->m_name
                    , str(",").join(formal_params.slice(0,arity-n_overloads))
                    , n_overloads ? (n_overloads!=arity?str(" [,"):str("[ ")) : str()
@@ -253,7 +251,7 @@ namespace boost { namespace python { namespace objects {

        return str(
            "%s %s(%s%s%s%s) %s"
-            % boost::python::make_tuple // workaround, see top
+            % make_tuple
            ( cpp_types?ret_type:str("")
                , f->m_name
                , str(",").join(formal_params.slice(0,arity-n_overloads))
--- a/src/object/life_support.cpp
+++ b/src/object/life_support.cpp
@@ -36,7 +36,8 @@ extern "C"
 }

 PyTypeObject life_support_type = {
-    PyVarObject_HEAD_INIT(NULL, 0)//(&PyType_Type)
+    PyObject_HEAD_INIT(0)//(&PyType_Type)
+    0,
    const_cast<char*>("Boost.Python.life_support"),
    sizeof(life_support),
    0,
@@ -91,9 +92,9 @@ PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient)
    if (nurse == Py_None || nurse == patient)
        return nurse;
    
-    if (Py_TYPE(&life_support_type) == 0)
+    if (life_support_type.ob_type == 0)
    {
-        Py_TYPE(&life_support_type) = &PyType_Type;
+        life_support_type.ob_type = &PyType_Type;
        PyType_Ready(&life_support_type);
    }
    
--- a/src/object_operators.cpp
+++ b/src/object_operators.cpp
@@ -38,13 +38,7 @@ BOOST_PYTHON_DECL object operator op(object const& l, object const& r)  \
 BOOST_PYTHON_BINARY_OPERATOR(+, Add)
 BOOST_PYTHON_BINARY_OPERATOR(-, Subtract)
 BOOST_PYTHON_BINARY_OPERATOR(*, Multiply)
-#if PY_VERSION_HEX >= 0x03000000
-// We choose FloorDivide instead of TrueDivide to keep the semantic
-// conform with C/C++'s '/' operator
-BOOST_PYTHON_BINARY_OPERATOR(/, FloorDivide)
-#else
 BOOST_PYTHON_BINARY_OPERATOR(/, Divide)
-#endif
 BOOST_PYTHON_BINARY_OPERATOR(%, Remainder)
 BOOST_PYTHON_BINARY_OPERATOR(<<, Lshift)
 BOOST_PYTHON_BINARY_OPERATOR(>>, Rshift)
@@ -64,12 +58,7 @@ BOOST_PYTHON_DECL object& operator op##=(object& l, object const& r)    \
 BOOST_PYTHON_INPLACE_OPERATOR(+, Add)
 BOOST_PYTHON_INPLACE_OPERATOR(-, Subtract)
 BOOST_PYTHON_INPLACE_OPERATOR(*, Multiply)
-#if PY_VERSION_HEX >= 0x03000000
-// Same reason as above for choosing FloorDivide instead of TrueDivide
-BOOST_PYTHON_INPLACE_OPERATOR(/, FloorDivide)
-#else
 BOOST_PYTHON_INPLACE_OPERATOR(/, Divide)
-#endif
 BOOST_PYTHON_INPLACE_OPERATOR(%, Remainder)
 BOOST_PYTHON_INPLACE_OPERATOR(<<, Lshift)
 BOOST_PYTHON_INPLACE_OPERATOR(>>, Rshift)
--- a/src/object_protocol.cpp
+++ b/src/object_protocol.cpp
@@ -103,7 +103,6 @@ namespace // slicing code copied directly out of the Python implementation
  static PyObject *
  apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
  {
-#if PY_VERSION_HEX < 0x03000000
      PyTypeObject *tp = u->ob_type;
      PySequenceMethods *sq = tp->tp_as_sequence;

@@ -115,9 +114,7 @@ namespace // slicing code copied directly out of the Python implementation
              return NULL;
          return PySequence_GetSlice(u, ilow, ihigh);
      }
-      else 
-#endif
-      {
+      else {
          PyObject *slice = PySlice_New(v, w, NULL);
          if (slice != NULL) {
              PyObject *res = PyObject_GetItem(u, slice);
@@ -133,7 +130,6 @@ namespace // slicing code copied directly out of the Python implementation
  assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
      /* u[v:w] = x */
  {
-#if PY_VERSION_HEX < 0x03000000
      PyTypeObject *tp = u->ob_type;
      PySequenceMethods *sq = tp->tp_as_sequence;

@@ -148,9 +144,7 @@ namespace // slicing code copied directly out of the Python implementation
          else
              return PySequence_SetSlice(u, ilow, ihigh, x);
      }
-      else 
-#endif
-      {
+      else {
          PyObject *slice = PySlice_New(v, w, NULL);
          if (slice != NULL) {
              int res;
--- a/src/str.cpp
+++ b/src/str.cpp
@@ -10,40 +10,23 @@ namespace boost { namespace python { namespace detail {
 detail::new_reference str_base::call(object const& arg_)
 {
    return (detail::new_reference)PyObject_CallFunction(
-#if PY_VERSION_HEX >= 0x03000000
-        (PyObject*)&PyUnicode_Type,
-#else
-        (PyObject*)&PyString_Type, 
-#endif
-        const_cast<char*>("(O)"), 
+        (PyObject*)&PyString_Type, const_cast<char*>("(O)"), 
        arg_.ptr());
 } 

 str_base::str_base()
-  : object(detail::new_reference(
-#if PY_VERSION_HEX >= 0x03000000
-              ::PyUnicode_FromString("")
-#else
-              ::PyString_FromString("")
-#endif
-            ))
+  : object(detail::new_reference(::PyString_FromString("")))
 {}

 str_base::str_base(const char* s)
-  : object(detail::new_reference(
-#if PY_VERSION_HEX >= 0x03000000
-              ::PyUnicode_FromString(s)
-#else
-              ::PyString_FromString(s)
-#endif
-            ))
+  : object(detail::new_reference(::PyString_FromString(s)))
 {}

 namespace {

    ssize_t str_size_as_py_ssize_t(std::size_t n)
    {
-      if (n > static_cast<std::size_t>(ssize_t_max))
+      if (n > ssize_t_max)
      {
          throw std::range_error("str size > ssize_t_max");
      }
@@ -55,12 +38,9 @@ namespace {
 str_base::str_base(char const* start, char const* finish)
    : object(
        detail::new_reference(
-#if PY_VERSION_HEX >= 0x03000000
-            ::PyUnicode_FromStringAndSize
-#else
-            ::PyString_FromStringAndSize
-#endif
-                (start, str_size_as_py_ssize_t(finish - start))
+            ::PyString_FromStringAndSize(
+                start, str_size_as_py_ssize_t(finish - start)
+            )
        )
    )
 {}
@@ -68,12 +48,9 @@ str_base::str_base(char const* start, char const* finish)
 str_base::str_base(char const* start, std::size_t length) // new str
    : object(
        detail::new_reference(
-#if PY_VERSION_HEX >= 0x03000000
-            ::PyUnicode_FromStringAndSize
-#else
-            ::PyString_FromStringAndSize
-#endif
-            ( start, str_size_as_py_ssize_t(length) )
+            ::PyString_FromStringAndSize(
+                start, str_size_as_py_ssize_t(length)
+            )
        )
    )
 {}
@@ -115,7 +92,6 @@ long str_base::count(object_cref sub, object_cref start, object_cref end) const
    return extract<long>(this->attr("count")(sub,start,end));
 }

-#if PY_VERSION_HEX < 0x03000000
 object str_base::decode() const
 {
    return this->attr("decode")();
@@ -130,7 +106,6 @@ object str_base::decode(object_cref encoding, object_cref errors) const
 {
    return this->attr("decode")(encoding,errors);
 }
-#endif

 object str_base::encode() const
 {
@@ -147,16 +122,9 @@ object str_base::encode(object_cref encoding, object_cref errors) const
    return this->attr("encode")(encoding,errors);
 }

-
-#if PY_VERSION_HEX >= 0x03000000
-    #define _BOOST_PYTHON_ASLONG PyLong_AsLong
-#else
-    #define _BOOST_PYTHON_ASLONG PyInt_AsLong
-#endif
-
 bool str_base::endswith(object_cref suffix) const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("endswith")(suffix).ptr());
+    bool result = PyInt_AsLong(this->attr("endswith")(suffix).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -167,7 +135,7 @@ BOOST_PYTHON_DEFINE_STR_METHOD(expandtabs, 1)

 long str_base::find(object_cref sub) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("find")(sub).ptr());
+    long result = PyInt_AsLong(this->attr("find")(sub).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -175,7 +143,7 @@ long str_base::find(object_cref sub) const

 long str_base::find(object_cref sub, object_cref start) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("find")(sub,start).ptr());
+    long result = PyInt_AsLong(this->attr("find")(sub,start).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -183,7 +151,7 @@ long str_base::find(object_cref sub, object_cref start) const

 long str_base::find(object_cref sub, object_cref start, object_cref end) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("find")(sub,start,end).ptr());
+    long result = PyInt_AsLong(this->attr("find")(sub,start,end).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -191,7 +159,7 @@ long str_base::find(object_cref sub, object_cref start, object_cref end) const

 long str_base::index(object_cref sub) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("index")(sub).ptr());
+    long result = PyInt_AsLong(this->attr("index")(sub).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -199,7 +167,7 @@ long str_base::index(object_cref sub) const

 long str_base::index(object_cref sub, object_cref start) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("index")(sub,start).ptr());
+    long result = PyInt_AsLong(this->attr("index")(sub,start).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -207,7 +175,7 @@ long str_base::index(object_cref sub, object_cref start) const

 long str_base::index(object_cref sub, object_cref start, object_cref end) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("index")(sub,start,end).ptr());
+    long result = PyInt_AsLong(this->attr("index")(sub,start,end).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -215,7 +183,7 @@ long str_base::index(object_cref sub, object_cref start, object_cref end) const

 bool str_base::isalnum() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("isalnum")().ptr());
+    bool result = PyInt_AsLong(this->attr("isalnum")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -223,7 +191,7 @@ bool str_base::isalnum() const

 bool str_base::isalpha() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("isalpha")().ptr());
+    bool result = PyInt_AsLong(this->attr("isalpha")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -231,7 +199,7 @@ bool str_base::isalpha() const

 bool str_base::isdigit() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("isdigit")().ptr());
+    bool result = PyInt_AsLong(this->attr("isdigit")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -239,7 +207,7 @@ bool str_base::isdigit() const

 bool str_base::islower() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("islower")().ptr());
+    bool result = PyInt_AsLong(this->attr("islower")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -247,7 +215,7 @@ bool str_base::islower() const

 bool str_base::isspace() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("isspace")().ptr());
+    bool result = PyInt_AsLong(this->attr("isspace")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -255,7 +223,7 @@ bool str_base::isspace() const

 bool str_base::istitle() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("istitle")().ptr());
+    bool result = PyInt_AsLong(this->attr("istitle")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -263,7 +231,7 @@ bool str_base::istitle() const

 bool str_base::isupper() const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("isupper")().ptr());
+    bool result = PyInt_AsLong(this->attr("isupper")().ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -278,7 +246,7 @@ BOOST_PYTHON_DEFINE_STR_METHOD(replace, 3)

 long str_base::rfind(object_cref sub) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("rfind")(sub).ptr());
+    long result = PyInt_AsLong(this->attr("rfind")(sub).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -286,7 +254,7 @@ long str_base::rfind(object_cref sub) const

 long str_base::rfind(object_cref sub, object_cref start) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("rfind")(sub,start).ptr());
+    long result = PyInt_AsLong(this->attr("rfind")(sub,start).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -294,7 +262,7 @@ long str_base::rfind(object_cref sub, object_cref start) const

 long str_base::rfind(object_cref sub, object_cref start, object_cref end) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("rfind")(sub,start,end).ptr());
+    long result = PyInt_AsLong(this->attr("rfind")(sub,start,end).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -302,7 +270,7 @@ long str_base::rfind(object_cref sub, object_cref start, object_cref end) const

 long str_base::rindex(object_cref sub) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("rindex")(sub).ptr());
+    long result = PyInt_AsLong(this->attr("rindex")(sub).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -310,7 +278,7 @@ long str_base::rindex(object_cref sub) const

 long str_base::rindex(object_cref sub, object_cref start) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("rindex")(sub,start).ptr());
+    long result = PyInt_AsLong(this->attr("rindex")(sub,start).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -318,7 +286,7 @@ long str_base::rindex(object_cref sub, object_cref start) const

 long str_base::rindex(object_cref sub, object_cref start, object_cref end) const
 {
-    long result = _BOOST_PYTHON_ASLONG(this->attr("rindex")(sub,start,end).ptr());
+    long result = PyInt_AsLong(this->attr("rindex")(sub,start,end).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -354,7 +322,7 @@ list str_base::splitlines(object_cref keepends) const

 bool str_base::startswith(object_cref prefix) const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("startswith")(prefix).ptr());
+    bool result = PyInt_AsLong(this->attr("startswith")(prefix).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -362,7 +330,7 @@ bool str_base::startswith(object_cref prefix) const

 bool str_base::startswith(object_cref prefix, object_cref start) const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("startswith")(prefix,start).ptr());
+    bool result = PyInt_AsLong(this->attr("startswith")(prefix,start).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
@@ -370,14 +338,12 @@ bool str_base::startswith(object_cref prefix, object_cref start) const

 bool str_base::startswith(object_cref prefix, object_cref start, object_cref end) const
 {
-    bool result = _BOOST_PYTHON_ASLONG(this->attr("startswith")(prefix,start,end).ptr());
+    bool result = PyInt_AsLong(this->attr("startswith")(prefix,start,end).ptr());
    if (PyErr_Occurred())
        throw_error_already_set();
    return result;
 }

-#undef _BOOST_PYTHON_ASLONG
-
 BOOST_PYTHON_DEFINE_STR_METHOD(strip, 0)
 BOOST_PYTHON_DEFINE_STR_METHOD(swapcase, 0)
 BOOST_PYTHON_DEFINE_STR_METHOD(title, 0)
@@ -391,12 +357,7 @@ static struct register_str_pytype_ptr
    {
        const_cast<converter::registration &>(
            converter::registry::lookup(boost::python::type_id<boost::python::str>())
-            )
-#if PY_VERSION_HEX >= 0x03000000
-            .m_class_object = &PyUnicode_Type;
-#else
-            .m_class_object = &PyString_Type;
-#endif
+            ).m_class_object = &PyString_Type;
    }
 }register_str_pytype_ptr_;
    
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -0,0 +1,207 @@
+macro(bpl_test TESTNAME)
+  parse_arguments(BPL_TEST
+    "ARGS"
+    ""
+    ${ARGN})
+
+  # Determine the Python and C++ source files for this test
+  if (BPL_TEST_DEFAULT_ARGS)
+    # First argument is the Python source we will run, the rest are
+    # either extra Python sources we're dependent on or C++ files from
+    # which we will build extension modules.
+    car(BPL_TEST_PYSOURCE ${BPL_TEST_DEFAULT_ARGS})
+    cdr(BPL_TEST_DEFAULT_ARGS ${BPL_TEST_DEFAULT_ARGS})
+
+    get_filename_component(BPL_TEST_PYBASE ${BPL_TEST_PYSOURCE} NAME_WE)
+    foreach(SRC ${BPL_TEST_DEFAULT_ARGS})
+      get_filename_component(BPL_SRC_EXT ${SRC} EXT)
+      if (BPL_SRC_EXT STREQUAL ".cpp")
+        # Build a Python extension module from this source file
+        get_filename_component(BPL_SRC_NAME ${SRC} NAME_WE)
+        if(BPL_TEST_PYBASE STREQUAL "${BPL_SRC_NAME}")
+          boost_python_extension(${BPL_SRC_NAME}_ext ${SRC})
+        else(BPL_TEST_PYBASE STREQUAL "${BPL_SRC_NAME}")
+          boost_python_extension(${BPL_SRC_NAME} ${SRC})
+        endif(BPL_TEST_PYBASE STREQUAL "${BPL_SRC_NAME}")
+      endif (BPL_SRC_EXT STREQUAL ".cpp")
+    endforeach(SRC ${BPL_TEST_DEFAULT_ARGS})
+  else (BPL_TEST_DEFAULT_ARGS)
+    set(BPL_TEST_PYSOURCE "${TESTNAME}.py")
+
+    # Build a Python extension module from this source file
+    boost_python_extension(${TESTNAME}_ext "${TESTNAME}.cpp")
+  endif(BPL_TEST_DEFAULT_ARGS)
+
+  # We'll need the full patch to run the Python test
+  set(BPL_TEST_PYSOURCE ${CMAKE_CURRENT_SOURCE_DIR}/${BPL_TEST_PYSOURCE})
+    
+  # Run the test itself
+  file(TO_NATIVE_PATH "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}" PYTHONPATH)
+  if(WIN32 AND NOT UNIX)
+    string(REPLACE "\\" "\\\\" PYTHONPATH "${PYTHONPATH}")
+  endif(WIN32 AND NOT UNIX)
+  set(FULL_TESTNAME ${PROJECT_NAME}-${TESTNAME})
+  add_test(${FULL_TESTNAME}
+    ${PYTHON_EXECUTABLE} 
+    "${CMAKE_CURRENT_SOURCE_DIR}/pyrun.py" 
+    "${PYTHONPATH}"
+    ${BPL_TEST_PYSOURCE} ${BPL_TEST_ARGS})
+
+  set_tests_properties(${FULL_TESTNAME}
+    PROPERTIES
+    LABELS "${PROJECT_NAME}"
+    )
+endmacro(bpl_test)
+
+macro(py_run TESTNAME)
+  boost_test_run(${TESTNAME} 
+    ${TESTNAME}.cpp
+    DEPENDS boost_python STATIC
+    LINK_LIBS ${PYTHON_LIBRARIES})
+endmacro(py_run)
+
+boost_test_run(exec 
+  DEPENDS boost_python STATIC 
+  ARGS "${CMAKE_CURRENT_SOURCE_DIR}/exec.py"
+  LINK_LIBS ${PYTHON_LIBRARIES})
+boost_test_run(exec-dynamic 
+  exec.cpp
+  ARGS "${CMAKE_CURRENT_SOURCE_DIR}/exec.py"
+  DEPENDS boost_python SHARED 
+  LINK_LIBS ${PYTHON_LIBRARIES})
+
+bpl_test(crossmod_exception 
+  crossmod_exception.py crossmod_exception_a.cpp crossmod_exception_b.cpp)
+
+bpl_test(injected)
+bpl_test(properties)
+bpl_test(return_arg)
+bpl_test(staticmethod)
+bpl_test(shared_ptr)
+bpl_test(andreas_beyer)
+bpl_test(polymorphism)
+bpl_test(polymorphism2)
+
+bpl_test(wrapper_held_type)
+bpl_test(polymorphism2_auto_ptr)
+
+bpl_test(auto_ptr)
+
+bpl_test(minimal)
+bpl_test(args)
+bpl_test(raw_ctor)
+bpl_test(numpy numpy.py printer.py numeric_tests.py numarray_tests.py numpy.cpp)
+bpl_test(enum)
+bpl_test(exception_translator)
+bpl_test(pearu1 test_cltree.py cltree.cpp)
+bpl_test(try newtest.py m1.cpp m2.cpp)
+bpl_test(const_argument)
+bpl_test(keywords keywords_test.py keywords.cpp)
+   
+boost_python_extension(builtin_converters_ext test_builtin_converters.cpp)
+bpl_test(builtin_converters test_builtin_converters.py builtin_converters_ext)
+
+#
+#   See the contents of this file for more details on an existing
+#   overload resoluton bug.
+#
+#   boost_python_extension(overload_resolution test_overload_resolution.cpp)
+#
+
+bpl_test(test_pointer_adoption)
+bpl_test(operators)
+bpl_test(callbacks)
+bpl_test(defaults)
+
+bpl_test(object)
+bpl_test(list)
+bpl_test(long)
+bpl_test(dict)
+bpl_test(tuple)
+bpl_test(str)
+bpl_test(slice)
+
+bpl_test(virtual_functions)
+bpl_test(back_reference)
+bpl_test(implicit)
+bpl_test(data_members)
+
+bpl_test(ben_scott1)
+
+bpl_test(bienstman1)
+bpl_test(bienstman2)
+bpl_test(bienstman3)
+
+bpl_test(multi_arg_constructor)
+# TODO: A bug in the Win32 intel compilers causes compilation of one
+# of our tests to take forever when debug symbols are
+# enabled. This rule turns them off when added to the requirements
+# section 
+#   <toolset>intel-win:<debug-symbols>off
+
+bpl_test(iterator iterator.py iterator.cpp input_iterator.cpp)
+
+bpl_test(stl_iterator stl_iterator.py stl_iterator.cpp)
+
+bpl_test(extract)
+
+bpl_test (crossmod_opaque
+  crossmod_opaque.py crossmod_opaque_a.cpp crossmod_opaque_b.cpp)
+
+bpl_test(opaque)
+bpl_test(voidptr)
+
+bpl_test(pickle1)
+bpl_test(pickle2)
+bpl_test(pickle3)
+bpl_test(pickle4)
+
+bpl_test(nested)
+
+bpl_test(docstring)
+
+bpl_test(vector_indexing_suite)
+
+bpl_test(pointer_vector)
+# TODO: Turn off this test on HP CXX, as the test hangs when executing.
+# Whenever the cause for the failure of the polymorphism test is found
+# and fixed, this should be retested.
+#    <toolset>hp_cxx:<build>no
+      
+boost_python_extension(map_indexing_suite_ext 
+  map_indexing_suite.cpp int_map_indexing_suite.cpp a_map_indexing_suite.cpp)
+
+bpl_test(map_indexing_suite 
+  map_indexing_suite.py map_indexing_suite_ext)
+
+
+# --- unit tests of library components ---
+
+boost_test_compile(indirect_traits_test)
+boost_test_run(destroy_test)
+py_run(pointer_type_id_test)
+py_run(bases)
+boost_test_run(if_else)
+py_run(pointee)
+boost_test_run(result)
+
+boost_test_compile(string_literal)
+boost_test_compile(borrowed)
+boost_test_compile(object_manager)
+boost_test_compile(copy_ctor_mutates_rhs)
+
+py_run(upcast)
+  
+boost_test_compile(select_holder)
+
+boost_test_run(select_from_python_test
+  select_from_python_test.cpp ../src/converter/type_id.cpp
+  COMPILE_FLAGS "-DBOOST_PYTHON_STATIC_LIB"
+  LINK_LIBS ${PYTHON_LIBRARIES})
+  
+boost_test_compile(select_arg_to_python_test)
+
+boost_test_compile_fail(raw_pyobject_fail1)
+boost_test_compile_fail(raw_pyobject_fail2)
+boost_test_compile_fail(as_to_python_function)
+boost_test_compile_fail(object_fail1)
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -77,15 +77,12 @@ bpl-test crossmod_exception
 [ bpl-test shared_ptr ]
 [ bpl-test enable_shared_from_this ]
 [ bpl-test andreas_beyer ]
-[ bpl-test wrapper_held_type ]
-
-[ bpl-test polymorphism2_auto_ptr 
-  : polymorphism2_auto_ptr.py polymorphism2.py polymorphism2_auto_ptr.cpp 
-]
-
 [ bpl-test polymorphism ]
 [ bpl-test polymorphism2 ]

+[ bpl-test wrapper_held_type ]
+[ bpl-test polymorphism2_auto_ptr ]
+
 [ bpl-test auto_ptr ]

 [ bpl-test minimal ]
--- a/test/a_map_indexing_suite.cpp
+++ b/test/a_map_indexing_suite.cpp
@@ -48,11 +48,7 @@ struct AFromPython

  static void* convertible(PyObject* obj_ptr)
  {
-#if PY_VERSION_HEX >= 0x03000000
-    if (!PyLong_Check(obj_ptr)) return 0;
-#else
    if (!PyInt_Check(obj_ptr)) return 0;
-#endif
    return obj_ptr;
  }

@@ -64,11 +60,7 @@ struct AFromPython
        (boost::python::converter::rvalue_from_python_storage< A >*)
        data)-> storage.bytes;

-#if PY_VERSION_HEX >= 0x03000000
-    new (storage) A((int)PyLong_AsLong(obj_ptr));
-#else
    new (storage) A((int)PyInt_AsLong(obj_ptr));
-#endif
    data->convertible = storage;
  }
 };
--- a/test/crossmod_opaque.py
+++ b/test/crossmod_opaque.py
@@ -1,4 +1,4 @@
-# -*- coding: latin-1 -*-
+# -*- coding: iso-latin-1 -*-
 # Copyright Gottfried Ganßauge 2006.
 # Distributed under the Boost Software License, Version 1.0. (See
 # accompanying file LICENSE_1_0.txt or copy at
--- a/test/defaults.py
+++ b/test/defaults.py
@@ -2,6 +2,13 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 """
+# Use builtin True/False when available:
+>>> try:
+...     assert(True == 1)
+... except:
+...     True = 1
+...     False = 0
+
 >>> from defaults_ext import *
 >>> bar(1)
 'int(1); char(D); string(default); double(0.0); '
--- a/test/dict.py
+++ b/test/dict.py
@@ -20,7 +20,7 @@
 [(1, {'key2': 'value2'}), ('key1', 'value1')]
 >>> print dict_from_sequence([(1,1),(2,2),(3,3)])
 {1: 1, 2: 2, 3: 3}
->>> test_templates(printer) #doctest: +NORMALIZE_WHITESPACE
+>>> test_templates(printer)
 a test string
 13
 None
--- a/test/enum.cpp
+++ b/test/enum.cpp
@@ -12,7 +12,7 @@
 #endif 
 using namespace boost::python;

-enum color { red = 1, green = 2, blue = 4, blood = 1 };
+enum color { red = 1, green = 2, blue = 4 };

 #if BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
 namespace boost  // Pro7 has a hard time detecting enums
@@ -34,7 +34,6 @@ BOOST_PYTHON_MODULE(enum_ext)
        .value("red", red)
        .value("green", green)
        .value("blue", blue)
-        .value("blood", blood)
        .export_values()
        ;
    
--- a/test/enum.py
+++ b/test/enum.py
@@ -4,8 +4,8 @@
 '''
 >>> from enum_ext import *

->>> identity(color.red) # in case of duplicated enums it always take the last enum
-enum_ext.color.blood
+>>> identity(color.red)
+enum_ext.color.red

 >>> identity(color.green)
 enum_ext.color.green
@@ -13,8 +13,8 @@ enum_ext.color.green
 >>> identity(color.blue)
 enum_ext.color.blue

->>> identity(color(1)) # in case of duplicated enums it always take the last enum
-enum_ext.color.blood
+>>> identity(color(1))
+enum_ext.color.red

 >>> identity(color(2))
 enum_ext.color.green
@@ -28,7 +28,7 @@ enum_ext.color.blue
  --- check export to scope ---

 >>> identity(red)
-enum_ext.color.blood
+enum_ext.color.red

 >>> identity(green)
 enum_ext.color.green
@@ -42,18 +42,10 @@ enum_ext.color.blue

 >>> c = colorized()
 >>> c.x
-enum_ext.color.blood
+enum_ext.color.red
 >>> c.x = green
 >>> c.x
 enum_ext.color.green
->>> red == blood
-True
->>> red == green
-False
->>> hash(red) == hash(blood)
-True
->>> hash(red) == hash(green)
-False
 '''

 # pickling of enums only works with Python 2.3 or higher
--- a/test/exec.cpp
+++ b/test/exec.cpp
@@ -59,13 +59,7 @@ void eval_test()
 void exec_test()
 {
  // Register the module with the interpreter
-  if (PyImport_AppendInittab(const_cast<char*>("embedded_hello"),
-#if PY_VERSION_HEX >= 0x03000000 
-			     PyInit_embedded_hello 
-#else 
-			     initembedded_hello 
-#endif 
-			     ) == -1) 
+  if (PyImport_AppendInittab(const_cast<char*>("embedded_hello"), initembedded_hello) == -1)
    throw std::runtime_error("Failed to add embedded_hello to the interpreter's "
                 "builtin modules");
  // Retrieve the main module
@@ -111,76 +105,49 @@ void exec_test_error()
 {
  // Execute a statement that raises a python exception.
  python::dict global;
-  python::object result = python::exec("print(unknown) \n", global, global);
-}
-
-void exercise_embedding_html()
-{
-    using namespace boost::python;
-    /* code from: libs/python/doc/tutorial/doc/tutorial.qbk
-       (generates libs/python/doc/tutorial/doc/html/python/embedding.html)
-     */
-    object main_module = import("__main__");
-    object main_namespace = main_module.attr("__dict__");
-
-    object ignored = exec("hello = file('hello.txt', 'w')\n"
-                          "hello.write('Hello world!')\n"
-                          "hello.close()",
-                          main_namespace);
-}
-
-void check_pyerr(bool pyerr_expected=false)
-{
-  if (PyErr_Occurred())
-  {
-    if (!pyerr_expected) {
-      BOOST_ERROR("Python Error detected");
-      PyErr_Print();
-    }
-    else {
-      PyErr_Clear();
-    }
-  }
-  else
-  {
-    BOOST_ERROR("A C++ exception was thrown  for which "
-                "there was no exception handler registered.");
-  }
+  python::object result = python::exec("print unknown \n", global, global);
 }

 int main(int argc, char **argv)
 {
-  BOOST_TEST(argc == 2 || argc == 3);
+  BOOST_TEST(argc == 2);
  std::string script = argv[1];
  // Initialize the interpreter
  Py_Initialize();

-  if (python::handle_exception(eval_test)) {
-    check_pyerr();
-  }
-  else if(python::handle_exception(exec_test)) {
-    check_pyerr();
-  }
-  else if (python::handle_exception(boost::bind(exec_file_test, script))) {
-    check_pyerr();
+  if (python::handle_exception(eval_test) ||
+      python::handle_exception(exec_test) ||
+      python::handle_exception(boost::bind(exec_file_test, script)))
+  {
+    if (PyErr_Occurred())
+    {
+      BOOST_ERROR("Python Error detected");
+      PyErr_Print();
+    }
+    else
+    {
+        BOOST_ERROR("A C++ exception was thrown  for which "
+                    "there was no exception handler registered.");
+    }
  }
  
  if (python::handle_exception(exec_test_error))
  {
-    check_pyerr(/*pyerr_expected*/ true);
+    if (PyErr_Occurred())
+    {
+      PyErr_Print();
+    }
+    else
+    {
+        BOOST_ERROR("A C++ exception was thrown  for which "
+                    "there was no exception handler registered.");
+    }
  }
  else
  {
-    BOOST_ERROR("Python exception expected, but not seen.");
+      BOOST_ERROR("Python exception expected, but not seen.");
  }
-
-  if (argc > 2) {
-    // The main purpose is to test compilation. Since this test generates
-    // a file and I (rwgk) am uncertain about the side-effects, run it only
-    // if explicitly requested.
-    exercise_embedding_html();
-  }
-
+  
  // Boost.Python doesn't support Py_Finalize yet.
  // Py_Finalize();
  return boost::report_errors();
--- a/test/exec.py
+++ b/test/exec.py
@@ -2,5 +2,5 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-if 1:
-    number = 42
+print 'Hello World !'
+number = 42
--- a/test/iterator.py
+++ b/test/iterator.py
@@ -53,7 +53,7 @@
 >>> ll.push_back(x)
 >>> x.push_back(7)
 >>> ll.push_back(x)
->>> for a in ll: #doctest: +NORMALIZE_WHITESPACE
+>>> for a in ll:
 ...     for b in a:
 ...         print b,
 ...     print
--- a/test/list.cpp
+++ b/test/list.cpp
@@ -7,8 +7,6 @@
 #include <boost/python/def.hpp>
 #include <boost/python/class.hpp>
 #include <boost/python/list.hpp>
-#include <boost/python/tuple.hpp>
-#include <boost/python/dict.hpp>
 #include <boost/python/make_function.hpp>
 #include <boost/lexical_cast.hpp>
 #define BOOST_ENABLE_ASSERT_HANDLER
@@ -111,16 +109,11 @@ void exercise(list x, object y, object print)

    print("sorted:");
    x.pop(2); // make sorting predictable
-    x.pop(2); // remove [1,2] so the list is sortable in py3k
    x.sort();
    print(x);

    print("reverse sorted:");
-#if PY_VERSION_HEX >= 0x03000000
-    x.sort(*tuple(), **dict(make_tuple(make_tuple("reverse", true))));
-#else
    x.sort(&notcmp);
-#endif
    print(x);

    list w;
--- a/test/list.py
+++ b/test/list.py
@@ -73,7 +73,7 @@ X(22)
 ...

 >>> y = X(42)
->>> exercise(letters, y, printer) #doctest: +NORMALIZE_WHITESPACE
+>>> exercise(letters, y, printer)
 after append:
 ['h', 'e', 'l', 'l', 'o', '.', [1, 2], X(42), 5, X(3)]
 number of X(42) instances: 1
@@ -97,9 +97,9 @@ removing 666
 reversing...
 ['y', 'x', X(3), [1, 2], '.', 'o', 'l', 'l', 'e', 'h']
 sorted:
-['.', 'e', 'h', 'l', 'l', 'o', 'x', 'y']
+[[1, 2], '.', 'e', 'h', 'l', 'l', 'o', 'x', 'y']
 reverse sorted:
-['y', 'x', 'o', 'l', 'l', 'h', 'e', '.']
+['y', 'x', 'o', 'l', 'l', 'h', 'e', '.', [1, 2]]
 '''

 def run(args = None):
--- a/test/long.py
+++ b/test/long.py
@@ -3,12 +3,12 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 '''
 >>> from long_ext import *
->>> print new_long()
-0
->>> print longify(42)
-42
->>> print longify_string('300')
-300
+>>> new_long()
+0L
+>>> longify(42)
+42L
+>>> longify_string('300')
+300L
 >>> is_long(20L)
 'yes'
 >>> is_long('20')
--- a/test/m1.cpp
+++ b/test/m1.cpp
@@ -32,7 +32,8 @@ struct NoddyObject : PyObject
 };

 PyTypeObject NoddyType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
+    PyObject_HEAD_INIT(NULL)
+    0,
    const_cast<char*>("Noddy"),
    sizeof(NoddyObject),
    0,
@@ -103,7 +104,8 @@ struct extract_simple_object
 };

 PyTypeObject SimpleType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
+    PyObject_HEAD_INIT(NULL)
+    0,
    const_cast<char*>("Simple"),
    sizeof(SimpleObject),
    0,
--- a/test/m2.cpp
+++ b/test/m2.cpp
@@ -13,11 +13,6 @@
 #include <boost/python/return_value_policy.hpp>
 #include "simple_type.hpp"

-#if PY_VERSION_HEX >= 0x03000000
-# define PyString_FromString PyUnicode_FromString
-# define PyInt_FromLong PyLong_FromLong
-#endif
-
 // Get a simple (by value) from the argument, and return the
 // string it holds.
 PyObject* unwrap_simple(simple x)
@@ -57,11 +52,6 @@ PyObject* unwrap_int_const_ref(int const& x)
    return PyInt_FromLong(x);
 }

-#if PY_VERSION_HEX >= 0x03000000
-# undef PyString_FromString
-# undef PyInt_FromLong
-#endif
-
 // rewrap<T> extracts a T from the argument, then converts the T back
 // to a PyObject* and returns it.
 template <class T>
--- a/test/map_indexing_suite.py
+++ b/test/map_indexing_suite.py
@@ -197,7 +197,7 @@ kiwi
 >>> tm["kimpo"] = X("bbb")
 >>> print_xmap(tm)
 [ (joel, aaa) (kimpo, bbb) ]
->>> for el in tm: #doctest: +NORMALIZE_WHITESPACE
+>>> for el in tm:
 ...     print el.key(),
 ...     dom = el.data()
 joel kimpo
--- a/test/opaque.py
+++ b/test/opaque.py
@@ -1,4 +1,4 @@
-# -*- coding: latin-1 -*-
+# -*- coding: iso-latin-1 -*-
 # Copyright Gottfried Ganßauge 2003..2006.  Distributed under the Boost
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/pickle1.cpp
+++ b/test/pickle1.cpp
@@ -40,7 +40,8 @@ namespace boost_python_test {
    boost::python::tuple
    getinitargs(const world& w)
    {
-        return boost::python::make_tuple(w.get_country());
+        using namespace boost::python;
+        return make_tuple(w.get_country());
    }
  };

--- a/test/pickle2.cpp
+++ b/test/pickle2.cpp
@@ -52,14 +52,16 @@ namespace boost_python_test {
    boost::python::tuple
    getinitargs(const world& w)
    {
-        return boost::python::make_tuple(w.get_country());
+        using namespace boost::python;
+        return make_tuple(w.get_country());
    }

    static
    boost::python::tuple
    getstate(const world& w)
    {
-        return boost::python::make_tuple(w.get_secret_number());
+        using namespace boost::python;
+        return make_tuple(w.get_secret_number());
    }

    static
@@ -75,7 +77,7 @@ namespace boost_python_test {
              );
          throw_error_already_set();
        }
-
+        
        long number = extract<long>(state[0]);
        if (number != 42)
            w.set_secret_number(number);
--- a/test/pickle2.py
+++ b/test/pickle2.py
@@ -29,7 +29,7 @@ r'''>>> import pickle2_ext
    >>> wd.__dict__
    {'x': 1}
    >>> try: pstr = pickle.dumps(wd)
-    ... except RuntimeError, err: print err
+    ... except RuntimeError, err: print err[0]
    ...
    Incomplete pickle support (__getstate_manages_dict__ not set)
 '''
--- a/test/pickle3.cpp
+++ b/test/pickle3.cpp
@@ -25,6 +25,10 @@
 #include <boost/python/extract.hpp>
 #include <boost/python/back_reference.hpp>

+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580)) || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+# define make_tuple boost::python::make_tuple
+#endif 
+
 namespace boost_python_test {

  // A friendly class.
@@ -49,18 +53,18 @@ namespace boost_python_test {
    boost::python::tuple
    getinitargs(const world& w)
    {
-        return boost::python::make_tuple(w.get_country());
+        using namespace boost::python;
+        return make_tuple(w.get_country());
    }

    static
    boost::python::tuple
    getstate(boost::python::object w_obj)
    {
-        world const& w = boost::python::extract<world const&>(w_obj)();
+        using namespace boost::python;
+        world const& w = extract<world const&>(w_obj)();

-        return boost::python::make_tuple(
-            w_obj.attr("__dict__"),
-            w.get_secret_number());
+        return make_tuple(w_obj.attr("__dict__"), w.get_secret_number());
    }

    static
@@ -69,7 +73,7 @@ namespace boost_python_test {
    {
        using namespace boost::python;
        world& w = extract<world&>(w_obj)();
-
+        
        if (len(state) != 2)
        {
          PyErr_SetObject(PyExc_ValueError,
@@ -78,11 +82,11 @@ namespace boost_python_test {
              );
          throw_error_already_set();
        }
-
+        
        // restore the object's __dict__
        dict d = extract<dict>(w_obj.attr("__dict__"))();
        d.update(state[0]);
-
+        
        // restore the internal state of the C++ object
        long number = extract<long>(state[1]);
        if (number != 42)
--- a/test/str.cpp
+++ b/test/str.cpp
@@ -26,13 +26,8 @@ void work_with_string(object print)
    print(data.capitalize());
    print('[' + data.center(30) + ']');
    print(data.count("t"));
-#if PY_VERSION_HEX < 0x03000000
    print(data.encode("utf-8"));
    print(data.decode("utf-8"));
-#else
-    print(data.encode("utf-8").attr("decode")("utf-8"));
-    print(data.encode("utf-8").attr("decode")("utf-8"));
-#endif
    
    BOOST_ASSERT(!data.endswith("xx"));
    BOOST_ASSERT(!data.startswith("test"));
--- a/test/str.py
+++ b/test/str.py
@@ -7,7 +7,7 @@
 ...     for x in args: print x,
 ...     print
 ...
->>> work_with_string(printer) #doctest: +NORMALIZE_WHITESPACE
+>>> work_with_string(printer)
 ['this', 'is', 'a', 'demo', 'string']
 ['this', 'is', 'a', 'demo string']
 this<->is<->a<->demo<->string
--- a/test/test_builtin_converters.cpp
+++ b/test/test_builtin_converters.cpp
@@ -17,10 +17,6 @@ struct by_value
    {
        return x;
    }
-    static int size(void)
-    {
-        return sizeof(T);
-    }
 };

 template <class T>
@@ -65,17 +61,7 @@ BOOST_PYTHON_MODULE(builtin_converters_ext)
 {    
    def("get_type", get_type);
    def("return_null_handle", return_null_handle);
-
-// These methods are used solely for getting some C++ type sizes
-    def("bool_size", by_value<bool>::size);
-    def("char_size", by_value<char>::size);
-    def("int_size", by_value<int>::size);
-    def("short_size", by_value<short>::size);
-    def("long_size", by_value<long>::size);
-#ifdef HAVE_LONG_LONG
-    def("long_long_size", by_value<BOOST_PYTHON_LONG_LONG>::size);
-#endif
-
+        
    def("rewrap_value_bool", by_value<bool>::rewrap);
    def("rewrap_value_char", by_value<char>::rewrap);
    def("rewrap_value_signed_char", by_value<signed char>::rewrap);
--- a/test/test_builtin_converters.py
+++ b/test/test_builtin_converters.py
@@ -4,33 +4,12 @@
 r"""
 >>> from builtin_converters_ext import *

-# Provide values for integer converter tests
->>> def _signed_values(s):
-...     base = 2 ** (8 * s - 1)
-...     return [[-base, -1, 1, base - 1], [-base - 1, base]]
->>> def _unsigned_values(s):
-...     base = 2 ** (8 * s)
-...     return [[1, base - 1], [-1L, -1, base]]
-
-# Wrappers to simplify tests
->>> def should_pass(method, values):
-...     result = map(method, values[0])
-...     if result != values[0]:
-...         print "Got %s but expected %s" % (result, values[0])
->>> def test_overflow(method, values):
-...     for v in values[1]:
-...         try: method(v)
-...         except OverflowError: pass
-...         else: print "OverflowError expected"
-
 # Synthesize idendity functions in case long long not supported
 >>> if not 'rewrap_value_long_long' in dir():
 ...     def rewrap_value_long_long(x): return long(x)
 ...     def rewrap_value_unsigned_long_long(x): return long(x)
 ...     def rewrap_const_reference_long_long(x): return long(x)
 ...     def rewrap_const_reference_unsigned_long_long(x): return long(x)
->>> if not 'long_long_size' in dir():
-...     def long_long_size(): return long_size()

 >>> try: bool_exists = bool
 ... except: pass
@@ -77,43 +56,21 @@ False
 >>> hex(rewrap_value_unsigned_long(0x80000001L)).replace('L','')
 '0x80000001'

->>> rewrap_value_long_long(42) == 42
-True
->>> rewrap_value_unsigned_long_long(42) == 42
-True
+>>> rewrap_value_long_long(42)
+42L
+>>> rewrap_value_unsigned_long_long(42)
+42L

   show that we have range checking. 
+ 
+>>> try: rewrap_value_unsigned_short(-42)
+... except OverflowError: pass
+... else: print 'expected an OverflowError!'

->>> should_pass(rewrap_value_signed_char, _signed_values(char_size()))
->>> should_pass(rewrap_value_short, _signed_values(short_size()))
->>> should_pass(rewrap_value_int, _signed_values(int_size()))
->>> should_pass(rewrap_value_long, _signed_values(long_size()))
->>> should_pass(rewrap_value_long_long, _signed_values(long_long_size()))
+>>> try: rewrap_value_int(sys.maxint * 2)
+... except OverflowError: pass
+... else: print 'expected an OverflowError!'

->>> should_pass(rewrap_value_unsigned_char, _unsigned_values(char_size()))
->>> should_pass(rewrap_value_unsigned_short, _unsigned_values(short_size()))
->>> should_pass(rewrap_value_unsigned_int, _unsigned_values(int_size()))
->>> should_pass(rewrap_value_unsigned_long, _unsigned_values(long_size()))
->>> should_pass(rewrap_value_unsigned_long_long,
-...     _unsigned_values(long_long_size()))
-
->>> test_overflow(rewrap_value_signed_char, _signed_values(char_size()))
->>> test_overflow(rewrap_value_short, _signed_values(short_size()))
->>> test_overflow(rewrap_value_int, _signed_values(int_size()))
->>> test_overflow(rewrap_value_long, _signed_values(long_size()))
->>> test_overflow(rewrap_value_long_long, _signed_values(long_long_size()))
-
->>> test_overflow(rewrap_value_unsigned_char, _unsigned_values(char_size()))
->>> test_overflow(rewrap_value_unsigned_short, _unsigned_values(short_size()))
->>> test_overflow(rewrap_value_unsigned_int, _unsigned_values(int_size()))
->>> test_overflow(rewrap_value_unsigned_long, _unsigned_values(long_size()))
-
-# Exceptionally for PyLong_AsUnsignedLongLong(), a negative value raises
-# TypeError on Python versions prior to 2.7
->>> for v in _unsigned_values(long_long_size())[1]:
-...     try: rewrap_value_unsigned_long_long(v)
-...     except (OverflowError, TypeError): pass
-...     else: print "OverflowError or TypeError expected"

 >>> assert abs(rewrap_value_float(4.2) - 4.2) < .000001
 >>> rewrap_value_double(4.2) - 4.2
@@ -130,13 +87,23 @@ True
 >>> rewrap_value_string('yo, wassup?')
 'yo, wassup?'

->>> print rewrap_value_wstring(u'yo, wassup?')
-yo, wassup?
-
+>>> try:
+...     if unicode: pass
+... except:
+...     print "u'yo, wassup?'"
+... else:
+...     eval("rewrap_value_wstring(u'yo, wassup?')")
+u'yo, wassup?'
+    
   test that overloading on unicode works:

->>> print rewrap_value_string(u'yo, wassup?')
-yo, wassup?
+>>> try:
+...     if unicode: pass
+... except:
+...     print "u'yo, wassup?'"
+... else:
+...     eval("rewrap_value_string(u'yo, wassup?')")
+u'yo, wassup?'

   wrap strings with embedded nulls:
   
@@ -188,10 +155,10 @@ yo, wassup?
 42
 >>> rewrap_const_reference_unsigned_long(42)
 42
->>> rewrap_const_reference_long_long(42) == 42
-True
->>> rewrap_const_reference_unsigned_long_long(42) == 42
-True
+>>> rewrap_const_reference_long_long(42)
+42L
+>>> rewrap_const_reference_unsigned_long_long(42)
+42L


 >>> assert abs(rewrap_const_reference_float(4.2) - 4.2) < .000001
--- a/test/tuple.py
+++ b/test/tuple.py
@@ -11,7 +11,7 @@
 ('t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g')
 >>> t1 = convert_to_tuple("this is")
 >>> t2 = (1,2,3,4)
->>> test_operators(t1,t2,printer) #doctest: +NORMALIZE_WHITESPACE
+>>> test_operators(t1,t2,printer)
 ('t', 'h', 'i', 's', ' ', 'i', 's', 1, 2, 3, 4)
 >>> make_tuple()
 ()
--- a/test/upcast.cpp
+++ b/test/upcast.cpp
@@ -13,7 +13,7 @@ int main()
 {
    PyTypeObject o;
    Y y;
-    BOOST_TEST(&Py_REFCNT(boost::python::upcast<PyObject>(&o)) == &Py_REFCNT(&o));
-    BOOST_TEST(&Py_REFCNT(boost::python::upcast<PyObject>(&y)) == &Py_REFCNT(&y));
+    BOOST_TEST(&boost::python::upcast<PyObject>(&o)->ob_refcnt == &o.ob_refcnt);
+    BOOST_TEST(&boost::python::upcast<PyObject>(&y)->ob_refcnt == &y.ob_refcnt);
    return boost::report_errors();
 }