therubyracer 0.6.3 → 0.7.0.pre

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_cxt.cpp

@@ -1,6 +1,8 @@
+#include "rr.h"
 #include "v8_cxt.h"
 #include "v8_msg.h"
 #include "v8_template.h"
+#include "v8_external.h"
 #include "converters.h"
 
 using namespace v8;
@@ -10,92 +12,87 @@ VALUE V8_C_Context;
 //TODO: rename everything to Context_
 //TODO: do the object init from within here
 
-VALUE v8_Context_New(int argc, VALUE *argv, VALUE self) {
-  HandleScope handles;
-  VALUE scope;
-  rb_scan_args(argc,argv, "01", &scope);
-  if (NIL_P(scope)) {
-    return V8_Ref_Create(self, Context::New());
-  } else {
-    Persistent<Context> context = Context::New(0, Racer_Create_V8_ObjectTemplate(scope));
-    Context::Scope enter(context);
-    context->Global()->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), External::Wrap((void *)scope));
-    VALUE ref = V8_Ref_Create(self, context, scope);
-    context.Dispose();
-    return ref;
-  }
-}
-
-VALUE v8_Context_InContext(VALUE self) {
-  return Context::InContext() ? Qtrue : Qfalse;  
-}
 
-VALUE v8_Context_GetCurrent(VALUE self) {
-  HandleScope handles;
-  if (Context::InContext()) {
-    Local<Context> current = Context::GetCurrent();
-    return V8_Ref_Create(self, current);    
-  } else {
-    return Qnil;
+namespace {
+  
+  Local<Context> unwrap(VALUE value) {
+    return V8_Ref_Get<Context>(value);
   }
-}
-
-VALUE v8_cxt_Global(VALUE self) {
-  HandleScope handles;
-  Local<Context> cxt = V8_Ref_Get<Context>(self);
-  Local<Value> global = *cxt->Global();
-  return V82RB(global);
-}
-
-VALUE v8_cxt_open(VALUE self) {
-  HandleScope handles;
-  Local<Context> cxt = V8_Ref_Get<Context>(self);
-  Context::Scope enter(cxt);
-  if (rb_block_given_p()) {
-    return rb_yield(self);
-  } else {
-    return Qnil;
+  
+  //TODO: make this scriptable and less static
+  VALUE New(int argc, VALUE *argv, VALUE self) {
+    HandleScope handles;
+    VALUE scope;
+    rb_scan_args(argc,argv, "01", &scope);
+    if (NIL_P(scope)) {
+      Persistent<Context> cxt(Context::New());
+      VALUE ref = V8_Ref_Create(self, cxt);
+      cxt.Dispose();
+      return ref;
+    } else {
+      Persistent<Context> context = Context::New(0, Racer_Create_V8_ObjectTemplate(scope));
+      Context::Scope enter(context);
+      context->Global()->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), rr_v8_external_create(scope));
+      VALUE ref = V8_Ref_Create(self, context, scope);
+      context.Dispose();
+      return ref;
+    }
   }
-}
 
-VALUE Racer_Error_Message(TryCatch& exception) {
-  VALUE msg = V8_Ref_Create(V8_C_Message, exception.Message());
-  Local<Value> stack = exception.StackTrace();
-  if (!stack.IsEmpty()) {
-    rb_iv_set(msg,"@stack",V82RB(stack));    
+  VALUE InContext(VALUE self) {
+    return Context::InContext() ? Qtrue : Qfalse;  
+  }
+  
+  VALUE GetEntered(VALUE self) {
+    HandleScope handles;
+    if (Context::InContext()) {
+      Local<Context> current = Context::GetEntered();
+      return V8_Ref_Create(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;
+    }
   }
-  return msg;  
 }
 
-VALUE v8_cxt_eval(VALUE self, VALUE source, VALUE filename) {
-  HandleScope handles;
-  TryCatch exceptions;
-  Local<Context> cxt = V8_Ref_Get<Context>(self);
-  Context::Scope enter(cxt);
-  Local<Value> source_str = RB2V8(source);
-  Local<Value> source_name = RTEST(filename) ? RB2V8(filename) : *String::New("<eval>");
-  Local<Script> script = Script::Compile(source_str->ToString(), source_name);
-	if (exceptions.HasCaught()) {	  
-    return Racer_Error_Message(exceptions);
-	} 
-  Local<Value> result = script->Run();
-  if (exceptions.HasCaught()) {
-    return Racer_Error_Message(exceptions);
-  } else {
-    return V82RB(result);
-  }
+void rr_init_cxt() {
+  VALUE ContextClass = V8_C_Context = rr_define_class("Context");
+  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);
 }
 
-VALUE v8_cxt_eql(VALUE self, VALUE other) {
-  HandleScope handles;
-  if (RTEST(CLASS_OF(other) != V8_C_Context)) {
-    return Qnil;
-  } else {
-    Local<Context> cxt = V8_Ref_Get<Context>(self);
-    Local<Context> that = V8_Ref_Get<Context>(other);
-    return cxt == that ? Qtrue : Qfalse;
-  }
-  return Qnil;
+VALUE rr_reflect_v8_context(Handle<Context> value) {
+  return V8_Ref_Create(V8_C_Context, value);
 }
 
 

data/ext/v8/v8_cxt.h

@@ -5,16 +5,9 @@
 #include "v8.h"
 #include "v8_ref.h"
 
-extern VALUE rb_cV8;
-extern VALUE V8_C_Object;
 extern VALUE V8_C_Context;
 
-VALUE v8_Context_New(int argc, VALUE *argv, VALUE self);
-VALUE v8_Context_InContext(VALUE self);
-VALUE v8_Context_GetCurrent(VALUE self);
-VALUE v8_cxt_Global(VALUE self);
-VALUE v8_cxt_open(VALUE self);
-VALUE v8_cxt_eval(VALUE self, VALUE source, VALUE filename);
-VALUE v8_cxt_eql(VALUE self, VALUE other);
+void rr_init_cxt();
+VALUE rr_reflect_v8_context(v8::Handle<v8::Context> value);
 
 #endif

data/ext/v8/v8_date.cpp

@@ -0,0 +1,26 @@
+#include "rr.h"
+#include "v8_date.h"
+#include "v8_value.h"
+#include "v8_ref.h"
+
+using namespace v8;
+
+namespace {
+  
+  VALUE DateClass;
+  
+  VALUE New(VALUE self, VALUE time) {
+    HandleScope scope;
+    return rr_v8_ref_create(self, Date::New(NUM2DBL(rb_funcall(time, rb_intern("to_f"), 0))));
+  }
+}
+
+void rr_init_v8_date() {
+  DateClass = rr_define_class("Date", rr_cV8_C_Value);
+  rr_define_singleton_method(DateClass, "New", New, 1);
+}
+
+VALUE rr_reflect_v8_date(Handle<Value> value) {
+  Local<Date> date(Date::Cast(*value));
+  return rr_v8_ref_create(DateClass, date);
+}

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_exception.cpp

@@ -0,0 +1,55 @@
+#include "v8_exception.h"
+#include "rr.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()));
+  }
+}
+
+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);
+  
+  v8::V8::SetFatalErrorHandler(fatal);
+  signal(SIGSEGV, segfault);
+}

