rkelly-turbo 0.1.0

data/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

data/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

data/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

data/lib/rkelly/syntax_error.rb

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

data/lib/rkelly/token.rb

@@ -0,0 +1,27 @@
+module RKelly
+  class Token
+    attr_accessor :name, :value, :transformer, :range
+    def initialize(name, value, &transformer)
+      @name         = name
+      @value        = value
+      @transformer  = transformer if transformer
+    end
+
+    # For backwards compatibility
+    def line
+      @range.from.line
+    end
+
+    def to_racc_token
+      if @transformer
+        @name, @value = @transformer.call(@name, @value)
+        @transformer = nil
+      end
+      [@name, @value]
+    end
+
+    def to_s
+      return "#{self.name}: #{self.value}"
+    end
+  end
+end

data/lib/rkelly/tokenizer.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require 'rkelly/lexeme'
+require 'rkelly/char_range'
+require 'strscan'
+
+module RKelly
+  class Tokenizer
+    KEYWORDS = Hash[%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
+    }.map {|kw| [kw, kw.upcase.to_sym] }]
+
+    # These 6 are always reserved in ECMAScript 5.1
+    # Some others are only reserved in strict mode, but RKelly doesn't
+    # differenciate between strict and non-strict mode code.
+    # http://www.ecma-international.org/ecma-262/5.1/#sec-7.6.1.2
+    # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Reserved_Words
+    RESERVED = Hash[%w{
+      class enum export extends import super
+    }.map {|kw| [kw, true] }]
+
+    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,
+    }
+
+    # Some keywords can be followed by regular expressions (eg, return and throw).
+    # Others can be followed by division.
+    KEYWORDS_THAT_IMPLY_DIVISION = {
+      'this' => true,
+      'true' => true,
+      'false' => true,
+      'null' => true,
+    }
+
+    KEYWORDS_THAT_IMPLY_REGEX = KEYWORDS.reject {|k,v| KEYWORDS_THAT_IMPLY_DIVISION[k] }
+
+    SINGLE_CHARS_THAT_IMPLY_DIVISION = {
+      ')' => true,
+      ']' => true,
+      '}' => true,
+    }
+
+    # Determine the method to use to measure String length in bytes,
+    # because StringScanner#pos can only be set in bytes.
+    #
+    # - In Ruby 1.8 String#length returns always the string length
+    #   in bytes.
+    #
+    # - In Ruby 1.9+ String#length returns string length in
+    #   characters and we need to use String#bytesize instead.
+    #
+    BYTESIZE_METHOD = "".respond_to?(:bytesize) ? :bytesize : :length
+
+    # JavaScript whitespace can consist of any Unicode space separator
+    # characters.
+    #
+    # - In Ruby 1.9+ we can just use the [[:space:]] character class
+    #   and match them all.
+    #
+    # - In Ruby 1.8 we need a regex that identifies the specific bytes
+    #   in UTF-8 text.
+    #
+    WHITESPACE_REGEX = "".respond_to?(:encoding) ? /[[:space:]]+/m : %r{
+      (
+        \xC2\xA0     |   # no-break space
+        \xE1\x9A\x80 |   # ogham space mark
+        \xE2\x80\x80 |   # en quad
+        \xE2\x80\x81 |   # em quad
+        \xE2\x80\x82 |   # en space
+        \xE2\x80\x83 |   # em space
+        \xE2\x80\x84 |   # three-per-em space
+        \xE2\x80\x85 |   # four-pre-em süace
+        \xE2\x80\x86 |   # six-per-em space
+        \xE2\x80\x87 |   # figure space
+        \xE2\x80\x88 |   # punctuation space
+        \xE2\x80\x89 |   # thin space
+        \xE2\x80\x8A |   # hair space
+        \xE2\x80\xA8 |   # line separator
+        \xE2\x80\xA9 |   # paragraph separator
+        \xE2\x80\xAF |   # narrow no-break space
+        \xE2\x81\x9F |   # medium mathematical space
+        \xE3\x80\x80     # ideographic space
+      )+
+    }mx
+
+    WORD_CHARS = (('a'..'z').to_a + ('A'..'Z').to_a + ['_', '$']).freeze
+    DIGITS = ('0'..'9').to_a.freeze
+    def initialize(&block)
+      @lexemes = Hash.new {|hash, key| hash[key] = [] }
+
+      token(:COMMENT, /\/(?:\*(?:.)*?\*\/|\/[^\n]*)/m, ['/'])
+      token(:STRING, /"(?:[^"\\]*(?:\\.[^"\\]*)*)"|'(?:[^'\\]*(?:\\.[^'\\]*)*)'/m, ["'", '"'])
+
+      # Matcher for basic ASCII whitespace.
+      # (Unicode whitespace is handled separately in #match_lexeme)
+      #
+      # Can't use just "\s" in regex, because in Ruby 1.8 this
+      # doesn't include the vertical tab "\v" character
+      token(:S, /[ \t\r\n\f\v]*/m, [" ", "\t", "\r", "\n", "\f", "\v"])
+
+      # A regexp to match floating point literals (but not integer literals).
+
+      token(:NUMBER, /\d+\.\d*(?:[eE][-+]?\d+)?|\d+(?:\.\d*)?[eE][-+]?\d+|\.\d+(?:[eE][-+]?\d+)?/m, DIGITS+['.']) do |type, value|
+        value.gsub!(/\.(\D)/, '.0\1') if value =~ /\.\w/
+        #value.gsub!(/\.$/, '.0') if value.end_with? '.'
+        #value.gsub!(/^\./, '0.') if value.start_with? '.'
+        [type, value.to_f]
+      end
+      token(:NUMBER, /0[xX][\da-fA-F]+|0[oO][0-7]+|0[0-7]*|\d+/, DIGITS) do |type, value|
+        [type, value.to_i(0)]
+      end
+
+      token(:RAW_IDENT, /([_\$A-Za-z][_\$0-9A-Za-z]*)/, WORD_CHARS) do |type,value|
+        if KEYWORDS[value]
+          [KEYWORDS[value], value]
+        elsif RESERVED[value]
+          [:RESERVED, value]
+        else
+          [:IDENT, value]
+        end
+      end
+
+      # To distinguish regular expressions from comments, we require that
+      # regular expressions start with a non * character (ie, not look like
+      # /*foo*/). Note that we can't depend on the length of the match to
+      # correctly distinguish, since `/**/i` is longer if matched as a regular
+      # expression than as matched as a comment.
+      # Incidentally, we're also not matching empty regular expressions
+      # (eg, // and //g). Here we could depend on match length and priority to
+      # determine that these are actually comments, but it turns out to be
+      # easier to not match them in the first place.
+      token(:REGEXP, %r{
+             /                  (?# beginning )
+
+             (?:
+               [^\r\n\[/\\]+      (?# any char except \r \n [ / \ )
+               |
+               \\ [^\r\n]         (?# escape sequence )
+               |
+               \[ (?:[^\]\\]|\\.)* \]   (?# [...] can contain any char including / )
+                                        (?# only \ and ] have to be escaped here )
+             )+
+
+             /[gimuy]*          (?# ending + modifiers )
+      }x, ['/'])
+
+      literal_chars = LITERALS.keys.map {|k| k.slice(0,1) }.uniq
+      literal_regex = Regexp.new(LITERALS.keys.sort_by { |x|
+          x.length
+        }.reverse.map { |x| "#{x.gsub(/([|+*^])/, '\\\\\1')}" }.join('|'))
+      token(:LITERALS, literal_regex, literal_chars) do |type, value|
+        [LITERALS[value], value]
+      end
+
+      symbols = ('!'..'/').to_a + (':'..'@').to_a + ('['..'^').to_a + ['`'] + ('{'..'~').to_a
+      token(:SINGLE_CHAR, /./, symbols) do |type, value|
+        [value, value]
+      end
+    end
+
+    def tokenize(string)
+      raw_tokens(string).map { |x| x.to_racc_token }
+    end
+
+    def raw_tokens(string)
+      scanner = StringScanner.new(string)
+      tokens = []
+      range = CharRange::EMPTY
+      accepting_regexp = true
+      while !scanner.eos?
+        token = match_lexeme(scanner, accepting_regexp)
+
+        if token.name != :S
+          accepting_regexp = followable_by_regex(token)
+        end
+
+        scanner.pos += token.value.send(BYTESIZE_METHOD)
+        token.range = range = range.next(token.value)
+        tokens << token
+      end
+      tokens
+    end
+
+    private
+
+    # Returns the token of the first matching lexeme
+    def match_lexeme(scanner, accepting_regexp)
+      lexemes = @lexemes[scanner.peek(1)].reverse
+      while lexeme = lexemes.pop
+        next if lexeme.name == :REGEXP && !accepting_regexp
+
+        token = lexeme.match(scanner)
+        return token if token
+      end
+
+      # When some other character encountered, try to match it as
+      # whitespace, as in JavaScript whitespace can contain any
+      # Unicode whitespace character.
+      if str = scanner.check(WHITESPACE_REGEX)
+        return Token.new(:S, str)
+      end
+    end
+
+    # Registers a lexeme and maps it to all the characters it can
+    # begin with.  So later when scanning the source we only need to
+    # match those lexemes that can begin with the character we're at.
+    def token(name, pattern, chars, &block)
+      lexeme = Lexeme.new(name, pattern, &block)
+      chars.each do |c|
+        @lexemes[c] << lexeme
+      end
+    end
+
+    def followable_by_regex(current_token)
+      case current_token.name
+      when :SINGLE_CHAR
+        !SINGLE_CHARS_THAT_IMPLY_DIVISION[current_token.value]
+      when :RAW_IDENT
+        KEYWORDS_THAT_IMPLY_REGEX[current_token.value]
+      when :NUMBER
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/rkelly/visitable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RKelly
+  module Visitable
+    # This is a big optimization impairing readability of this code. I'm sorry for
+    # that, but this path is called heavily. See git history.
+    module ClassMethods
+      def visitor_method_names_by_ancestors
+        @visitor_method_names_by_ancestors ||= self.ancestors.reject do |i|
+          %w[Kernel Object BasicObject Enumerable
+             RKelly::Visitors RKelly::Visitable PP::ObjectMixin].include? i.name.to_s
+        end.map do |ancestor|
+          :"visit_#{ancestor.name.split('::').last}"
+        end
+      end
+    end
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    # End of the big optimization
+
+    # Based off the visitor pattern from RubyGarden
+    def accept(visitor, &block)
+      klass, meth = self.class.visitor_method_names_by_ancestors.find do |meth|
+        return visitor.send(meth, self, &block) if visitor.respond_to?(meth)
+      end
+
+      raise "No visitor for '#{self.class}'"
+    end
+  end
+end

data/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

data/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