rlang 0.4.1 → 0.6.0

data/lib/rlang/lib/string.rb

@@ -1,4 +1,5 @@
 require_relative './malloc'
+require_relative './memory'
 
 class String
   attr_reader :length, :ptr
@@ -10,21 +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)
-    @ptr = ptr
+    result :none
+    if ptr == 0
+      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 [](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

@@ -2,6 +2,49 @@
 # Copyright (c) 2019, Laurent Julliard and contributors
 # All rights reserved.
 #
+# Integer 32 methods
+
+require_relative '../string'
+
 class I32
+
+  DIGITS = "0123456789ABCDEF"
+
   def self.size; 4; end
+
+  # convert an integer to its string representation in a given base
+  def self.itoa(x,base)
+    result :String
+
+    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
+    result.reverse!
+  end
+
+  def to_s
+    result :String
+    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

@@ -2,6 +2,8 @@
 # Copyright (c) 2019, Laurent Julliard and contributors
 # All rights reserved.
 #
+# Integer 64 methods
+
 class I64
   def self.size; 8; end
 end

data/lib/rlang/lib/unistd.rb

@@ -8,6 +8,7 @@
 # srbk(0) returns the current value of the break
 # Note: in WASM we can only grow linear memory by pages (64 KB block)
 
+require_relative './memory'
 
 # These 3 global variables below are used by the
 # dynamic memory allocator. You can redefine them
@@ -27,8 +28,6 @@ $HEAP_MAX_SIZE = 1073741824  # 1GB
 $HEAP_SIZE = 0
 
 class Unistd
-  result :Memory, :grow, :I32
-  result :Memory, :size, :I32
 
   def self.sbrk(n)
     # local variables used. All default type

data/lib/rlang/lib/wasi.rb

@@ -0,0 +1,184 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# WASI Interface to WASM runtime
+
+require_relative './array'
+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
+    attr_type ciovs: :Array32
+
+    def initialize(n)
+      result :none
+      # a ciov is list of n (address to buffer, length of buffer)
+      @n = n
+      @index = 0
+      @max_index = 2 * @n
+      @ciovs = Array32.new(2*n)
+    end
+
+    def << (string)
+      arg string: :String
+      result :CIOVec
+      raise "CIOVec full !" if @index >= @max_index
+      @ciovs[@index] = string.ptr
+      @ciovs[@index+1] = string.length
+      @index += 2
+      self
+    end
+
+    def free
+      result :none
+      @ciovs.free
+      Object.free(self)
+    end
+  end
+
+  # An IOVec is an array of (address to buffer, length of buffer)
+  # where WASM runtime can read data coming from the WASM module
+  class IOVec
+    attr_reader :iovs
+    attr_type iovs: :Array32
+
+    IOV_SIZE = 1024
+
+    def initialize(n)
+      result :none
+      @iovs = Array32.new(2*n)
+      @n = n
+      i = 0
+      while i < n;
+        @iovs[i] = Malloc.malloc(IOV_SIZE)
+        @iovs[i+1] = IOV_SIZE
+        i += 2
+      end
+    end
+
+    def free
+      result :none
+      i = 0
+      while i < @n
+        Malloc.free(@iovs[i])
+        i += 2
+      end
+      @iovs.free
+      Object.free(self)
+    end
+  end
+
+  # 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
+
+  import :wasi_unstable, :fd_read
+  def self.fd_read(fd, iovs, iovs_count, nread_ptr); end
+
+  import :wasi_unstable, :proc_exit
+  def self.proc_exit(exitcode); result :none; end
+
+  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)
+    raise "Errno args_sizes_get" if errno != 0
+
+    # Allocate memory areas to receive the argument pointers
+    # (argv) and the argument strings (argv_buf)
+    #
+    # Setup an extra slot in argv array to simplify the
+    # loop below
+    argv = Array32.new(ARGC+1) # Assuming I32 for pointers
+    argv_buf = Malloc.malloc(@@argv_buf_size)
+    errno = WASI.args_get(argv.ptr, argv_buf)
+
+    raise "Errno args_get" if errno != 0
+    argv[ARGC] = argv[0] + @@argv_buf_size
+
+    # Workaround to avoid dynamic constant assignment error
+    Memory.store32(ARGV.addr, Array32.new(ARGC))
+
+    # Now scan through arguments and turn them into a Rlang
+    # Array of Strings (like ARGV in Ruby)
+    i = 0
+    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/attr.rb

@@ -11,14 +11,14 @@ require_relative './wtype'
 module Rlang::Parser
   class Attr
     include Log
-    attr_reader :name, :getter, :setter, :ivar
+    attr_reader :name, :getter, :setter, :ivar, :klass
 
     # The name argument can either be the attribute name
     # (e.g. :size) or an ivar name (e.g. :@size)
