therubyracer-freebsd 0.10.1

data/ext/v8/v8_callbacks.h

@@ -0,0 +1,8 @@
+#ifndef _RR_V8_CALLBACKS_
+#define _RR_V8_CALLBACKS_
+#include "rr.h"
+void rr_init_v8_callbacks();
+VALUE rr_v82rb(const v8::AccessorInfo& info);
+VALUE rr_v82rb(const v8::Arguments& arguments);
+
+#endif

data/ext/v8/v8_context.cpp

@@ -0,0 +1,92 @@
+#include "rr.h"
+#include "v8_handle.h"
+#include "v8_context.h"
+#include "v8_message.h"
+#include "v8_template.h"
+#include "v8_external.h"
+
+using namespace v8;
+
+namespace {
+
+  VALUE ContextClass;
+
+  Persistent<Context>& unwrap(VALUE value) {
+    return rr_v8_handle<Context>(value);
+  }
+
+  VALUE New(int argc, VALUE *argv, VALUE self) {
+    HandleScope handles;
+    VALUE global_template; VALUE global_object;
+    rb_scan_args(argc,argv, "02", &global_template, &global_object);
+    Handle<ObjectTemplate> v8_global_template(NIL_P(global_template) ? Handle<ObjectTemplate>() : rr_v8_handle<ObjectTemplate>(global_template));
+    Handle<Value> v8_global_object(NIL_P(global_object) ? Handle<Value>() : rr_v8_handle<Value>(global_object));
+    Persistent<Context> cxt(Context::New(0, v8_global_template, v8_global_object));
+    VALUE ref = rr_v8_handle_new(self, cxt);
+    cxt.Dispose();
+    return ref;
+  }
+
+  VALUE InContext(VALUE self) {
+    return Context::InContext() ? Qtrue : Qfalse;  
+  }
+
+  VALUE GetEntered(VALUE self) {
+    HandleScope handles;
+    if (Context::InContext()) {
+      Local<Context> current = Context::GetEntered();
+      return rr_v8_handle_new(self, current);    
+    } else {
+      return Qnil;
+    }
+  }
+
+  VALUE Global(VALUE self) {
+    HandleScope handles;
+    return rr_v82rb(unwrap(self)->Global());
+  }  
+
+  VALUE Enter(VALUE self) {
+    HandleScope handles;
+    unwrap(self)->Enter();
+    return self;
+  }
+
+  VALUE Exit(VALUE self) {
+    HandleScope handles;
+    unwrap(self)->Exit();
+    return self;
+  }
+
+  VALUE IsEntered(VALUE self) {
+    HandleScope handles;
+    if (Context::InContext()) {
+      return rr_v82rb(unwrap(self) == Context::GetEntered());
+    } else {
+      return Qfalse;
+    }
+  }
+  VALUE GetData(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->GetData());
+  }
+  VALUE SetData(VALUE self, VALUE data) {
+    HandleScope scope;
+    unwrap(self)->SetData(rr_rb2v8(data)->ToString());
+    return Qnil;
+  }
+}
+
+void rr_init_context() {
+  ContextClass = rr_define_class("Context", rr_v8_handle_class());
+  rr_define_singleton_method(ContextClass, "New", New, -1);
+  rr_define_singleton_method(ContextClass, "InContext", InContext, 0);
+  rr_define_singleton_method(ContextClass, "GetEntered", GetEntered, 0);
+  rr_define_method(ContextClass, "Global", Global, 0);
+  rr_define_method(ContextClass, "Enter", Enter, 0);
+  rr_define_method(ContextClass, "Exit", Exit, 0);
+  rr_define_method(ContextClass, "IsEntered", IsEntered, 0);
+  rr_define_method(ContextClass, "GetData", GetData, 0);
+  rr_define_method(ContextClass, "SetData", SetData, 1);
+}
+

data/ext/v8/v8_context.h

@@ -0,0 +1,6 @@
+#ifndef _RUBY_V8_CXT_
+#define _RUBY_V8_CXT_ 
+
+void rr_init_context();
+
+#endif

data/ext/v8/v8_date.cpp

