Bug fix for NULL pointers with return_internal_reference<>.

dabrahams · dabrahams · commit 3c5df281019e · 2002-08-19T15:19:08.000Z
[SVN r14952]
diff --git a/doc/v2/with_custodian_and_ward.html b/doc/v2/with_custodian_and_ward.html
@@ -66,10 +66,12 @@ <h2><a name="introduction">Introduction</a></h2>
     the custodian as long as the <i>custodian</i> object supports <a
     href="http://www.python.org/doc/current/lib/module-weakref.html">weak
     references</a> (Boost.Python extension classes all support weak
-    references). The two class templates
+    references). If the <i>custodian</i> object does not support weak
+    references and is not <code>None</code>, an appropriate exception
+    will be thrown. The two class templates
     <code>with_custodian_and_ward</code> and
     <code>with_custodian_and_ward_postcall</code> differ in the point
-    at which they take effect. 
+    at which they take effect.
 
     <p>In order to reduce the chance of inadvertently
     creating dangling pointers, the default is to do lifetime binding
diff --git a/src/object/life_support.cpp b/src/object/life_support.cpp
@@ -5,6 +5,7 @@
 // to its suitability for any purpose.
 #include <boost/python/object/life_support.hpp>
 #include <boost/python/detail/none.hpp>
+#include <boost/python/refcount.hpp>
 
 namespace boost { namespace python { namespace objects { 
 
@@ -80,9 +81,17 @@ PyTypeObject life_support_type = {
 
 PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient)
 {
+    if (nurse == Py_None)
+        return incref(nurse);
+    
+    if ((life_support_type.tp_flags & Py_TPFLAGS_READY) == 0)
+        PyType_Ready(&life_support_type);
+    
     life_support* system = PyObject_New(life_support, &life_support_type);
     if (!system)
         return 0;
+
+    system->patient = 0;
     
     // We're going to leak this reference, but don't worry; the
     // life_support system decrements it when the nurse dies.
diff --git a/test/test_pointer_adoption.cpp b/test/test_pointer_adoption.cpp
@@ -29,7 +29,12 @@ struct inner
     std::string s;
 };
 
-struct A
+struct Base
+{
+    virtual ~Base() {}
+};
+
+struct A : Base
 {
     A(std::string const& s)
         : x(s)
@@ -76,40 +81,47 @@ A* create(std::string const& s)
     return new A(s);
 }
 
+A* as_A(Base* b)
+{
+    return dynamic_cast<A*>(b);
+}
+
 BOOST_PYTHON_MODULE_INIT(test_pointer_adoption_ext)
 {
-    boost::python::module("test_pointer_adoption_ext")
-        .def("num_a_instances", num_a_instances)
+    boost::python::module m("test_pointer_adoption_ext");
+        m.def("num_a_instances", num_a_instances)
 
         // Specify the manage_new_object return policy to take
         // ownership of create's result
         .def("create", create, return_value_policy<manage_new_object>())
-        
-        .add(
-            
-            class_<A>(no_init)
-            .def("content", &A::content)
-            .def("get_inner", &A::get_inner, return_internal_reference<>())
-            )
 
+        .def("as_A", as_A, return_internal_reference<>())
         .add(
-            class_<inner>(no_init)
-            .def("change", &inner::change)
-            )
+
+    class_<Base>("Base")
+            );
         
-        .add(
-            class_<B>("B")
-            .def_init(args<A*>(), with_custodian_and_ward_postcall<1,2>())
-            
-            .def("adopt", &B::adopt
-                 // Adopt returns a pointer referring to a subobject of its 2nd argument (1st being "self")
-                 , return_internal_reference<2
-                      // Meanwhile, self holds a reference to the 2nd argument.
-                      , with_custodian_and_ward<1,2> >()
-                )
+    m.add(class_<A, bases<Base> >(no_init)
+        .def("content", &A::content)
+        .def("get_inner", &A::get_inner, return_internal_reference<>())
+        )
+    
+    .add(class_<inner>(no_init)
+        .def("change", &inner::change)
+        )
+        
+    .add(class_<B>("B")
+        .def_init(args<A*>(), with_custodian_and_ward_postcall<1,2>())
             
-            .def("a_content", &B::a_content)
+        .def("adopt", &B::adopt
+             // Adopt returns a pointer referring to a subobject of its 2nd argument (1st being "self")
+             , return_internal_reference<2
+             // Meanwhile, self holds a reference to the 2nd argument.
+             , with_custodian_and_ward<1,2> >()
             )
+            
+         .def("a_content", &B::a_content))
         ;
 }
 
+#include "module_tail.cpp"
diff --git a/test/test_pointer_adoption.py b/test/test_pointer_adoption.py
@@ -70,6 +70,11 @@
 >>> num_a_instances()
 0
 
+>>> as_A(create('dynalloc')) is None
+0
+>>> base = Base()
+>>> as_A(base) is None
+1
 """
 def run(args = None):
     import sys
