therubyracer 0.10.2 → 0.11.0beta1

data/ext/v8/v8_exception.h

@@ -1,11 +0,0 @@
-#ifndef _RR_V8_EXCEPTION_
-#define _RR_V8_EXCEPTION_
-
-#include "v8.h"
-#include "ruby.h"
-
-void rr_init_v8_exception();
-VALUE rr_reflect_v8_stacktrace(v8::Handle<v8::StackTrace> value);
-VALUE rr_reflect_v8_stackframe(v8::Handle<v8::StackFrame> value);
-
-#endif

data/ext/v8/v8_external.cpp

@@ -1,70 +0,0 @@
-#include "rr.h"
-#include "v8_external.h"
-
-#include "v8_handle.h"
-#include "v8_value.h"
-using namespace v8;
-
-namespace {
-  VALUE ExternalClass;
-  VALUE references;
-
-  struct Weaklink {
-    bool finalized_from_rb;
-    bool finalized_from_v8;
-    VALUE target;
-  };
-
-  VALUE Weaklink_finalized_from_ruby(VALUE object_id, VALUE data) {
-    Weaklink* link = 0;
-    Data_Get_Struct(data, struct Weaklink, link);
-    link->finalized_from_rb = true;
-    if (link->finalized_from_v8) {
-      delete link;
-    }
-    return Qnil;
-  }
-  void Weaklink_finalized_from_v8(Persistent<Value> value, void* data) {
-    Weaklink* link = (Weaklink*)data;
-    link->finalized_from_v8 = true;
-    if (link->finalized_from_rb) {
-      delete link;
-    }
-    value.Dispose();
-  }
-
-  VALUE New(VALUE self, VALUE value) {
-    HandleScope scope;
-    Weaklink* link = new Weaklink();
-    link->finalized_from_v8 = false;
-    link->finalized_from_rb = false;
-    link->target = value;
-    Persistent<External> external = Persistent<External>::New(External::New((void*)link));
-    external.MakeWeak(link,Weaklink_finalized_from_v8);
-    VALUE finalizer_data = Data_Wrap_Struct(rb_cObject, 0, 0, link);
-    rr_define_finalizer(value, (void*)Weaklink_finalized_from_ruby, finalizer_data);
-    return rr_v8_handle_new(self, external);
-  }
-
-  VALUE _Value(VALUE self) {
-    HandleScope scope;
-    Weaklink* link = (Weaklink*)rr_v8_handle<External>(self)->Value();
-    if (link->finalized_from_rb) {
-      rb_warn("an active v8::External wraps a VALUE that has already been finalized! This is not good.\n");
-      return Qnil;
-    } else {
-      return link->target;
-    }
-    return (VALUE)rr_v8_handle<External>(self)->Value();
-  }
-}
-
-void rr_init_v8_external() {
-  ExternalClass = rr_define_class("External", rr_v8_value_class());
-  rr_define_singleton_method(ExternalClass, "New", New, 1);
-  rr_define_method(ExternalClass, "Value", _Value, 0);
-}
-
-VALUE rr_reflect_v8_external(Handle<Value> external) {
-  return rr_v8_handle_new(ExternalClass, external);
-}

data/ext/v8/v8_external.h

@@ -1,8 +0,0 @@
-#ifndef _RR_V8_EXTERNAL_
-#define _RR_V8_EXTERNAL_
-
-#include "rr.h"
-
-void rr_init_v8_external();
-VALUE rr_reflect_v8_external(v8::Handle<v8::Value> value);
-#endif

data/ext/v8/v8_function.cpp

