jbarnette-johnson 1.0.0.200806240111

data/ext/spidermonkey/debugger.h

@@ -0,0 +1,9 @@
+#ifndef JOHNSON_SPIDERMONKEY_DEBUGGER_H
+#define JOHNSON_SPIDERMONKEY_DEBUGGER_H
+
+#include "spidermonkey.h"
+#include "jsdbgapi.h"
+
+void init_Johnson_SpiderMonkey_Debugger(VALUE spidermonkey);
+
+#endif

data/ext/spidermonkey/extconf.rb

@@ -0,0 +1,25 @@
+# this needs to happen before mkmf is required.
+ENV["ARCHFLAGS"] = "-arch #{`uname -p` =~ /powerpc/ ? 'ppc' : 'i386'}"
+
+require "mkmf"
+
+if Config::CONFIG['target_os'] == 'mingw32'
+  $libs = append_library($libs, "winmm")
+  $CFLAGS << " -DXP_WIN -DXP_WIN32"
+else
+  $CFLAGS << " -g -DXP_UNIX"
+end
+$CFLAGS << " -O3 -Wall -Wextra -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline"
+
+spidermonkey_base_dir = "../../vendor/spidermonkey"
+
+spidermonkey_obj_dir = Dir[spidermonkey_base_dir + "/#{ENV['CROSS'] || ''}*.OBJ"].first
+
+dir_config("johnson/spidermonkey")
+
+find_header("jsautocfg.h", spidermonkey_obj_dir)
+find_header("jsapi.h", spidermonkey_base_dir)
+
+$LOCAL_LIBS << spidermonkey_obj_dir + "/libjs.a"
+
+create_makefile("johnson/spidermonkey")

data/ext/spidermonkey/extensions.c

@@ -0,0 +1,37 @@
+#include "extensions.h"
+
+static JSBool /* Object.defineProperty(target, name, value, flags) */
+define_property(JSContext *js_context, JSObject* UNUSED(obj), uintN argc, jsval *argv, jsval *retval) {
+  assert(argc > 1);
+  char *name = JS_GetStringBytes(JSVAL_TO_STRING(argv[1]));
+
+  // READ_ONLY | ITERABLE | NON_DELETABLE
+  jsuint flags = argc > 3 ? (unsigned) JSVAL_TO_INT(argv[3]) : 0;
+
+  *retval = JSVAL_VOID;
+  return JS_DefineProperty(js_context, JSVAL_TO_OBJECT(argv[0]), name, argc > 2 ? argv[2] : JSVAL_VOID, NULL, NULL, flags);
+}
+
+VALUE init_spidermonkey_extensions(JohnsonContext* context, VALUE self)
+{
+  PREPARE_RUBY_JROOTS(context->js, 1);
+  
+  jsval Object;
+  JSObject * global = JS_GetGlobalObject(context->js);
+  JCHECK(JS_GetProperty(context->js, global, "Object", &Object));
+  JROOT(Object);
+
+  JCHECK(JS_DefineFunction(context->js, JSVAL_TO_OBJECT(Object),
+    "defineProperty", define_property, 4, 0));
+        
+  JCHECK(JS_DefineProperty(context->js, JSVAL_TO_OBJECT(Object), "READ_ONLY",
+    INT_TO_JSVAL(0x02), NULL, NULL, JSPROP_READONLY));
+        
+  JCHECK(JS_DefineProperty(context->js, JSVAL_TO_OBJECT(Object), "ITERABLE",
+    INT_TO_JSVAL(0x01), NULL, NULL, JSPROP_READONLY));
+        
+  JCHECK(JS_DefineProperty(context->js, JSVAL_TO_OBJECT(Object), "NON_DELETABLE",
+    INT_TO_JSVAL(0x04), NULL, NULL, JSPROP_READONLY));
+
+  JRETURN_RUBY(self);
+}

data/ext/spidermonkey/extensions.h

