twostroke 0.2.2 → 0.2.3

data/lib/twostroke.rb

@@ -4,4 +4,5 @@ require "twostroke/lexer"
 require "twostroke/parser"
 require "twostroke/ast"
 require "twostroke/compiler"
-require "twostroke/runtime"
+require "twostroke/runtime"
+require "twostroke/context"

data/lib/twostroke/ast/break.rb

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

data/lib/twostroke/ast/continue.rb

@@ -1,5 +1,7 @@
 module Twostroke::AST
   class Continue < Base
+    attr_accessor :label
+    
     def collapse
       self
     end

data/lib/twostroke/compiler/tsasm.rb

@@ -2,12 +2,11 @@ class Twostroke::Compiler::TSASM
   attr_accessor :bytecode, :ast, :prefix
   
   def initialize(ast, prefix = nil)
-    @methods = Hash[self.class.private_instance_methods(false).map { |name| [name, true] }]
     @ast = ast
     @prefix = prefix
   end
   
-  def compile(node = nil)
+  def compile(node = nil, *opt_args)
     if node
       if node.respond_to? :each
         # hoist named functions to top
@@ -16,14 +15,10 @@ class Twostroke::Compiler::TSASM
       elsif node.is_a? Symbol
         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
+        output :".line", @current_line = node.line if node.line and node.line > @current_line
+        @node_stack.push node
+        send type(node), node, *opt_args if node
+        @node_stack.pop
       end
     else
       @indent = 0
@@ -34,6 +29,7 @@ class Twostroke::Compiler::TSASM
       @break_stack = []
       @continue_stack = []
       @node_stack = []
+      @labels = {}
       @current_line = 0
             
       ast.each { |node| hoist node }
@@ -382,7 +378,9 @@ private
       output :pushfinally, finally_label
     end
     end_label = uniqid
+    
     compile node.try_statements
+    
     # no exceptions? clean up
     output :popcatch if node.catch_variable
     output :jmp, finally_label
@@ -437,12 +435,13 @@ private
     output :array, node.items.size
   end
   
-  def While(node)
+  def While(node, continue_label = nil)
     start_label = uniqid
     end_label = uniqid
     @continue_stack.push start_label
     @break_stack.push end_label
     output :".label", start_label
+    output :".label", continue_label if continue_label
     compile node.condition
     output :jif, end_label
     compile node.body
@@ -544,11 +543,26 @@ private
     @break_stack.pop
   end
   
+  def Label(node)
+    error! "Label '#{node.name}' has already been declared" if @labels[node.name]
+    end_label = uniqid
+    continue_label = uniqid
+    @labels[node.name] = { break: end_label }
+    if [:While, :DoWhile, :ForLoop, :ForIn].include? type(node.statement)
+      @labels[node.name][:continue] = continue_label
+      compile node.statement, continue_label
+    else
+      compile node.statement
+    end
+    output :".label", end_label
+    @labels.delete node.name
+  end
+  
   def Body(node)
     node.statements.each { |s| compile s }
   end
   
-  def DoWhile(node)
+  def DoWhile(node, continue_label = nil)
     start_label = uniqid
     next_label = uniqid
     end_label = uniqid
@@ -557,12 +571,13 @@ private
     output :".label", start_label
     compile node.body
     output :".label", next_label
+    output :".label", continue_label if continue_label
     compile node.condition
     output :jit, start_label
     output :".label", end_label
   end
   
-  def ForLoop(node)
+  def ForLoop(node, continue_label = nil)
     compile node.initializer if node.initializer
     start_label = uniqid
     next_label = uniqid
@@ -574,6 +589,7 @@ private
     output :jif, end_label
     compile node.body if node.body
     output :".label", next_label
+    output :".label", continue_label if continue_label
     compile node.increment if node.increment
     output :jmp, start_label
     output :".label", end_label
@@ -585,7 +601,7 @@ private
     output :enumnext
   end
   
-  def ForIn(node)
+  def ForIn(node, continue_label = nil)
     end_label = uniqid
     loop_label = uniqid
     @break_stack.push end_label
@@ -593,6 +609,7 @@ private
     compile node.object
     output :enum
     output :".label", loop_label
+    output :".label", continue_label if continue_label
     output :jiee, end_label
     mutate node.lval, :_enum_next
     compile node.body
@@ -614,13 +631,23 @@ private
   end
   
   def Break(node)
-    raise Twostroke::Compiler::CompileError, "Break not allowed outside of loop" unless @break_stack.any?
-    output :jmp, @break_stack.last
+    if node.label
+      error! "Undefined label '#{node.label}'" unless @labels[node.label]
+      output :jmp, @labels[node.label][:break]
+    else
+      error! "Break not allowed outside of loop" unless @break_stack.any?
+      output :jmp, @break_stack.last
+    end
   end
   
   def Continue(node)
-    raise Twostroke::Compiler::CompileError, "Continue not allowed outside of loop" unless @continue_stack.any?
-    output :jmp, @continue_stack.last
+    if node.label
+      error! "Undefined label '#{node.label}'" unless @labels[node.label]
+      output :jmp, @labels[node.label][:continue]
+    else
+      error! "Continue not allowed outside of loop" unless @continue_stack.any?
+      output :jmp, @continue_stack.last
+    end
   end
   
   def TypeOf(node)

data/lib/twostroke/context.rb

@@ -0,0 +1,58 @@
+module Twostroke
+  class Context
+    attr_reader :vm
+    
+    def initialize
+      @ai = 0
+      @vm = Twostroke::Runtime::VM.new({})
+      Twostroke::Runtime::Lib.setup_environment vm
+    end
+    
+    def [](var)
+      vm.global_scope.get_var(var.intern).to_ruby
+    end
+    
+    def raw_eval(src)
+      prefix = make_prefix
+      bytecode = compile src, prefix
+      main = :"#{prefix}main"
+      bytecode[main][-2] = [:ret]
+      vm.bytecode.merge! bytecode
+      vm.execute main, vm.global_scope.close
+    end  
+    
+    def eval(src)
+      raw_eval(src + ";").to_ruby
+    end
+    
+    def raw_exec(src)
+      prefix = make_prefix
+      bytecode = compile src, prefix
+      vm.bytecode.merge! bytecode
+      vm.execute :"#{prefix}_main"
+    end
+    
+    def exec(src)
+      raw_exec(src).to_ruby
+    end
+    
+    def inspect
+      to_s
+    end
+    
+  private  
+    def make_prefix
+      "#{@ai += 1}_".intern
+    end
+  
+    def compile(src, prefix)
+      parser = Twostroke::Parser.new Twostroke::Lexer.new src
+      parser.parse
+      compiler = Twostroke::Compiler::TSASM.new parser.statements, prefix
+      compiler.compile
+      compiler.bytecode
+    end
+  end
+end
+
+require "twostroke/context/object_proxy"

data/lib/twostroke/context/object_proxy.rb

@@ -0,0 +1,42 @@
+module Twostroke
+  class Context
+    class ObjectProxy < BasicObject
+      def initialize(object)
+        @object = object
+      end
+      
+      def [](prop)
+        o = @object.get(prop.to_s) and o.to_ruby
+      end
+      
+      def []=(prop, val)
+        unless val.is_a? ::Twostroke::Runtime::Types::Value
+          val = ::Twostroke::Runtime::Types.marshal val
+        end
+        @object.put prop.to_s, val
+      end
+      
+      def method_missing(prop, *args, &block)
+        return self[prop] = args[0] if prop =~ /=\z/
+        val = self[prop]
+        if val.respond_to? :call
+          val.call(*args)
+        elsif args.size > 0
+          ::Kernel.p args
+          ::Kernel.raise "Cannot call non-callable"
+        else
+          val
+        end
+      end
+      
+      def inspect
+        if toString = @object.get("toString") and toString.respond_to? :call
+          s = toString.call(nil, @object, [])
+          if s.is_a? ::Twostroke::Runtime::Types::Primitive
+            ::Twostroke::Runtime::Types.to_string(s).string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twostroke/lexer.rb

@@ -12,7 +12,7 @@ module Twostroke
   end
   
   class Lexer
-    attr_accessor :str, :col, :line
+    attr_accessor :str, :col, :line, :restricted
     
     def state
       { str: str, col: col, line: line }
