therubyracer-discourse 0.12.0

data/ext/v8/script.cc

@@ -0,0 +1,115 @@
+#include "rr.h"
+#include "pthread.h"
+#include "unistd.h"
+
+namespace rr {
+
+void Script::Init() {
+  ClassBuilder("Script").
+    defineSingletonMethod("New", &New).
+    defineMethod("Run", &Run).
+    defineMethod("RunWithTimeout", &RunWithTimeout).
+    store(&Class);
+  ClassBuilder("ScriptOrigin").
+    defineSingletonMethod("new", &ScriptOrigin::initialize).
+    store(&ScriptOrigin::Class);
+  ClassBuilder("ScriptData").
+    defineSingletonMethod("PreCompile", &ScriptData::PreCompile).
+    defineSingletonMethod("New", &ScriptData::New).
+    defineMethod("Length", &ScriptData::Length).
+    defineMethod("Data", &ScriptData::Data).
+    defineMethod("HasError", &ScriptData::HasError).
+    store(&ScriptData::Class);
+}
+
+VALUE ScriptOrigin::initialize(int argc, VALUE argv[], VALUE self) {
+  VALUE name; VALUE line_offset; VALUE column_offset;
+  rb_scan_args(argc, argv, "12", &name, &line_offset, &column_offset);
+  v8::Handle<v8::Integer> loff = v8::Integer::New(RTEST(line_offset) ? NUM2INT(line_offset) : 0);
+  v8::Handle<v8::Integer> coff = v8::Integer::New(RTEST(column_offset) ? NUM2INT(column_offset) : 0);
+  return ScriptOrigin(new v8::ScriptOrigin(*String(name), loff, coff));
+}
+
+VALUE ScriptData::PreCompile(VALUE self, VALUE input, VALUE length) {
+#ifdef HAVE_RUBY_ENCODING_H
+  if (!rb_equal(rb_enc_from_encoding(rb_utf8_encoding()), rb_obj_encoding(input))) {
+    rb_warn("ScriptData::Precompile only accepts UTF-8 encoded source, not: %s", RSTRING_PTR(rb_inspect(rb_obj_encoding(input))));
+  }
+#endif
+  return ScriptData(v8::ScriptData::PreCompile(RSTRING_PTR(input), NUM2INT(length)));
+}
+VALUE ScriptData::New(VALUE self, VALUE data, VALUE length) {
+  return ScriptData(v8::ScriptData::New(RSTRING_PTR(data), NUM2INT(length)));
+}
+VALUE ScriptData::Length(VALUE self) {
+  return ScriptData(self)->Length();
+}
+VALUE ScriptData::Data(VALUE self) {
+  ScriptData data(self);
+#ifdef HAVE_RUBY_ENCODING_H
+  return rb_enc_str_new(data->Data(), data->Length(), rb_enc_find("BINARY"));
+#else
+  return rb_str_new(data->Data(), data->Length());
+#endif
+}
+
+VALUE ScriptData::HasError(VALUE self) {
+  return ScriptData(self)->HasError();
+}
+
+VALUE Script::New(int argc, VALUE argv[], VALUE self) {
+  VALUE source; VALUE origin; VALUE pre_data; VALUE script_data;
+  rb_scan_args(argc, argv, "13", &source, &origin, &pre_data, &script_data);
+  if (argc == 2) {
+    VALUE filename = origin;
+    return Script(v8::Script::New(String(source), Value(filename)));
+  } else {
+    return Script(v8::Script::New(String(source), ScriptOrigin(origin), ScriptData(pre_data), String(script_data)));
+  }
+}
+
+VALUE Script::Run(VALUE self) {
+  return Value(Script(self)->Run());
+}
+
+typedef struct {
+    v8::Isolate *isolate;
+    long timeout;
+} timeout_data;
+
+void* breaker(void *d) {
+  timeout_data* data = (timeout_data*)d;
+  usleep(data->timeout*1000);
+  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+  v8::V8::TerminateExecution(data->isolate);
+  return NULL;
+}
+
+VALUE Script::RunWithTimeout(VALUE self, VALUE timeout) {
+  pthread_t breaker_thread;
+  timeout_data data;
+  VALUE rval;
+  void *res;
+
+  data.isolate = v8::Isolate::GetCurrent();
+  data.timeout = NUM2LONG(timeout);
+
+  pthread_create(&breaker_thread, NULL, breaker, &data);
+
+  rval = Value(Script(self)->Run());
+
+  pthread_cancel(breaker_thread);
+  pthread_join(breaker_thread, &res);
+
+  return rval;
+}
+
+template <> void Pointer<v8::ScriptData>::unwrap(VALUE value) {
+  Data_Get_Struct(value, class v8::ScriptData, pointer);
+}
+
+template <> void Pointer<v8::ScriptOrigin>::unwrap(VALUE value) {
+  Data_Get_Struct(value, class v8::ScriptOrigin, pointer);
+}
+
+} //namespace rr

