johnson 1.2.0 → 2.0.0.pre0

data/lib/johnson/tracemonkey/js_land_proxy.rb

@@ -0,0 +1,64 @@
+# FIXME: This definition should probably be somewhere else
+class Array
+  def js_property?(name)
+    name == :length
+  end
+  def js_properties
+    (0...size).to_a
+  end
+end
+
+module Johnson
+  module TraceMonkey
+    module JSLandProxy #:nodoc:
+      def self.send_with_possible_block(target, symbol, args)
+        block = args.pop if args.last.is_a?(RubyLandProxy) && args.last.function?
+        target.__send__(symbol, *args, &block)
+      end
+      
+      def self.treat_all_properties_as_methods(target)
+        def target.js_property?(name); true; end
+      end
+          
+      def self.js_property?(target, name)
+        # FIXME: that rescue is gross; handles, e.g., "name?"
+        (target.send(:instance_variable_defined?, "@#{name}") rescue false) ||
+          (target.respond_to?(:js_property?) && target.__send__(:js_property?, name))
+      end
+      
+      def self.autovivified(target, attribute)
+        target.send(:__johnson_js_properties)[attribute]
+      end
+
+      def self.autovivified?(target, attribute)
+        target.respond_to?(:__johnson_js_properties) &&
+          target.send(:__johnson_js_properties).key?(attribute)
+      end
+
+      def self.autovivify(target, attribute, value)
+        (class << target; self; end).instance_eval do
+          unless target.respond_to?(:__johnson_js_properties)
+            define_method(:__johnson_js_properties) do
+              @__johnson_js_properties ||= {}
+            end
+          end
+          
+          define_method(:"#{attribute}=") do |arg|
+            send(:__johnson_js_properties)[attribute] = arg
+          end
+          
+          define_method(:"#{attribute}") do |*args|
+            js_prop = send(:__johnson_js_properties)[attribute]
+            if js_prop.is_a?(RubyLandProxy) && js_prop.function?
+              js_prop.call_using(self, *args)
+            else
+              js_prop
+            end
+          end
+        end
+
+        target.send(:"#{attribute}=", value)
+      end
+    end
+  end
+end

data/lib/johnson/tracemonkey/mutable_tree_visitor.rb

