johnson 1.1.0

data/ext/spidermonkey/conversions.c

@@ -0,0 +1,320 @@
+#include "conversions.h"
+#include "js_land_proxy.h"
+#include "ruby_land_proxy.h"
+
+DEFINE_RUBY_WRAPPER(convert_to_ruby, convert_to_ruby, ARGLIST2(runtime, js_value))
+
+DECLARE_RUBY_WRAPPER(rb_funcall_0, VALUE obj; ID sym; int argc)
+DEFINE_RUBY_WRAPPER(rb_funcall_0, rb_funcall, ARGLIST3(obj, sym, argc))
+
+DECLARE_RUBY_WRAPPER(rb_funcall_2, VALUE obj; ID sym; int argc; VALUE a; VALUE b)
+DEFINE_RUBY_WRAPPER(rb_funcall_2, rb_funcall, ARGLIST5(obj, sym, argc, a, b))
+
+static JSBool convert_float_or_bignum_to_js(JohnsonRuntime* runtime, VALUE float_or_bignum, jsval* retval)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  return JS_NewDoubleValue(context, NUM2DBL(float_or_bignum), retval);
+}
+
+static JSBool convert_symbol_to_js(JohnsonRuntime* runtime, VALUE symbol, jsval* retval)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_JROOTS(context, 2);
+
+  VALUE to_s = CALL_RUBY_WRAPPER(rb_funcall_0, symbol, rb_intern("to_s"), 0);
+  jsval name = STRING_TO_JSVAL(JS_NewStringCopyN(context, StringValuePtr(to_s), (size_t) StringValueLen(to_s)));
+
+  JROOT(name);
+
+  // calls Johnson.symbolize(name) in JS-land. See lib/prelude.js
+
+  jsval nsJohnson;    
+  JCHECK(JS_GetProperty(context, runtime->global, "Johnson", &nsJohnson));
+  JROOT(nsJohnson);
+
+  JCHECK(JS_CallFunctionName(context, JSVAL_TO_OBJECT(nsJohnson), "symbolize", 1, &name, retval));
+
+  JRETURN;
+}
+
+static JSBool convert_regexp_to_js(JohnsonRuntime* runtime, VALUE regexp, jsval* retval)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_JROOTS(context, 0);
+  VALUE source = rb_funcall(regexp, rb_intern("source"), 0);
+  jsint options = (jsint)(NUM2INT(rb_funcall(regexp, rb_intern("options"), 0)));
+
+  JSObject* obj = JS_NewRegExpObject(context,
+        StringValuePtr(source),
+        (size_t) StringValueLen(source),
+        (unsigned) options);
+
+  JCHECK(obj);
+  *retval = OBJECT_TO_JSVAL(obj);
+  JRETURN;
+}
+
+JSBool convert_to_js(JohnsonRuntime* runtime, VALUE ruby, jsval* retval)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_JROOTS(context, 0);
+  switch(TYPE(ruby))
+  {
+    case T_NONE:
+      JERROR("I don't know how to handle T_NONE.");
+      JRETURN;
+
+    case T_ICLASS:
+      JERROR("I don't know how to handle T_ICLASS.");
+      JRETURN;
+
+    case T_MATCH:
+      JERROR("I don't know how to handle T_MATCH.");
+      JRETURN;
+
+    case T_BLKTAG:
+      JERROR("I don't know how to handle T_BLKTAG.");
+      JRETURN;
+
+    case T_NODE:
+      JERROR("I don't know how to handle T_NODE | T_MASK.");
+      JRETURN;
+
+    case T_UNDEF:
+      JERROR("I don't know how to handle T_UNDEF.");
+      JRETURN;
+
+    case T_VARMAP:
+      JERROR("I don't know how to handle T_VARMAP.");
+      JRETURN;
+
+    case T_NIL:
+      *retval = JSVAL_NULL;
+      JRETURN;
+
+    case T_TRUE:
+      *retval = JSVAL_TRUE;
+      JRETURN;
+    
+    case T_FALSE:
+      *retval = JSVAL_FALSE;
+      JRETURN;
+
+    case T_STRING:
+      {
+        JSString* str = JS_NewStringCopyN(context, StringValuePtr(ruby), (size_t) StringValueLen(ruby));
+        JCHECK(str);
+        *retval = STRING_TO_JSVAL(str);
+        JRETURN;
+      }
+
+    case T_FIXNUM:
+      {
+        long val = NUM2LONG(ruby);
+        if (val >= JSVAL_INT_MIN && val <= JSVAL_INT_MAX)
+        {
+          *retval = INT_TO_JSVAL((jsint)val);
+          JRETURN;
+        }
+      }
+
+    case T_FLOAT:
+    case T_BIGNUM:
+      JCHECK(convert_float_or_bignum_to_js(runtime, ruby, retval));
+      JRETURN;
+
+    case T_SYMBOL:
+      JCHECK(convert_symbol_to_js(runtime, ruby, retval));
+      JRETURN;
+
+    case T_CLASS:
+    case T_ARRAY:
+    case T_HASH:
+    case T_MODULE:
+    case T_FILE:
+    case T_STRUCT:
+    case T_OBJECT:
+      JCHECK(make_js_land_proxy(runtime, ruby, retval));
+      JRETURN;
+      
+    case T_REGEXP:
+      JCHECK(convert_regexp_to_js(runtime, ruby, retval));
+      JRETURN;
+
+    case T_DATA: // HEY! keep T_DATA last for fall-through
+      if (ruby_value_is_proxy(ruby))
+        JCHECK(unwrap_ruby_land_proxy(runtime, ruby, retval));
+      else // If we can't identify the object, just wrap it
+        JCHECK(make_js_land_proxy(runtime, ruby, retval));
+      JRETURN;
+
+    default:
+      JERROR("unknown ruby type in switch");
+  }
+  
+  *retval = JSVAL_NULL;
+  JRETURN;
+}
+
+VALUE convert_js_string_to_ruby(JohnsonRuntime* runtime, JSString* str)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_RUBY_JROOTS(context, 1);
+  JROOT(str);
+  char* bytes = JS_GetStringBytes(str);
+  JCHECK(bytes);
+  JRETURN_RUBY(rb_str_new(bytes, (signed long)JS_GetStringLength(str)));
+}
+
+static VALUE convert_regexp_to_ruby(JohnsonRuntime* runtime, jsval regexp)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_RUBY_JROOTS(context, 1);
+  JROOT(regexp);
+  JSRegExp* re = (JSRegExp*)JS_GetPrivate(context, JSVAL_TO_OBJECT(regexp));
+
+  JRETURN_RUBY(CALL_RUBY_WRAPPER(rb_funcall_2, rb_cRegexp, rb_intern("new"), 2,
+    convert_js_string_to_ruby(runtime, re->source),
+    INT2NUM((long)re->flags)));
+}
+
+static bool js_value_is_regexp(JohnsonRuntime* runtime, jsval maybe_regexp)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_RUBY_JROOTS(context, 1);
+  JROOT(maybe_regexp);
+  JSBool result = JS_InstanceOf(context, JSVAL_TO_OBJECT(maybe_regexp), &js_RegExpClass, NULL);
+  JRETURN_RUBY(result ? true : false);
+}
+
+static bool js_value_is_symbol(JohnsonRuntime* runtime, jsval maybe_symbol)
+{
+  jsval nsJohnson, cSymbol;
+  JSContext * context = johnson_get_current_context(runtime);
+
+  PREPARE_RUBY_JROOTS(context, 3);
+  JROOT(maybe_symbol);
+
+  JCHECK(JS_GetProperty(context, runtime->global, "Johnson", &nsJohnson));
+  if (!JSVAL_IS_OBJECT(nsJohnson))
+    JERROR("Unable to retrieve Johnson from JSLand");
+  JROOT(nsJohnson);
+
+  JCHECK(JS_GetProperty(context, JSVAL_TO_OBJECT(nsJohnson), "Symbol", &cSymbol));
+  if (!JSVAL_IS_OBJECT(cSymbol))
+    JERROR("Unable to retrieve Johnson.Symbol from JSLand");
+  JROOT(cSymbol);
+
+  JSBool is_a_symbol;
+  JCHECK(JS_HasInstance(context, JSVAL_TO_OBJECT(cSymbol), maybe_symbol, &is_a_symbol));
+
+  JRETURN_RUBY(is_a_symbol != JS_FALSE);
+}
+
+VALUE convert_to_ruby(JohnsonRuntime* runtime, jsval js)
+{
+  if (JSVAL_NULL == js) return Qnil;
+
+  JSContext * context = johnson_get_current_context(runtime);
+
+  PREPARE_RUBY_JROOTS(context, 1);
+  JROOT(js);
+  
+  switch (JS_TypeOfValue(context, js))
+  {
+    case JSTYPE_VOID:
+      JRETURN_RUBY(Qnil);
+      
+    case JSTYPE_FUNCTION: 
+    case JSTYPE_OBJECT:
+      if (OBJECT_TO_JSVAL(runtime->global) == js)
+        // global gets special treatment, since the Prelude might not be loaded
+        JRETURN_RUBY(make_ruby_land_proxy(runtime, js, "GlobalProxy"));
+      
+      // this conditional requires the Prelude
+      if (js_value_is_symbol(runtime, js))
+        JRETURN_RUBY(ID2SYM(rb_intern(JS_GetStringBytes(JS_ValueToString(context, js)))));
+    
+      if (js_value_is_proxy(runtime, js))
+        JRETURN_RUBY(unwrap_js_land_proxy(runtime, js));
+
+      if (js_value_is_regexp(runtime, js))
+        JRETURN_RUBY(convert_regexp_to_ruby(runtime, js));
+    
+      JRETURN_RUBY(make_ruby_land_proxy(runtime, js, "RubyLandProxy"));
+        
+    case JSTYPE_BOOLEAN:
+      JRETURN_RUBY(JSVAL_TRUE == js ? Qtrue : Qfalse);
+      
+    case JSTYPE_STRING:
+      JRETURN_RUBY(convert_js_string_to_ruby(runtime, JSVAL_TO_STRING(js)));
+      
+    case JSTYPE_NUMBER:
+      if (JSVAL_IS_INT(js)) JRETURN_RUBY(INT2FIX(JSVAL_TO_INT(js)));
+      else JRETURN_RUBY(rb_float_new(*JSVAL_TO_DOUBLE(js)));
+
+    default:
+      JERROR("unknown js type in switch");
+  }
+  
+  JRETURN_RUBY(Qnil);
+}
+
+NORETURN(void) raise_js_error_in_ruby(JohnsonRuntime* runtime)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  JohnsonContext * johnson_context = OUR_CONTEXT(context);
+  if (JS_IsExceptionPending(context))
+  {
+    assert(JS_GetPendingException(context, &(johnson_context->ex)));
+    JS_AddNamedRoot(context, &(johnson_context->ex), "raise_js_error_in_ruby");
+    JS_ClearPendingException(context);
+    JS_RemoveRoot(context, &(johnson_context->ex));
+  }
+
+  VALUE ruby_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js);
+  if (johnson_context->ex)
+    RAISE_JS_ERROR(ruby_runtime, johnson_context->ex);
+
+  // FIXME: I don't think this is needed, it should
+  // be done on the Ruby side.
+  if (!johnson_context->msg)
+    rb_raise(rb_eRuntimeError, "Unknown JavaScriptError");
+
+  // FIXME: I don't think this can ever happen....
+  rb_raise(rb_eRuntimeError, johnson_context->msg);
+}
+
+#define TAG_RAISE 0x6
+#define TAG_THROW 0x7
+
+JSBool report_ruby_error_in_js(JohnsonRuntime* runtime, int state, VALUE old_errinfo)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  assert(state);
+  switch (state)
+  {
+    case TAG_RAISE:
+      {
+        VALUE local_error = ruby_errinfo;
+        jsval js_err;
+        ruby_errinfo = old_errinfo;
+        if (!convert_to_js(runtime, local_error, &js_err))
+          return JS_FALSE;
+        JS_SetPendingException(context, js_err);
+        return JS_FALSE;
+      }
+
+    case TAG_THROW:
+      // FIXME: This should be propagated to JS... as an exception?
+
+    default:
+      {
+        JSString* str = JS_NewStringCopyZ(context, "Unexpected longjmp from ruby!");
+        if (str)
+          JS_SetPendingException(context, STRING_TO_JSVAL(str));
+        return JS_FALSE;
+      }
+  }
+}
+

