rlang 0.5.1 → 0.6.0

data/lib/rlang/lib/string.rb

@@ -11,34 +11,118 @@ class String
   # ptr is a simple memory address of type
   # :I32 (see it as the equivalent of a
   # char * in C)
-
+  #
   # There are 3 ways to initialize a new String object
   #  * with a string literal (e.g. mystring = "Hello World!")
   #  * by pointing at an existing memory location (e.g. String.new(ptr, length))
   #  * by asking Rlang to allocate the String space when ptr is NULL (e.g. String.new(0, length))
+  # No memory is allocated for the string bytes if the string is empty
   def initialize(ptr, length)
     result :none
     if ptr == 0
-      @ptr = Malloc.malloc(length)
+      if length == 0
+        @ptr = 0
+      else
+        @ptr = Malloc.malloc(length)
+      end
     else
       @ptr = ptr
     end
     @length = length
   end
 
+  def size; @length; end
+  def to_s; self; end
+
+  def empty?
+    @length == 0
+  end
+
+  def ord
+    result :I32
+    Memory.load32_8(@ptr)
+  end
+
   def +(stg)
     arg stg: :String
     result :String
-    new_length = self.length + stg.length
-    # allocate space for concatenated string
-    new_ptr = Malloc.malloc(new_length)
-    Memory.copy(self.ptr, new_ptr, self.length)
-    Memory.copy(stg.ptr, new_ptr + self.length, stg.length)
-    # Create new object string
-    String.new(new_ptr, new_length)
+
+    # Create new object string with proper size
+    s = String.new(0, @length + stg.length)
+    # Copy both strings in the new one
+    Memory.copy(@ptr, s.ptr, @length)
+    Memory.copy(stg.ptr, s.ptr + @length, stg.length)
+    s
   end
 
-  def size; @length; end
-  def to_s; self; end
+  def [](idx)
+    result :String
+    # The condition below should actually return nil
+    # to be compliant with the Ruby library but we don't
+    # have nil in Rlang so return an empty string
+    return "" if (idx >= @length) || (idx < -@length)
+    idx = (@length + idx) if idx < 0
+    stg = String.new(0,1)
+    Memory.copy(@ptr+idx, stg.ptr, 1)
+    stg
+  end
+
+  def []=(idx, stg)
+    arg stg: :String
+    result :String
+    if (idx >= @length) || (idx < -@length)
+      raise "IndexError: index out bound"
+    end
+    idx = (@length + idx) if idx < 0
+    i=0
+    tgt_ptr = @ptr+idx
+    while i < stg.length && (idx + i) < @length
+      Memory.copy(stg.ptr+i, tgt_ptr+i, 1)
+      i += 1
+    end
+    stg
+  end
+
+  def *(times)
+    result :String
+    full_length = @length * times
+    stg = String.new(0, full_length)
+    idx=0
+    while idx < full_length
+      stg[idx] = self
+      idx += @length
+    end
+    stg
+  end
+
+  def reverse!
+    result :String
+    half_size = @length/2
+    i=0
+    while i < half_size
+      swap = Memory.load32_8(@ptr+i)
+      Memory.store32_8(@ptr+i, Memory.load32_8(@ptr+@length-1-i))
+      Memory.store32_8(@ptr+@length-1-i, swap)
+      i += 1
+    end
+    self
+  end
+
+  def ==(stg)
+    arg stg: :String
+    return false if stg.length != @length
+    i = 0
+    stg_ptr = stg.ptr
+    while i < @length
+      return false if Memory.load32_8(@ptr+i) != Memory.load32_8(stg_ptr+i)
+      i += 1
+    end
+    true
+  end
+  
+  def !=(stg)
+    arg stg: :String
+    !(self == stg)
+  end
 
 end

data/lib/rlang/lib/type/i32.rb

@@ -4,29 +4,47 @@
 #
 # Integer 32 methods
 
-class String; end
+require_relative '../string'
 
 class I32
-  ConvertString = "0123456789ABCDEF"
+
+  DIGITS = "0123456789ABCDEF"
 
   def self.size; 4; end
 
-  def to_str(base)
+  # convert an integer to its string representation in a given base
+  def self.itoa(x,base)
     result :String