@@ -28,6 +28,14 @@ module Twostroke
       @col = 1
       @line = 1
       @line_terminator = false
+      @restricted = false
+    end
+    
+    def restrict
+      @restricted = true
+      retn = yield
+      @restricted = false
+      retn
     end
     
     def read_token(allow_regexp = true)
@@ -40,7 +48,7 @@ module Twostroke
           @col = 1 if !newlines.zero?
           @line += newlines
           @col += m[0].length - (m[0].rindex("\n") || 0)
-          if token[0] == :LINE_TERMINATOR or [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include? token[0]
+          if [:WHITESPACE, :MULTI_COMMENT, :SINGLE_COMMENT].include?(token[0]) or (!restricted && token[0] == :LINE_TERMINATOR)
             return read_token(allow_regexp)
           else
             return tok

data/lib/twostroke/parser.rb

@@ -559,23 +559,49 @@ module Twostroke
     end
     
     def return
-      assert_type next_token, :RETURN
+      tok = @lexer.restrict do
+        assert_type next_token, :RETURN
+        peek_token true
+      end
+      if tok.type == :LINE_TERMINATOR
+        next_token true
+        return AST::Return.new line: token.line
+      end
       expr = expression unless peek_token.type == :SEMICOLON || peek_token.type == :CLOSE_BRACE
       AST::Return.new line: token.line, expression: expr
     end
     
     def break
-      assert_type next_token, :BREAK
-      AST::Break.new line: token.line
+      tok = @lexer.restrict do
+        assert_type next_token, :BREAK
+        peek_token
+      end
+      if tok.type == :LINE_TERMINATOR
+        next_token
+        return AST::Break.new line: token.line
+      end
+      label = next_token.val if try_peek_token and peek_token.type == :BAREWORD
+      AST::Break.new line: token.line, label: label
     end
     
     def continue
-      assert_type next_token, :CONTINUE
-      AST::Continue.new line: token.line
+      tok = @lexer.restrict do
+        assert_type next_token, :CONTINUE
+        peek_token
+      end
+      if tok.type == :LINE_TERMINATOR
+        next_token
+        return AST::Continue.new line: token.line
+      end
+      label = next_token.val if try_peek_token and peek_token.type == :BAREWORD
+      AST::Continue.new line: token.line, label: label
     end
     
     def throw
-      assert_type next_token, :THROW
+      tok = @lexer.restrict do
+        assert_type next_token, :THROW
+        error! "illegal newline after throw" if peek_token(true).type == :LINE_TERMINATOR
+      end
       AST::Throw.new line: token.line, expression: expression
     end
     
@@ -634,9 +660,10 @@ module Twostroke
         key = token
         assert_type next_token, :COLON
         obj.items.push [key, assignment_expression]
+        assert_type peek_token, :COMMA, :CLOSE_BRACE
         if peek_token.type == :COMMA
           next_token
-          redo
+          next
         end
       end
       next_token
@@ -648,9 +675,10 @@ module Twostroke
       ary = AST::Array.new line: token.line
       while peek_token(true).type != :CLOSE_BRACKET
         ary.items.push assignment_expression
+        assert_type peek_token, :COMMA, :CLOSE_BRACKET
         if peek_token.type == :COMMA
           next_token
-          redo
+          next
         end
       end
       next_token

data/lib/twostroke/runtime/lib.rb

@@ -3,7 +3,9 @@ module Twostroke::Runtime
     INITIALIZERS = []
   
     def self.setup_environment(vm)
-      INITIALIZERS.each { |i| i.arity == 1 ? i.(vm.global_scope) : i.(vm.global_scope, vm) }
+      scope = vm.global_scope
+      INITIALIZERS.each { |i| i.arity == 1 ? i.(scope) : i.(scope, vm) }
+      scope.get_var("Object").prototype = Types::Function.constructor_function.get("prototype")
     end
   
     def self.register(&bk)

data/lib/twostroke/runtime/lib/boolean.rb

@@ -5,19 +5,13 @@ module Twostroke::Runtime
     
     proto = Types::Object.new
     proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
-      if this.is_a?(Types::BooleanObject)
+        Lib.throw_type_error "Boolean.prototype.valueOf is not generic" unless this.is_a?(Types::BooleanObject)
         Types::String.new(this.boolean.to_s)
-      else
-        Lib.throw_type_error "Boolean.prototype.toString is not generic"
-      end
-    }, nil, "toString", [])
+      }, nil, "toString", [])
     proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) {
-      if this.is_a?(Types::BooleanObject)
+        Lib.throw_type_error "Boolean.prototype.valueOf is not generic" unless this.is_a?(Types::BooleanObject)
         Types::Boolean.new(this.boolean)
-      else
-        Types.to_primitive(this)
-      end
-    }, nil, "valueOf", [])
+      }, nil, "valueOf", [])
     obj.proto_put "prototype", proto
   end
 end

