twostroke 0.1.0 → 0.2.0

data/lib/twostroke/runtime/lib/array.js

@@ -21,13 +21,19 @@ Array.prototype.reverse = function() {
 	return this;
 };
 
-Array.prototype.concat = function(other) {
+Array.prototype.concat = function() {
 	var x = [];
 	Array.prototype.slice.call(this).forEach(function(el) {
 		x.push(el);
 	});
-	Array.prototype.slice.call(other).forEach(function(el) {
-		x.push(el);
+	Array.prototype.slice.call(arguments).forEach(function(obj) {
+	  if(obj instanceof Array) {
+	    obj.forEach(function(el) {
+	      x.push(el);
+	    });
+	  } else {
+	    x.push(obj);
+	  }
 	});
 	return x;
 };

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

@@ -50,6 +50,20 @@ module Twostroke::Runtime
         Types::Array.new this.generic_items[begin_index.number.to_i...end_index.number.to_i]
       end
     }, nil, "slice", [])
+    # Array.prototype.splice
+    proto.proto_put "splice", Types::Function.new(->(scope, this, args) {
+        Lib.throw_type_error "Array.prototype.splice is not generic" unless this.is_a? Types::Array
+        idx = Types.to_uint32(args[0] || Types::Undefined.new)
+        count = args[1] && Types.to_uint32(args[1])
+        if count and count >= 0
+          retn = this.items[idx...(idx + count)]
+          this.items[idx...(idx + count)] = args.drop(2)
+        else
+          retn = this.items[idx..-1]
+          this.items[idx..-1] = args.drop(2)
+        end
+        Types::Array.new retn
+      }, nil, "splice", [])
     # Array.prototype.sort
     proto.proto_put "sort", Types::Function.new(->(scope, this, args) {
       Lib.throw_type_error "Array.prototype.sort is not generic" unless this.is_a? Types::Array
@@ -59,13 +73,7 @@ module Twostroke::Runtime
       this
     }, nil, "sort", [])
     # Array.prototype.length
-    proto.define_own_property "length", get: ->(this) { Types::Number.new this.items.size }, set: ->(this,val) do
-        Lib.throw_type_error "Array.prototype.length is not generic" unless this.is_a? Types::Array
-        len = Types.to_number(val)
-        Lib.throw_range_error "invalid array length" if len.nan? || len.number < 0 || (len.number % 1) != 0
-        this.items = this.items[0...len.number.to_i]
-        len
-      end, writable: true
+    proto.define_own_property "length", get: ->(this) { Types::Number.new this.items.size }
     ary.proto_put "prototype", proto
   end
 end

data/lib/twostroke/runtime/lib/console.rb

@@ -1,12 +1,13 @@
 module Twostroke::Runtime
   Lib.register do |scope|    
-    log = Types::Function.new(->(scope, this, args) { puts args.map { |o| Types.to_string(o).string }.join(" ") }, nil, "log", ["string"])
+    log = Types::Function.new(->(scope, this, args) { print args.map { |o| Types.to_string(o).string }.join(" ") + "\n" }, nil, "log", ["string"])
   
     console = Types::Object.new
     ["log", "info", "warn", "error"].each do |m|
       console.proto_put m, log
     end
-    console.proto_put "_gets", Types::Function.new(->(scope, this, args) { Types::String.new gets }, nil, "_gets", [])
+    console.proto_put "_gets", Types::Function.new(->(scope, this, args) { Types::String.new STDIN.gets }, nil, "_gets", [])
+    console.proto_put "_readAll", Types::Function.new(->(scope, this, args) { Types::String.new STDIN.read }, nil, "_readAll", [])
     console.proto_put "_print", Types::Function.new(->(scope, this, args) { print args.map { |o| Types.to_string(o).string }.join(" ") }, nil, "_print", ["string"])
     scope.set_var "console", console
   end

data/lib/twostroke/runtime/lib/error.rb

@@ -12,7 +12,7 @@ module Twostroke::Runtime
     }, nil, "toString", [])
     error.proto_put "prototype", error.prototype
     
