johnson 1.2.0 → 2.0.0.pre0

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.rb

@@ -1,3 +1,5 @@
+require "stackdeck"
+
 require "generator"
 
 # the 'public' interface
@@ -13,11 +15,12 @@ require "johnson/visitors"
 # parse tree nodes
 require "johnson/nodes"
 
-# SpiderMonkey, the default JS engine
-require "johnson/spidermonkey"
-
 module Johnson
-  VERSION = "1.2.0"
+  VERSION = "2.0.0.pre0"
+
+  def self.version
+    VERSION
+  end
 
   ###
   # Evaluate the given JavaScript +expression+ in a new runtime, after
@@ -44,4 +47,9 @@ module Johnson
     rt.load(*files)
     rt
   end
+  
+  def self.runtimes
+    Runtime.runtimes
+  end
+
 end

data/lib/johnson/error.rb

@@ -1,4 +1,9 @@
 module Johnson
   class Error < StandardError
+    attr_accessor :original_exception
+    def initialize(message, original=nil)
+      super(message)
+      @original_exception = original unless original.nil?
+    end
   end
 end

data/lib/johnson/js/prelude.js

@@ -126,7 +126,16 @@ Johnson.require = function(file) {
   
   if(Johnson.required[file]) return false;
   
-  for(var directory in Ruby["$LOAD_PATH"]) {
+  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)) {
@@ -146,4 +155,10 @@ this.__defineGetter__("__FILE__", function() {
   }
 })
 
+Johnson.getStack = function() {
+  try { throw new Error; } catch(e) {
+    return e.stack.replace(/(.*\n){3}/, '');
+  }
+};
+
 null; // no need to marshal a result

data/lib/johnson/parser.rb

@@ -1,4 +1,5 @@
 require 'stringio'
+require 'johnson/runtime'
 require 'johnson/parser/syntax_error'
 
 module Johnson
@@ -14,7 +15,7 @@ module Johnson
       end
 
       def parse_io(js, filename = nil, linenum = nil)
-        Johnson::SpiderMonkey::ImmutableNode.parse_io(js, filename, linenum)
+        Johnson::Runtime.send(:default).parse_io(js, filename, linenum)
       end
     end
   end

data/lib/johnson/runtime.rb

@@ -18,29 +18,31 @@ module Johnson
       self
     end
 
-    ###
-    # Create a new Runtime instance, using the default JavaScript
-    # engine.
-    #
-    # Optionally takes a parameter specifying which engine to use, but
-    # this is deprecated; instead, just create an instance of that
-    # engine's runtime directly.
-    #
-    # :call-seq:
-    #   new(runtime_class=nil)
-    #
-    def self.new(*args)
-      return super if self < Johnson::Runtime
-
-      delegate = args.first
-      if delegate.is_a? Class
-        delegate.new
-      elsif delegate
-        delegate
-      else
-        Johnson::SpiderMonkey::Runtime.new
-      end
-    end
+     ###
+     # Create a new Runtime instance, using the default JavaScript
+     # engine.
+     #
+     # Optionally takes a parameter specifying which engine to use, but
+     # this is deprecated; instead, just create an instance of that
+     # engine's runtime directly.
+     #
+     # :call-seq:
+     #   new(runtime_class=nil)
+     #
+     def self.new(*args)
+       return super if self < Johnson::Runtime
+
+       delegate = args.first
+       if delegate.is_a? Class
+         delegate.new
+       elsif delegate
+         delegate
+       elsif
+         v = default.new( *args )
+         raise "hell" if !v
+         v
+       end
+     end
 
     ###
     # Install the Johnson prelude into this runtime environment.
@@ -77,7 +79,6 @@ module Johnson
       evaluate_compiled_script(compiled_script)
     end
 
-
     ###
     # The JavaScript unique Global Object.
     def global
@@ -108,15 +109,75 @@ module Johnson
     ###
     # Compile the JavaScript source in +script+. If supplied, the script
     # is marked as starting on line +linenum+ of +filename+.
-    def compile(script, filename=nil, linenum=nil)
+    def compile(script, filename=nil, linenum=nil, global=nil)
       raise NotImplementedError
     end
 
     ###
     # Evaluates the given JS script, that should have been returned by a
     # previous call to #compile().
