rlang 0.5.0 → 0.5.1

data/lib/rlang/lib/object.rb

@@ -6,6 +6,7 @@
 
 require_relative './malloc'
 require_relative './kernel'
+require_relative './string'
 
 class Object
 
@@ -20,4 +21,9 @@ class Object
     result :none
     Malloc.free(object_ptr)
   end
+
+  def to_s
+    result :String
+    "Object <addr>"
+  end
 end

data/lib/rlang/lib/rlang.rb

@@ -0,0 +1,29 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Rlang standard library classes and modules
+# and runtime initialization
+#
+require_relative './rlang_core'
+require_relative './wasi'
+require_relative './io'
+
+class Rlang
+  def self.init
+    # WASI init: setup ARGC, ARGV, etc...
+    errno = WASI.init
+
+    # IO init: setup fd of stdin, out and err
+    # This code cannot be executed within io.rb
+    # as STDxxx can only be used after io.rb is
+    # compiled
+    STDIN.fd  = WASI::STDIN_FD
+    STDOUT.fd = WASI::STDOUT_FD
+    STDERR.fd = WASI::STDERR_FD
+    $stdin  = STDIN
+    $stdout = STDOUT
+    $stderr = STDERR
+    errno
+  end
+end

data/lib/rlang/lib/rlang_core.rb

@@ -0,0 +1,14 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Rlang core library classes and modules
+#
+require_relative './type'
+require_relative './memory'
+require_relative './unistd'
+require_relative './malloc'
+require_relative './object'
+require_relative './kernel'
+require_relative './string'
+require_relative './array'

data/lib/rlang/lib/string.rb

@@ -11,8 +11,18 @@ 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))
   def initialize(ptr, length)
-    @ptr = ptr
+    result :none
+    if ptr == 0
+      @ptr = Malloc.malloc(length)
+    else
+      @ptr = ptr
+    end
     @length = length
   end
 
@@ -28,4 +38,7 @@ class String
     String.new(new_ptr, new_length)
   end
 
+  def size; @length; end
+  def to_s; self; end
+
 end

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

@@ -2,6 +2,31 @@
 # Copyright (c) 2019, Laurent Julliard and contributors
 # All rights reserved.
 #
+# Integer 32 methods
+
+class String; end
+
 class I32
+  ConvertString = "0123456789ABCDEF"
+
   def self.size; 4; end
+
+  def to_str(base)
+    result :String
+    "0"
+=begin
+    # TODO
+    if n < base
+      return convertString[n]
+    else
+      return toStr(n//base,base) + convertString[n%base]
+    end
+=end
+  end
+
+  def to_s
+    result :String
+    self.to_str(10)
+  end
+
 end

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

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

data/lib/rlang/lib/wasi.rb

@@ -0,0 +1,133 @@
+# 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)
+
+class WASI
+  STDIN_FD  = 0
+  STDOUT_FD = 1
+  STDERR_FD = 2
+  @@argv_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, :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
+
+  # Initialize WASI environment and related Rlang
+  # objects (ARGC, ARGV,...)
+  def self.init
+    local argv: :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) #Malloc.malloc((ARGC+1) * 4) # 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)
+      i += 1
+    end
+    return errno
+  end
+
+end
+

data/lib/rlang/parser.rb

@@ -29,23 +29,19 @@ module Rlang::Parser
 
     include Log
 
-    ARITHMETIC_OPS = [:+, :-, :*, :/, :%, :&, :|, :^, :>>, :<<]
-    RELATIONAL_OPS = [:==, :!=, :>, :<, :>=, :<=, :'>s', :'<s', :'>=s', :'>=s']
-    UNARY_OPS = [:'!']
-
-    # Type cast order in decreading order of precedence
-    TYPE_CAST_PRECEDENCE = [Type::F64, Type::F32, Type::I64, Type::I32]
-
     # WARNING!! THIS IS A **VERY** NASTY HACK PRETENDING
     # THAT THIS int VALUE means NIL. It's totally unsafe 
     # of course as an expression could end up evaluating
     # to this value and not be nil at all. But I'm using
     # it for now in the xxxx_with_result_type variants of
     # some parsing methods (if, while,...)
+    # NOTE: those variants with result type are **NOT** the
+    # ones used by Rlang right now
     NIL = 999999999
 
-    # export toggle for method declaration
-    @@export = false
+    # export and import toggle for method declaration
+    @@export, @@export_name = false, nil
+    @@import, @@import_module_name, @@import_function_name = false, nil, nil
 
 
     attr_accessor :wgenerator, :source, :config
