johnson 1.1.0

data/lib/johnson/nodes/ternary_node.rb

@@ -0,0 +1,20 @@
+module Johnson
+  module Nodes
+    TERNARY_NODES = %w{
+      Ternary
+      If
+      Try
+      Catch
+    }
+    class TernaryNode < Node
+      alias :b_else :value
+      attr_accessor :cond, :b_then
+      def initialize(line, column, cond, b_then, b_else)
+        super(line, column, b_else)
+        @cond   = cond
+        @b_then = b_then
+      end
+    end
+    TERNARY_NODES.each { |bn| const_set(bn.to_sym, Class.new(TernaryNode)) }
+  end
+end

data/lib/johnson/parser.rb

@@ -0,0 +1,21 @@
+require 'stringio'
+require 'johnson/parser/syntax_error'
+
+module Johnson
+  module Parser
+    class << self
+      def parse(js, filename = nil, linenum = nil)
+        tree = if js.is_a?(String)
+          parse_io(StringIO.new(js), filename, linenum)
+        else
+          parse_io(js, filename, linenum)
+        end
+        tree.to_mutable_tree
+      end
+
+      def parse_io(js, filename = nil, linenum = nil)
+        Johnson::SpiderMonkey::ImmutableNode.parse_io(js, filename, linenum)
+      end
+    end
+  end
+end

data/lib/johnson/parser/syntax_error.rb

@@ -0,0 +1,13 @@
+module Johnson
+  module Parser
+    class SyntaxError < RuntimeError
+      attr_accessor :message, :file_name, :line_number
+      def initialize(message, file_name, line_number)
+        super("#{message} in (#{file_name || "nil"}): #{line_number}")
+        @message      = message
+        @file_name    = file_name
+        @line_number  = line_number
+      end
+    end
+  end
+end

data/lib/johnson/runtime.rb

@@ -0,0 +1,63 @@
+module Johnson
+  class Runtime
+    attr_reader :delegate
+    
+    def initialize(delegate=Johnson::SpiderMonkey::Runtime)
+      @delegate = delegate.is_a?(Class) ? delegate.new : delegate
+      evaluate(Johnson::PRELUDE, "Johnson::PRELUDE", 1)
+      global.Johnson.runtime = self
+    end
+    
+    def [](key)
+      delegate[key.to_s]
+    end
+    
+    def []=(key, value)
+      delegate[key.to_s] = value
+    end
+    
+    def evaluate(expression, filename=nil, linenum=nil)
+      return nil if expression.nil?
+      delegate.evaluate(expression, filename, linenum)
+    end
+    
+    def global
+      delegate.global
+    end
+    
+    def load(*files)
+      files.map { |f| delegate.evaluate(File.read(f).gsub(/\A#!.*$/, ''), f, 1) }.last
+    end
+
+    ###
+    # Johnson.require on each file in +files+
+    def require(*files)
+      files.each do |file|
+        evaluate("Johnson.require('#{file}');")
+      end
+    end
+
+    ###
+    # Compile +script+ with +filename+ and +linenum+
+    def compile(script, filename=nil, linenum=nil)
+      delegate.compile(script, filename, linenum)
+    end
+
+    ###
+    # Yield to +block+ in +filename+ at +linenum+
+    def break(filename, linenum, &block)
+      delegate.break(filename, linenum, &block)
+    end
+
+    def evaluate_compiled_script(script)
+      delegate.evaluate_compiled(script)
+    end
+
+    private
+    # Called by SpiderMonkey's garbage collector to determine whether or
+    # not it should GC
+    def should_sm_gc?
+      false
+    end
+  end
+end

data/lib/johnson/spidermonkey/context.rb

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

data/lib/johnson/spidermonkey/debugger.rb

@@ -0,0 +1,67 @@
+module Johnson #:nodoc:
+  module SpiderMonkey #: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/spidermonkey/immutable_node.rb

@@ -0,0 +1,282 @@
+module Johnson #:nodoc:
+  module SpiderMonkey #:nodoc:
+    class ImmutableNode
+      def accept(visitor)
+        case pn_arity
+        when :pn_list
+          handle_list(visitor)
+        when :pn_name
+          if 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