-    def evaluate_compiled_script(script)
+    def evaluate_compiled_script(script,scope=nil)
       raise NotImplementedError
     end
+
+    def current_stack
+      global.Johnson.getStack
+    end
+
+    def parse_js_stack(ex, full_stack)
+      full_js_stack = full_stack.split(/\n/)
+      short_js_stack = current_stack.split(/\n/)
+
+      upper, lower = StackDeck.split_list(full_js_stack, short_js_stack)
+      upper.map {|s| StackDeck::Frame::JavaScript.parse(s) }
+    end
+    private :parse_js_stack
+
+    def raise_js_exception(jsex)
+      case jsex
+      when Exception
+        if stack = jsex.send(:remove_instance_variable, :@js_stack)
+          jsex.higher_stack_deck.concat parse_js_stack(jsex, stack)
+        end
+        raise jsex
+      when String
+        ex = Johnson::Error.new(jsex)
+      when Johnson::RubyLandProxy
+        ex = Johnson::Error.new(jsex['message'] || jsex.to_s, jsex)
+        if stack = jsex['stack']
+          stack = parse_js_stack(ex, stack)
+          top = StackDeck::Frame::JavaScript.new(nil, jsex['fileName'], jsex['lineNumber'])
+          stack.unshift top unless top.same_line?(stack.first)
+          ex.higher_stack_deck.concat stack
+        end
+      else
+        ex = Johnson::Error.new(jsex.inspect)
+      end
+
+      ex.set_backtrace caller(2)
+      raise ex
+    end
+
+    @runtimes = []
+
+    class << self
+
+      attr_reader :runtimes
+
+      private
+
+      def default
+        if @runtimes.empty?
+          require "johnson/spidermonkey"
+        end
+        @runtimes[0]
+      end
+
+      def inherited runtime
+        @runtimes << runtime
+      end
+
+    end
+
   end
 end

data/lib/johnson/spidermonkey/runtime.rb

@@ -1,6 +1,10 @@
 module Johnson #:nodoc:
   module SpiderMonkey #:nodoc:
     class Runtime < Johnson::Runtime # native
+      def version
+        SpiderMonkey::VERSION
+      end
+
       CONTEXT_MAP_KEY = :johnson_context_map
 
       attr_reader :traps
@@ -49,24 +53,11 @@ module Johnson #:nodoc:
       end
 
       class << self
-        def raise_js_exception(jsex)
-          raise jsex if Exception === jsex
-          raise Johnson::Error.new(jsex.to_s) unless Johnson::SpiderMonkey::RubyLandProxy === jsex
-
-          stack = jsex.stack rescue nil
 
-          message = jsex['message'] || jsex.to_s
-          at = "(#{jsex['fileName']}):#{jsex['lineNumber']}"
-          ex = Johnson::Error.new("#{message} at #{at}")
-          if stack
-            js_caller = stack.split("\n").find_all { |x| x != '@:0' }
-            ex.set_backtrace(js_caller + caller)
-          else
-            ex.set_backtrace(caller)
-          end
-
-          raise ex
+        def parse_io *args
+          Johnson::SpiderMonkey::ImmutableNode.parse_io( *args )
         end
+
       end
 
       private

data/lib/johnson/tracemonkey.rb

@@ -0,0 +1,13 @@
+require "johnson"
+
+# the native TraceMonkey extension
+require "johnson/tracemonkey/tracemonkey"
+
+# the TraceMonkey bits written in Ruby
+require "johnson/tracemonkey/runtime"
+require "johnson/tracemonkey/context"
+require "johnson/tracemonkey/js_land_proxy"
+require "johnson/tracemonkey/ruby_land_proxy"
+require "johnson/tracemonkey/mutable_tree_visitor"
+require "johnson/tracemonkey/debugger"
+require "johnson/tracemonkey/immutable_node"

data/lib/johnson/tracemonkey/context.rb

@@ -0,0 +1,10 @@
+module Johnson #:nodoc:
+  module TraceMonkey #:nodoc:
+    class Context # native
+      def initialize(runtime, options={})
+        @runtime = runtime
+        initialize_native(runtime, options)
+      end
+    end
+  end
+end

data/lib/johnson/tracemonkey/debugger.rb

@@ -0,0 +1,67 @@
+module Johnson #:nodoc:
+  module TraceMonkey #:nodoc:
+    class Debugger # native
+      JSTRAP_ERROR    = 0
+      JSTRAP_CONTINUE = 1
+      JSTRAP_RETURN   = 2
+      JSTRAP_THROW    = 3
+      JSTRAP_LIMIT    = 4
+      attr_accessor :logger
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def interrupt_handler(context, script, bytecode)
+        line_num  = line_number(context, script, bytecode)
+        f_name    = file_name(context, script)
+        logger.debug("interrupt_handler #{f_name} #{line_num}")
+        JSTRAP_CONTINUE
+      end
+
+      def new_script_hook(filename, linenum)
+        logger.debug("new_script_hook: #{filename} #{linenum}")
+      end
+
+      def destroy_script_hook
+        logger.debug("destroy_script_hook")
+      end
+
+      def debugger_handler(context, script, bytecode)
+        line_num  = line_number(context, script, bytecode)
+        f_name    = file_name(context, script)
+        logger.debug("debugger_handler: #{bytecode}")
+        JSTRAP_CONTINUE
+      end
+
+      def source_handler(filename, line_number, str)
+        logger.debug("source_handler: #{filename}(#{line_number}): #{str}")
+      end
+
+      # +call_hook+ is called before and after script execution.  +before+
+      # is +true+ if before, +false+ otherwise.
+      def execute_hook(context, stack_frame, before, ok)
+        logger.debug("execute_hook: #{before} #{ok}")
+      end
+
+      # +call_hook+ is called before and after a function call.  +before+
+      # is +true+ if before, +false+ otherwise.
+      def call_hook(before, ok)
+        logger.debug("call_hook: #{before} #{ok}")
+      end
+
+      def object_hook(is_new)
+        logger.debug("object_hook: #{is_new}")
+      end
+
+      # This hook can change the control
+      def throw_hook(bytecode)
+        logger.debug("throw_hook: #{bytecode}")
+        JSTRAP_CONTINUE
+      end
+
+      def debug_error_hook(message)
+        logger.debug("debug_error_hook: #{message}")
+      end
+    end
+  end
+end

data/lib/johnson/tracemonkey/immutable_node.rb

