therubyracer 0.10.2 → 0.11.0beta1

data/ext/v8/accessor.cc

@@ -0,0 +1,181 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Accessor::Info::Class;
+
+  void Accessor::Init() {
+    ClassBuilder("AccessorInfo").
+      defineMethod("This", &Info::This).
+      defineMethod("Holder", &Info::Holder).
+      defineMethod("Data", &Info::Data).
+      store(&Info::Class);
+  }
+
+  Accessor::Accessor(VALUE getter, VALUE setter, VALUE data_) : get(getter), set(setter), data(data_) {}
+
+  Accessor::Accessor(VALUE get, VALUE set, VALUE query, VALUE deleter, VALUE enumerator, VALUE data) {
+    this->get = get;
+    this->set = set;
+    this->query = query;
+    this->deleter = deleter;
+    this->enumerator = enumerator;
+    this->data = data;
+  }
+
+  Accessor::Accessor(v8::Handle<v8::Value> value) {
+    v8::Local<v8::Object> wrapper = value->ToObject();
+    this->get = unwrap(wrapper, 0);
+    this->set = unwrap(wrapper, 1);
+    this->query = unwrap(wrapper, 2);
+    this->deleter = unwrap(wrapper, 3);
+    this->enumerator = unwrap(wrapper, 4);
+    v8::Handle<v8::Value> data = wrapper->Get(5);
+    if (!data.IsEmpty()) {
+      this->data = Value(data);
+    }
+  }
+
+  Accessor::operator v8::Handle<v8::Value>() {
+    v8::Local<v8::Object> wrapper = v8::Object::New();
+    wrap(wrapper, 0, this->get);
+    wrap(wrapper, 1, this->set);
+    wrap(wrapper, 2, this->query);
+    wrap(wrapper, 3, this->deleter);
+    wrap(wrapper, 4, this->enumerator);
+    if (RTEST(this->data)) {
+      wrapper->Set(5, Value(this->data));
+    }
+    return wrapper;
+  }
+
+  void Accessor::wrap(v8::Handle<v8::Object> wrapper, int index, VALUE value) {
+    if (RTEST(value)) {
+      wrapper->Set(index, External::wrap(value));
+    }
+  }
+
+  VALUE Accessor::unwrap(v8::Handle<v8::Object> wrapper, int index) {
+    v8::Handle<v8::Value> value = wrapper->Get(index);
+    if (value.IsEmpty()) {
+      return Qnil;
+    } else {
+      v8::Handle<v8::External> external(v8::External::Cast(*value));
+      return External::unwrap(external);
+    }
+  }
+
+
+  VALUE Accessor::Info::This(VALUE self) {
+    return Object(Info(self)->This());
+  }
+
+  VALUE Accessor::Info::Holder(VALUE self) {
+    return Object(Info(self)->Holder());
+  }
+
+  VALUE Accessor::Info::Data(VALUE self) {
+    return Accessor(Info(self)->Data()).data;
+  }
+
+  v8::Handle<v8::Value> Accessor::AccessorGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).get(property);
+  }
+
+  void Accessor::AccessorSetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    Info(info).set(property, value);
+  }
+  v8::Handle<v8::Value> Accessor::NamedPropertyGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).get(property);
+  }
+  v8::Handle<v8::Value> Accessor::NamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    return Info(info).set(property, value);
+  }
+  v8::Handle<v8::Integer> Accessor::NamedPropertyQuery(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).query(property);
+  }
+  v8::Handle<v8::Boolean> Accessor::NamedPropertyDeleter(v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+    return Info(info).remove(property);
+  }
+  v8::Handle<v8::Array> Accessor::NamedPropertyEnumerator(const v8::AccessorInfo& info) {
+    return Info(info).enumerateNames();
+  }
+
+  v8::Handle<v8::Value> Accessor::IndexedPropertyGetter(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).get(index);
+  }
+  v8::Handle<v8::Value> Accessor::IndexedPropertySetter(uint32_t index, v8::Local<v8::Value> value, const v8::AccessorInfo& info) {
+    return Info(info).set(index, value);
+  }
+  v8::Handle<v8::Integer> Accessor::IndexedPropertyQuery(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).query(index);
+  }
+  v8::Handle<v8::Boolean> Accessor::IndexedPropertyDeleter(uint32_t index, const v8::AccessorInfo& info) {
+    return Info(info).remove(index);
+  }
+  v8::Handle<v8::Array> Accessor::IndexedPropertyEnumerator(const v8::AccessorInfo& info) {
+    return Info(info).enumerateIndices();
+  }
+
+  Accessor::Info::Info(const v8::AccessorInfo& info) {
+    this->info = &info;
+  }
+
+  Accessor::Info::Info(VALUE value) {
+    Data_Get_Struct(value, class v8::AccessorInfo, info);
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::get(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.get, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::set(v8::Local<v8::String> property, v8::Local<v8::Value> value) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.set, rb_intern("call"), 3, (VALUE)String(property), (VALUE)Value(value), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Integer> Accessor::Info::query(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return v8::Integer::New(NUM2INT(rb_funcall(accessor.query, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Boolean> Accessor::Info::remove(v8::Local<v8::String> property) {
+    Accessor accessor(info->Data());
+    return v8::Boolean::New(Bool(rb_funcall(accessor.deleter, rb_intern("call"), 2, (VALUE)String(property), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Array> Accessor::Info::enumerateNames() {
+    Accessor accessor(info->Data());
+    return Array(rb_funcall(accessor.enumerator, rb_intern("call"), 1, (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::get(uint32_t index) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.get, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Value> Accessor::Info::set(uint32_t index, v8::Local<v8::Value> value) {
+    Accessor accessor(info->Data());
+    return Value(rb_funcall(accessor.set, rb_intern("call"), 3, UINT2NUM(index), (VALUE)Value(value), (VALUE)*this));
+  }
+
+  v8::Handle<v8::Integer> Accessor::Info::query(uint32_t index) {
+    Accessor accessor(info->Data());
+    return v8::Integer::New(NUM2INT(rb_funcall(accessor.query, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Boolean> Accessor::Info::remove(uint32_t index) {
+    Accessor accessor(info->Data());
+    return v8::Boolean::New(Bool(rb_funcall(accessor.deleter, rb_intern("call"), 2, UINT2NUM(index), (VALUE)*this)));
+  }
+
+  v8::Handle<v8::Array> Accessor::Info::enumerateIndices() {
+    Accessor accessor(info->Data());
+    return Array(rb_funcall(accessor.enumerator, rb_intern("call"), 1, (VALUE)*this));
+  }
+
+  Accessor::Info::operator VALUE() {
+    return Data_Wrap_Struct(Class, 0, 0, (void*)this->info);
+  }
+}

data/ext/v8/array.cc

@@ -0,0 +1,26 @@
+#include "rr.h"
+
+namespace rr {
+
+void Array::Init() {
+  ClassBuilder("Array", Object::Class).
+    defineSingletonMethod("New", &New).
+    defineMethod("Length", &Length).
+    defineMethod("CloneElementAt", &CloneElementAt).
+    store(&Class);
+}
+
+VALUE Array::New(int argc, VALUE argv[], VALUE self) {
+  VALUE length; rb_scan_args(argc, argv, "01", &length);
+  return Array(v8::Array::New(RTEST(length) ? NUM2INT(length) : 0));
+}
+
+VALUE Array::Length(VALUE self) {
+  return UInt32(Array(self)->Length());
+}
+
+VALUE Array::CloneElementAt(VALUE self, VALUE index) {
+  return Object(Array(self)->CloneElementAt(UInt32(index)));
+}
+
+}

data/ext/v8/backref.cc

@@ -0,0 +1,56 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Backref::Storage;
+  ID Backref::_new;
+  ID Backref::object;
+
+  void Backref::Init() {
+    Storage = rb_eval_string("Ref::WeakReference");
+    rb_gc_register_address(&Storage);
+    _new = rb_intern("new");
+    object = rb_intern("object");
+  }
+
+  Backref::Backref(VALUE initial) {
+    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() {
+    return rb_funcall(storage, object, 0);
+  }
+
+  VALUE Backref::set(VALUE data) {
+    deallocate();
+    allocate(data);
+    return data;
+  }
+
+  v8::Handle<v8::Value> Backref::toExternal() {
+    v8::Local<v8::Value> wrapper = v8::External::Wrap(this);
+    v8::Persistent<v8::Value>::New(wrapper).MakeWeak(this, &release);
+    return wrapper;
+  }
+
+  void Backref::release(v8::Persistent<v8::Value> handle, void* data) {
+    handle.Dispose();
+    Backref* backref = (Backref*)data;
+    delete backref;
+  }
+}

data/ext/v8/build.rb

@@ -0,0 +1,51 @@
+
+LIBV8_COMPATIBILITY = '~> 3.11.8'
+
+def have_rubygem_libv8?
+  require 'rubygems'
+  gem 'libv8', LIBV8_COMPATIBILITY
+  return true
+rescue Gem::LoadError
+  return false
+rescue LoadError
+  return false
+end
+
+def build_with_system_libv8
+  dir_config('v8')
+  find_header('v8.h') or begin
+    puts <<-EOS
+    The Ruby Racer requires libv8 #{LIBV8_COMPATIBILITY}
+    to be present on your system in order to compile
+    and link, but it could not be found.
+
+    In order to resolve this, you will either need to manually
+    install an appropriate libv8 and make sure that this
+    build process can find it. If you install it into the
+    standard system path, then it should just be picked up
+    automatically. Otherwise, you'll have to pass some extra
+    flags to the build process as a hint.
+
+    If you don't want to bother with all that, there is a
+    rubygem that will do all this for you. You can add
+    following line to your Gemfile:
+        gem 'libv8', '#{LIBV8_COMPATIBILITY}'
+
+    We hope that helps, and we apologize, but now we have
+    to push the eject button on this install.
+
+    thanks,
+    The Mgmt.
+
+    EOS
+    raise "unable to locate libv8. Please see output for details"
+  end
+  $LDFLAGS << " -lv8 "
+end
+
+def build_with_rubygem_libv8
+  require 'libv8'
+  include Libv8
+  $INCFLAGS.insert 0, "#{libv8_include_flags} "
+  $LDFLAGS.insert 0, libv8_objects.join(' ') + " "
+end

data/ext/v8/constants.cc

@@ -0,0 +1,34 @@
+#include "rr.h"
+
+namespace rr {
+  VALUE Constants::_Undefined;
+  VALUE Constants::_Null;
+  VALUE Constants::_True;
+  VALUE Constants::_False;
+  void Constants::Init() {
+    ModuleBuilder("V8::C").
+      defineSingletonMethod("Undefined", &Undefined).
+      defineSingletonMethod("Null", &Null).
+      defineSingletonMethod("True", &True).
+      defineSingletonMethod("False", &False);
+
+    _Undefined = _Null = _True = _False = Qnil;
+    rb_gc_register_address(&_Undefined);
+    rb_gc_register_address(&_Null);
+    rb_gc_register_address(&_True);
+    rb_gc_register_address(&_False);
+  }
+
+  VALUE Constants::Undefined(VALUE self) {
+    return cached<Primitive, v8::Primitive>(&_Undefined, v8::Undefined());
+  }
+  VALUE Constants::Null(VALUE self) {
+    return cached<Primitive, v8::Primitive>(&_Null, v8::Null());
+  }
+  VALUE Constants::True(VALUE self) {
+    return cached<Bool, v8::Boolean>(&_True, v8::True());
+  }
+  VALUE Constants::False(VALUE self) {
+    return cached<Bool, v8::Boolean>(&_False, v8::False());
+  }
+}

data/ext/v8/constraints.cc

@@ -0,0 +1,52 @@
+#include "rr.h"
+
+namespace rr {
+  void ResourceConstraints::Init() {
+    ClassBuilder("ResourceConstraints").
+      defineSingletonMethod("new", &initialize).
+      defineMethod("max_young_space_size", &max_young_space_size).
+      defineMethod("set_max_young_space_size", &set_max_young_space_size).
+      defineMethod("max_old_space_size", &max_old_space_size).
+      defineMethod("set_max_old_space_size", &set_max_old_space_size).
+      defineMethod("max_executable_size", &set_max_executable_size).
+      defineMethod("set_max_executable_size", &set_max_executable_size).
+      store(&Class);
+    ModuleBuilder("V8::C").
+      defineSingletonMethod("SetResourceConstraints", &SetResourceConstraints);
+  }
+
+  VALUE ResourceConstraints::SetResourceConstraints(VALUE self, VALUE constraints) {
+    Void(v8::SetResourceConstraints(ResourceConstraints(constraints)));
+  }
+
+  VALUE ResourceConstraints::initialize(VALUE self) {
+    return ResourceConstraints(new v8::ResourceConstraints());
+  }
+  VALUE ResourceConstraints::max_young_space_size(VALUE self) {
+    return INT2FIX(ResourceConstraints(self)->max_young_space_size());
+  }
+  VALUE ResourceConstraints::set_max_young_space_size(VALUE self, VALUE value) {
+    Void(ResourceConstraints(self)->set_max_young_space_size(NUM2INT(value)));
+  }
+  VALUE ResourceConstraints::max_old_space_size(VALUE self) {
+    return INT2FIX(ResourceConstraints(self)->max_old_space_size());
+  }
+  VALUE ResourceConstraints::set_max_old_space_size(VALUE self, VALUE value) {
+    Void(ResourceConstraints(self)->set_max_old_space_size(NUM2INT(value)));
+  }
+  VALUE ResourceConstraints::max_executable_size(VALUE self) {
+    return INT2FIX(ResourceConstraints(self)->max_executable_size());
+  }
+  VALUE ResourceConstraints::set_max_executable_size(VALUE self, VALUE value) {
+    Void(ResourceConstraints(self)->set_max_executable_size(NUM2INT(value)));
+  }
+
+  // What do these even mean?
+  // uint32_t* stack_limit() const { return stack_limit_; }
+  // // Sets an address beyond which the VM's stack may not grow.
+  // void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
+
+  template <> void Pointer<v8::ResourceConstraints>::unwrap(VALUE value) {
+    Data_Get_Struct(value, class v8::ResourceConstraints, pointer);
+  }
+}

data/ext/v8/context.cc

@@ -0,0 +1,130 @@
+#include "rr.h"
+
+namespace rr {
+
+void Context::Init() {
+  ClassBuilder("Context").
+    defineSingletonMethod("New", &New).
+    defineSingletonMethod("GetCurrent", &GetCurrent).
+    defineSingletonMethod("GetEntered", &GetEntered).
+    defineSingletonMethod("GetCalling", &GetCalling).
+    defineSingletonMethod("InContext", &InContext).
+    defineMethod("Dispose", &Dispose).
+    defineMethod("Global", &Global).
+    defineMethod("DetachGlobal", &Global).
+    defineMethod("ReattachGlobal", &ReattachGlobal).
+    defineMethod("SetSecurityToken", &SetSecurityToken).
+    defineMethod("UseDefaultSecurityToken", &UseDefaultSecurityToken).
+    defineMethod("GetSecurityToken", &GetSecurityToken).
+    defineMethod("HasOutOfMemoryException", &HasOutOfMemoryException).
+    defineMethod("SetData", &SetData).
+    defineMethod("GetData", &GetData).
+    defineMethod("AllowCodeGenerationFromStrings", &AllowCodeGenerationFromStrings).
+    defineMethod("IsCodeGenerationFromStringsAllowed", &IsCodeGenerationFromStringsAllowed).
+    defineMethod("Enter", &Enter).
+    defineMethod("Exit", &Exit).
+    store(&Class);
+  ClassBuilder("ExtensionConfiguration").
+    defineSingletonMethod("new", &ExtensionConfiguration::initialize).
+    store(&ExtensionConfiguration::Class);
+}
+
+VALUE Context::Dispose(VALUE self) {
+  Void(Context(self).dispose())
+}
+
+VALUE Context::Global(VALUE self) {
+  return Object(Context(self)->Global());
+}
+
+VALUE Context::DetachGlobal(VALUE self) {
+  Void(Context(self)->DetachGlobal());
+}
+
+VALUE Context::ReattachGlobal(VALUE self, VALUE global) {
+  Void(Context(self)->ReattachGlobal(Object(global)));
+}
+
+VALUE Context::GetEntered(VALUE self) {
+  return Context(v8::Context::GetEntered());
+}
+
+VALUE Context::GetCurrent(VALUE self) {
+  return Context(v8::Context::GetCurrent());
+}
+
+VALUE Context::GetCalling(VALUE self) {
+  return Context(v8::Context::GetCalling());
+}
+
+VALUE Context::SetSecurityToken(VALUE self, VALUE token) {
+  Void(Context(self)->SetSecurityToken(Value(token)));
+}
+
+VALUE Context::UseDefaultSecurityToken(VALUE self) {
+  Void(Context(self)->UseDefaultSecurityToken());
+}
+
+VALUE Context::GetSecurityToken(VALUE self) {
+  return Value(Context(self)->GetSecurityToken());
+}
+
+VALUE Context::HasOutOfMemoryException(VALUE self) {
+  return Bool(Context(self)->HasOutOfMemoryException());
+}
+
+VALUE Context::InContext(VALUE self) {
+  return Bool(v8::Context::InContext());
+}
+
+VALUE Context::SetData(VALUE self, VALUE data) {
+  Void(Context(self)->SetData(String(data)));
+}
+
+VALUE Context::GetData(VALUE self) {
+  return Value(Context(self)->GetData());
+}
+
+VALUE Context::AllowCodeGenerationFromStrings(VALUE self, VALUE allow) {
+  Void(Context(self)->AllowCodeGenerationFromStrings(RTEST(allow)));
+}
+
+VALUE Context::IsCodeGenerationFromStringsAllowed(VALUE self) {
+  return Bool(Context(self)->IsCodeGenerationFromStringsAllowed());
+}
+
+VALUE ExtensionConfiguration::initialize(VALUE self, VALUE names) {
+  int length = RARRAY_LENINT(names);
+  const char* array[length];
+  for (int i = 0; i < length; i++) {
+    array[i] = RSTRING_PTR(rb_ary_entry(names, i));
+  }
+  return ExtensionConfiguration(new v8::ExtensionConfiguration(length, array));
+}
+
+VALUE Context::New(int argc, VALUE argv[], VALUE self) {
+  VALUE extension_configuration; VALUE global_template; VALUE global_object;
+  rb_scan_args(argc, argv, "03", &extension_configuration, &global_template, &global_object);
+  v8::Persistent<v8::Context> context(v8::Context::New(
+    ExtensionConfiguration(extension_configuration),
+    *ObjectTemplate(global_template),
+    *Object(global_object)
+  ));
+  Context reference(context);
+  context.Dispose();
+  return reference;
+}
+
+VALUE Context::Enter(VALUE self) {
+  Void(Context(self)->Enter());
+}
+
+VALUE Context::Exit(VALUE self) {
+  Void(Context(self)->Exit());
+}
+
+template <> void Pointer<v8::ExtensionConfiguration>::unwrap(VALUE value) {
+  Data_Get_Struct(value, class v8::ExtensionConfiguration, pointer);
+}
+
+}