daff 1.1.2

data/lib/lib/haxe/io/bytes.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Bytes 
+    
+    def initialize(length,b)
+      @length = length
+      @b = b
+    end
+    
+    attr_accessor :length
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :b
+    
+    public
+    
+    def get_string(pos,len)
+      raise ::Haxe::Io::Error.outside_bounds if pos < 0 || len < 0 || pos + len > @length
+      return @b.byteslice(pos,len)
+    end
+    
+    def Bytes.of_string(s)
+      return ::Haxe::Io::Bytes.new(s.bytesize,s)
+    end
+    
+  end
+
+end
+end

data/lib/lib/haxe/io/eof.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Eof 
+    
+    protected
+    
+    def to_s 
+      return "Eof"
+    end
+    
+  end
+
+end
+end

data/lib/lib/haxe/io/error.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Error
+    ISENUM__ = true
+    attr_accessor :tag
+    attr_accessor :index
+    attr_accessor :params
+    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
+    
+    def Error.blocked() Error.new("Blocked",0) end
+    def Error.custom(e)  Error.new("Custom",3,[e]) end
+    def Error.outside_bounds() Error.new("OutsideBounds",2) end
+    def Error.overflow() Error.new("Overflow",1) end
+    CONSTRUCTS__ = ["Blocked","Overflow","OutsideBounds","Custom"]
+  end
+
+end
+end

data/lib/lib/haxe/io/output.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+module Io
+  class Output 
+    
+    def write_byte(c)
+      raise "Not implemented"
+    end
+    
+    def write_bytes(s,pos,len)
+      k = len
+      b = s.b
+      raise ::Haxe::Io::Error.outside_bounds if pos < 0 || len < 0 || pos + len > s.length
+      while(k > 0) 
+        self.write_byte(b[pos])
+        pos+=1
+        k-=1
+      end
+      return len
+    end
+    
+    def write_full_bytes(s,pos,len)
+      while(len > 0) 
+        k = self.write_bytes(s,pos,len)
+        pos += k
+        len -= k
+      end
+    end
+    
+    def write_string(s)
+      b = ::Haxe::Io::Bytes.of_string(s)
+      self.write_full_bytes(b,0,b.length)
+    end
+    
+  end
+
+end
+end

data/lib/lib/haxe/log.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Haxe
+  class Log 
+    
+    class << self
+    attr_accessor :_trace
+    end
+    @_trace = lambda {|v,infos = nil|
+      ::Rb::Boot.__trace(v,infos)
+    }
+    
+  end
+
+end

data/lib/lib/hx_overrides.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class HxOverrides 
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def HxOverrides.date_str(date)
+      m = date.get_month + 1
+      d = date.get_date
+      h = date.get_hours
+      mi = date.get_minutes
+      s = date.get_seconds
+      return _hx_str(date.get_full_year) + "-" + _hx_str((((m < 10) ? "0" + _hx_str(m) : "" + _hx_str(m)))) + "-" + _hx_str((((d < 10) ? "0" + _hx_str(d) : "" + _hx_str(d)))) + " " + _hx_str((((h < 10) ? "0" + _hx_str(h) : "" + _hx_str(h)))) + ":" + _hx_str((((mi < 10) ? "0" + _hx_str(mi) : "" + _hx_str(mi)))) + ":" + _hx_str((((s < 10) ? "0" + _hx_str(s) : "" + _hx_str(s))))
+    end
+    
+  end
+

data/lib/lib/imap.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class IMap 
+  end
+

data/lib/lib/lambda.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class Lambda 
+    
+    def Lambda.array(it)
+      a = Array.new
+      _it = Rb::RubyIterator.new(it)
+      while(_it.has_next) do
+        i = _it._next
+        a.push(i)
+      end
+      return a
+    end
+    
+    def Lambda.map(it,f)
+      l = List.new
+      _it = Rb::RubyIterator.new(it)
+      while(_it.has_next) do
+        x = _it._next
+        l.add((f).call(x))
+      end
+      return l
+    end
+    
+    def Lambda.has(it,elt)
+      _it = Rb::RubyIterator.new(it)
+      while(_it.has_next) do
+        x = _it._next
+        return true if x == elt
+      end
+      return false
+    end
+    
+  end
+