-    "0"
-=begin
-    # TODO
-    if n < base
-      return convertString[n]
-    else
-      return toStr(n//base,base) + convertString[n%base]
+
+    raise "itoa base out of range" if base < 2 || base > DIGITS.length
+    if x <= 0
+      if x == 0
+        return DIGITS[0]
+      else
+        return  "-" + self.itoa(0-x, base)
+      end
+    end
+
+    result = ""
+    while x > 0
+      remainder = x % base
+      x /= base
+      result += DIGITS[remainder]
     end
-=end
+    result.reverse!
   end
 
   def to_s
     result :String
-    self.to_str(10)
+    I32.itoa(self, 10)
+  end
+
+  def chr
+    result :String
+    raise "out of char range" if self > 255 || self < 0
+    stg = String.new(0,1)
+    Memory.store32_8(stg.ptr, self)
+    stg
   end
 
 end

data/lib/rlang/lib/type/i64.rb

@@ -4,8 +4,6 @@
 #
 # Integer 64 methods
 
-class String; end
-
 class I64
   def self.size; 8; end
 end

data/lib/rlang/lib/wasi.rb

@@ -9,12 +9,15 @@ require_relative './string'
 
 ARGC = 0
 ARGV = 0.cast_to(:Array32)
+ENV  = 0.cast_to(:Array32)
 
 class WASI
   STDIN_FD  = 0
   STDOUT_FD = 1
   STDERR_FD = 2
   @@argv_buf_size = 0
+  @@environc = 0
+  @@environ_buf_size = 0
 
   class CIOVec
     attr_reader :ciovs
@@ -81,9 +84,15 @@ class WASI
   # Import WASI functions
   import :wasi_unstable, :args_sizes_get
   def self.args_sizes_get(argc, args_size); end
-  
+
   import :wasi_unstable, :args_get
   def self.args_get(argv, argv_buf); end
+  
+  import :wasi_unstable, :environ_get
+  def self.environ_get(environ, environ_buf); end
+
+  import :wasi_unstable, :environ_sizes_get
+  def self.environ_sizes_get(environc, environ_buf_size); end
 
   import :wasi_unstable, :fd_write
   def self.fd_write(fd, iovs, iovs_count, nwritten_ptr); end
@@ -94,10 +103,8 @@ class WASI
   import :wasi_unstable, :proc_exit
   def self.proc_exit(exitcode); result :none; end
 
-  # Initialize WASI environment and related Rlang
-  # objects (ARGC, ARGV,...)
-  def self.init
-    local argv: :Array32
+  def self.argv_init
+    local argv: :Array32, environ: :Array32
 
     # Get number of arguments and their total size
     errno = WASI.args_sizes_get(ARGC.addr, @@argv_buf_size.addr)
@@ -108,7 +115,7 @@ class WASI
     #
     # Setup an extra slot in argv array to simplify the
     # loop below
-    argv = Array32.new(ARGC+1) #Malloc.malloc((ARGC+1) * 4) # Assuming I32 for pointers
+    argv = Array32.new(ARGC+1) # Assuming I32 for pointers
     argv_buf = Malloc.malloc(@@argv_buf_size)
     errno = WASI.args_get(argv.ptr, argv_buf)
 
@@ -124,10 +131,54 @@ class WASI
     while i < ARGC
       length = argv[i+1] - argv[i] - 1 # -1 because of null terminated
       ARGV[i] = String.new(argv[i], length)
+      # Nullify argv[i] so that String is not freed
+      argv[i] = 0
       i += 1
     end
+    argv.free
     return errno
   end
 
+  # Initialize WASI environment and related Rlang
+  # objects (ARGC, ARGV,...)
+  def self.environ_init
+    local environ: :Array32
+
+    # Get environ variable count and buf size
+    errno = WASI.environ_sizes_get(@@environc.addr, @@environ_buf_size.addr)
+    raise "Errno environ_sizes_get" if errno != 0
+
+    # Allocate memory areas to receive the env var pointers
+    # (env) and the env var strings (env_buf)
+    environ = Array32.new(@@environc+1) # Assuming I32 for pointers
+    environ_buf = Malloc.malloc(@@environ_buf_size)
+    errno = WASI.environ_get(environ.ptr, environ_buf)
+
+    raise "Errno environ_get" if errno != 0
+    environ[@@environc] = environ[0] + @@environ_buf_size
+
+    # Workaround to avoid dynamic constant assignment error
+    Memory.store32(ENV.addr, Array32.new(@@environc))
+
+    # Now scan through arguments and turn them into a Rlang
+    # Array of Strings (like ARGV in Ruby)
+    i = 0
+    while i < @@environc
+      length = environ[i+1] - environ[i] - 1 # -1 because of null terminated
+      ENV[i] = String.new(environ[i], length)
+      # Nullify environ[i] so that String is not freed
+      #environ[i] = 0
+      i += 1
+    end
+    #environ.free
+
+    return errno
+  end
+
+  def self.init
+    self.argv_init
+    self.environ_init
+  end
+
 end
 

data/lib/rlang/parser/data.rb

@@ -38,6 +38,8 @@ module Rlang::Parser
       @@current_address = 0
     end
 
+    # Append a value to the DAta object 
+    # and return this DAta object
     def append_value(value, wtype)
       logger.warn "Data type #{@wtype} misaligned!!! (Data[:#{@label}] value #{value} at address #{@address}" \
         unless self.aligned?
@@ -49,6 +51,7 @@ module Rlang::Parser
       end
       # Always make sure current address is aligned
       self.class.align(WType::DEFAULT.size)
+      self
     end
 
     def aligned?
@@ -64,6 +67,8 @@ module Rlang::Parser
       @@label_table[label].address
     end
 
+    # Append a value to the DAta object identified by the
+    # label and return this DAta object object
     def self.append(label, value, wtype=WType::DEFAULT)
       logger.debug "appending #{value} to DAta[#{label}]"
       if self.exist? label

data/lib/rlang/parser/ext/integer.rb

@@ -1,5 +1,7 @@
 class Integer
+  # Works for both signed and unsignd 32 or 64 bits integers
   def to_little_endian(byte_count)
-    ("%0#{byte_count*2}X" % self).scan(/../).reverse.map {|byte| "\\#{byte}"}.join('')
+    i = (self < 0) ? 2**(byte_count*8) + self : self
+    ("%0#{byte_count*2}X" % i).scan(/../).reverse.map {|byte| "\\#{byte}"}.join('')
   end
 end

data/lib/rlang/parser/ext/type.rb

@@ -2,6 +2,18 @@ module Type
 
   class I64 < Numeric
     MAX = 2**64 - 1
+    MIN = 0
+    def self.signed?; true; end
+    def size; 8; end  # size in bytes
+    def self.size; 8; end # size in bytes
+    def wasm_type; 'i64'; end
+    def self.wasm_type; 'i64'; end
+  end
+
+  class UI64 < Numeric
+    MAX = 2**63 - 1
+    MIN = -2**63
+    def self.signed?; false; end
     def size; 8; end  # size in bytes
     def self.size; 8; end # size in bytes
     def wasm_type; 'i64'; end
@@ -9,9 +21,23 @@ module Type
   end
 
   class I32 < Numeric
-    MAX = 2**64 - 1
+    MAX = 2**31 - 1
+    MIN = -2**31
+    def initialize(v); @v = Integer(v); end
+    def +(v); I32.new(v + @v); end
+    def self.signed?; true; end
+    def size; 4; end # size in bytes
+    def self.size; 4; end # size in bytes
+    def wasm_type; 'i32'; end
+    def self.wasm_type; 'i32'; end
+  end
+
+  class UI32 < Numeric
+    MAX = 2**32 - 1
+    MIN = 0
     def initialize(v); @v = Integer(v); end
     def +(v); I32.new(v + @v); end
+    def self.signed?; false; end
     def size; 4; end # size in bytes
     def self.size; 4; end # size in bytes
     def wasm_type; 'i32'; end
@@ -20,6 +46,7 @@ module Type
 
   class F64 < Numeric
     MAX = 1.7976931348623158E308
+    def self.signed?; true; end
     def size; 8; end # size in bytes
     def wasm_type; 'f64'; end
     def self.size; 8; end # size in bytes
@@ -29,6 +56,7 @@ module Type
   class F32 < Numeric
     MAX = 3.4028235E38
     # size in bytes
+    def self.signed?; true; end
     def size; 4; end  
     def wasm_type; 'f32'; end
     def self.size; 4; end  
@@ -60,5 +88,6 @@ module Type
   end
 
   DEFAULT = Type::I32
+  UNSIGNED_DEFAULT = Type::UI32
 
 end

data/lib/rlang/parser/global.rb

@@ -53,6 +53,13 @@ module Rlang::Parser
     end
 
     def self.transpile(depth)
+      # TODO : we should probably do that in a less "hardcoded" way
+      # Adjust the Heap base address to start after the static DAta
+      # section
+      g_heap = Global.find(:$HEAP)
+      g_heap.value = [DAta.align(8), g_heap.value].max if g_heap
+      
+      # Go generate code now
       indent = ' ' * depth * 2
       output = []
       @@globals.each do |g|