twostroke 0.0.1 → 0.0.2

data/lib/twostroke/ast/binary_operators.rb

@@ -6,7 +6,16 @@ module Twostroke::AST
       StrictInequality BitwiseAnd BitwiseXor BitwiseOr
       And Or).each do |op|
     klass = Class.new Base do
-      attr_accessor :left, :right
+      attr_accessor :left, :right, :assign_result_left
+      
+      def initialize(*args)
+        @assign_result_left = false
+        super *args
+      end
+      
+      def collapse
+        self.class.new left: left.collapse, right: right.collapse, assign_result_left: assign_result_left
+      end
     end
     const_set op, klass
   end

data/lib/twostroke/ast/for_in.rb

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

data/lib/twostroke/ast/if.rb

@@ -1,4 +1,3 @@
-require 'pry'
 module Twostroke::AST
   class If < Base
     attr_accessor :condition, :then, :else

data/lib/twostroke/ast/new.rb

@@ -0,0 +1,14 @@
+module Twostroke::AST
+  class New < Base
+    attr_accessor :callee, :arguments
+    
+    def initialize(*args)
+      @arguments = []
+      super *args
+    end
+    
+    def collapse
+      self.class.new callee: callee.collapse, arguments: arguments.map(&:collapse)
+    end
+  end
+end

data/lib/twostroke/ast/null.rb

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

data/lib/twostroke/ast/this.rb

@@ -0,0 +1,5 @@
+module Twostroke::AST
+  class This < Base
+    def collapse; self; end
+  end
+end

data/lib/twostroke/ast/try.rb

@@ -0,0 +1,11 @@
+module Twostroke::AST
+  class Try < Base
+    attr_accessor :try_statements, :catch_variable, :catch_statements, :finally_statements
+    
+    def collapse
+      self.class.new try_statements: try_statements.map(&:collapse), catch_variable: catch_variable,
+        catch_statements: (catch_statements && catch_statements.map(&:collapse)),
+        finally_statements: (finally_statements && finally_statements.map(&:collapse))
+    end
+  end
+end

data/lib/twostroke/ast/unary_operators.rb

@@ -1,6 +1,6 @@
 module Twostroke::AST
   [ :PostIncrement, :PreIncrement, :PostDecrement, :PreDecrement,
-    :BinaryNot, :UnaryPlus, :Negation, :TypeOf, :Not ].each do |op|
+    :BinaryNot, :UnaryPlus, :Negation, :TypeOf, :Not, :Void ].each do |op|
       klass = Class.new Base do
         attr_accessor :value
       

data/lib/twostroke/ast/unsorted_binop.rb

@@ -27,7 +27,6 @@ module Twostroke::AST
         :PIPE               => BitwiseOr,
         :AND                => And,
         :OR                 => Or
-        
       }
     end
     
@@ -83,7 +82,6 @@ module Twostroke::AST
           if token.is_a? Symbol
             r = stack.pop
             l = stack.pop
-            puts token
             stack.push UnsortedBinop.operator_class[token].new(left: l, right: r)
           else
             stack.push token

data/lib/twostroke/ast/while.rb

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

data/lib/twostroke/parser.rb

@@ -56,7 +56,10 @@ module Twostroke
       when :VAR;        var
       when :IF;         consume_semicolon = false; send :if
       when :FOR;        consume_semicolon = false; send :for
+      when :WHILE;      consume_semicolon = false; send :while
+      when :TRY;        consume_semicolon = false; try
       when :OPEN_BRACE; consume_semicolon = false; body
+      when :FUNCTION;   consume_semicolon = false; function
       when :SEMICOLON;  nil
       else; expression
       end
@@ -67,29 +70,58 @@ module Twostroke
       st
     end
     
-    def expression(no_comma = false)
+    def expression(no_comma = false, no_in = false, no_ternary = false)
       expr = expression_after_unary no_comma
-      if [:PLUS, :MINUS, :ASTERISK, :SLASH, :GT, :LT,
-          :GTE, :LTE, :DOUBLE_EQUALS, :TRIPLE_EQUALS,
-          :NOT_EQUALS, :NOT_DOUBLE_EQUALS, :AND, :OR,
-          :AMPERSAND, :PIPE, :CARET, :MOD, :LEFT_SHIFT,
-          :RIGHT_SHIFT, :RIGHT_TRIPLE_SHIFT,  ].include? peek_token.type
-        binop expr
+      new_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
+      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
+        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
+          ternary(expr)
+        else
+          expr
+        end
       elsif peek_token.type == :EQUALS
         next_token