data/ext/v8/signature.cc

@@ -0,0 +1,18 @@
+#include "rr.h"
+
+namespace rr {
+  void Signature::Init() {
+    ClassBuilder("Signature").
+      defineMethod("New", &New).
+      store(&Class);
+  }
+
+  VALUE Signature::New(int argc, VALUE args[], VALUE self) {
+    VALUE receiver; VALUE argv;
+    rb_scan_args(argc, args, "02", &receiver, &argv);
+    FunctionTemplate recv(receiver);
+    int length = RARRAY_LENINT(argv);
+    FunctionTemplate::array<FunctionTemplate> types(argv);
+    return Signature(v8::Signature::New(recv, length, types));
+  }
+}

data/ext/v8/stack.cc

@@ -0,0 +1,76 @@
+#include "rr.h"
+
+namespace rr {
+  void Stack::Init() {
+    ClassBuilder("StackTrace").
+      defineSingletonMethod("kLineNumber", &Trace::kLineNumber).
+      defineSingletonMethod("kColumnOffset", &Trace::kColumnOffset).
+      defineSingletonMethod("kScriptName", &Trace::kScriptName).
+      defineSingletonMethod("kFunctionName", &Trace::kFunctionName).
+      defineSingletonMethod("kIsEval", &Trace::kIsEval).
+      defineSingletonMethod("kIsConstructor", &Trace::kIsConstructor).
+      defineSingletonMethod("kScriptNameOrSourceURL", &Trace::kScriptNameOrSourceURL).
+      defineSingletonMethod("kOverview", &Trace::kOverview).
+      defineSingletonMethod("kDetailed", &Trace::kDetailed).
+      defineSingletonMethod("CurrentStackTrace", &Trace::CurrentStackTrace).
+      defineMethod("GetFrame", &Trace::GetFrame).
+      defineMethod("GetFrameCount", &Trace::GetFrameCount).
+      defineMethod("AsArray", &Trace::AsArray).
+      store(&Trace::Class);
+    ClassBuilder("StackFrame").
+      defineMethod("GetLineNumber", &Frame::GetLineNumber).
+      defineMethod("GetColumn", &Frame::GetColumn).
+      defineMethod("GetScriptName", &Frame::GetScriptName).
+      defineMethod("GetScriptNameOrSourceURL", &Frame::GetScriptNameOrSourceURL).
+      defineMethod("GetFunctionName", &Frame::GetFunctionName).
+      defineMethod("IsEval", &Frame::IsEval).
+      defineMethod("IsConstructor", &Frame::IsConstructor).
+      store(&Frame::Class);
+  }
+
+  VALUE Stack::Trace::GetFrame(VALUE self, VALUE index) {
+    return Frame(Trace(self)->GetFrame(NUM2UINT(index)));
+  }
+
+  VALUE Stack::Trace::GetFrameCount(VALUE self) {
+    return INT2FIX(Trace(self)->GetFrameCount());
+  }
+
+  VALUE Stack::Trace::AsArray(VALUE self) {
+    return Array(Trace(self)->AsArray());
+  }
+
+  VALUE Stack::Trace::CurrentStackTrace(int argc, VALUE argv[], VALUE self) {
+    VALUE frame_limit; VALUE options;
+    rb_scan_args(argc, argv, "11", &frame_limit, &options);
+    return Trace(v8::StackTrace::CurrentStackTrace(NUM2INT(frame_limit), StackTraceOptions(options)));
+  }
+
+  VALUE Stack::Frame::GetLineNumber(VALUE self) {
+    return INT2FIX(Frame(self)->GetLineNumber());
+  }
+
+  VALUE Stack::Frame::GetColumn(VALUE self) {
+    return INT2FIX(Frame(self)->GetColumn());
+  }
+
+  VALUE Stack::Frame::GetScriptName(VALUE self) {
+    return String(Frame(self)->GetScriptName());
+  }
+
+  VALUE Stack::Frame::GetScriptNameOrSourceURL(VALUE self) {
+    return String(Frame(self)->GetScriptNameOrSourceURL());
+  }
+
+  VALUE Stack::Frame::GetFunctionName(VALUE self) {
+    return String(Frame(self)->GetFunctionName());
+  }
+
+  VALUE Stack::Frame::IsEval(VALUE self) {
+    return Bool(Frame(self)->IsEval());
+  }
+
+  VALUE Stack::Frame::IsConstructor(VALUE self) {
+    return Bool(Frame(self)->IsConstructor());
+  }
+}

