don't use rb_block_call() since it is not in rbx

ext/v8/backref.cc

@@ -4,27 +4,42 @@ namespace rr {
 
   VALUE Backref::Storage;
   ID Backref::_new;
-  ID Backref::access;
+  ID Backref::object;
 
   void Backref::Init() {
-    Storage = rb_eval_string("require 'v8/util/weakcell'; V8::Util::Weakcell::Storage");
+    Storage = rb_eval_string("Ref::WeakReference");
     rb_gc_register_address(&Storage);
     _new = rb_intern("new");
-    access = rb_intern("access");
+    object = rb_intern("object");
   }
 
-  Backref::Backref() {
+  Backref::Backref(VALUE initial) {
-    this->storage = rb_funcall(Storage, _new, 0);
+    allocate(initial);
+    this->storage = rb_funcall(Storage, _new, 1, initial);
     rb_gc_register_address(&storage);
   }
 
   Backref::~Backref() {
+    deallocate();
+  }
+
+  void Backref::allocate(VALUE data) {
+    this->storage = rb_funcall(Storage, _new, 1, data);
+    rb_gc_register_address(&storage);
+  }
+
+  void Backref::deallocate() {
     rb_gc_unregister_address(&storage);
   }
 
-  VALUE Backref::get(VALUE (*populate)(ANYARGS), VALUE data) {
+  VALUE Backref::get() {
-    VALUE args[0];
+    return rb_funcall(storage, object, 0);
-    return rb_block_call(storage, access, 0, args, populate, data);
+  }
+
+  VALUE Backref::set(VALUE data) {
+    deallocate();
+    allocate(data);
+    return data;
   }
 
   v8::Handle<v8::Value> Backref::toExternal() {

ext/v8/object.cc

@@ -135,29 +135,25 @@ Object::operator VALUE() {
   if (handle.IsEmpty()) {
     return Qnil;
   }
-  VALUE value;
   Backref* backref;
   v8::Local<v8::String> key(v8::String::NewSymbol("rr::Backref"));
   v8::Local<v8::Value> external = handle->GetHiddenValue(key);
+  VALUE value;
   if (external.IsEmpty()) {
-    backref = new Backref();
+    value = downcast();
+    backref = new Backref(value);
     handle->SetHiddenValue(key, backref->toExternal());
   } else {
     backref = (Backref*)v8::External::Unwrap(external);
+    value = backref->get();
+    if (!RTEST(value)) {
+      value = downcast();
+      backref->set(value);
+    }
   }
-  return backref->get((VALUE (*)(...))&toVALUE, Data_Wrap_Struct(rb_cObject, 0, 0, this));
   return value;
 }
 
-VALUE Object::toVALUE(VALUE yield, VALUE wrapper) {
-  if (!RTEST(wrapper)) {
-    fprintf(stderr, "WTF?");
-  }
-  Object* object(NULL);
-  Data_Get_Struct(wrapper, class Object, object);
-  return object->downcast();
-}
-
 VALUE Object::downcast() {
   if (handle->IsFunction()) {
     return Function((v8::Handle<v8::Function>) v8::Function::Cast(*handle));

ext/v8/rr.h

@@ -206,16 +206,19 @@ template <class T> VALUE Ref<T>::Class;
 class Backref {
 public:
   static void Init();
-  Backref();
+  Backref(VALUE value);
   virtual ~Backref();
-  VALUE get(VALUE (*populate)(ANYARGS), VALUE data);
+  VALUE get();
+  VALUE set(VALUE value);
   v8::Handle<v8::Value> toExternal();
   static void release(v8::Persistent<v8::Value> handle, void* data);
 private:
+  void allocate(VALUE data);
+  void deallocate();
   VALUE storage;
   static VALUE Storage;
   static ID _new;
-  static ID access;
+  static ID object;
 };
 class Handles {
 public: