add rkelly, a javascript parsing library. this version fixes several bugs in the abandoned gem, see https://github.com/tenderlove/rkelly/pull/6

git-svn-id: file:///home/svn/framework3/trunk@12815 4d416f70-5f16-0410-b530-b9f4589650da

lib/rkelly/constants.rb

@@ -0,0 +1,3 @@
+module RKelly
+  VERSION = '1.0.3'
+end

lib/rkelly/js.rb

@@ -0,0 +1,14 @@
+require 'rkelly/js/nan'
+require 'rkelly/js/property'
+require 'rkelly/js/base'
+require 'rkelly/js/global_object'
+require 'rkelly/js/object'
+require 'rkelly/js/object_prototype'
+require 'rkelly/js/function_prototype'
+require 'rkelly/js/array'
+require 'rkelly/js/boolean'
+require 'rkelly/js/math'
+require 'rkelly/js/number'
+require 'rkelly/js/string'
+require 'rkelly/js/scope'
+require 'rkelly/js/function'

lib/rkelly/js/array.rb

@@ -0,0 +1,15 @@
+module RKelly
+  module JS
+    class Array < Base
+      class << self
+        def create(*args)
+          self.new(*args)
+        end
+      end
+
+      def initialize(*args)
+        super()
+      end
+    end
+  end
+end

lib/rkelly/js/base.rb

@@ -0,0 +1,91 @@
+module RKelly
+  module JS
+    class Base
+      attr_reader :properties, :return, :value
+      def initialize
+        @properties = Hash.new { |h,k|
+          h[k] = Property.new(k, :undefined, self)
+        }
+        @return     = nil
+        @returned   = false
+        @value      = self
+        self['Class'] = self.class.to_s.split('::').last
+      end
+
+      def [](name)
+        return self.properties[name] if has_property?(name)
+        if self.properties['prototype'].value != :undefined
+          self.properties['prototype'].value[name]
+        else
+          RKelly::Runtime::UNDEFINED
+        end
+      end
+
+      def []=(name, value)
+        return unless can_put?(name)
+        if has_property?(name)
+          self.properties[name].value = value
+        else
+          self.properties[name] = Property.new(name, value, self)
+        end
+      end
+
+      def can_put?(name)
+        if !has_property?(name)
+          return true if self.properties['prototype'].nil?
+          return true if self.properties['prototype'].value.nil?
+          return true if self.properties['prototype'].value == :undefined
+          return self.properties['prototype'].value.can_put?(name)
+        end
+        !self.properties[name].read_only?
+      end
+
+      def has_property?(name)
+        return true if self.properties.has_key?(name)
+        return false if self.properties['prototype'].nil?
+        return false if self.properties['prototype'].value.nil?
+        return false if self.properties['prototype'].value == :undefined
+        self.properties['prototype'].value.has_property?(name)
+      end
+
+      def delete(name)
+        return true unless has_property?(name)
+        return false if self.properties[name].dont_delete?
+        self.properties.delete(name)
+        true
+      end
+
+      def default_value(hint)
+        case hint
+        when 'Number'
+          value_of = self['valueOf']
+          if value_of.function || value_of.value.is_a?(RKelly::JS::Function)
+            return value_of
+          end
+          to_string = self['toString']
+          if to_string.function || to_string.value.is_a?(RKelly::JS::Function)
+            return to_string
+          end
+        end
+      end
+
+      def return=(value)
+        @returned = true
+        @return = value
+      end
+
+      def returned?; @returned; end
+
+      private
+      def unbound_method(name, object_id = nil, &block)
+        name = "#{name}_#{self.class.to_s.split('::').last}_#{object_id}"
+        unless RKelly::JS::Base.instance_methods.include?(name.to_sym)
+          RKelly::JS::Base.class_eval do
+            define_method(name, &block)
+          end
+        end
+        RKelly::JS::Base.instance_method(name)
+      end
+    end
+  end
+end

lib/rkelly/js/boolean.rb

@@ -0,0 +1,21 @@
+module RKelly
+  module JS
+    class Boolean < Base
+      class << self
+        def create(*args)
+          return false if args.length == 0
+          self.new(args.first)
+        end
+      end
+      def initialize(*args)
+        super()
+        value = args.first.nil? ? false : args.first
+        self['valueOf'] = value
+        self['valueOf'].function = lambda {
+          value
+        }
+        self['toString'] = args.first.to_s
+      end
+    end
+  end
+end

lib/rkelly/js/function.rb

@@ -0,0 +1,39 @@
+module RKelly
+  module JS
+    class Function < Base
+      class << self
+        def create(*args)
+          if args.length > 0
+            parser = RKelly::Parser.new
+            body = args.pop
+            tree = parser.parse("function x(#{args.join(',')}) { #{body} }")
+            func = tree.value.first
+            self.new(func.function_body, func.arguments)
+          else
+            self.new
+          end
+        end
+      end
+
+      attr_reader :body, :arguments
+      def initialize(body = nil, arguments = [])
+        super()
+        @body = body
+        @arguments = arguments
+        self['prototype'] = JS::FunctionPrototype.new(self)
+        self['toString'] = :undefined
+        self['length'] = arguments.length
+      end
+
+      def js_call(scope_chain, *params)
+        arguments.each_with_index { |name, i|
+          scope_chain[name.value] = params[i] || RKelly::Runtime::UNDEFINED
+        }
+        function_visitor  = RKelly::Visitors::FunctionVisitor.new(scope_chain)
+        eval_visitor      = RKelly::Visitors::EvaluationVisitor.new(scope_chain)
+        body.accept(function_visitor) if body
+        body.accept(eval_visitor) if body
+      end
+    end
+  end
+end

lib/rkelly/js/function_prototype.rb

@@ -0,0 +1,15 @@
+module RKelly
+  module JS
+    # This is the object protytpe
+    # ECMA-262 15.2.4
+    class FunctionPrototype < ObjectPrototype
+      def initialize(function)
+        super()
+        self['Class'] = 'Object'
+        self['constructor'] = function
+        self['arguments'].value = nil
+      end
+    end
+  end
+end
+

lib/rkelly/js/global_object.rb

@@ -0,0 +1,52 @@
+module RKelly
+  module JS
+    class GlobalObject < Base
+      def initialize
+        super
+        self['class']     = 'GlobalObject'
+        self['NaN']       = JS::NaN.new
+        self['NaN'].attributes << :dont_enum
+        self['NaN'].attributes << :dont_delete
+
+        self['Infinity']  = 1.0/0.0
+        self['Infinity'].attributes << :dont_enum
+        self['Infinity'].attributes << :dont_delete
+
+        self['undefined'] = :undefined
+        self['undefined'].attributes << :dont_enum
+        self['undefined'].attributes << :dont_delete
+
+        self['Array'] = JS::Array.new
+        self['Array'].function = lambda { |*args|
+          JS::Array.create(*args)
+        }
+
+        self['Object'] = JS::Object.new
+        self['Object'].function = lambda { |*args|
+          JS::Object.create(*args)
+        }
+
+        self['Math'] = JS::Math.new
+
+        self['Function'] = :undefined
+        self['Function'].function = lambda { |*args|
+          JS::Function.create(*args)
+        }
+
+        self['Number'] = JS::Number.new
+        self['Number'].function = lambda { |*args|
+          JS::Number.create(*args)
+        }
+
+        self['Boolean'] = JS::Boolean.new
+        self['Boolean'].function = lambda { |*args|
+          JS::Boolean.create(*args)
+        }
+        self['String'] = JS::String.new('')
+        self['String'].function = lambda { |*args|
+          JS::String.create(*args)
+        }
+      end
+    end
+  end
+end

lib/rkelly/js/math.rb

@@ -0,0 +1,10 @@
+module RKelly
+  module JS
+    class Math < Base
+      def initialize
+        super
+        self['PI'] = ::Math::PI
+      end
+    end
+  end
+end

lib/rkelly/js/nan.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module JS
+    # Class to represent Not A Number
+    # In Ruby NaN != NaN, but in JS, NaN == NaN
+    class NaN < ::Numeric
+      def ==(other)
+        other.respond_to?(:nan?) && other.nan?
+      end
+
+      def nan?
+        true
+      end
+
+      def +(o); self; end
+      def -(o); self; end
+    end
+  end
+end

lib/rkelly/js/number.rb

@@ -0,0 +1,22 @@
+module RKelly
+  module JS
+    class Number < Base
+      class << self
+        def create(*args)
+          self.new(args.first || 0)
+        end
+      end
+
+      def initialize(value = 0)
+        super()
+        self['MAX_VALUE'] = 1.797693134862315e+308
+        self['MIN_VALUE'] = 1.0e-306
+        self['NaN']       = JS::NaN.new
+        self['POSITIVE_INFINITY'] = 1.0/0.0
+        self['NEGATIVE_INFINITY'] = -1.0/0.0
+        self['valueOf'] = lambda { value }
+        self['toString'] = value.to_s
+      end
+    end
+  end
+end

lib/rkelly/js/object.rb

@@ -0,0 +1,30 @@
+module RKelly
+  module JS
+    class Object < Base
+      attr_reader :value
+      class << self
+        def create(*args)
+          arg = args.first
+          return self.new if arg.nil? || arg == :undefined
+          case arg
+          when true, false
+            JS::Boolean.new(arg)
+          when Numeric
+            JS::Number.new(arg)
+          when ::String
+            JS::String.new(arg)
+          else
+            self.new(arg)
+          end
+        end
+      end
+
+      def initialize(*args)
+        super()
+        self['prototype'] = JS::ObjectPrototype.new
+        self['valueOf'] = lambda { args.first || self }
+        self['valueOf'].function = lambda { args.first || self }
+      end
+    end
+  end
+end

lib/rkelly/js/object_prototype.rb

@@ -0,0 +1,14 @@
+module RKelly
+  module JS
+    # This is the object protytpe
+    # ECMA-262 15.2.4
+    class ObjectPrototype < Base
+      def initialize
+        super
+        self['toString'].function = unbound_method(:toString) do
+          "[object #{self['Class'].value}]"
+        end
+      end
+    end
+  end
+end

lib/rkelly/js/property.rb

