twostroke 0.0.4 → 0.1.0

data/lib/twostroke/runtime/lib/object.rb

@@ -0,0 +1,55 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    proto = Types::Object.new
+  
+    obj = Types::Function.new(->(scope, this, args) {
+        if args.length.zero? || args[0].is_a?(Types::Null) || args[0].is_a?(Types::Undefined)
+          Types::Object.new
+        else
+          Types.to_object(args[0])
+        end
+      }, nil, "Object", [])
+    #obj.prototype is Function, lets set its prototype to proto
+    obj.prototype.prototype = proto
+    obj.proto_put "prototype", proto
+    scope.set_var "Object", obj
+    
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+      if this.is_a? Types::Primitive
+        Types.to_string(this).string
+      else
+        Types::String.new "[object #{this._class ? this._class.name : "Object"}]"
+      end
+    }, nil, "toString", [])
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) { this }, nil, "valueOf", [])
+    proto.proto_put "hasOwnProperty", Types::Function.new(->(scope, this, args) {
+      Types::Boolean.new Types.to_object(this || Types::Undefined.new).has_own_property(Types.to_string(args[0] || Types::Undefined.new).string)
+    }, nil, "hasOwnProperty", [])
+    proto.proto_put "isPrototypeOf", Types::Function.new(->(scope, this, args) {
+      if args[0].is_a? Types::Object
+        proto = args[0].prototype
+        this = Types.to_object(this || Types::Undefined.new)
+        while proto.is_a?(Types::Object)
+          return Types::Boolean.new(true) if this == proto
+          proto = proto.prototype
+        end
+      end
+      Types::Boolean.new false
+    }, nil, "isPrototypeOf", [])
+    proto.proto_put "propertyIsEnumerable", Types::Function.new(->(scope, this, args) {
+      this = Types.to_object(this || Types::Undefined.new)
+      prop = Types.to_string(args[0] || Types::Undefined.new).string
+      if this.has_accessor(prop)
+        Types::Boolean.new this.accessors[prop][:enumerable]
+      elsif this.has_property
+        Types::Boolean.new true
+      else
+        Types::Boolean.new false
+      end
+    }, nil, "propertyIsEnumerable", [])
+    
+    Types::Object.set_global_prototype proto
+    Types::Object.define_singleton_method(:constructor_function) { obj }
+    scope.global_scope.root_object.prototype = proto
+  end
+end

data/lib/twostroke/runtime/lib/regexp.rb

@@ -0,0 +1,28 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    regexp = Types::RegExp.constructor_function
+    scope.set_var "RegExp", regexp
+    proto = Types::Object.new
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+        Lib.throw_type_error "RegExp.prototype.toString is not generic" unless this.is_a?(Types::RegExp)
+        this.primitive_value
+      }, nil, "toString", [])
+    proto.define_own_property "global", get: ->(this) {
+        Types::Boolean.new this.global
+      }, writable: false, enumerable: false, configurable: false
+    proto.define_own_property "ignoreCase", get: ->(this) {
+        Types::Boolean.new((this.regexp.options & Regexp::IGNORECASE) != 0)
+      }, writable: false, enumerable: false, configurable: false
+    proto.define_own_property "multiline", get: ->(this) {
+        Types::Boolean.new((this.regexp.options & Regexp::MULTILINE) != 0)
+      }, writable: false, enumerable: false, configurable: false
+    proto.define_own_property "source", get: ->(this) {
+        Types::String.new this.regexp.source
+      }, writable: false, enumerable: false, configurable: false
+    proto.proto_put "test", Types::Function.new(->(scope, this, args) {
+        Lib.throw_type_error "RegExp.prototype.test is not generic" unless this.is_a?(Types::RegExp)
+        Types::Boolean.new((Types.to_string(args[0] || Undefined.new).string =~ this.regexp) != nil)
+      }, nil, "test", [])
+    regexp.proto_put "prototype", proto
+  end
+end

data/lib/twostroke/runtime/lib/string.rb

