smparkes-johnson 1.1.2.3

data/ext/tracemonkey/split_global.cc

@@ -0,0 +1,392 @@
+/* liberally copied from mozilla shell source (js.cpp) (MPL 1.1/GPL 2.0/LGPL 2.1) */
+
+// Changes from js.cpp: Equality does more checking; I think the
+// original checking is wrong (if you want inner == outer)
+
+// The newer moz sources override thisobject. The code is below but
+// not used. The current interpreter seems to do inner/outer incorrectly
+// in one place with that callback in place. Deserves relooking at
+// when upgrading to new SM.
+
+#include "split_global.h"
+
+#define LAZY_STANDARD_CLASSES
+
+/* A class for easily testing the inner/outer object callbacks. */
+typedef struct ComplexObject {
+    JSBool isInner;
+    JSBool frozen;
+    JSObject *inner;
+    JSObject *outer;
+} ComplexObject;
+
+static JSObject *
+split_create_outer(JSContext *cx);
+
+static JSObject *
+split_create_inner(JSContext *cx, JSObject *outer);
+
+static ComplexObject *
+split_get_private(JSContext *cx, JSObject *obj);
+
+static JSBool
+split_addProperty(JSContext *cx, JSObject *obj, jsval, jsval *vp)
+{
+    ComplexObject *cpx;
+    jsid asId;
+
+    cpx = split_get_private(cx, obj);
+    if (!cpx)
+        return JS_TRUE;
+    if (!cpx->isInner && cpx->inner) {
+        /* Make sure to define this property on the inner object. */
+        if (!JS_ValueToId(cx, *vp, &asId))
+            return JS_FALSE;
+        return OBJ_DEFINE_PROPERTY(cx, cpx->inner, asId, *vp, NULL, NULL,
+                                   JSPROP_ENUMERATE, NULL);
+    }
+    return JS_TRUE;
+}
+
+static JSBool
+split_getProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
+{
+    ComplexObject *cpx;
+
+    cpx = split_get_private(cx, obj);
+    if (!cpx)
+        return JS_TRUE;
+    if (!cpx->isInner && cpx->inner) {
+        if (JSVAL_IS_STRING(id)) {
+            JSString *str;
+
+            str = JSVAL_TO_STRING(id);
+            return JS_GetUCProperty(cx, cpx->inner, JS_GetStringChars(str),
+                                    JS_GetStringLength(str), vp);
+        }
+        if (JSVAL_IS_INT(id))
+            return JS_GetElement(cx, cpx->inner, JSVAL_TO_INT(id), vp);
+        return JS_TRUE;
+    }
+
+    return JS_TRUE;
+}
+
+static JSBool
+split_setProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
+{
+    ComplexObject *cpx;
+
+    cpx = split_get_private(cx, obj);
+    if (!cpx)
+        return JS_TRUE;
+    if (!cpx->isInner && cpx->inner) {
+        if (JSVAL_IS_STRING(id)) {
+            JSString *str;
+
+            str = JSVAL_TO_STRING(id);
+            return JS_SetUCProperty(cx, cpx->inner, JS_GetStringChars(str),
+                                    JS_GetStringLength(str), vp);
+        }
+        if (JSVAL_IS_INT(id))
+            return JS_SetElement(cx, cpx->inner, JSVAL_TO_INT(id), vp);
+        return JS_TRUE;
+    }
+
+    return JS_TRUE;
+}
+
+static JSBool
+split_delProperty(JSContext *cx, JSObject *obj, jsval, jsval *vp)
+{
+    ComplexObject *cpx;
+    jsid asId;
+
+    cpx = split_get_private(cx, obj);
+    if (!cpx)
+        return JS_TRUE;
+    if (!cpx->isInner && cpx->inner) {
+        /* Make sure to define this property on the inner object. */
+        if (!JS_ValueToId(cx, *vp, &asId))
+            return JS_FALSE;
+        return OBJ_DELETE_PROPERTY(cx, cpx->inner, asId, vp);
+    }
+    return JS_TRUE;
+}
+
+static JSBool
+split_enumerate(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
+                  jsval *statep, jsid *idp)
+{
+    ComplexObject *cpx;
+    JSObject *iterator;
+
+    switch (enum_op) {
+      case JSENUMERATE_INIT:
+        cpx = (ComplexObject *) JS_GetPrivate(cx, obj);
+
+        if (!cpx->isInner && cpx->inner)
+            obj = cpx->inner;
+
+        iterator = JS_NewPropertyIterator(cx, obj);
+        if (!iterator)
+            return JS_FALSE;
+
+        *statep = OBJECT_TO_JSVAL(iterator);
+        if (idp)
+            *idp = JSVAL_ZERO;
+        break;
+
+      case JSENUMERATE_NEXT:
+        iterator = (JSObject*)JSVAL_TO_OBJECT(*statep);
+        if (!JS_NextProperty(cx, iterator, idp))
+            return JS_FALSE;
+
+        if (!JSVAL_IS_VOID(*idp))
+            break;
+        /* Fall through. */
+
+      case JSENUMERATE_DESTROY:
+        /* Let GC at our iterator object. */
+        *statep = JSVAL_NULL;
+        break;
+    }
+
+    return JS_TRUE;
+}
+
+static JSBool
+split_resolve(JSContext *cx, JSObject *obj, jsval id, uintN flags,
+                JSObject **objp)
+{
+    ComplexObject *cpx;
+
+    cpx = split_get_private(cx, obj);
+    if (!cpx)
+        return JS_TRUE;
+    if (!cpx->isInner && cpx->inner) {
+        jsid asId;
+        JSProperty *prop;
+
+        if (!JS_ValueToId(cx, id, &asId))
+            return JS_FALSE;
+
+        if (!OBJ_LOOKUP_PROPERTY(cx, cpx->inner, asId, objp, &prop))
+            return JS_FALSE;
+        if (prop)
+            OBJ_DROP_PROPERTY(cx, cpx->inner, prop);
+
+        return JS_TRUE;
+    }
+
+#ifdef LAZY_STANDARD_CLASSES
+    if (!(flags & JSRESOLVE_ASSIGNING)) {
+        JSBool resolved;
+
+        if (!JS_ResolveStandardClass(cx, obj, id, &resolved))
+            return JS_FALSE;
+
+        if (resolved) {
+            *objp = obj;
+            return JS_TRUE;
+        }
+    }
+#endif
+
+    /* XXX For additional realism, let's resolve some random property here. */
+    return JS_TRUE;
+}
+
+static void
+split_finalize(JSContext *cx, JSObject *obj)
+{
+    JS_free(cx, JS_GetPrivate(cx, obj));
+}
+
+static uint32
+split_mark(JSContext *cx, JSObject *obj, void *arg)
+{
+    ComplexObject *cpx;
+
+    cpx = (ComplexObject *) JS_GetPrivate(cx, obj);
+
+    if (!cpx->isInner && cpx->inner) {
+        /* Mark the inner object. */
+        JS_MarkGCThing(cx, cpx->inner, "ComplexObject.inner", arg);
+    }
+
+    return 0;
+}
+
+static JSObject *
+split_outerObject(JSContext *cx, JSObject *obj)
+{
+    ComplexObject *cpx;
+
+    cpx = (ComplexObject *) JS_GetPrivate(cx, obj);
+    return cpx->isInner ? cpx->outer : obj;
+}
+
+static JSObject *
+split_thisObject(JSContext *cx, JSObject *obj)
+{
+    OBJ_TO_OUTER_OBJECT(cx, obj);
+    if (!obj)
+        return NULL;
+    return obj;
+}
+
+static JSObjectOps split_objectops;
+
+static JSObjectOps *
+split_getObjectOps(JSContext *cx, JSClass *clasp)
+{
+    if (!split_objectops.thisObject) {
+        memcpy(&split_objectops, &js_ObjectOps, sizeof split_objectops);
+        split_objectops.thisObject = split_thisObject;
+    }
+
+    return &split_objectops;
+}
+
+static JSBool
+split_equality(JSContext *cx, JSObject *obj, jsval v, JSBool *bp);
+
+static JSObject *
+split_innerObject(JSContext *cx, JSObject *obj)
+{
+    ComplexObject *cpx;
+
+    cpx = (ComplexObject *) JS_GetPrivate(cx, obj);
+    if (cpx->frozen) {
+        JS_ASSERT(!cpx->isInner);
+        return obj;
+    }
+    return !cpx->isInner ? cpx->inner : obj;
+}
+
+static JSExtendedClass split_global_class = {
+    {"split_global",
+    JSCLASS_NEW_RESOLVE | JSCLASS_NEW_ENUMERATE | JSCLASS_HAS_PRIVATE |
+    JSCLASS_GLOBAL_FLAGS | JSCLASS_IS_EXTENDED,
+    split_addProperty, split_delProperty,
+    split_getProperty, split_setProperty,
+    (JSEnumerateOp)split_enumerate,
+    (JSResolveOp)split_resolve,
+    JS_ConvertStub, split_finalize,
+     /* split_getObjectOps */ NULL, NULL, NULL, NULL, NULL, NULL,
+    split_mark, NULL},
+    split_equality, split_outerObject, split_innerObject,
+    NULL, NULL, NULL, NULL, NULL
+};
+
+static JSBool
+split_equality(JSContext *cx, JSObject *obj, jsval v, JSBool *bp)
+{
+    *bp = JS_FALSE;
+    if (JSVAL_IS_PRIMITIVE(v))
+        return JS_TRUE;
+
+    JSObject *obj2 = JSVAL_TO_OBJECT(v);
+    if (JS_GET_CLASS(cx, obj2) != &split_global_class.base)
+        return JS_TRUE;
+
+    ComplexObject *cpx = (ComplexObject *) JS_GetPrivate(cx, obj2);
+    ComplexObject *ourCpx = (ComplexObject *) JS_GetPrivate(cx, obj);
+
+    if( cpx == ourCpx ) {
+      *bp = JS_TRUE;
+    } else if ( cpx->inner ) {
+      *bp = ( cpx->inner == obj && ourCpx->outer == obj2);
+    } else {
+      *bp = ( cpx->outer == obj && ourCpx->inner == obj2);
+    }
+    return JS_TRUE;
+}
+
+JSObject *
+split_create_outer(JSContext *cx)
+{
+    ComplexObject *cpx;
+    JSObject *obj;
+
+    cpx = (ComplexObject *) JS_malloc(cx, sizeof *obj);
+    if (!cpx)
+        return NULL;
+    cpx->isInner = JS_FALSE;
+    cpx->frozen = JS_TRUE;
+    cpx->inner = NULL;
+    cpx->outer = NULL;
+
+    obj = JS_NewObject(cx, &split_global_class.base, NULL, NULL);
+    if (!obj || !JS_SetParent(cx, obj, NULL)) {
+        JS_free(cx, cpx);
+        return NULL;
+    }
+
+    if (!JS_SetPrivate(cx, obj, cpx)) {
+        JS_free(cx, cpx);
+        return NULL;
+    }
+
+    return obj;
+}
+
+static JSObject *
+split_create_inner(JSContext *cx, JSObject *outer)
+{
+    ComplexObject *cpx, *outercpx;
+    JSObject *obj;
+
+    JS_ASSERT(JS_GET_CLASS(cx, outer) == &split_global_class.base);
+
+    cpx = (ComplexObject *) JS_malloc(cx, sizeof *cpx);
+    if (!cpx)
+        return NULL;
+    cpx->isInner = JS_TRUE;
+    cpx->frozen = JS_FALSE;
+    cpx->inner = NULL;
+    cpx->outer = outer;
+
+    obj = JS_NewObject(cx, &split_global_class.base, NULL, NULL);
+    if (!obj || !JS_SetParent(cx, obj, NULL) || !JS_SetPrivate(cx, obj, cpx)) {
+        JS_free(cx, cpx);
+        return NULL;
+    }
+
+    outercpx = (ComplexObject *) JS_GetPrivate(cx, outer);
+    outercpx->inner = obj;
+    outercpx->frozen = JS_FALSE;
+
+    return obj;
+}
+
+static ComplexObject *
+split_get_private(JSContext *cx, JSObject *obj)
+{
+    do {
+        if (JS_GET_CLASS(cx, obj) == &split_global_class.base)
+            return (ComplexObject *) JS_GetPrivate(cx, obj);
+        obj = JS_GetParent(cx, obj);
+    } while (obj);
+
+    return NULL;
+}
+
+JSObject* johnson_create_split_global_outer_object(JSContext* cx)
+{
+  JSObject* outer = split_create_outer(cx);
+  // fprintf(stderr,"outer %08x\n", outer);
+  return outer;
+}
+
+JSObject* johnson_create_split_global_inner_object(JSContext* cx, JSObject* outer)
+{
+  // JSObject* current = JS_GetGlobalObject(cx);
+  // JS_SetGlobalObject(cx, outer);
+  JSObject* inner = split_create_inner(cx, outer);
+  JS_ClearScope(cx, outer);
+  // fprintf(stderr,"inner %08x outer %08x\n", inner, outer);
+  // JS_SetGlobalObject(cx, current);
+  return inner;
+}