-        AST::Assignment.new left: expr, right: expression(no_comma)
-      elsif peek_token.type == :QUESTION
+        AST::Assignment.new left: expr, right: expression(true)
+      elsif !no_ternary && peek_token.type == :QUESTION
         ternary(expr)
       else
         expr
       end
+      
+      if !no_comma && peek_token.type == :COMMA
+        next_token
+        AST::MultiExpression.new left: new_expr, right: expression
+      else
+        new_expr
+      end
     end
     
-    def expression_after_unary(no_comma = false)
+    def expression_after_unary(no_comma = false, no_call = false)
       expr = case peek_token.type
       when :FUNCTION; function
       when :STRING; string
       when :NUMBER; number
+      when :THIS; this
+      when :NULL; null
+      when :NEW; send :new
       when :BAREWORD; bareword
       when :OPEN_PAREN; parens
       when :OPEN_BRACE; object_literal
@@ -98,13 +130,14 @@ module Twostroke
       when :TILDE; tilde
       when :INCREMENT; pre_increment
       when :DECREMENT; pre_decrement
+      when :VOID; void
       when :PLUS; unary_plus
       when :MINUS; unary_minus
       when :TYPEOF; typeof
       else error! "Unexpected #{peek_token.type}"
       end
       loop do
-        if peek_token.type == :OPEN_PAREN
+        if !no_call && peek_token.type == :OPEN_PAREN
           expr = call expr
         elsif peek_token.type == :OPEN_BRACKET
           expr = index expr
@@ -125,7 +158,7 @@ module Twostroke
     
     def binop(left)
       next_token
-      AST::UnsortedBinop.new left: left, op: token.type, right: expression
+      AST::UnsortedBinop.new left: left, op: token.type, right: expression(false, false, true)
     end
     
     def body
@@ -138,6 +171,16 @@ module Twostroke
       body
     end
     
+    def this
+      assert_type next_token, :THIS
+      AST::This.new
+    end
+    
+    def null
+      assert_type next_token, :NULL
+      AST::Null.new
+    end
+    
     def bareword
       assert_type next_token, :BAREWORD
       AST::Variable.new name: token.val
@@ -169,11 +212,29 @@ module Twostroke
       assert_type next_token, :FOR
       assert_type next_token, :OPEN_PAREN
       # decide if this is a for(... in ...) or a for(;;) loop
-      stmt = statement(false)
-      assert_type next_token, :SEMICOLON, :CLOSE_PAREN
-      if token.type == :CLOSE_PAREN
-        # this is a for(... in ...) loop. we'll figure out how to deal with that in a sec
-        error! "for..in loops not implemented yet!" # @TODO
+      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
+        for_in = true
+      else
+        stmt = statement(false)
+        assert_type next_token, :SEMICOLON, :CLOSE_PAREN
+        for_in = (token.type == :CLOSE_PAREN)
+      end
+      if for_in
+        @i = saved_i # no luck parsing for(;;), reparse as for(..in..)
+        if peek_token.type == :VAR
+          next_token
+          assert_type next_token, :BAREWORD
+          lval = AST::Declaration.new name: token.val
+        else
+          lval = expression(false, true)
+        end
+        assert_type next_token, :IN
+        obj = expression
+        assert_type next_token, :CLOSE_PAREN
+        AST::ForIn.new lval: lval, object: obj, body: statement
       else
         initializer = stmt
         condition = statement(false)
@@ -184,6 +245,48 @@ module Twostroke
       end
     end
     