data/lib/lib/list.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class List 
+    
+    def initialize
+      @length = 0
+    end
+    
+    protected
+    
+    attr_accessor :h
+    attr_accessor :q
+    
+    public
+    
+    attr_accessor :length
+    
+    def add(item)
+      x = [item]
+      if @h == nil 
+        @h = x
+      else 
+        @q[1] = x
+      end
+      @q = x
+      @length+=1
+    end
+    
+    def iterator 
+      return { h: @h, has_next: lambda {
+        return @h != nil
+      }, _next: lambda {
+        return nil if @h == nil
+        x = @h[0]
+        @h = @h[1]
+        return x
+      }}
+    end
+    
+  end
+

data/lib/lib/rb/boot.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Rb
+  class Boot 
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    def Boot.__trace(v,i)
+      if i != nil 
+        puts "#{v} #{i.inspect}"
+      else 
+        puts v
+      end
+    end
+    
+  end
+
+end

data/lib/lib/rb/ruby_iterator.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Rb
+  class RubyIterator 
+    
+    def initialize(x)
+      if x.is_a?(Hash) 
+        @ref = x.values.each
+        @at = 0
+        @len = x.size
+      elsif x.respond_to?("each") 
+        @ref = x.each
+        @at = 0
+        @len = x.size
+      elsif x.respond_to?("iterator") 
+        @ref = x.iterator
+        @at = -1
+        @at = -2 if !@ref.respond_to?("has_next")
+      else 
+        @ref = x
+        @at = -2
+      end
+    end
+    
+    protected
+    
+    attr_accessor :ref
+    attr_accessor :at
+    attr_accessor :len
+    
+    public
+    
+    def has_next 
+      return @ref[:has_next].call if @at == -1
+      return @ref[:has_next][:call].call if @at == -2
+      return @at < @len
+    end
+    
+    def _next 
+      return @ref[:_next].call if @at == -1
+      return @ref[:_next][:call].call if @at == -2
+      @at+=1
+      return @ref.next
+    end
+    
+  end
+
+end

data/lib/lib/reflect.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class Reflect 
+    
+    def Reflect.field(o,field)
+      begin
+        result = o[field]
+        result = o[field.to_sym] if result == nil
+        return result
+      rescue => e
+        return field
+      end
+    end
+    
+    def Reflect.fields(o)
+      if o.respond_to?("attributes") 
+        return o.attributes
+      else 
+        return o.keys
+      end
+    end
+    
+    def Reflect.is_function(f)
+      return f.respond_to?("call")
+    end
+    
+  end
+

data/lib/lib/string_buf.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class StringBuf 
+    
+    def initialize
+      @b = ""
+    end
+    
+    # protected - in ruby this doesn't play well with static/inline methods
+    
+    attr_accessor :b
+  end
+

data/lib/lib/sys.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+  class HxSys 
+    
+    def HxSys.args 
+      return ARGV
+    end
+    
+    def HxSys.stdout 
+      return ::Sys::Io::FileOutput.new(STDOUT)
+    end
+    
+    def HxSys.stderr 
+      return ::Sys::Io::FileOutput.new(STDERR)
+    end
+    
+  end
+

data/lib/lib/sys/io/file.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Sys
+module Io
+  class HxFile 
+    
+    def HxFile.get_content(path)
+      return IO.read(path)
+    end
+    
+    def HxFile.save_content(path,content)
+      IO.write(path,content)
+    end
+    
+  end
+
+end
+end

data/lib/lib/sys/io/file_handle.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Sys
+module Io
+  class FileHandle
+    ISENUM__ = true
+    attr_accessor :tag
+    attr_accessor :index
+    attr_accessor :params
+    def initialize(t,index,p = nil ) @tag = t; @index = index; @params = p; end
+    
+    CONSTRUCTS__ = []
+  end
+
+end
+end

data/lib/lib/sys/io/file_output.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+module Sys
+module Io
+  class FileOutput < ::Haxe::Io::Output 
+    
+    def initialize(f)
+      @__f = f
+    end
+    
+    protected
+    
+    attr_accessor :__f
+    
+    public
+    
+     
+    
+    def write_byte(c)
+      @__f.putc(c)
+    end
+     
+    
+    def write_bytes(b,p,l)
+      s = b.get_string(p,l)
+      r = @__f.write(s)
+      raise ::Haxe::Io::Error.custom("An error occurred") if r < l
+      return r
+    end
+    
+  end
+
+end
+end