@@ -0,0 +1,40 @@
+#include "rr.h"
+#include "v8_date.h"
+#include "v8_value.h"
+#include "v8_handle.h"
+#include "v8_object.h"
+
+using namespace v8;
+
+namespace {
+
+  VALUE DateClass;
+
+  VALUE New(VALUE self, VALUE time) {
+    HandleScope scope;
+    return rr_v8_handle_new(self, Date::New(NUM2DBL(time)));
+  }
+
+  // Override Value::NumberValue in order to ensure that we call the more specific and optimized
+  // Number Value in v8::Date
+  VALUE NumberValue(VALUE self) {
+    Persistent<Date> date = rr_v8_handle<Date>(self);
+    return rr_v82rb(date->NumberValue());
+  }
+
+  VALUE DateTimeConfigurationChangeNotification(VALUE self) {
+    Date::DateTimeConfigurationChangeNotification();
+    return Qnil;
+  }
+}
+
+void rr_init_v8_date() {
+  DateClass = rr_define_class("Date", rr_v8_value_class());
+  rr_define_singleton_method(DateClass, "New", New, 1);
+  rr_define_singleton_method(DateClass, "DateTimeConfigurationChangeNotification", DateTimeConfigurationChangeNotification, 0);
+  rr_define_method(DateClass, "NumberValue", NumberValue, 0);
+}
+
+VALUE rr_reflect_v8_date(Handle<Value> value) {
+  return rr_reflect_v8_object_as(Handle<Object>::Cast(value), DateClass);
+}

data/ext/v8/v8_date.h

@@ -0,0 +1,6 @@
+#ifndef _RR_V8_DATE_
+#define _RR_V8_DATE_
+
+void rr_init_v8_date();
+VALUE rr_reflect_v8_date(v8::Handle<v8::Value> value);
+#endif

data/ext/v8/v8_debug.cpp

@@ -0,0 +1,17 @@
+#include "rr.h"
+#include "v8_debug.h"
+#include "v8-debug.h"
+
+using namespace v8;
+
+namespace {
+
+  VALUE EnableAgent(VALUE self, VALUE application_name, VALUE port) {
+    return rr_v82rb(v8::Debug::EnableAgent(RSTRING_PTR(application_name), NUM2INT(port), false));
+  }
+}
+
+void rr_init_v8_debug() {
+  VALUE DebugModule = rr_define_module("Debug");
+  rr_define_singleton_method(DebugModule, "EnableAgent", EnableAgent, 2);
+}

data/ext/v8/v8_debug.h

@@ -0,0 +1,6 @@
+#ifndef _RR_V8_DEBUG_
+#define _RR_V8_DEBUG_
+
+void rr_init_v8_debug();
+
+#endif

data/ext/v8/v8_exception.cpp