@@ -121,6 +117,8 @@ module Rlang::Parser
       raise "wnode type is incorrect (got #{wnode})" unless wnode.is_a?(WNode) || wnode.nil?
       logger.debug "\n---------------------->>\n" + 
         "Parsing node: #{node}, wnode: #{wnode.head}, keep_eval: #{keep_eval}"
+      # Nothing to parse
+      return if node.nil?  
 
       case node.type
       when :self
@@ -274,8 +272,12 @@ module Rlang::Parser
       super_class_path = _build_const_path(super_class_const_node)
       wn_class = @wgenerator.klass(wnode, class_path, super_class_path)
 
+      # If body node is nil then this must be interpreted as
+      # a class declaration (no implementation yet)
+      return wn_class unless body_node
+
       # Parse the body of the class
-      parse_node(body_node, wn_class) if body_node
+      parse_node(body_node, wn_class)
 
       # We finished parsing the class body so
       # 1) postprocess instance variables
@@ -962,7 +964,9 @@ module Rlang::Parser
 
       # create corresponding func node
       wn_method = @wgenerator.def_method(wnode, method_name, :class)
-      wn_method.method.export! if (@@export || self.config[:export_all])
+      if @@import
+        wn_import = @wgenerator.import_method(wn_method, @@import_module_name, @@import_function_name)
+      end
 
       # collect method arguments
       parse_args(arg_nodes, wn_method)
@@ -970,7 +974,7 @@ module Rlang::Parser
       # that we know what the return type is in advance
       # If :nil for instance then it may change the way
       # we generate code in the body of the method
