twostroke 0.0.4 → 0.1.0

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

@@ -1,33 +1,182 @@
 module Twostroke::Runtime::Types
-  class Object < BasicType
-    attr_accessor :properties, :accessor_properties
-    
-    def initialize(env)
+  class Object < Value
+    attr_accessor :_class, :prototype
+    attr_reader :accessors, :properties, :extensible, :data
+    private :accessors, :properties
+
+    def initialize
+      @extensible = true
       @properties = {}
-      @accessor_properties = {}
-      properties["__proto__"]
+      @accessors = {}
+      @prototype ||= defined?(@@_prototype) ? @@_prototype : Null.new
+      @_class = self.class.constructor_function if !defined?(@_class) && self.class.respond_to?(:constructor_function)
+      @data = {} # for abitrary data not safe to store as a property
+      proto_put "constructor", @_class
+    end
+    
+    def _class=(c)
+      proto_put "constructor", (@_class = c)
+    end
+    
+    def self.set_global_prototype(proto)
+      @@_prototype = proto
+    end
+    
+    def typeof
+      "object"
+    end
+    
+    def constructing?
+      @constructing
+    end
+    
+    # this allows us to treat the object like a generic array.
+    # the value of this method is not memoized, so call sparingly
+    def generic_items
+      return items if respond_to? :items
+      len = Twostroke::Runtime::Types.to_number(get "length").number
+      return [] if (len.is_a?(Float) && (len.nan? || len.infinite?)) || len < 0
+      len = len.to_i
+      (0...len).map { |i| get i.to_s }
+    end
+    
+    def construct(opts = {})
+      @constructing = true
+      opts.each do |k,v|
+        if respond_to? "#{k}="
+          send "#{k}=", v
+        else
+          instance_variable_set "@#{k}", v
+        end
+      end
+      yield
+      @constructing = false
+    end
+    
+    def get(prop, this = self)
+      if accessors.has_key? prop
+        accessors[prop][:get].(this)
+      elsif properties.has_key? prop
+        properties[prop]
+      else
+        prototype && prototype.is_a?(Object) ? prototype.get(prop, this) : Undefined.new
+      end
+    end
+    
+    def get_own_property(prop)
+      if accessors.has_key? prop
+        accessors[prop][:get] ? accessors[prop][:get].(this) : Undefined.new
+      elsif properties.has_key? prop
+        properties[prop]
+      else
+        Undefined.new
+      end
+    end
+    
+    def get_property(prop)
+      # @TODO?
     end
     
-    def [](key)
-      if accessor_properties.key? key
-        accessor_properties[key].get self
-      elsif properties.key? key
-        properties[key]
-      elsif properties.key? "__proto__"
-        properties["__proto__"][key]
+    def each_enumerable_property(&bk)
+      accessors.select { |k,v| v[:enumerable] }.each { |k,v| yield k }
+      properties.reject { |k,v| accessors[k] }.each { |k,v| yield k }
+      if prototype && prototype.is_a?(Object)
+        prototype.each_enumerable_property &bk
+      end
+    end
+    
+    def put(prop, value, this = self)
+      if accessors.has_key? prop
+        accessors[prop][:set].(this, value) if accessors[prop][:set] && accessors[prop][:writable]
+      elsif properties.has_key? prop
+        properties[prop] = value
+      #elsif prototype && prototype.is_a?(Object) && prototype.has_accessor(prop)
+      #  prototype.put prop, value, this
+      else
+        properties[prop] = value
+      end
+    end
+    
+    # puts prop as a non-enumerable property
+    def proto_put(prop, value)
+      define_own_property prop, value: value, enumerable: false
+    end
+    
+    def can_put(prop)
+      extensible && (!accessors.has_key?(prop) || accessors[prop][:configurable])
+    end
+    
+    def has_property(prop)
+      accessors.has_key?(prop) || properties.has_key?(prop) || (prototype && prototype.is_a?(Object) && prototype.has_property(prop))
+    end
+    
+    def has_accessor(prop)
+      accessors.has_key?(prop)
+    end
+    
+    def has_own_property(prop)
+      accessors.has_key?(prop) || properties.has_key?(prop)
+    end
+    
+    def delete(prop)
+      if accessors.has_key? prop
+        accessors.delete prop if accessors[prop][:configurable]
+      elsif prop != "prototype"
+        properties.delete prop
+      end
+    end
+    
+    def delete!(prop)
+      if accessors.has_key? prop
+        accessors.delete prop if accessors[prop][:configurable]
       else