@@ -0,0 +1,133 @@
+#include "v8_exception.h"
+#include "rr.h"
+#include "v8_handle.h"
+// #include "execinfo.h"
+// #include "signal.h"
+
+using namespace v8;
+namespace {
+
+  static void* stack[20];
+
+  void fatal(const char* location, const char* message) {
+    rb_raise(rb_eFatal, "%s: %s", location, message);
+  }
+  // void segfault(int sig) {
+  //   fprintf(stderr, "segfault: game over.\n");
+  //   int size = backtrace(stack, 20);
+  //   backtrace_symbols_fd(stack, size, 2);
+  //   exit(1);
+  // }
+  VALUE _ThrowException(VALUE rbmod, VALUE value) {
+    HandleScope scope;
+    Handle<Value> err = rr_rb2v8(value);
+    return rr_v82rb(ThrowException(err));
+  }
+  VALUE RangeError(VALUE rbclass, VALUE value) {
+    HandleScope scope;
+    return rr_v82rb(Exception::RangeError(rr_rb2v8(value)->ToString()));
+  }
+  VALUE ReferenceError(VALUE rbclass, VALUE value) {
+    HandleScope scope;
+    return rr_v82rb(Exception::ReferenceError(rr_rb2v8(value)->ToString()));
+  }
+  VALUE SyntaxError(VALUE rbclass, VALUE value) {
+    HandleScope scope;
+    return rr_v82rb(Exception::SyntaxError(rr_rb2v8(value)->ToString()));
+  }
+  VALUE Error(VALUE rbclass, VALUE value) {
+    HandleScope scope;
+    return rr_v82rb(Exception::Error(rr_rb2v8(value)->ToString()));
+  }
+
+  VALUE StackTraceClass;
+  VALUE StackFrameClass;
+  namespace Trace {
+
+    Persistent<StackTrace>& trace(VALUE value) {
+      return rr_v8_handle<StackTrace>(value);
+    }
+    VALUE GetFrame(VALUE self, VALUE index) {
+      HandleScope scope;
+      return rr_v82rb(trace(self)->GetFrame(NUM2UINT(index)));
+    }
+    VALUE GetFrameCount(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(trace(self)->GetFrameCount());
+    }
+    VALUE AsArray(VALUE self) {
+      return rr_v82rb(trace(self)->AsArray());
+    }
+    VALUE CurrentStackTrace(VALUE self, VALUE frame_limit) {
+      return rr_v82rb(StackTrace::CurrentStackTrace(NUM2INT(frame_limit)));
+    }
+  }
+
+  namespace Frame {
+    Persistent<StackFrame>& frame(VALUE value) {
+     return rr_v8_handle<StackFrame>(value);
+    }
+    VALUE GetLineNumber(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(frame(self)->GetLineNumber());
+    }
+    VALUE GetColumn(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(frame(self)->GetColumn());
+    }
+    VALUE GetScriptName(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(frame(self)->GetScriptName());
+    }
+    VALUE GetFunctionName(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(frame(self)->GetFunctionName());
+    }
+    VALUE IsEval(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(frame(self)->IsEval());
+    }
+    VALUE IsConstructor(VALUE self) {
+      HandleScope scope;
+      return rr_v82rb(frame(self)->IsConstructor());
+    }
+  }
+
+}
+
+void rr_init_v8_exception() {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  rr_define_singleton_method(V8_C, "ThrowException", _ThrowException, 1);
+
+  VALUE ExceptionClass = rr_define_class("Exception");
+  rr_define_singleton_method(ExceptionClass, "RangeError", RangeError, 1);
+  rr_define_singleton_method(ExceptionClass, "ReferenceError", ReferenceError, 1);
+  rr_define_singleton_method(ExceptionClass, "SyntaxError", SyntaxError, 1);
+  rr_define_singleton_method(ExceptionClass, "Error", Error, 1);
+
+  StackTraceClass = rr_define_class("StackTrace", rr_v8_handle_class());
+  rr_define_singleton_method(StackTraceClass, "CurrentStackTrace", Trace::CurrentStackTrace, 1);
+  rr_define_method(StackTraceClass, "GetFrame", Trace::GetFrame, 1);
+  rr_define_method(StackTraceClass, "GetFrameCount", Trace::GetFrameCount, 0);
+  rr_define_method(StackTraceClass, "AsArray", Trace::AsArray, 0);
+
+  StackFrameClass = rr_define_class("StackFrame", rr_v8_handle_class());
+  rr_define_method(StackFrameClass, "GetLineNumber", Frame::GetLineNumber, 0);
+  rr_define_method(StackFrameClass, "GetColumn", Frame::GetColumn, 0);
+  rr_define_method(StackFrameClass, "GetScriptName", Frame::GetScriptName, 0);
+  rr_define_method(StackFrameClass, "GetFunctionName", Frame::GetFunctionName, 0);
+  rr_define_method(StackFrameClass, "IsEval", Frame::IsEval, 0);
+  rr_define_method(StackFrameClass, "IsConstructor", Frame::IsConstructor, 0);
+
+  v8::V8::SetFatalErrorHandler(fatal);
+  //comment this in for debugging.
+  // signal(SIGSEGV, segfault);
+}
+
+VALUE rr_reflect_v8_stacktrace(Handle<StackTrace> value) {
+  return rr_v8_handle_new(StackTraceClass, value);
+}
+VALUE rr_reflect_v8_stackframe(Handle<StackFrame> value) {
+  return rr_v8_handle_new(StackFrameClass, value);
+}

data/ext/v8/v8_exception.h

@@ -0,0 +1,11 @@
+#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

@@ -0,0 +1,70 @@
+#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

@@ -0,0 +1,8 @@
+#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

@@ -0,0 +1,69 @@
+
+#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);
+}