-    def initialize(class_wnode, name, wtype=WType::DEFAULT)
-      @class_wnode = class_wnode
+    def initialize(klass, name, wtype=WType::DEFAULT)
+      @klass = klass
       @name = name
-      @ivar = class_wnode.create_ivar(:"@#{name}", wtype)
+      @ivar = klass.wnode.create_ivar(:"@#{name}", wtype)
       @getter = nil
       @setter = nil
       @export = false
@@ -26,16 +26,16 @@ module Rlang::Parser
     end
 
     def attr_reader
-      @getter = @class_wnode.find_or_create_method(self.getter_name, nil, wtype, :instance)
+      @getter = @klass.wnode.find_or_create_method(nil, self.getter_name, :instance, wtype)
       @getter.export! if @export
-      logger.debug "Getter created: #{@getter.inspect}"
+      logger.debug "Getter created: #{@getter}"
       @getter
     end
 
     def attr_writer
-      @setter = @class_wnode.find_or_create_method(self.setter_name, nil, wtype, :instance)
+      @setter = @klass.wnode.find_or_create_method(nil, self.setter_name, :instance, wtype)
       @setter.export! if @export
-      logger.debug "Setter created: #{@setter.inspect}"
+      logger.debug "Setter created: #{@setter}"
       @setter
     end
 
@@ -47,10 +47,6 @@ module Rlang::Parser
       @export = true
     end
 
-    def class_name
-      @class_wnode.class_name
-    end
-
     def wtype
       @ivar.wtype
     end
@@ -64,7 +60,7 @@ module Rlang::Parser
       @getter.wtype = wtype if @getter
       @setter.wtype = wtype if @setter
       @ivar.wtype = wtype
-      logger.debug "Attr/Getter/Setter/ivar wtype updated : #{@getter.inspect}"
+      logger.debug "Attr/Getter/Setter/ivar wtype updated : #{@getter}"
     end
 
     def getter_name

data/lib/rlang/parser/const.rb

@@ -10,6 +10,110 @@ require_relative './cvar'
 # Constants and Class variables are managed
 # in exactly the same way
 module Rlang::Parser
-  class Const < CVar
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Class variables
+# Note: Const class inherits from this class
+
+require_relative '../../utils/log'
+require_relative './wtype'
+require_relative './data'
+
+module Rlang::Parser
+  class Const
+    include Log
+    attr_reader :scope_class, :name, :value
+    attr_accessor :wtype
+
+    def initialize(name, value, wtype=WType::DEFAULT)
+      @scope_class = nil
+      @name  = name
+      @wtype = wtype
+      @data  = nil
+      self.value = value if value
+    end
+
+    # class or module in which constant is defined
+    # not to be confused with wtype that hold the Rlang
+    # class of the constant
+    def scope_class=(scope_class_or_mod)
+      logger.debug "Placing Constant #{name} in scope class #{scope_class_or_mod&.name}"
+      raise "Error: constant scope class already initialized with #{scope_class.name} / #{@scope_class}. Got #{scope_class_or_mod.name} / #{scope_class_or_mod}." \
+        if @scope_class
+      @scope_class = scope_class_or_mod
+      @scope_class.consts << self if @scope_class
+    end
+
+    # The value attribute can either be set at
+    # initialize time or later (e.g. for classes and modules)
+    def value=(value)
+      # TODO: as opposed to Ruby we don't handle constant
+      # reassignment for now.
+      raise "Constant #{self.name} already initialized with value #{@value}. Now getting #{value}" \
+        if @value
+      return nil unless value
+      logger.debug "Initializing constant #{@name} @ #{@address} with value #{@value} / wtype #{@wtype}"
+      if value.kind_of? Module
+         # for now just store 0 in constants
+         # pointing to class or module
+         # TODO: probably point to a minimal data 
+         # with the class path string for instance (= class name)
+        self.data = 0
+      else
+        self.data = value
+      end
+      @value = value
+    end
+
+    def data=(value)
+      @data = DAta.new(self.path_name.to_sym, value, @wtype)
+    end
+
+    # the symbol form of this constant path
+    # e.g. a constant A::B will return :"A::B"
+    def path_name
+      #@scope_class ? "#{@scope_class.path_name}::#{@name}".to_sym : @name
+      self.path.map(&:name).join('::').to_sym
+    end
+
+    # Returns an array of successive Const objects that
+    # altogether makes the full path of this Const
+    # e.g. a constant A::B will return [Const(:A), Const(:B)]
+    def path
+      sk = nil; c = self; p = [c]
+      while (sk = c.scope_class) && sk.const != c
+        logger.debug "c: #{c.name}/#{c}, sk: #{sk.name}/#{sk}"
+        c = sk.const
+        p.unshift(c)
+      end
+      # Do not keep Object as the first element of the
+      # const path unless it is the only element
+      p.shift if p.first.name == :Object && p.size > 1
+      logger.debug "Const#path : #{p.map(&:name)}"
+      p
+    end
+
+    def class?
+      @wtype.name == :Class
+    end
+
+    def module?
+      @wtype.name == :Module
+    end
+
+    def address
+      @data.address
+    end
+
+    def wasm_name
+      "$#{self.path_name}"
+    end
+
+    def wasm_type
+      @wtype.wasm_type
+    end
   end
 end