@@ -1,69 +0,0 @@
-
-#include <vector>
-#include "v8_function.h"
-#include "v8_object.h"
-#include "v8_handle.h"
-
-using namespace v8;
-
-namespace {
-  VALUE FunctionClass;
-  
-  Persistent<Function>& unwrap(VALUE value) {
-    return rr_v8_handle<Function>(value);
-  }  
-  VALUE Call(VALUE self, VALUE recv, VALUE arguments) {
-    HandleScope handles;
-    if (!Context::InContext()) {
-      rb_raise(rb_eScriptError, "no open V8 Context in V8::C::Function::Call()");
-      return Qnil;
-    }
-    Handle<Function> function = unwrap(self);
-    Local<Object> thisObj = rr_rb2v8(recv)->ToObject();
-    Handle<Array> args = rr_v8_handle<Array>(arguments);
-    int argc = args->Length();
-    std::vector< Handle<Value> > argv (argc);
-    for (int i = 0; i < argc; i++) {
-      argv[i] = args->Get(i);
-    }
-    return rr_v82rb(function->Call(thisObj, argc, &argv[0]));
-  }
-  
-  VALUE NewInstance(VALUE self, VALUE arguments) {
-    HandleScope scope;
-    Handle<Function> function = unwrap(self);
-    Handle<Array> args = rr_v8_handle<Array>(arguments);
-    int argc = args->Length();
-    std::vector< Handle<Value> > argv (argc);
-    for (int i = 0; i < argc; i++) {
-      argv[i] = args->Get(i);
-    }
-    return rr_v82rb(function->NewInstance(argc, &argv[0]));
-  }
-  VALUE GetName(VALUE self) {
-    HandleScope scope;
-    return rr_v82rb(unwrap(self)->GetName());
-  }
-  VALUE SetName(VALUE self, VALUE name) {
-    HandleScope scope;
-    Handle<String> str = rr_v8_handle<String>(name);
-    unwrap(self)->SetName(str);
-    return Qnil;
-  }  
-  // VALUE GetScriptOrigin(VALUE self) {
-  //   return rr_v82rb(unwrap(self)->GetScriptOrigin());
-  // }
-}
-
-void rr_init_function() {
-  FunctionClass = rr_define_class("Function", rr_v8_object_class());
-  rr_define_method(FunctionClass, "Call", Call, 2);
-  rr_define_method(FunctionClass, "NewInstance", NewInstance, 1);
-  rr_define_method(FunctionClass, "GetName", GetName, 0);
-  rr_define_method(FunctionClass, "SetName", SetName, 1);
-  // rr_define_method(FunctionClass, "GetScriptOrigin", GetScriptOrigin, 0);
-}
-
-VALUE rr_reflect_v8_function(Handle<Value> value) {
-  return rr_reflect_v8_object_as(value, FunctionClass);
-}

data/ext/v8/v8_function.h

@@ -1,11 +0,0 @@
-#ifndef _RUBY_V8_FUNCTION_
-#define _RUBY_V8_FUNCTION_
-
-#include "rr.h"
-#include "v8.h"
-
-void rr_init_function();
-
-VALUE rr_reflect_v8_function(v8::Handle<v8::Value> value);
-
-#endif

data/ext/v8/v8_handle.cpp

