Merge pull request #126 from swig-fortran/fix-null-sp

Fix inconsistencies with null shared pointers

Author: sethrj

Examples/test-suite/fortran/fortran_ownership_runme.F90

@@ -56,6 +56,11 @@ subroutine test_standard
   ASSERT(.not. btest(b%swigdata%cmemflags, swig_cmem_rvalue_bit))
   ASSERT(foo_counter == 3)
 
+  ! Return null
+  call b%release()
+  b = get_null()
+  ASSERT(.not. c_associated(b%swigdata%cptr))
+
   ! Capture from function
   b = make_foo(6)
   ASSERT(btest(b%swigdata%cmemflags, swig_cmem_own_bit))

Examples/test-suite/fortran/li_boost_shared_ptr_runme.F90

@@ -8,7 +8,6 @@ program li_boost_shared_ptr_runme
   implicit none
   type(Klass) :: f1, f2
   integer(c_int) :: orig_total_count
-  integer(c_int) :: memory_leak
 
   !call set_debug_shared(.true.)
 
@@ -40,6 +39,17 @@ program li_boost_shared_ptr_runme
   call f1%release() ! Clear the raw pointer (does not deallocate)
   ASSERT(use_count(f1) == 0)
 
+  ! Test null pointers
+  f1 = sp_pointer_null()
+  ASSERT(nullsmartpointerpointertest(f1) == "null pointer")
+  call f1%release()
+  f1 = null_sp_pointer()
+  ASSERT(nullsmartpointerpointertest(f1) == "null pointer")
+  call f1%release()
+  f1 = sp_value_null()
+  ASSERT(nullsmartpointerpointertest(f1) == "null pointer")
+  call f1%release()
+
   ! Copy-construct the underlying object
   f1 = Klass(f2)
   ASSERT(use_count(f1) == 1)
@@ -52,12 +62,7 @@ program li_boost_shared_ptr_runme
 
   call f2%release() ! Further calls to release() are allowable null-ops
 
-  ! Create a temporary shared pointer that's passed into a function
-  ! THIS LEAKS MEMORY!
-  ASSERT(use_count(Klass()) == 1)
-  memory_leak = 1
-
   ! The getTotal_count function is static, so 'f2' doesn't have to be allocated
-  ASSERT(f2%getTotal_count() == orig_total_count + memory_leak)
+  ASSERT(f2%getTotal_count() == orig_total_count)
 end program
 

Examples/test-suite/fortran_ownership.i

@@ -43,6 +43,7 @@ Foo& reference(Foo& other) { return other; }
 const Foo& const_reference(const Foo& other) { return other; }
 Foo make_foo(int val) { return Foo(val); }
 Foo make_foo_subroutine(int val) { return Foo(val); }
+Foo* get_null() { return NULL; }
 
 int get_value(const Foo& other) { return other.val; }
 int get_value_copy(Foo other) { return other.val; }

Examples/test-suite/li_boost_shared_ptr.i

@@ -242,6 +242,10 @@ std::string nullsmartpointerpointertest(SwigBoost::shared_ptr<Klass>* k) {
   else
     return "also not null";
 }
+
+SwigBoost::shared_ptr<Klass>* sp_pointer_null() { return NULL; }
+SwigBoost::shared_ptr<Klass>* null_sp_pointer() { static SwigBoost::shared_ptr<Klass> static_sp; return &static_sp; }
+SwigBoost::shared_ptr<Klass> sp_value_null() { return SwigBoost::shared_ptr<Klass>(); }
 // $owner
 Klass *pointerownertest() {
   return new Klass("pointerownertest");

Lib/fortran/boost_shared_ptr.i

@@ -62,8 +62,8 @@
  * SP-owned copy of the obtained value.
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1, fragment="SWIG_check_sp_nonnull") CONST TYPE ($&1_type argp = 0) {
-  SWIG_check_sp_nonnull($input, "$1_ltype", "$fclassname", "$decl", return $null)
-  argp = $input->cptr ? %static_cast($input->cptr, SWIGSP__*)->get() : NULL;
+  SWIG_check_sp_nonnull($input->cptr, "$1_ltype", "$fclassname", "$decl", return $null)
+  argp = static_cast<SWIGSP__*>($input->cptr)->get();
   $1 = *argp;
 }
 %typemap(out, noblock=1) CONST TYPE {
@@ -76,10 +76,16 @@
  * cmemflags, but the result is always a new self-owned shared pointer.
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1) CONST TYPE * (SWIGSP__* smartarg) {
-  smartarg = %static_cast($input->cptr, SWIGSP__*);
-  $1 = smartarg ? %const_cast(smartarg->get(), TYPE*) : NULL;
+  smartarg = (SWIGSP__*)($input->cptr);
+  $1 = smartarg ? (TYPE*)(smartarg->get()) : NULL;
 }
 