@@ -0,0 +1,20 @@
+module RKelly
+  module JS
+    class Property
+      attr_accessor :name, :value, :attributes, :function, :binder
+      def initialize(name, value, binder = nil, function = nil, attributes = [])
+        @name = name
+        @value = value
+        @binder = binder
+        @function = function
+        @attributes = attributes
+      end
+
+      [:read_only, :dont_enum, :dont_delete, :internal].each do |property|
+        define_method(:"#{property}?") do
+          self.attributes.include?(property)
+        end
+      end
+    end
+  end
+end

lib/rkelly/js/scope.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module JS
+    class Scope < Base
+    end
+  end
+end

lib/rkelly/js/string.rb

@@ -0,0 +1,21 @@
+module RKelly
+  module JS
+    class String < Base
+      class << self
+        def create(*args)
+          self.new(args.first || '')
+        end
+      end
+
+      def initialize(value)
+        super()
+        self['valueOf'] = value
+        self['valueOf'].function = lambda { value }
+        self['toString'] = value
+        self['fromCharCode'] = unbound_method(:fromCharCode) { |*args|
+          args.map { |x| x.chr }.join
+        }
+      end
+    end
+  end
+end

lib/rkelly/lexeme.rb

@@ -0,0 +1,18 @@
+require 'rkelly/token'
+
+module RKelly
+  class Lexeme
+    attr_reader :name, :pattern
+    def initialize(name, pattern, &block)
+      @name       = name
+      @pattern    = pattern
+      @block      = block
+    end
+
+    def match(string)
+      match = pattern.match(string)
+      return Token.new(name, match.to_s, &@block) if match
+      match
+    end
+  end
+end

lib/rkelly/nodes.rb

@@ -0,0 +1,25 @@
+require 'rkelly/nodes/node'
+require 'rkelly/nodes/function_expr_node'
+require 'rkelly/nodes/binary_node'
+require 'rkelly/nodes/bracket_accessor_node'
+require 'rkelly/nodes/case_clause_node'
+require 'rkelly/nodes/comma_node'
+require 'rkelly/nodes/conditional_node'
+require 'rkelly/nodes/dot_accessor_node'
+require 'rkelly/nodes/for_in_node'
+require 'rkelly/nodes/for_node'
+require 'rkelly/nodes/function_call_node'
+require 'rkelly/nodes/function_decl_node'
+require 'rkelly/nodes/function_expr_node'
+require 'rkelly/nodes/if_node'
+require 'rkelly/nodes/label_node'
+require 'rkelly/nodes/new_expr_node'
+require 'rkelly/nodes/not_strict_equal_node'
+require 'rkelly/nodes/op_equal_node'
+require 'rkelly/nodes/postfix_node'
+require 'rkelly/nodes/prefix_node'
+require 'rkelly/nodes/property_node'
+require 'rkelly/nodes/resolve_node'
+require 'rkelly/nodes/strict_equal_node'
+require 'rkelly/nodes/try_node'
+require 'rkelly/nodes/var_decl_node'

lib/rkelly/nodes/binary_node.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module Nodes
+    class BinaryNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+
+    %w[Subtract LessOrEqual GreaterOrEqual Add Multiply While NotEqual
+       DoWhile Switch LogicalAnd UnsignedRightShift Modulus While
+       NotStrictEqual Less With In Greater BitOr StrictEqual LogicalOr
+       BitXOr LeftShift Equal BitAnd InstanceOf Divide RightShift].each do |node|
+      eval "class #{node}Node < BinaryNode; end"
+    end
+  end
+end

lib/rkelly/nodes/bracket_accessor_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class BracketAccessorNode < Node
+      attr_reader :accessor
+      def initialize(resolve, accessor)
+        super(resolve)
+        @accessor = accessor
+      end
+    end
+  end
+end

lib/rkelly/nodes/case_clause_node.rb

@@ -0,0 +1,11 @@
+require 'rkelly/nodes/binary_node'
+
+module RKelly
+  module Nodes
+    class CaseClauseNode < BinaryNode
+      def initialize(left, src = SourceElementsNode.new([]))
+        super
+      end
+    end
+  end
+end

lib/rkelly/nodes/comma_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class CommaNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+  end
+end

lib/rkelly/nodes/conditional_node.rb

@@ -0,0 +1,11 @@
+require 'rkelly/nodes/if_node'
+
+module RKelly
+  module Nodes
+    class ConditionalNode < IfNode
+      def initialize(test, true_block, else_block)
+        super
+      end
+    end
+  end
+end

lib/rkelly/nodes/dot_accessor_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class DotAccessorNode < Node
+      attr_accessor :accessor
+      def initialize(resolve, accessor)
+        super(resolve)
+        @accessor = accessor
+      end
+    end
+  end
+end

lib/rkelly/nodes/for_in_node.rb

@@ -0,0 +1,12 @@
+module RKelly
+  module Nodes
+    class ForInNode < Node
+      attr_reader :left, :right
+      def initialize(left, right, block)
+        super(block)
+        @left = left
+        @right = right
+      end
+    end
+  end
+end

lib/rkelly/nodes/for_node.rb

@@ -0,0 +1,13 @@
+module RKelly
+  module Nodes
+    class ForNode < Node
+      attr_reader :init, :test, :counter
+      def initialize(init, test, counter, body)
+        super(body)
+        @init = init
+        @test = test
+        @counter = counter
+      end
+    end
+  end
+end

lib/rkelly/nodes/function_call_node.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Nodes
+    class FunctionCallNode < Node
+      attr_reader :arguments
+      def initialize(value, arguments)
+        super(value)
+        @arguments = arguments
+      end
+
+      def ==(other)
+        super && @arguments == other.arguments
+      end
+      alias :=~ :==
+    end
+  end
+end

lib/rkelly/nodes/function_decl_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class FunctionDeclNode < FunctionExprNode
+    end
+  end
+end

lib/rkelly/nodes/function_expr_node.rb

@@ -0,0 +1,12 @@
+module RKelly
+  module Nodes
+    class FunctionExprNode < Node
+      attr_reader :function_body, :arguments
+      def initialize(name, body, args = [])
+        super(name)
+        @function_body = body
+        @arguments = args
+      end
+    end
+  end
+end

lib/rkelly/nodes/if_node.rb

@@ -0,0 +1,12 @@
+module RKelly
+  module Nodes
+    class IfNode < Node
+      attr_reader :conditions, :else
+      def initialize(conditions, value, else_stmt = nil)
+        super(value)
+        @conditions = conditions
+        @else = else_stmt
+      end
+    end
+  end
+end

lib/rkelly/nodes/label_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class LabelNode < Node
+      attr_reader :name
+      def initialize(name, value)
+        super(value)
+        @name = name
+      end
+    end
+  end
+end

lib/rkelly/nodes/new_expr_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class NewExprNode < Node
+      attr_reader :arguments
+      def initialize(value, args)
+        super(value)
+        @arguments = args
+      end
+    end
+  end
+end

lib/rkelly/nodes/node.rb

