Release 1.47.0 beta 1

[SVN r72708]

class.cpp

@@ -0,0 +1,28 @@
+// 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)
+#include <boost/python/module.hpp>
+#include <boost/python/def.hpp>
+#include <boost/python/object.hpp>
+#include <boost/python/class.hpp>
+
+using namespace boost::python;
+
+struct X
+{
+    int x;
+    X(int n) : x(n) { }
+};
+
+int x_function(X& x)
+{   return x.x;
+}
+
+
+BOOST_PYTHON_MODULE(class_ext)
+{
+    class_<X>("X", init<int>());
+    def("x_function", x_function);
+}
+
+#include "module_tail.cpp"

doc/PyConDC_2003/bpl_mods.txt

@@ -27,7 +27,6 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
           Somerville, MA 02143
 :Contact: dave@boost-consulting.com
 :organization: `Boost Consulting`_
-:date: $Date$
 :status: This is a "work in progress"
 :version: 1
 :copyright: Copyright David Abrahams 2002. All rights reserved

doc/PyConDC_2003/default.css

@@ -1,8 +1,6 @@
 /*
 :Author: David Goodger
 :Contact: goodger@users.sourceforge.net
-:date: $Date$
-:version: $Revision$
 :copyright: This stylesheet has been placed in the public domain.
 
 boostinspect:nolicense

doc/tutorial/doc/html/index.html

@@ -124,7 +124,7 @@
 <p>
     </p>
 <pre class="programlisting"><span class="special">&gt;&gt;&gt;</span> <span class="keyword">import</span> <span class="identifier">hello_ext</span>
-<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
+<span class="special">&gt;&gt;&gt;</span> <span class="keyword">print</span> <span class="identifier">hello_ext</span><span class="special">.</span><span class="identifier">greet</span><span class="special">()</span>
 <span class="identifier">hello</span><span class="special">,</span> <span class="identifier">world</span>
 </pre>
 <p>

doc/tutorial/doc/tutorial.qbk

@@ -62,7 +62,7 @@ resulting DLL is now visible to Python. Here's a sample Python session:
 [python]
 
     >>> import hello_ext
-    >>> print hello.greet()
+    >>> print hello_ext.greet()
     hello, world
 
 [c++]

example/tutorial/Jamroot

@@ -26,6 +26,14 @@ project
 # source files after the colon separated by spaces.
 python-extension hello_ext : hello.cpp ;
 
+# Put the extension and Boost.Python DLL in the current directory, so
+# that running script by hand works.
+install convenient_copy 
+  : hello_ext 
+  : <install-dependencies>on <install-type>SHARED_LIB <install-type>PYTHON_EXTENSION 
+    <location>. 
+  ;
+
 # A little "rule" (function) to clean up the syntax of declaring tests
 # of these extension modules.
 local rule run-test ( test-name : sources + )

include/boost/python/converter/builtin_converters.hpp

@@ -122,7 +122,7 @@ BOOST_PYTHON_TO_INT(short)
 BOOST_PYTHON_TO_INT(int)
 BOOST_PYTHON_TO_INT(long)
 
-# if defined(_MSC_VER) && defined(_WIN64)
+# if defined(_MSC_VER) && defined(_WIN64) && PY_VERSION_HEX < 0x03000000
 /* Under 64-bit Windows std::size_t is "unsigned long long". To avoid
    getting a Python long for each std::size_t the value is checked before
    the conversion. A std::size_t is converted to a simple Python int

include/boost/python/detail/operator_id.hpp

@@ -53,6 +53,9 @@ enum operator_id
     op_nonzero,
 #endif
     op_repr
+#if PY_VERSION_HEX >= 0x03000000
+    ,op_truediv
+#endif
 };
 
 }}} // namespace boost::python::detail

include/boost/python/module_init.hpp

@@ -13,27 +13,54 @@
 
 namespace boost { namespace python { namespace detail {
 
+#  if PY_VERSION_HEX >= 0x03000000
+
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef&, void(*)());
+
+#else
+
 BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
 
+#endif
+
 }}}
 
 #  if PY_VERSION_HEX >= 0x03000000
 
-#   define _BOOST_PYTHON_MODULE_INIT(name)              \
-  PyObject* BOOST_PP_CAT (PyInit_,name)()		\
-{                                                       \
-    return boost::python::detail::init_module(          \
-					      BOOST_PP_STRINGIZE(name),&BOOST_PP_CAT(init_module_,name)); \
-}                                                       \
-  void BOOST_PP_CAT(init_module_,name)()
+#   define _BOOST_PYTHON_MODULE_INIT(name) \
+  PyObject* BOOST_PP_CAT(PyInit_, name)()  \
+  { \
+    static PyModuleDef_Base initial_m_base = { \
+        PyObject_HEAD_INIT(NULL) \
+        0, /* m_init */ \
+        0, /* m_index */ \
+        0 /* m_copy */ };  \
+    static PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } }; \
+ \
+    static struct PyModuleDef moduledef = { \
+        initial_m_base, \
+        BOOST_PP_STRINGIZE(name), \
+        0, /* m_doc */ \
+        -1, /* m_size */ \
+        initial_methods, \
+        0,  /* m_reload */ \
+        0, /* m_traverse */ \
+        0, /* m_clear */ \
+        0,  /* m_free */ \
+    }; \
+ \
+    return boost::python::detail::init_module( \
+        moduledef, BOOST_PP_CAT(init_module_, name) ); \
+  } \
+  void BOOST_PP_CAT(init_module_, name)()
 
 #  else
 
 #   define _BOOST_PYTHON_MODULE_INIT(name)              \
