therubyracer-tmpfork 0.12.2

data/ext/v8/backref.cc

@@ -0,0 +1,45 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Backref::Storage;
+  ID Backref::_new;
+  ID Backref::object;
+
+  void Backref::Init() {
+    Storage = rb_eval_string("V8::Weak::Ref");
+    rb_gc_register_address(&Storage);
+    _new = rb_intern("new");
+    object = rb_intern("object");
+  }
+
+  Backref::Backref(VALUE initial) {
+    set(initial);
+    rb_gc_register_address(&storage);
+  }
+
+  Backref::~Backref() {
+    rb_gc_unregister_address(&storage);
+  }
+
+  VALUE Backref::set(VALUE data) {
+    this->storage = rb_funcall(Storage, _new, 1, data);
+    return data;
+  }
+
+  VALUE Backref::get() {
+    return rb_funcall(storage, object, 0);
+  }
+
+  v8::Handle<v8::Value> Backref::toExternal() {
+    v8::Local<v8::Value> wrapper = v8::External::New(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/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("SetEmbedderData", &SetEmbedderData).
+    defineMethod("GetEmbedderData", &GetEmbedderData).
+    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::SetEmbedderData(VALUE self, VALUE index, VALUE data) {
+  Void(Context(self)->SetEmbedderData(NUM2INT(index), Value(data)));
+}
+
+VALUE Context::GetEmbedderData(VALUE self, VALUE index) {
+  Void(Context(self)->GetEmbedderData(NUM2INT(index)));
+}
+
+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);
+}
+
+}

data/ext/v8/date.cc

@@ -0,0 +1,18 @@
+#include "rr.h"
+
+namespace rr {
+
+  void Date::Init() {
+    ClassBuilder("Date", Value::Class).
+      defineSingletonMethod("New", &New).
+      defineMethod("NumberValue", &NumberValue).
+      store(&Class);
+  }
+
+  VALUE Date::New(VALUE self, VALUE time) {
+    return Value(v8::Date::New(NUM2DBL(time)));
+  }
+  VALUE Date::NumberValue(VALUE self) {
+    return rb_float_new(Date(self)->NumberValue());
+  }
+}

data/ext/v8/exception.cc

@@ -0,0 +1,38 @@
+#include "rr.h"
+
+namespace rr {
+  void Exception::Init() {
+    ModuleBuilder("V8::C").
+      defineSingletonMethod("ThrowException", &ThrowException);
+    ClassBuilder("Exception").
+      defineSingletonMethod("RangeError", &RangeError).
+      defineSingletonMethod("ReferenceError", &ReferenceError).
+      defineSingletonMethod("SyntaxError", &SyntaxError).
+      defineSingletonMethod("TypeError", &TypeError).
+      defineSingletonMethod("Error", &Error);
+  }
+
+  VALUE Exception::ThrowException(VALUE self, VALUE exception) {
+    return Value(v8::ThrowException(Value(exception)));
+  }
+
+  VALUE Exception::RangeError(VALUE self, VALUE message) {
+    return Value(v8::Exception::RangeError(String(message)));
+  }
+
+  VALUE Exception::ReferenceError(VALUE self, VALUE message) {
+    return Value(v8::Exception::ReferenceError(String(message)));
+  }
+
+  VALUE Exception::SyntaxError(VALUE self, VALUE message) {
+    return Value(v8::Exception::SyntaxError(String(message)));
+  }
+
+  VALUE Exception::TypeError(VALUE self, VALUE message) {
+    return Value(v8::Exception::TypeError(String(message)));
+  }
+
+  VALUE Exception::Error(VALUE self, VALUE message) {
+    return Value(v8::Exception::Error(String(message)));
+  }
+}

data/ext/v8/extconf.rb