data/lib/twostroke/runtime/lib/console.rb

@@ -1,6 +1,6 @@
 module Twostroke::Runtime
   Lib.register do |scope|    
-    log = Types::Function.new(->(scope, this, args) { print args.map { |o| Types.to_string(o).string }.join(" ") + "\n" }, nil, "log", ["string"])
+    log = Types::Function.new(->(scope, this, args) { puts args.map { |o| Types.to_string(o).string }.join(" ") }, nil, "log", ["string"])
   
     console = Types::Object.new
     ["log", "info", "warn", "error"].each do |m|

data/lib/twostroke/runtime/lib/date.rb

@@ -1,3 +1,5 @@
+require "time"
+
 module Twostroke::Runtime
   Lib.register do |scope|
     obj = Types::Function.new(->(scope, this, args) {
@@ -9,7 +11,7 @@ module Twostroke::Runtime
           if args[0].is_a?(Types::Number)
             this.data[:time] = Time.at *(args[0].number*1000).divmod(1000_000)
           else
-            this.data[:time] = Time.parse Types.to_string(args[0]).string rescue this.data[:time] = :invalid
+            this.data[:time] = Time.parse(Types.to_string(args[0]).string) rescue this.data[:time] = :invalid
           end
         else
           args = args.take(7)
@@ -26,10 +28,13 @@ module Twostroke::Runtime
     obj.proto_put "parse", Types::Function.new(->(scope, this, args) {
         Types::Number.new (Time.parse(Types.to_string(args[0]).string).to_f * 1000).floor
       }, nil, "parse", [])
-    obj.proto_put "UTC", Types::Function.new(->(scope, this, args) {
+    obj.proto_put "UTC", Types::Function.new(->(scope, this, args) {  
+        return Types::Number.new Float::NAN if args.size < 2
         args = args.take(7)
           .map { |a| Types.to_uint32(a) }
-          .zip([9999, 12, 31, 23, 59, 59, 999]) { |a,b| [a || 0, b].min }
+          .zip([9999, 12, 31, 23, 59, 59, 999])
+          .map { |a,b| [a || 0, b].min }
+        args[1] += 1 if args[1]
         args[6] *= 1000 if args[6]
         Types::Number.new (Time.utc(*args).to_f * 1000).floor
       }, nil, "UTC", [])
@@ -37,7 +42,16 @@ module Twostroke::Runtime
     proto = Types::Object.new
     obj.proto_put "prototype", proto
     
-    { "Date" => :day, "Day" => :wday, "FullYear" => :year, "Hours" => :hour,
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+        Lib.throw_type_error "this is not a Date object" unless this.data[:time]
+        Types::String.new this.data[:time].strftime("%a %b %d %Y %H:%M:%S GMT%z (%Z)")
+      }, nil, "toString", [])
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) {
+        Lib.throw_type_error "this is not a Date object" unless this.data[:time]
+        Types::Number.new (this.data[:time].to_f * 1000).to_i
+      }, nil, "valueOf", [])
+    
+    { "Date" => :day, "Day" => :wday, "FullYear" => :year, "Year" => ->t{ t.year - 1900 }, "Hours" => :hour,
       "Milliseconds" => ->t{ (t.usec / 1000).to_i }, "Minutes" => :min, "Month" => :month,
       "Seconds" => :sec, "Time" => ->t{ (t.to_f * 1000).floor }, "TimezoneOffset" => ->t{ t.utc_offset / 60 } }.each do |prop,method|
         # Date.prototype.getXXX