@@ -0,0 +1,86 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    obj = Types::StringObject.constructor_function
+    scope.set_var "String", obj
+    
+    proto = Types::Object.new
+    # String.prototype.toString
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+        if this.is_a?(Types::StringObject)
+          Types::String.new(this.string)
+        else
+          Lib.throw_type_error "String.prototype.toString is not generic"
+        end
+      }, nil, "toString", [])
+    # String.prototype.valueOf
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) { this.is_a?(Types::StringObject) ? Types::String.new(this.string) : Types.to_primitive(this) }, nil, "valueOf", [])
+    # String.prototype.split
+    proto.proto_put "split", Types::Function.new(->(scope, this, args) {
+        sep = Types.to_string(args[0] || Types::Undefined.new).string
+        str = Types.to_string(this).string
+        Types::Array.new (if args[1]
+            str.split sep, Types.to_uint32(args[1])
+          else
+            str.split sep
+          end).map { |s| Types::String.new s }
+      }, nil, "split", [])
+    # String.prototype.length
+    proto.define_own_property "length", get: ->(this) { Types::Number.new this.string.size }, writable: false, enumerable: false
+    # String.prototype.replace
+    proto.proto_put "replace", Types::Function.new(->(scope, this, args) {
+        sobj = Types.to_string(this)
+        s = sobj.string
+        
+        find = args[0] || Types::Undefined.new
+        re = find.is_a?(Types::RegExp) ? find.regexp : Regexp.new(Regexp.escape Types.to_string(find).string)
+        global = find.is_a?(Types::RegExp) && find.global
+        
+        replace = args[1] || Types::Undefined.new
+        callback = replace.respond_to?(:call) ? replace : ->(*_) { replace }
+        
+        retn = ""
+        offset = 0
+        loop do
+          md = re.match s, offset
+          break unless md && (offset.zero? || global)
+          retn << md.pre_match[offset..-1]
+          retn << Types.to_string(callback.(scope, nil, [*md.to_a.map { |c| Types::String.new c }, Types::Number.new(md.begin 0), sobj])).string
+          offset = md.end 0
+        end
+        
+        retn << s[offset..-1]
+
+        Types::String.new retn
+      }, nil, "replace", [])
+=begin
+        find = args[0] || Types::Undefined.new
+        find = Types.to_string(find).string unless find.is_a?(Types::RegExp)
+        replace = args[1] || Types::Undefined.new
+        replace = Types.to_string(replace).string unless replace.respond_to? :call        
+        Types::String.new(if find.is_a?(String)
+          if replace.is_a?(String)
+            s.sub find, replace
+          else
+            s.sub(find) { |m| Types.to_string(replace.call(scope, nil, [Types::String.new(m), Types::Number.new(s.index m), sobj])).string }
+          end
+        else
+          m = s.method(find.global ? :gsub : :sub)
+          if replace.is_a?(String)
+            m.(find.regexp, replace)
+          else
+            offset = 0
+            m.(find.regexp) do |m|
+              idx = s.index m, offset
+              offset = idx + m.size
+              Types.to_string(replace.call(scope, nil, [Types::String.new(m), Types::Number.new(idx), sobj])).string
+            end
+          end
+        end)
+=end
+    obj.proto_put "prototype", proto
+    
+    obj.proto_put "fromCharCode", Types::Function.new(->(scope, this, args) {
+        Types::String.new args.map { |a| Types.to_number(a).number.to_i.chr }.join
+      }, nil, "fromCharCode", [])
+  end
+end

data/lib/twostroke/runtime/lib/undefined.rb

@@ -0,0 +1,7 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    scope.set_var "undefined", Types::Undefined.new
+    
+    scope.set_var "crap", Types::Function.new(->(scope,this,args) { require "pry"; pry binding }, nil, "crap", [])
+  end
+end

data/lib/twostroke/runtime/lib.rb

