twostroke 0.0.4 → 0.1.0

data/lib/twostroke/runtime/vm_frame.rb

@@ -0,0 +1,459 @@
+module Twostroke::Runtime
+  class VM::Frame
+    attr_reader :vm, :insns, :stack, :sp_stack, :catch_stack, :finally_stack, :enum_stack, :exception, :ip, :scope
+    
+    def initialize(vm, section, callee = nil)
+      @vm = vm
+      @section = section
+      @insns = vm.bytecode[section]
+      @callee = callee
+    end
+    
+    def arguments_object
+      arguments = Types::Object.new
+      @args.each_with_index { |arg,i| arguments.put i.to_s, arg }
+      arguments.put "length", Types::Number.new(@args.size)
+      arguments.put "callee", @callee
+      arguments
+    end
+    
+    def execute(scope, this = nil, args = [])
+      @scope = scope || Scope.new(vm.global_scope)
+      @stack = []
+      @sp_stack = []
+      @catch_stack = []
+      @finally_stack = []
+      @enum_stack = []
+      @ip = 0
+      @return = false
+      @this = this || @scope.global_scope.root_object
+      @args = args
+      if @callee
+        # the arguments object is only available within functions
+        scope.declare :arguments
+        scope.set_var :arguments, arguments_object
+      end
+      
+      until @return
+        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
+          end
+        else
+          error! "unknown instruction #{ins}"
+        end
+      end
+      
+      stack.last
+    end
+    
+    define_method ".name" do |arg|
+      scope.declare arg.intern
+      scope.set_var arg.intern, @callee
+    end
+    
+    define_method ".local" do |arg|
+      scope.declare arg.intern
+    end
+    
+    define_method ".arg" do |arg|
+      scope.declare arg.intern
+      scope.set_var arg.intern, @args.shift || Types::Undefined.new
+    end
+    
+    define_method ".catch" do |arg|
+      scope.declare arg.intern
+      scope.set_var arg.intern, @exception
+    end
+    
+    ## instructions
+    
+    def push(arg)
+      if arg.is_a? Symbol
+        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
+    
+    def call(arg)
+      args = []
+      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)
+    end
+    
+    def thiscall(arg)
+      args = []
+      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)
+    end
+    
+    def newcall(arg)
+      args = []
+      arg.times { args.unshift @stack.pop }
+      fun = stack.pop
+      Lib.throw_type_error "called non callable" unless fun.respond_to?(:call)
+      obj = Types::Object.new
+      obj.construct prototype: fun.get("prototype"), _class: fun do
+        retn = fun.call(scope, obj, args)
+        if retn.is_a?(Types::Undefined)
+          stack.push obj
+        else
+          stack.push retn
+        end
+      end
+    end
+    
+    def dup(arg)
+      n = arg || 1
+      stack.push *stack[-n..-1]
+    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
+    end
+    
+    def delete(arg)
+      Types.to_object(stack.pop).delete arg.to_s
+    end
+    
+    def in(arg)
+      obj = Types.to_object stack.pop
+      idx = Types.to_string stack.pop
+      stack.push Types::Boolean.new(obj.has_property idx.string)
+    end
+    
+    def enum(arg)
+      props = []
+      obj = stack.pop
+      Types.to_object(obj).each_enumerable_property { |p| props.push p } unless obj.is_a?(Types::Null) || obj.is_a?(Types::Undefined)
+      @enum_stack.push [props, 0]
+    end
+
+    def enumnext(arg)
+      enum = @enum_stack.last
+      stack.push Types::String.new(enum[0][enum[1]])
+      enum[1] += 1
+    end
+    
+    def jiee(arg)
+      enum = @enum_stack.last
+      @ip = arg if enum[1] >= enum[0].size
+    end
+    
+    def popenum(arg)
+      @enum_stack.pop
+    end
+    
+    def set(arg)
+      scope.set_var arg, stack.last
+    end
+    
+    def setprop(arg)
+      val = stack.pop
+      obj = stack.pop
+      obj.put arg.to_s, val
+      stack.push val
+    end
+    
+    def ret(arg)
+      if finally_stack.empty?
+        @return = true
+      else
+        @ip = finally_stack.last
+      end
+    end
+    
+    def _throw(arg)
+      throw :exception, stack.pop
+    end
+    
+    def eq(arg)
+      b = stack.pop
+      a = stack.pop
+      stack.push Types::Boolean.new(Types.eq(a, b))
+    end
+    
+    def seq(arg)
+      b = stack.pop
+      a = stack.pop
+      stack.push Types::Boolean.new(Types.seq(a, b))
+    end
+    
+    def null(arg)
+      stack.push Types::Null.new
+    end
+    
+    def true(arg)
+      stack.push Types::Boolean.new(true)
+    end
+    
+    def false(arg)
+      stack.push Types::Boolean.new(false)
+    end
+    
+    def jmp(arg)
+      @ip = arg.to_i
+    end
+    
+    def jif(arg)
+      if Types.is_falsy stack.pop
+        @ip = arg.to_i
+      end
+    end
+    
+    def jit(arg)
+      if Types.is_truthy stack.pop
+        @ip = arg.to_i
+      end
+    end
+    
+    def not(arg)
+      stack.push Types::Boolean.new(Types.is_falsy(stack.pop))
+    end
+    
+    def inc(arg)
+      stack.push Types::Number.new(Types.to_number(stack.pop).number + 1)
+    end
+    
+    def dec(arg)
+      stack.push Types::Number.new(Types.to_number(stack.pop).number - 1)
+    end
+    
+    def pop(arg)
+      stack.pop
+    end
+    
+    def index(arg)
+      index = Types.to_string(stack.pop).string
+      stack.push(Types.to_object(stack.pop).get(index) || Types::Undefined.new)
+    end
+    
+    def array(arg)
+      args = []
+      arg.times { args.unshift stack.pop }
+      stack.push Types::Array.new(args)
+    end
+    
+    def undefined(arg)
+      stack.push Types::Undefined.new
+    end
+    
+    def number(arg)
+      stack.push Types.to_number(stack.pop)
+    end
+    
+    def regexp(arg)
+      stack.push Types::RegExp.new(*arg)
+    end
+    
+    def sal(arg)
+      r = Types.to_uint32(stack.pop) & 31
+      l = Types.to_int32 stack.pop
+      stack.push Types::Number.new(l << r)
+    end
+    
+    def sar(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)
+      r = Types.to_uint32(stack.pop) & 31
+      l = Types.to_uint32 stack.pop
+      stack.push Types::Number.new(l >> r)
+    end
+    
+    def add(arg)
+      r = stack.pop
+      l = stack.pop
+      right = Types.to_primitive r
+      left = Types.to_primitive l
+      
+      if left.is_a?(Types::String) || right.is_a?(Types::String)
+        stack.push Types::String.new(Types.to_string(left).string + Types.to_string(right).string)
+      else
+        stack.push Types::Number.new(Types.to_number(left).number + Types.to_number(right).number)
+      end
+    end
+    
+    def sub(arg)
+      right = Types.to_number(stack.pop).number
+      left = Types.to_number(stack.pop).number
+      stack.push Types::Number.new(left - right)
+    end
+    
+    def mul(arg)
+      right = Types.to_number(stack.pop).number
+      left = Types.to_number(stack.pop).number
+      stack.push Types::Number.new(left * right)
+    end
+    
+    def div(arg)
+      right = Types.to_number(stack.pop).number
+      left = Types.to_number(stack.pop).number
+      stack.push Types::Number.new(left / right.to_f)
+    end
+    
+    def mod(arg)
+      right = Types.to_number(stack.pop).number
+      left = Types.to_number(stack.pop).number
+      stack.push Types::Number.new(left % right)
+    end
+    
+    def and(arg)
+      right = Types.to_int32 stack.pop
+      left = Types.to_int32 stack.pop
+      stack.push Types::Number.new(left & right)
+    end
+    
+    def or(arg)
+      right = Types.to_int32 stack.pop
+      left = Types.to_int32 stack.pop
+      stack.push Types::Number.new(left | right)
+    end
+    
+    def xor(arg)
+      right = Types.to_int32 stack.pop
+      left = Types.to_int32 stack.pop
+      stack.push Types::Number.new(left ^ right)
+    end
+    
+    def setindex(arg)
+      val = stack.pop
+      index = Types.to_string(stack.pop).string
+      Types.to_object(stack.pop).put index, val
+      stack.push val
+    end
+    
+    def lt(arg)
+      comparison_oper :<
+    end
+    
+    def lte(arg)
+      comparison_oper :<=
+    end
+    
+    def gt(arg)
+      comparison_oper :>
+    end
+    
+    def gte(arg)
+      comparison_oper :>=
+    end
+    
+    def typeof(arg)
+      if arg
+        stack.push Types::String.new(scope.has_var(arg) ? scope.get_var(arg).typeof : "undefined")
+      else
+        stack.push Types::String.new(stack.pop.typeof)
+      end
+    end
+    
+    def instanceof(arg)
+      r = stack.pop
+      l = stack.pop
+      stack.push Types::Boolean.new(r.has_instance l)
+    end
+    
+    def close(arg)
+      name = vm.bytecode[arg].select { |ins,arg| ins == :".name" }.map { |ins,arg| arg }.first
+      arguments = vm.bytecode[arg].select { |ins,arg| ins == :".arg" }.map(&:last).map(&:to_s)
+      scope = @scope
+      fun = Types::Function.new(->(outer_scope, this, args) { VM::Frame.new(vm, arg, fun).execute(scope.close, this, args) }, "...", name || "", arguments)
+      stack.push fun
+    end
+    
+    def callee(arg)
+      stack.push @callee
+    end
+    
+    def object(arg)
+      obj = Types::Object.new
+      kvs = []
+      arg.reverse_each { |a| kvs << [a, stack.pop] }
+      kvs.reverse_each { |kv| obj.put kv[0].to_s, kv[1] }
+      stack.push obj
+    end
+    
+    def negate(arg)
+      n = Types.to_number(stack.pop).number
+      if n.zero?
+        stack.push Types::Number.new(-n.to_f) # to preserve javascript's 0/-0 semantics
+      else
+        stack.push Types::Number.new(-n)
+      end
+    end
+    
+    def with(arg)
+      @scope = ObjectScope.new stack.pop, @scope
+    end
+    
+    def popscope(arg)
+      @scope = @scope.parent
+    end
+    
+    def pushsp(arg)
+      sp_stack.push stack.size
+    end
+    
+    def popsp(arg)
+      @stack = stack[0...sp_stack.pop]
+    end
+    
+    def pushcatch(arg)
+      catch_stack.push arg
+    end
+    
+    def popcatch(arg)
+      catch_stack.pop
+    end
+    
+    def pushfinally(arg)
+      finally_stack.push arg
+    end
+    
+    def popfinally(arg)
+      finally_stack.pop
+    end
+    
+    def this(arg)
+      stack.push @this
+    end
+    
+  private
+    def comparison_oper(op)
+      right = Types.to_primitive stack.pop
+      left = Types.to_primitive stack.pop
+      
+      if left.is_a?(Types::String) && right.is_a?(Types::String)
+        stack.push Types::Boolean.new(left.string.send op, right.string)
+      else
+        stack.push Types::Boolean.new(Types.to_number(left).number.send op, Types.to_number(right).number)
+      end
+    end
+  
+    def error!(msg)
+      vm.send :error!, "#{msg} (at #{@section}+#{@ip - 1})"
+    end
+  end
+end