data/ext/tracemonkey/split_global.h

@@ -0,0 +1,11 @@
+#ifndef JOHNSON_TRACEMONKEY_SPLIT_GLOBAL_H
+#define JOHNSON_TRACEMONKEY_SPLIT_GLOBAL_H
+
+#include "tracemonkey.h"
+#include "context.h"
+#include "runtime.h"
+
+JSObject* johnson_create_split_global_outer_object(JSContext* cx);
+JSObject* johnson_create_split_global_inner_object(JSContext* cx, JSObject* outer);
+
+#endif

data/ext/tracemonkey/tracemonkey.cc

@@ -0,0 +1,23 @@
+#include "tracemonkey.h"
+#include "context.h"
+#include "ruby_land_proxy.h"
+#include "debugger.h"
+#include "immutable_node.h"
+
+extern "C"
+void Init_tracemonkey()
+{
+  JS_SetCStringsAreUTF8();
+
+  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
+  VALUE tracemonkey = rb_define_module_under(johnson, "TraceMonkey");
+  
+  init_Johnson_TraceMonkey_Context(tracemonkey);
+  init_Johnson_TraceMonkey_Proxy(tracemonkey);
+  init_Johnson_TraceMonkey_Debugger(tracemonkey);
+  init_Johnson_TraceMonkey_Immutable_Node(tracemonkey);
+  init_Johnson_TraceMonkey_Runtime(tracemonkey);
+  
+  rb_define_const(tracemonkey, "VERSION",
+    rb_obj_freeze(rb_str_new2(JS_GetImplementationVersion())));
+}

