twostroke 0.1.0 → 0.2.0

data/lib/twostroke/runtime/vm_frame.rb

@@ -18,12 +18,13 @@ module Twostroke::Runtime
     end
     
     def execute(scope, this = nil, args = [])
-      @scope = scope || Scope.new(vm.global_scope)
+      @scope = scope || vm.global_scope
       @stack = []
       @sp_stack = []
       @catch_stack = []
       @finally_stack = []
       @enum_stack = []
+      @temp_slot = nil
       @ip = 0
       @return = false
       @this = this || @scope.global_scope.root_object
@@ -35,13 +36,18 @@ module Twostroke::Runtime
       end
       
       until @return
-        ins, arg = *insns[ip]
+        ins, arg = insns[ip]
         st = @stack.size
         @ip += 1
         if respond_to? ins
           if @exception = catch(:exception) { public_send ins, arg; nil }
-            throw :exception, @exception if catch_stack.empty?
-            @ip = catch_stack.last
+#            puts "--> #{Types.to_string(exception).string}  #{@name || "(anonymous function)"}:#{@line}  <#{@section}+#{@ip}>"
+            throw :exception, @exception if catch_stack.empty? && finally_stack.empty?
+            if catch_stack.any?
+              @ip = catch_stack.last
+            else
+              @ip = finally_stack.last
+            end
           end
         else
           error! "unknown instruction #{ins}"
@@ -51,7 +57,12 @@ module Twostroke::Runtime
       stack.last
     end
     
+    define_method ".line" do |arg|
+      @line = arg
+    end
+    
     define_method ".name" do |arg|
+      @name = arg
       scope.declare arg.intern
       scope.set_var arg.intern, @callee
     end
@@ -68,6 +79,7 @@ module Twostroke::Runtime
     define_method ".catch" do |arg|
       scope.declare arg.intern
       scope.set_var arg.intern, @exception
+      @exception = nil
     end
     
     ## instructions
@@ -91,7 +103,7 @@ module Twostroke::Runtime
       arg.times { args.unshift @stack.pop }
       fun = stack.pop
       Lib.throw_type_error "called non callable" unless fun.respond_to?(:call)
-      stack.push fun.call(scope, scope.global_scope.root_object, args)
+      stack.push fun.call(scope, fun.inherits_caller_this ? @this : scope.global_scope.root_object, args)
     end
     
     def thiscall(arg)
@@ -99,7 +111,8 @@ module Twostroke::Runtime
       arg.times { args.unshift stack.pop }
       fun = stack.pop
       Lib.throw_type_error "called non callable" unless fun.respond_to?(:call)
-      stack.push fun.call(scope, Types.to_object(stack.pop), args)
+      this_arg = Types.to_object stack.pop
+      stack.push fun.call(scope, fun.inherits_caller_this ? @this : this_arg, args)
     end
     
     def newcall(arg)
@@ -123,16 +136,33 @@ module Twostroke::Runtime
       stack.push *stack[-n..-1]
     end
     
+    def tst(arg)
+      @temp_slot = stack.pop
+    end
+    
+    def tld(arg)
+      stack.push @temp_slot
+    end
+    
     def member(arg)
       stack.push Types.to_object(stack.pop).get(arg.to_s)
     end
     
     def deleteg(arg)
-      scope.global_scope.root_object.delete arg.to_s
+      scope.delete arg
+      stack.push Types::Boolean.true
     end
     
     def delete(arg)
       Types.to_object(stack.pop).delete arg.to_s
+      stack.push Types::Boolean.true
+    end
+    
+    def deleteindex(arg)
+      obj = Types.to_object stack.pop
+      idx = Types.to_string stack.pop
+      obj.delete idx.string
+      stack.push Types::Boolean.true
     end
     
     def in(arg)
@@ -169,7 +199,7 @@ module Twostroke::Runtime
     
     def setprop(arg)
       val = stack.pop
-      obj = stack.pop
+      obj = Types.to_object(stack.pop)
       obj.put arg.to_s, val
       stack.push val
     end
@@ -338,6 +368,11 @@ module Twostroke::Runtime
       stack.push Types::Number.new(left ^ right)
     end
     
+    def bnot(arg)
+      val = Types.to_int32 stack.pop
+      stack.push Types::Number.new ~val
+    end
+    
     def setindex(arg)
       val = stack.pop
       index = Types.to_string(stack.pop).string
@@ -436,6 +471,10 @@ module Twostroke::Runtime
       finally_stack.pop
     end
     
+    def endfinally(arg)
+      throw :exception, @exception if @exception
+    end
+    
     def this(arg)
       stack.push @this
     end

data/lib/twostroke/tokens.rb

