twostroke 0.1.0 → 0.2.0

data/lib/twostroke/ast/case.rb

@@ -12,7 +12,7 @@ module Twostroke::AST
     
     def walk(&bk)
       if yield self
-        expression.walk &bk
+        expression.walk &bk if expression
         statements.each { |s| s.walk &bk }
       end
     end

data/lib/twostroke/ast/function.rb

@@ -1,6 +1,6 @@
 module Twostroke::AST
   class Function < Base
-    attr_accessor :name, :arguments, :statements
+    attr_accessor :name, :arguments, :statements, :fnid
     
     def initialize(*args)
       @arguments = []
@@ -9,7 +9,7 @@ module Twostroke::AST
     end
     
     def collapse
-      self.class.new name: name, arguments: arguments, statements: statements.reject(&:nil?).map(&:collapse)
+      self.class.new name: name, arguments: arguments, statements: statements.reject(&:nil?).map(&:collapse), fnid: fnid
     end
     
     def walk(&bk)

data/lib/twostroke/ast/label.rb

@@ -0,0 +1,20 @@
+module Twostroke::AST
+  class Label < Base
+    attr_accessor :name, :statement
+    
+    def initialize(*args)
+      @statements = []
+      super *args
+    end
+    
+    def collapse
+      self.class.new name: name, statement: statement
+    end
+    
+    def walk(&bk)
+      if yield self
+        statement.walk &bk
+      end
+    end
+  end
+end

data/lib/twostroke/ast/switch.rb

@@ -11,6 +11,7 @@ module Twostroke::AST
     
     def walk(&bk)
       if yield self
+        
         expression.walk &bk
         cases.each { |c| c.walk &bk }
       end

data/lib/twostroke/ast/try.rb

@@ -3,9 +3,9 @@ module Twostroke::AST
     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))
+      self.class.new try_statements: try_statements.reject(&:nil?).map(&:collapse), catch_variable: catch_variable,
+        catch_statements: (catch_statements && catch_statements.reject(&:nil?).map(&:collapse)),
+        finally_statements: (finally_statements && finally_statements.reject(&:nil?).map(&:collapse))
     end
     
     def walk(&bk)

data/lib/twostroke/ast/unary_operators.rb

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

data/lib/twostroke/ast.rb

@@ -1,6 +1,7 @@
 module Twostroke
   module AST
     class Base
+      attr_accessor :line
       def initialize(hash = {})
         hash.each do |k,v|
           send "#{k}=", v

data/lib/twostroke/compiler/javascript.rb

@@ -80,13 +80,31 @@ private
     "\"#{escaped}\""
   end
   
+  def lval(node)
+    if type(left) == :Variable
+      left.name
+    elsif type(left) == :Declaration
+        left.name
+    elsif type(left) == :MemberAccess
+      compile left.object
+      "#{stack}.pop().#{left.member}"
+    elsif type(left) == :Index
+      compile left.object
+      compile left.index
+      output "var __A = stack.pop(), __B = stack.pop();"
+      "__B[__A]"
+    else
+      "bad lval!"
+    end
+  end
+  
   def mutate(left, fmt)
     lval = nil
     if type(left) == :Variable
-      lval = "#{left.name}"
+      lval = left.name
     elsif type(left) == :Declaration
       compile left
-      lval = "#{left.name}"
+      lval = left.name
     elsif type(left) == :MemberAccess
       compile left.object
       lval = "#{stack}.pop().#{left.member}"

data/lib/twostroke/compiler/tsasm.rb

@@ -17,7 +17,10 @@ class Twostroke::Compiler::TSASM
         send node
       else
         if @methods[type(node)]
+          output :".line", @current_line = node.line if node.line and node.line > @current_line
+          @node_stack.push node
           send type(node), node if node
+          @node_stack.pop
         else
           error! "#{type node} not implemented"
         end
@@ -30,6 +33,8 @@ class Twostroke::Compiler::TSASM
       @sections = [:"#{prefix}main"]
       @break_stack = []
       @continue_stack = []
+      @node_stack = []
+      @current_line = 0
             
       ast.each { |node| hoist node }
       ast.each { |node| compile node }
@@ -66,8 +71,11 @@ private
     node.walk do |node|
       if node.is_a? Twostroke::AST::Declaration
         output :".local", node.name.intern
+        false
       elsif node.is_a? Twostroke::AST::Function
         output :".local", node.name.intern if node.name
+        # because javascript is odd, entire function bodies need to be hoisted, not just their declarations
+        Function(node, true)
         false
       else
         true
@@ -76,7 +84,7 @@ private
   end
   
   def error!(msg)
-    raise Twostroke::Compiler::CompileError, msg
+    raise Twostroke::Compiler::CompileError, "#{msg} at line #{@current_line}"
   end
   
   def type(node)
@@ -108,7 +116,7 @@ private
       compile left.object
       compile right
       output :setprop, left.member.intern
-    elsif type(left) == :Index  
+    elsif type(left) == :Index
       compile left.object
       compile left.index
       compile right
@@ -136,7 +144,7 @@ private
           output :set, node.left.name.intern
         elsif type(node.left) == :MemberAccess
           compile node.left.object
-          dup
+          output :dup
           output :member, node.left.member.intern
           compile node.right
           output op
@@ -180,15 +188,23 @@ private
       compile left.object
       output :dup
       output :member, left.member.intern
+      output :dup
+      output :tst
       output op
       output :setprop, left.member.intern
+      output :pop
+      output :tld
     elsif type(left) == :Index  
       compile left.object
       compile left.index
       output :dup, 2
       output :index
+      output :dup
+      output :tst
       output op
       output :setindex
+      output :pop
+      output :tld
     else
       error! "Bad lval in post-mutation"
     end
@@ -214,7 +230,12 @@ private
       output op
       output :setprop, left.member.intern
     elsif type(left) == :Index
-      error! "pre-mutatation of array index not supported yet" # @TODO
+      compile left.object
+      compile left.index
+      output :dup, 2
+      output :index
+      output op
+      output :setindex
     else
       error! "Bad lval in post-mutation"
     end
@@ -238,7 +259,7 @@ private
     elsif type(node.callee) == :Index
       compile node.callee.object
       output :dup
-      output node.callee.index
+      compile node.callee.index
       output :index
       node.arguments.each { |n| compile n }
       output :thiscall, node.arguments.size
@@ -275,27 +296,30 @@ private
     output :regexp, node.regexp
   end
   
-  def Function(node)
-    fnid = :"#{@prefix}fn_#{uniqid}"
+  def Function(node, in_hoist_stage = false)
+    fnid = node.fnid ||= :"#{@prefix}fn_#{uniqid}"
     
-    section fnid
-    output :".name", node.name if node.name
-    node.arguments.each do |arg|
-      output :".arg", arg.intern
-    end
-    output :".local", node.name.intern if node.name
-    node.statements.each { |s| hoist s }
-    if node.name
-      output :callee
-      output :set, node.name.intern
+    if !node.name or in_hoist_stage
+      section fnid
+      output :".name", node.name if node.name
+      node.arguments.each do |arg|
+        output :".arg", arg.intern
+      end
+      output :".local", node.name.intern if node.name
+      node.statements.each { |s| hoist s }
+      if node.name
+        output :callee
+        output :set, node.name.intern
+      end
+      node.statements.each { |s| compile s }
+      output :undefined
+      output :ret
+      pop_section
+      output :close, fnid
+      output :set, node.name.intern if node.name
+    else  
+      output :close, fnid
     end
-    node.statements.each { |s| compile s }
-    output :undefined
-    output :ret
-    pop_section
-    
-    output :close, fnid
-    output :set, node.name.intern if node.name
   end
   
   def Declaration(node)
@@ -327,15 +351,18 @@ private
   end
   
   def Delete(node)