data/lib/twostroke/runtime.rb

@@ -1,7 +1,8 @@
-module Twostroke
-  module Runtime
-    Dir.glob File.expand_path("../runtime/*", __FILE__) do |f|
-      require f
-    end
+module Twostroke::Runtime
+  class RuntimeError < Twostroke::Error
+  end
+  
+  Dir.glob File.expand_path("../runtime/*.rb", __FILE__) do |f|
+    require f
   end
 end

data/lib/twostroke/tokens.rb

@@ -1,33 +1,45 @@
 module Twostroke
   class Lexer
-    RESERVED = %w(function var if instanceof in else for while do this return throw typeof try catch finally void null new delete switch case break)
+    RESERVED = %w(
+      function var if instanceof in else for while do this return
+        throw typeof try catch finally void null new delete switch
+        case break continue default true false with)
     TOKENS = [
 
       [ :MULTI_COMMENT, %r{/\*.*?\*/} ],
       [ :SINGLE_COMMENT, /\/\/.*?$/ ],
 
       [ :WHITESPACE, /\s+/ ],
-      [ :NUMBER, /((?<oct>0[0-7]+)|(?<hex>0x[A-Fa-f0-9]+)|(?<to_f>(\d+(\.?\d*([eE][+-]?\d+)?)?|\.\d+([eE][+-]?\d+)?)))/, ->m { m[0].send m.names.first } ],
+      [ :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
+        if (n % 1).zero?
+          n.to_i
+        else
+          n
+        end
+      end ],
 
       *RESERVED.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] } ],
 