@@ -0,0 +1,282 @@
+module Johnson #:nodoc:
+  module TraceMonkey #:nodoc:
+    class ImmutableNode
+      def accept(visitor)
+        case pn_arity
+        when :pn_list
+          handle_list(visitor)
+        when :pn_name
+          if !pn_used && pn_expr
+            m = {
+              :tok_colon  => :visit_Label,
+              :tok_name   => :visit_AssignExpr,
+              :tok_dot    => :visit_DotAccessor,
+              :tok_lexicalscope => :visit_LexicalScope
+            }[pn_type]
+            raise "Unknown type #{pn_type}" unless m
+            visitor.send(m, self)
+          else
+            visitor.visit_Name(self)
+          end
+        when :pn_binary
+          handle_binary(visitor)
+        when :pn_unary
+          handle_unary(visitor)
+        when :pn_nullary
+          handle_nullary(visitor)
+        when :pn_func
+          visitor.visit_Function(self)
+        when :pn_ternary
+          m = {
+            :tok_hook   => :visit_Ternary,
+            :tok_if     => :visit_If,
+            :tok_try    => :visit_Try,
+            :tok_catch  => :visit_Catch,
+          }[pn_type]
+          raise "Unknown ternary #{pn_type}" unless m
+          visitor.send(m, self)
+        else
+          raise "unkown arity: #{pn_arity}"
+        end
+      end
+
+      def to_mutable_tree
+        MutableTreeVisitor.new.accept(self)
+      end
+
+      def to_sexp
+        to_mutable_tree.to_sexp
+      end
+
+      private
+      def handle_unary(visitor)
+        case pn_type
+        when :tok_throw
+          visitor.visit_Throw(self)
+        when :tok_delete
+          visitor.visit_Delete(self)
+        when :tok_return
+          visitor.visit_Return(self)
+        when :tok_unaryop
+          m = {
+            :jsop_void    => :visit_Void,
+            :jsop_typeof  => :visit_Typeof,
+            :jsop_pos     => :visit_UnaryPositive,
+            :jsop_neg     => :visit_UnaryNegative,
+            :jsop_bitnot  => :visit_BitwiseNot,
+            :jsop_not     => :visit_Not,
+          }[pn_op]
+          raise "Unknown tok_unaryop type: #{pn_op}" unless m
+          visitor.send(m, self)
+        when :tok_rp
+          visitor.visit_Parenthesis(self)
+        when :tok_inc
+          m = {
+            :jsop_nameinc => :visit_PostfixIncrement,
+            :jsop_propinc => :visit_PostfixIncrement,
+            :jsop_eleminc => :visit_PostfixIncrement,
+            :jsop_incname => :visit_PrefixIncrement,
+            :jsop_incprop => :visit_PrefixIncrement,
+            :jsop_incelem => :visit_PrefixIncrement,
+          }[pn_op]
+          raise "Unknown increment type: #{pn_op}" unless m
+          visitor.send(m, self)
+        when :tok_dec
+          m = {
+            :jsop_namedec => :visit_PostfixDecrement,
+            :jsop_propdec => :visit_PostfixDecrement,
+            :jsop_elemdec => :visit_PostfixDecrement,
+            :jsop_decname => :visit_PrefixDecrement,
+            :jsop_decprop => :visit_PrefixDecrement,
+            :jsop_decelem => :visit_PrefixDecrement,
+          }[pn_op]
+          raise "Unknown decrement type: #{pn_op}" unless m
+          visitor.send(m, self)
+        when :tok_semi
+          pn_kid.accept(visitor) if pn_kid
+        else
+          raise "unknown unary: #{pn_type}"
+        end
+      end
+
+      def handle_list(visitor)
+        case pn_type
+        when :tok_shop
+          handle_shiftop(visitor)
+        when :tok_divop
+          handle_divop(visitor)
+        when :tok_eqop
+          handle_eqop(visitor)
+        when :tok_relop
+          handle_relop(visitor)
+        else
+          m = {
+            :tok_lc         => :visit_SourceElements,
+            :tok_var        => :visit_VarStatement,
+            :tok_let        => :visit_LetStatement,
+            :tok_comma      => :visit_Comma,
+            :tok_rc         => :visit_ObjectLiteral,
+            :tok_rb         => :visit_ArrayLiteral,
+            :tok_new        => :visit_New,
+            :tok_lp         => :visit_FunctionCall,
+            :tok_import     => :visit_Import,
+            :tok_export     => :visit_Export,
+            :tok_plus       => :visit_OpAdd,
+            :tok_or         => :visit_Or,
+            :tok_minus      => :visit_OpSubtract,
+            :tok_and        => :visit_And,
+            :tok_bitand     => :visit_OpBitAnd,
+            :tok_bitor      => :visit_OpBitOr,
+            :tok_bitxor     => :visit_OpBitXor,
+            :tok_star       => :visit_OpMultiply,
+            :tok_instanceof => :visit_InstanceOf,
+          }[pn_type]
+          raise "Unknown type: #{pn_type} at (#{line}, #{index})" unless m
+          visitor.send(m, self)
+        end
+      end
+
+      OP_TO_METHOD = {
+        :jsop_null  => :visit_Null,
+        :jsop_true  => :visit_True,
+        :jsop_false => :visit_False,
+        :jsop_this  => :visit_This,
+      }
+      def handle_nullary(visitor)
+        case pn_type
+        when :tok_number
+          visitor.visit_Number(self)
+        when :tok_string
+          visitor.visit_String(self)
+        when :tok_regexp
+          visitor.visit_Regexp(self)
+        when :tok_name
+          visitor.visit_Name(self)
+        when :tok_comma
+          visitor.visit_Null(self)
+        when :tok_continue
+          visitor.visit_Continue(self)
+        when :tok_break
+          visitor.visit_Break(self)
+        when :tok_primary
+          sym = OP_TO_METHOD[pn_op]
+          raise "Unknown op #{pn_op}" unless sym
+          visitor.send(sym, self)
+        else
+          raise "Unknown nullary type: #{pn_type}"
+        end
+      end
+
+      def handle_binary(visitor)
+        case pn_type
+        when :tok_assign
+          m = {
+            :jsop_add     => :visit_OpAddEqual,
+            :jsop_sub     => :visit_OpSubtractEqual,
+            :jsop_nop     => :visit_OpEqual,
+            :jsop_mul     => :visit_OpMultiplyEqual,
+            :jsop_div     => :visit_OpDivideEqual,
+            :jsop_lsh     => :visit_OpLShiftEqual,
+            :jsop_rsh     => :visit_OpRShiftEqual,
+            :jsop_ursh    => :visit_OpURShiftEqual,
+            :jsop_bitand  => :visit_OpBitAndEqual,
+            :jsop_bitxor  => :visit_OpBitXorEqual,
+            :jsop_bitor   => :visit_OpBitOrEqual,
+            :jsop_mod     => :visit_OpModEqual,
+          }[pn_op]
+          raise "Unknown assign op #{pn_op}" unless m
+          visitor.send(m, self)
+        when :tok_divop
+          handle_divop(visitor)
+        when :tok_shop
+          handle_shiftop(visitor)
+        when :tok_eqop
+          handle_eqop(visitor)
+        when :tok_colon
+          m = {
+            :jsop_getter  => :visit_GetterProperty,
+            :jsop_setter  => :visit_SetterProperty,
+            :jsop_nop     => :visit_Property
+          }[pn_op]
+          raise "Unknown assign op #{pn_op}" unless m
+          visitor.send(m, self)
+        when :tok_relop
+          handle_relop(visitor)
+        when :tok_for
+          if pn_left.pn_type == :tok_in
+            visitor.visit_ForIn(self)
+          else
+            visitor.visit_For(self)
+          end
+        else
+          m = {
+            :tok_while      => :visit_While,
+            :tok_with       => :visit_With,
+            :tok_default    => :visit_Default,
+            :tok_case       => :visit_Case,
+            :tok_switch     => :visit_Switch,
+            :tok_do         => :visit_DoWhile,
+            :tok_instanceof => :visit_InstanceOf,
+            :tok_in         => :visit_In,
+            :tok_and        => :visit_And,
+            :tok_or         => :visit_Or,
+            :tok_star       => :visit_OpMultiply,
+            :tok_lb         => :visit_BracketAccess,
+            :tok_minus      => :visit_OpSubtract,
+            :tok_plus       => :visit_OpAdd,
+            :tok_bitor      => :visit_OpBitOr,
+            :tok_bitxor     => :visit_OpBitXor,
+            :tok_bitand     => :visit_OpBitAnd,
+          }[pn_type]
+          raise "Unknown binary type: #{pn_type}" unless m
+          visitor.send(m, self)
+        end
+      end
+
+      def handle_shiftop(visitor)
+        m = {
+          :jsop_ursh  => :visit_OpURShift,
+          :jsop_rsh   => :visit_OpRShift,
+          :jsop_lsh   => :visit_OpLShift,
+        }[pn_op]
+        raise "Unknown shift op #{pn_op} at (#{line}, #{index})" unless m
+        visitor.send(m, self)
+      end
+
+      def handle_divop(visitor)
+        m = {
+          :jsop_div => :visit_OpDivide,
+          :jsop_mod => :visit_OpMod,
+        }[pn_op]
+        raise "Unknown assign op #{pn_op} at (#{line}, #{index})" unless m
+        visitor.send(m, self)
+      end
+
+      def handle_eqop(visitor)
+        m = {
+          :jsop_strictne  => :visit_StrictNotEqual,
+          :jsop_stricteq  => :visit_StrictEqual,
+          :jsop_ne        => :visit_NotEqual,
+          :jsop_eq        => :visit_Equal,
+        }[pn_op]
+        raise "Unknown equal op #{pn_op} at (#{line}, #{index})" unless m
+        visitor.send(m, self)
+      end
+
+      def handle_relop(visitor)
+        m = {
+          :jsop_ge  => :visit_GreaterThanOrEqual,
+          :jsop_le  => :visit_LessThanOrEqual,
+          :jsop_gt  => :visit_GreaterThan,
+          :jsop_lt  => :visit_LessThan,
+        }[pn_op]
+        raise "Unknown relop #{pn_op} at (#{line}, #{index})" unless m
+        visitor.send(m, self)
+      end
+
+      def raise_parse_error(message, file_name, line_number)
+        raise Johnson::Parser::SyntaxError.new(message, file_name, line_number)
+      end
+    end
+  end
+end