@@ -1,186 +0,0 @@
-
-#include "rr.h"
-#include "v8_handle.h"
-
-using namespace v8;
-
-/**
-* Creates a new Persistent storage cell for `handle`
-* so that we can reference it from Ruby. Ruby metadat
-* is contained on the handle object, and then the actual
-* v8 references are contain in an instance of `Payload`
-*/
-v8_handle::v8_handle(Handle<void> object) {
-  this->weakref_callback = Qnil;
-  this->weakref_callback_parameters = Qnil;
-  this->dead = false;
-  this->payload = new Payload(object);
-}
-
-v8_handle::~v8_handle() {}
-
-/**
-* Construct a new handle payload.
-*
-* Each payload contains a Ruby object wrapper so that it
-* can be enqueued for V8 GC (the GC queue is a ruby Array)
-* the wrapper is pre-allocated at payload creation time
-* so that no Ruby objects are allocated during Ruby GC.
-*/
-v8_handle::Payload::Payload(Handle<void> object) {
-  rb_gc_register_address(&wrapper);
-  handle = Persistent<void>::New(object);
-  wrapper = Data_Wrap_Struct(rb_cObject, 0, destroy, this);
-}
-
-v8_handle::Payload::~Payload() {
-  rb_gc_unregister_address(&wrapper);
-}
-
-void v8_handle::Payload::release() {
-  handle.Dispose();
-  handle.Clear();
-}
-
-void v8_handle::Payload::destroy(v8_handle::Payload* payload) {
-  delete payload;
-}
-
-namespace {
-  /**
-  * Holds dead references, that are no longer being held in Ruby, so that they can be garbage collected
-  * inside of V8
-  */
-  VALUE handle_queue;
-
-  /**
-  * Invoked by the Ruby garbage collector whenever it determines that this handle is
-  * still reachable. We in turn, mark our weak callback parameters, so that it knows
-  * they are reachable too.
-  */
-  void v8_handle_mark(v8_handle* handle) {
-    rb_gc_mark(handle->weakref_callback);
-    rb_gc_mark(handle->weakref_callback_parameters);
-  }
-
-  /**
-  * Whenver a V8::C::Handle becomes garbage collected, we do not free it immediately.
-  * instead, we put them into a "zombie" queue, where its corresponding V8 storage cell
-  * can be released safely while the V8 engine is running. A zombie Ruby object is
-  * created to wrap it so that it can be stored in the queue.
-  */
-  void v8_handle_enqueue(v8_handle* handle) {
-    handle->dead = true;
-    rb_ary_unshift(handle_queue, handle->payload->wrapper);
-  }
-
-  /**
-  * Drains the dead handle queue, and releases them from V8
-  *
-  * This implements the V8 `GCPrologueCallback` and is registered to run before
-  * each invocation of the V8 garbage collector. It empties the queue of dead handles
-  * and disposes of them. It is important to do this operations inside V8 so that
-  * Ruby garbage collection is never locked, and never touches V8.
-  */
-  void v8_handle_dequeue(GCType type, GCCallbackFlags flags) {
-    for (VALUE handle = rb_ary_pop(handle_queue); RTEST(handle); handle = rb_ary_pop(handle_queue)) {
-      v8_handle::Payload* payload = NULL;
-      Data_Get_Struct(handle, struct v8_handle::Payload, payload);
-      payload->release();
-    }
-  }
-
-  VALUE New(VALUE self, VALUE handle) {
-    if (RTEST(handle)) {
-      Persistent<void> that = rr_v8_handle<void>(handle);
-      return rr_v8_handle_new(self, that);
-    } else {
-      return rr_v8_handle_new(self, Handle<void>());
-    }
-  }
-
-  VALUE IsEmpty(VALUE self) {
-    return rr_v82rb(rr_v8_handle<void>(self).IsEmpty());
-  }
-
-  VALUE Clear(VALUE self) {
-    rr_v8_handle<void>(self).Clear();
-    return Qnil;
-  }
-
-  VALUE Dispose(VALUE self) {
-    rr_v8_handle<void>(self).Dispose();
-    return Qnil;
-  }
-
-  void RubyWeakReferenceCallback(Persistent<Value> value, void* parameter) {
-    VALUE self = (VALUE)parameter;
-    v8_handle* handle = rr_v8_handle_raw(self);
-    VALUE callback = handle->weakref_callback;
-    VALUE parameters = handle->weakref_callback_parameters;
-    if (RTEST(callback)) {
-      rb_funcall(callback, rb_intern("call"), 2, self, parameters);
-    }
-    value.Dispose();
-    handle->payload->release();
-    handle->dead = true;
-
-  }
-
-  VALUE MakeWeak(VALUE self, VALUE parameters, VALUE callback) {
-    v8_handle* handle = rr_v8_handle_raw(self);
-    handle->weakref_callback = callback;
-    handle->weakref_callback_parameters = parameters;
-    rr_v8_handle<void>(self).MakeWeak((void*)self, RubyWeakReferenceCallback);
-    return Qnil;
-  }
-
-  VALUE ClearWeak(VALUE self) {
-    rr_v8_handle<void>(self).ClearWeak();
-    return Qnil;
-  }
-
-  VALUE IsNearDeath(VALUE self) {
-    return rr_v82rb(rr_v8_handle<void>(self).IsNearDeath());
-  }
-
-  VALUE IsWeak(VALUE self) {
-    return rr_v82rb(rr_v8_handle<void>(self).IsWeak());
-  }
-
-  VALUE dead_p(VALUE self) {
-    return rr_v8_handle_raw(self)->dead ? Qtrue : Qfalse;
-  }
-}
-
-void rr_init_handle() {
-  VALUE HandleClass = rr_define_class("Handle");
-  rr_define_method(HandleClass, "dead?", dead_p, 0);
-  rr_define_singleton_method(HandleClass, "New", New, 1);
-  rr_define_method(HandleClass, "IsEmpty", IsEmpty, 0);
-  rr_define_method(HandleClass, "Clear", Clear, 0);
-  rr_define_method(HandleClass, "Dispose", Dispose, 0);
-  rr_define_method(HandleClass, "MakeWeak", MakeWeak, 2);
-  rr_define_method(HandleClass, "ClearWeak", ClearWeak, 0);
-  rr_define_method(HandleClass, "IsNearDeath", IsNearDeath, 0);
-  rr_define_method(HandleClass, "IsWeak", IsWeak, 0);
-
-  rb_gc_register_address(&handle_queue);
-  handle_queue = rb_ary_new();
-  V8::AddGCPrologueCallback(v8_handle_dequeue);
-}
-
-VALUE rr_v8_handle_new(VALUE klass, v8::Handle<void> handle) {
-  v8_handle* new_handle = new v8_handle(handle);
-  return Data_Wrap_Struct(klass, v8_handle_mark, v8_handle_enqueue, new_handle);
-}
-
-VALUE rr_v8_handle_class() {
-  return rr_define_class("Handle");
-}
-
-v8_handle* rr_v8_handle_raw(VALUE value) {
-  v8_handle* handle = 0;
-  Data_Get_Struct(value, struct v8_handle, handle);
-  return handle;
-}