-      [ :STRING, /(["'])((\\.|[^\1])*?[^\1\\]?)\1/, ->m do
-        m[2].gsub(/\\([bfnrt])/) { |m|
+      [ :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]
           end
         }
-        .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[1] }
       end ],
       
       [ :REGEXP, %r{/(?<src>(\\.|[^\1])*?[^\1\\]?)/(?<opts>[gim]+)?}, ->m { [m[:src], m[:opts]] } ],

data/lib/twostroke.rb

@@ -2,4 +2,6 @@ require "twostroke/error"
 require "twostroke/tokens"
 require "twostroke/lexer"
 require "twostroke/parser"
-require "twostroke/ast"
+require "twostroke/ast"
+require "twostroke/compiler"
+require "twostroke/runtime"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twostroke
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-15 00:00:00.000000000Z
+date: 2011-11-09 00:00:00.000000000 Z
 dependencies: []
-description: An implementation of Javascript written in pure Ruby. This project currently
-  includes a WIP parser, and will include a runtime.
+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
+  standard library.
 email:
 - charlie@charliesomerville.com
 executables: []
@@ -26,9 +27,11 @@ files:
 - lib/twostroke/ast/break.rb
 - lib/twostroke/ast/call.rb
 - 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
 - lib/twostroke/ast/for_loop.rb
 - lib/twostroke/ast/function.rb
@@ -47,22 +50,53 @@ files:
 - lib/twostroke/ast/ternary.rb
 - lib/twostroke/ast/this.rb
 - lib/twostroke/ast/throw.rb
+- 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
 - lib/twostroke/ast.rb
+- lib/twostroke/compiler/javascript.rb
+- lib/twostroke/compiler/tsasm.rb
+- lib/twostroke/compiler.rb
 - lib/twostroke/error.rb
 - lib/twostroke/lexer.rb
 - lib/twostroke/parser.rb
-- lib/twostroke/runtime/context.rb
-- lib/twostroke/runtime/environment.rb
-- lib/twostroke/runtime/types/basic_type.rb
+- lib/twostroke/runtime/lib/array.js
+- lib/twostroke/runtime/lib/array.rb
+- lib/twostroke/runtime/lib/boolean.rb
+- 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/function.rb
+- lib/twostroke/runtime/lib/math.rb
+- lib/twostroke/runtime/lib/number.rb
+- lib/twostroke/runtime/lib/object.js
+- lib/twostroke/runtime/lib/object.rb
+- lib/twostroke/runtime/lib/regexp.rb
+- lib/twostroke/runtime/lib/string.rb
+- lib/twostroke/runtime/lib/undefined.rb
+- lib/twostroke/runtime/lib.rb
+- lib/twostroke/runtime/scope.rb
+- lib/twostroke/runtime/types/array.rb
+- lib/twostroke/runtime/types/boolean.rb
+- lib/twostroke/runtime/types/boolean_object.rb
+- lib/twostroke/runtime/types/function.rb
 - lib/twostroke/runtime/types/null.rb
+- lib/twostroke/runtime/types/number.rb
+- lib/twostroke/runtime/types/number_object.rb
 - lib/twostroke/runtime/types/object.rb
+- lib/twostroke/runtime/types/regexp.rb
+- lib/twostroke/runtime/types/string.rb
+- lib/twostroke/runtime/types/string_object.rb
 - lib/twostroke/runtime/types/undefined.rb
+- lib/twostroke/runtime/types/value.rb
 - lib/twostroke/runtime/types.rb
+- lib/twostroke/runtime/vm.rb
+- lib/twostroke/runtime/vm_frame.rb
 - lib/twostroke/runtime.rb
 - lib/twostroke/tokens.rb
 - lib/twostroke.rb

data/lib/twostroke/runtime/context.rb

@@ -1,33 +0,0 @@
-module Twostroke::Runtime
-  class Context
-    attr_accessor :variables, :parent
-    
-    def initialize
-      variables = {}
-    end
-    
-    def [](var)
-      if variables.key? var
-        variables[var]
-      elsif parent
-        parent[var]
-      else
-        raise "ReferenceError" # TODO
-      end
-    end
-    
-    def []=(var, val)
-      if variables.key?(var) || parent.nil?
-        variables[var] = val
-      else
-        parent[var] = val
-      end
-    end
-    
-    def create_context
-      context = Context.new
-      context.parent = self
-      context
-    end
-  end
-end

data/lib/twostroke/runtime/environment.rb

@@ -1,13 +0,0 @@
-module Twostroke::Runtime
-  class Environment
-    attr_accessor :root_context, :root_object
-    
-    def initialize(root_name)
-      @root_object = Types::Object.new
-      @root_context = Context.new
-      @root_contect.variables = @root_object
-      
-      
-    end
-  end
-end

data/lib/twostroke/runtime/types/basic_type.rb

@@ -1,5 +0,0 @@
-module Twostroke::Runtime::Types
-  class BasicType
-    #
-  end
-end