data/ext/v8/v8_exception.h

@@ -0,0 +1,6 @@
+#ifndef _RR_V8_EXCEPTION_
+#define _RR_V8_EXCEPTION_
+
+void rr_init_v8_exception();
+
+#endif

data/ext/v8/v8_external.cpp

@@ -0,0 +1,50 @@
+#include "v8_external.h"
+#include "rr.h"
+#include "v8_ref.h"
+using namespace v8;
+
+namespace {
+  VALUE ExternalClass;
+  VALUE references;
+  VALUE _Value(VALUE self) {
+    HandleScope scope;
+    return (VALUE)V8_Ref_Get<External>(self)->Value();
+  }
+  VALUE Wrap(VALUE rbclass, VALUE value) {
+    HandleScope scope;
+    return rr_v8_ref_create(rbclass, rr_v8_external_create(value));
+  }
+  VALUE Unwrap(VALUE self, VALUE value) {
+    if (rb_obj_is_kind_of(value, self)) {
+      return _Value(value);
+    } else {
+      rb_raise(rb_eArgError, "cannot unwrap %s. It is not a kind of %s", RSTRING_PTR(rb_class_name(rb_class_of(value))), RSTRING_PTR(rb_class_name(self)));
+      return Qnil;
+    }
+  }
+
+  void GCWeakReferenceCallback(Persistent<Value> object, void* parameter) {
+    // printf("V8 GC!!!!\n");
+    Local<External> external(External::Cast(*object));
+    rb_hash_delete(references, rb_obj_id((VALUE)external->Value()));
+    // V8::AdjustAmountOfExternalAllocatedMemory(-100000000);
+  }
+}
+
+void rr_init_v8_external() {
+  ExternalClass = rr_define_class("External");
+  references = rb_hash_new();
+  rb_define_const(ExternalClass, "OBJECTS_REFERENCED_FROM_WITHIN_V8", references);
+  rr_define_singleton_method(ExternalClass, "Wrap", Wrap, 1);
+  rr_define_singleton_method(ExternalClass, "Unwrap", Unwrap, 1);
+  rr_define_method(ExternalClass, "Value", _Value, 0);
+}
+
+Handle<Value> rr_v8_external_create(VALUE value) {
+  rb_hash_aset(references, rb_obj_id(value), value);
+  Local<Value> external(External::Wrap((void *)value));
+  Persistent<Value> record = Persistent<Value>::New(external);
+  // V8::AdjustAmountOfExternalAllocatedMemory(100000000);
+  record.MakeWeak(NULL, GCWeakReferenceCallback);
+  return 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();
+v8::Handle<v8::Value> rr_v8_external_create(VALUE value);
+#endif

data/ext/v8/v8_func.cpp

@@ -1,28 +1,86 @@
 
 #include "converters.h"
 #include "v8_func.h"
+#include "v8_obj.h"
 
 using namespace v8;
 
-VALUE V8_C_Function;
+VALUE rr_cV8_C_Function;
 
-VALUE V8_Wrap_Function(Handle<Function> f) {
-  return V8_Ref_Create(V8_C_Function, f);
+namespace {
+  VALUE FunctionClass;
+  
+  Local<Function> unwrap(VALUE value) {
+    return V8_Ref_Get<Function>(value);
+  }  
+  VALUE Call(int argc, VALUE *argv, VALUE self) {
+    HandleScope handles;
+    VALUE recv; VALUE f_argv;
+    rb_scan_args(argc, argv, "1*", &recv, &f_argv);
+    
+    Local<Function> function = V8_Ref_Get<Function>(self);
+    Local<Object> thisObject;
+    if (NIL_P(recv)) {
+      if (Context::InContext()) {
+        thisObject = Context::GetEntered()->Global();
+      } else {
+        Persistent<Context> cxt = Context::New();
+        Context::Scope scope(cxt);
+        thisObject = Object::New();
+        cxt.Dispose();
+      }
+    } else {
+      if (!Context::InContext()) {
+        Persistent<Context> cxt = Context::New();
+        cxt->Enter();
+        thisObject = rr_rb2v8(recv)->ToObject();
+        cxt->Exit();
+      } else {
+        thisObject = rr_rb2v8(recv)->ToObject();
+      }
+    }
+    int f_argc = argc - 1;
+    Local<Value> arguments[f_argc];
+    for (int i = 0; i < f_argc; i++) {
+      arguments[i] = *rr_rb2v8(rb_ary_entry(f_argv, i));
+    }
+    Local<Value> result = function->Call(thisObject, f_argc, arguments);
+    return rr_v82rb(result);
+  }
+  VALUE NewInstance(int argc, VALUE *argv, VALUE self) {
+    HandleScope handles;
+    VALUE f_argv;
+    rb_scan_args(argc, argv, "*", &f_argv);
+    Local<Function> function = V8_Ref_Get<Function>(self);
+    Local<Value> arguments[argc];
+    for (int i = 0; i < argc; i++) {
+      arguments[i] = *rr_rb2v8(rb_ary_entry(f_argv, i));
+    }
+    return rr_v82rb(function->NewInstance(argc, arguments));
+  }
+  VALUE GetName(VALUE self) {
+    return rr_v82rb(unwrap(self)->GetName());
+  }
+  VALUE SetName(VALUE self, VALUE name) {
+    Local<String> str = V8_Ref_Get<String>(name);
+    unwrap(self)->SetName(str);
+    return Qnil;
+  }  
+  // VALUE GetScriptOrigin(VALUE self) {
+  //   return rr_v82rb(unwrap(self)->GetScriptOrigin());
+  // }
 }
 
+void rr_init_func() {
+  FunctionClass = rr_define_class("Function", rr_cV8_C_Object);
+  rr_define_method(FunctionClass, "Call", Call, -1);
+  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 v8_C_Function_Call(int argc, VALUE *argv, VALUE self) {
-  HandleScope handles;
-  VALUE recv; VALUE f_argv;
-  rb_scan_args(argc, argv, "1*", &recv, &f_argv);
-
-  Local<Function> function = V8_Ref_Get<Function>(self);
-  Local<Object> thisObject(Object::Cast(*RB2V8(recv)));
-  int f_argc = argc - 1;
-  Local<Value> arguments[f_argc];
-  for (int i = 0; i < f_argc; i++) {
-    arguments[i] = RB2V8(rb_ary_entry(f_argv,i));
-  }
-  Local<Value> result = function->Call(thisObject, f_argc, arguments);
-  return V82RB(result);
-}
+VALUE rr_reflect_v8_function(Handle<Value> value) {
+  Local<Function> function(Function::Cast(*value));
+  return V8_Ref_Create(FunctionClass, function);
+}