data/ext/v8/v8_handle.h

@@ -1,48 +0,0 @@
-#ifndef _RR_V8_HANDLE_
-#define _RR_V8_HANDLE_
-
-#include <v8.h>
-#include "ruby.h"
-
-/**
-* Holds a reference to a V8 heap object. This serves as the base
-* class for all of the low-level proxies that reference into V8.
-*/
-struct v8_handle  {
-
-  /**
-  * Contains the *actual* V8 references. This object is kept
-  * separate so that it can be "detached" from the handle when
-  * it is garbage collected, and enqueued separately and
-  * collected in the context of a V8 thread.
-  */
-
-  struct Payload {
-    Payload(v8::Handle<void> object);
-    virtual ~Payload();
-    void release();
-    static void destroy(v8_handle::Payload* payload);
-    v8::Persistent<void> handle;
-    VALUE wrapper;
-  };
-
-  v8_handle(v8::Handle<void> object);
-  virtual ~v8_handle();
-
-  Payload* payload;
-  bool dead;
-  VALUE weakref_callback;
-  VALUE weakref_callback_parameters;
-};
-
-void rr_init_handle();
-
-v8_handle* rr_v8_handle_raw(VALUE value);
-
-template <class T> v8::Persistent<T>& rr_v8_handle(VALUE value) {
-  return (v8::Persistent<T>&)(rr_v8_handle_raw(value)->payload->handle);
-}
-VALUE rr_v8_handle_new(VALUE rbclass, v8::Handle<void> handle);
-VALUE rr_v8_handle_class();
-
-#endif

data/ext/v8/v8_locker.cpp