@@ -0,0 +1,12 @@
+#ifndef JOHNSON_SPIDERMONKEY_EXTENSIONS_H
+#define JOHNSON_SPIDERMONKEY_EXTENSIONS_H
+
+#include "spidermonkey.h"
+#include "context.h"
+#include "conversions.h"
+
+// A context is passed here because there might not be a current context
+// for the runtime when the function is called.
+VALUE init_spidermonkey_extensions(JohnsonContext* context, VALUE self);
+
+#endif

data/ext/spidermonkey/global.c

@@ -0,0 +1,40 @@
+#include "global.h"
+
+static JSBool enumerate(JSContext *js_context, JSObject *obj)
+{
+  return JS_EnumerateStandardClasses(js_context, obj);
+}
+
+static JSBool resolve(JSContext *js_context, JSObject *obj, jsval id, uintN flags, JSObject **objp)
+{
+  if ((flags & JSRESOLVE_ASSIGNING) == 0)
+  {
+    JSBool resolved_p;
+
+    if (!JS_ResolveStandardClass(js_context, obj, id, &resolved_p))
+      return JS_FALSE;
+    
+    if (resolved_p)
+      *objp = obj;
+  }
+
+  return JS_TRUE;
+}
+
+static JSClass OurGlobalClass = {
+  "global", JSCLASS_NEW_RESOLVE | JSCLASS_GLOBAL_FLAGS,
+  JS_PropertyStub, // addProperty
+  JS_PropertyStub, // delProperty
+  JS_PropertyStub, // getProperty
+  JS_PropertyStub, // setProperty
+  enumerate,
+  (JSResolveOp) resolve,
+  JS_ConvertStub,
+  JS_FinalizeStub,
+  JSCLASS_NO_OPTIONAL_MEMBERS
+};
+
+JSObject* johnson_create_global_object(JSContext* context)
+{
+  return JS_NewObject(context, &OurGlobalClass, NULL, NULL);
+}

data/ext/spidermonkey/global.h

@@ -0,0 +1,11 @@
+#ifndef JOHNSON_SPIDERMONKEY_GLOBAL_H
+#define JOHNSON_SPIDERMONKEY_GLOBAL_H
+
+#include "spidermonkey.h"
+#include "context.h"
+#include "runtime.h"
+
+// NOTE: one of the FEW places a context should be passed around
+JSObject* johnson_create_global_object(JSContext* context);
+
+#endif

data/ext/spidermonkey/idhash.c

@@ -0,0 +1,16 @@
+#include "idhash.h"
+
+static JSHashNumber key_hash(const void *key)
+{
+  return (JSHashNumber)key;
+}
+
+static intN comparator(const void *v1, const void *v2)
+{
+  return v1 == v2;
+}
+
+JSHashTable* create_id_hash()
+{
+  return JS_NewHashTable(0, key_hash, comparator, comparator, NULL, NULL);  
+}

data/ext/spidermonkey/idhash.h

@@ -0,0 +1,8 @@
+#ifndef JOHNSON_SPIDERMONKEY_IDHASH_H
+#define JOHNSON_SPIDERMONKEY_IDHASH_H
+
+#include "spidermonkey.h"
+
+JSHashTable* create_id_hash();
+
+#endif

data/ext/spidermonkey/immutable_node.c.erb