@@ -0,0 +1,242 @@
+module Johnson
+  module TraceMonkey
+    class MutableTreeVisitor
+      include Johnson::Nodes
+
+      def visit_For(ro_node)
+        For.new(  ro_node.line,
+                  ro_node.index,
+                  ro_node.pn_left.pn_kid1 && ro_node.pn_left.pn_kid1.accept(self),
+                  ro_node.pn_left.pn_kid2 && ro_node.pn_left.pn_kid2.accept(self),
+                  ro_node.pn_left.pn_kid3 && ro_node.pn_left.pn_kid3.accept(self),
+                  ro_node.pn_right.accept(self)
+               )
+      end
+
+      def visit_Name(ro_node)
+        Name.new(ro_node.line, ro_node.index, ro_node.name)
+      end
+
+      def visit_Number(ro_node)
+        Number.new(ro_node.line, ro_node.index, ro_node.pn_dval)
+      end
+
+      def visit_String(ro_node)
+        Nodes::String.new(  ro_node.line,
+                            ro_node.index,
+                            ro_node.name )
+      end
+
+      def visit_Regexp(ro_node)
+        Regexp.new( ro_node.line,
+                    ro_node.index,
+                    ro_node.regexp )
+      end
+
+      def visit_Function(ro_node)
+        Function.new( ro_node.line,
+                      ro_node.index,
+                      ro_node.function_name,
+                      ro_node.function_args,
+                      ro_node.function_body.accept(self) )
+      end
+
+      def visit_LexicalScope(ro_node)
+        LexicalScope.new(
+          ro_node.line,
+          ro_node.index,
+          Name.new(ro_node.line, ro_node.index, "unnamed"), # lexical scope nodes don't hold a name
+          ro_node.pn_expr.accept(self))
+      end
+
+      %w{ Label AssignExpr DotAccessor }.each do |type|
+        define_method(:"visit_#{type}") do |ro_node|
+          Nodes.const_get(type).new(
+            ro_node.line,
+            ro_node.index,
+            Name.new(ro_node.line, ro_node.index, ro_node.name),
+            ro_node.pn_expr.accept(self)
+          )
+        end
+      end
+
+      %w{
+        SourceElements
+        VarStatement
+        LetStatement
+        Comma
+        ObjectLiteral
+        ArrayLiteral
+        New
+        FunctionCall
+        Import
+        Export
+      }.each do |list_op|
+        define_method(:"visit_#{list_op}") do |ro_node|
+          Nodes.const_get(list_op).new( ro_node.line,
+                                        ro_node.index,
+                                        ro_node.children.map { |c|
+                                          c.accept(self)
+                                        }.compact)
+        end
+      end
+
+      {
+        'Null'      => nil,
+        'True'      => true,
+        'False'     => false,
+        'This'      => 'this',
+        'Continue'  => 'continue',
+        'Break'     => 'break',
+      }.each do |type,val|
+        define_method(:"visit_#{type}") do |ro_node|
+          Nodes.const_get(type).new(
+                                    ro_node.line,
+                                    ro_node.index,
+                                    val
+                                   )
+        end
+      end
+
+      def visit_Try(ro_node)
+        Try.new(
+          ro_node.line,
+          ro_node.index,
+          ro_node.pn_kid1 && ro_node.pn_kid1.accept(self),
+          if ro_node.pn_kid2
+            case ro_node.pn_kid2.pn_type
+            when :tok_reserved
+              ro_node.pn_kid2.children.map { |x| x.pn_expr.accept(self) }
+            else
+              raise "HALP some other catch #{ro_node.line}, #{ro_node.index}"
+            end
+          else
+            nil
+          end,
+          ro_node.pn_kid3 && ro_node.pn_kid3.accept(self)
+        )
+      end
+
+      %w{
+        Ternary
+        If
+        Catch
+      }.each do |node|
+        define_method(:"visit_#{node}") do |ro_node|
+          Nodes.const_get(node).new(
+            ro_node.line,
+            ro_node.index,
+            ro_node.pn_kid1 && ro_node.pn_kid1.accept(self),
+            ro_node.pn_kid2 && ro_node.pn_kid2.accept(self),
+            ro_node.pn_kid3 && ro_node.pn_kid3.accept(self)
+          )
+        end
+      end
+
+      %w{
+        BitwiseNot
+        Delete
+        Not
+        Parenthesis
+        PostfixDecrement
+        PostfixIncrement
+        PrefixDecrement
+        PrefixIncrement
+        Return
+        Throw
+        Typeof
+        UnaryNegative
+        UnaryPositive
+        Void
+      }.each do |node|
+        define_method(:"visit_#{node}") do |ro_node|
+          Nodes.const_get(node).new(ro_node.line,
+                                    ro_node.index,
+                                    ro_node.pn_kid && ro_node.pn_kid.accept(self))
+        end
+      end
+
+      %w{
+        And
+        BracketAccess
+        DoWhile
+        Case
+        Default
+        While
+        With
+        Equal
+        Switch
+        In
+        InstanceOf
+        GetterProperty
+        ForIn
+        GreaterThan
+        LessThan
+        GreaterThanOrEqual
+        LessThanOrEqual
+        NotEqual
+        OpAdd
+        OpAddEqual
+        OpBitAnd
+        OpBitAndEqual
+        OpBitOr
+        OpBitOrEqual
+        OpBitXor
+        OpBitXorEqual
+        OpDivide
+        OpDivideEqual
+        OpEqual
+        OpLShift
+        OpLShiftEqual
+        OpMod
+        OpModEqual
+        OpMultiply
+        OpMultiplyEqual
+        OpRShift
+        OpRShiftEqual
+        OpSubtract
+        OpSubtractEqual
+        OpURShift
+        OpURShiftEqual
+        Or
+        Property
+        SetterProperty
+        StrictEqual
+        StrictNotEqual
+      }.each do |bin_op|
+        define_method(:"visit_#{bin_op}") do |ro_node|
+          if ro_node.children.length > 1
+            kids = ro_node.children.reverse
+            tree = self.class.const_get(bin_op).new(
+                          ro_node.line,
+                          ro_node.index,
+                          kids[1].accept(self),
+                          kids[0].accept(self)
+            )
+            2.times { kids.shift }
+            kids.each do |kid|
+              tree = self.class.const_get(bin_op).new(
+                            ro_node.line,
+                            ro_node.index,
+                            kid.accept(self),
+                            tree
+              )
+            end
+            tree
+          else
+            self.class.const_get(bin_op).new(
+                          ro_node.line,
+                          ro_node.index,
+                          ro_node.pn_left && ro_node.pn_left.accept(self),
+                          ro_node.pn_right && ro_node.pn_right.accept(self)
+                       )
+          end
+        end
+      end
+
+      def accept(target)
+        target.accept(self)
+      end
+    end
+  end
+end

data/lib/johnson/tracemonkey/ruby_land_proxy.rb

