therubyracer 0.10.2 → 0.11.0beta1

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

@@ -1,27 +1,23 @@
 require 'mkmf'
-require 'set'
-begin
-  require 'rubygems'
-  gem 'libv8', '~> 3.3.10'
-  require 'libv8'
-rescue LoadError, Gem::LoadError
-  require 'libv8'
-end
+require File.expand_path '../build', __FILE__
 
+have_library('pthread')
 have_library('objc') if RUBY_PLATFORM =~ /darwin/
-
-#we have to manually prepend the libv8 include path to INCFLAGS
-#since find_header() does not actually work as advertized.
-#see https://github.com/cowboyd/therubyracer/issues/91
-$INCFLAGS.insert 0, "-I#{Libv8.include_path} "
-
 $CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
 $CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
 $CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
-
-$LDFLAGS.insert 0, "#{Libv8.library_path}/libv8.#{$LIBEXT} "
-$LIBS << ' -lpthread'
+$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 have_rubygem_libv8?
+  build_with_rubygem_libv8
+else
+  build_with_system_libv8
+end
 
-create_makefile('v8')
+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");
+  }
+}

data/ext/v8/gc.cc

@@ -0,0 +1,43 @@
+#include "rr.h"
+
+namespace rr {
+  GC::Queue* queue;
+
+  GC::Queue::Queue() : first(0), divider(0), last(0){
+    first = new GC::Queue::Node(NULL);
+    divider = first;
+    last = first;
+  }
+
+  void GC::Queue::Enqueue(void* reference) {
+    last->next = new Node(reference);
+    last = last->next;
+    while (first != divider) {
+      Node* tmp = first;
+      first = first->next;
+      delete tmp;
+    }
+  }
+
+  void* GC::Queue::Dequeue() {
+    void* result = NULL;
+    if (divider != last) {
+      result = divider->next->value;
+      divider = divider->next;
+    }
+    return result;
+  }
+
+  void GC::Finalize(void* phantom) {
+    queue->Enqueue(phantom);
+  }
+  void GC::Drain(v8::GCType type, v8::GCCallbackFlags flags) {
+    for(Phantom phantom = queue->Dequeue(); phantom.NotNull(); phantom = queue->Dequeue()) {
+      phantom.destroy();
+    }
+  }
+  void GC::Init() {
+    queue = new GC::Queue();
+    v8::V8::AddGCPrologueCallback(GC::Drain);
+  }
+}

data/ext/v8/handles.cc

@@ -0,0 +1,34 @@
+#include "rr.h"
+
+namespace rr {
+
+void Handles::Init() {
+  VALUE v8 = rb_define_module("V8");
+  VALUE c = rb_define_module_under(v8, "C");
+  rb_define_singleton_method(c, "HandleScope", (VALUE (*)(...))&HandleScope, -1);
+}
+
+VALUE Handles::HandleScope(int argc, VALUE* argv, VALUE self) {
+  if (!rb_block_given_p()) {
+    return Qnil;
+  }
+  int state = 0;
+  VALUE code;
+  rb_scan_args(argc,argv,"00&", &code);
+  VALUE result = SetupAndCall(&state, code);
+  if (state != 0) {
+    rb_jump_tag(state);
+  }
+  return result;
+}
+
+VALUE Handles::SetupAndCall(int* state, VALUE code) {
+  v8::HandleScope scope;
+  return rb_protect(&DoCall, code, state);
+}
+
+VALUE Handles::DoCall(VALUE code) {
+  return rb_funcall(code, rb_intern("call"), 0);
+}
+
+}

data/ext/v8/heap.cc

@@ -0,0 +1,31 @@
+#include "rr.h"
+
+namespace rr {
+  void HeapStatistics::Init() {
+    ClassBuilder("HeapStatistics").
+      defineSingletonMethod("new", &initialize).
+      defineMethod("total_heap_size", &total_heap_size).
+      defineMethod("total_heap_size_executable", &total_heap_size_executable).
+      defineMethod("used_heap_size", &used_heap_size).
+      defineMethod("heap_size_limit", &heap_size_limit).
+      store(&Class);
+  }
+  VALUE HeapStatistics::initialize(VALUE self) {
+    return HeapStatistics(new v8::HeapStatistics());
+  }
+  VALUE HeapStatistics::total_heap_size(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->total_heap_size());
+  }
+  VALUE HeapStatistics::total_heap_size_executable(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->total_heap_size_executable());
+  }
+  VALUE HeapStatistics::used_heap_size(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->used_heap_size());
+  }
+  VALUE HeapStatistics::heap_size_limit(VALUE self) {
+    return SIZET2NUM(HeapStatistics(self)->heap_size_limit());
+  }
+  template <> void Pointer<v8::HeapStatistics>::unwrap(VALUE value) {
+    Data_Get_Struct(value, class v8::HeapStatistics, pointer);
+  }
+}