@@ -0,0 +1,42 @@
+module Twostroke::Runtime
+  module Lib
+    INITIALIZERS = []
+  
+    def self.setup_environment(vm)
+      INITIALIZERS.each { |i| i.arity == 1 ? i.(vm.global_scope) : i.(vm.global_scope, vm) }
+    end
+  
+    def self.register(&bk)
+      INITIALIZERS << bk
+    end
+  
+    require File.expand_path("../lib/object.rb", __FILE__)
+    Dir.glob File.expand_path("../lib/*.rb", __FILE__) do |f|
+      require f
+    end
+  
+    class << self    
+      Dir.glob File.expand_path("../lib/*.js", __FILE__) do |f|      
+        INITIALIZERS << ->(global_scope, vm) {
+          privileged_scope = global_scope.close
+          privileged_scope.declare :twostroke_lib_set
+          privileged_scope.set_var :twostroke_lib_set, Types::Function.new(->(scope, this, args) {
+            vm.lib[Types.to_string(args[0] || Types::Undefined.new).string.intern] = args[1] || Types::Undefined.new
+          }, nil, "twostroke_lib_set", [])
+          
+          parser = Twostroke::Parser.new(Twostroke::Lexer.new(File.read f))
+          parser.parse
+
+          compiler = Twostroke::Compiler::TSASM.new parser.statements, "lib_#{f}_"
+          compiler.compile
+
+          compiler.bytecode.each do |k,v|
+            vm.bytecode[k] = v
+          end
+
+          vm.execute :"lib_#{f}_main", privileged_scope
+        }
+      end
+    end
+  end
+end

data/lib/twostroke/runtime/scope.rb