data/ext/spidermonkey/conversions.h

@@ -0,0 +1,18 @@
+#ifndef JOHNSON_SPIDERMONKEY_CONVERSIONS_H
+#define JOHNSON_SPIDERMONKEY_CONVERSIONS_H
+
+#include "spidermonkey.h"
+#include "context.h"
+#include "runtime.h"
+
+DECLARE_RUBY_WRAPPER(convert_to_ruby, JohnsonRuntime* runtime; jsval js_value)
+#define CONVERT_TO_RUBY(runtime, js) CALL_RUBY_WRAPPER(convert_to_ruby, runtime, js)
+
+JSBool convert_to_js(JohnsonRuntime* runtime, VALUE ruby, jsval* retval);
+VALUE convert_to_ruby(JohnsonRuntime* runtime, jsval js);
+VALUE convert_js_string_to_ruby(JohnsonRuntime* runtime, JSString* str);
+
+NORETURN(void raise_js_error_in_ruby(JohnsonRuntime* runtime));
+JSBool report_ruby_error_in_js(JohnsonRuntime* runtime, int state, VALUE old_errinfo);
+
+#endif

data/ext/spidermonkey/debugger.c

@@ -0,0 +1,226 @@
+#include "debugger.h"
+#include "context.h"
+#include "conversions.h"
+#include "immutable_node.h"
+
+/*
+ * call-seq:
+ *   frame_pc(context, frame)
+ *
+ * Get the frame parse context
+ */
+static VALUE frame_pc(VALUE UNUSED(self), VALUE context, VALUE frame)
+{
+  JSContext * js = NULL;
+  JSStackFrame * fp = NULL;
+  Data_Get_Struct(context, JSContext, js);
+  Data_Get_Struct(frame, JSStackFrame, fp);
+  return Data_Wrap_Struct(rb_cObject, NULL, NULL, JS_GetFramePC(js, fp));
+}
+
+/*
+ * call-seq:
+ *   line_number(context, script, bytecode)
+ *
+ * Get the line number of the +bytecode+ given +context+ and +script+
+ */
+static VALUE line_number(VALUE UNUSED(self), VALUE context, VALUE script, VALUE bytecode)
+{
+  JSContext * js        = NULL;
+  JSScript * js_script     = NULL;
+  jsbytecode * js_bytecode = NULL;
+
+  Data_Get_Struct(context, JSContext, js);
+  Data_Get_Struct(script, JSScript, js_script);
+  Data_Get_Struct(bytecode, jsbytecode, js_bytecode);
+
+  return INT2NUM((long)JS_PCToLineNumber(js, js_script, js_bytecode));
+}
+
+/*
+ * call-seq:
+ *   file_name(context, script)
+ *
+ * Get the file name of the +script+ given +context+
+ */
+static VALUE file_name(VALUE UNUSED(self), VALUE context, VALUE script)
+{
+  JSContext * js        = NULL;
+  JSScript * js_script     = NULL;
+
+  Data_Get_Struct(context, JSContext, js);
+  Data_Get_Struct(script, JSScript, js_script);
+
+  return rb_str_new2(JS_GetScriptFilename(js, js_script));
+}
+
+static JSTrapStatus interrupt_handler(JSContext *js, JSScript *script,
+                                      jsbytecode *pc, jsval *UNUSED(rval), void *rb)
+{
+  assert(js);
+  assert(rb);
+  assert(pc);
+
+  VALUE self = (VALUE)rb;
+  VALUE rb_cx     = Data_Wrap_Struct(rb_cObject, NULL, NULL, js);
+  VALUE rb_script = Data_Wrap_Struct(rb_cObject, NULL, NULL, script);
+  VALUE rb_pc     = Data_Wrap_Struct(rb_cObject, NULL, NULL, pc);
+
+  return NUM2INT(rb_funcall(self, rb_intern("interrupt_handler"), 3,
+        rb_cx,
+        rb_script,
+        rb_pc
+        ));
+}
+
+static void new_script_hook(JSContext *UNUSED(js),
+                            const char *filename,
+                            uintN lineno,
+                            JSScript *UNUSED(script),
+                            JSFunction *UNUSED(fun),
+                            void *rb)
+{
+  VALUE self = (VALUE)rb;
+  VALUE rb_filename = rb_str_new2(filename);
+  VALUE rb_linenum  = UINT2NUM((unsigned long)lineno);
+
+  /* FIXME: Pass the rest of this crap to the debugger? */
+  rb_funcall(self, rb_intern("new_script_hook"), 2, rb_filename, rb_linenum);
+}
+
+static void destroy_script_hook(JSContext *UNUSED(js),
+                                JSScript *UNUSED(script),
+                                void *rb)
+{
+  VALUE self = (VALUE)rb;
+  rb_funcall(self, rb_intern("destroy_script_hook"), 0);
+}
+
+static JSTrapStatus debugger_handler(JSContext *js, JSScript *script,
+                                     jsbytecode *pc, jsval *UNUSED(rval), void *rb)
+{
+  assert(js);
+  assert(rb);
+  assert(pc);
+
+  VALUE self = (VALUE)rb;
+  VALUE rb_cx     = Data_Wrap_Struct(rb_cObject, NULL, NULL, js);
+  VALUE rb_script = Data_Wrap_Struct(rb_cObject, NULL, NULL, script);
+  VALUE rb_pc     = Data_Wrap_Struct(rb_cObject, NULL, NULL, pc);
+
+  return NUM2INT(rb_funcall(self, rb_intern("debugger_handler"), 3,
+        rb_cx,
+        rb_script,
+        rb_pc
+        ));
+}
+
+static void source_handler(const char *filename, uintN lineno,
+                           jschar *str, size_t length,
+                           void **UNUSED(listenerTSData), void *rb)
+{
+  VALUE self = (VALUE)rb;
+  VALUE rb_filename = rb_str_new2(filename);
+  VALUE rb_lineno   = ULONG2NUM((unsigned long)lineno);
+  VALUE rb_str      = rb_str_new((char *)str, (signed long)(length * sizeof(jschar)));
+
+  rb_funcall(self, rb_intern("source_handler"), 3, rb_filename, rb_lineno, rb_str);
+}
+
+static void * execute_hook(JSContext *js, JSStackFrame *fp, JSBool before,
+                           JSBool *ok, void *rb)
+{
+  VALUE self = (VALUE)rb;
+  VALUE rb_before = JS_TRUE == before ? Qtrue : Qfalse;
+  VALUE rb_ok     = ok ? Qtrue : Qfalse;
+  VALUE rb_js     = Data_Wrap_Struct(rb_cObject, NULL, NULL, (void *)js);
+  VALUE rb_fp     = Data_Wrap_Struct(rb_cObject, NULL, NULL, (void *)fp);
+
+  rb_funcall(self, rb_intern("execute_hook"), 4, rb_js,rb_fp,rb_before,rb_ok);
+  return rb;
+}
+
+static void * call_hook(JSContext *UNUSED(js), JSStackFrame *UNUSED(fp), JSBool before,
+                           JSBool *ok, void *rb)
+{
+  VALUE self = (VALUE)rb;
+  VALUE rb_before = before ? Qtrue : Qfalse;
+  VALUE rb_ok     = ok ? Qtrue : Qfalse;
+
+  rb_funcall(self, rb_intern("call_hook"), 2, rb_before, rb_ok);
+  return rb;
+}
+
+static void object_hook(JSContext *js, JSObject *obj, JSBool isNew, void *rb)
+{
+  assert(rb);
+  assert(js);
+  assert(obj);
+  VALUE self = (VALUE)rb;
+
+  VALUE rb_is_new = isNew ? Qtrue : Qfalse;
+
+  rb_funcall(self, rb_intern("object_hook"), 1, rb_is_new);
+}
+
+static JSTrapStatus throw_hook(JSContext *UNUSED(js), JSScript *UNUSED(script),
+                               jsbytecode *pc, jsval *UNUSED(rval), void *rb)
+{
+  VALUE self = (VALUE)rb;
+  VALUE rb_bytecode = jsop_to_symbol(*pc);
+  return NUM2INT(rb_funcall(self, rb_intern("throw_hook"), 1, rb_bytecode));
+}
+
+static JSBool debug_error_hook(JSContext *UNUSED(js), const char *message,
+                                JSErrorReport *UNUSED(report), void *rb)
+{
+  VALUE self = (VALUE)rb;
+  VALUE rb_message = rb_str_new2(message);
+  rb_funcall(self, rb_intern("debug_error_hook"), 1, rb_message);
+  return JS_TRUE;
+}
+
+static VALUE allocate(VALUE klass)
+{
+  JSDebugHooks* debug = calloc(1L, sizeof(JSDebugHooks));
+  VALUE self = Data_Wrap_Struct(klass, 0, 0, debug);
+
+  debug->interruptHandler = interrupt_handler;
+  debug->interruptHandlerData = (void *)self;
+  debug->newScriptHook = new_script_hook;
+  debug->newScriptHookData = (void *)self;
+  debug->destroyScriptHook = destroy_script_hook;
+  debug->destroyScriptHookData = (void *)self;
+  debug->debuggerHandler = debugger_handler;
+  debug->debuggerHandlerData = (void *)self;
+  debug->sourceHandler = source_handler;
+  debug->sourceHandlerData = (void *)self;
+  debug->executeHook = execute_hook;
+  debug->executeHookData = (void *)self;
+  debug->callHook = call_hook;
+  debug->callHookData = (void *)self;
+  debug->objectHook = object_hook;
+  debug->objectHookData = (void *)self;
+  debug->throwHook = throw_hook;
+  debug->throwHookData = (void *)self;
+  debug->debugErrorHook = debug_error_hook;
+  debug->debugErrorHookData = (void *)self;
+
+  return self;
+}
+
+void init_Johnson_SpiderMonkey_Debugger(VALUE spidermonkey)
+{
+  /* HACK:  These comments are *only* to make RDoc happy.
+  VALUE johnson = rb_define_module("Johnson");
+  VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
+  */
+
+  /* This is the debugging hooks used with SpiderMonkey. */
+  VALUE debugger = rb_define_class_under(spidermonkey, "Debugger", rb_cObject);
+  rb_define_private_method(debugger, "frame_pc", frame_pc, 2);
+  rb_define_private_method(debugger, "line_number", line_number, 3);
+  rb_define_private_method(debugger, "file_name", file_name, 2);
+
+  rb_define_alloc_func(debugger, allocate);
+}