-        Undefined.undefined
+        properties.delete prop
+      end
+    end
+    
+    def default_value(hint = nil)      
+      if hint.nil?
+        # @TODO
+        # hint = is_a?(Date) ? "String" : "Number"
+        hint = "Number"
+      end
+      
+      if hint == "String"
+        toString = get "toString"
+        if toString.respond_to? :call
+          str = toString.call(nil, self, [])
+          return str if str.is_a? Primitive
+        end
+        valueOf = get "valueOf"
+        if valueOf.respond_to? :call
+          val = valueOf.call(nil, self, [])
+          return val if val.is_a? Primitive
+        end
+        Twostroke::Runtime::Lib.throw_type_error "could not convert object to string"
+      elsif hint == "Number"
+        valueOf = get "valueOf"
+        if valueOf.respond_to? :call
+          val = valueOf.call(nil, self, [])
+          return val if val.is_a? Primitive
+        end
+        toString = get "toString"
+        if toString.respond_to? :call
+          str = toString.call(nil, self, [])
+          return str if str.is_a? Primitive
+        end
+        Twostroke::Runtime::Lib.throw_type_error "could not convert object to string"
       end
     end
     
-    def []=(key, val)
-      if accessor_properties.key? key
-        accessor_properties[key].get self
-      elsif properties.key? key
-        properties[key]
+    def define_own_property(prop, descriptor)
+      unless descriptor.has_key?(:get) || descriptor.has_key?(:set)
+        descriptor[:get] = ->(this) { descriptor[:value] }
+        descriptor[:set] = ->(this, value) { descriptor[:value] = value }
+        descriptor[:value] ||= Undefined.new
       else
-        Undefined.undefined
+        descriptor[:writable] = true if descriptor.has_key?(:set)
       end
+      accessors[prop] = descriptor
     end
   end
 end

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

@@ -0,0 +1,31 @@
+module Twostroke::Runtime::Types
+  class RegExp < Object
+    def self.constructor_function
+      @@constructor_function ||=
+        Function.new(->(scope, this, args) {
+          RegExp.new Twostroke::Runtime::Types.to_string(args[0] || Undefined.new).string, args[1] && Twostroke::Runtime::Types.to_string(args[1]).string
+        }, nil, "RegExp", [])
+    end
+    
+    attr_reader :regexp
+    attr_reader :global
+    def initialize(regexp_source, options)
+      opts = 0
+      (options ||= "").each_char do |opt|
+        opts |= case opt
+        when "m"; Regexp::MULTILINE
+        when "i"; Regexp::IGNORECASE
+        else; 0
+        end
+      end
+      @regexp = Regexp.new regexp_source, opts
+      @global = options.include? "g"
+      @prototype = RegExp.constructor_function.get("prototype")
+      super()
+    end
+    
+    def primitive_value
+      String.new(regexp.inspect + (@global ? "g" : ""))
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Twostroke::Runtime::Types
+  class String < Primitive
+    attr_reader :string
+    def initialize(string)
+      @string = string
+    end
+    
+    def ===(other)
+      other.is_a?(String) && string == other.string
+    end
+    
+    def typeof
+      "string"
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Twostroke::Runtime
+  module Types
+    class StringObject < Object
+      def self.constructor_function
+        @@constructor_function ||=
+          Function.new(->(scope, this, args) { this.constructing? ? Types.to_object(Types.to_string(args[0] || Undefined.new)) : Types.to_string(args[0]) }, nil, "String", [])
+      end
+    
+      attr_reader :string
+      def initialize(string)
+        @prototype = StringObject.constructor_function.get("prototype")
+        @string = string
+        super()
+      end
+    
+      def primitive_value
+        String.new string
+      end
+      
+      def get(prop, this = self)
+        if prop =~ /\A\d+\z/
+          String.new string[prop.to_i]
+        else
+          super prop, this
+        end
+      end
+      
+      def has_property(prop)
+        if prop =~ /\A\d+\z/
+          i = prop.to_i
+          i >= 0 && i < string.size
+        else
+          super prop
+        end
+      end
+      
+      def has_own_property(prop)
+        if prop =~ /\A\d+\z/
+          i = prop.to_i
+          i >= 0 && i < string.size
+        else
+          super prop
+        end
+      end
+      
+      def each_enumerable_property(&bk)
+        (0...string.length).map(&:to_s).each &bk
+        super &bk
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,14 @@
+module Twostroke::Runtime::Types
+  class Value
+    def typeof
+      "VALUE"
+    end
+    
+    def has_instance(obj)
+      Twostroke::Runtime::Lib.throw_type_error "Expected a function in instanceof check"
+    end
+  end
+  
+  class Primitive < Value
+  end
+end

data/lib/twostroke/runtime/types.rb

