twostroke 0.2.2 → 0.2.3

data/lib/twostroke/runtime/vm_frame.rb

@@ -38,18 +38,14 @@ module Twostroke::Runtime
       until @return
         ins, arg = insns[ip]
         @ip += 1
-        if respond_to? ins
-          if @exception = catch(:exception) { send ins, arg; nil }
-#            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
+        if @exception = catch(:exception) { send ins, arg; nil }
+#          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
-        else
-          error! "unknown instruction #{ins}"
         end
       end
       
@@ -88,12 +84,8 @@ module Twostroke::Runtime
         stack.push scope.get_var(arg)
       elsif arg.is_a?(Fixnum) || arg.is_a?(Float)
         stack.push Types::Number.new(arg)
-      elsif arg.is_a?(Bignum)
-        stack.push Types::Number.new(arg.to_f)
       elsif arg.is_a?(String)
         stack.push Types::String.new(arg)
-      else
-        error! "bad argument to push instruction"
       end
     end
     
@@ -232,11 +224,11 @@ module Twostroke::Runtime
     end
     
     def true(arg)
-      stack.push Types::Boolean.new(true)
+      stack.push Types::Boolean.true
     end
     
     def false(arg)
-      stack.push Types::Boolean.new(false)
+      stack.push Types::Boolean.false
     end
     
     def jmp(arg)
@@ -300,13 +292,13 @@ module Twostroke::Runtime
       stack.push Types::Number.new(l << r)
     end
     
-    def sar(arg)
+    def slr(arg)
       r = Types.to_uint32(stack.pop) & 31
       l = Types.to_int32 stack.pop
       stack.push Types::Number.new(l >> r)
     end
     
-    def slr(arg)
+    def sar(arg)
       r = Types.to_uint32(stack.pop) & 31
       l = Types.to_uint32 stack.pop
       stack.push Types::Number.new(l >> r)

data/lib/twostroke/tokens.rb

@@ -10,7 +10,7 @@ module Twostroke
       [ :SINGLE_COMMENT, /\/\/.*?($|\r|\u2029|\u2028)/ ],
 
       [ :LINE_TERMINATOR, /[\n\r\u2028\u2029]/ ],