+end

data/lib/rlang/parser/cvar.rb

@@ -12,17 +12,21 @@ require_relative './data'
 module Rlang::Parser
   class CVar
     include Log
-    attr_reader :name, :class_name
+    attr_reader :name, :klass
     attr_accessor :wtype
 
-    def initialize(class_name, name, value=0, wtype=WType::DEFAULT)
+    def initialize(klass, name, value=0, wtype=WType::DEFAULT)
+      @klass = klass
       @name = name
-      @class_name = class_name
       @wtype = wtype
       # Allocate and initialize the new cvar
-      raise "Error: Class variable #{self.wasm_name} already created!" if DAta.exist? self.wasm_name.to_sym
-      @data = DAta.new(self.wasm_name.to_sym, value, wtype)
-      logger.debug "creating #{self.class} #{class_name}::#{name} @ #{@address} with value #{value} / wtype #{wtype}"
+      raise "Error: #{self.class} #{self.wasm_name} already created!" if DAta.exist? self.wasm_name.to_sym
+      @data = DAta.new(self.wasm_name.to_sym, value, wtype) unless wtype.name == :Class
+      logger.debug "creating #{self.class} #{self.class_name}::#{name} @ #{@address} with value #{value} / wtype #{wtype}"
+    end
+
+    def class_name
+      @klass.path_name
     end
 
     def address
@@ -34,7 +38,7 @@ module Rlang::Parser
     end
 
     def wasm_name
-      "$#{@class_name}::#{@name}"
+      "$#{self.class_name}::#{@name}"
     end
 
     def wasm_type

data/lib/rlang/parser/data.rb

@@ -23,13 +23,14 @@ module Rlang::Parser
     def initialize(label, value, wtype=WType::DEFAULT)
       raise "Data label '#{label}' already initialized" \
         if self.class.exist? label
+      logger.debug "@@current_address: #{@@current_address}"
       @label = label
       @wtype = wtype
       @address = @@current_address
       @@label_table[@label] = self
       @value = []
       self.append_value(value, wtype)
-      logger.debug "New Data[#{@label}] initialized with #{@value} at address #{@address}"
+      logger.debug "New Data[#{@label}] initialized with #{@value} at address #{@address} / new current address: #{@@current_address}"
     end
 
     def self.reset!
@@ -37,15 +38,20 @@ 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?
       @value << value
-      if value.is_a?(String) 
+      if value.is_a? String
         @@current_address += value.length
       else
-        logger.warn "Data type #{@wtype} misaligned!!! (Data[:#{@label}] value #{value} at address #{@address}" \
-          unless self.aligned?
         @@current_address += @wtype.size
       end
+      # Always make sure current address is aligned
+      self.class.align(WType::DEFAULT.size)
+      self
     end
 
     def aligned?
@@ -61,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
@@ -71,6 +79,8 @@ module Rlang::Parser
     end
 
     def self.address=(address)
+      logger.fatal "ERROR!! Cannot decrease current DAta address (was #{@@current_address}, got #{address}) " \
+        if address < @@current_address
       @@current_address = address
     end
 
@@ -86,7 +96,8 @@ module Rlang::Parser
 
     # Transpile data to WAT code
     # in order of increasing address
-    def self.transpile
+    def self.transpile(depth)
+      indent = ' ' * depth * 2
       output = []
       @@label_table.sort_by {|s,d| d.address}.each do |s,d|
         logger.debug "Generating data #{d.inspect}"
@@ -106,7 +117,7 @@ module Rlang::Parser
           end
         end
       end
-      output.join("\n")
+      indent + output.join("\n #{indent}")
     end
   end
 

data/lib/rlang/parser/export.rb

@@ -17,10 +17,11 @@ module Rlang::Parser
 
     # Export Rlang funcs, etc... grouping them
     # by object type for Wasm code readability
-    def self.transpile
-      @@exports.sort_by {|e| e.object.class.to_s}.collect do |export|
+    def self.transpile(depth)
+      indent = ' ' * depth * 2
+      indent + @@exports.sort_by {|e| e.object.class.to_s}.collect do |export|
         export.object.export_wasm_code
-      end.join("\n")
+      end.join("\n#{indent}")
     end
   end
 end

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