johnson 2.0.0.pre1 → 2.0.0.pre2

data/ext/spidermonkey/spidermonkey.c

@@ -1,22 +0,0 @@
-#include "spidermonkey.h"
-#include "context.h"
-#include "ruby_land_proxy.h"
-#include "debugger.h"
-#include "immutable_node.h"
-
-void Init_spidermonkey()
-{
-  JS_SetCStringsAreUTF8();
-
-  VALUE johnson = rb_const_get(rb_mKernel, rb_intern("Johnson"));
-  VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
-  
-  init_Johnson_SpiderMonkey_Context(spidermonkey);
-  init_Johnson_SpiderMonkey_Proxy(spidermonkey);
-  init_Johnson_SpiderMonkey_Debugger(spidermonkey);
-  init_Johnson_SpiderMonkey_Immutable_Node(spidermonkey);
-  init_Johnson_SpiderMonkey_Runtime(spidermonkey);
-  
-  rb_define_const(spidermonkey, "VERSION",
-    rb_obj_freeze(rb_str_new2(JS_GetImplementationVersion())));
-}

data/ext/spidermonkey/spidermonkey.h

@@ -1,29 +0,0 @@
-#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 "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
-
-#endif

data/lib/johnson/spidermonkey.rb

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

data/lib/johnson/spidermonkey/context.rb

@@ -1,10 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,282 +0,0 @@
-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

data/lib/johnson/spidermonkey/js_land_proxy.rb

@@ -1,64 +0,0 @@
-# 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 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.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