data/ext/v8/string.cc

@@ -0,0 +1,47 @@
+#include "rr.h"
+
+namespace rr {
+
+void String::Init() {
+  ClassBuilder("String", Primitive::Class).
+    defineSingletonMethod("New", &New).
+    defineSingletonMethod("NewSymbol", &NewSymbol).
+    defineSingletonMethod("Concat", &Concat).
+    defineMethod("Utf8Value", &Utf8Value).
+    store(&Class);
+}
+
+VALUE String::New(VALUE StringClass, VALUE string) {
+  return String(v8::String::New(RSTRING_PTR(string), (int)RSTRING_LEN(string)));
+}
+
+VALUE String::NewSymbol(VALUE self, VALUE string) {
+  return String(v8::String::NewSymbol(RSTRING_PTR(string), (int)RSTRING_LEN(string)));
+}
+
+VALUE String::Utf8Value(VALUE self) {
+  String str(self);
+  #ifdef HAVE_RUBY_ENCODING_H
+  return rb_enc_str_new(*v8::String::Utf8Value(*str), str->Utf8Length(), rb_enc_find("utf-8"));
+  #else
+  return rb_str_new(*v8::String::Utf8Value(*str), str->Utf8Length());
+  #endif
+}
+
+VALUE String::Concat(VALUE self, VALUE left, VALUE right) {
+  return String(v8::String::Concat(String(left), String(right)));
+}
+
+String::operator v8::Handle<v8::String>() const {
+  switch (TYPE(value)) {
+  case T_STRING:
+    return v8::String::New(RSTRING_PTR(value), (int)RSTRING_LEN(value));
+  case T_DATA:
+    return Ref<v8::String>::operator v8::Handle<v8::String>();
+  default:
+    VALUE string = rb_funcall(value, rb_intern("to_s"), 0);
+    return v8::String::New(RSTRING_PTR(string), (int)RSTRING_LEN(string));
+  }
+}
+
+} //namespace rr

data/ext/v8/template.cc