-    ["Eval", "Range", "Reference", "Syntax", "Type", "URI"].each do |e|
+    ["Eval", "Range", "Reference", "Syntax", "Type", "URI", "_Interrupt"].each do |e|
       obj = Types::Function.new(->(scope, this, args) {
         this.proto_put "name", Types::String.new("#{e}Error")
         this.proto_put "message", (args[0] || Types::Undefined.new)

data/lib/twostroke/runtime/lib/etc.js

@@ -0,0 +1,38 @@
+JSON = {
+  stringify: function(obj) {
+    switch(typeof obj) {
+      case "string":
+        return '"' + obj.replace(/["\\]/g, function(x) { return "\\" + x; }).replace(/[\x00-\x1F]/g, function(x) {
+            var s = x.charCodeAt(0).toString(16);
+            while(s.length < 4) s = "0" + s;
+            return "\\u" + s;
+          }) + '"';
+      case "number":
+      case "boolean":
+        return obj.toString();
+      case "undefined":
+        return "null";
+      case "object":
+        if(obj === null) {
+          return "null";
+        } else if(obj instanceof Array) {
+          return "[" + obj.map(function(x) { return JSON.stringify(x); }).filter(function(o) { return o !== undefined; }).join(",") + "]";
+        } else {
+          var keys = [];
+          for(var k in obj) {
+            if(obj.hasOwnProperty(k)) {
+              keys.push(k);
+            }
+          }
+          return "{" + keys.map(function(k) {
+              var v = JSON.stringify(obj[k]);
+              if(v) {
+                return '"' + k + '":' + JSON.stringify(obj[k]);
+              }
+            }).filter(function(o) { return o !== undefined; }).join(",") + "}";
+        }
+      default:
+        return undefined;
+    }
+  }
+};

data/lib/twostroke/runtime/lib/etc.rb

@@ -0,0 +1,29 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    evaled = 0
+    eval = Types::Function.new(->(_scope, this, args) {      
+        src = Types.to_string(args[0] || Types::Undefined.new).string + ";"
+        
+        begin
+          parser = Twostroke::Parser.new Twostroke::Lexer.new src
+          parser.parse
+
+          evaled += 1
+          compiler = Twostroke::Compiler::TSASM.new parser.statements, "evaled_#{evaled}_"
+          compiler.compile
+        rescue Twostroke::SyntaxError => e
+          Lib.throw_syntax_error e.to_s
+        end
+        
+        vm = scope.global_scope.vm
+        compiler.bytecode.each do |k,v|
+          vm.bytecode[k] = v
+        end
+        
+        vm.bytecode[:"evaled_#{evaled}_main"][-2] = [:ret]
+        vm.execute :"evaled_#{evaled}_main", _scope, this
+      }, nil, "eval", [])
+    eval.inherits_caller_this = true
+    scope.set_var "eval", eval
+  end
+end

data/lib/twostroke/runtime/lib/math.rb

@@ -6,6 +6,31 @@ module Twostroke::Runtime
     scope.set_var "Infinity", Types::Number.new(Float::INFINITY)
     scope.set_var "NaN", Types::Number.new(Float::NAN)
     
+    scope.set_var "isNaN", Types::Function.new(->(scope, this, args) {
+      Types::Boolean.new(args[0].is_a?(Types::Number) && args[0].nan?)
+    }, nil, "isNaN", [])
+    
+    scope.set_var "parseInt", Types::Function.new(->(scope, this, args) {
+      str = Types.to_string(args[0] || Undefined.new).string.gsub(/\A\s+/,"")
+      unless args[1] and (radix = Types.to_uint32(args[1])) != 0
+        case str
+        when /\A0x/i; radix = 16
+        when /\A0/i;  radix = 8
+        else;         radix = 10
+        end
+      end
+      if radix < 2 or radix > 36
+        Types::Number.new(Float::NAN)
+      else
+        begin
+          Integer(str[0], radix) # ensure the first character can be converted
+          Types::Number.new str.to_i radix
+        rescue
+          Types::Number.new(Float::NAN)
+        end
+      end
+    }, nil, "parseInt", [])
+    
     # one argument functions
     %w(sqrt sin cos tan).each do |method|
       obj.proto_put method, Types::Function.new(->(scope, this, args) {
@@ -13,6 +38,8 @@ module Twostroke::Runtime
         }, nil, method, [])
     end
 
+    obj.proto_put "PI", Types::Number.new(Math::PI)
+
     obj.proto_put "random", Types::Function.new(->(scope, this, args) {
       Types::Number.new rand
     }, nil, "random", [])
@@ -24,6 +51,10 @@ module Twostroke::Runtime
     obj.proto_put "ceil", Types::Function.new(->(scope, this, args) {
         Types::Number.new Types.to_number(args[0] || Undefined.new).number.ceil
       }, nil, "ceil", [])
+      
+    obj.proto_put "abs", Types::Function.new(->(scope, this, args) {
+        Types::Number.new Types.to_number(args[0] || Undefined.new).number.abs
+      }, nil, "floor", [])
     
     obj.proto_put "max", Types::Function.new(->(scope, this, args) {
         Types::Number.new [-Float::INFINITY, *args.map { |a| Types.to_number(a).number }].max

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

@@ -6,7 +6,13 @@ module Twostroke::Runtime
     proto = Types::Object.new
     proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
       if this.is_a?(Types::NumberObject)
-        Types::String.new(this.number.to_s)
+        base = args[0] ? Types.to_uint32(args[0]) : 10
+        Lib.throw_range_error "toString() radix argument must be between 2 and 36" if base < 2 or base > 36
+        if this.number.is_a? Fixnum or this.number.is_a? Bignum
+          Types::String.new this.number.to_s base
+        else
+          Types::String.new this.number.to_s
+        end
       else
         Lib.throw_type_error "Number.prototype.toString is not generic"
       end

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

@@ -41,7 +41,7 @@ module Twostroke::Runtime
       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
+      elsif this.has_property(prop)
         Types::Boolean.new true
       else
         Types::Boolean.new false

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

@@ -23,6 +23,7 @@ module Twostroke::Runtime
         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", [])
+    proto.proto_put "exec", Types::Function.new(Types::RegExp.method(:exec), nil, "exec", [])
     regexp.proto_put "prototype", proto
   end
 end

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

@@ -52,31 +52,71 @@ module Twostroke::Runtime
 
         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
+    # String.prototype.slice
+    proto.proto_put "slice", Types::Function.new(->(scope, this, args) {
+        sobj = Types.to_string(this)
+        s = sobj.string
+        if args[0].nil?
+          sobj
         else
-          m = s.method(find.global ? :gsub : :sub)
-          if replace.is_a?(String)
-            m.(find.regexp, replace)
+          start = Types.to_int32 args[0]
+          if args[1]
+            fin = Types.to_int32 args[1]
+            Types::String.new s[start...fin]
           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
+            Types::String.new s[start..-1]
           end
-        end)
-=end
+        end
+      }, nil, "slice", [])
+    # String.prototype.indexOf
+    proto.proto_put "indexOf", Types::Function.new(->(scope, this, args) {
+        idx = args[1] ? Types.to_int32(args[1]) : 0
+        Types::Number.new(Types.to_string(this).string.index(Types.to_string(args[0] || Types::Undefined.new).string, idx) || -1)
+      }, nil, "indexOf", [])
+    # String.prototype.lastIndexOf
+    proto.proto_put "lastIndexOf", Types::Function.new(->(scope, this, args) {
+        idx = args[1] ? Types.to_int32(args[1]) : -1
+        Types::Number.new(Types.to_string(this).string.rindex(Types.to_string(args[0] || Types::Undefined.new).string, idx) || -1)
+      }, nil, "lastIndexOf", [])
+    # String.prototype.charAt
+    proto.proto_put "charAt", Types::Function.new(->(scope, this, args) {
+        idx = args[0] ? Types.to_int32(args[0]) : 0
+        str = Types.to_string(this).string
+        if idx < 0 or idx >= str.length
+          Types::String.new ""
+        else
+          Types::String.new str[idx]
+        end
+      }, nil, "charAt", [])
+    # String.prototype.charAt
+    proto.proto_put "charCodeAt", Types::Function.new(->(scope, this, args) {
+        idx = args[0] ? Types.to_int32(args[0]) : 0
+        str = Types.to_string(this).string
+        if idx < 0 or idx >= str.length
+          Types::Number.new Float::NAN
+        else
+          Types::Number.new str[idx].ord
+        end
+      }, nil, "charCodeAt", [])
+    # String.prototype.match
+    proto.proto_put "match", Types::Function.new(->(scope, this, args) {
+        re = args[0] || Types::Undefined.new
+        re = Types::RegExp.constructor_function.(nil, nil, re) unless re.is_a?(Types::RegExp)
+        unless re.global
+          # same as re.exec(str) in this case
+          Types::RegExp.exec(nil, re, [this])
+        else
+          Types::RegExp.all_matches(nil, re, [this])
+        end
+      }, nil, "match", [])
+    # String.prototype.toUpperCase
+    proto.proto_put "toUpperCase", Types::Function.new(->(scope, this, args) {
+        Types::String.new Types.to_string(this).string.upcase
+      }, nil, "toUpperCase", [])
+    # String.prototype.toUpperCase
+    proto.proto_put "toLowerCase", Types::Function.new(->(scope, this, args) {
+        Types::String.new Types.to_string(this).string.downcase
+      }, nil, "toLowerCase", [])
     obj.proto_put "prototype", proto
     
     obj.proto_put "fromCharCode", Types::Function.new(->(scope, this, args) {

data/lib/twostroke/runtime/scope.rb

@@ -31,6 +31,14 @@ module Twostroke::Runtime
       @locals[var] = Types::Undefined.new
     end
     
+    def delete(var)
+      if has_var var
+        @locals.delete var
+      else
+        parent.delete var
+      end
+    end
+    
     def close
       Scope.new self
     end
@@ -59,11 +67,11 @@ module Twostroke::Runtime
       if object.has_property var.to_s
         object.put var.to_s, value
       else
-        parent.set_var var.to_s, value
+        parent.set_var var, value
       end
     end
     
-    def has_var
+    def has_var(var)
       object.has_property(var.to_s) || parent.has_var(var)
     end
     
@@ -71,6 +79,14 @@ module Twostroke::Runtime
       parent.declare var
     end
     
+    def delete(var)
+      if has_var var
+        object.delete var.to_s
+      else
+        parent.delete var
+      end
+    end
+    
     def close
       Scope.new self
     end
@@ -103,6 +119,11 @@ module Twostroke::Runtime
     end
     
     def declare(var)
+      @root_object.put var.to_s, Types::Undefined.new
+    end
+    
+    def delete(var)
+      @root_object.delete var.to_s
     end
     
     def close

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

@@ -19,6 +19,11 @@ module Twostroke::Runtime
         @prototype = Array.constructor_function.get("prototype")
         super()
         @items = items
+        define_own_property "length", get: ->(this) { Types::Number.new this.items.size }, set: ->(this,val) do
+            Lib.throw_type_error "Array.prototype.length is not generic" unless this.is_a? Types::Array
+            len = Types.to_uint32(val)
+            this.items = this.items[0...len]
+          end, writable: true, enumerable: false
       end
       
       def length

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

@@ -33,6 +33,7 @@ module Twostroke::Runtime::Types
     end
     
     attr_reader :arguments, :name, :source, :function
+    attr_accessor :inherits_caller_this
     def initialize(function, source, name, arguments)
       @function = function
       @source = source
@@ -44,11 +45,13 @@ module Twostroke::Runtime::Types
       @_class = nil unless defined?(@@constructor_function)
       super()
       @prototype = nil
-      proto_put "prototype", Object.new
+      proto = Object.new
+      proto.construct _class: self
+      put "prototype", proto
     end
     
     def prototype
-      @prototype ||= Function.constructor_function.get("prototype")
+      @prototype ||= Function.constructor_function.get("prototype") if Function.constructor_function
     end
     
     def has_instance(obj)

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

@@ -2,7 +2,6 @@ module Twostroke::Runtime::Types
   class Object < Value
     attr_accessor :_class, :prototype
     attr_reader :accessors, :properties, :extensible, :data
-    private :accessors, :properties
 
     def initialize
       @extensible = true
@@ -49,7 +48,7 @@ module Twostroke::Runtime::Types
           instance_variable_set "@#{k}", v
         end
       end
-      yield
+      yield if block_given?
       @constructing = false
     end
     
@@ -90,8 +89,8 @@ module Twostroke::Runtime::Types
         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
+#      elsif prototype && prototype.is_a?(Object) && prototype.has_accessor(prop)
+#        prototype.put prop, value, this
       else
         properties[prop] = value
       end

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

@@ -3,7 +3,7 @@ module Twostroke::Runtime::Types
     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
+          RegExp.new((args[0] && !args[0].is_a?(Undefined)) ? Twostroke::Runtime::Types.to_string(args[0]).string : "", args[1] && Twostroke::Runtime::Types.to_string(args[1]).string)
         }, nil, "RegExp", [])
     end
     
@@ -18,7 +18,7 @@ module Twostroke::Runtime::Types
         else; 0
         end
       end
-      @regexp = Regexp.new regexp_source, opts
+      @regexp = Regexp.new RegExp.to_ruby_regexp(regexp_source), opts
       @global = options.include? "g"
       @prototype = RegExp.constructor_function.get("prototype")
       super()
@@ -27,5 +27,48 @@ module Twostroke::Runtime::Types
     def primitive_value
       String.new(regexp.inspect + (@global ? "g" : ""))
     end
+    
+    def self.to_ruby_regexp(src)
+      src.
+      
+      # javascript's ^$ match the start and end of the entire string
+      # ruby's ^$ are line-based, so convert to \A and \z
+        gsub(/([^\[]|\A)\^/,"\\1\\A").gsub("$","\\z").
+      
+      # javascript supports \cA through \cZ for control characters
+        gsub(/\\c[a-z]/i) { |m| (m.last.downcase.ord - 'a'.ord).chr }
+    end
+    
+    def self.exec(scope, this, args)
+      re = this.is_a?(RegExp) ? this : constructor_function.(nil, nil, this)
+      str = Twostroke::Runtime::Types.to_string(args[0] || Twostroke::Runtime::Types::Undefined.new).string
+      if md = re.regexp.match(str)
+        result = Twostroke::Runtime::Types::Array.new md.to_a.map { |s| s ? Twostroke::Runtime::Types::String.new(s) : Twostroke::Runtime::Types::Undefined.new }
+        result.put "index", Twostroke::Runtime::Types::Number.new(md.offset(0).first)
+        result.put "input", Twostroke::Runtime::Types::String.new(str)
+        result
+      else
+        Twostroke::Runtime::Types::Null.new
+      end
+    end
+    
+    def self.all_matches(scope, this, args)
+      re = this.is_a?(RegExp) ? this : constructor_function.(nil, nil, this)
+      str = Twostroke::Runtime::Types.to_string(args[0] || Twostroke::Runtime::Types::Undefined.new).string
+      arr = []
+      idx = 0
+      while md = re.regexp.match(str, idx)
+        arr << Twostroke::Runtime::Types::String.new(md[0])
+        idx = md.offset(0).last
+      end
+      if arr.any?
+        result = Twostroke::Runtime::Types::Array.new arr
+        result.put "index", Twostroke::Runtime::Types::Number.new(re.regexp.match(str).offset(0).first)
+        result.put "input", Twostroke::Runtime::Types::String.new(str)
+        result
+      else
+        Twostroke::Runtime::Types::Null.new
+      end
+    end
   end
 end

data/lib/twostroke/runtime/types.rb

@@ -44,7 +44,7 @@ module Twostroke::Runtime::Types
       0
     else
       int32 = num.number.to_i & 0xffff_ffff
-      int32 -= 2 ** 31 if int32 >= 2 ** 31
+      int32 -= 2 ** 32 if int32 >= 2 ** 31
       int32
     end
   end

data/lib/twostroke/runtime/vm.rb

@@ -9,8 +9,8 @@ module Twostroke::Runtime
       @lib = {}
     end
     
-    def execute(section = :main, scope = nil)
-      Frame.new(self, section).execute scope      
+    def execute(section = :main, scope = nil, this = nil)
+      Frame.new(self, section).execute scope, this
     end
     
     def throw_error(type, message)