-      if (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
+      if body_node && (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
         logger.debug "result directive found: #{result_node}"
         parse_node(result_node, wn_method, keep_eval)
       end
@@ -987,9 +991,12 @@ module Rlang::Parser
       @wgenerator.locals(wn_method)
       @wgenerator.result(wn_method)
       @wgenerator.params(wn_method)
+      @wgenerator.export_method(wn_method, @@export_name) if (@@export || self.config[:export_all])
       logger.debug "Full method wnode: #{wn_method}"
-      # reset export toggle
-      @@export = false
+
+      # reset method toggles
+      self.class._reset_toggles
+
       return wn_method
     end
 
@@ -1008,18 +1015,19 @@ module Rlang::Parser
       logger.debug "Defining instance method: #{method_name}"
 
       # create corresponding func node
-      # Note: because module inclusion generate both instance
-      # and class methods we may get two methods wnode 
       wn_method = @wgenerator.def_method(wnode, method_name, :instance)
-      wn_method.method.export! if (@@export || self.config[:export_all])
+      if @@import
+        wn_import = @wgenerator.import_method(wn_method, @@import_module_name, @@import_function_name)
+      end
 
       # collect method arguments
       wn_args = parse_args(arg_nodes, wn_method)
+
       # Look for any result directive and parse it so 
       # that we know what the return type is in advance
       # If :nil for instance then it may change the way
       # we generate code in the body of the method
-      if (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
+      if body_node && (result_node = body_node.children.find {|n| n.respond_to?(:type) && n.type == :send && n.children[1] == :result})
         logger.debug "result directive found: #{result_node}"
         parse_node(result_node, wn_method, keep_eval)
       end
@@ -1036,9 +1044,11 @@ module Rlang::Parser
       @wgenerator.locals(wn_method)
       @wgenerator.result(wn_method)
       @wgenerator.params(wn_method)
+      @wgenerator.export_method(wn_method, @@export_name) if (@@export || self.config[:export_all])
       logger.debug "Full method wnode: #{wn_method}"
-      # reset export toggle
-      @@export = false
+
+      # reset method toggles
+      self.class._reset_toggles
 
       # if we are in a module then also define
       # the class method because we don't know
@@ -1067,10 +1077,12 @@ module Rlang::Parser
         when /^\./
           # If file starts with . then look for file in pwd
           load_path = [Dir.pwd]
+=begin
         when /^rlang/
           # If it starts with rlang then look for it in the 
           # installed rlang gem in addition to load path
           load_path = self.config[:LOAD_PATH] + $LOAD_PATH
+=end
         else
           load_path = self.config[:LOAD_PATH]
           load_path = [Dir.pwd] if self.config[:LOAD_PATH].empty?
@@ -1090,7 +1102,7 @@ module Rlang::Parser
           end
         end
       end
-      raise LoadError, "no such file to load: #{full_path_file}" unless full_path_file
+      raise LoadError, "no such file to load: #{file}" unless full_path_file
 
       # Now load the file 
       if File.extname(full_path_file) == '.wat'
@@ -1274,6 +1286,49 @@ module Rlang::Parser
         return wn_cast
       end
 
+      # addr method applied to statically allocated variables
+      # only constant and class variables returns their address 
+      # in memory
+      #
+      # Example
+      # @@argv_bu_size.addr
+      # ---
+      # (send (cvar :@@argv_buf_size) :addr)
+      #
+      if method_name == :addr
+        if recv_node.type == :const
+          # Build constant path from embedded const sexp
+          const_path = _build_const_path(recv_node)
+          full_const_name = const_path.join('::')
+
+          # See if constant exists. It should at this point
+          unless (const = wnode.find_const(const_path))
+            raise "unknown constant #{full_const_name}"
+          end
+          wn_const_addr = @wgenerator.const_addr(wnode, const)
+
+          # Drop last evaluated result if asked to
+          @wgenerator.drop(wnode) unless keep_eval
+          return wn_const_addr
+
+        elsif recv_node.type == :cvar
+          raise "Class variable can only be accessed in method scope" \
+            unless wnode.in_method_scope?
+          cv_name = recv_node.children.first
+          if (cvar = wnode.find_cvar(cv_name))
+            wn_cvar_addr = @wgenerator.cvar_addr(wnode, cvar)
+          else
+            raise "unknown class variable #{cv_name}"
+          end
+          # Drop last evaluated result if asked to
+          @wgenerator.drop(wnode) unless keep_eval
+          return wn_cvar_addr
+
+        else
+          # Do nothing. This will be treated as a regular method call
+        end
+      end
+
       # A that stage it's a method call of some sort
       # (call on class or instance)
       return parse_send_method_lookup(node, wnode, keep_eval)
@@ -1310,6 +1365,10 @@ module Rlang::Parser
         return parse_send_export(node, wnode, keep_eval)
       end
 
+      if recv_node.nil? && method_name == :import
+        return parse_send_import(node, wnode, keep_eval)
+      end
+
       if recv_node.nil? && method_name == :local
         return parse_send_local(node, wnode, keep_eval)
       end
@@ -1420,9 +1479,57 @@ module Rlang::Parser
 
     # Directive to declare the current method
     # in the WASM exports
+    # Example
+    #
+    # export
+    # ---
+    # (send nil :export)
+    # OR
+    # export :function_name
+    # ---
+    # (send nil :export
+    #   (sym :function_name))
+    #
+    # With out an explicit function name, the export name
+    # will be automatically built from the class/method names
     def parse_send_export(node, wnode, keep_eval)
-      raise "export must be used in class scope" unless wnode.in_class_scope?
+      logger.debug "Export directive found for..."
+      raise "export must be used in class scope" unless wnode.in_class_or_module_scope?
       @@export = true
+      if (function_node = node.children[2])
+        raise "export function name must be a symbol (got #{function_node})" \
+          unless function_node.type == :sym  
+        @@export_name = function_node.children.last
+      end
+      logger.debug "... #{@@export_name}"
+      return
+    end
+
+    # Directive to declare the current method
+    # in the WASM imports
+    # Example
+    #
+    # import :module_name, :function_name
+    # ---
+    # (send nil :import
+    #   (sym :mod)
+    #   (sym :func))
+    #
+    def parse_send_import(node, wnode, keep_eval)
+      logger.debug "Import directive found for..."
+      raise "export must be used in class scope" unless wnode.in_class_or_module_scope?
+      raise "import expects 2 arguments (got #{node.children.count - 2})" \
+        unless node.children.count == 4
+      
+      module_node, function_node = node.children[2..-1]
+      raise "import module name must be a symbol (got #{module_node})" \
+        unless module_node.type == :sym    
+      raise "import function name must be a symbol (got #{function_node})" \
+        unless function_node.type == :sym
+      @@import = true
+      @@import_module_name   = module_node.children.last
+      @@import_function_name = function_node.children.last
+      logger.debug "... #{@@import_module_name}, #{@@import_function_name}"
       return
     end
 
@@ -2145,6 +2252,11 @@ module Rlang::Parser
       const_path
     end
 
+    def self._reset_toggles
+      @@export, @@export_name = false, nil
+      @@import, @@import_module_name, @@import_function_name = false, nil, nil
+    end
+
     def dump
       @ast
     end