@@ -0,0 +1,175 @@
+#include "rr.h"
+
+namespace rr {
+  void Template::Init() {
+    ClassBuilder("Template").
+      defineMethod("Set", &Set);
+    ObjectTemplate::Init();
+    FunctionTemplate::Init();
+  }
+
+  VALUE Template::Set(int argc, VALUE argv[], VALUE self) {
+    VALUE name; VALUE value; VALUE attributes;
+    rb_scan_args(argc, argv, "21", &name, &value, &attributes);
+    Void(Template(self)->Set(*String(name), *Value(value), PropertyAttribute(attributes)));
+  }
+
+  void ObjectTemplate::Init() {
+    ClassBuilder("ObjectTemplate", "Template").
+      defineSingletonMethod("New", &New).
+      defineMethod("NewInstance", &NewInstance).
+      defineMethod("SetAccessor", &SetAccessor).
+      defineMethod("SetNamedPropertyHandler", &SetNamedPropertyHandler).
+      defineMethod("SetIndexedPropertyHandler", &SetIndexedPropertyHandler).
+      defineMethod("SetCallAsFunctionHandler", &SetCallAsFunctionHandler).
+      defineMethod("MarkAsUndetectable", &MarkAsUndetectable).
+      defineMethod("SetAccessCheckCallbacks", &SetAccessCheckCallbacks).
+      defineMethod("InternalFieldCount", &InternalFieldCount).
+      defineMethod("SetInternalFieldCount", &SetInternalFieldCount).
+      store(&Class);
+  }
+
+  VALUE ObjectTemplate::New(VALUE self) {
+    return ObjectTemplate(v8::ObjectTemplate::New());
+  }
+
+  VALUE ObjectTemplate::NewInstance(VALUE self) {
+    return Object(ObjectTemplate(self)->NewInstance());
+  }
+
+  VALUE ObjectTemplate::SetAccessor(int argc, VALUE argv[], VALUE self) {
+    VALUE name; VALUE get; VALUE set; VALUE data; VALUE settings; VALUE attribs;
+    rb_scan_args(argc, argv, "24", &name, &get, &set, &data, &settings, &attribs);
+    Accessor accessor(get, set, data);
+    ObjectTemplate(self)->SetAccessor(
+      String(name),
+      accessor.accessorGetter(),
+      accessor.accessorSetter(),
+      accessor,
+      AccessControl(settings),
+      PropertyAttribute(attribs)
+    );
+    Void();
+  }
+
+  VALUE ObjectTemplate::SetNamedPropertyHandler(int argc, VALUE argv[], VALUE self) {
+    VALUE get; VALUE set; VALUE query; VALUE deleter; VALUE enumerator; VALUE data;
+    rb_scan_args(argc, argv, "15", &get, &set, &query, &deleter, &enumerator, &data);
+    Accessor accessor(get,set,query,deleter,enumerator,data);
+    ObjectTemplate(self)->SetNamedPropertyHandler(
+      accessor.namedPropertyGetter(),
+      accessor.namedPropertySetter(),
+      accessor.namedPropertyQuery(),
+      accessor.namedPropertyDeleter(),
+      accessor.namedPropertyEnumerator(),
+      accessor
+    );
+    Void();
+  }
+
+   VALUE ObjectTemplate::SetIndexedPropertyHandler(int argc, VALUE argv[], VALUE self) {
+     VALUE get; VALUE set; VALUE query; VALUE deleter; VALUE enumerator; VALUE data;
+     rb_scan_args(argc, argv, "15", &get, &set, &query, &deleter, &enumerator, &data);
+     Accessor accessor(get,set,query,deleter,enumerator,data);
+     ObjectTemplate(self)->SetIndexedPropertyHandler(
+       accessor.indexedPropertyGetter(),
+       accessor.indexedPropertySetter(),
+       accessor.indexedPropertyQuery(),
+       accessor.indexedPropertyDeleter(),
+       accessor.indexedPropertyEnumerator(),
+       accessor
+     );
+     Void();
+   }
+
+   VALUE ObjectTemplate::SetCallAsFunctionHandler(int argc, VALUE argv[], VALUE self) {
+     VALUE callback; VALUE data;
+     rb_scan_args(argc, argv, "11", &callback, &data);
+     Invocation invocation(callback, data);
+     Void(ObjectTemplate(self)->SetCallAsFunctionHandler(invocation, invocation));
+   }
+
+   VALUE ObjectTemplate::MarkAsUndetectable(VALUE self) {
+     Void(ObjectTemplate(self)->MarkAsUndetectable());
+   }
+
+
+   VALUE ObjectTemplate::SetAccessCheckCallbacks(int argc, VALUE argv[], VALUE self) {
+     VALUE named_handler; VALUE indexed_handler; VALUE data; VALUE turned_on_by_default;
+     rb_scan_args(argc, argv, "22", &named_handler, &indexed_handler, &data, &turned_on_by_default);
+     return not_implemented("ObjectTemplate::SetAccessCheckCallbacks");
+   }
+
+   VALUE ObjectTemplate::InternalFieldCount(VALUE self) {
+     return INT2FIX(ObjectTemplate(self)->InternalFieldCount());
+   }
+
+   VALUE ObjectTemplate::SetInternalFieldCount(VALUE self, VALUE count) {
+     Void(ObjectTemplate(self)->SetInternalFieldCount(NUM2INT(count)));
+   }
+
+  void FunctionTemplate::Init() {
+    ClassBuilder("FunctionTemplate", "Template").
+      defineSingletonMethod("New", &New).
+      defineMethod("GetFunction", &GetFunction).
+      defineMethod("SetCallHandler", &SetCallHandler).
+      defineMethod("InstanceTemplate", &InstanceTemplate).
+      defineMethod("Inherit", &Inherit).
+      defineMethod("PrototypeTemplate", &PrototypeTemplate).
+      defineMethod("SetClassName", &SetClassName).
+      defineMethod("SetHiddenPrototype", &SetHiddenPrototype).
+      defineMethod("ReadOnlyPrototype", &ReadOnlyPrototype).
+      defineMethod("HasInstance", &HasInstance).
+      store(&Class);
+  }
+
+  VALUE FunctionTemplate::New(int argc, VALUE argv[], VALUE self) {
+    VALUE code; VALUE data; VALUE signature;
+    rb_scan_args(argc, argv, "03", &code, &data, &signature);
+    if (RTEST(code)) {
+      Invocation invocation(code, data);
+      return FunctionTemplate(v8::FunctionTemplate::New(invocation, invocation, Signature(signature)));
+    } else {
+      return FunctionTemplate(v8::FunctionTemplate::New());
+    }
+  }
+
+  VALUE FunctionTemplate::GetFunction(VALUE self) {
+    return Function(FunctionTemplate(self)->GetFunction());
+  }
+
+  VALUE FunctionTemplate::SetCallHandler(int argc, VALUE argv[], VALUE self) {
+    VALUE code; VALUE data;
+    rb_scan_args(argc, argv, "11", &code, &data);
+    Invocation invocation(code, data);
+    Void(FunctionTemplate(self)->SetCallHandler(invocation, invocation));
+  }
+
+  VALUE FunctionTemplate::InstanceTemplate(VALUE self) {
+    return ObjectTemplate(FunctionTemplate(self)->InstanceTemplate());
+  }
+
+  VALUE FunctionTemplate::Inherit(VALUE self, VALUE parent) {
+    Void(FunctionTemplate(self)->Inherit(FunctionTemplate(parent)));
+  }
+
+  VALUE FunctionTemplate::PrototypeTemplate(VALUE self) {
+    return ObjectTemplate(FunctionTemplate(self)->PrototypeTemplate());
+  }
+
+  VALUE FunctionTemplate::SetClassName(VALUE self, VALUE name) {
+    Void(FunctionTemplate(self)->SetClassName(String(name)));
+  }
+
+  VALUE FunctionTemplate::SetHiddenPrototype(VALUE self, VALUE value) {
+    Void(FunctionTemplate(self)->SetHiddenPrototype(Bool(value)));
+  }
+
+  VALUE FunctionTemplate::ReadOnlyPrototype(VALUE self) {
+    Void(FunctionTemplate(self)->ReadOnlyPrototype());
+  }
+
+  VALUE FunctionTemplate::HasInstance(VALUE self, VALUE object) {
+    return Bool(FunctionTemplate(self)->HasInstance(Value(object)));
+  }
+}