@@ -0,0 +1,17 @@
+module Johnson #:nodoc:
+  module TraceMonkey #:nodoc:
+    class RubyLandProxy < Johnson::RubyLandProxy # native
+      module Callable
+        def call_using(this, *args)
+          native_call(this, *args)
+        end
+      end
+    end
+    class RubyLandScript < Johnson::TraceMonkey::RubyLandProxy # native
+      def break(linenum, &block)
+        runtime.set_trap(self, linenum, block)
+        runtime.traps << [self, linenum]
+      end
+    end
+  end
+end

data/lib/johnson/tracemonkey/runtime.rb

@@ -0,0 +1,80 @@
+module Johnson #:nodoc:
+  module TraceMonkey #:nodoc:
+    class Runtime < Johnson::Runtime # native
+      def version
+        TraceMonkey::VERSION
+      end
+
+      CONTEXT_MAP_KEY = :johnson_context_map
+
+      attr_reader :traps
+      def initialize(options={})
+        @debugger = nil
+        @gcthings = {}
+        @traps = []
+        initialize_native(options)
+        super()
+      end
+      
+      # called from js_land_proxy.c:make_js_land_proxy
+      def add_gcthing(thing)
+        @gcthings[thing.object_id] = thing
+      end
+      
+      # called from js_land_proxy.c:finalize
+      def remove_gcthing(object_id)
+        @gcthings.delete(object_id) if defined? @gcthings
+      end
+
+      def debugger?
+        not @debugger.nil?
+      end
+
+      def current_context
+        contexts = (Thread.current[CONTEXT_MAP_KEY] ||= {})
+        contexts[self.object_id] ||= Context.new(self)
+      end
+
+      def evaluate(script, filename = nil, linenum = nil, global=nil, scope=nil)
+        return nil if script.nil?
+        compiled_script = compile(script, filename, linenum, global)
+        evaluate_compiled_script(compiled_script, scope)
+      end
+
+      alias :evaluate_compiled_script_without_clearing_traps :evaluate_compiled_script
+      def evaluate_compiled_script script, scope=nil
+        evaluate_compiled_script_without_clearing_traps(script,scope)
+      ensure
+        @traps.each do |trap_tuple|
+          clear_trap(*trap_tuple)
+        end
+      end
+
+      ###
+      # Compile +script+ with +filename+ and +linenum+
+      def compile(script, filename=nil, linenum=nil, global=nil)
+        filename ||= 'none'
+        linenum  ||= 1
+        native_compile(script, filename, linenum, global)
+      end
+
+      class << self
+
+        def parse_io *args
+          Johnson::TraceMonkey::ImmutableNode.parse_io( *args )
+        end
+
+      end
+
+      private
+      # Called by TraceMonkey's garbage collector to determine whether or
+      # not it should GC
+      def should_sm_gc?
+        return false if Thread.list.find_all { |t|
+          t.key?(CONTEXT_MAP_KEY)
+        }.length > 1
+        true
+      end
+    end
+  end
+end

data/test/{johnson_test.rb → generic/johnson_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper"))
 
 class JohnsonTest < Test::Unit::TestCase
   def test_shortcut_evaluate

data/test/{parser_test.rb → generic/parser_test.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "helper"))
 
 require 'stringio'
 class ParserTest < Test::Unit::TestCase

data/test/helper.rb

@@ -26,6 +26,7 @@ module Johnson
 
     def setup
       @runtime = Johnson::Runtime.new
+      raise "hell" if !@runtime
       #@runtime.delegate.gc_zeal = 2
       #@runtime.delegate.debugger = Johnson::SpiderMonkey::Debugger.new(TestLogger.new)
     end
@@ -52,12 +53,30 @@ module Johnson
       @parser = Johnson::Parser
     end
   
-    def assert_sexp(expected, actual)
-      assert_equal(expected, actual.to_sexp)
+    def assert_includes enumerable, element
+      if !enumerable.include?( element )
+        flunk element.to_s + " not in [" + enumerable.map { |e| e.to_s }.join(" ") + "]"
+      end
+  end
+
+    def assert_sexp(*args)
+      if args.length == 2
+        assert_equal(args[0],args[1].to_sexp)
+      else
+        expected = args[0,args.length-1]
+        actual = args.last
+        assert_includes expected, actual.to_sexp
+      end
     end
 
-    def assert_ecma(expected, actual)
-      assert_equal(expected, actual.to_ecma)
+    def assert_ecma(*args)
+      if args.length == 2
+        assert_equal(args[0],args[1].to_ecma)
+      else
+        expected = args[0,args.length-1]
+        actual = args.last
+        assert_includes expected, actual.to_ecma
+      end
     end
   end
 end