johnson 1.2.0 → 2.0.0.pre0

data/README.rdoc

@@ -25,7 +25,8 @@ Mozilla SpiderMonkey JavaScript runtime as a C extension.
 Copyright 2008-2010 John Barnette,
 Aaron Patterson,
 Yehuda Katz,
-Matthew Draper
+Matthew Draper,
+Steven Parkes
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -6,6 +6,37 @@ require "hoe"
 gem "rake-compiler", "~> 0.6"
 require "rake/extensiontask"
 
+FILTER = ENV['FILTER'] || ENV['TESTOPTS']
+
+INTERPRETERS = [ "spidermonkey", "tracemonkey" ]
+
+SUFFIXES = {}
+SUFFIXES[ "spidermonkey" ] = "c"
+SUFFIXES[ "tracemonkey" ] = "cc"
+
+generated_nodes = []
+
+INTERPRETERS.each do |interpreter|
+
+  suffix = SUFFIXES[interpreter]
+  
+  generated_nodes << "ext/#{interpreter}/immutable_node.#{suffix}"
+  
+  generated_node = "ext/#{interpreter}/immutable_node.#{suffix}"
+  
+  file generated_node => "ext/#{interpreter}/immutable_node.#{suffix}.erb"  do |t|
+    template = ERB.new(File.open(t.prerequisites.first, "rb") { |x| x.read })
+    jsops = jsops interpreter
+    tokens = tokens interpreter
+    template.result(binding)
+    File.open(generated_node, "wb") { |f| f.write template.result(binding) }
+  end
+
+  task :"compile:#{interpreter}" => generated_node
+  task :compile => :"compile:#{interpreter}"
+
+end
+
 Hoe.plugin :debugging, :doofus, :git
 Hoe.plugins.delete :rubyforge
 
@@ -14,45 +45,68 @@ Hoe.spec "johnson" do
   developer "Aaron Patterson", "aaron.patterson@gmail.com"
   developer "Yehuda Katz",     "wycats@gmail.com"
   developer "Matthew Draper",  "matthew@trebex.net"
+  developer "Steven Parkes",   "smparkes@smparkes.net"
 
   self.extra_rdoc_files         = FileList["*.rdoc"]
   self.history_file             = "CHANGELOG.rdoc"
   self.readme_file              = "README.rdoc"
-  self.test_globs               = %w(test/**/*_test.rb)
-  self.spec_extras[:extensions] = %w(ext/spidermonkey/extconf.rb)
+  self.spec_extras[:extensions] = %w(ext/spidermonkey/extconf.rb 
+                                     ext/tracemonkey/extconf.rb)
 
+  extra_deps << ["stackdeck", "~> 0.1"]
   extra_dev_deps << ["rake-compiler", "~> 0.6"]
 
   clean_globs    << "ext/**/Makefile"
-  clean_globs    << "ext/**/*.{o,so,bundle,a,log}"
+  clean_globs    << "ext/**/*.{o,so,dylib,bundle,a,log}"
+  clean_globs    << "vendor/**/*.{o,so,dylib,bundle,a,log}"
   clean_globs    << "ext/spidermonkey/immutable_node.c"
+  clean_globs    << "ext/tracemonkey/immutable_node.cc"
   clean_globs    << "lib/johnson/**/*.{bundle,so}"
   clean_globs    << "tmp"
   clean_globs    << "vendor/spidermonkey/**/*.OBJ"
 
+  clean_globs    << "vendor/tracemonkey/**/.deps"
+  clean_globs    << "vendor/tracemonkey/dist"
+  clean_globs    << "vendor/tracemonkey/**/Makefile"
+  clean_globs    << "vendor/tracemonkey/unallmakefiles"
+  clean_globs    << "vendor/tracemonkey/config.{cache,status}"
+  clean_globs    << "vendor/tracemonkey/config/{autoconf,myconfig,myrules}.mk"
+  clean_globs    << "vendor/tracemonkey/config/{nfspwd,nsinstall,revdepth}"
+  clean_globs    << "vendor/tracemonkey/{host_jskwgen,host_jsoplengen,js}"
+  clean_globs    << "vendor/tracemonkey/{{,shell/}js,js-config,js-config.h}"
+  clean_globs    << "vendor/tracemonkey/{jsautocfg.h,jsautokw.h,jsautooplen.h}"
+  clean_globs    << "vendor/tracemonkey/{jscpucfg,mozilla-config.h}"
+
   Rake::ExtensionTask.new "spidermonkey", spec do |ext|
     ext.lib_dir = "lib/johnson/spidermonkey"