-      [ :WHITESPACE, /[[:space:]]+/ ],
+      [ :WHITESPACE, /[ \t\r\v\f]+/ ],
       [ :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
@@ -29,7 +29,7 @@ module Twostroke
       [ :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 /\\([0-6]{1,3})/; m[1..-1].to_i(8).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]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twostroke
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-11 00:00:00.000000000 Z
+date: 2012-01-17 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
@@ -57,9 +57,10 @@ files:
 - lib/twostroke/ast/while.rb
 - lib/twostroke/ast/with.rb
 - lib/twostroke/ast.rb
-- lib/twostroke/compiler/javascript.rb
 - lib/twostroke/compiler/tsasm.rb
 - lib/twostroke/compiler.rb
+- lib/twostroke/context/object_proxy.rb
+- lib/twostroke/context.rb
 - lib/twostroke/error.rb
 - lib/twostroke/lexer.rb
 - lib/twostroke/parser.rb
@@ -73,6 +74,7 @@ files:
 - lib/twostroke/runtime/lib/etc.rb
 - lib/twostroke/runtime/lib/function.rb
 - lib/twostroke/runtime/lib/math.rb
+- lib/twostroke/runtime/lib/number.js
 - lib/twostroke/runtime/lib/number.rb
 - lib/twostroke/runtime/lib/object.js
 - lib/twostroke/runtime/lib/object.rb

data/lib/twostroke/compiler/javascript.rb

@@ -1,414 +0,0 @@
-class Twostroke::Compiler::Javascript  
-  attr_accessor :src, :ast
-  
-  def initialize(ast)
-    @methods = Hash[self.class.private_instance_methods(false).map { |name| [name, true] }]
-    @ast = ast
-  end
-  
-  def compile(node = nil)
-    if node
-      if node.respond_to? :each
-        # hoist named functions to top
-        node.select { |n| n.is_a?(Twostroke::AST::Function) && n.name }.each { |n| compile n }
-        node.reject { |n| n.is_a?(Twostroke::AST::Function) && n.name }.each { |n| compile n }
-      else
-        if @methods[type(node)]
-          send type(node), node if node
-        else
-          error! "#{type node} not implemented"
-        end
-      end
-    else
-      @indent = 0
-      @src = ""
-      prologue
-      ast.each { |node| compile node }
-    end
-  end
-  
-private
-  # utility methods
-  
-  def error!(msg)
-    raise Twostroke::Compiler::CompileError, msg
-  end
-  
-  def type(node)
-    node.class.name.split("::").last.intern
-  end
-  
-  def indent
-    @indent += 1
-  end
-  
-  def dedent
-    @indent -= 1
-  end
-  
-  def output(line)
-    @src << "#{"\t" * @indent}#{line}\n"
-  end
-  
-  def stack
-    "__stack"
-  end
-  
-  def prologue
-    output "var #{stack} = [], #{stack}_sizes = [], __tmp;"
-  end
-  
-  def binop(op, node)
-    if node.assign_result_left
-      compile node.right
-      mutate node.left, "%s #{op}= #{stack}.pop()"
-    else
-      compile node.right
-      compile node.left
-      output "#{stack}.push(#{stack}.pop() #{op} #{stack}.pop());"
-    end
-  end
-  
-  def escape(str)
-    escaped = str.gsub("\\","\\\\").gsub('"','\\"').gsub(/[^\x20-\x7e]/) do |m|
-      if m.ord < 256
-        sprintf '\x%02x', m.ord
-      else
-        sprintf '\u%04x', m.ord
-      end
-    end
-    "\"#{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
-    elsif type(left) == :Declaration
-      compile left
-      lval = left.name
-    elsif type(left) == :MemberAccess
-      compile left.object
-      lval = "#{stack}.pop().#{left.member}"
-    elsif type(left) == :Index
-      compile left.index
-      compile left.object
-      lval = "#{stack}.pop()[#{stack}.pop()]"
-    else
-      error! "Invalid left hand side in assignment"
-    end
-    output "#{stack}.push(#{sprintf(fmt, lval)});"
-  end
-  
-  # code generation methods
-  
-  def Call(node)
-    compile node.arguments.reverse_each 
-    callee = nil
-    if type(node.callee) == :MemberAccess
-      compile node.callee.object
-      callee = "#{stack}.pop().#{node.callee.member}"
-    elsif type(node.callee) == :Index
-      compile node.callee.index
-      compile node.callee.object
-      callee = "#{stack}.pop()[#{stack}.pop()]"
-    else
-      compile node.callee
-      callee = "#{stack}.pop()"
-    end
-    args = (["#{stack}.pop()"] * node.arguments.size).join ", "
-    output "#{stack}.push(#{callee}(#{args}));"
-  end
-  
-  def Variable(node)
-    output "#{stack}.push(#{node.name});"
-  end
-  
-  def String(node)
-    output "#{stack}.push(#{escape node.string});"
-  end
-  
-  def MultiExpression(node)
-    output "#{stack}_sizes.push(#{stack}.length);"
-    compile node.left
-    output "#{stack}.length = #{stack}_sizes.pop();" # so we don't unbalance the stack
-    compile node.right
-  end
-  
-  def Declaration(node)
-    output "var #{node.name};"
-  end
-  
-  def Assignment(node)
-    compile node.right
-    mutate node.left, "%s = #{stack}.pop()"
-  end
-  
-  def Function(node)
-    if node.name
-      output "function #{node.name}(#{node.arguments.join ", "}) {"
-    else
-      output "#{stack}.push(function(#{node.arguments.join ", "}) {"
-    end
-    indent
-    prologue
-    compile node.statements
-    dedent
-    if node.name
-      output "}"
-      output "#{stack}.push(#{node.name});"
-    else
-      output "});"
-    end
-  end
-  
-  def Return(node)
-    compile node.expression
-    output "return #{stack}.pop();"
-  end
-  
-  def Addition(node);         binop "+", node; end
-  def Subtraction(node);      binop "-", node; end
-  def Multiplication(node);   binop "*", node; end
-  def Division(node);         binop "/", node; end
-  def Equality(node);         binop "==", node; end
-  def Inequality(node);       binop "!=", node; end
-  def StrictEquality(node);   binop "===", node; end
-  def StrictInequality(node); binop "!==", node; end
-  def LessThan(node);         binop "<", node; end
-  def LessThanEqual(node);    binop "<=", node; end
-  def GreaterThan(node);      binop ">", node; end
-  def GreaterThanEqual(node); binop ">=", node; end
-  
-  def And(node)
-    compile node.left
-    output "if(#{stack}[#{stack}.length - 1]) {"
-    indent
-    compile node.right
-    dedent
-    output "}"
-  end
-  def Or(node)
-    compile node.left
-    output "if(!#{stack}[#{stack}.length - 1]) {"
-    indent
-    compile node.right
-    dedent
-    output "}"
-  end
-  
-  def If(node)
-    compile node.condition
-    output "if(#{stack}.pop()) {"
-    indent
-    compile node.then
-    dedent
-    output "} else {"
-    indent
-    compile node.else if node.else
-    dedent
-    output "}"
-  end
-  
-  def Null(node)
-    output "#{stack}.push(null);"
-  end
-  
-  def This(node)
-    output "#{stack}.push(this);"
-  end
-  
-  def Array(node)
-    compile node.items.reverse
-    args = ["#{stack}.pop()"] * node.items.size
-    output "#{stack}.push([#{args.join ", "}]);"
-  end
-  
-  def ObjectLiteral(node)
-    compile node.items.map(&:last).reverse
-    keys = []
-    node.items.each do |k,v|
-      keys << "#{escape k.val}: #{stack}.pop()"
-    end
-    output "#{stack}.push({ #{keys.join ", "} });"
-  end
-  
-  def Number(node)
-    output "#{stack}.push(#{node.number});"
-  end
-  
-  def Index(node)
-    compile node.index
-    compile node.object
-    output "#{stack}.push(#{stack}.pop()[#{stack}.pop()]);"
-  end
-  
-  def Negation(node)
-    compile node.value
-    output "#{stack}.push(-#{stack}.pop());"
-  end
-  
-  def Not(node)
-    compile node.value
-    output "#{stack}.push(!#{stack}.pop());"
-  end
-  
-  def Body(node)
-    compile node.statements
-  end
-  
-  def Ternary(node)
-    compile node.condition
-    output "if(#{stack}.pop()) {"
-    indent
-    compile node.if_true
-    dedent
-    output "} else {"
-    indent
-    compile node.if_false
-    dedent
-    output "}"
-  end
-  
-  def MemberAccess(node)
-    compile node.object
-    output "#{stack}.push(#{stack}.pop().#{node.member});"
-  end
-  
-  def ForLoop(node)
-    compile node.initializer
-    output "while(true) {"
-    indent
-    compile node.condition
-    output "if(!#{stack}.pop()) break;"
-    compile node.body
-    compile node.increment
-    dedent
-    output "}"
-  end
-  
-  def ForIn(node)
-    compile node.object
-    output "for(var __tmp_lval in #{stack}.pop()) {"
-    indent
-    mutate node.lval, "%s = __tmp_lval"
-    compile node.body
-    dedent
-    output "}"
-  end
-  
-  def PostIncrement(node)
-    mutate node.value, "%s++"
-  end
-  def PostDecrement(node)
-    mutate node.value, "%s--"
-  end
-  def PreIncrement(node)
-    mutate node.value, "++%s"
-  end
-  def PreDecrement(node)
-    mutate node.value, "--%s"
-  end
-  
-  def While(node)
-    output "while(true) {"
-    indent
-    compile node.condition
-    output "if(!#{stack}.pop()) break;"
-    compile node.body
-    dedent
-    output "}"
-  end
-  
-  def Try(node)
-    output "try {"
-    indent
-    compile node.try_statements
-    dedent
-    if node.catch_variable
-      output "} catch(#{node.catch_variable}) {"
-      indent
-      compile node.catch_statements
-      dedent
-    end
-    if node.finally_statements
-      output "} finally {"
-      indent
-      compile node.finally_statements
-      dedent
-    end
-    output "}"
-  end
-  
-  def Void(node)
-    compile node.value
-    output "#{stack}.push(void #{stack}.pop());"
-  end
-  
-  def TypeOf(node)
-    puts type(node.value)
-    if type(node.value) == :VARIABLE
-      output "#{stack}.push(typeof #{node.value.name});"
-    else
-      compile node.value
-      output "#{stack}.push(typeof #{stack}.pop());"
-    end
-  end
-  
-  def New(node)
-    compile node.arguments.reverse
-    compile node.callee
-    args = ["#{stack}.pop()"] * node.arguments.size
-    output "__tmp = #{stack}.pop();"
-    output "#{stack}.push(new __tmp(#{args.join ", "}));"
-  end
-  
-  def Switch(node)
-    compile node.cases.reverse.map { |c| c.expression }.reject(&:nil?)
-    cases = ["#{stack}.pop()"] * node.cases.size
-    output "__tmp = [#{cases.join ", "}]"
-    compile node.expression
-    output "switch(#{stack}.pop()) {"
-    indent
-    i = 0
-    node.cases.each do |c|
-      dedent
-      if c.expression
-        output "case __tmp[#{i}]:"
-        i += 1
-      else
-        output "default:"
-      end
-      indent
-      compile c.statements
-    end
-    dedent
-    output "}"
-  end
-  
-  def Break(node)
-    output "break;"
-  end
-  
-  def Continue(node)
-    output "continue;"
-  end
-end