@@ -0,0 +1,120 @@
+module Twostroke::Runtime
+  class Scope
+    attr_reader :parent
+    
+    def initialize(parent = nil)
+      @locals = {}
+      @parent = parent
+    end
+    
+    def get_var(var)
+      if @locals.has_key? var
+        @locals[var]
+      else
+        @parent.get_var(var)
+      end
+    end
+    
+    def set_var(var, value)
+      if @locals.has_key? var
+        @locals[var] = value
+      else
+        @parent.set_var(var, value)
+      end
+    end
+    
+    def has_var(var)
+      @locals.has_key?(var) || parent.has_var(var)
+    end
+    
+    def declare(var)
+      @locals[var] = Types::Undefined.new
+    end
+    
+    def close
+      Scope.new self
+    end
+    
+    def global_scope
+      @global_scope ||= parent.global_scope
+    end
+  end
+  
+  class ObjectScope
+    attr_reader :object, :parent
+    
+    def initialize(object, parent)
+      @parent, @object = parent, object
+    end
+    
+    def get_var(var)
+      if object.has_property var.to_s
+        object.get var.to_s
+      else
+        parent.get_var var
+      end
+    end
+    
+    def set_var(var, value)
+      if object.has_property var.to_s
+        object.put var.to_s, value
+      else
+        parent.set_var var.to_s, value
+      end
+    end
+    
+    def has_var
+      object.has_property(var.to_s) || parent.has_var(var)
+    end
+    
+    def declare(var)
+      parent.declare var
+    end
+    
+    def close
+      Scope.new self
+    end
+    
+    def global_scope
+      @global_scope ||= parent.global_scope
+    end
+  end
+  
+  class GlobalScope
+    attr_reader :root_object, :root_name, :vm
+    
+    def initialize(vm, root_name = "window", root_object = nil)
+      @root_name = root_name
+      @root_object = root_object || Types::Object.new
+      @root_object.put root_name.to_s, @root_object
+      @vm = vm
+    end
+    
+    def get_var(var)
+      if @root_object.has_property var.to_s
+        @root_object.get var.to_s
+      else
+        Lib.throw_reference_error "undefined variable #{var}"
+      end
+    end
+    
+    def has_var(var)
+      @root_object.has_property var.to_s
+    end
+    
+    def declare(var)
+    end
+    
+    def close
+      Scope.new self
+    end
+    
+    def set_var(var, value)
+      @root_object.put var.to_s, value
+    end
+    
+    def global_scope
+      self
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Twostroke::Runtime
+  module Types
+    class Array < Object
+      def self.constructor_function
+        @@constructor_function ||=
+          Function.new(->(scope, this, args) do
+              if args.length.zero?
+                Array.new
+              elsif args.length == 1
+                Array.new([nil] * Twostroke::Runtime::Types.to_uint32(args[0]))
+              else
+                Array.new args
+              end
+            end, nil, "Array", [])
+      end
+    
+      attr_accessor :items
+      def initialize(items = [])
+        @prototype = Array.constructor_function.get("prototype")
+        super()
+        @items = items
+      end
+      
+      def length
+        items.size
+      end
+      
+      def get(prop, this = self)
+        if prop =~ /\A\d+\z/
+          items[prop.to_i] || Undefined.new
+        else
+          super prop, this
+        end
+      end
+      
+      def put(prop, val, this = self)
+        if prop =~ /\A\d+\z/
+          items[prop.to_i] = val
+        else
+          super prop, val, this
+        end
+      end
+      
+      def has_property(prop)
+        if prop =~ /\A\d+\z/
+          i = prop.to_i
+          i >= 0 && i < items.size && !items[i].nil?
+        else
+          super prop
+        end
+      end
+      
+      def has_own_property(prop)
+        if prop =~ /\A\d+\z/
+          i = prop.to_i
+          i >= 0 && i < items.size && !items[i].nil?
+        else
+          super prop
+        end
+      end
+      
+      def delete(prop)
+        if prop =~ /\A\d+\z/
+          i = prop.to_i
+          if i >= 0 && i < items.size && !items[i].nil?
+            items[i] = nil
+            return true
+          end
+        end
+        super prop
+      end
+      
+      def each_enumerable_property(&bk)
+        (0...items.size).map(&:to_s).each &bk
+        super &bk
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Twostroke::Runtime::Types
+  class Boolean < Primitive
+    def self.true
+      @@true ||= Boolean.new(true)
+    end
+    def self.false
+      @@false ||= Null.new(false)
+    end
+  
+    attr_reader :boolean
+    def initialize(boolean)
+      @boolean = boolean
+    end
+    
+    def ===(other)
+      other.is_a?(Boolean) && boolean == other.boolean
+    end
+    
+    def typeof
+      "boolean"
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Twostroke::Runtime::Types
+  class BooleanObject < Object
+    def self.constructor_function
+      @@constructor_function ||=
+        Function.new(->(scope, this, args) { 
+          if this.constructing?
+            Twostroke::Runtime::Types.to_object(Twostroke::Runtime::Types.to_boolean(args[0] || Undefined.new))
+          else
+            Twostroke::Runtime::Types.to_boolean(args[0])
+          end
+        }, nil, "Boolean", [])
+    end
+    
+    attr_reader :boolean
+    def initialize(boolean)
+      @prototype = BooleanObject.constructor_function.get("prototype")
+      super()
+      @boolean = boolean
+    end
+    
+    def primitive_value
+      Boolean.new boolean
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Twostroke::Runtime::Types
+  class Function < Object
+    def self.constructor_function
+      unless defined?(@@constructor_function)
+        @@constructor_function = nil # lock the Function constructor out from here...
+        @@created_funcs = 0
+        @@constructor_function = Function.new(->(scope, this, args) {
+          formal_parameters = (args.size > 1 ? args[0...-1] : []).map { |a| Twostroke::Runtime::Types.to_string(a).string }
+          src = Twostroke::Runtime::Types.to_string(args[-1] || Undefined.new).string
+          
+          parser = Twostroke::Parser.new(Twostroke::Lexer.new(src))
+          parser.parse
+
+          @@created_funcs += 1
+          fun_ast = Twostroke::AST::Function.new name: "anonymous", arguments: formal_parameters, statements: parser.statements
+          compiler = Twostroke::Compiler::TSASM.new [fun_ast], "runtime_created_#{@@created_funcs}_"
+          compiler.compile
+          
+          vm = scope.global_scope.vm
+          compiler.bytecode.each do |k,v|
+            vm.bytecode[k] = v
+          end
+          
+          global_scope = vm.global_scope
+          fun = Function.new(->(_scope, _this, _args) {
+            Twostroke::Runtime::VM::Frame.new(vm, :"runtime_created_#{@@created_funcs}_fn_1", fun).execute(global_scope, _this, _args)
+          }, src, "anonymous", formal_parameters)
+        }, nil, "Function", [])
+        @@constructor_function.proto_put "constructor", @@constructor_function
+        @@constructor_function._class = @@constructor_function
+      end
+      @@constructor_function
+    end
+    
+    attr_reader :arguments, :name, :source, :function
+    def initialize(function, source, name, arguments)
+      @function = function
+      @source = source
+      @name = name
+      @arguments = arguments
+      # setting @_class to Function's constructor would result in a stack overflow,
+      # so we'll set it to nil and patch things up after @@constructor_function has
+      # been set
+      @_class = nil unless defined?(@@constructor_function)
+      super()
+      @prototype = nil
+      proto_put "prototype", Object.new
+    end
+    
+    def prototype
+      @prototype ||= Function.constructor_function.get("prototype")
+    end
+    
+    def has_instance(obj)
+      return false unless obj.is_a? Object
+      o = get "prototype"
+      Twostroke::Runtime::Lib.throw_type_error "Function prototype not an object" unless o.is_a? Object
+      loop do
+        obj = obj.prototype
+        return false unless obj.is_a?(Object)
+        return true if obj == o
+      end
+    end
+    
+    def typeof
+      "function"
+    end
+    
+    def primitive_value
+      String.new "function #{name}(#{arguments.join ","}) { #{source || "[native code]"} }"
+    end
+    
+    def call(upper_scope, this, args)
+      retn_val = function.(upper_scope, this || upper_scope.global_scope.root_object, args)
+      # prevent non-Value objects being returned to javascript
+      if retn_val.is_a? Value
+        retn_val
+      else
+        Undefined.new
+      end
+    end
+  end
+end

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