@@ -0,0 +1,88 @@
+module RKelly
+  module Nodes
+    class Node
+      include RKelly::Visitable
+      include RKelly::Visitors
+      include Enumerable
+
+      attr_accessor :value, :comments, :line, :filename
+      def initialize(value)
+        @value = value
+        @comments = []
+        @filename = @line = nil
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && @value == other.value
+      end
+      alias :=~ :==
+
+      def ===(other)
+        other.is_a?(self.class) && @value === other.value
+      end
+
+      def pointcut(pattern)
+        case pattern
+        when String
+          ast = RKelly::Parser.new.parse(pattern)
+          # Only take the first statement
+          finder = ast.value.first.class.to_s =~ /StatementNode$/ ?
+            ast.value.first.value : ast.value.first
+          visitor = PointcutVisitor.new(finder)
+        else
+          visitor = PointcutVisitor.new(pattern)
+        end
+
+        visitor.accept(self)
+        visitor
+      end
+      alias :/ :pointcut
+
+      def to_sexp
+        SexpVisitor.new.accept(self)
+      end
+
+      def to_ecma
+        ECMAVisitor.new.accept(self)
+      end
+
+      def to_dots
+        visitor = DotVisitor.new
+        visitor.accept(self)
+        header = <<-END
+digraph g {
+graph [ rankdir = "TB" ];
+node [
+  fontsize = "16"
+  shape = "ellipse"
+];
+edge [ ];
+        END
+        nodes = visitor.nodes.map { |x| x.to_s }.join("\n")
+        counter = 0
+        arrows = visitor.arrows.map { |x|
+          s = "#{x} [\nid = #{counter}\n];"
+          counter += 1
+          s
+        }.join("\n")
+        "#{header}\n#{nodes}\n#{arrows}\n}"
+      end
+
+      def each(&block)
+        EnumerableVisitor.new(block).accept(self)
+      end
+
+      def to_real_sexp
+        RealSexpVisitor.new.accept(self)
+      end
+    end
+
+    %w[EmptyStatement Parenthetical ExpressionStatement True Delete Return TypeOf
+       SourceElements Number LogicalNot AssignExpr FunctionBody
+       ObjectLiteral UnaryMinus Throw This BitwiseNot Element String
+       Array CaseBlock Null Break Parameter Block False Void Regexp
+       Arguments Attr Continue ConstStatement UnaryPlus VarStatement].each do |node|
+      eval "class #{node}Node < Node; end"
+    end
+  end
+end

lib/rkelly/nodes/not_strict_equal_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class NotStrictEqualNode < BinaryNode
+    end
+  end
+end

lib/rkelly/nodes/op_equal_node.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Nodes
+    class OpEqualNode < Node
+      attr_reader :left
+      def initialize(left, right)
+        super(right)
+        @left = left
+      end
+    end
+
+    %w[Multiply Divide LShift Minus Plus Mod XOr RShift And URShift Or].each do |node|
+      eval "class Op#{node}EqualNode < OpEqualNode; end"
+    end
+
+  end
+end

lib/rkelly/nodes/postfix_node.rb

@@ -0,0 +1,11 @@
+module RKelly
+  module Nodes
+    class PostfixNode < Node
+      attr_reader :operand
+      def initialize(operand, operator)
+        super(operator)
+        @operand = operand
+      end
+    end
+  end
+end

lib/rkelly/nodes/prefix_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class PrefixNode < PostfixNode
+    end
+  end
+end

lib/rkelly/nodes/property_node.rb

@@ -0,0 +1,13 @@
+module RKelly
+  module Nodes
+    class PropertyNode < Node
+      attr_reader :name
+      def initialize(name, value)
+        super(value)
+        @name = name
+      end
+    end
+
+    %w[Getter Setter].each {|node| eval "class #{node}PropertyNode < PropertyNode; end"}
+  end
+end

lib/rkelly/nodes/resolve_node.rb

@@ -0,0 +1,19 @@
+module RKelly
+  module Nodes
+    class ResolveNode < Node
+      def ==(other)
+        return true if super
+        if @value =~ /^[A-Z]/
+          place = [Object, Module, RKelly::Nodes].find { |x|
+            x.const_defined?(@value.to_sym)
+          }
+          return false unless place
+          klass = place.const_get(@value.to_sym)
+          return true if klass && other.is_a?(klass) || other.value.is_a?(klass)
+        end
+        false
+      end
+      alias :=~ :==
+    end
+  end
+end

lib/rkelly/nodes/strict_equal_node.rb

@@ -0,0 +1,6 @@
+module RKelly
+  module Nodes
+    class StrictEqualNode < BinaryNode
+    end
+  end
+end

lib/rkelly/nodes/try_node.rb

@@ -0,0 +1,13 @@
+module RKelly
+  module Nodes
+    class TryNode < Node
+      attr_reader :catch_var, :catch_block, :finally_block
+      def initialize(value, catch_var, catch_block, finally_block = nil)
+        super(value)
+        @catch_var = catch_var
+        @catch_block = catch_block
+        @finally_block = finally_block
+      end
+    end
+  end
+end

lib/rkelly/nodes/var_decl_node.rb

@@ -0,0 +1,15 @@
+module RKelly
+  module Nodes
+    class VarDeclNode < Node
+      attr_accessor :name, :type
+      def initialize(name, value, constant = false)
+        super(value)
+        @name = name
+        @constant = constant
+      end
+
+      def constant?; @constant; end
+      def variable?; !@constant; end
+    end
+  end
+end

lib/rkelly/parser.rb

@@ -0,0 +1,104 @@
+require 'rkelly/tokenizer'
+require 'rkelly/generated_parser'
+
+
+module RKelly
+  class Parser < RKelly::GeneratedParser
+    TOKENIZER = Tokenizer.new
+
+    RKelly::GeneratedParser.instance_methods.each do |im|
+      next unless im.to_s =~ /^_reduce_\d+$/
+      eval(<<-eoawesomehack)
+        def #{im}(val, _values, result)
+          r = super(val.map { |v|
+              v.is_a?(Token) ? v.to_racc_token[1] : v
+            }, _values, result)
+          if token = val.find { |v| v.is_a?(Token) }
+            r.line = token.line if r.respond_to?(:line)
+            r.filename = @filename if r.respond_to?(:filename)
+          end
+          r
+        end
+      eoawesomehack
+    end
+
+    attr_accessor :logger
+    def initialize
+      @tokens = []
+      @logger = nil
+      @terminator = false
+      @prev_token = nil
+      @comments = []
+    end
+
+    # Parse +javascript+ and return an AST
+    def parse(javascript, filename = nil)
+      @tokens = TOKENIZER.raw_tokens(javascript)
+      @position = 0
+      @filename = filename
+      ast = do_parse
+      apply_comments(ast)
+    end
+
+    def yyabort
+      raise "something bad happened, please report a bug with sample JavaScript"
+    end
+
+    private
+    def apply_comments(ast)
+      ast_hash = Hash.new { |h,k| h[k] = [] }
+      (ast || []).each { |n|
+        next unless n.line
+        ast_hash[n.line] << n
+      }
+      max = ast_hash.keys.sort.last
+      @comments.each do |comment|
+        node = nil
+        comment.line.upto(max) do |line|
+          if ast_hash.key?(line)
+            node = ast_hash[line].first
+            break
+          end
+        end
+        node.comments << comment if node
+      end if max
+      ast
+    end
+
+    def on_error(error_token_id, error_value, value_stack)
+      if logger
+        logger.error(token_to_str(error_token_id))
+        logger.error("error value: #{error_value}")
+        logger.error("error stack: #{value_stack}")
+      end
+    end
+
+    def next_token
+      @terminator = false
+      begin
+        return [false, false] if @position >= @tokens.length
+        n_token = @tokens[@position]
+        @position += 1
+        case @tokens[@position - 1].name
+        when :COMMENT
+          @comments << n_token
+          @terminator = true if n_token.value =~ /^\/\//
+        when :S
+          @terminator = true if n_token.value =~ /[\r\n]/
+        end
+      end while([:COMMENT, :S].include?(n_token.name))
+
+      if @terminator &&
+          ((@prev_token && %w[continue break return throw].include?(@prev_token.value)) ||
+           (n_token && %w[++ --].include?(n_token.value)))
+        @position -= 1
+        return (@prev_token = RKelly::Token.new(';', ';')).to_racc_token
+      end
+
+      @prev_token = n_token
+      v = n_token.to_racc_token
+      v[1] = n_token
+      v
+    end
+  end
+end

lib/rkelly/runtime.rb

@@ -0,0 +1,36 @@
+require 'rkelly/js'
+require 'rkelly/runtime/scope_chain'
+
+module RKelly
+  class Runtime
+    UNDEFINED = RKelly::JS::Property.new(:undefined, :undefined)
+
+    def initialize
+      @parser = Parser.new
+      @scope  = ScopeChain.new
+    end
+
+    # Execute +js+
+    def execute(js)
+      function_visitor  = Visitors::FunctionVisitor.new(@scope)
+      eval_visitor      = Visitors::EvaluationVisitor.new(@scope)
+      tree = @parser.parse(js)
+      function_visitor.accept(tree)
+      eval_visitor.accept(tree)
+      @scope
+    end
+
+    def call_function(function_name, *args)
+      function = @scope[function_name].value
+      @scope.new_scope { |chain|
+        function.js_call(chain, *(args.map { |x|
+          RKelly::JS::Property.new(:param, x)
+        }))
+      }.value
+    end
+
+    def define_function(function, &block)
+      @scope[function.to_s].function = block
+    end
+  end
+end

lib/rkelly/runtime/ruby_function.rb

@@ -0,0 +1,13 @@
+module RKelly
+  class Runtime
+    class RubyFunction
+      def initialize(&block)
+        @code = block
+      end
+
+      def call(chain, *args)
+        @code.call(*args)
+      end
+    end
+  end
+end

lib/rkelly/runtime/scope_chain.rb

@@ -0,0 +1,57 @@
+module RKelly
+  class Runtime
+    class ScopeChain
+      include RKelly::JS
+
+      def initialize(scope = Scope.new)
+        @chain = [GlobalObject.new]
+      end
+
+      def <<(scope)
+        @chain << scope
+      end
+
+      def has_property?(name)
+        scope = @chain.reverse.find { |x|
+          x.has_property?(name)
+        }
+        scope ? scope[name] : nil
+      end
+      
+      def [](name)
+        property = has_property?(name)
+        return property if property
+        @chain.last.properties[name]
+      end
+
+      def []=(name, value)
+        @chain.last.properties[name] = value
+      end
+
+      def pop
+        @chain.pop
+      end
+
+      def this
+        @chain.last
+      end
+
+      def new_scope(&block)
+        @chain << Scope.new
+        result = yield(self)
+        @chain.pop
+        result
+      end
+
+      def return=(value)
+        @chain.last.return = value
+      end
+
+      def return; @chain.last.return; end
+
+      def returned?
+        @chain.last.returned?
+      end
+    end
+  end
+end

lib/rkelly/syntax_error.rb

@@ -0,0 +1,4 @@
+module RKelly
+  class SyntaxError < ::SyntaxError
+  end
+end

lib/rkelly/token.rb

@@ -0,0 +1,15 @@
+module RKelly
+  class Token
+    attr_accessor :name, :value, :transformer, :line
+    def initialize(name, value, &transformer)
+      @name         = name
+      @value        = value
+      @transformer  = transformer
+    end
+
+    def to_racc_token
+      return transformer.call(name, value) if transformer
+      [name, value]
+    end
+  end
+end

lib/rkelly/tokenizer.rb

@@ -0,0 +1,136 @@
+require 'rkelly/lexeme'
+
+module RKelly
+  class Tokenizer
+    KEYWORDS = %w{
+      break case catch continue default delete do else finally for function
+      if in instanceof new return switch this throw try typeof var void while 
+      with 
+
+      const true false null debugger
+    }
+
+    RESERVED = %w{
+      abstract boolean byte char class double enum export extends
+      final float goto implements import int interface long native package
+      private protected public short static super synchronized throws
+      transient volatile
+    }
+
+    LITERALS = {
+      # Punctuators
+      '=='  => :EQEQ,
+      '!='  => :NE,
+      '===' => :STREQ,
+      '!==' => :STRNEQ,
+      '<='  => :LE,
+      '>='  => :GE,
+      '||'  => :OR,
+      '&&'  => :AND,
+      '++'  => :PLUSPLUS,
+      '--'  => :MINUSMINUS,
+      '<<'  => :LSHIFT,
+      '<<=' => :LSHIFTEQUAL,
+      '>>'  => :RSHIFT,
+      '>>=' => :RSHIFTEQUAL,
+      '>>>' => :URSHIFT,
+      '>>>='=> :URSHIFTEQUAL,
+      '&='  => :ANDEQUAL,
+      '%='  => :MODEQUAL,
+      '^='  => :XOREQUAL,
+      '|='  => :OREQUAL,
+      '+='  => :PLUSEQUAL,
+      '-='  => :MINUSEQUAL,
+      '*='  => :MULTEQUAL,
+      '/='  => :DIVEQUAL,
+    }
+
+    TOKENS_THAT_IMPLY_DIVISION = [:IDENT, :NUMBER, ')', ']', '}']
+
+    def initialize(&block)
+      @lexemes = []
+
+      token(:COMMENT, /\A\/(?:\*(?:.)*?\*\/|\/[^\n]*)/m)
+      token(:STRING, /\A"(?:[^"\\]*(?:\\.[^"\\]*)*)"|\A'(?:[^'\\]*(?:\\.[^'\\]*)*)'/m)
+
+      # A regexp to match floating point literals (but not integer literals).
+      token(:NUMBER, /\A\d+\.\d*(?:[eE][-+]?\d+)?|\A\d+(?:\.\d*)?[eE][-+]?\d+|\A\.\d+(?:[eE][-+]?\d+)?/m) do |type, value|
+        value.gsub!(/\.(\D)/, '.0\1') if value =~ /\.\w/
+        value.gsub!(/\.$/, '.0') if value =~ /\.$/
+        value.gsub!(/^\./, '0.') if value =~ /^\./
+        [type, eval(value)]
+      end
+      token(:NUMBER, /\A0[xX][\da-fA-F]+|\A0[0-7]*|\A\d+/) do |type, value|
+        [type, eval(value)]
+      end
+
+      token(:LITERALS,
+        Regexp.new(LITERALS.keys.sort_by { |x|
+          x.length
+        }.reverse.map { |x| "\\A#{x.gsub(/([|+*^])/, '\\\\\1')}" }.join('|')
+      )) do |type, value|
+        [LITERALS[value], value]
+      end
+
+      token(:IDENT, /\A([_\$A-Za-z][_\$0-9A-Za-z]*)/) do |type,value|
+        if KEYWORDS.include?(value)
+          [value.upcase.to_sym, value]
+        elsif RESERVED.include?(value)
+          [:RESERVED, value]
+        else
+          [type, value]
+        end
+      end
+
+      token(:REGEXP, /\A\/(?:[^\/\r\n\\]*(?:\\[^\r\n][^\/\r\n\\]*)*)\/[gi]*/)
+      token(:S, /\A[\s\r\n]*/m)
+
+      token(:SINGLE_CHAR, /\A./) do |type, value|
+        [value, value]
+      end
+    end
+  
+    def tokenize(string)
+      raw_tokens(string).map { |x| x.to_racc_token }
+    end
+
+    def raw_tokens(string)
+      tokens = []
+      line_number = 1
+      accepting_regexp = true
+      while string.length > 0
+        longest_token = nil
+
+        @lexemes.each { |lexeme|
+          next if lexeme.name == :REGEXP && !accepting_regexp
+
+          match = lexeme.match(string)
+          next if match.nil?
+          longest_token = match if longest_token.nil?
+          next if longest_token.value.length >= match.value.length
+          longest_token = match
+        }
+
+        accepting_regexp = followable_by_regex(longest_token)
+
+        longest_token.line = line_number
+        line_number += longest_token.value.scan(/\n/).length
+        string = string.slice(Range.new(longest_token.value.length, -1))
+        tokens << longest_token
+      end
+      tokens
+    end
+  
+    private
+    def token(name, pattern = nil, &block)
+      @lexemes << Lexeme.new(name, pattern, &block)
+    end
+
+    def followable_by_regex(current_token)
+     name = current_token.name
+     name = current_token.value if name == :SINGLE_CHAR
+     #the tokens that imply division vs. start of regex form a disjoint set
+     !TOKENS_THAT_IMPLY_DIVISION.include?(name)
+    end
+  end
+end

lib/rkelly/visitable.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Visitable
+    # Based off the visitor pattern from RubyGarden
+    def accept(visitor, &block)
+      klass = self.class.ancestors.find { |ancestor|
+        visitor.respond_to?("visit_#{ancestor.name.split(/::/)[-1]}")
+      }
+
+      if klass
+        visitor.send(:"visit_#{klass.name.split(/::/)[-1]}", self, &block)
+      else
+        raise "No visitor for '#{self.class}'"
+      end
+    end
+  end
+end

lib/rkelly/visitors.rb

@@ -0,0 +1,4 @@
+require 'rkelly/visitors/visitor'
+Dir[File.join(File.dirname(__FILE__), "visitors/*_visitor.rb")].each do |file|
+  require file[/rkelly\/visitors\/.*/]
+end

lib/rkelly/visitors/dot_visitor.rb

@@ -0,0 +1,228 @@
+module RKelly
+  module Visitors
+    class DotVisitor < Visitor
+      class Node < Struct.new(:node_id, :fields)
+        ESCAPE = /([<>"\\])/
+        def to_s
+          counter = 0
+          label = fields.map { |f|
+            s = "<f#{counter}> #{f.to_s.gsub(ESCAPE, '\\\\\1').gsub(/[\r\n]/,' ')}"
+            counter += 1
+            s
+          }.join('|')
+          "\"#{node_id}\" [\nlabel = \"#{label}\"\nshape = \"record\"\n];"
+        end
+      end
+
+      class Arrow < Struct.new(:from, :to, :label)
+        def to_s
+          "\"#{from.node_id}\":f0 -> \"#{to.node_id}\":f0"
+        end
+      end
+
+      attr_reader :nodes, :arrows
+      def initialize
+        @stack = []
+        @node_index = 0
+        @nodes  = []
+        @arrows = []
+      end
+
+      ## Terminal nodes
+      %w{
+        BreakNode ContinueNode EmptyStatementNode FalseNode
+        NullNode NumberNode ParameterNode RegexpNode ResolveNode StringNode
+        ThisNode TrueNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type, o.value].compact)
+          add_arrow_for(node)
+          @nodes << node
+        end
+      end
+      ## End Terminal nodes
+
+      # Single value nodes
+      %w{
+        AssignExprNode BitwiseNotNode BlockNode DeleteNode ElementNode
+        ExpressionStatementNode FunctionBodyNode LogicalNotNode ReturnNode
+        ThrowNode TypeOfNode UnaryMinusNode UnaryPlusNode VoidNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          o.value && o.value.accept(self)
+          @stack.pop
+        end
+      end
+      # End Single value nodes
+
+      # Binary nodes
+      %w{
+        AddNode BitAndNode BitOrNode BitXOrNode CaseClauseNode CommaNode
+        DivideNode DoWhileNode EqualNode GreaterNode GreaterOrEqualNode InNode
+        InstanceOfNode LeftShiftNode LessNode LessOrEqualNode LogicalAndNode
+        LogicalOrNode ModulusNode MultiplyNode NotEqualNode NotStrictEqualNode
+        OpAndEqualNode OpDivideEqualNode OpEqualNode OpLShiftEqualNode
+        OpMinusEqualNode OpModEqualNode OpMultiplyEqualNode OpOrEqualNode
+        OpPlusEqualNode OpRShiftEqualNode OpURShiftEqualNode OpXOrEqualNode
+        RightShiftNode StrictEqualNode SubtractNode SwitchNode
+        UnsignedRightShiftNode WhileNode WithNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          o.left && o.left.accept(self)
+          o.value && o.value.accept(self)
+          @stack.pop
+        end
+      end
+      # End Binary nodes
+
+      # Array Value Nodes
+      %w{
+        ArgumentsNode ArrayNode CaseBlockNode ConstStatementNode
+        ObjectLiteralNode SourceElementsNode VarStatementNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          o.value && o.value.each { |v| v && v.accept(self) }
+          @stack.pop
+        end
+      end
+      # END Array Value Nodes
+
+      # Name and Value Nodes
+      %w{
+        LabelNode PropertyNode GetterPropertyNode SetterPropertyNode VarDeclNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type, o.name || 'NULL'])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          o.value && o.value.accept(self)
+          @stack.pop
+        end
+      end
+      # END Name and Value Nodes
+
+      %w{ PostfixNode PrefixNode }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type, o.value])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          o.operand && o.operand.accept(self)
+          @stack.pop
+        end
+      end
+
+      def visit_ForNode(o)
+        node = Node.new(@node_index += 1, ['ForNode'])
+        add_arrow_for(node)
+        @nodes << node
+        @stack.push(node)
+        [:init, :test, :counter, :value].each do |method|
+          o.send(method) && o.send(method).accept(self)
+        end
+        @stack.pop
+      end
+
+      %w{ IfNode ConditionalNode }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          [:conditions, :value, :else].each do |method|
+            o.send(method) && o.send(method).accept(self)
+          end
+          @stack.pop
+        end
+      end
+
+      def visit_ForInNode(o)
+        node = Node.new(@node_index += 1, ['ForInNode'])
+        add_arrow_for(node)
+        @nodes << node
+        @stack.push(node)
+        [:left, :right, :value].each do |method|
+          o.send(method) && o.send(method).accept(self)
+        end
+        @stack.pop
+      end
+
+      def visit_TryNode(o)
+        node = Node.new(@node_index += 1, ['TryNode', o.catch_var || 'NULL'])
+        add_arrow_for(node)
+        @nodes << node
+        @stack.push(node)
+        [:value, :catch_block, :finally_block].each do |method|
+          o.send(method) && o.send(method).accept(self)
+        end
+        @stack.pop
+      end
+
+      def visit_BracketAccessorNode(o)
+        node = Node.new(@node_index += 1, ['BracketAccessorNode'])
+        add_arrow_for(node)
+        @nodes << node
+        @stack.push(node)
+        [:value, :accessor].each do |method|
+          o.send(method) && o.send(method).accept(self)
+        end
+        @stack.pop
+      end
+
+      %w{ NewExprNode FunctionCallNode }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          [:value, :arguments].each do |method|
+            o.send(method) && o.send(method).accept(self)
+          end
+          @stack.pop
+        end
+      end
+
+      %w{ FunctionExprNode FunctionDeclNode }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          node = Node.new(@node_index += 1, [type, o.value || 'NULL'])
+          add_arrow_for(node)
+          @nodes << node
+          @stack.push(node)
+          o.arguments.each { |a| a && a.accept(self) }
+          o.function_body && o.function_body.accept(self)
+          @stack.pop
+        end
+      end
+
+      def visit_DotAccessorNode(o)
+        node = Node.new(@node_index += 1, ['DotAccessorNode', o.accessor])
+        add_arrow_for(node)
+        @nodes << node
+        @stack.push(node)
+        [:value].each do |method|
+          o.send(method) && o.send(method).accept(self)
+        end
+        @stack.pop
+      end
+
+      private
+      def add_arrow_for(node, label = nil)
+        @arrows << Arrow.new(@stack.last, node, label) if @stack.length > 0
+      end
+
+    end
+  end
+end

lib/rkelly/visitors/ecma_visitor.rb

@@ -0,0 +1,327 @@
+module RKelly
+  module Visitors
+    class ECMAVisitor < Visitor
+      def initialize
+        @indent = 0
+      end
+
+      def visit_ParentheticalNode(o)
+        "(#{o.value.accept(self)})"
+      end
+
+      def visit_SourceElementsNode(o)
+        o.value.map { |x| "#{indent}#{x.accept(self)}" }.join("\n")
+      end
+
+      def visit_VarStatementNode(o)
+        "var #{o.value.map { |x| x.accept(self) }.join(', ')};"
+      end
+
+      def visit_ConstStatementNode(o)
+        "const #{o.value.map { |x| x.accept(self) }.join(', ')};"
+      end
+
+      def visit_VarDeclNode(o)
+        "#{o.name}#{o.value ? o.value.accept(self) : nil}"
+      end
+
+      def visit_AssignExprNode(o)
+        " = #{o.value.accept(self)}"
+      end
+
+      def visit_NumberNode(o)
+        o.value.to_s
+      end
+
+      def visit_ForNode(o)
+        init    = o.init ? o.init.accept(self) : ';'
+        test    = o.test ? o.test.accept(self) : ''
+        counter = o.counter ? o.counter.accept(self) : ''
+        # VarStatementNodes will have a ; appended automatically, but other
+        # expressions won't, so make sure it's there
+        if init[-1,1] != ';'
+            init += ';'
+        end
+        "for(#{init} #{test}; #{counter}) #{o.value.accept(self)}"
+      end
+
+      def visit_LessNode(o)
+        "#{o.left.accept(self)} < #{o.value.accept(self)}"
+      end
+
+      def visit_ResolveNode(o)
+        o.value
+      end
+
+      def visit_PostfixNode(o)
+        "#{o.operand.accept(self)}#{o.value}"
+      end
+
+      def visit_PrefixNode(o)
+        "#{o.value}#{o.operand.accept(self)}"
+      end
+
+      def visit_BlockNode(o)
+        @indent += 1
+        "{\n#{o.value.accept(self)}\n#{@indent -=1; indent}}"
+      end
+
+      def visit_ExpressionStatementNode(o)
+        "#{o.value.accept(self)};"
+      end
+
+      def visit_OpEqualNode(o)
+        "#{o.left.accept(self)} = #{o.value.accept(self)}"
+      end
+
+      def visit_FunctionCallNode(o)
+        "#{o.value.accept(self)}(#{o.arguments.accept(self)})"
+      end
+
+      def visit_ArgumentsNode(o)
+        o.value.map { |x| x.accept(self) }.join(', ')
+      end
+
+      def visit_StringNode(o)
+        o.value
+      end
+
+      def visit_NullNode(o)
+        "null"
+      end
+
+      def visit_FunctionDeclNode(o)
+        "#{indent}function #{o.value}(" +
+          "#{o.arguments.map { |x| x.accept(self) }.join(', ')})" +
+          "#{o.function_body.accept(self)}"
+      end
+
+      def visit_ParameterNode(o)
+        o.value
+      end
+
+      def visit_FunctionBodyNode(o)
+        @indent += 1
+        "{\n#{o.value.accept(self)}\n#{@indent -=1; indent}}"
+      end
+
+      def visit_BreakNode(o)
+        "break" + (o.value ? " #{o.value}" : '') + ';'
+      end
+
+      def visit_ContinueNode(o)
+        "continue" + (o.value ? " #{o.value}" : '') + ';'
+      end
+
+      def visit_TrueNode(o)
+        "true"
+      end
+
+      def visit_FalseNode(o)
+        "false"
+      end
+
+      def visit_EmptyStatementNode(o)
+        ';'
+      end
+
+      def visit_RegexpNode(o)
+        o.value
+      end
+
+      def visit_DotAccessorNode(o)
+        "#{o.value.accept(self)}.#{o.accessor}"
+      end
+
+      def visit_ThisNode(o)
+        "this"
+      end
+
+      def visit_BitwiseNotNode(o)
+        "~#{o.value.accept(self)}"
+      end
+
+      def visit_DeleteNode(o)
+        "delete #{o.value.accept(self)}"
+      end
+
+      def visit_ArrayNode(o)
+        "[#{o.value.map { |x| x ? x.accept(self) : '' }.join(', ')}]"
+      end
+
+      def visit_ElementNode(o)
+        o.value.accept(self)
+      end
+
+      def visit_LogicalNotNode(o)
+        "!#{o.value.accept(self)}"
+      end
+
+      def visit_UnaryMinusNode(o)
+        "-#{o.value.accept(self)}"
+      end
+
+      def visit_UnaryPlusNode(o)
+        "+#{o.value.accept(self)}"
+      end
+
+      def visit_ReturnNode(o)
+        "return" + (o.value ? " #{o.value.accept(self)}" : '') + ';'
+      end
+
+      def visit_ThrowNode(o)
+        "throw #{o.value.accept(self)};"
+      end
+
+      def visit_TypeOfNode(o)
+        "typeof #{o.value.accept(self)}"
+      end
+
+      def visit_VoidNode(o)
+        "void(#{o.value.accept(self)})"
+      end
+
+      [
+        [:Add, '+'],
+        [:BitAnd, '&'],
+        [:BitOr, '|'],
+        [:BitXOr, '^'],
+        [:Divide, '/'],
+        [:Equal, '=='],
+        [:Greater, '>'],
+        [:Greater, '>'],
+        [:GreaterOrEqual, '>='],
+        [:GreaterOrEqual, '>='],
+        [:In, 'in'],
+        [:InstanceOf, 'instanceof'],
+        [:LeftShift, '<<'],
+        [:LessOrEqual, '<='],
+        [:LogicalAnd, '&&'],
+        [:LogicalOr, '||'],
+        [:Modulus, '%'],
+        [:Multiply, '*'],
+        [:NotEqual, '!='],
+        [:NotStrictEqual, '!=='],
+        [:OpAndEqual, '&='],
+        [:OpDivideEqual, '/='],
+        [:OpLShiftEqual, '<<='],
+        [:OpMinusEqual, '-='],
+        [:OpModEqual, '%='],
+        [:OpMultiplyEqual, '*='],
+        [:OpOrEqual, '|='],
+        [:OpPlusEqual, '+='],
+        [:OpRShiftEqual, '>>='],
+        [:OpURShiftEqual, '>>>='],
+        [:OpXOrEqual, '^='],
+        [:RightShift, '>>'],
+        [:StrictEqual, '==='],
+        [:Subtract, '-'],
+        [:UnsignedRightShift, '>>>'],
+      ].each do |name,op|
+        define_method(:"visit_#{name}Node") do |o|
+          "#{o.left.accept(self)} #{op} #{o.value.accept(self)}"
+        end
+      end
+
+      def visit_WhileNode(o)
+        "while(#{o.left.accept(self)}) #{o.value.accept(self)}"
+      end
+
+      def visit_SwitchNode(o)
+        "switch(#{o.left.accept(self)}) #{o.value.accept(self)}"
+      end
+
+      def visit_CaseBlockNode(o)
+        @indent += 1
+        "{\n" + (o.value ? o.value.map { |x| x.accept(self) }.join('') : '') +
+          "#{@indent -=1; indent}}"
+      end
+
+      def visit_CaseClauseNode(o)
+        if o.left
+            case_code = "#{indent}case #{o.left.accept(self)}:\n"
+        else
+            case_code = "#{indent}default:\n"
+        end
+        @indent += 1
+        case_code += "#{o.value.accept(self)}\n"
+        @indent -= 1
+        case_code
+      end
+
+      def visit_DoWhileNode(o)
+        "do #{o.left.accept(self)} while(#{o.value.accept(self)});"
+      end
+
+      def visit_WithNode(o)
+        "with(#{o.left.accept(self)}) #{o.value.accept(self)}"
+      end
+
+      def visit_LabelNode(o)
+        "#{o.name}: #{o.value.accept(self)}"
+      end
+
+      def visit_ObjectLiteralNode(o)
+        @indent += 1
+        lit = "{" + (o.value.length > 0 ? "\n" : ' ') +
+          o.value.map { |x| "#{indent}#{x.accept(self)}" }.join(",\n") +
+          (o.value.length > 0 ? "\n" : '') + '}'
+        @indent -= 1
+        lit
+      end
+
+      def visit_PropertyNode(o)
+        "#{o.name}: #{o.value.accept(self)}"
+      end
+
+      def visit_GetterPropertyNode(o)
+        "get #{o.name}#{o.value.accept(self)}"
+      end
+
+      def visit_SetterPropertyNode(o)
+        "set #{o.name}#{o.value.accept(self)}"
+      end
+
+      def visit_FunctionExprNode(o)
+        "#{o.value}(#{o.arguments.map { |x| x.accept(self) }.join(', ')}) " +
+          "#{o.function_body.accept(self)}"
+      end
+
+      def visit_CommaNode(o)
+        "#{o.left.accept(self)}, #{o.value.accept(self)}"
+      end
+
+      def visit_IfNode(o)
+        "if(#{o.conditions.accept(self)}) #{o.value.accept(self)}" +
+          (o.else ? " else #{o.else.accept(self)}" : '')
+      end
+
+      def visit_ConditionalNode(o)
+        "#{o.conditions.accept(self)} ? #{o.value.accept(self)} : " +
+          "#{o.else.accept(self)}"
+      end
+
+      def visit_ForInNode(o)
+        "for(#{o.left.accept(self)} in #{o.right.accept(self)}) " +
+          "#{o.value.accept(self)}"
+      end
+
+      def visit_TryNode(o)
+        "try #{o.value.accept(self)}" +
+          (o.catch_block ? " catch(#{o.catch_var}) #{o.catch_block.accept(self)}" : '') +
+          (o.finally_block ? " finally #{o.finally_block.accept(self)}" : '')
+      end
+
+      def visit_BracketAccessorNode(o)
+        "#{o.value.accept(self)}[#{o.accessor.accept(self)}]"
+      end
+
+      def visit_NewExprNode(o)
+        "new #{o.value.accept(self)}(#{o.arguments.accept(self)})"
+      end
+
+      private
+      def indent; ' ' * @indent * 2; end
+    end
+  end
+end

lib/rkelly/visitors/enumerable_visitor.rb

@@ -0,0 +1,18 @@
+module RKelly
+  module Visitors
+    class EnumerableVisitor < Visitor
+      def initialize(block)
+        @block = block
+      end
+
+      ALL_NODES.each do |type|
+        eval <<-RUBY
+          def visit_#{type}Node(o)
+            @block[o]
+            super
+          end
+        RUBY
+      end
+    end
+  end
+end

lib/rkelly/visitors/evaluation_visitor.rb

@@ -0,0 +1,419 @@
+module RKelly
+  module Visitors
+    class EvaluationVisitor < Visitor
+      attr_reader :scope_chain
+      def initialize(scope)
+        super()
+        @scope_chain = scope
+        @operand = []
+      end
+
+      def visit_SourceElementsNode(o)
+        o.value.each { |x|
+          next if scope_chain.returned?
+          x.accept(self)
+        }
+      end
+
+      def visit_FunctionDeclNode(o)
+      end
+
+      def visit_VarStatementNode(o)
+        o.value.each { |x| x.accept(self) }
+      end
+
+      def visit_VarDeclNode(o)
+        @operand << o.name
+        o.value.accept(self) if o.value
+        @operand.pop
+      end
+
+      def visit_IfNode(o)
+        truthiness = o.conditions.accept(self)
+        if truthiness.value && truthiness.value != 0
+          o.value.accept(self)
+        else
+          o.else && o.else.accept(self)
+        end
+      end
+
+      def visit_ResolveNode(o)
+        scope_chain[o.value]
+      end
+
+      def visit_ThisNode(o)
+        scope_chain.this
+      end
+
+      def visit_ExpressionStatementNode(o)
+        o.value.accept(self)
+      end
+
+      def visit_AddNode(o)
+        left  = to_primitive(o.left.accept(self), 'Number')
+        right = to_primitive(o.value.accept(self), 'Number')
+
+        if left.value.is_a?(::String) || right.value.is_a?(::String)
+          RKelly::JS::Property.new(:add,
+            "#{left.value}#{right.value}"
+          )
+        else
+          additive_operator(:+, left, right)
+        end
+      end
+
+      def visit_SubtractNode(o)
+        RKelly::JS::Property.new(:subtract,
+          o.left.accept(self).value - o.value.accept(self).value
+        )
+      end
+
+      def visit_MultiplyNode(o)
+        left = to_number(o.left.accept(self)).value
+        right = to_number(o.value.accept(self)).value
+        return_val = 
+          if [left, right].any? { |x| x.respond_to?(:nan?) && x.nan? }
+            RKelly::JS::NaN.new
+          else
+            [left, right].any? { |x|
+              x.respond_to?(:intinite?) && x.infinite?
+            } && [left, right].any? { |x| x == 0
+            } ? RKelly::JS::NaN.new : left * right
+          end
+        RKelly::JS::Property.new(:multiple, return_val)
+      end
+
+      def visit_DivideNode(o)
+        left = to_number(o.left.accept(self)).value
+        right = to_number(o.value.accept(self)).value
+        return_val = 
+          if [left, right].any? { |x|
+            x.respond_to?(:nan?) && x.nan? ||
+            x.respond_to?(:intinite?) && x.infinite?
+          }
+            RKelly::JS::NaN.new
+          elsif [left, right].all? { |x| x == 0 }
+            RKelly::JS::NaN.new
+          elsif right == 0
+            left * (right.eql?(0) ? (1.0/0.0) : (-1.0/0.0))
+          else
+            left / right
+          end
+        RKelly::JS::Property.new(:divide, return_val)
+      end
+
+      def visit_ModulusNode(o)
+        left = to_number(o.left.accept(self)).value
+        right = to_number(o.value.accept(self)).value
+        return_val = 
+          if [left, right].any? { |x| x.respond_to?(:nan?) && x.nan? }
+            RKelly::JS::NaN.new
+          elsif [left, right].all? { |x| x.respond_to?(:infinite?) && x.infinite? }
+            RKelly::JS::NaN.new
+          elsif right == 0
+            RKelly::JS::NaN.new
+          elsif left.respond_to?(:infinite?) && left.infinite?
+            RKelly::JS::NaN.new
+          elsif right.respond_to?(:infinite?) && right.infinite?
+            left
+          else
+            left % right
+          end
+        RKelly::JS::Property.new(:divide, return_val)
+      end
+
+      def visit_OpEqualNode(o)
+        left = o.left.accept(self)
+        right = o.value.accept(self)
+        left.value = right.value
+        left.function = right.function
+        left
+      end
+
+      def visit_OpPlusEqualNode(o)
+        o.left.accept(self).value += o.value.accept(self).value
+      end
+
+      def visit_AssignExprNode(o)
+        scope_chain[@operand.last] = o.value.accept(self)
+      end
+
+      def visit_NumberNode(o)
+        RKelly::JS::Property.new(o.value, o.value)
+      end
+
+      def visit_VoidNode(o)
+        o.value.accept(self)
+        RKelly::JS::Property.new(:undefined, :undefined)
+      end
+
+      def visit_NullNode(o)
+        RKelly::JS::Property.new(nil, nil)
+      end
+
+      def visit_TrueNode(o)
+        RKelly::JS::Property.new(true, true)
+      end
+
+      def visit_FalseNode(o)
+        RKelly::JS::Property.new(false, false)
+      end
+
+      def visit_StringNode(o)
+        RKelly::JS::Property.new(:string,
+          o.value.gsub(/\A['"]/, '').gsub(/['"]$/, '')
+        )
+      end
+
+      def visit_FunctionCallNode(o)
+        left      = o.value.accept(self)
+        arguments = o.arguments.accept(self)
+        call_function(left, arguments)
+      end
+
+      def visit_NewExprNode(o)
+        visit_FunctionCallNode(o)
+      end
+
+      def visit_DotAccessorNode(o)
+        left = o.value.accept(self)
+        right = left.value[o.accessor]
+        right.binder = left.value
+        right
+      end
+
+      def visit_EqualNode(o)
+        left = o.left.accept(self)
+        right = o.value.accept(self)
+
+        RKelly::JS::Property.new(:equal_node, left.value == right.value)
+      end
+
+      def visit_BlockNode(o)
+        o.value.accept(self)
+      end
+
+      def visit_FunctionBodyNode(o)
+        o.value.accept(self)
+        scope_chain.return
+      end
+
+      def visit_ReturnNode(o)
+        scope_chain.return = o.value.accept(self)
+      end
+
+      def visit_BitwiseNotNode(o)
+        orig = o.value.accept(self)
+        number = to_int_32(orig)
+        RKelly::JS::Property.new(nil, ~number.value)
+      end
+
+      def visit_PostfixNode(o)
+        orig = o.operand.accept(self)
+        number = to_number(orig)
+        case o.value
+        when '++'
+          orig.value = number.value + 1
+        when '--'
+          orig.value = number.value - 1
+        end
+        number
+      end
+
+      def visit_PrefixNode(o)
+        orig = o.operand.accept(self)
+        number = to_number(orig)
+        case o.value
+        when '++'
+          orig.value = number.value + 1
+        when '--'
+          orig.value = number.value - 1
+        end
+        orig
+      end
+
+      def visit_LogicalNotNode(o)
+        bool = to_boolean(o.value.accept(self))
+        bool.value = !bool.value
+        bool
+      end
+
+      def visit_ArgumentsNode(o)
+        o.value.map { |x| x.accept(self) }
+      end
+
+      def visit_TypeOfNode(o)
+        val = o.value.accept(self)
+        return RKelly::JS::Property.new(:string, 'object') if val.value.nil?
+
+        case val.value
+        when String
+          RKelly::JS::Property.new(:string, 'string')
+        when Numeric
+          RKelly::JS::Property.new(:string, 'number')
+        when true
+          RKelly::JS::Property.new(:string, 'boolean')
+        when false
+          RKelly::JS::Property.new(:string, 'boolean')
+        when :undefined
+          RKelly::JS::Property.new(:string, 'undefined')
+        else
+          RKelly::JS::Property.new(:object, 'object')
+        end
+      end
+
+      def visit_UnaryPlusNode(o)
+        orig = o.value.accept(self)
+        to_number(orig)
+      end
+
+      def visit_UnaryMinusNode(o)
+        orig = o.value.accept(self)
+        v = to_number(orig)
+        v.value = v.value == 0 ? -0.0 : 0 - v.value
+        v
+      end
+
+      %w{
+        ArrayNode BitAndNode BitOrNode
+        BitXOrNode BracketAccessorNode BreakNode
+        CaseBlockNode CaseClauseNode CommaNode ConditionalNode
+        ConstStatementNode ContinueNode DeleteNode
+        DoWhileNode ElementNode EmptyStatementNode
+        ForInNode ForNode
+        FunctionExprNode GetterPropertyNode GreaterNode GreaterOrEqualNode
+        InNode InstanceOfNode LabelNode LeftShiftNode LessNode
+        LessOrEqualNode LogicalAndNode LogicalOrNode
+        NotEqualNode NotStrictEqualNode
+        ObjectLiteralNode OpAndEqualNode OpDivideEqualNode
+        OpLShiftEqualNode OpMinusEqualNode OpModEqualNode
+        OpMultiplyEqualNode OpOrEqualNode OpRShiftEqualNode
+        OpURShiftEqualNode OpXOrEqualNode ParameterNode
+        PropertyNode RegexpNode RightShiftNode
+        SetterPropertyNode StrictEqualNode
+        SwitchNode ThrowNode TryNode
+        UnsignedRightShiftNode
+        WhileNode WithNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+          raise "#{type} not defined"
+        end
+      end
+
+      private
+      def to_number(object)
+        return RKelly::JS::Property.new('0', 0) unless object.value
+
+        return_val =
+          case object.value
+          when :undefined
+            RKelly::JS::NaN.new
+          when false
+            0
+          when true
+            1
+          when Numeric
+            object.value
+          when ::String
+            s = object.value.gsub(/(\A[\s\xB\xA0]*|[\s\xB\xA0]*\Z)/, '')
+            if s.length == 0
+              0
+            else
+              case s
+              when /^([+-])?Infinity/
+                $1 == '-' ? -1.0/0.0 : 1.0/0.0
+              when /\A[-+]?\d+\.\d*(?:[eE][-+]?\d+)?$|\A[-+]?\d+(?:\.\d*)?[eE][-+]?\d+$|\A[-+]?\.\d+(?:[eE][-+]?\d+)?$/, /\A[-+]?0[xX][\da-fA-F]+$|\A[+-]?0[0-7]*$|\A[+-]?\d+$/
+                s.gsub!(/\.(\D)/, '.0\1') if s =~ /\.\w/
+                s.gsub!(/\.$/, '.0') if s =~ /\.$/
+                s.gsub!(/^\./, '0.') if s =~ /^\./
+                s.gsub!(/^([+-])\./, '\10.') if s =~ /^[+-]\./
+                s = s.gsub(/^[0]*/, '') if /^0[1-9]+$/.match(s)
+                eval(s)
+              else
+                RKelly::JS::NaN.new
+              end
+            end
+          when RKelly::JS::Base
+            return to_number(to_primitive(object, 'Number'))
+          end
+        RKelly::JS::Property.new(nil, return_val)
+      end
+
+      def to_boolean(object)
+        return RKelly::JS::Property.new(false, false) unless object.value
+        value = object.value
+        boolean =
+          case value
+          when :undefined
+            false
+          when true
+            true
+          when Numeric
+            value == 0 || value.respond_to?(:nan?) && value.nan? ? false : true
+          when ::String
+            value.length == 0 ? false : true
+          when RKelly::JS::Base
+            true
+          else
+            raise
+          end
+        RKelly::JS::Property.new(boolean, boolean)
+      end
+
+      def to_int_32(object)
+        number = to_number(object)
+        value = number.value
+        return number if value == 0
+        if value.respond_to?(:nan?) && (value.nan? || value.infinite?)
+          RKelly::JS::Property.new(nil, 0)
+        end
+        value = ((value < 0 ? -1 : 1) * value.abs.floor) % (2 ** 32)
+        if value >= 2 ** 31
+          RKelly::JS::Property.new(nil, value - (2 ** 32))
+        else
+          RKelly::JS::Property.new(nil, value)
+        end
+      end
+
+      def to_primitive(object, preferred_type = nil)
+        return object unless object.value
+        case object.value
+        when false, true, :undefined, ::String, Numeric
+          RKelly::JS::Property.new(nil, object.value)
+        when RKelly::JS::Base
+          call_function(object.value.default_value(preferred_type))
+        end
+      end
+
+      def additive_operator(operator, left, right)
+        left, right = to_number(left).value, to_number(right).value
+
+        left = left.respond_to?(:nan?) && left.nan? ? 0.0/0.0 : left
+        right = right.respond_to?(:nan?) && right.nan? ? 0.0/0.0 : right
+
+        result = left.send(operator, right)
+        result = result.respond_to?(:nan?) && result.nan? ? JS::NaN.new : result
+
+        RKelly::JS::Property.new(operator, result)
+      end
+
+      def call_function(property, arguments = [])
+        function  = property.function || property.value
+        case function
+        when RKelly::JS::Function
+          scope_chain.new_scope { |chain|
+            function.js_call(chain, *arguments)
+          }
+        when UnboundMethod
+          RKelly::JS::Property.new(:ruby,
+            function.bind(property.binder).call(*(arguments.map { |x| x.value}))
+          )
+        else
+          RKelly::JS::Property.new(:ruby,
+            function.call(*(arguments.map { |x| x.value }))
+          )
+        end
+      end
+    end
+  end
+end

lib/rkelly/visitors/function_visitor.rb

@@ -0,0 +1,46 @@
+module RKelly
+  module Visitors
+    class FunctionVisitor < Visitor
+      attr_reader :scope_chain
+      def initialize(scope)
+        super()
+        @scope_chain = scope
+      end
+
+      def visit_SourceElementsNode(o)
+        o.value.each { |x| x.accept(self) }
+      end
+
+      def visit_FunctionDeclNode(o)
+        if o.value
+          scope_chain[o.value].value = RKelly::JS::Function.new(o.function_body, o.arguments)
+        end
+      end
+
+      %w{
+        AddNode ArgumentsNode ArrayNode AssignExprNode BitAndNode BitOrNode
+        BitXOrNode BitwiseNotNode BlockNode BracketAccessorNode BreakNode
+        CaseBlockNode CaseClauseNode CommaNode ConditionalNode
+        ConstStatementNode ContinueNode DeleteNode DivideNode
+        DoWhileNode DotAccessorNode ElementNode EmptyStatementNode EqualNode
+        ExpressionStatementNode FalseNode ForInNode ForNode FunctionBodyNode
+        FunctionExprNode GetterPropertyNode GreaterNode GreaterOrEqualNode
+        IfNode InNode InstanceOfNode LabelNode LeftShiftNode LessNode
+        LessOrEqualNode LogicalAndNode LogicalNotNode LogicalOrNode ModulusNode
+        MultiplyNode NewExprNode NotEqualNode NotStrictEqualNode NullNode
+        NumberNode ObjectLiteralNode OpAndEqualNode OpDivideEqualNode
+        OpEqualNode OpLShiftEqualNode OpMinusEqualNode OpModEqualNode
+        OpMultiplyEqualNode OpOrEqualNode OpPlusEqualNode OpRShiftEqualNode
+        OpURShiftEqualNode OpXOrEqualNode ParameterNode PostfixNode PrefixNode
+        PropertyNode RegexpNode ResolveNode ReturnNode RightShiftNode
+        SetterPropertyNode StrictEqualNode StringNode
+        SubtractNode SwitchNode ThisNode ThrowNode TrueNode TryNode TypeOfNode
+        UnaryMinusNode UnaryPlusNode UnsignedRightShiftNode VarDeclNode
+        VarStatementNode VoidNode WhileNode WithNode
+      }.each do |type|
+        define_method(:"visit_#{type}") do |o|
+        end
+      end
+    end
+  end
+end

lib/rkelly/visitors/pointcut_visitor.rb

@@ -0,0 +1,31 @@
+module RKelly
+  module Visitors
+    class PointcutVisitor < Visitor
+      attr_reader :matches
+      def initialize(pattern, matches = [])
+        @pattern  = pattern
+        @matches  = matches
+      end
+
+      def >(pattern)
+        pattern =
+          case pattern
+          when Class
+            pattern.new(Object)
+          else
+            pattern
+          end
+        self.class.new(nil, @matches.map do |m|
+          m.pointcut(pattern).matches
+        end.flatten)
+      end
+
+      ALL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          @matches << o if @pattern === o
+          super(o)
+        end
+      end
+    end
+  end
+end

lib/rkelly/visitors/real_sexp_visitor.rb

@@ -0,0 +1,16 @@
+module RKelly
+  module Visitors
+    class RealSexpVisitor < Visitor
+      ALL_NODES.each do |type|
+        eval <<-RUBY
+          def visit_#{type}Node(o)
+            sexp = s(:#{type.scan(/[A-Z][a-z]+/).join('_').downcase}, *super(o))
+            sexp.line = o.line if o.line
+            sexp.file = o.filename
+            sexp
+          end
+        RUBY
+      end
+    end
+  end
+end

lib/rkelly/visitors/sexp_visitor.rb

@@ -0,0 +1,373 @@
+module RKelly
+  module Visitors
+    class SexpVisitor < Visitor
+      def visit_NumberNode(o)
+        [:lit, o.value]
+      end
+
+      def visit_RegexpNode(o)
+        [:lit, o.value]
+      end
+
+      def visit_AssignExprNode(o)
+        [:assign, super]
+      end
+
+      def visit_VarDeclNode(o)
+        [ o.constant? ? :const_decl : :var_decl ] + super(o)
+      end
+
+      def visit_VarStatementNode(o)
+        [:var, super]
+      end
+
+      def visit_PostfixNode(o)
+        [:postfix, super, o.value]
+      end
+
+      def visit_PrefixNode(o)
+        [:prefix, super, o.value]
+      end
+
+      def visit_DeleteNode(o)
+        [:delete, super]
+      end
+
+      def visit_VoidNode(o)
+        [:void, super]
+      end
+
+      def visit_TypeOfNode(o)
+        [:typeof, super]
+      end
+
+      def visit_UnaryPlusNode(o)
+        [:u_plus, super]
+      end
+
+      def visit_UnaryMinusNode(o)
+        [:u_minus, super]
+      end
+
+      def visit_BitwiseNotNode(o)
+        [:bitwise_not, super]
+      end
+
+      def visit_LogicalNotNode(o)
+        [:not, super]
+      end
+
+      def visit_ConstStatementNode(o)
+        [:const, super]
+      end
+
+      def visit_MultiplyNode(o)
+        [:multiply, *super]
+      end
+
+      def visit_DivideNode(o)
+        [:divide, *super]
+      end
+
+      def visit_ModulusNode(o)
+        [:modulus, *super]
+      end
+
+      def visit_AddNode(o)
+        [:add, *super]
+      end
+
+      def visit_LeftShiftNode(o)
+        [:lshift, *super]
+      end
+
+      def visit_RightShiftNode(o)
+        [:rshift, *super]
+      end
+
+      def visit_UnsignedRightShiftNode(o)
+        [:urshift, *super]
+      end
+
+      def visit_SubtractNode(o)
+        [:subtract, *super]
+      end
+
+      def visit_LessNode(o)
+        [:less, *super]
+      end
+
+      def visit_GreaterNode(o)
+        [:greater, *super]
+      end
+
+      def visit_LessOrEqualNode(o)
+        [:less_or_equal, *super]
+      end
+
+      def visit_GreaterOrEqualNode(o)
+        [:greater_or_equal, *super]
+      end
+
+      def visit_InstanceOfNode(o)
+        [:instance_of, *super]
+      end
+
+      def visit_EqualNode(o)
+        [:equal, *super]
+      end
+
+      def visit_NotEqualNode(o)
+        [:not_equal, *super]
+      end
+
+      def visit_StrictEqualNode(o)
+        [:strict_equal, *super]
+      end
+
+      def visit_NotStrictEqualNode(o)
+        [:not_strict_equal, *super]
+      end
+
+      def visit_BitAndNode(o)
+        [:bit_and, *super]
+      end
+
+      def visit_BitOrNode(o)
+        [:bit_or, *super]
+      end
+
+      def visit_BitXOrNode(o)
+        [:bit_xor, *super]
+      end
+
+      def visit_LogicalAndNode(o)
+        [:and, *super]
+      end
+
+      def visit_LogicalOrNode(o)
+        [:or, *super]
+      end
+
+      def visit_InNode(o)
+        [:in, *super]
+      end
+
+      def visit_DoWhileNode(o)
+        [:do_while, *super]
+      end
+
+      def visit_WhileNode(o)
+        [:while, *super]
+      end
+
+      def visit_WithNode(o)
+        [:with, *super]
+      end
+
+      def visit_CaseClauseNode(o)
+        [:case, *super]
+      end
+
+      def visit_CaseBlockNode(o)
+        [:case_block, super]
+      end
+
+      def visit_SwitchNode(o)
+        [:switch, *super]
+      end
+
+      def visit_ForNode(o)
+        [ :for, *super]
+      end
+
+      def visit_BlockNode(o)
+        [:block, super]
+      end
+
+      def visit_IfNode(o)
+        [:if, *super].compact
+      end
+
+      def visit_ConditionalNode(o)
+        [:conditional, *super]
+      end
+
+      def visit_ForInNode(o)
+        [ :for_in, *super]
+      end
+
+      def visit_TryNode(o)
+        [ :try, *super]
+      end
+
+      def visit_EmptyStatementNode(o)
+        [:empty]
+      end
+
+      def visit_FunctionBodyNode(o)
+        [:func_body, super]
+      end
+
+      def visit_ResolveNode(o)
+        [:resolve, o.value]
+      end
+
+      def visit_BracketAccessorNode(o)
+        [:bracket_access, *super]
+      end
+
+      def visit_NewExprNode(o)
+        [:new_expr, *super]
+      end
+
+      def visit_ParameterNode(o)
+        [:param, o.value]
+      end
+
+      def visit_BreakNode(o)
+        [:break, o.value].compact
+      end
+
+      def visit_ContinueNode(o)
+        [:continue, o.value].compact
+      end
+
+      def visit_LabelNode(o)
+        [:label ] + super
+      end
+
+      def visit_ThrowNode(o)
+        [:throw, super]
+      end
+
+      def visit_ObjectLiteralNode(o)
+        [:object, super]
+      end
+
+      def visit_PropertyNode(o)
+        [ :property ] + super
+      end
+
+      def visit_GetterPropertyNode(o)
+        [ :getter ] + super
+      end
+
+      def visit_SetterPropertyNode(o)
+        [ :setter ] + super
+      end
+
+      def visit_ElementNode(o)
+        [:element, super ]
+      end
+
+      def visit_ExpressionStatementNode(o)
+        [:expression, super ]
+      end
+
+      def visit_OpEqualNode(o)
+        [:op_equal, *super ]
+      end
+
+      def visit_OpPlusEqualNode(o)
+        [:op_plus_equal, *super ]
+      end
+
+      def visit_OpMinusEqualNode(o)
+        [:op_minus_equal, *super ]
+      end
+
+      def visit_OpMultiplyEqualNode(o)
+        [:op_multiply_equal, *super ]
+      end
+
+      def visit_OpDivideEqualNode(o)
+        [:op_divide_equal, *super]
+      end
+
+      def visit_OpLShiftEqualNode(o)
+        [:op_lshift_equal, *super ]
+      end
+
+      def visit_OpRShiftEqualNode(o)
+        [:op_rshift_equal, *super ]
+      end
+
+      def visit_OpURShiftEqualNode(o)
+        [:op_urshift_equal, *super ]
+      end
+
+      def visit_OpAndEqualNode(o)
+        [:op_and_equal, *super ]
+      end
+
+      def visit_OpXOrEqualNode(o)
+        [:op_xor_equal, *super ]
+      end
+
+      def visit_OpOrEqualNode(o)
+        [:op_or_equal, *super ]
+      end
+
+      def visit_OpModEqualNode(o)
+        [:op_mod_equal, *super]
+      end
+
+      def visit_CommaNode(o)
+        [:comma, *super]
+      end
+
+      def visit_FunctionCallNode(o)
+        [:function_call, *super]
+      end
+
+      def visit_ArrayNode(o)
+        [:array, super]
+      end
+
+      def visit_ThisNode(o)
+        [:this]
+      end
+
+      def visit_ReturnNode(o)
+        o.value ? [:return, super] : [:return]
+      end
+
+      def visit_FunctionExprNode(o)
+        [ :func_expr, *super]
+      end
+
+      def visit_FunctionDeclNode(o)
+        [ :func_decl, *super]
+      end
+
+      def visit_ArgumentsNode(o)
+        [:args, super]
+      end
+
+      def visit_DotAccessorNode(o)
+        [:dot_access,
+          super,
+          o.accessor
+        ]
+      end
+
+      def visit_NullNode(o)
+        [:nil]
+      end
+      
+      def visit_StringNode(o)
+        [:str, o.value]
+      end
+
+      def visit_FalseNode(o)
+        [:false]
+      end
+
+      def visit_TrueNode(o)
+        [:true]
+      end
+
+    end
+  end
+end

lib/rkelly/visitors/visitor.rb

@@ -0,0 +1,136 @@
+module RKelly
+  module Visitors
+    class Visitor
+      TERMINAL_NODES = %w{
+        Break Continue EmptyStatement False Null Number Parameter Regexp Resolve
+        String This True
+      }
+      SINGLE_VALUE_NODES = %w{
+        Parenthetical AssignExpr BitwiseNot Block Delete Element ExpressionStatement
+        FunctionBody LogicalNot Return Throw TypeOf UnaryMinus UnaryPlus Void
+      }
+      BINARY_NODES = %w{
+        Add BitAnd BitOr BitXOr CaseClause Comma Divide DoWhile Equal Greater
+        GreaterOrEqual In InstanceOf LeftShift Less LessOrEqual LogicalAnd
+        LogicalOr Modulus Multiply NotEqual NotStrictEqual OpAndEqual
+        OpDivideEqual OpEqual OpLShiftEqual OpMinusEqual OpModEqual
+        OpMultiplyEqual OpOrEqual OpPlusEqual OpRShiftEqual OpURShiftEqual
+        OpXOrEqual RightShift StrictEqual Subtract Switch UnsignedRightShift
+        While With
+      }
+      ARRAY_VALUE_NODES = %w{
+        Arguments Array CaseBlock ConstStatement ObjectLiteral SourceElements
+        VarStatement
+      }
+      NAME_VALUE_NODES = %w{
+        Label Property GetterProperty SetterProperty VarDecl
+      }
+      PREFIX_POSTFIX_NODES  = %w{ Postfix Prefix }
+      CONDITIONAL_NODES     = %w{ If Conditional }
+      FUNC_CALL_NODES       = %w{ NewExpr FunctionCall }
+      FUNC_DECL_NODES       = %w{ FunctionExpr FunctionDecl }
+      ALL_NODES = %w{ For ForIn Try BracketAccessor DotAccessor } +
+        TERMINAL_NODES + SINGLE_VALUE_NODES + BINARY_NODES + ARRAY_VALUE_NODES +
+        NAME_VALUE_NODES + PREFIX_POSTFIX_NODES + CONDITIONAL_NODES +
+        FUNC_CALL_NODES + FUNC_DECL_NODES
+
+      def accept(target)
+        target.accept(self)
+      end
+
+      TERMINAL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") { |o| o.value }
+      end
+
+      BINARY_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.left && o.left.accept(self), o.value && o.value.accept(self)]
+        end
+      end
+
+      ARRAY_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.value && o.value.map { |v| v ? v.accept(self) : nil }
+        end
+      end
+
+      NAME_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.name.to_s.to_sym, o.value ? o.value.accept(self) : nil]
+        end
+      end
+
+      SINGLE_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.value.accept(self) if o.value
+        end
+      end
+
+      PREFIX_POSTFIX_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.operand.accept(self)
+        end
+      end
+
+      CONDITIONAL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [ o.conditions.accept(self),
+            o.value.accept(self),
+            o.else ? o.else.accept(self) : nil
+          ]
+        end
+      end
+      FUNC_CALL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.value.accept(self), o.arguments.accept(self)]
+        end
+      end
+      FUNC_DECL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [
+            o.value ? o.value : nil,
+            o.arguments.map { |x| x.accept(self) },
+            o.function_body.accept(self)
+          ]
+        end
+      end
+
+      def visit_ForNode(o)
+        [
+          o.init ? o.init.accept(self) : nil,
+          o.test ? o.test.accept(self) : nil,
+          o.counter ? o.counter.accept(self) : nil,
+          o.value.accept(self)
+        ]
+      end
+
+      def visit_ForInNode(o)
+        [
+          o.left.accept(self),
+          o.right.accept(self),
+          o.value.accept(self)
+        ]
+      end
+
+      def visit_TryNode(o)
+        [
+          o.value.accept(self),
+          o.catch_var ? o.catch_var : nil,
+          o.catch_block ? o.catch_block.accept(self) : nil,
+          o.finally_block ? o.finally_block.accept(self) : nil
+        ]
+      end
+
+      def visit_BracketAccessorNode(o)
+        [
+          o.value.accept(self),
+          o.accessor.accept(self)
+        ]
+      end
+
+      def visit_DotAccessorNode(o)
+        o.value.accept(self)
+      end
+    end
+  end
+end