data/ext/tracemonkey/tracemonkey.h

@@ -0,0 +1,32 @@
+#ifndef JOHNSON_SPIDERMONKEY_H
+#define JOHNSON_SPIDERMONKEY_H
+
+#include <assert.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <ruby.h>
+
+#include "jsapi.h"
+#include "jshash.h"
+#include "jsobj.h"
+#include "jsregexp.h"
+
+#include "jroot.h"
+
+#ifndef StringValueLen
+#define StringValueLen(v) (RSTRING(v)->len)
+#endif
+
+#ifndef UNUSED
+# if defined(__GNUC__)
+#  define MAYBE_UNUSED(name) name __attribute__((unused))
+#  define UNUSED(name) MAYBE_UNUSED(UNUSED_ ## name)
+# else
+#  define MAYBE_UNUSED(name) name
+#  define UNUSED(name) name
+# endif
+#endif
+
+typedef VALUE(*ruby_callback)(...);
+
+#endif

data/lib/johnson/cli/options.rb

@@ -0,0 +1,67 @@
+require "optparse"
+
+module Johnson #:nodoc:
+  module CLI #:nodoc:
+    class Options #:nodoc:
+      class << self
+        alias_method :parse!, :new
+      end
+      
+      attr_reader :arguments
+      attr_reader :expressions
+      attr_reader :files_to_preload
+      attr_reader :files_to_evaluate
+      attr_reader :load_paths
+      attr_reader :paths_to_require
+    
+      def initialize(*args)
+        @arguments = []
+        @expressions = []
+        @load_paths = []
+        @files_to_preload = []
+        @paths_to_require = []
+
+        argv = args.flatten
+        
+        if index = argv.index("--")
+          @arguments = argv[(index+1)..-1]
+          argv = argv[0..index]
+        end
+
+        parser = OptionParser.new do |parser|
+          parser.banner = "Usage: johnson [options] [file.js...] [-- jsargs...]"
+          parser.version = Johnson::VERSION
+
+          parser.on("-e [EXPRESSION]", "Evaluate [EXPRESSION] and exit") do |expression|
+            @expressions << expression
+          end
+      
+          parser.on("-I [DIRECTORY]", "Specify $LOAD_PATH directories") do |dir|
+            @load_paths << dir
+          end
+
+          parser.on("-i [FILE]", "Evaluate [FILE] before interaction") do |file|
+            @files_to_preload << file
+          end
+          
+          parser.on("-r [PATH]", "Require [PATH] before executing") do |path|
+            @paths_to_require << path
+          end
+      
+          parser.on("-h", "-?", "--help", "Show this message") do
+            puts parser
+            exit
+          end
+      
+          parser.on("-v", "--version", "Show Johnson's version (#{Johnson::VERSION})") do
+            puts Johnson::VERSION
+            exit
+          end  
+        end
+        
+        parser.parse!(argv)
+        @files_to_evaluate = argv.dup
+      end 
+    end
+  end
+end