@@ -0,0 +1,522 @@
+#include "immutable_node.h"
+
+static VALUE cNode;
+
+static void deallocate(ImmutableNodeContext* context)
+{
+  if (context->pc)
+  {
+    js_FinishParseContext(context->js, context->pc);
+    free(context->pc);
+  }
+
+  JS_DestroyContext(context->js);
+  JS_DestroyRuntime(context->runtime);
+  free(context);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  ImmutableNodeContext * context = calloc(1, sizeof(ImmutableNodeContext));
+
+  VALUE self = Data_Wrap_Struct(klass, 0, deallocate, context);
+
+  assert(context->runtime = JS_NewRuntime(0x100000));
+  assert(context->js = JS_NewContext(context->runtime, 8192));
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   parse_io(stream, filename=nil, line_number=0)
+ *
+ * Parses an IO object, returning a native spidermonkey parse tree.
+ */
+static VALUE parse_io(int argc, VALUE *argv, VALUE klass) {
+  VALUE self = allocate(klass);
+  VALUE stream, filename, linenum;
+
+  ImmutableNodeContext* context;
+  Data_Get_Struct(self, ImmutableNodeContext, context);
+
+  assert(context->pc = calloc(1, sizeof(JSParseContext)));
+
+  rb_scan_args( argc, argv, "12", &stream, &filename, &linenum );
+  
+  VALUE file_contents = rb_funcall(stream, rb_intern("read"), 0);
+  size_t length = NUM2INT(rb_funcall(file_contents, rb_intern("length"), 0));
+
+  jschar* chars;
+  assert(chars = js_InflateString(context->js, StringValuePtr(file_contents), &length));
+
+  if(!filename && rb_respond_to(stream, rb_intern("path"))) {
+    filename = rb_funcall(stream, rb_intern("path"), 0);
+  }
+  char* filenamez = RTEST(filename) ? StringValueCStr(filename) : NULL;
+  int linenumi = RTEST(linenum) ? NUM2INT(linenum) : 1;
+
+  assert(js_InitParseContext(context->js, context->pc, 
+      NULL,
+      chars,
+      length,
+      NULL, filenamez, (unsigned)linenumi));
+
+  context->node = js_ParseScript(context->js, 
+      JS_NewObject(context->js, NULL, NULL, NULL),
+      context->pc);
+  if(JS_IsExceptionPending(context->js)) {
+    jsval exception, message, file_name, line_number;
+    JS_GetPendingException(context->js, &exception);
+    JS_GetProperty(context->js, JSVAL_TO_OBJECT(exception), "message",&message);
+    JS_GetProperty(context->js, JSVAL_TO_OBJECT(exception), "fileName",&file_name);
+    JS_GetProperty(context->js, JSVAL_TO_OBJECT(exception), "lineNumber",&line_number);
+    JS_ClearPendingException(context->js);
+
+    rb_funcall( self,
+                rb_intern("raise_parse_error"),
+                3,
+                message == JSVAL_NULL ? 
+                  Qnil :
+                  rb_str_new2(JS_GetStringBytes(JSVAL_TO_STRING(message))),
+                rb_str_new2(JS_GetStringBytes(JSVAL_TO_STRING(file_name))),
+                INT2NUM(JSVAL_TO_INT(line_number))
+                );
+
+  }
+  return self;
+}
+
+/*
+ * call-seq:
+ *   line
+ *
+ * Returns the line number of the node.
+ */
+static VALUE line(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  return INT2NUM(ctx->node->pn_pos.begin.lineno);
+}
+
+/*
+ * call-seq:
+ *   index
+ *
+ * Returns the column number of the node.
+ */
+static VALUE begin_index(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  return INT2NUM(ctx->node->pn_pos.begin.index);
+}
+
+/*
+ * call-seq:
+ *   pn_arity
+ *
+ * Returns the arity of the node as a symbol.
+ */
+static VALUE pn_arity(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  switch(ctx->node->pn_arity) {
+    case PN_FUNC:
+      return ID2SYM(rb_intern("pn_func"));
+    case PN_LIST:
+      return ID2SYM(rb_intern("pn_list"));
+    case PN_TERNARY:
+      return ID2SYM(rb_intern("pn_ternary"));
+    case PN_BINARY:
+      return ID2SYM(rb_intern("pn_binary"));
+    case PN_UNARY:
+      return ID2SYM(rb_intern("pn_unary"));
+    case PN_NAME:
+      return ID2SYM(rb_intern("pn_name"));
+    case PN_NULLARY:
+      return ID2SYM(rb_intern("pn_nullary"));
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_type
+ *
+ * Returns the type of the node as a symbol.
+ */
+static VALUE pn_type(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  switch(ctx->node->pn_type) {
+    <% tokens.each do |token| %>
+    case <%= token %>: return ID2SYM(rb_intern("<%= token.downcase %>"));
+    <% end %>
+  }
+  return INT2NUM(ctx->node->pn_type);
+}
+
+/*
+ * call-seq:
+ *   pn_expr
+ *
+ * Returns the parse node expression as an ImmutableNode.
+ */
+static VALUE data_pn_expr(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  if(ctx->node->pn_expr) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_expr;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_kid
+ *
+ * Returns the child ImmutableNode.
+ */
+static VALUE data_pn_kid(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  if(ctx->node->pn_kid) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_kid;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_kid1
+ *
+ * Returns the first child ImmutableNode.
+ */
+static VALUE data_pn_kid1(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  if(ctx->node->pn_kid1) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_kid1;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_kid2
+ *
+ * Returns the second child ImmutableNode.
+ */
+static VALUE data_pn_kid2(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  if(ctx->node->pn_kid2) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_kid2;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_kid3
+ *
+ * Returns the third child ImmutableNode.
+ */
+static VALUE data_pn_kid3(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  if(ctx->node->pn_kid3) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_kid3;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_dval
+ *
+ * Returns the numeric value of the node.
+ */
+static VALUE data_pn_dval(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  if(JSVAL_IS_NUMBER(ATOM_KEY(ctx->node->pn_atom))) {
+    return rb_float_new(ctx->node->pn_dval);
+  } else {
+    return INT2NUM((int)(ctx->node->pn_dval));
+  }
+}
+
+/*
+ * call-seq:
+ *   pn_op
+ *
+ * Returns the op code for the node as a symbol.
+ */
+static VALUE data_pn_op(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  return jsop_to_symbol(ctx->node->pn_op);
+}
+
+/*
+ * call-seq:
+ *   pn_left
+ *
+ * Returns the left side ImmutableNode.
+ */
+static VALUE data_pn_left(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+
+  if(ctx->node->pn_left) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_left;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_extra
+ *
+ * Returns extra informaton about the node as an Integer.
+ */
+static VALUE data_pn_extra(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+
+  return UINT2NUM(ctx->node->pn_extra);
+}
+
+/*
+ * call-seq:
+ *   name
+ *
+ * Returns the name of the node.
+ */
+static VALUE name(VALUE self) {
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  return rb_str_new2(JS_GetStringBytes(ATOM_TO_STRING(ctx->node->pn_atom)));
+}
+
+/*
+ * call-seq:
+ *   regexp
+ *
+ * Returns the regexp value as a String.
+ */
+static VALUE regexp(VALUE self) {
+  ImmutableNodeContext * ctx;
+  jsval result;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  js_regexp_toString(ctx->js, ctx->node->pn_pob->object, &result);
+  return rb_str_new2(JS_GetStringBytes(JSVAL_TO_STRING(result)));
+}
+
+/*
+ * call-seq:
+ *   function_name
+ *
+ * Returns the function name as a String.
+ */
+static VALUE function_name(VALUE self) {
+  ImmutableNodeContext * ctx;
+  JSFunction * f;
+  JSObject * object;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  object = ctx->node->pn_funpob->object;
+  f = (JSFunction *)JS_GetPrivate(ctx->js, ctx->node->pn_funpob->object);
+
+  if(f->atom) {
+    return rb_str_new2(JS_GetStringBytes(ATOM_TO_STRING(f->atom)));
+  } else {
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq:
+ *   function_args
+ *
+ * Returns the function argument names as an Array of String.
+ */
+static VALUE function_args(VALUE self) {
+  ImmutableNodeContext * ctx;
+  JSFunction * f;
+  JSObject * object;
+  jsuword* names;
+  VALUE func_args;
+  int i;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  object = ctx->node->pn_funpob->object;
+  f = (JSFunction *)JS_GetPrivate(ctx->js, ctx->node->pn_funpob->object);
+
+  func_args = rb_ary_new2(f->nargs);
+  if(f->nargs > 0) {
+    names = js_GetLocalNameArray(ctx->js, f, &ctx->js->tempPool);
+    for(i = 0; i < f->nargs; i++) {
+      rb_ary_push(func_args,
+          rb_str_new2(JS_GetStringBytes(ATOM_TO_STRING(names[i])))
+          );
+    }
+  }
+  return func_args;
+}
+
+/*
+ * call-seq:
+ *   function_body
+ *
+ * Returns the function body as an ImmutableNode.
+ */
+static VALUE function_body(VALUE self) {
+  ImmutableNodeContext * ctx;
+  JSFunction * f;
+  JSObject * object;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  object = ctx->node->pn_funpob->object;
+  f = (JSFunction *)JS_GetPrivate(ctx->js, ctx->node->pn_funpob->object);
+
+  if(ctx->node->pn_body) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_body;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   pn_right
+ *
+ * Returns right side as an ImmutableNode.
+ */
+static VALUE data_pn_right(VALUE self)
+{
+  ImmutableNodeContext * ctx;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+
+  if(ctx->node->pn_right) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = ctx->node->pn_right;
+    return node;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   children
+ *
+ * Returns children as an Array of ImmutableNode.
+ */
+static VALUE children(VALUE self) {
+  ImmutableNodeContext * ctx;
+  JSParseNode * p;
+  VALUE children;
+
+  Data_Get_Struct(self, ImmutableNodeContext, ctx);
+  children = rb_ary_new();
+  for(p = ctx->node->pn_head; p != NULL; p = p->pn_next) {
+    ImmutableNodeContext *roc;
+    VALUE node = Data_Make_Struct(cNode, ImmutableNodeContext, NULL, NULL, roc);
+    roc->js = ctx->js;
+    roc->node = p;
+
+    rb_ary_push(children, node);
+  }
+
+  return children;
+}
+
+VALUE jsop_to_symbol(JSUint32 jsop)
+{
+  switch(jsop) {
+    <% jsops.each do |jsop| %>
+    case <%= jsop %>: return ID2SYM(rb_intern("<%= jsop.downcase %>"));
+    <% end %>
+  }
+  return UINT2NUM(jsop);
+}
+
+void init_Johnson_SpiderMonkey_Immutable_Node(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");
+  */
+
+  /* ImmutableNode class. */
+  cNode = rb_define_class_under(spidermonkey, "ImmutableNode", rb_cObject);
+
+  rb_define_alloc_func(cNode, allocate);
+  rb_define_singleton_method(cNode, "parse_io", parse_io, -1);
+  rb_define_method(cNode, "line", line, 0);
+  rb_define_method(cNode, "index", begin_index, 0);
+  rb_define_method(cNode, "pn_arity", pn_arity, 0);
+  rb_define_method(cNode, "pn_type", pn_type, 0);
+  rb_define_method(cNode, "pn_expr", data_pn_expr, 0);
+  rb_define_method(cNode, "pn_kid", data_pn_kid, 0);
+  rb_define_method(cNode, "pn_kid1", data_pn_kid1, 0);
+  rb_define_method(cNode, "pn_kid2", data_pn_kid2, 0);
+  rb_define_method(cNode, "pn_kid3", data_pn_kid3, 0);
+  rb_define_method(cNode, "pn_dval", data_pn_dval, 0);
+  rb_define_method(cNode, "pn_op", data_pn_op, 0);
+  rb_define_method(cNode, "pn_left", data_pn_left, 0);
+  rb_define_method(cNode, "pn_extra", data_pn_extra, 0);
+  rb_define_method(cNode, "name", name, 0);
+  rb_define_method(cNode, "regexp", regexp, 0);
+  rb_define_method(cNode, "function_name", function_name, 0);
+  rb_define_method(cNode, "function_args", function_args, 0);
+  rb_define_method(cNode, "function_body", function_body, 0);
+  rb_define_method(cNode, "pn_right", data_pn_right, 0);
+  rb_define_method(cNode, "children", children, 0);
+}