+    ext.source_pattern = "*.{c,h}"
+  end
+
+  Rake::ExtensionTask.new "tracemonkey", spec do |ext|
+    ext.lib_dir = "lib/johnson/tracemonkey"
+    ext.source_pattern = "*.{cc,h}"
   end
 end
 
+task(:test).clear
+
+task :test => :compile
+
 task :clean do
   Dir.chdir "vendor/spidermonkey" do
     sh "make clean -f Makefile.ref" unless Dir["**/libjs.a"].empty?
   end
-end
 
-task :test => :compile
+  Dir.chdir "vendor/tracemonkey" do
+    sh "make clean -f Makefile.ref" unless Dir["**/libjs.a"].empty?
+  end
+end
 
 require "erb"
 
-GENERATED_NODE = "ext/spidermonkey/immutable_node.c"
-
-task :package        => GENERATED_NODE
-task :check_manifest => GENERATED_NODE
-
-def jsops
+def jsops interpreter
   ops = []
-  File.open("vendor/spidermonkey/jsopcode.tbl", "rb") { |f|
+  File.open("vendor/#{interpreter}/jsopcode.tbl", "rb") { |f|
     f.each_line do |line|
       if line =~ /^OPDEF\((\w+),/
         ops << $1
@@ -62,9 +116,9 @@ def jsops
   ops
 end
 
-def tokens
+def tokens interpreter
   toks = []
-  File.open("vendor/spidermonkey/jsscan.h", "rb") { |f|
+  File.open("vendor/#{interpreter}/jsscan.h", "rb") { |f|
     f.each_line do |line|
       line.scan(/TOK_\w+/).each do |token|
         next if token == "TOK_ERROR"
@@ -75,9 +129,27 @@ def tokens
   toks.uniq
 end
 
-file GENERATED_NODE => "ext/spidermonkey/immutable_node.c.erb"  do |t|
-  template = ERB.new(File.open(t.prerequisites.first, "rb") { |x| x.read })
-  File.open(GENERATED_NODE, "wb") { |f| f.write template.result(binding) }
+task :"test:default" do
+  ruby %(#{Hoe::RUBY_FLAGS} -rrubygems -rjohnson -e 'require "test/johnson/generic/default_test"' #{FILTER})
 end
 
-file "ext/spidermonkey/extconf.rb" => GENERATED_NODE
+task :test => :"test:default"
+
+INTERPRETERS.each do |interpreter|
+
+  task :"test:#{interpreter}" do
+    tests = Dir["test/**/generic/**/*_test.rb"] + Dir["test/**/#{interpreter}/**/*_test.rb"]
+    tests.map! { |t| %(require "#{t}";) }
+    ruby "#{Hoe::RUBY_FLAGS} -rrubygems -rjohnson -rjohnson/#{interpreter} -e '#{tests.join("; ")}' #{FILTER}"
+  end
+
+  task :test => :"test:#{interpreter}"
+
+end
+
+task :package        => generated_nodes
+task :check_manifest => generated_nodes
+
+# Local Variables:
+# mode:ruby
+# End:

data/ext/spidermonkey/conversions.c

@@ -333,8 +333,15 @@ JSBool report_ruby_error_in_js(JohnsonRuntime* runtime, int state, VALUE old_err
         VALUE local_error = ruby_errinfo;
         ruby_errinfo = old_errinfo;
 
-        local_error = rb_funcall(local_error, rb_intern("inspect"), 0);
-        JS_ReportError(context, StringValuePtr(local_error));
+        if (rb_funcall(local_error, rb_intern("respond_to?"), 1, ID2SYM(rb_intern("copy_ruby_stack_to_deck"))))
+          rb_funcall(local_error, rb_intern("copy_ruby_stack_to_deck"), 0);
+
+        VALUE rb_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js);
+        rb_iv_set(local_error, "@js_stack", rb_funcall(rb_runtime, rb_intern("current_stack"), 0));
+
+        jsval js_error;
+        convert_to_js(runtime, local_error, &js_error);
+        JS_SetPendingException(context, js_error);
 
         return JS_FALSE ;
       }

data/ext/spidermonkey/ruby_land_proxy.c

@@ -450,7 +450,7 @@ call_function_property(int argc, VALUE* argv, VALUE self)
   JROOT(function);
 
   // should never be anything but a function
-  if (!JS_ObjectIsFunction(context, function))
+  if (!JS_ObjectIsFunction(context, JSVAL_TO_OBJECT(function)))
     JERROR("Specified property \"%s\" isn't a function.", StringValueCStr(name));
 
   REMOVE_JROOTS;

data/ext/spidermonkey/runtime.h

@@ -9,7 +9,7 @@
   do {\
     JohnsonRuntime * _rt = NULL;\
     Data_Get_Struct(rb_runtime, JohnsonRuntime, _rt);\
-    rb_funcall(CLASS_OF(rb_runtime), rb_intern("raise_js_exception"), 1,\
+    rb_funcall(rb_runtime, rb_intern("raise_js_exception"), 1,\
       convert_to_ruby(_rt, ex)); \
   } while(0)
 

data/ext/tracemonkey/context.cc

@@ -0,0 +1,125 @@
+#include "context.h"
+#include "conversions.h"
+#include "global.h"
+#include "extensions.h"
+#include "idhash.h"
+#include "jsdbgapi.h"
+
+// callback for JS_SetErrorReporter
+static void report_js_error(JSContext* js, const char* message, JSErrorReport* UNUSED(report))
+{
+  // first we find ourselves
+  VALUE self = (VALUE)JS_GetContextPrivate(js);
+
+  // then we find our bridge
+  JohnsonContext* context;
+  Data_Get_Struct(self, JohnsonContext, context);
+
+  // NOTE: TraceMonkey REALLY doesn't like being interrupted. If we
+  // jump over to Ruby and raise here, segfaults and such ensue.
+  // Instead, we store the exception (if any) and the error message
+  // on the context. They're dealt with in the if (!ok) block of evaluate().
+
+  strncpy(context->msg, message, MAX_EXCEPTION_MESSAGE_SIZE);
+  JS_GetPendingException(context->js, &context->ex);
+}
+
+// callback for JS_SetOperationCallback
+static JSBool operation_callback(JSContext* js)
+{
+  static unsigned long operation_counter = 0;
+  if( ++operation_counter % 0x1000 == 0 )
+    JS_MaybeGC( js );
+  return JS_TRUE;
+}
+
+/*
+ * call-seq:
+ *   native_initialize(runtime, options)
+ *
+ * Create the underlying TraceMonkey context. This must be called
+ * first, and only once. Called by +initialize+ by default.
+ */
+static VALUE
+initialize_native(VALUE self, VALUE rb_runtime, VALUE UNUSED(options))
+{
+  JohnsonContext* context;
+  JohnsonRuntime* runtime;
+
+  Data_Get_Struct(self, JohnsonContext, context);
+  Data_Get_Struct(rb_runtime, JohnsonRuntime, runtime);
+
+  if ((context->js = JS_NewContext(runtime->js, 8192L)))
+  {
+    // See if the runtime already has a shared global object.
+    JSObject* global = runtime->global;
+
+    // If it does, use it. If not,
+    if (!global)
+      // create one of our global objects.
+      global = johnson_create_global_object(context->js);
+
+    // Manually set the context's global object.
+    JS_SetGlobalObject(context->js, global);
+    JS_SetErrorReporter(context->js, report_js_error);
+    JS_SetOperationCallback(context->js, operation_callback);
+    JS_SetContextPrivate(context->js, (void *)self);
+
+    JS_SetOptions(context->js, JS_GetOptions(context->js)
+#ifdef JSOPTION_DONT_REPORT_UNCAUGHT
+        | JSOPTION_DONT_REPORT_UNCAUGHT
+#endif
+#ifdef JSOPTION_VAROBJFIX
+        | JSOPTION_VAROBJFIX
+#endif
+#ifdef JSOPTION_ATLINE
+        | JSOPTION_ATLINE
+#endif
+#ifdef JSOPTION_ATLINE
+        | JSOPTION_ATLINE
+#endif
+#ifdef JSOPTION_JIT
+        | JSOPTION_JIT
+#endif
+// #ifdef JSOPTION_XML
+//         | JSOPTION_XML
+// #endif
+        );
+
+    // Success.
+    return init_tracemonkey_extensions(context, self);
+  }
+
+  if (context->js) JS_DestroyContext(context->js);
+
+  rb_raise(rb_eRuntimeError, "Failed to initialize TraceMonkey context");
+}
+
+///////////////////////////////////////////////////////////////////////////
+//// INFRASTRUCTURE BELOW HERE ////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+static VALUE allocate(VALUE klass)
+{
+  JohnsonContext* context = (JohnsonContext*)calloc(1L, sizeof(JohnsonContext));
+  return Data_Wrap_Struct(klass, 0, 0, context);
+}
+
+void init_Johnson_TraceMonkey_Context(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");
+  */
+
+  /* This is the private context used for TraceMonkey. */
+  VALUE context = rb_define_class_under(tracemonkey, "Context", rb_cObject);
+
+  rb_define_alloc_func(context, allocate);
+  rb_define_private_method(context, "initialize_native", (ruby_callback)initialize_native, 2);
+}
+
+VALUE Johnson_TraceMonkey_JSLandProxy()
+{
+  return rb_eval_string("Johnson::TraceMonkey::JSLandProxy");
+}

data/ext/tracemonkey/context.h

@@ -0,0 +1,19 @@
+#ifndef JOHNSON_TRACEMONKEY_CONTEXT_H
+#define JOHNSON_TRACEMONKEY_CONTEXT_H
+
+#include "tracemonkey.h"
+
+#define MAX_EXCEPTION_MESSAGE_SIZE 2048L
+
+typedef struct {
+  JSContext *js;
+  
+  jsval ex; // an exception value
+  char msg[MAX_EXCEPTION_MESSAGE_SIZE]; // the 'backup' message
+  
+} JohnsonContext;
+
+void init_Johnson_TraceMonkey_Context(VALUE tracemonkey);
+VALUE Johnson_TraceMonkey_JSLandProxy();
+
+#endif

data/ext/tracemonkey/conversions.cc

@@ -0,0 +1,365 @@
+#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))
+
+DEFINE_RUBY_WRAPPER(convert_js_string_to_ruby, convert_js_string_to_ruby, ARGLIST2(runtime, str))
+
+static VALUE convert_regexp_to_ruby(JohnsonRuntime* runtime, jsval regexp);
+DECLARE_RUBY_WRAPPER(convert_regexp_to_ruby, JohnsonRuntime* runtime; jsval regexp)
+DEFINE_RUBY_WRAPPER(convert_regexp_to_ruby, convert_regexp_to_ruby, ARGLIST2(runtime, regexp))
+
+DEFINE_RUBY_WRAPPER(rb_funcall_0, rb_funcall, ARGLIST3(obj, sym, argc))
+DEFINE_RUBY_WRAPPER(rb_funcall_1, rb_funcall, ARGLIST4(obj, sym, argc, a))
+DEFINE_RUBY_WRAPPER(rb_funcall_2, rb_funcall, ARGLIST5(obj, sym, argc, a, b))
+
+DECLARE_RUBY_WRAPPER(rb_float_new, double v)
+DEFINE_RUBY_WRAPPER(rb_float_new, rb_float_new, ARGLIST1(v))
+
+DEFINE_RUBY_WRAPPER(rb_intern, rb_intern, ARGLIST1(name))
+
+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);
+  CALL_RUBY_WRAPPER(rb_string_value, (VALUE)&to_s);
+  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);
+  CALL_RUBY_WRAPPER(rb_string_value, (VALUE)&source);
+  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:
+      {
+        CALL_RUBY_WRAPPER(rb_string_value, (VALUE)&ruby);
+        const char * src = StringValuePtr(ruby);
+        const size_t srclen = StringValueLen(ruby);
+        size_t dstlen = 0;
+        JCHECK(JS_DecodeBytes(context, src, srclen, NULL, &dstlen));
+        jschar* dstchars = (jschar*)JS_malloc(context, sizeof(jschar) * (1 + dstlen));
+        JCHECK(dstchars);
+        JCHECK(JS_DecodeBytes(context, src, srclen, dstchars, &dstlen));
+        JSString* str = JS_NewUCString(context, dstchars, dstlen);
+        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:
+      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);
+  jschar* src = JS_GetStringChars(str);
+  JCHECK(src);
+  size_t srclen = JS_GetStringLength(str);
+  size_t dstlen = 0;
+  JCHECK(JS_EncodeCharacters(context, src, srclen, NULL, &dstlen));
+  char* dst = (char*)JS_malloc(context, sizeof(char) * (1 + dstlen));
+  JCHECK(dst);
+  JCHECK(JS_EncodeCharacters(context, src, srclen, dst, &dstlen));
+  // This will leak dst if rb_str_new raises
+  VALUE ruby_str = rb_str_new(dst, dstlen);
+  JS_free(context, dst);
+  JRETURN_RUBY(ruby_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(RB_FUNCALL_2(rb_cRegexp, RB_INTERN("new"),
+    CONVERT_JS_STRING_TO_RUBY(runtime, re->source),
+    INT2NUM((long)re->flags)));
+}
+
+static JSBool js_value_is_regexp(JohnsonRuntime* runtime, jsval maybe_regexp, bool* is_regexp)
+{
+  JSContext * context = johnson_get_current_context(runtime);
+  PREPARE_JROOTS(context, 1);
+  JROOT(maybe_regexp);
+  JSBool result = JS_InstanceOf(context, JSVAL_TO_OBJECT(maybe_regexp), &js_RegExpClass, NULL);
+  *is_regexp = (result ? true : false);
+  JRETURN;
+}
+
+static JSBool js_value_is_symbol(JohnsonRuntime* runtime, jsval maybe_symbol, bool* is_symbol)
+{
+  jsval nsJohnson, cSymbol;
+  JSContext * context = johnson_get_current_context(runtime);
+
+  PREPARE_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));
+
+  *is_symbol = (is_a_symbol != JS_FALSE);
+  JRETURN;
+}
+
+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: 
+#if JS_HAS_XML_SUPPORT
+    case JSTYPE_XML:
+#endif JS_HAS_XML_SUPPORT
+    case JSTYPE_OBJECT: {
+      if (OBJECT_TO_JSVAL(runtime->global) == js)
+        // global gets special treatment, since the Prelude might not be loaded
+        JRETURN_RUBY(CALL_RUBY_WRAPPER(make_ruby_land_proxy, runtime, js, "GlobalProxy"));
+      
+      // this conditional requires the Prelude
+      bool is_symbol = false;
+      JCHECK(js_value_is_symbol(runtime, js, &is_symbol));
+      if (is_symbol)
+        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));
+
+      bool is_regexp = false;
+      JCHECK(js_value_is_regexp(runtime, js, &is_regexp));
+      if (is_regexp)
+        JRETURN_RUBY(CALL_RUBY_WRAPPER(convert_regexp_to_ruby, runtime, js));
+    
+      JRETURN_RUBY(CALL_RUBY_WRAPPER(make_ruby_land_proxy, runtime, js, LEAKY_ROOT_NAME("RubyLandProxy", JS_GetStringBytes(JS_ValueToString(context, js)))));
+    }
+
+    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(CALL_RUBY_WRAPPER(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;
+        ruby_errinfo = old_errinfo;
+
+        if (rb_funcall(local_error, rb_intern("respond_to?"), 1, ID2SYM(rb_intern("copy_ruby_stack_to_deck"))))
+          rb_funcall(local_error, rb_intern("copy_ruby_stack_to_deck"), 0);
+
+        VALUE rb_runtime = (VALUE)JS_GetRuntimePrivate(runtime->js);
+        rb_iv_set(local_error, "@js_stack", rb_funcall(rb_runtime, rb_intern("current_stack"), 0));
+
+        jsval js_error;
+        convert_to_js(runtime, local_error, &js_error);
+        JS_SetPendingException(context, js_error);
+
+        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;
+      }
+  }
+}
+