+    def while
+      assert_type next_token, :WHILE
+      assert_type next_token, :OPEN_PAREN
+      node = AST::While.new condition: expression
+      assert_type next_token, :CLOSE_PAREN
+      node.body = statement
+      node
+    end
+    
+    def try
+      try = AST::Try.new try_statements: []
+      assert_type next_token, :TRY
+      assert_type next_token, :OPEN_BRACE
+      while peek_token.type != :CLOSE_BRACE
+        try.try_statements << statement
+      end
+      assert_type next_token, :CLOSE_BRACE
+      assert_type next_token, :CATCH, :FINALLY
+      if token.type == :CATCH
+        try.catch_statements = []
+        assert_type next_token, :OPEN_PAREN
+        assert_type next_token, :BAREWORD
+        try.catch_variable = token.val
+        assert_type next_token, :CLOSE_PAREN
+        assert_type next_token, :OPEN_BRACE
+        while peek_token.type != :CLOSE_BRACE
+          try.catch_statements << statement
+        end
+        assert_type next_token, :CLOSE_BRACE
+      end
+      if try_peek_token && peek_token.type == :FINALLY
+        try.finally_statements = []
+        assert_type next_token, :FINALLY
+        assert_type next_token, :OPEN_BRACE
+        while peek_token.type != :CLOSE_BRACE
+          try.finally_statements << statement
+        end
+        assert_type next_token, :CLOSE_BRACE
+      end
+      try
+    end
+    
     def member_access(obj)
       assert_type next_token, :MEMBER_ACCESS
       assert_type next_token, :BAREWORD
@@ -199,6 +302,17 @@ module Twostroke
       end
     end
     
+    def new
+      assert_type next_token, :NEW
+      node = AST::New.new
+      node.callee = expression_after_unary(false, true)
+      if try_peek_token && peek_token.type == :OPEN_PAREN
+        call = call(node.callee)
+        node.arguments = call.arguments
+      end
+      node
+    end
+    
     def call(callee)
       assert_type next_token, :OPEN_PAREN
       c = AST::Call.new callee: callee
@@ -341,6 +455,11 @@ module Twostroke
       AST::BinaryNot.new value: expression_after_unary
     end
     
+    def void
+      assert_type next_token, :VOID
+      AST::Void.new value: expression_after_unary
+    end
+    
     def unary_plus
       assert_type next_token, :PLUS
       AST::UnaryPlus.new value: expression_after_unary
@@ -357,7 +476,7 @@ module Twostroke
     end
     
     def post_decrement(obj)
-      assert_type next_token, :INCREMENT
+      assert_type next_token, :DECREMENT
       AST::PostDecrement.new value: obj
     end
     
@@ -367,7 +486,7 @@ module Twostroke
     end
     
     def pre_decrement(obj)
-      assert_type next_token, :INCREMENT
+      assert_type next_token, :DECREMENT
       AST::PreDecrement.new value: obj
     end
     

data/lib/twostroke/tokens.rb

@@ -8,8 +8,8 @@ module Twostroke
       [ :WHITESPACE, /\s+/ ],
       [ :NUMBER, /\d+(\.\d*(e[+-]?\d+)?)?/, ->m { m[0].to_f } ],
 
-      *%w(function var if instanceof in else for while do this return throw typeof try catch).map do |w|
-        [ w.upcase.intern, /#{w}/ ]
+      *%w(function var if instanceof in else for while do this return throw typeof try catch finally void null new).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] } ],
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twostroke
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-04 00:00:00.000000000Z
+date: 2011-10-05 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.
@@ -25,20 +25,26 @@ files:
 - lib/twostroke/ast/body.rb
 - lib/twostroke/ast/call.rb
 - lib/twostroke/ast/declaration.rb
+- lib/twostroke/ast/for_in.rb
 - lib/twostroke/ast/for_loop.rb
 - lib/twostroke/ast/function.rb
 - lib/twostroke/ast/if.rb
 - lib/twostroke/ast/index.rb
 - lib/twostroke/ast/member_access.rb
 - lib/twostroke/ast/multi_expression.rb
+- lib/twostroke/ast/new.rb
+- lib/twostroke/ast/null.rb
 - lib/twostroke/ast/number.rb
 - lib/twostroke/ast/object_literal.rb
 - lib/twostroke/ast/return.rb
 - lib/twostroke/ast/string.rb
 - lib/twostroke/ast/ternary.rb
+- lib/twostroke/ast/this.rb
+- lib/twostroke/ast/try.rb
 - lib/twostroke/ast/unary_operators.rb
 - lib/twostroke/ast/unsorted_binop.rb
 - lib/twostroke/ast/variable.rb
+- lib/twostroke/ast/while.rb
 - lib/twostroke/ast.rb
 - lib/twostroke/error.rb
 - lib/twostroke/lexer.rb