johnson 1.2.0 → 2.0.0.pre0

data/ext/tracemonkey/ruby_land_proxy.h

@@ -0,0 +1,38 @@
+#ifndef JOHNSON_TRACEMONKEY_RUBY_LAND_PROXY_H
+#define JOHNSON_TRACEMONKEY_RUBY_LAND_PROXY_H
+
+#include "tracemonkey.h"
+#include "runtime.h"
+
+#ifdef LEAK_ROOT_NAMES
+#define LEAKY_ROOT_NAME(static_string, dynamic_detail) \
+  ({\
+    const char * const _leaky_root__detail = (dynamic_detail);\
+    char * _leaky_root__leaked = malloc(strlen(static_string) + strlen(_leaky_root__detail) + 2);\
+    strcpy(_leaky_root__leaked, static_string);\
+    _leaky_root__leaked[strlen(static_string)] = ':';\
+    strcpy(_leaky_root__leaked + strlen(static_string) + 1, _leaky_root__detail);\
+    _leaky_root__leaked;\
+  })
+#else
+#define LEAKY_ROOT_NAME(static_string, dynamic_detail) (static_string)
+#endif
+
+DECLARE_RUBY_WRAPPER(make_ruby_land_proxy, JohnsonRuntime* runtime; jsval value; const char* root_name)
+
+DECLARE_RUBY_WRAPPER(rb_string_value, VALUE v)
+DECLARE_RUBY_WRAPPER(rb_string_value_cstr, VALUE v)
+
+typedef struct {
+  void* key;
+  JohnsonRuntime* runtime;
+  VALUE self;
+} RubyLandProxy;
+
+bool ruby_value_is_proxy(VALUE maybe_proxy);
+bool ruby_value_is_script_proxy(VALUE maybe_proxy);
+JSBool unwrap_ruby_land_proxy(JohnsonRuntime* runtime, VALUE proxy, jsval* retval);
+VALUE make_ruby_land_proxy(JohnsonRuntime* runtime, jsval value, const char* root_name);
+void init_Johnson_TraceMonkey_Proxy(VALUE tracemonkey);
+
+#endif

data/ext/tracemonkey/runtime.cc