-  void BOOST_PP_CAT(init,name)()			\
+  void BOOST_PP_CAT(init,name)()                        \
 {                                                       \
     boost::python::detail::init_module(                 \
-				       BOOST_PP_STRINGIZE(name),&BOOST_PP_CAT(init_module_,name)); \
+        BOOST_PP_STRINGIZE(name),&BOOST_PP_CAT(init_module_,name)); \
 }                                                       \
   void BOOST_PP_CAT(init_module_,name)()
 
@@ -42,23 +69,23 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
 #  if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(BOOST_PYTHON_STATIC_MODULE)
 
 #   define BOOST_PYTHON_MODULE_INIT(name)                           \
-  void BOOST_PP_CAT(init_module_,name)();			    \
+  void BOOST_PP_CAT(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 BOOST_PP_CAT(init_module_,name)();				\
+  void BOOST_PP_CAT(init_module_,name)();                               \
 extern "C" __attribute__ ((visibility("default"))) _BOOST_PYTHON_MODULE_INIT(name)
 
 #  else
 
 #   define BOOST_PYTHON_MODULE_INIT(name)                               \
-  void BOOST_PP_CAT(init_module_,name)();				\
+  void BOOST_PP_CAT(init_module_,name)();                               \
 extern "C" _BOOST_PYTHON_MODULE_INIT(name)
 
 #  endif
 
-# endif 
+# endif
 
 #endif // MODULE_INIT_DWA20020722_HPP

include/boost/python/object/function.hpp

@@ -39,6 +39,8 @@ struct BOOST_PYTHON_DECL function : PyObject
     void doc(object const& x);
     
     object const& name() const;
+
+    object const& get_namespace() const { return m_namespace; }
     
  private: // helper functions
     object signature(bool show_return_type=false) const;

include/boost/python/object/make_instance.hpp

@@ -10,6 +10,8 @@
 # include <boost/python/converter/registered.hpp>
 # include <boost/python/detail/decref_guard.hpp>
 # include <boost/python/detail/none.hpp>
+# include <boost/mpl/assert.hpp>
+# include <boost/mpl/or.hpp>
 # include <boost/type_traits/is_union.hpp>
 
 namespace boost { namespace python { namespace objects { 

include/boost/python/operators.hpp

@@ -212,7 +212,11 @@ namespace self_ns                                       \
 BOOST_PYTHON_BINARY_OPERATOR(add, radd, +)
 BOOST_PYTHON_BINARY_OPERATOR(sub, rsub, -)
 BOOST_PYTHON_BINARY_OPERATOR(mul, rmul, *)
-BOOST_PYTHON_BINARY_OPERATOR(div, rdiv, /)
+#if PY_VERSION_HEX >= 0x03000000
+    BOOST_PYTHON_BINARY_OPERATOR(truediv, rtruediv, /)
+#else
+    BOOST_PYTHON_BINARY_OPERATOR(div, rdiv, /)
+#endif
 BOOST_PYTHON_BINARY_OPERATOR(mod, rmod, %)
 BOOST_PYTHON_BINARY_OPERATOR(lshift, rlshift, <<)
 BOOST_PYTHON_BINARY_OPERATOR(rshift, rrshift, >>)

include/boost/python/override.hpp

@@ -77,7 +77,7 @@ namespace detail
       template <class T>
       T unchecked(type<T>* = 0)
       {
-          return extract<T>(m_obj)();
+          return extract<T>(m_obj.get())();
       }
    private:
       mutable handle<> m_obj;

src/converter/builtin_converters.cpp

@@ -366,7 +366,9 @@ namespace
       static PyTypeObject const* get_pytype() { return &PyFloat_Type;}
   };
 
+#if PY_VERSION_HEX >= 0x03000000
   unaryfunc py_unicode_as_string_unaryfunc = PyUnicode_AsUTF8String;
+#endif
 
   // A SlotPolicy for extracting C++ strings from Python objects.
   struct string_rvalue_from_python
@@ -431,7 +433,10 @@ namespace
           if (!result.empty())
           {
               int err = PyUnicode_AsWideChar(
-                  (PyUnicodeObject *)intermediate
+#if PY_VERSION_HEX < 0x03020000
+                  (PyUnicodeObject *)
+#endif
+                    intermediate
                 , &result[0]
                 , result.size());
 

src/converter/from_python.cpp

@@ -44,11 +44,8 @@ BOOST_PYTHON_DECL rvalue_from_python_stage1_data rvalue_from_python_stage1(
     // First check to see if it's embedded in an extension class
     // instance, as a special case.
     data.convertible = objects::find_instance_impl(source, converters.target_type, converters.is_shared_ptr);
-    if (data.convertible)
-    {
         data.construct = 0;
-    }
-    else
+    if (!data.convertible)
     {
         for (rvalue_from_python_chain const* chain = converters.rvalue_chain;
              chain != 0;

src/module.cpp

@@ -11,6 +11,23 @@
 
 namespace boost { namespace python { namespace detail {
 
+namespace
+{
+    PyObject* init_module_in_scope(PyObject* m, void(*init_function)())
+    {
+        if (m != 0)
+        {
+            // Create the current module scope
+            object m_obj(((borrowed_reference_t*)m));
+            scope current_module(m_obj);
+
+            handle_exception(init_function);
+        }
+
+        return m;
+    }
+}
+
 BOOST_PYTHON_DECL void scope_setattr_doc(char const* name, object const& x, char const* doc)
 {
     // Use function::add_to_namespace to achieve overloading if
@@ -19,42 +36,31 @@ BOOST_PYTHON_DECL void scope_setattr_doc(char const* name, object const& x, char
     objects::add_to_namespace(current, name, x, doc);
 }
 
+#if PY_VERSION_HEX >= 0x03000000
+
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef& moduledef, void(*init_function)())
+{
+    return init_module_in_scope(
+        PyModule_Create(&moduledef),
+        init_function);
+}
+
+#else
+
 namespace
 {
-  PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } };
+    PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } };
 }
 
 BOOST_PYTHON_DECL PyObject* 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)
-    {
-        // Create the current module scope
-        object m_obj(((borrowed_reference_t*)m));
-        scope current_module(m_obj);
-        
-        handle_exception(init_function);
-    }
-    return m;
+    return init_module_in_scope(
+        Py_InitModule(const_cast<char*>(name), initial_methods),
+        init_function);
 }
 
+#endif
+
 }}} // namespace boost::python::detail
 
 namespace boost { namespace python {

src/object/class.cpp

@@ -76,11 +76,11 @@ extern "C"
   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};
+      static const char *kwlist[] = {"fget", "fset", "fdel", "doc", 0};
       propertyobject *prop = (propertyobject *)self;
 
       if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOOO:property",
-                  kwlist, &get, &set, &del, &doc))
+                  const_cast<char **>(kwlist), &get, &set, &del, &doc))
           return -1;
 
       if (get == Py_None)
