therubyracer 0.11.0beta8-x86-freebsd-9

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::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,52 @@
+
+LIBV8_COMPATIBILITY = '~> 3.11.8'
+
+def have_rubygem_libv8?
+  require 'rubygems'
+  gem 'libv8', LIBV8_COMPATIBILITY
+  require 'libv8'
+  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);
+}
+
+}

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,25 @@
+require 'mkmf'
+require File.expand_path '../build', __FILE__
+
+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
+if have_rubygem_libv8?
+  build_with_rubygem_libv8
+else
+  build_with_system_libv8
+end
+
+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);
+}
+}