nmatrix 0.1.0.rc4 → 0.1.0.rc5

data/ext/nmatrix/storage/dense/dense.cpp

@@ -123,8 +123,8 @@ namespace nm { namespace dense_storage {
    */
   template <typename D>
   void set(VALUE left, SLICE* slice, VALUE right) {
-    NM_CONSERVATIVE(nm_register_value(left));
-    NM_CONSERVATIVE(nm_register_value(right));
+    NM_CONSERVATIVE(nm_register_value(&left));
+    NM_CONSERVATIVE(nm_register_value(&right));
 
     DENSE_STORAGE* s = NM_STORAGE_DENSE(left);
 
@@ -174,8 +174,8 @@ namespace nm { namespace dense_storage {
         nm_unregister_values(reinterpret_cast<VALUE*>(v), v_size);
       NM_FREE(v);
     }
-    NM_CONSERVATIVE(nm_unregister_value(left));
-    NM_CONSERVATIVE(nm_unregister_value(right));
+    NM_CONSERVATIVE(nm_unregister_value(&left));
+    NM_CONSERVATIVE(nm_unregister_value(&right));
 
   }
 
@@ -361,12 +361,12 @@ void nm_dense_storage_unregister(const STORAGE* s) {
  */
 VALUE nm_dense_map_pair(VALUE self, VALUE right) {
 
-  NM_CONSERVATIVE(nm_register_value(self));
-  NM_CONSERVATIVE(nm_register_value(right));
+  NM_CONSERVATIVE(nm_register_value(&self));
+  NM_CONSERVATIVE(nm_register_value(&right));
 
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(right));
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_enumerator_length);
 
   DENSE_STORAGE *s = NM_STORAGE_DENSE(self),
@@ -391,10 +391,10 @@ VALUE nm_dense_map_pair(VALUE self, VALUE right) {
            t_index = nm_dense_storage_pos(t, coords);
 
     VALUE sval = NM_DTYPE(self) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(s->elements)[s_index] : rubyobj_from_cval((char*)(s->elements) + s_index*DTYPE_SIZES[NM_DTYPE(self)], NM_DTYPE(self)).rval;
-    nm_register_value(sval);
+    nm_register_value(&sval);
     VALUE tval = NM_DTYPE(right) == nm::RUBYOBJ ? reinterpret_cast<VALUE*>(t->elements)[t_index] : rubyobj_from_cval((char*)(t->elements) + t_index*DTYPE_SIZES[NM_DTYPE(right)], NM_DTYPE(right)).rval;
     result_elem[k] = rb_yield_values(2, sval, tval);
-    nm_unregister_value(sval);
+    nm_unregister_value(&sval);
   }
 
   VALUE klass = CLASS_OF(self);
@@ -404,8 +404,8 @@ VALUE nm_dense_map_pair(VALUE self, VALUE right) {
 
   nm_unregister_nmatrix(m);
   nm_dense_storage_unregister(result);
-  NM_CONSERVATIVE(nm_unregister_value(self));
-  NM_CONSERVATIVE(nm_unregister_value(right));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
 
   return to_return;
 
@@ -416,10 +416,10 @@ VALUE nm_dense_map_pair(VALUE self, VALUE right) {
  */
 VALUE nm_dense_map(VALUE self) {
 
-  NM_CONSERVATIVE(nm_register_value(self));
+  NM_CONSERVATIVE(nm_register_value(&self));
 
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
   RETURN_SIZED_ENUMERATOR(self, 0, 0, nm_enumerator_length);
 
   DENSE_STORAGE *s = NM_STORAGE_DENSE(self);
@@ -454,7 +454,7 @@ VALUE nm_dense_map(VALUE self) {
 
   nm_unregister_nmatrix(m);
   nm_dense_storage_unregister(result);
-  NM_CONSERVATIVE(nm_unregister_value(self));
+  NM_CONSERVATIVE(nm_unregister_value(&self));
 
   return to_return;
 }
@@ -465,10 +465,10 @@ VALUE nm_dense_map(VALUE self) {
  */
 VALUE nm_dense_each_with_indices(VALUE nmatrix) {
 
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
   
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, nm_enumerator_length); // fourth argument only used by Ruby2+
   DENSE_STORAGE* s = NM_STORAGE_DENSE(nmatrix);
 
@@ -486,7 +486,7 @@ VALUE nm_dense_each_with_indices(VALUE nmatrix) {
     nm_dense_storage_coords(sliced_dummy, k, coords);
     slice_index = nm_dense_storage_pos(s, coords);
     VALUE ary = rb_ary_new();
-    nm_register_value(ary);
+    nm_register_value(&ary);
     if (NM_DTYPE(nmatrix) == nm::RUBYOBJ) rb_ary_push(ary, reinterpret_cast<VALUE*>(s->elements)[slice_index]);
     else rb_ary_push(ary, rubyobj_from_cval((char*)(s->elements) + slice_index*DTYPE_SIZES[NM_DTYPE(nmatrix)], NM_DTYPE(nmatrix)).rval);
 
@@ -496,12 +496,12 @@ VALUE nm_dense_each_with_indices(VALUE nmatrix) {
 
     // yield the array which now consists of the value and the indices
     rb_yield(ary);
-    nm_unregister_value(ary);
+    nm_unregister_value(&ary);
   }
 
   nm_dense_storage_delete(sliced_dummy);
 
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
 
   return nmatrix;
 
@@ -517,10 +517,10 @@ VALUE nm_dense_each_with_indices(VALUE nmatrix) {
  */
 VALUE nm_dense_each(VALUE nmatrix) {
 
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
 
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, nm_enumerator_length);
 
   DENSE_STORAGE* s = NM_STORAGE_DENSE(nmatrix);
@@ -553,7 +553,7 @@ VALUE nm_dense_each(VALUE nmatrix) {
   }
 
   nm_dense_storage_delete(sliced_dummy);
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
 
   return nmatrix;
 
@@ -874,26 +874,26 @@ namespace nm {
  * Otherwise, the NMATRIX* still belongs to Ruby and Ruby will free it.
  */
 std::pair<NMATRIX*,bool> interpret_arg_as_dense_nmatrix(VALUE right, nm::dtype_t dtype) {
-  NM_CONSERVATIVE(nm_register_value(right));
+  NM_CONSERVATIVE(nm_register_value(&right));
   if (TYPE(right) == T_DATA && (RDATA(right)->dfree == (RUBY_DATA_FUNC)nm_delete || RDATA(right)->dfree == (RUBY_DATA_FUNC)nm_delete_ref)) {
     NMATRIX *r;
     if (NM_STYPE(right) != DENSE_STORE || NM_DTYPE(right) != dtype || NM_SRC(right) != NM_STORAGE(right)) {
       UnwrapNMatrix( right, r );
       NMATRIX* ldtype_r = nm_cast_with_ctype_args(r, nm::DENSE_STORE, dtype, NULL);
-      NM_CONSERVATIVE(nm_unregister_value(right));
+      NM_CONSERVATIVE(nm_unregister_value(&right));
       return std::make_pair(ldtype_r,true);
     } else {  // simple case -- right-hand matrix is dense and is not a reference and has same dtype
       UnwrapNMatrix( right, r );
-      NM_CONSERVATIVE(nm_unregister_value(right));
+      NM_CONSERVATIVE(nm_unregister_value(&right));
       return std::make_pair(r, false);
     }
     // Do not set v_alloc = true for either of these. It is the responsibility of r/ldtype_r
   } else if (TYPE(right) == T_DATA) {
-    NM_CONSERVATIVE(nm_unregister_value(right));
+    NM_CONSERVATIVE(nm_unregister_value(&right));
     rb_raise(rb_eTypeError, "unrecognized type for slice assignment");
   }
 
-  NM_CONSERVATIVE(nm_unregister_value(right));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
   return std::make_pair<NMATRIX*,bool>(NULL, false);
 }
 

data/ext/nmatrix/storage/list/list.cpp

@@ -87,11 +87,11 @@ public:
     if (init_obj_ == Qnil) {
       init_obj_ = s->dtype == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s->default_val) : rubyobj_from_cval(s->default_val, s->dtype).rval;
     }
-    nm_register_value(init_obj_);
+    nm_register_value(&init_obj_);
   }
 
   ~RecurseData() {
-    nm_unregister_value(init_obj_);
+    nm_unregister_value(&init_obj_);
     nm_list_storage_unregister(ref);
     nm_list_storage_unregister(actual);
   }
@@ -198,14 +198,14 @@ static void map_empty_stored_r(RecurseData& result, RecurseData& s, LIST* x, con
       if (rev) val = rb_yield_values(2, t_init, s_val);
       else     val = rb_yield_values(2, s_val, t_init);
 
-      nm_register_value(val);
+      nm_register_value(&val);
 
       if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue) {
         xcurr = nm::list::insert_helper(x, xcurr, curr->key - offset, val);
         temp_vals.push_front(reinterpret_cast<VALUE*>(xcurr->val));
-        nm_register_value(*reinterpret_cast<VALUE*>(xcurr->val));
+        nm_register_value(&*reinterpret_cast<VALUE*>(xcurr->val));
       }
-      nm_unregister_value(val);
+      nm_unregister_value(&val);
 
       curr = curr->next;
       if (curr && curr->key - offset >= x_shape) curr = NULL;
@@ -272,7 +272,7 @@ static void map_stored_r(RecurseData& result, RecurseData& left, LIST* x, const
       if (!rb_equal(val, result.init_obj())) {
         xcurr = nm::list::insert_helper(x, xcurr, key, val);
         temp_vals.push_front(reinterpret_cast<VALUE*>(xcurr->val));
-        nm_register_value(*reinterpret_cast<VALUE*>(xcurr->val));
+        nm_register_value(&*reinterpret_cast<VALUE*>(xcurr->val));
       }
 
       if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
@@ -369,15 +369,15 @@ static void map_merged_stored_r(RecurseData& result, RecurseData& left, RecurseD
         rcurr = rcurr->next;
       }
 
-      nm_register_value(val);
+      nm_register_value(&val);
 
       if (rb_funcall(val, rb_intern("!="), 1, result.init_obj()) == Qtrue) {
         xcurr = nm::list::insert_helper(x, xcurr, key, val);
         temp_vals.push_front(reinterpret_cast<VALUE*>(xcurr->val));
-        nm_register_value(*reinterpret_cast<VALUE*>(xcurr->val));
+        nm_register_value(&*reinterpret_cast<VALUE*>(xcurr->val));
       }
 
-      nm_unregister_value(val);
+      nm_unregister_value(&val);
 
       if (rcurr && rcurr->key - right.offset(rec) >= result.ref_shape(rec)) rcurr = NULL;
       if (lcurr && lcurr->key - left.offset(rec) >= result.ref_shape(rec)) lcurr = NULL;
@@ -495,7 +495,7 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
         } else if (node->key > key) {
           D* nv = NM_ALLOC(D); *nv = v[v_offset++];
           if (dest->dtype == nm::RUBYOBJ) {
-            nm_register_value(*reinterpret_cast<VALUE*>(nv));
+            nm_register_value(&*reinterpret_cast<VALUE*>(nv));
             temp_vals.push_front(reinterpret_cast<VALUE*>(nv));
           }
 
@@ -508,7 +508,7 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
       } else { // no node -- insert a new one
         D* nv = NM_ALLOC(D); *nv = v[v_offset++];
         if (dest->dtype == nm::RUBYOBJ) {
-          nm_register_value(*reinterpret_cast<VALUE*>(nv));
+          nm_register_value(&*reinterpret_cast<VALUE*>(nv));
           temp_vals.push_front(reinterpret_cast<VALUE*>(nv));
         }
         if (prev) node = insert_after(prev, key, nv);
@@ -535,8 +535,8 @@ static bool slice_set(LIST_STORAGE* dest, LIST* l, size_t* coords, size_t* lengt
 
 template <typename D>
 void set(VALUE left, SLICE* slice, VALUE right) {
-  NM_CONSERVATIVE(nm_register_value(left));
-  NM_CONSERVATIVE(nm_register_value(right));
+  NM_CONSERVATIVE(nm_register_value(&left));
+  NM_CONSERVATIVE(nm_register_value(&right));
   LIST_STORAGE* s = NM_STORAGE_LIST(left);
 
   std::pair<NMATRIX*,bool> nm_and_free =
@@ -590,8 +590,8 @@ void set(VALUE left, SLICE* slice, VALUE right) {
     NM_FREE(v);
     nm_unregister_nmatrix(nm_and_free.first);
   }
-  NM_CONSERVATIVE(nm_unregister_value(left));
-  NM_CONSERVATIVE(nm_unregister_value(right));
+  NM_CONSERVATIVE(nm_unregister_value(&left));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
 }
 
 /*
@@ -693,7 +693,7 @@ void nm_list_storage_mark(STORAGE* storage_base) {
 
 static void __nm_list_storage_unregister_temp_value_list(std::list<VALUE*>& temp_vals) {
   for (std::list<VALUE*>::iterator it = temp_vals.begin(); it != temp_vals.end(); ++it) {
-    nm_unregister_value(**it);
+    nm_unregister_value(&**it);
   }
 }
 
@@ -704,11 +704,11 @@ static void __nm_list_storage_unregister_temp_list_list(std::list<LIST*>& temp_v
 }
 
 void nm_list_storage_register_node(const NODE* curr) {
-  nm_register_value(*reinterpret_cast<VALUE*>(curr->val));
+  nm_register_value(&*reinterpret_cast<VALUE*>(curr->val));
 }
 
 void nm_list_storage_unregister_node(const NODE* curr) {
-  nm_unregister_value(*reinterpret_cast<VALUE*>(curr->val));
+  nm_unregister_value(&*reinterpret_cast<VALUE*>(curr->val));
 }
 
 /**
@@ -719,7 +719,7 @@ void nm_list_storage_unregister_node(const NODE* curr) {
  * node so that this won't happen.
  */
 void nm_list_storage_completely_unregister_node(const NODE* curr) {
-  nm_completely_unregister_value(*reinterpret_cast<VALUE*>(curr->val));
+  nm_completely_unregister_value(&*reinterpret_cast<VALUE*>(curr->val));
 }
 
 void nm_list_storage_register_list(const LIST* list, size_t recursions) {
@@ -757,7 +757,7 @@ void nm_list_storage_unregister_list(const LIST* list, size_t recursions) {
 void nm_list_storage_register(const STORAGE* s) {
   const LIST_STORAGE* storage = reinterpret_cast<const LIST_STORAGE*>(s);
   if (storage && storage->dtype == nm::RUBYOBJ) {
-    nm_register_value(*reinterpret_cast<VALUE*>(storage->default_val));
+    nm_register_value(&*reinterpret_cast<VALUE*>(storage->default_val));
     nm_list_storage_register_list(storage->rows, storage->dim - 1);
   }
 }
@@ -765,7 +765,7 @@ void nm_list_storage_register(const STORAGE* s) {
 void nm_list_storage_unregister(const STORAGE* s) {
   const LIST_STORAGE* storage = reinterpret_cast<const LIST_STORAGE*>(s);
   if (storage && storage->dtype == nm::RUBYOBJ) {
-    nm_unregister_value(*reinterpret_cast<VALUE*>(storage->default_val));
+    nm_unregister_value(&*reinterpret_cast<VALUE*>(storage->default_val));
     nm_list_storage_unregister_list(storage->rows, storage->dim - 1);
   }
 }
@@ -798,7 +798,7 @@ static NODE* list_storage_get_single_node(LIST_STORAGE* s, SLICE* slice) {
  */
 static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t rec, VALUE& stack) {
   VALUE empty  = s.dtype() == nm::RUBYOBJ ? *reinterpret_cast<VALUE*>(s.init()) : s.init_obj();
-  NM_CONSERVATIVE(nm_register_value(stack));
+  NM_CONSERVATIVE(nm_register_value(&stack));
 
   if (rec) {
     for (unsigned long index = 0; index < s.ref_shape(rec); ++index) {
@@ -816,7 +816,7 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
     }
     rb_ary_shift(stack);
   }
-  NM_CONSERVATIVE(nm_unregister_value(stack));
+  NM_CONSERVATIVE(nm_unregister_value(&stack));
 }
 
 /*
@@ -825,7 +825,7 @@ static void each_empty_with_indices_r(nm::list_storage::RecurseData& s, size_t r
 static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l, size_t rec, VALUE& stack) {
   if (s.dtype() == nm::RUBYOBJ)
     nm_list_storage_register_list(l, rec);
-  NM_CONSERVATIVE(nm_register_value(stack));
+  NM_CONSERVATIVE(nm_register_value(&stack));
   NODE*  curr  = l->first;
 
   size_t offset = s.offset(rec);
@@ -865,7 +865,7 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
       rb_ary_pop(stack);
     }
   }
-  NM_CONSERVATIVE(nm_unregister_value(stack));
+  NM_CONSERVATIVE(nm_unregister_value(&stack));
   if (s.dtype() == nm::RUBYOBJ)
     nm_list_storage_unregister_list(l, rec);
 }
@@ -877,7 +877,7 @@ static void each_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l,
 static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const LIST* l, size_t rec, VALUE& stack) {
   if (s.dtype() == nm::RUBYOBJ)
     nm_list_storage_register_list(l, rec);
-  NM_CONSERVATIVE(nm_register_value(stack));
+  NM_CONSERVATIVE(nm_register_value(&stack));
 
   NODE* curr = l->first;
 
@@ -916,7 +916,7 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
       if (curr && curr->key - offset >= shape) curr = NULL;
     }
   }
-  NM_CONSERVATIVE(nm_unregister_value(stack));
+  NM_CONSERVATIVE(nm_unregister_value(&stack));
   if (s.dtype() == nm::RUBYOBJ)
     nm_list_storage_unregister_list(l, rec);
 }
@@ -927,11 +927,11 @@ static void each_stored_with_indices_r(nm::list_storage::RecurseData& s, const L
  */
 VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
 
-  NM_CONSERVATIVE(nm_register_value(nmatrix));
+  NM_CONSERVATIVE(nm_register_value(&nmatrix));
 
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   RETURN_SIZED_ENUMERATOR(nmatrix, 0, 0, 0);
 
   nm::list_storage::RecurseData sdata(NM_STORAGE_LIST(nmatrix));
@@ -941,7 +941,7 @@ VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
   if (stored) each_stored_with_indices_r(sdata, sdata.top_level_list(), sdata.dim() - 1, stack);
   else        each_with_indices_r(sdata, sdata.top_level_list(), sdata.dim() - 1, stack);
 
-  NM_CONSERVATIVE(nm_unregister_value(nmatrix));
+  NM_CONSERVATIVE(nm_unregister_value(&nmatrix));
   return nmatrix;
 }
 
@@ -951,8 +951,8 @@ VALUE nm_list_each_with_indices(VALUE nmatrix, bool stored) {
  * which probably needs to be casted.
  */
 VALUE nm_list_map_stored(VALUE left, VALUE init) {
-  NM_CONSERVATIVE(nm_register_value(left));
-  NM_CONSERVATIVE(nm_register_value(init));
+  NM_CONSERVATIVE(nm_register_value(&left));
+  NM_CONSERVATIVE(nm_register_value(&init));
 
   LIST_STORAGE *s = NM_STORAGE_LIST(left);
 
@@ -965,20 +965,20 @@ VALUE nm_list_map_stored(VALUE left, VALUE init) {
   //}
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(left));
-  NM_CONSERVATIVE(nm_unregister_value(init));
+  NM_CONSERVATIVE(nm_unregister_value(&left));
+  NM_CONSERVATIVE(nm_unregister_value(&init));
   RETURN_SIZED_ENUMERATOR(left, 0, 0, 0); // FIXME: Test this. Probably won't work. Enable above code instead.
 
   // Figure out default value if none provided by the user
   if (init == Qnil) {
-    nm_unregister_value(init);
+    nm_unregister_value(&init);
     init = rb_yield_values(1, sdata.init_obj());
-    nm_register_value(init);
+    nm_register_value(&init);
   }
 	// Allocate a new shape array for the resulting matrix.
   void* init_val = NM_ALLOC(VALUE);
   memcpy(init_val, &init, sizeof(VALUE));
-  nm_register_value(*reinterpret_cast<VALUE*>(init_val));
+  nm_register_value(&*reinterpret_cast<VALUE*>(init_val));
 
   NMATRIX* result = nm_create(nm::LIST_STORE, nm_list_storage_create(nm::RUBYOBJ, sdata.copy_alloc_shape(), s->dim, init_val));
   LIST_STORAGE* r = reinterpret_cast<LIST_STORAGE*>(result->storage);
@@ -989,9 +989,9 @@ VALUE nm_list_map_stored(VALUE left, VALUE init) {
   VALUE to_return = Data_Wrap_Struct(CLASS_OF(left), nm_mark, nm_delete, result);
 
   nm_unregister_nmatrix(result);
-  nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
-  NM_CONSERVATIVE(nm_unregister_value(init));
-  NM_CONSERVATIVE(nm_unregister_value(left));
+  nm_unregister_value(&*reinterpret_cast<VALUE*>(init_val));
+  NM_CONSERVATIVE(nm_unregister_value(&init));
+  NM_CONSERVATIVE(nm_unregister_value(&left));
 
   return to_return;
 }
@@ -1001,9 +1001,9 @@ VALUE nm_list_map_stored(VALUE left, VALUE init) {
  * map merged stored iterator. Always returns a matrix containing RubyObjects which probably needs to be casted.
  */
 VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
-  NM_CONSERVATIVE(nm_register_value(left));
-  NM_CONSERVATIVE(nm_register_value(right));
-  NM_CONSERVATIVE(nm_register_value(init));
+  NM_CONSERVATIVE(nm_register_value(&left));
+  NM_CONSERVATIVE(nm_register_value(&right));
+  NM_CONSERVATIVE(nm_register_value(&init));
 
   bool scalar = false;
 
@@ -1031,23 +1031,23 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
   //}
   // If we don't have a block, return an enumerator.
   RETURN_SIZED_ENUMERATOR_PRE
-  NM_CONSERVATIVE(nm_unregister_value(left));
-  NM_CONSERVATIVE(nm_unregister_value(right));
-  NM_CONSERVATIVE(nm_unregister_value(init));
+  NM_CONSERVATIVE(nm_unregister_value(&left));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
+  NM_CONSERVATIVE(nm_unregister_value(&init));
   RETURN_SIZED_ENUMERATOR(left, 0, 0, 0); // FIXME: Test this. Probably won't work. Enable above code instead.
 
   // Figure out default value if none provided by the user
   nm::list_storage::RecurseData& tdata = *(new nm::list_storage::RecurseData(t)); //FIXME: this is a hack to make sure that we can run the destructor before nm_list_storage_delete(t) below.
   if (init == Qnil) {
-    nm_unregister_value(init);
+    nm_unregister_value(&init);
     init = rb_yield_values(2, sdata.init_obj(), tdata.init_obj());
-    nm_register_value(init);
+    nm_register_value(&init);
   }
 
   // Allocate a new shape array for the resulting matrix.
   void* init_val = NM_ALLOC(VALUE);
   memcpy(init_val, &init, sizeof(VALUE));
-  nm_register_value(*reinterpret_cast<VALUE*>(init_val));
+  nm_register_value(&*reinterpret_cast<VALUE*>(init_val));
 
   NMATRIX* result = nm_create(nm::LIST_STORE, nm_list_storage_create(nm::RUBYOBJ, sdata.copy_alloc_shape(), s->dim, init_val));
   LIST_STORAGE* r = reinterpret_cast<LIST_STORAGE*>(result->storage);
@@ -1060,11 +1060,11 @@ VALUE nm_list_map_merged_stored(VALUE left, VALUE right, VALUE init) {
 
   VALUE to_return = Data_Wrap_Struct(CLASS_OF(left), nm_mark, nm_delete, result);
 
-  nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
+  nm_unregister_value(&*reinterpret_cast<VALUE*>(init_val));
 
-  NM_CONSERVATIVE(nm_unregister_value(init));
-  NM_CONSERVATIVE(nm_unregister_value(right));
-  NM_CONSERVATIVE(nm_unregister_value(left));
+  NM_CONSERVATIVE(nm_unregister_value(&init));
+  NM_CONSERVATIVE(nm_unregister_value(&right));
+  NM_CONSERVATIVE(nm_unregister_value(&left));
 
   return to_return;
 }
@@ -1101,7 +1101,7 @@ static LIST* slice_copy(const LIST_STORAGE* src, LIST* src_rows, size_t* coords,
         }
       } else { // matches src->dim - n > 1
         if (src->dtype == nm::RUBYOBJ) {
-          nm_register_value(*reinterpret_cast<VALUE*>(src_node->val));
+          nm_register_value(&*reinterpret_cast<VALUE*>(src_node->val));
           temp_vals.push_front(reinterpret_cast<VALUE*>(src_node->val));
         }
         nm::list::insert_copy(dst_rows, false, key, src_node->val, DTYPE_SIZES[src->dtype]);
@@ -1134,7 +1134,7 @@ void* nm_list_storage_get(const STORAGE* storage, SLICE* slice) {
     void *init_val = NM_ALLOC_N(char, DTYPE_SIZES[s->dtype]);
     memcpy(init_val, s->default_val, DTYPE_SIZES[s->dtype]);
     if (s->dtype == nm::RUBYOBJ)
-      nm_register_value(*reinterpret_cast<VALUE*>(init_val));
+      nm_register_value(&*reinterpret_cast<VALUE*>(init_val));
 
     size_t *shape = NM_ALLOC_N(size_t, s->dim);
     memcpy(shape, slice->lengths, sizeof(size_t) * s->dim);
@@ -1144,7 +1144,7 @@ void* nm_list_storage_get(const STORAGE* storage, SLICE* slice) {
     ns->rows = slice_copy(s, s->rows, slice->coords, slice->lengths, 0);
 
     if (s->dtype == nm::RUBYOBJ) {
-      nm_unregister_value(*reinterpret_cast<VALUE*>(init_val));
+      nm_unregister_value(&*reinterpret_cast<VALUE*>(init_val));
     }
 
     nm_list_storage_unregister(s);
@@ -1197,7 +1197,7 @@ void* nm_list_storage_ref(const STORAGE* storage, SLICE* slice) {
 static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coords, size_t* lengths, size_t n) {
   nm_list_storage_register(dest);
   if (dest->dtype == nm::RUBYOBJ) {
-    nm_register_value(*reinterpret_cast<VALUE*>(val));
+    nm_register_value(&*reinterpret_cast<VALUE*>(val));
     nm_list_storage_register_list(l, dest->dim - n - 1);
   }
 
@@ -1240,7 +1240,7 @@ static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coo
       }
       if (dest->dtype == nm::RUBYOBJ) {
         temp_vals.push_front(reinterpret_cast<VALUE*>(node->val));
-        nm_register_value(*reinterpret_cast<VALUE*>(node->val));
+        nm_register_value(&*reinterpret_cast<VALUE*>(node->val));
       }
     }
     __nm_list_storage_unregister_temp_value_list(temp_vals);
@@ -1248,7 +1248,7 @@ static void slice_set_single(LIST_STORAGE* dest, LIST* l, void* val, size_t* coo
 
   nm_list_storage_unregister(dest);
   if (dest->dtype == nm::RUBYOBJ) {
-    nm_unregister_value(*reinterpret_cast<VALUE*>(val));
+    nm_unregister_value(&*reinterpret_cast<VALUE*>(val));
     nm_list_storage_unregister_list(l, dest->dim - n - 1);
   }
 }
@@ -1275,7 +1275,7 @@ NODE* nm_list_storage_insert(STORAGE* storage, SLICE* slice, void* val) {
   LIST_STORAGE* s = (LIST_STORAGE*)storage;
   nm_list_storage_register(s);
   if (s->dtype == nm::RUBYOBJ)
-    nm_register_value(*reinterpret_cast<VALUE*>(val));
+    nm_register_value(&*reinterpret_cast<VALUE*>(val));
   // Pretend dims = 2
   // Then coords is going to be size 2
   // So we need to find out if some key already exists
@@ -1291,7 +1291,7 @@ NODE* nm_list_storage_insert(STORAGE* storage, SLICE* slice, void* val) {
 
   nm_list_storage_unregister(s);
   if (s->dtype == nm::RUBYOBJ)
-    nm_unregister_value(*reinterpret_cast<VALUE*>(val));
+    nm_unregister_value(&*reinterpret_cast<VALUE*>(val));
 
   return nm::list::insert(l, true, s->offset[r] + slice->coords[r], val);
 }
@@ -1620,9 +1620,9 @@ extern "C" {
    * Get the default_value property from a list matrix.
    */
   VALUE nm_list_default_value(VALUE self) {
-    NM_CONSERVATIVE(nm_register_value(self));
+    NM_CONSERVATIVE(nm_register_value(&self));
     VALUE to_return = (NM_DTYPE(self) == nm::RUBYOBJ) ? *reinterpret_cast<VALUE*>(NM_DEFAULT_VAL(self)) : rubyobj_from_cval(NM_DEFAULT_VAL(self), NM_DTYPE(self)).rval;
-    NM_CONSERVATIVE(nm_unregister_value(self));
+    NM_CONSERVATIVE(nm_unregister_value(&self));
     return to_return;
   }
 } // end of extern "C" block