-    if node.expression.is_a?(Twostroke::AST::Variable)
-      output :deleteg, node.expression.name
-    elsif node.expression.is_a?(Twostroke::AST::MemberAccess)
-      compile node.expression.object
-      output :delete, node.expression.member
-    elsif node.expression.is_a?(Twostroke::AST::Index)
-      compile node.expression.object
-      output :delete, node.expression.index
+    if node.value.is_a?(Twostroke::AST::Variable)
+      output :deleteg, node.value.name.intern
+    elsif node.value.is_a?(Twostroke::AST::MemberAccess)
+      compile node.value.object
+      output :delete, node.value.member
+    elsif node.value.is_a?(Twostroke::AST::Index)  
+      compile node.value.index
+      compile node.value.object
+      output :deleteindex
     else
+      compile node.value
+      output :pop
       output :true
     end
   end
@@ -358,7 +385,6 @@ private
     compile node.try_statements
     # no exceptions? clean up
     output :popcatch if node.catch_variable
-    output :popfinally if node.catch_variable
     output :jmp, finally_label
     
     if node.catch_variable
@@ -371,6 +397,7 @@ private
     if node.finally_statements
       output :popfinally
       compile node.finally_statements
+      output :endfinally
     end
   end
   
@@ -437,7 +464,11 @@ private
   end
   
   def Number(node)
-    output :push, node.number
+    if node.number.is_a? Bignum
+      output :push, node.number.to_f
+    else
+      output :push, node.number
+    end
   end
   
   def UnaryPlus(node)
@@ -517,16 +548,32 @@ private
     node.statements.each { |s| compile s }
   end
   
+  def DoWhile(node)
+    start_label = uniqid
+    next_label = uniqid
+    end_label = uniqid
+    @continue_stack.push next_label
+    @break_stack.push end_label
+    output :".label", start_label
+    compile node.body
+    output :".label", next_label
+    compile node.condition
+    output :jit, start_label
+    output :".label", end_label
+  end
+  
   def ForLoop(node)
     compile node.initializer if node.initializer
     start_label = uniqid
+    next_label = uniqid
     end_label = uniqid
-    @continue_stack.push start_label
+    @continue_stack.push next_label
     @break_stack.push end_label
     output :".label", start_label
     compile node.condition if node.condition
     output :jif, end_label
     compile node.body if node.body
+    output :".label", next_label
     compile node.increment if node.increment
     output :jmp, start_label
     output :".label", end_label
@@ -556,16 +603,23 @@ private
     @continue_stack.pop
   end
   
+  def BinaryNot(node)
+    compile node.value
+    output :bnot
+  end
+  
   def Not(node)
     compile node.value
     output :not
   end
   
   def Break(node)
+    raise Twostroke::Compiler::CompileError, "Break not allowed outside of loop" unless @break_stack.any?
     output :jmp, @break_stack.last
   end
   
   def Continue(node)
+    raise Twostroke::Compiler::CompileError, "Continue not allowed outside of loop" unless @continue_stack.any?
     output :jmp, @continue_stack.last
   end
   

data/lib/twostroke/compiler.rb

@@ -1,5 +1,5 @@
 module Twostroke::Compiler
-  class CompileError < Twostroke::Error
+  class CompileError < Twostroke::SyntaxError
   end
   
   Dir.glob File.expand_path("../compiler/*", __FILE__) do |f|

data/lib/twostroke/error.rb

@@ -1,4 +1,7 @@
 module Twostroke
   class Error < StandardError
   end
+  
+  class SyntaxError < Error
+  end
 end

data/lib/twostroke/lexer.rb

@@ -1,5 +1,5 @@
 module Twostroke
-  class LexError < Twostroke::Error
+  class LexError < SyntaxError
   end
   
   class Token
@@ -27,6 +27,7 @@ module Twostroke
       @str = str
       @col = 1
       @line = 1
+      @line_terminator = false
     end
     
     def read_token(allow_regexp = true)
@@ -39,7 +40,7 @@ module Twostroke
           @col = 1 if !newlines.zero?
           @line += newlines
           @col += m[0].length - (m[0].rindex("\n") || 0)
-          if [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include? token[0]
+          if token[0] == :LINE_TERMINATOR or [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include? token[0]
             return read_token(allow_regexp)
           else
             return tok