@@ -1,139 +0,0 @@
-#include "rr.h"
-#include "v8_locker.h"
-
-using namespace v8;
-
-namespace {
-  namespace Lock {
-
-    /**
-    * Document-method: V8::C::Locker#new
-    *
-    * Allocates and returns a new `v8::Locker` object. The thread that instantiated
-    * this object will hold the V8 interpreter lock until it is released with a
-    * corresponding call to {#delete}.
-    *
-    * It critical that you call {#delete} to deallocate it, preferably within the same method.
-    * If you don't, two bad things will happen:
-    *
-    * 1. You'll leak the underlying C++ object
-    * 1. Worse, you'll leave the V8 vm locked to this thread forever
-    *
-    * It's dangerous! Be sure to `ensure`.
-    *
-    * for detailed semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
-    *
-    * @return [V8::C::Locker] the new locker
-    */
-
-    VALUE New(VALUE LockerClass) {
-      Locker* locker = new Locker();
-      return Data_Wrap_Struct(LockerClass, 0, 0, (void*)locker);
-    }
-
-    /**
-    * Document-method: V8::C::Locker#delete
-    *
-    * Pop this lock off the stack for this thread. For a full run down of V8 locking
-    * semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
-    * @return nil
-    */
-    VALUE Delete(VALUE self) {
-      Locker* locker = 0;
-      Data_Get_Struct(self, class Locker, locker);
-      delete locker;
-    }
-  }
-
-  namespace Unlock {
-    /**
-    * Document-method: V8::C::Unlocker#new
-    *
-    * Allocates and returns a new `v8::UnLocker` object, temporarily releasing any locks that
-    * this thread is holding. It will reaquire all of the locksto {#delete}.
-    *
-    * This is a great thing to do when you want to call out to some code that might do some
-    * waiting, sleeping, and you want to politely let other threads use this VM.
-    *
-    * It critical that you call {#delete} to deallocate it, preferably within the same method.
-    * If you don't, two bad things will happen:
-    *
-    * 1. You'll leak the underlying C++ object
-    * 1. You won't restore the locks to your current thread, and will mess things up horribly
-    *
-    * It's dangerous! Be sure to `ensure`.
-    *
-    * For details on V8 locking semantics, see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
-    * @return [V8::C::Unocker] the new locker
-    */
-    VALUE New(VALUE UnlockerClass) {
-      Unlocker* unlocker = new Unlocker();
-      return Data_Wrap_Struct(UnlockerClass, 0, 0, (void*)unlocker);
-    }
-
-    /**
-    * Document-method: V8::C::Unlocker#delete
-    *
-    * Restore any locks to the stack that were temporarily removed by this `Unlocker`.
-    * For a full run down, see semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
-    * @return nil
-    */
-    VALUE Delete(VALUE self) {
-      Unlocker* unlocker;
-      Data_Get_Struct(self, class Unlocker, unlocker);
-      delete unlocker;
-    }
-  }
-
-  /**
-  * Document-method: V8::C::Locker#StartPreemption
-  * Start preemption.
-  * When preemption is started, a timer is fired every n milli seconds that will switch between
-  * multiple threads that are in contention for the V8 lock.
-  *
-  * @param [Integer] every_n_ms
-  * @return nil
-  */
-  VALUE StartPreemption(VALUE self, VALUE every_n_ms) {
-    Locker::StartPreemption(NUM2INT(rb_to_int(every_n_ms)));
-    return Qnil;
-  }
-
-  /**
-  * Document-method: V8::C::Locker#StartPreemption
-  * Stop preemption
-  */
-  VALUE StopPreemption(VALUE self) {
-    Locker::StopPreemption();
-    return Qnil;
-  }
-
-  /**
-  * Document-method: V8::C::Locker#IsLocked
-  * Returns whether or not the locker is locked by the current thread.
-  */
-  VALUE IsLocked(VALUE self) {
-    return rr_v82rb(Locker::IsLocked());
-  }
-
-  /**
-  * Document-method: V8::C::Locker#IsActive
-  * Returns whether v8::Locker is being used by this V8 instance.
-  */
-  VALUE IsActive(VALUE self) {
-    return rr_v82rb(Locker::IsActive());
-  }
-}
-
-void rr_init_v8_locker() {
-  VALUE LockerClass = rr_define_class("Locker");
-  VALUE UnlockerClass = rr_define_class("Unlocker");
-  rr_define_singleton_method(LockerClass, "new", Lock::New, 0);
-  rr_define_method(LockerClass, "delete", Lock::Delete, 0);
-  rr_define_singleton_method(UnlockerClass, "new", Unlock::New, 0);
-  rr_define_method(UnlockerClass, "delete", Unlock::Delete, 0);
-  rr_define_singleton_method(LockerClass, "StartPreemption", StartPreemption, 1);
-  rr_define_singleton_method(LockerClass, "StopPreemption", StopPreemption, 0);
-  rr_define_singleton_method(LockerClass, "IsLocked", IsLocked, 0);
-  rr_define_singleton_method(LockerClass, "IsActive", IsActive, 0);
-}