@@ -303,7 +303,7 @@ static PyTypeObject class_metatype_object = {
 // object.
 void instance_holder::install(PyObject* self) throw()
 {
-    assert(Py_TYPE(Py_TYPE(self)) == &class_metatype_object);
+    assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self)), &class_metatype_object));
     m_next = ((objects::instance<>*)self)->objects;
     ((objects::instance<>*)self)->objects = this;
 }
@@ -482,7 +482,8 @@ 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 (!Py_TYPE(Py_TYPE(inst)) ||
+              !PyType_IsSubtype(Py_TYPE(Py_TYPE(inst)), &class_metatype_object))
           return 0;
     
       instance<>* self = reinterpret_cast<instance<>*>(inst);
@@ -727,7 +728,7 @@ 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(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
     objects::instance<>* self = (objects::instance<>*)self_;
     
     int total_size_needed = holder_offset + holder_size;
@@ -752,7 +753,7 @@ 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(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
     objects::instance<>* self = (objects::instance<>*)self_;
     if (storage != (char*)self + Py_SIZE(self))
     {

src/object/function.cpp

@@ -670,11 +670,26 @@ extern "C"
     {
         return python::incref(upcast<PyObject>(&PyCFunction_Type));
     }
+
+    static PyObject* function_get_module(PyObject* op, void*)
+    {
+        function* f = downcast<function>(op);
+        object const& ns = f->get_namespace();
+        if (!ns.is_none()) {
+            return python::incref(ns.ptr());
+        }
+        PyErr_SetString(
+            PyExc_AttributeError, const_cast<char*>(
+                "Boost.Python function __module__ unknown."));
+        return 0;
+    }
 }
 
 static PyGetSetDef function_getsetlist[] = {
     {const_cast<char*>("__name__"), (getter)function_get_name, 0, 0, 0 },
     {const_cast<char*>("func_name"), (getter)function_get_name, 0, 0, 0 },
+    {const_cast<char*>("__module__"), (getter)function_get_module, 0, 0, 0 },
+    {const_cast<char*>("func_module"), (getter)function_get_module, 0, 0, 0 },
     {const_cast<char*>("__class__"), (getter)function_get_class, 0, 0, 0 },    // see note above
     {const_cast<char*>("__doc__"), (getter)function_get_doc, (setter)function_set_doc, 0, 0},
     {const_cast<char*>("func_doc"), (getter)function_get_doc, (setter)function_set_doc, 0, 0},

test/Jamfile.v2

@@ -3,11 +3,15 @@
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 import python ;
+import os ;
+
+lib socket ;
 
 use-project /boost/python : ../build ;
 project /boost/python/test 
   : requirements
     <toolset>gcc:<cxxflags>-Wextra
+    <target-os>qnxnto:<library>socket
   ;
 
 local PY = ;
@@ -117,6 +121,7 @@ bpl-test crossmod_exception
  [ bpl-test defaults ]
 
 [ bpl-test object ]
+[ bpl-test class ]
 [ bpl-test list ]
 [ bpl-test long ]
 [ bpl-test dict ]

test/class.cpp

@@ -0,0 +1,28 @@
+// 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)
+#include <boost/python/module.hpp>
+#include <boost/python/def.hpp>
+#include <boost/python/object.hpp>
+#include <boost/python/class.hpp>
+
+using namespace boost::python;
+
+struct X
+{
+    int x;
+    X(int n) : x(n) { }
+};
+
+int x_function(X& x)
+{   return x.x;
+}
+
+
+BOOST_PYTHON_MODULE(class_ext)
+{
+    class_<X>("X", init<int>());
+    def("x_function", x_function);
+}
+
+#include "module_tail.cpp"

test/class.py

@@ -0,0 +1,40 @@
+# 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)
+'''
+>>> from class_ext import *
+
+Ensure sanity:
+
+    >>> x = X(42)
+    >>> x_function(x)
+    42
+
+Demonstrate extraction in the presence of metaclass changes:
+
+    >>> class MetaX(X.__class__):
+    ...     def __new__(cls, *args):
+    ...         return super(MetaX, cls).__new__(cls, *args)
+    >>> class XPlusMetatype(X):
+    ...     __metaclass__ = MetaX
+    >>> x = XPlusMetatype(42)
+    >>> x_function(x)
+    42
+
+
+'''
+
+def run(args = None):
+    import sys
+    import doctest
+
+    if args is not None:
+        sys.argv = args
+    return doctest.testmod(sys.modules.get(__name__))
+
+if __name__ == '__main__':
+    print "running..."
+    import sys
+    status = run()[0]
+    if (status == 0): print "Done."
+    sys.exit(status)