jbarnette-johnson 1.0.0.200806240111

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,280 @@
+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,
+            }[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_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

data/lib/johnson/spidermonkey/js_land_proxy.rb

@@ -0,0 +1,62 @@
+module Johnson
+  module SpiderMonkey
+    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.call_proc_by_oid(oid, *args)
+        id2ref(oid).call(*args)
+      end
+      
+      def self.id2ref(oid)
+        ObjectSpace._id2ref(oid)
+      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/spidermonkey/mutable_tree_visitor.rb

@@ -0,0 +1,233 @@
+module Johnson
+  module SpiderMonkey
+    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
+
+      %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
+        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