data/lib/johnson/cli.rb

@@ -0,0 +1,8 @@
+require "johnson"
+require "johnson/cli/options"
+
+module Johnson #:nodoc:
+  module CLI #:nodoc:
+    JS = IO.read File.dirname(__FILE__) + "/js/cli.js"
+  end
+end

data/lib/johnson/error.rb

@@ -0,0 +1,4 @@
+module Johnson
+  class Error < StandardError
+  end
+end

data/lib/johnson/js/cli.js

@@ -0,0 +1,30 @@
+Ruby.require("uri");
+Ruby.require("open-uri");
+
+function load() {
+  for (var i = 0; i < arguments.length; ++i)
+    Johnson.require(arguments[i]);
+}
+
+function print() {
+  for (var i = 0; i < arguments.length; ++i)
+    Ruby.puts(arguments[i]);
+}
+
+// NOTE: the Rhino version takes an optional encoding
+function readFile(path) {
+  return Ruby.IO.read(path);
+}
+
+// NOTE: the Rhino version takes an optional encoding
+function readUrl(url) {
+  return Ruby.URI.parse(url).read();
+}
+
+function quit() {
+  Ruby.exit();
+}
+
+function version() {
+  return Ruby.Johnson.VERSION;
+}

data/lib/johnson/js/prelude.js