data/ext/v8/init.cc

@@ -0,0 +1,39 @@
+#include "rr.h"
+
+extern "C" {
+  void Init_init();
+}
+
+using namespace rr;
+
+extern "C" {
+  void Init_init() {
+    v8::Locker lock();
+    GC::Init();
+    V8::Init();
+    Handles::Init();
+    Accessor::Init();
+    Context::Init();
+    Invocation::Init();
+    Signature::Init();
+    Value::Init();
+    Primitive::Init();
+    String::Init();
+    Object::Init();
+    Array::Init();
+    Function::Init();
+    Date::Init();
+    Constants::Init();
+    External::Init();
+    Script::Init();
+    Template::Init();
+    Stack::Init();
+    Message::Init();
+    TryCatch::Init();
+    Exception::Init();
+    Locker::Init();
+    ResourceConstraints::Init();
+    HeapStatistics::Init();
+    Backref::Init();
+  }
+}

data/ext/v8/invocation.cc

@@ -0,0 +1,86 @@
+#include "rr.h"
+
+namespace rr {
+
+  VALUE Invocation::Arguments::Class;
+
+  void Invocation::Init() {
+    Arguments::Init();
+  }
+
+  void Invocation::Arguments::Init() {
+    ClassBuilder("Arguments").
+      defineMethod("Length", &Length).
+      defineMethod("[]", &Get).
+      defineMethod("Callee", &Callee).
+      defineMethod("This", &This).
+      defineMethod("Holder", &Holder).
+      defineMethod("IsConstructCall", &IsConstructCall).
+      defineMethod("Data", &Data).
+    store(&Invocation::Arguments::Class);
+  }
+
+  Invocation::Invocation(VALUE code, VALUE data) {
+    this->code = code;
+    this->data = data;
+  }
+  Invocation::Invocation(v8::Handle<v8::Value> value) {
+    v8::Local<v8::Object> wrapper = value->ToObject();
+    this->code = External::unwrap((v8::Handle<v8::External>)v8::External::Cast(*wrapper->Get(0)));
+    this->data = Value(wrapper->Get(1));
+  }
+  Invocation::operator v8::InvocationCallback() {
+    return &Callback;
+  }
+  Invocation::operator v8::Handle<v8::Value>() {
+    v8::Local<v8::Object> wrapper = v8::Object::New();
+    wrapper->Set(0, External::wrap(this->code));
+    wrapper->Set(1, Value(this->data));
+    return wrapper;
+  }
+
+  v8::Handle<v8::Value> Invocation::Callback(const v8::Arguments& args) {
+    return Arguments(args).Call();
+  }
+
+  Invocation::Arguments::Arguments(const v8::Arguments& args) {
+    this->args = &args;
+  }
+
+  Invocation::Arguments::Arguments(VALUE value) {
+    Data_Get_Struct(value, class v8::Arguments, args);
+  }
+
+  v8::Handle<v8::Value> Invocation::Arguments::Call() {
+    Invocation invocation(args->Data());
+    return Value(rb_funcall(invocation.code, rb_intern("call"), 1, Data_Wrap_Struct(Class, 0, 0, (void*)this->args)));
+  }
+
+  VALUE Invocation::Arguments::Length(VALUE self) {
+    return INT2FIX(Arguments(self)->Length());
+  }
+
+  VALUE Invocation::Arguments::Get(VALUE self, VALUE index) {
+    return Value((*Arguments(self))[NUM2INT(index)]);
+  }
+
+  VALUE Invocation::Arguments::Callee(VALUE self) {
+    return Function(Arguments(self)->Callee());
+  }
+
+  VALUE Invocation::Arguments::This(VALUE self) {
+    return Object(Arguments(self)->This());
+  }
+
+  VALUE Invocation::Arguments::Holder(VALUE self) {
+    return Object(Arguments(self)->Holder());
+  }
+
+  VALUE Invocation::Arguments::IsConstructCall(VALUE self) {
+    return Bool(Arguments(self)->IsConstructCall());
+  }
+
+  VALUE Invocation::Arguments::Data(VALUE self) {
+    return Invocation(Arguments(self)->Data()).data;
+  }
+}