@@ -7,9 +7,10 @@ module Twostroke
     TOKENS = [
 
       [ :MULTI_COMMENT, %r{/\*.*?\*/} ],
-      [ :SINGLE_COMMENT, /\/\/.*?$/ ],
+      [ :SINGLE_COMMENT, /\/\/.*?($|\r|\u2029|\u2028)/ ],
 
-      [ :WHITESPACE, /\s+/ ],
+      [ :LINE_TERMINATOR, /[\n\r\u2028\u2029]/ ],
+      [ :WHITESPACE, /[[:space:]]+/ ],
       [ :NUMBER, /((?<oct>0[0-7]+)|(?<hex>0x[A-Fa-f0-9]+)|(?<to_f>(\d+(\.?\d*([eE][+-]?\d+)?)?|\.\d+([eE][+-]?\d+)?)))/, ->m do
         method, number = m.names.zip(m.captures).select { |k,v| v }.first
         n = number.send method
@@ -25,21 +26,24 @@ module Twostroke
       end,
       [ :BAREWORD, /[a-zA-Z_\$][\$a-zA-Z_0-9]*/, ->m { m[0] } ],
 
-      [ :STRING, /(["'])((\\\n|\\.|[^\1])*?[^\1\\]?)\1/, ->m do
-        m[2]
-        .gsub(/\\([0-6]{1,3})/) { |m| m[1].to_i(7).chr }
-        .gsub(/\\x([a-f0-9]{2})/i) { |m| m[1].to_i(16).chr }
-        .gsub(/\\u([a-f0-9]{4})/i) { |m| m[1].to_i(16).chr }
-        .gsub(/\\(.)/m) { |m|
-          case m[1]
-          when "b"; "\b"
-          when "n"; "\n"
-          when "f"; "\f"
-          when "r"; "\r"
-          when "t"; "\t"
-          else; m[1]
+      [ :STRING, /(["'])((\\\n|\\.|[^\n\r\u2028\u2029\1])*?[^\1\\]?)\1/, ->m do
+        m[2].gsub(/\\(([0-6]{1,3})|u([a-f0-9]{4})|x([a-f0-9]{2})|\n|.)/i) do |m|
+          case m
+          when /\\([0-6]{1,3})/; m[1..-1].to_i(7).chr "utf-8" 
+          when /\\u([a-f0-9]{4})/i; m[2..-1].to_i(16).chr "utf-8"
+          when /\\x([a-f0-9]{2})/i; m[2..-1].to_i(16).chr "utf-8"
+          else case m[1]
+                 when "b"; "\b"
+                 when "n"; "\n"
+                 when "f"; "\f"
+                 when "v"; "\v"
+                 when "r"; "\r"
+                 when "t"; "\t"
+                 when "\n"; ""
+                 else; m[1]
+               end
           end
-        }
+        end
       end ],
       
       [ :REGEXP, %r{/(?<src>(\\.|[^\1])*?[^\1\\]?)/(?<opts>[gim]+)?}, ->m { [m[:src], m[:opts]] } ],
@@ -53,6 +57,18 @@ module Twostroke
 
       [ :MEMBER_ACCESS, /\./ ],
 
+      [ :ADD_EQUALS, /\+=/ ],
+      [ :MINUS_EQUALS, /-=/ ],
+      [ :TIMES_EQUALS, /\*=/ ], # textmate barfs it's syntax highlighting on this one lol
+      [ :DIVIDE_EQUALS, /\/=/ ],
+      [ :MOD_EQUALS, /%=/ ],
+      [ :LEFT_SHIFT_EQUALS, /<<=/ ],
+      [ :RIGHT_TRIPLE_SHIFT_EQUALS, />>>=/ ],
+      [ :RIGHT_SHIFT_EQUALS, />>=/ ],
+      [ :BITWISE_AND_EQUALS, /&=/ ],
+      [ :BITWISE_XOR_EQUALS, /\^=/ ],
+      [ :BITWISE_OR_EQUALS, /\|=/ ],
+
       [ :INCREMENT, /\+\+/ ],
       [ :DECREMENT, /--/ ],
       [ :PLUS, /\+/ ],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twostroke
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-09 00:00:00.000000000 Z
+date: 2012-01-10 00:00:00.000000000 Z
 dependencies: []
 description: An implementation of Javascript written in pure Ruby. Twostroke contains
   a parser, a bytecode compiler, a VM, and a minimal implementation of the Javascript
@@ -29,7 +29,6 @@ files:
 - lib/twostroke/ast/case.rb
 - lib/twostroke/ast/continue.rb
 - lib/twostroke/ast/declaration.rb
-- lib/twostroke/ast/delete.rb
 - lib/twostroke/ast/do_while.rb
 - lib/twostroke/ast/false.rb
 - lib/twostroke/ast/for_in.rb
@@ -37,6 +36,7 @@ files:
 - lib/twostroke/ast/function.rb
 - lib/twostroke/ast/if.rb
 - lib/twostroke/ast/index.rb
+- lib/twostroke/ast/label.rb
 - lib/twostroke/ast/member_access.rb
 - lib/twostroke/ast/multi_expression.rb
 - lib/twostroke/ast/new.rb
@@ -53,7 +53,6 @@ files:
 - lib/twostroke/ast/true.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/with.rb
@@ -70,7 +69,8 @@ files:
 - lib/twostroke/runtime/lib/console.rb
 - lib/twostroke/runtime/lib/date.rb
 - lib/twostroke/runtime/lib/error.rb
-- lib/twostroke/runtime/lib/function.js
+- lib/twostroke/runtime/lib/etc.js
+- lib/twostroke/runtime/lib/etc.rb
 - lib/twostroke/runtime/lib/function.rb
 - lib/twostroke/runtime/lib/math.rb
 - lib/twostroke/runtime/lib/number.rb

data/lib/twostroke/ast/delete.rb

@@ -1,15 +0,0 @@
-module Twostroke::AST
-  class Delete < Base
-    attr_accessor :expression
-    
-    def collapse
-      self.class.new expression: expression.collapse
-    end
-    
-    def walk(&bk)
-      if yield self
-        expression.walk &bk
-      end
-    end
-  end
-end

data/lib/twostroke/ast/unsorted_binop.rb

@@ -1,97 +0,0 @@
-module Twostroke::AST
-  class UnsortedBinop < Base
-    attr_accessor :left, :op, :right
-    
-    def self.operator_class
-      @@classes ||= {
-        :ASTERISK           => Multiplication,
-        :SLASH              => Division,
-        :MOD                => Modulus,
-        :PLUS               => Addition,
-        :MINUS              => Subtraction,
-        :LEFT_SHIFT         => LeftShift,
-        :RIGHT_SHIFT        => RightArithmeticShift,
-        :RIGHT_TRIPLE_SHIFT => RightLogicalShift,
-        :LT                 => LessThan,
-        :LTE                => LessThanEqual,
-        :GT                 => GreaterThan,
-        :GTE                => GreaterThanEqual,
-        :IN                 => In,
-        :INSTANCEOF         => InstanceOf,
-        :DOUBLE_EQUALS      => Equality,
-        :NOT_EQUALS         => Inequality,
-        :TRIPLE_EQUALS      => StrictEquality,
-        :NOT_DOUBLE_EQUALS  => StrictInequality,
-        :AMPERSAND          => BitwiseAnd,
-        :CARET              => BitwiseXor,
-        :PIPE               => BitwiseOr,
-        :AND                => And,
-        :OR                 => Or
-      }
-    end
-    
-    def self.operator_precedence
-      @precedences ||= {
-        :ASTERISK           => 5,
-        :SLASH              => 5,
-        :MOD                => 5,
-        :PLUS               => 6,
-        :MINUS              => 6,
-        :LEFT_SHIFT         => 7,
-        :RIGHT_SHIFT        => 7,
-        :RIGHT_TRIPLE_SHIFT => 7,
-        :LT                 => 8,
-        :LTE                => 8,
-        :GT                 => 8,
-        :GTE                => 8,
-        :IN                 => 8,
-        :INSTANCEOF         => 8,
-        :DOUBLE_EQUALS      => 9,
-        :NOT_EQUALS         => 9,
-        :TRIPLE_EQUALS      => 9,
-        :NOT_DOUBLE_EQUALS  => 9,
-        :AMPERSAND          => 10,
-        :CARET              => 11,
-        :PIPE               => 12,
-        :AND                => 13,
-        :OR                 => 14
-      }
-    end
-    
-    def collapse(called_by_binop = false)
-      left_collapsed = left.is_a?(UnsortedBinop) ? left.collapse(true) : left.collapse
-      right_collapsed = right.is_a?(UnsortedBinop) ? right.collapse(true) : right.collapse
-      input = [*left_collapsed, op, *right_collapsed]
-      
-      unless called_by_binop
-        stack = []
-        output = []
-        input.each do |token|
-          if token.is_a? Symbol
-            while stack.size > 0 && UnsortedBinop.operator_precedence[stack.last] <= UnsortedBinop.operator_precedence[token]
-              output.push stack.pop
-            end
-            stack.push token
-          else
-            output.push token
-          end
-        end
-        output.push stack.pop until stack.empty?
-        
-        output.each do |token|
-          if token.is_a? Symbol
-            r = stack.pop
-            l = stack.pop
-            stack.push UnsortedBinop.operator_class[token].new(left: l, right: r)
-          else
-            stack.push token
-          end
-        end
-        
-        stack.last
-      else
-        input
-      end
-    end
-  end
-end