data/ext/v8/trycatch.cc

@@ -0,0 +1,87 @@
+#include "rr.h"
+
+namespace rr {
+  VALUE TryCatch::Class;
+
+  void TryCatch::Init() {
+    ClassBuilder("TryCatch").
+      defineMethod("HasCaught", &HasCaught).
+      defineMethod("CanContinue", &CanContinue).
+      defineMethod("ReThrow", &ReThrow).
+      defineMethod("Exception", &Exception).
+      defineMethod("StackTrace", &StackTrace).
+      defineMethod("Message", &Message).
+      defineMethod("Reset", &Reset).
+      defineMethod("SetVerbose", &SetVerbose).
+      defineMethod("SetCaptureMessage", &SetCaptureMessage).
+      store(&Class);
+    VALUE v8 = rb_define_module("V8");
+    VALUE c = rb_define_module_under(v8, "C");
+    rb_define_singleton_method(c, "TryCatch", (VALUE (*)(...))&doTryCatch, -1);
+  }
+
+  TryCatch::TryCatch(v8::TryCatch* impl) {
+    this->impl = impl;
+  }
+  TryCatch::TryCatch(VALUE value) {
+    Data_Get_Struct(value, class v8::TryCatch, impl);
+  }
+
+  TryCatch::operator VALUE() {
+    return Data_Wrap_Struct(Class, 0, 0, impl);
+  }
+
+  VALUE TryCatch::HasCaught(VALUE self) {
+    return Bool(TryCatch(self)->HasCaught());
+  }
+  VALUE TryCatch::CanContinue(VALUE self) {
+    return Bool(TryCatch(self)->CanContinue());
+  }
+  VALUE TryCatch::ReThrow(VALUE self) {
+    return Value(TryCatch(self)->ReThrow());
+  }
+  VALUE TryCatch::Exception(VALUE self) {
+    return Value(TryCatch(self)->Exception());
+  }
+  VALUE TryCatch::StackTrace(VALUE self) {
+    return Value(TryCatch(self)->StackTrace());
+  }
+  VALUE TryCatch::Message(VALUE self) {
+    return rr::Message(TryCatch(self)->Message());
+  }
+  VALUE TryCatch::Reset(VALUE self) {
+    Void(TryCatch(self)->Reset());
+  }
+  VALUE TryCatch::SetVerbose(VALUE self, VALUE value) {
+    Void(TryCatch(self)->SetVerbose(Bool(value)));
+  }
+  VALUE TryCatch::SetCaptureMessage(VALUE self, VALUE value) {
+    Void(TryCatch(self)->SetCaptureMessage(Bool(value)));
+  }
+
+  VALUE TryCatch::doTryCatch(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 TryCatch::setupAndCall(int* state, VALUE code) {
+    v8::TryCatch trycatch;
+    rb_iv_set(code, "_v8_trycatch", TryCatch(&trycatch));
+    VALUE result = rb_protect(&doCall, code, state);
+    rb_iv_set(code, "_v8_trycatch", Qnil);
+    return result;
+  }
+
+  VALUE TryCatch::doCall(VALUE code) {
+    return rb_funcall(code, rb_intern("call"), 1, rb_iv_get(code, "_v8_trycatch"));
+  }
+}