@@ -0,0 +1,454 @@
+#include "runtime.h"
+#include "global.h"
+#include "split_global.h"
+#include "idhash.h"
+#include "conversions.h"
+#include "debugger.h"
+#include "jroot.h"
+#include "ruby_land_proxy.h"
+
+/*
+ * call-seq:
+ *   global()
+ *
+ * Returns the global object used for this context.
+ */
+static VALUE global(VALUE self)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  return convert_to_ruby(runtime, OBJECT_TO_JSVAL(runtime->global));
+}
+
+static VALUE new_split_global_outer(VALUE self)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  JSContext * context = johnson_get_current_context(runtime);
+
+  PREPARE_RUBY_JROOTS(context, 0);
+
+  JSObject* new_split_global_outer_object = johnson_create_split_global_outer_object(context);
+
+  JRETURN_RUBY(convert_to_ruby(runtime, OBJECT_TO_JSVAL(new_split_global_outer_object)));
+}
+
+static VALUE new_split_global_inner(VALUE self, VALUE ruby_outer)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  JSContext * context = johnson_get_current_context(runtime);
+
+  PREPARE_RUBY_JROOTS(context, 1);
+
+  jsval outer;
+
+  JCHECK(convert_to_js(runtime,ruby_outer,&outer));
+  JROOT(outer);
+
+  JSObject* new_inner_object = johnson_create_split_global_inner_object(context,JSVAL_TO_OBJECT(outer));
+  
+  JRETURN_RUBY(convert_to_ruby(runtime, OBJECT_TO_JSVAL(new_inner_object)));
+}
+
+static JSTrapStatus trap_handler( JSContext *context,
+                                  JSScript *UNUSED(script),
+                                  jsbytecode *UNUSED(pc),
+                                  jsval *UNUSED(rval),
+                                  void *block_closure )
+{
+  PREPARE_JROOTS(context, 0);
+  VALUE block = (VALUE)block_closure;
+  RB_FUNCALL_0T(block, rb_intern("call"), JSTrapStatus);
+  return JSTRAP_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *   clear_trap(script, line_num)
+ *
+ * Clear the trap previously set at +line_num+ of +script+.
+ */
+static VALUE clear_trap(VALUE self, VALUE script, VALUE linenum)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  jsval compiled_js;
+  if(!convert_to_js(runtime, script, &compiled_js))
+    rb_raise(rb_eRuntimeError, "Couldn't get compiled script.");
+
+  JSScript * js_script = (JSScript *)JS_GetPrivate(context, JSVAL_TO_OBJECT(compiled_js));
+
+  jsbytecode * pc = JS_LineNumberToPC(context, js_script, (uintN)NUM2INT(linenum));
+  JS_ClearTrap(context, js_script, pc, NULL, NULL);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   set_trap(script, line_num, block)
+ *
+ * Set a trap to invoke +block+ when execution of +script+ reaches
+ * +line_num+.
+ */
+static VALUE set_trap(VALUE self, VALUE script, VALUE linenum, VALUE block)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  jsval compiled_js;
+  if(!convert_to_js(runtime, script, &compiled_js))
+    rb_raise(rb_eRuntimeError, "Couldn't get compiled script.");
+  JSScript * js_script = (JSScript *)JS_GetPrivate(context, JSVAL_TO_OBJECT(compiled_js));
+
+  jsbytecode * pc = JS_LineNumberToPC(context, js_script, (uintN)NUM2INT(linenum));
+  return JS_SetTrap(context, js_script, pc, trap_handler, (void*)block) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   native_compile(script_string, filename, linenum)
+ *
+ * Compile the JavaScript code in +script_string+, marked as originating
+ * from +filename+ starting at +linenum+.
+ */
+
+static VALUE native_compile(VALUE self, VALUE script, VALUE filename, VALUE linenum, VALUE ruby_global)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  JohnsonContext * johnson_context = OUR_CONTEXT(context);
+
+  JSObject* global = runtime->global;
+
+  if ( ruby_global != Qnil ) {
+    jsval js_global;
+    convert_to_js(runtime, ruby_global, &js_global);
+    global = JSVAL_TO_OBJECT(js_global);
+  }
+
+  JSScript * compiled_js = JS_CompileScript(
+      context,
+      global,
+      StringValuePtr(script),
+      (size_t)StringValueLen(script),
+      StringValueCStr(filename),
+      (unsigned)NUM2INT(linenum)
+  );
+  if(compiled_js == NULL) {
+    if (JS_IsExceptionPending(context))
+    {
+      // If there's an exception pending here, it's a syntax error.
+      JS_GetPendingException(context, &johnson_context->ex);
+      JS_ClearPendingException(context);
+    }
+
+    if (johnson_context->ex) {
+      RAISE_JS_ERROR(self, johnson_context->ex);
+      return Qnil;
+    }
+
+    // TM returns NULL with no exception on OOM: see the disccusion near JS_ReportOutOfMemory in
+    // https://developer.mozilla.org/En/SpiderMonkey/JSAPI_User_Guide
+    
+    rb_raise(rb_eRuntimeError, "Tracemonkey reported out of memory.");
+  }
+
+  JSObject * script_object = JS_NewScriptObject(context, compiled_js);
+
+  return make_ruby_land_proxy(runtime, OBJECT_TO_JSVAL(script_object), LEAKY_ROOT_NAME("JSScriptProxy", RTEST(filename) ? RSTRING(rb_inspect(filename))->ptr : "(?)"));
+}
+
+/*
+ * call-seq:
+ *   evaluate_compiled_script(script_proxy)
+ *
+ * Evaluate previously compiled +script_proxy+, returning the final
+ * result from that script.
+ */
+static VALUE evaluate_compiled_script(VALUE self, VALUE compiled_script, VALUE ruby_scope)
+{
+  JohnsonRuntime* runtime;
+
+  if (!ruby_value_is_script_proxy(compiled_script))
+    rb_raise(rb_eArgError, "Compiled JS Script expected");
+
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext * context = johnson_get_current_context(runtime);
+  JohnsonContext * johnson_context = OUR_CONTEXT(context);
+
+  // clean things up first
+  johnson_context->ex = 0;
+  memset(johnson_context->msg, 0, MAX_EXCEPTION_MESSAGE_SIZE);
+
+  jsval compiled_js;
+  if(!convert_to_js(runtime, compiled_script, &compiled_js))
+    rb_raise(rb_eRuntimeError, "Script compilation failed");
+
+  JSScript * js_script = (JSScript *)JS_GetPrivate(context, JSVAL_TO_OBJECT(compiled_js));
+
+  JSObject* scope = runtime->global;
+
+  if ( ruby_scope != Qnil ) {
+    jsval js_scope;
+    convert_to_js(runtime, ruby_scope, &js_scope);
+    scope = JSVAL_TO_OBJECT(js_scope);
+  }
+
+  jsval js;
+  JSBool ok = JS_ExecuteScript(context, scope, js_script, &js);
+
+  if (!ok)
+  {
+    if (JS_IsExceptionPending(context))
+    {
+      // If there's an exception pending here, it's a syntax error.
+      JS_GetPendingException(context, &johnson_context->ex);
+      JS_ClearPendingException(context);
+    }
+
+    if (johnson_context->ex) {
+      RAISE_JS_ERROR(self, johnson_context->ex);
+      return Qnil;
+    }
+  }
+
+  return convert_to_ruby(runtime, js);
+}
+
+#ifdef JS_GC_ZEAL
+/*
+ * call-seq:
+ *   gc_zeal=(level)
+ *
+ * Sets the GC zeal.
+ *
+ * 0:: Normal
+ * 1:: Very Frequent
+ * 2:: Extremely Frequent
+ */
+static VALUE
+set_gc_zeal(VALUE self, VALUE zeal)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext* context = johnson_get_current_context(runtime);
+
+  JS_SetGCZeal(context, NUM2INT(zeal));
+
+  return zeal;
+}
+#endif
+
+/*
+ * call-seq:
+ *   gc()
+ *
+ * Manually initiates a TraceMonkey Garbage Collection run.
+ */
+static VALUE
+gc(VALUE self)
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  JSContext* context = johnson_get_current_context(runtime);
+
+  JS_GC(context);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   debugger=(debugger)
+ *
+ * Directs the runtime to install a full set of debug hooks, using the
+ * given +debugger+, which must be a Johnson::TraceMonkey::Debugger.
+ */
+static VALUE
+set_debugger(VALUE self, VALUE debugger)
+{
+  JohnsonRuntime* runtime;
+  JSDebugHooks* debug_hooks;
+
+  if (!ruby_value_is_debugger(debugger))
+    rb_raise(rb_eTypeError, "Expected Johnson::TraceMonkey::Debugger instance");
+
+  rb_iv_set(self, "@debugger", debugger);
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+  Data_Get_Struct(debugger, JSDebugHooks, debug_hooks);
+
+  JSContext * context = johnson_get_current_context(runtime);
+
+  JS_SetInterrupt(          runtime->js,
+                            debug_hooks->interruptHandler,
+                            debug_hooks->interruptHandlerData);
+  JS_SetNewScriptHook(      runtime->js,
+                            debug_hooks->newScriptHook,
+                            debug_hooks->newScriptHookData);
+  JS_SetDestroyScriptHook(  runtime->js,
+                            debug_hooks->destroyScriptHook,
+                            debug_hooks->destroyScriptHookData);
+  JS_SetDebuggerHandler(    runtime->js,
+                            debug_hooks->debuggerHandler,
+                            debug_hooks->debuggerHandlerData);
+  JS_SetSourceHandler(      runtime->js,
+                            debug_hooks->sourceHandler,
+                            debug_hooks->sourceHandlerData);
+  JS_SetExecuteHook(        runtime->js,
+                            debug_hooks->executeHook,
+                            debug_hooks->executeHookData);
+  JS_SetCallHook(           runtime->js,
+                            debug_hooks->callHook,
+                            debug_hooks->callHookData);
+  JS_SetObjectHook(         runtime->js,
+                            debug_hooks->objectHook,
+                            debug_hooks->objectHookData);
+  JS_SetThrowHook(          runtime->js,
+                            debug_hooks->throwHook,
+                            debug_hooks->throwHookData);
+  JS_SetDebugErrorHook(     runtime->js,
+                            debug_hooks->debugErrorHook,
+                            debug_hooks->debugErrorHookData);
+
+  JS_SetContextDebugHooks(context, debug_hooks);
+
+  return debugger;
+}
+
+JSBool gc_callback(JSContext *context, JSGCStatus status)
+{
+  if(status == JSGC_BEGIN) {
+    VALUE ruby_runtime = (VALUE)JS_GetRuntimePrivate(JS_GetRuntime(context));
+    if(rb_funcall(ruby_runtime, rb_intern("should_sm_gc?"), 0) == Qtrue)
+      return JS_TRUE;
+  }
+  return JS_FALSE;
+}
+
+/**
+ * call-seq:
+ *   initialize_native(options)
+ *
+ * Create the underlying TraceMonkey runtime. This must be called
+ * first, and only once. Called by +initialize+ by default.
+ */
+static VALUE
+initialize_native(VALUE self, VALUE UNUSED(options))
+{
+  JohnsonRuntime* runtime;
+  Data_Get_Struct(self, JohnsonRuntime, runtime);
+
+  if ((runtime->js = JS_NewRuntime(0x1000000))
+    && (runtime->jsids = create_id_hash())
+    && (runtime->rbids = create_id_hash()))
+  {
+    JS_SetRuntimePrivate(runtime->js, (void *)self);
+    JS_SetGCCallbackRT(runtime->js, gc_callback);
+
+    JSContext* context = johnson_get_current_context(runtime);
+
+    if ((runtime->global = JS_GetGlobalObject(context)))
+      return self;
+  }
+
+  // clean up after an initialization failure
+
+  if (runtime->rbids)
+    JS_HashTableDestroy(runtime->rbids);
+
+  if (runtime->jsids)
+    JS_HashTableDestroy(runtime->jsids);
+
+  if (runtime->js)
+    JS_DestroyRuntime(runtime->js);
+    
+  rb_raise(rb_eRuntimeError, "Couldn't initialize the runtime!");
+  return Qnil;
+}
+
+JSContext* johnson_get_current_context(JohnsonRuntime * runtime)
+{
+  JohnsonContext * context = NULL;
+  VALUE self = (VALUE)JS_GetRuntimePrivate(runtime->js);
+  Data_Get_Struct(rb_funcall(self, rb_intern("current_context"), 0), JohnsonContext, context);
+  return context->js;
+}
+
+static int proxy_cleanup_enumerator(JSHashEntry *entry, int /* i */, void* arg)
+{
+  JohnsonRuntime *runtime = (JohnsonRuntime*)(arg);
+  // entry->key is jsval; entry->value is RubyLandProxy*
+  RubyLandProxy * proxy = (RubyLandProxy *)(entry->value);
+  JS_RemoveRootRT(runtime->js, &(proxy->key));
+  proxy->runtime = NULL;
+  return 0;
+}
+
+static void deallocate(JohnsonRuntime* runtime)
+{
+  // our gc callback can create ruby objects, so disable it
+  JS_SetGCCallbackRT(runtime->js, NULL);
+
+  JSContext *context  = NULL;
+  JSContext *iterator = NULL;
+
+  while ((context = JS_ContextIterator(runtime->js, &iterator)) != NULL) {
+    JS_SetContextPrivate(iterator, NULL);
+    JS_DestroyContext(iterator);
+    iterator = NULL;
+  }
+
+  JSContext* cleanup = JS_NewContext(runtime->js, 8192L);
+  JS_HashTableEnumerateEntries(runtime->jsids, proxy_cleanup_enumerator, runtime);
+  JS_DestroyContext(cleanup);
+
+  JS_DestroyRuntime(runtime->js);
+  free(runtime);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  JohnsonRuntime* runtime = (JohnsonRuntime*)calloc(1L, sizeof(JohnsonRuntime));
+  return Data_Wrap_Struct(klass, 0, deallocate, runtime);
+}
+
+void init_Johnson_TraceMonkey_Runtime(VALUE tracemonkey)
+{
+  /* HACK:  These comments are *only* to make RDoc happy.
+  VALUE johnson = rb_define_module("Johnson");
+  VALUE tracemonkey = rb_define_module_under(johnson, "TraceMonkey");
+  */
+
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
+  VALUE johnson_runtime = rb_const_get(johnson, rb_intern("Runtime"));
+
+  VALUE klass = rb_define_class_under(tracemonkey, "Runtime", johnson_runtime);
+
+  rb_define_alloc_func(klass, allocate);
+  rb_define_private_method(klass, "initialize_native", (ruby_callback)initialize_native, 1);
+
+  rb_define_method(klass, "global", (ruby_callback)global, 0);
+
+  rb_define_method(klass, "new_split_global_outer", (ruby_callback)new_split_global_outer, 0);
+  rb_define_method(klass, "new_split_global_inner", (ruby_callback)new_split_global_inner, 1);
+
+  rb_define_method(klass, "debugger=", (ruby_callback)set_debugger, 1);
+  rb_define_method(klass, "gc", (ruby_callback)gc, 0);
+#ifdef JS_GC_ZEAL
+  rb_define_method(klass, "gc_zeal=", (ruby_callback)set_gc_zeal, 1);
+#endif
+  rb_define_method(klass, "evaluate_compiled_script", (ruby_callback)evaluate_compiled_script, 2);
+  rb_define_private_method(klass, "native_compile", (ruby_callback)native_compile, 4);
+  rb_define_method(klass, "set_trap", (ruby_callback)set_trap, 3);
+  rb_define_private_method(klass, "clear_trap", (ruby_callback)clear_trap, 2);
+}