@@ -0,0 +1,118 @@
+var Johnson = {};
+
+Johnson.Symbol = function(string) {
+  this.string = string;
+};
+
+Johnson.Symbol.prototype = {
+  toString: function() {
+    return this.string;
+  },
+
+  inspect: function() {
+    return ":" + this.toString();
+  }
+};
+
+Johnson.symbolCache = {};
+
+Johnson.symbolize = function(string) {
+  if (!Johnson.symbolCache[string])
+    Johnson.symbolCache[string] = new Johnson.Symbol(string);
+    
+  return Johnson.symbolCache[string];
+};
+
+Object.defineProperty(String.prototype, "toSymbol", function() {
+  return Johnson.symbolize(this.toString());
+}, Object.READ_ONLY | Object.NON_DELETABLE);
+
+(function(origApply) {
+  Object.defineProperty(Function.prototype, "apply", function(thisObj, arrayLike) {
+    var realArray = arrayLike;
+    if (arrayLike != null &&
+        !(arrayLike instanceof Array) &&
+        typeof arrayLike == 'object' &&
+        arrayLike.length != null) {
+      realArray = [];
+      for (var i = arrayLike.length - 1; i >= 0; i--) {
+        realArray[i] = arrayLike[i];
+      }
+    }
+    return origApply.call(this, thisObj, realArray);
+  }, Object.READ_ONLY | Object.NON_DELETABLE);
+})(Function.prototype.apply);
+
+Johnson.Generator = function(enumerableProxy, namesOnly) {
+  if (enumerableProxy.js_properties) {
+    this.items = enumerableProxy.js_properties();
+  } else {
+    this.items = (enumerableProxy.keys ? enumerableProxy.keys() : []).concat(enumerableProxy.methods());
+  }
+  this.index = 0;
+  if (!namesOnly)
+    this.obj = enumerableProxy;
+};
+
+Johnson.Generator.prototype.__iterator__ = function() {
+  return this;
+};
+
+Johnson.Generator.prototype.hasNext = function() {
+  return this.index < this.items.length;
+}
+
+Johnson.Generator.prototype.next = function() {
+  if (this.hasNext()) {
+    var name = this.items[this.index++];
+    if (this.obj) {
+      return [name, this.obj[name]];
+    } else {
+      return name;
+    }
+  }
+  throw StopIteration;
+}
+
+Johnson.Generator.create = function(namesOnly) {
+  return new Johnson.Generator(this, namesOnly);
+}
+
+Johnson.required = {};
+
+Johnson.require = function(file) {
+  file = Ruby.File.join(Ruby.File.dirname(file),
+    Ruby.File.basename(file, ".js") + ".js");
+  
+  if(Johnson.required[file]) return false;
+  
+  var paths;
+
+  if ( file[0] == '/' ) {
+    paths = [""];
+  } else {
+    paths = Ruby["$LOAD_PATH"]; 
+  }
+
+  for(var key in paths) {
+    var directory = paths[key];
+    var path = Ruby.File.join(directory, file);
+    
+    if(Ruby.File.send("file?", path)) {
+      Johnson.required[file] = true;
+      Johnson.runtime.load(path);
+      
+      return true;
+    }
+  }
+  
+  throw Ruby.LoadError;
+}
+
+this.__defineGetter__("__FILE__", function() { 
+  try { throw new Error; } catch(e) {
+    return e.stack.split("\n")[2].split("@")[1].split(":").slice(0,-1).join(":");
+  }
+})
+
+null; // no need to marshal a result