twostroke 0.0.3 → 0.0.4

data/lib/twostroke/ast/break.rb

@@ -0,0 +1,7 @@
+module Twostroke::AST
+  class Break < Base
+    def collapse
+      self
+    end
+  end
+end

data/lib/twostroke/ast/case.rb

@@ -0,0 +1,12 @@
+module Twostroke::AST
+  class Case < Base
+    attr_accessor :expression, :statements
+    def initialize(*args)
+      @statements = []
+      super *args
+    end
+    def collapse
+      self.class.new expression: expression.collapse, statements: statements.collect(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/delete.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Delete < Base
+    attr_accessor :expression
+    
+    def collapse
+      self.class.new expression: expression.collapse
+    end
+  end
+end

data/lib/twostroke/ast/do_while.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class DoWhile < Base
+    attr_accessor :body, :condition
+    
+    def collapse
+      self.class.new body: body.collapse, condition: condition.collapse
+    end
+  end
+end

data/lib/twostroke/ast/for_loop.rb

@@ -3,7 +3,10 @@ module Twostroke::AST
     attr_accessor :initializer, :condition, :increment, :body
     
     def collapse
-      self.class.new initializer: initializer.collapse, condition: condition.collapse, increment: increment.collapse, body: body.collapse
+      self.class.new initializer: initializer && initializer.collapse,
+        condition: condition && condition.collapse,
+        increment: increment && increment.collapse,
+        body: body.collapse
     end
   end
 end

data/lib/twostroke/ast/regexp.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Regexp < Base
+    attr_accessor :regexp
+    
+    def collapse
+      self
+    end
+  end
+end

data/lib/twostroke/ast/return.rb

@@ -3,7 +3,7 @@ module Twostroke::AST
     attr_accessor :expression
     
     def collapse
-      self.class.new expression: expression.collapse
+      self.class.new expression: expression && expression.collapse
     end
   end
 end

data/lib/twostroke/ast/switch.rb

@@ -0,0 +1,12 @@
+module Twostroke::AST
+  class Switch < Base
+    attr_accessor :expression, :cases
+    def initialize(*args)
+      @cases = []
+      super *args
+    end
+    def collapse
+      self.class.new expression: expression.collapse, cases: cases.collect(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/throw.rb

@@ -0,0 +1,9 @@
+module Twostroke::AST
+  class Throw < Base
+    attr_accessor :expression
+    
+    def collapse
+      self.class.new expression: expression.collapse
+    end
+  end
+end

data/lib/twostroke/ast/unsorted_binop.rb

@@ -17,7 +17,7 @@ module Twostroke::AST
         :GT                 => GreaterThan,
         :GTE                => GreaterThanEqual,
         :IN                 => In,
-        :INSTANCE_OF        => InstanceOf,
+        :INSTANCEOF         => InstanceOf,
         :DOUBLE_EQUALS      => Equality,
         :NOT_EQUALS         => Inequality,
         :TRIPLE_EQUALS      => StrictEquality,
@@ -45,7 +45,7 @@ module Twostroke::AST
         :GT                 => 8,
         :GTE                => 8,
         :IN                 => 8,
-        :INSTANCE_OF        => 8,
+        :INSTANCEOF         => 8,
         :DOUBLE_EQUALS      => 9,
         :NOT_EQUALS         => 9,
         :TRIPLE_EQUALS      => 9,

data/lib/twostroke/lexer.rb

@@ -9,43 +9,48 @@ module Twostroke
         send "#{k}=", v
       end
     end
-    def is?(t)
-      if t.is_a? Array
-        t.include? type
-      else
-        t == type
-      end
-    end
   end
   
   class Lexer
-    attr_reader :str, :col, :line, :tokens
+    attr_accessor :str, :col, :line
+    
+    def state
+      { str: str, col: col, line: line }
+    end
+    def state=(state)
+      @str = state[:str]
+      @col = state[:col]
+      @line = state[:line]
+    end
+    
     def initialize(str)
       @str = str
       @col = 1
       @line = 1
-      @tokens = []
     end
-    def lex
-      until @str.empty?
-        read_token
-      end
-    end
-  private
-    def read_token
-      TOKENS.each do |token|
+    
+    def read_token(allow_regexp = true)
+      TOKENS.select { |t| allow_regexp || t[0] != :REGEXP }.each do |token|
         m = token[1].match @str
         if m
-          @tokens.push Token.new(:type => token[0], :val => token[2] ? token[2].call(m) : nil, :line => @line, :col => @col) unless [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include? token[0]
+          tok = Token.new(:type => token[0], :val => token[2] ? token[2].call(m) : nil, :line => @line, :col => @col)
           @str = m.post_match
           newlines = m[0].count "\n"
           @col = 1 if !newlines.zero?
           @line += newlines
           @col += m[0].length - (m[0].rindex("\n") || 0)
-          return
+          if [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include? token[0]
+            return read_token(allow_regexp)
+          else
+            return tok
+          end
         end
       end
-      raise LexError, "Illegal character '#{@str[0]}' at line #{@line}, col #{@col}. (read #{@tokens.count} tokens)"
+      if @str.size > 0
+        raise LexError, "Illegal character '#{@str[0]}' at line #{@line}, col #{@col}."
+      else
+        nil
+      end
     end
   end
 end

data/lib/twostroke/parser.rb

@@ -5,14 +5,14 @@ module Twostroke
   class Parser
     attr_reader :statements
     
-    def initialize(tokens)
+    def initialize(lexer)
       @i = -1
-      @tokens = tokens + [Token.new(type: :SEMICOLON)]
+      @lexer = lexer
       @statements = []
     end
     
     def parse
-      while @i + 1 < @tokens.length
+      while try_peek_token
         st = statement
         statements.push st.collapse if st
       end
@@ -25,27 +25,29 @@ module Twostroke
     def assert_type(tok, *types)
       error! "Found #{tok.type}#{"<#{tok.val}>" if tok.val}, expected #{types.join ", "}" unless types.include? tok.type
     end
-    def stack
-      @stack
+    
+    def save_state
+      { cur_token: @cur_token, peek_token: @peek_token, lexer_state: @lexer.state }
     end
-    def stack_top
-      @stack.last
+    def load_state(state)
+      @cur_token = state[:cur_token]
+      @peek_token = state[:peek_token]
+      @lexer.state = state[:lexer_state]
     end
+    
     def token
-      @tokens[@i] or raise ParseError, "unexpected end of input"
+      @cur_token or raise ParseError, "unexpected end of input"
     end
-    def next_token
-      @i += 1
+    def next_token(allow_regexp = true)
+      @cur_token = @peek_token || @lexer.read_token(allow_regexp)
+      @peek_token = nil
       token
     end
-    def try_peek_token
-      @i + 1 < @tokens.length ? peek_token : nil
-    end
-    def peek_token
-      @tokens[@i + 1] or raise ParseError, "unexpected end of input"
+    def try_peek_token(allow_regexp = true)
+      @peek_token ||= @lexer.read_token(allow_regexp)
     end
-    def look_ahead(n = 1)
-      @tokens[@i + n]
+    def peek_token(allow_regexp = true)
+      @peek_token ||= @lexer.read_token(allow_regexp) or raise ParseError, "unexpected end of input"
     end
     
     ####################
@@ -53,9 +55,13 @@ module Twostroke
     def statement(consume_semicolon = true)
       st = case peek_token.type
       when :RETURN;     send :return
+      when :BREAK;      send :break
+      when :THROW;      send :throw
       when :VAR;        var
       when :IF;         consume_semicolon = false; send :if
       when :FOR;        consume_semicolon = false; send :for
+      when :SWITCH;     consume_semicolon = false; send :switch
+      when :DO;         send :do
       when :WHILE;      consume_semicolon = false; send :while
       when :TRY;        consume_semicolon = false; try
       when :OPEN_BRACE; consume_semicolon = false; body
@@ -64,64 +70,72 @@ module Twostroke
       else; expression
       end
       if consume_semicolon
-        #next_token if try_peek_token && peek_token.type == :SEMICOLON
-        assert_type next_token, :SEMICOLON
+        next_token if try_peek_token && peek_token.type == :SEMICOLON
+        #assert_type next_token, :SEMICOLON
       end
       st
     end
-    
+   
     def expression(no_comma = false, no_in = false, no_ternary = false)
       expr = expression_after_unary no_comma
-      new_expr = if [:PLUS, :MINUS, :ASTERISK, :SLASH, :MOD,
+      expr = if [:PLUS, :MINUS, :ASTERISK, :SLASH, :MOD,
           :LEFT_SHIFT, :RIGHT_SHIFT, :RIGHT_TRIPLE_SHIFT,
-          :AMPERSAND, :CARET, :PIPE ].include? peek_token.type
-        # these operators can be combined with assignment
-        if look_ahead(2).type == :EQUALS
-          # combination assignment
-          op = next_token.type
-          assert_type next_token, :EQUALS
-          AST::UnsortedBinop.operator_class[op].new left: expr, assign_result_left: true, right: expression
-        else
-          binop expr
-        end
+          :AMPERSAND, :CARET, :PIPE ].include? peek_token(false).type
+          state = save_state
+          next_token
+          combined = (peek_token(false).type == :EQUALS)
+          load_state state
+          if combined
+            # combination assignment
+            op = next_token(false).type
+            assert_type next_token(false), :EQUALS
+            AST::UnsortedBinop.operator_class[op].new left: expr, assign_result_left: true, right: expression(true, false, true)
+          else
+            binop expr
+          end
       elsif [ :GT, :LT, :GTE, :LTE, :DOUBLE_EQUALS,
               :TRIPLE_EQUALS, :NOT_EQUALS, :NOT_DOUBLE_EQUALS,
               :AND, :OR, :LEFT_SHIFT, :RIGHT_SHIFT,
               :RIGHT_TRIPLE_SHIFT, :INSTANCEOF,
-              *(no_in ? [] : [:IN]) ].include? peek_token.type
+              *(no_in ? [] : [:IN]) ].include? peek_token(false).type
         expr = binop expr
         # this has a higher precedence than the ternary
         # so we'll hackily check for a ternary after this
-        if try_peek_token && peek_token.type == :QUESTION
+        if try_peek_token && peek_token(false).type == :QUESTION
           ternary(expr)
         else
           expr
         end
-      elsif peek_token.type == :EQUALS
+      else
+        expr
+      end
+      expr = if peek_token(false).type == :EQUALS
         next_token
         AST::Assignment.new left: expr, right: expression(true)
-      elsif !no_ternary && peek_token.type == :QUESTION
+      elsif !no_ternary && peek_token(false).type == :QUESTION
         ternary(expr)
       else
         expr
       end
       
-      if !no_comma && peek_token.type == :COMMA
+      if !no_comma && peek_token(false).type == :COMMA
         next_token
-        AST::MultiExpression.new left: new_expr, right: expression
+        AST::MultiExpression.new left: expr, right: expression
       else
-        new_expr
+        expr
       end
     end
     
-    def expression_after_unary(no_comma = false, no_call = false)
+    def expression_after_unary(no_comma = true, no_call = false)
       expr = case peek_token.type
       when :FUNCTION; function
       when :STRING; string
       when :NUMBER; number
+      when :REGEXP; regexp
       when :THIS; this
       when :NULL; null
       when :NEW; send :new
+      when :DELETE; delete
       when :BAREWORD; bareword
       when :OPEN_PAREN; parens
       when :OPEN_BRACE; object_literal
@@ -137,17 +151,17 @@ module Twostroke
       else error! "Unexpected #{peek_token.type}"
       end
       loop do
-        if !no_call && peek_token.type == :OPEN_PAREN
+        if !no_call && peek_token(false).type == :OPEN_PAREN
           expr = call expr
-        elsif peek_token.type == :OPEN_BRACKET
+        elsif peek_token(false).type == :OPEN_BRACKET
           expr = index expr
-        elsif peek_token.type == :MEMBER_ACCESS
+        elsif peek_token(false).type == :MEMBER_ACCESS
           expr = member_access expr
-        elsif !no_comma && peek_token.type == :COMMA
+        elsif !no_comma && peek_token(false).type == :COMMA
           expr = comma(expr)
-        elsif peek_token.type == :INCREMENT
+        elsif peek_token(false).type == :INCREMENT
           expr = post_increment expr
-        elsif peek_token.type == :DECREMENT
+        elsif peek_token(false).type == :DECREMENT
           expr = post_decrement expr
         else
           return expr
@@ -157,8 +171,8 @@ module Twostroke
     end
     
     def binop(left)
-      next_token
-      AST::UnsortedBinop.new left: left, op: token.type, right: expression(false, false, true)
+      op = next_token.type
+      AST::UnsortedBinop.new left: left, op: op, right: expression(true, false, true)
     end
     
     def body
@@ -189,9 +203,9 @@ module Twostroke
     def ternary(cond)
       assert_type next_token, :QUESTION
       ternary = AST::Ternary.new condition: cond
-      ternary.if_true = expression
+      ternary.if_true = expression(true)
       assert_type next_token, :COLON
-      ternary.if_false = expression
+      ternary.if_false = expression(true)
       ternary
     end
     
@@ -207,23 +221,24 @@ module Twostroke
       end
       node
     end
-    
+
     def for
       assert_type next_token, :FOR
       assert_type next_token, :OPEN_PAREN
       # decide if this is a for(... in ...) or a for(;;) loop
-      for_in = false
-      saved_i = @i
-      if @i + 3 < @tokens.length && look_ahead(1).type == :VAR &&
-        look_ahead(2).type == :BAREWORD && look_ahead(3).type == :IN
+      saved_state = save_state
+      if next_token.type == :VAR && next_token.type == :BAREWORD && next_token.type == :IN
         for_in = true
+        load_state saved_state
       else
-        stmt = statement(false)
+        load_state saved_state
+        stmt = statement(false) unless peek_token.type == :SEMICOLON
         assert_type next_token, :SEMICOLON, :CLOSE_PAREN
         for_in = (token.type == :CLOSE_PAREN)
       end
+      load_state saved_state
       if for_in
-        @i = saved_i # no luck parsing for(;;), reparse as for(..in..)
+        # no luck parsing for(;;), reparse as for(..in..)        
         if peek_token.type == :VAR
           next_token
           assert_type next_token, :BAREWORD
@@ -236,15 +251,39 @@ module Twostroke
         assert_type next_token, :CLOSE_PAREN
         AST::ForIn.new lval: lval, object: obj, body: statement
       else
-        initializer = stmt
-        condition = statement(false)
+        initializer = statement(false) unless peek_token.type == :SEMICOLON
         assert_type next_token, :SEMICOLON
-        increment = statement(false)
+        condition = statement(false) unless peek_token.type == :SEMICOLON
+        assert_type next_token, :SEMICOLON
+        increment = statement(false) unless peek_token.type == :CLOSE_PAREN
         assert_type next_token, :CLOSE_PAREN
         AST::ForLoop.new initializer: initializer, condition: condition, increment: increment, body: statement
       end
     end
     
+    def switch
+      assert_type next_token, :SWITCH
+      assert_type next_token, :OPEN_PAREN
+      sw = AST::Switch.new expression: expression
+      assert_type next_token, :CLOSE_PAREN
+      assert_type next_token, :OPEN_BRACE
+      current_case = nil
+      while ![:CLOSE_BRACE].include? peek_token.type
+        if peek_token.type == :CASE
+          assert_type next_token, :CASE
+          expr = expression
+          current_case = AST::Case.new expression: expr
+          assert_type next_token, :COLON
+          sw.cases << current_case
+        else
+          error! "statements may only appear under a case" if current_case.nil?
+          current_case.statements << statement
+        end
+      end
+      assert_type next_token, :CLOSE_BRACE
+      sw
+    end
+    
     def while
       assert_type next_token, :WHILE
       assert_type next_token, :OPEN_PAREN
@@ -254,6 +293,16 @@ module Twostroke
       node
     end
     
+    def do
+      assert_type next_token, :DO
+      node = AST::DoWhile.new body: body
+      assert_type next_token, :WHILE
+      assert_type next_token, :OPEN_PAREN
+      node.condition = expression(false)
+      assert_type next_token, :CLOSE_PAREN
+      node
+    end
+    
     def try
       try = AST::Try.new try_statements: []
       assert_type next_token, :TRY
@@ -336,7 +385,23 @@ module Twostroke
     
     def return
       assert_type next_token, :RETURN
-      AST::Return.new expression: expression
+      expr = expression unless peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
+      AST::Return.new expression: expr
+    end
+    
+    def break
+      assert_type next_token, :BREAK
+      AST::Break.new
+    end
+    
+    def throw
+      assert_type next_token, :THROW
+      AST::Throw.new expression: expression
+    end
+    
+    def delete
+      assert_type next_token, :DELETE
+      AST::Delete.new expression: expression
     end
     
     def var
@@ -347,7 +412,7 @@ module Twostroke
     def var_rest
       assert_type next_token, :BAREWORD
       decl = AST::Declaration.new(name: token.val)
-      return decl if peek_token.type == :SEMICOLON
+      return decl if peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
       
       assert_type next_token, :COMMA, :EQUALS
       
@@ -355,7 +420,7 @@ module Twostroke
         AST::MultiExpression.new left: decl, right: var_rest
       else
         assignment = AST::Assignment.new left: decl, right: expression(true)
-        if peek_token.type == :SEMICOLON
+        if peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
           assignment
         elsif peek_token.type == :COMMA
           next_token
@@ -386,6 +451,11 @@ module Twostroke
       AST::String.new string: token.val
     end
     
+    def regexp
+      assert_type next_token, :REGEXP
+      AST::Regexp.new regexp: token.val
+    end
+    
     def object_literal
       assert_type next_token, :OPEN_BRACE
       obj = AST::ObjectLiteral.new
@@ -480,14 +550,14 @@ module Twostroke
       AST::PostDecrement.new value: obj
     end
     
-    def pre_increment(obj)
+    def pre_increment
       assert_type next_token, :INCREMENT
-      AST::PreIncrement.new value: obj
+      AST::PreIncrement.new value: expression_after_unary
     end
     
-    def pre_decrement(obj)
+    def pre_decrement
       assert_type next_token, :DECREMENT
-      AST::PreDecrement.new value: obj
+      AST::PreDecrement.new value: expression_after_unary
     end
     
     def typeof

data/lib/twostroke/runtime/context.rb

@@ -0,0 +1,33 @@
+module Twostroke::Runtime
+  class Context
+    attr_accessor :variables, :parent
+    
+    def initialize
+      variables = {}
+    end
+    
+    def [](var)
+      if variables.key? var
+        variables[var]
+      elsif parent
+        parent[var]
+      else
+        raise "ReferenceError" # TODO
+      end
+    end
+    
+    def []=(var, val)
+      if variables.key?(var) || parent.nil?
+        variables[var] = val
+      else
+        parent[var] = val
+      end
+    end
+    
+    def create_context
+      context = Context.new
+      context.parent = self
+      context
+    end
+  end
+end

data/lib/twostroke/runtime/environment.rb

@@ -0,0 +1,13 @@
+module Twostroke::Runtime
+  class Environment
+    attr_accessor :root_context, :root_object
+    
+    def initialize(root_name)
+      @root_object = Types::Object.new
+      @root_context = Context.new
+      @root_contect.variables = @root_object
+      
+      
+    end
+  end
+end

data/lib/twostroke/runtime/types/basic_type.rb

@@ -0,0 +1,5 @@
+module Twostroke::Runtime::Types
+  class BasicType
+    #
+  end
+end

data/lib/twostroke/runtime/types/null.rb

@@ -0,0 +1,7 @@
+module Twostroke::Runtime::Types
+  class Null < BasicType
+    def self.null
+      @@null ||= Null.new
+    end
+  end
+end

data/lib/twostroke/runtime/types/object.rb

@@ -0,0 +1,33 @@
+module Twostroke::Runtime::Types
+  class Object < BasicType
+    attr_accessor :properties, :accessor_properties
+    
+    def initialize(env)
+      @properties = {}
+      @accessor_properties = {}
+      properties["__proto__"]
+    end
+    
+    def [](key)
+      if accessor_properties.key? key
+        accessor_properties[key].get self
+      elsif properties.key? key
+        properties[key]
+      elsif properties.key? "__proto__"
+        properties["__proto__"][key]
+      else
+        Undefined.undefined
+      end
+    end
+    
+    def []=(key, val)
+      if accessor_properties.key? key
+        accessor_properties[key].get self
+      elsif properties.key? key
+        properties[key]
+      else
+        Undefined.undefined
+      end
+    end
+  end
+end

data/lib/twostroke/runtime/types/undefined.rb

@@ -0,0 +1,7 @@
+module Twostroke::Runtime::Types
+  class Undefined < BasicType
+    def self.undefined
+      @@undefined ||= Undefined.new
+    end
+  end
+end

data/lib/twostroke/runtime/types.rb

@@ -0,0 +1,7 @@
+module Twostroke::Runtime
+  module Types
+    Dir.glob File.expand_path("../types/*", __FILE__) do |f|
+      require f
+    end
+  end
+end

data/lib/twostroke/runtime.rb

@@ -0,0 +1,7 @@
+module Twostroke
+  module Runtime
+    Dir.glob File.expand_path("../runtime/*", __FILE__) do |f|
+      require f
+    end
+  end
+end

data/lib/twostroke/tokens.rb

@@ -1,14 +1,15 @@
 module Twostroke
   class Lexer
+    RESERVED = %w(function var if instanceof in else for while do this return throw typeof try catch finally void null new delete switch case break)
     TOKENS = [
 
       [ :MULTI_COMMENT, %r{/\*.*?\*/} ],
       [ :SINGLE_COMMENT, /\/\/.*?$/ ],
 
       [ :WHITESPACE, /\s+/ ],
-      [ :NUMBER, /\d+(\.\d*(e[+-]?\d+)?)?/, ->m { m[0].to_f } ],
+      [ :NUMBER, /((?<oct>0[0-7]+)|(?<hex>0x[A-Fa-f0-9]+)|(?<to_f>(\d+(\.?\d*([eE][+-]?\d+)?)?|\.\d+([eE][+-]?\d+)?)))/, ->m { m[0].send m.names.first } ],
 
-      *%w(function var if instanceof in else for while do this return throw typeof try catch finally void null new).map do |w|
+      *RESERVED.map do |w|
         [ w.upcase.intern, /#{w}(?=[^a-zA-Z_0-9])/ ]
       end,
       [ :BAREWORD, /[a-zA-Z_\$][\$a-zA-Z_0-9]*/, ->m { m[0] } ],
@@ -28,6 +29,8 @@ module Twostroke
         .gsub(/\\u([a-f0-9]{4})/i) { |m| m[1].to_i(16).chr }
         .gsub(/\\(.)/) { |m| m[1] }
       end ],
+      
+      [ :REGEXP, %r{/(?<src>(\\.|[^\1])*?[^\1\\]?)/(?<opts>[gim]+)?}, ->m { [m[:src], m[:opts]] } ],
 
       [ :OPEN_PAREN, /\(/ ],
       [ :CLOSE_PAREN, /\)/ ],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twostroke
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-05 00:00:00.000000000Z
+date: 2011-10-15 00:00:00.000000000Z
 dependencies: []
 description: An implementation of Javascript written in pure Ruby. This project currently
   includes a WIP parser, and will include a runtime.
@@ -23,8 +23,12 @@ files:
 - lib/twostroke/ast/assignment.rb
 - lib/twostroke/ast/binary_operators.rb
 - lib/twostroke/ast/body.rb
+- lib/twostroke/ast/break.rb
 - lib/twostroke/ast/call.rb
+- lib/twostroke/ast/case.rb
 - lib/twostroke/ast/declaration.rb
+- lib/twostroke/ast/delete.rb
+- lib/twostroke/ast/do_while.rb
 - lib/twostroke/ast/for_in.rb
 - lib/twostroke/ast/for_loop.rb
 - lib/twostroke/ast/function.rb
@@ -36,10 +40,13 @@ files:
 - lib/twostroke/ast/null.rb
 - lib/twostroke/ast/number.rb
 - lib/twostroke/ast/object_literal.rb
+- lib/twostroke/ast/regexp.rb
 - lib/twostroke/ast/return.rb
 - lib/twostroke/ast/string.rb
+- lib/twostroke/ast/switch.rb
 - lib/twostroke/ast/ternary.rb
 - lib/twostroke/ast/this.rb
+- lib/twostroke/ast/throw.rb
 - lib/twostroke/ast/try.rb
 - lib/twostroke/ast/unary_operators.rb
 - lib/twostroke/ast/unsorted_binop.rb
@@ -49,6 +56,14 @@ files:
 - lib/twostroke/error.rb
 - lib/twostroke/lexer.rb
 - lib/twostroke/parser.rb
+- lib/twostroke/runtime/context.rb
+- lib/twostroke/runtime/environment.rb
+- lib/twostroke/runtime/types/basic_type.rb
+- lib/twostroke/runtime/types/null.rb
+- lib/twostroke/runtime/types/object.rb
+- lib/twostroke/runtime/types/undefined.rb
+- lib/twostroke/runtime/types.rb
+- lib/twostroke/runtime.rb
 - lib/twostroke/tokens.rb
 - lib/twostroke.rb
 homepage: http://github.com/charliesome/twostroke