+// Replace call to "delete (Foo*) arg1;" with call to delete the *shared
+// pointer*: decrement the reference count instead of forcing the object to
+// be destroyed and causing a double-delete.
+%feature("unref") TYPE
+%{ (void)$self; delete smart$self; %}
+
 // The string "SWIG_NO_NULL_DELETER_$owner" is replaced by the macro
 // SWIG_NO_NULL_DELETER_1 if a raw pointer is being emitted via %newobject
 //   (for a shared pointer this macro is empty);
@@ -93,14 +99,15 @@
 }
 
 /* -------------------------------------------------------------------------
- * Original class by reference. Same as by pointer, but with null checks.
+ * Original class by reference. Add null checks.
  * ------------------------------------------------------------------------- */
-%typemap(in, noblock=1, fragment="SWIG_check_sp_nonnull") CONST TYPE& (SWIGSP__* smartarg) {
-  SWIG_check_sp_nonnull($input, "$1_ltype", "$fclassname", "$decl", return $null)
-  smartarg = %static_cast($input->cptr, SWIGSP__*);
-  $1 = %const_cast(smartarg->get(), TYPE*);
+%typemap(in, noblock=1, fragment="SWIG_check_sp_nonnull") CONST TYPE & {
+  SWIG_check_sp_nonnull($input->cptr, "$1_ltype", "$fclassname", "$decl", return $null)
+  $1 = (TYPE*)static_cast<SWIGSP__*>($input->cptr)->get();
 }
 
+%typemap(in) CONST TYPE &ASSIGNMENT_OTHER = SWIGTYPE *ASSIGNMENT_SELF;
+
 // Output value is never null. Because we're allocating a shared pointer, we set the memory ownership to MOVE so that the *SP*
 // will be properly deallocated. But we also must use a null deleter so that when the SP is deleted the corresponding memory
 // will not be.
@@ -113,35 +120,35 @@
  * SP by value
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr<CONST TYPE > {
-  if ($input->cptr) $1 = *%static_cast($input->cptr, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr<CONST TYPE >*);
+  if ($input->cptr) $1 = *static_cast<SWIG_SHARED_PTR_QNAMESPACE::shared_ptr<CONST TYPE >*>($input->cptr);
 }
 
 %typemap(out, noblock=1) SWIGSP__ {
-  $result.cptr = %new_copy($1, SWIGSP__);
+  $result.cptr = SWIG_SHARED_PTR_NOT_NULL($1) ? %new_copy($1, SWIGSP__) : NULL;
   $result.cmemflags = SWIG_MEM_OWN | SWIG_MEM_RVALUE;
 }
 
 /* -------------------------------------------------------------------------
  * SP by reference
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1) SWIGSP__& ($*1_ltype tempnull) {
-  $1 = $input->cptr ? %static_cast($input->cptr, $1_ltype) : &tempnull;
+  $1 = $input->cptr ? static_cast<$1_ltype >($input->cptr) : &tempnull;
 }
 
 %typemap(out, noblock=1) SWIGSP__& {
-  $result.cptr = SWIG_SHARED_PTR_NOT_NULL(*$1) ? %new_copy(*$1, SWIGSP__) : 0;
+  $result.cptr = SWIG_SHARED_PTR_NOT_NULL(*$1) ? %new_copy(*$1, SWIGSP__) : NULL;
   $result.cmemflags = SWIG_MEM_OWN | SWIG_MEM_RVALUE;
 }
 
 /* -------------------------------------------------------------------------
  * SP by pointer
  * ------------------------------------------------------------------------- */
 %typemap(in, noblock=1) SWIGSP__ * ($*1_ltype tempnull) {
-  $1 = $input->cptr ? %static_cast($input->cptr, $1_ltype) : &tempnull;
+  $1 = $input->cptr ? static_cast<$1_ltype >($input->cptr) : &tempnull;
 }
 
 %typemap(out, noblock=1, fragment="SWIG_null_deleter") SWIGSP__ * {
-  $result.cptr = ($1 && SWIG_SHARED_PTR_NOT_NULL(*$1)) ? %new_copy(*$1, SWIGSP__) : 0;
+  $result.cptr = ($1 && SWIG_SHARED_PTR_NOT_NULL(*$1)) ? %new_copy(*$1, SWIGSP__) : NULL;
   $result.cmemflags = SWIG_MEM_OWN | SWIG_MEM_RVALUE;
 }
 
@@ -158,15 +165,6 @@
 #error "typemaps for $1_type not available"
 %}
 
-/* -------------------------------------------------------------------------
- * Replace call to "delete (Foo*) arg1;" with call to delete the *shared
- * pointer* (so decrement the reference count instead of forcing the object to
- * be destroyed and causing a double-delete)
- */
-
-%feature("unref") TYPE
-%{ (void)$self; delete smart$self; %}
-
 /* -------------------------------------------------------------------------
  * Instantiate shared pointer
  */