@@ -1,7 +1,15 @@
 module Twostroke::Runtime::Types
-  class Null < BasicType
-    def self.null
-      @@null ||= Null.new
+  class Null < Primitive
+    def self.new
+      @@null ||= Null.allocate
+    end
+    
+    def ===(other)
+      other.is_a?(Null)
+    end
+    
+    def typeof
+      "object"
     end
   end
 end

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

@@ -0,0 +1,31 @@
+module Twostroke::Runtime::Types
+  class Number < Primitive    
+    attr_reader :number
+    def initialize(number)
+      @number = number
+    end
+    
+    def ===(other)
+      if number.zero? && other.is_a?(Number) && other.number.zero?
+        # in javascript, -0 and 0 are not equal
+        # in ruby they are, and the only way to check if a number is -0 is with #to_s
+        # please correct me if there's a better way
+        number.to_s[0] == other.number.to_s[0]
+      else
+        other.is_a?(Number) && number == other.number
+      end
+    end
+    def typeof
+      "number"
+    end
+    def zero?
+      number.zero?
+    end
+    def nan?
+      number.is_a?(Float) && number.nan?
+    end
+    def infinite?
+      number.is_a?(Float) && number.infinite?
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Twostroke::Runtime::Types
+  class NumberObject < Object
+    def self.constructor_function
+      @@constructor_function ||=
+        Function.new(->(scope, this, args) {
+          if this.constructing?
+            Twostroke::Runtime::Types.to_object(Twostroke::Runtime::Types.to_number(args[0] || Undefined.new))
+          else
+            Twostroke::Runtime::Types.to_number(args[0])
+          end
+        }, nil, "Number", [])
+    end
+    
+    attr_reader :number
+    def initialize(number)
+      @number = number
+      @prototype = NumberObject.constructor_function.get("prototype")
+      super()
+    end
+    
+    def primitive_value
+      Number.new number
+    end
+  end
+end