@@ -1,7 +1,136 @@
-module Twostroke::Runtime
-  module Types
-    Dir.glob File.expand_path("../types/*", __FILE__) do |f|
-      require f
+module Twostroke::Runtime::Types
+  def self.to_primitive(object, preferred_type = nil)
+    if object.is_a? Primitive
+      object
+    else
+      object.default_value preferred_type
     end
   end
+  
+  def self.to_boolean(object)
+    b = if object.is_a?(Boolean)
+        object.boolean
+      elsif object.is_a?(Undefined) || object.is_a?(Null)
+        false
+      elsif object.is_a?(Number)
+        !object.zero? && !object.nan?
+      elsif object.is_a?(String)
+        object.string != ""
+      else
+        true
+      end
+    Boolean.new b
+  end
+  
+  def self.to_number(object)
+    if object.is_a?(Undefined)
+      Number.new Float::NAN
+    elsif object.is_a?(Null)
+      Number.new 0
+    elsif object.is_a?(Boolean)
+      Number.new(object.boolean ? 1 : 0)
+    elsif object.is_a?(Number)
+      object
+    elsif object.is_a?(String)
+      Number.new(Float(object.string)) rescue Number.new(Float::NAN)
+    else # object is Object
+      to_number to_primitive(object)
+    end
+  end
+  
+  def self.to_int32(object)
+    num = to_number object
+    if num.nan? || num.infinite?
+      0
+    else
+      int32 = num.number.to_i & 0xffff_ffff
+      int32 -= 2 ** 31 if int32 >= 2 ** 31
+      int32
+    end
+  end
+  
+  def self.to_uint32(object)
+    num = to_number object
+    if num.nan? || num.infinite?
+      0
+    else
+      num.number.to_i & 0xffff_ffff
+    end
+  end
+  
+  def self.to_string(object)
+    if object.is_a?(Undefined)
+      String.new "undefined"
+    elsif object.is_a?(Null)
+      String.new "null"
+    elsif object.is_a?(Boolean)
+      String.new object.boolean.to_s
+    elsif object.is_a?(Number)
+      String.new object.number.to_s
+    elsif object.is_a?(String)
+      object
+    else
+      to_string to_primitive(object)
+    end
+  end
+  
+  def self.to_object(object)
+    if object.is_a?(Undefined) || object.is_a?(Null)
+      Twostroke::Runtime::Lib.throw_type_error "cannot convert null or undefined to object"
+    elsif object.is_a?(Boolean)
+      BooleanObject.new object.boolean
+    elsif object.is_a?(Number)
+      NumberObject.new object.number
+    elsif object.is_a?(String)
+      StringObject.new object.string
+    else
+      object
+    end
+  end
+  
+  def self.is_falsy(object)
+    !is_truthy(object)
+  end
+  
+  def self.is_truthy(object)
+    to_boolean(object).boolean
+  end
+  
+  def self.eq(a, b)
+    if a.class == b.class
+      a === b
+    elsif a.is_a?(Null) && b.is_a?(Undefined)
+      true
+    elsif a.is_a?(Undefined) && b.is_a?(Null)
+      true
+    elsif a.is_a?(Number) && b.is_a?(String)
+      eq(a, to_number(b))
+    elsif a.is_a?(String) && b.is_a?(Number)
+      eq(to_number(a), b)
+    elsif a.is_a?(Boolean)
+      eq(to_number(a), b)
+    elsif b.is_a?(Boolean)
+      eq(a, to_number(b))
+    elsif (a.is_a?(String) || b.is_a?(Number)) && b.is_a?(Object)
+      eq(a, to_primitive(b))
+    elsif a.is_a?(Object) && (b.is_a?(String) || b.is_a?(Number))
+      eq(to_primitive(a), b)
+    else
+      false
+    end
+  end
+  
+  def self.seq(a, b)
+    if a.class == b.class
+      a === b
+    else
+      false
+    end
+  end
+  
+  require File.expand_path("../types/value.rb", __FILE__)
+  require File.expand_path("../types/object.rb", __FILE__)
+  Dir.glob(File.expand_path("../types/*", __FILE__)).each do |f|
+    require f
+  end
 end

data/lib/twostroke/runtime/vm.rb

@@ -0,0 +1,25 @@
+module Twostroke::Runtime
+  class VM    
+    attr_accessor :bytecode
+    attr_reader :global_scope, :lib
+    
+    def initialize(bytecode)
+      @bytecode = bytecode
+      @global_scope = GlobalScope.new self
+      @lib = {}
+    end
+    
+    def execute(section = :main, scope = nil)
+      Frame.new(self, section).execute scope      
+    end
+    
+    def throw_error(type, message)
+      throw :exception, lib[type].(nil, global_scope.root_object, [Types::String.new(message)])
+    end
+  
+  private
+    def error!(msg)
+      raise RuntimeError, msg
+    end
+  end
+end