@@ -0,0 +1,34 @@
+require 'mkmf'
+
+have_library('pthread')
+have_library('objc') if RUBY_PLATFORM =~ /darwin/
+$CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
+$CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
+$CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
+$CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or RUBY_PLATFORM =~ /darwin/
+
+CONFIG['LDSHARED'] = '$(CXX) -shared' unless RUBY_PLATFORM =~ /darwin/
+if CONFIG['warnflags']
+  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
+  CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
+end
+if enable_config('debug')
+  $CFLAGS += " -O0 -ggdb3"
+end
+
+LIBV8_COMPATIBILITY = '~> 3.16.14'
+
+begin
+  require 'rubygems'
+  gem 'libv8', LIBV8_COMPATIBILITY
+rescue Gem::LoadError
+  warn "Warning! Unable to load libv8 #{LIBV8_COMPATIBILITY}."
+rescue LoadError
+  warn "Warning! Could not load rubygems. Please make sure you have libv8 #{LIBV8_COMPATIBILITY} installed."
+ensure
+  require 'libv8'
+end
+
+Libv8.configure_makefile
+
+create_makefile('v8/init')

data/ext/v8/external.cc

@@ -0,0 +1,43 @@
+#include "rr.h"
+
+namespace rr {
+
+void External::Init() {
+  ClassBuilder("External", "Value").
+    defineSingletonMethod("New", &New).
+    defineMethod("Value", &Value).
+    store(&Class);
+}
+VALUE External::New(VALUE self, VALUE data) {
+  return External(wrap(data));
+}
+
+v8::Handle<v8::External> External::wrap(VALUE data) {
+  Data* holder = new Data(data);
+  v8::Local<v8::External> ext = v8::External::New(holder);
+  v8::Persistent<v8::External>::New(ext).MakeWeak(holder, &release);
+  return ext;
+}
+
+VALUE External::unwrap(v8::Handle<v8::External> external) {
+  Data* data = (Data*)(external->Value());
+  return data->value;
+}
+
+VALUE External::Value(VALUE self) {
+  return unwrap(External(self));
+}
+
+void External::release(v8::Persistent<v8::Value> handle, void* parameter) {
+  handle.Dispose();
+  Data* data = (Data*)parameter;
+  delete data;
+}
+External::Data::Data(VALUE data) {
+  this->value = data;
+  rb_gc_register_address(&value);
+}
+External::Data::~Data() {
+  rb_gc_unregister_address(&value);
+}
+}

data/ext/v8/function.cc

@@ -0,0 +1,58 @@
+#include "rr.h"
+
+namespace rr {
+  void Function::Init() {
+    ClassBuilder("Function", Object::Class).
+      defineMethod("NewInstance", &NewInstance).
+      defineMethod("Call", &Call).
+      defineMethod("SetName", &SetName).
+      defineMethod("GetName", &GetName).
+      defineMethod("GetInferredName", &GetInferredName).
+      defineMethod("GetScriptLineNumber", &GetScriptLineNumber).
+      defineMethod("GetScriptColumnNumber", &GetScriptColumnNumber).
+      defineMethod("GetScriptId", &GetScriptId).
+      defineMethod("GetScriptOrigin", &GetScriptOrigin).
+      store(&Class);
+  }
+
+  VALUE Function::NewInstance(int argc, VALUE argv[], VALUE self) {
+    VALUE args;
+    rb_scan_args(argc,argv,"01", &args);
+    if (RTEST(args)) {
+      return Object(Function(self)->NewInstance(RARRAY_LENINT(args), Value::array<Value>(args)));
+    } else {
+      return Object(Function(self)->NewInstance());
+    }
+  }
+  VALUE Function::Call(VALUE self, VALUE receiver, VALUE argv) {
+    return Value(Function(self)->Call(Object(receiver), RARRAY_LENINT(argv), Value::array<Value>(argv)));
+  }
+
+  VALUE Function::SetName(VALUE self, VALUE name) {
+    Void(Function(self)->SetName(String(name)));
+  }
+
+  VALUE Function::GetName(VALUE self) {
+    return Value(Function(self)->GetName());
+  }
+
+  VALUE Function::GetInferredName(VALUE self) {
+    return Value(Function(self)->GetInferredName());
+  }
+
+  VALUE Function::GetScriptLineNumber(VALUE self) {
+    return INT2FIX(Function(self)->GetScriptLineNumber());
+  }
+
+  VALUE Function::GetScriptColumnNumber(VALUE self) {
+    return INT2FIX(Function(self)->GetScriptColumnNumber());
+  }
+
+  VALUE Function::GetScriptId(VALUE self) {
+    return Value(Function(self)->GetScriptId());
+  }
+
+  VALUE Function::GetScriptOrigin(VALUE self) {
+    return not_implemented("GetScriptOrigin");
+  }
+}