rlang 0.4.1 → 0.6.0

data/lib/rlang/lib/array/array64.rb

@@ -0,0 +1,56 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# 4 bytes object array class
+require_relative '../memory'
+require_relative '../object'
+require_relative '../type'
+require_relative '../string'
+
+
+class Array64
+  attr_reader :count, :ptr
+
+  # count: number of elements in Array
+  # Array elements are native types or
+  # pointers to objects
+  # Arrays are fixed size for now
+  def initialize(count)
+    # Avoid allocating 0 bytes in memory
+    if count == 0
+      @ptr = 0
+    else
+      # Memory size is count * 8 bytes
+      @ptr = Object.allocate(count << 3)
+    end
+    @count = count
+  end
+
+  def size; @count; end
+  def length; @count; end
+  def empty?; self.size == 0; end
+
+  def [](idx)
+    result :I64
+    raise "Index out of bound" if idx >= @count || idx < -@count
+    # offset in memory for elt #idx is idx * 8
+    Memory.load64(@ptr + (idx << 3))
+  end
+
+  def []=(idx, value)
+    arg value: :I64
+    result :I64
+    raise "Index out of bound" if idx >= @count || idx < -@count
+    # offset in memory for elt #idx is idx * 8
+    Memory.store64(@ptr + (idx << 3), value)
+    value
+  end
+
+  def free
+    result :none
+    Object.free(@ptr)
+    Object.free(self)
+  end
+
+end

data/lib/rlang/lib/array.rb

@@ -0,0 +1,6 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+require_relative './array/array32'
+require_relative './array/array64'

data/lib/rlang/lib/base64.rb

@@ -0,0 +1,223 @@
+# Rlang WebAssembly compiler
+# Copyright (c) 2019-2022, Laurent Julliard and contributors
+# All rights reserved.
+
+require 'kernel'
+require 'string'
+require 'array'
+
+module Base64
+
+  include Kernel
+
+  BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+  BASE64_CHARS_URLSAFE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+  PAD = "="
+  LINE_SEP = "\n" # Would be "\r\n" on Windows
+
+  # Tables of valid ASCII char maps for Base64 decoding.
+  # -1    : the char is invalid
+  #  >= 0 : the binary value to use for decoding (note: the '=' sign is also 0)
+  # 
+  BASE64_CHAR_MAP = 
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 
+     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 
+     9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 
+     27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 
+     51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1] 
+
+  BASE64_CHAR_MAP_URLSAFE = 
+    [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 
+     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, 0, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 
+     9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63, -1, 26, 
+     27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 
+     51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1] 
+
+
+  # Generic base 64 encoding 
+  # Derived from 
+  # http://www.java2s.com/Code/Java/Development-Class/AfastandmemoryefficientclasstoencodeanddecodetoandfromBASE64infullaccordancewithRFC2045.htm)
+  def self._encode64(bin, line_sep, base64_chars)
+    arg bin: :String, base64_chars: :String
+    local str: :String
+    result :String
+    
+    # Check special case
+    return "" if bin.empty?
+    slen = bin.length
+
+    # Number of even 24 bits (groups of 3 bytes)
+    elen = (slen / 3) * 3
+    # Encoded character count
+    ccnt = ((slen - 1) / 3 + 1) << 2
+    # Size of encoded string (incl. line separators)
+    # Note : Ruby implementation always add a \n at the end
+    # hence the +1
+    dlen = ccnt
+    dlen += ((ccnt - 1) / 60 + 1) * LINE_SEP.length if line_sep
+
+    # Allocate the proper size for encoded string
+    # to avoid allocating many string objects during
+    # concatenation
+    str = String.new(0, dlen)
+
+    # Encode even 24 bits
+    s=0; d=0; cc=0
+    while s < elen
+      # Copy next three bytes into lower 24 bits of int, 
+      # paying attention to sign.
+      i = bin[s].ord << 16  | bin[s+1].ord << 8 | bin[s+2].ord
+      s += 3
+
+      # Encode the int into four chars
+      str[d] = base64_chars[(i >> 18) & 0x3f]; d += 1
+      str[d] = base64_chars[(i >> 12) & 0x3f]; d += 1
+      str[d] = base64_chars[(i >> 6) & 0x3f]; d += 1
+      str[d] = base64_chars[i & 0x3f]; d += 1
+      cc += 1
+
+      # Add optional line separator each 60 chars in Ruby
+      if (line_sep && cc == 15 && d < dlen - 1)
+        str[d] = LINE_SEP; d += LINE_SEP.length
+        cc = 0
+      end
+    end
+
+    # Pad and encode last bits if source isn't even 24 bits.
+    left = slen - elen # 0 - 2
+    if left > 0
+      # Prepare the last int
+      i = bin[elen].ord << 10
+      i |= (bin[slen - 1].ord << 2) if left == 2
+
+      # Set last four chars
+      str[d] = base64_chars[i >> 12]; d += 1
+      str[d] = base64_chars[(i >> 6) & 0x3f]; d += 1
+      if left == 2
+        str[d] = base64_chars[i & 0x3f]
+      else
+        str[d] = PAD
+      end
+      d += 1
+      str[d] = PAD; d += 1
+    end
+
+    str[d] = LINE_SEP if line_sep
+    return str
+  end
+
+
+  # Decodes a BASE64 encoded String. All illegal characters will be 
+  # ignored and can handle both arrays with and without line separators.
+  # 
+  # Derived from
+  # http://www.java2s.com/Code/Java/Development-Class/AfastandmemoryefficientclasstoencodeanddecodetoandfromBASE64infullaccordancewithRFC2045.htm)
+
+  def self._decode64(str, base64_chars, base64_char_map)
+    arg str: :String, base64_chars: :String, base64_char_map: :Array32
+    local bin: :String
+    result :String
+
+    # Check special case
+    return "" if (slen = str.length) == 0
+  
+    # Count illegal characters (including '\r', '\n') to know what
+    # size the returned array will be, so we don't have to reallocate
+    # & copy it later.
+    # Number of separator characters. (Actually illegal characters, 
+    # but that's a bonus...)
+    sepcnt = 0; i = 0
+    while  i < slen
+      sepcnt += 1 if base64_char_map[str[i].ord] < 0
+      i += 1
+    end
+
+    # Check that legal chars (including '=') are evenly divideable
+    # by 4 as specified in RFC 2045.
+    return "" if (slen - sepcnt) % 4 != 0
+
+    # Count padding chars from the end
+    pad = 0; i = slen-1
+    while i > 0 && base64_char_map[str[i].ord] <= 0
+      pad += 1 if str[i] == PAD
+      i -= 1
+    end
+
+    # Preallocate String of exact length
+    len = ((slen - sepcnt) * 6 >> 3) - pad
+    bin = String.new(0, len)
+
+    # Go on decoding
+    s = 0; d = 0
+    while d < len
+      # Assemble 3 bytes into an int from 4 valid characters.
+      i = 0; j = 0
+      while j < 4
+        c = base64_char_map[str[s].ord]; s += 1
+        # j increases only if a valid char is found
+        if c != -1
+          i |= c << (18 - j * 6)
+          j += 1
+        end
+      end
+
+      # Now decode the int and add 3 chars to the bin string
+      bin[d] = (i >> 16 & 0xff).chr; d += 1
+      if d < len
+        bin[d] = (i >> 8 & 0xff).chr; d += 1
+        if d < len
+          bin[d] = (i & 0xff).chr; d += 1
+        end
+      end
+    end
+
+    return bin
+  end
+
+  def self.decode64(str)
+    arg str: :String
+    result :String
+    self._decode64(str, BASE64_CHARS, BASE64_CHAR_MAP)
+  end
+
+  def self.encode64(bin)
+    arg bin: :String
+    result :String
+    self._encode64(bin, 1, BASE64_CHARS)
+  end
+
+  def self.strict_decode64(str)
+    arg str: :String
+    self._decode64(str, BASE64_CHARS, BASE64_CHAR_MAP)
+  end
+
+  def self.strict_encode64(bin)
+    arg bin: :String
+    result :String
+    self._encode64(bin, 0, BASE64_CHARS)
+  end
+
+  def self.urlsafe_decode64(str)
+    arg str: :String
+    self._decode64(str, BASE64_CHARS_URLSAFE, BASE64_CHAR_MAP_URLSAFE)
+  end
+
+  def self.urlsafe_encode64(bin)
+    arg bin: :String
+    result :String
+    self._encode64(bin, 0, BASE64_CHARS_URLSAFE)
+  end
+
+end

data/lib/rlang/lib/io.rb

@@ -0,0 +1,75 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# IO class for all basic input and output operations
+
+require_relative './wasi'
+
+class IO
+  attr_accessor :fd
+
+  @@num_bytes_written = 0
+  @@num_bytes_read    = 0
+
+  def initialize(fd)
+    @fd = fd
+  end
+
+  def write(stg)
+    arg stg: :String
+    ciovec = WASI::CIOVec.new(1)
+    ciovec << stg
+    errno = WASI.fd_write(@fd, ciovec.ciovs.ptr, 1, @@num_bytes_written.addr)
+    ciovec.free
+    errno
+  end
+
+  def print(stg)
+    self.write(stg)
+  end
+
+  def puts(stg)
+    arg stg: :String
+    result :none
+    ciovec = WASI::CIOVec.new(2)
+    ciovec << stg
+    ciovec << "\n"
+    errno = WASI.fd_write(@fd, ciovec.ciovs.ptr, 2, @@num_bytes_written.addr)
+    ciovec.free
+  end   
+
+  def read
+    result :String
+    local stg: :String
+    iovec = WASI::IOVec.new(1)
+    errno = WASI.fd_read(@fd, iovec.iovs.ptr, 1, @@num_bytes_read.addr)
+    # -1 below because of \0 terminated string
+    stg = String.new(iovec.iovs[0], @@num_bytes_read-1) 
+    # Nullify the iovs entry used by the String object so it is not freed
+    iovec.iovs[0] = 0
+    iovec.free
+    stg
+  end
+
+end
+
+STDIN  = IO.new
+STDOUT = IO.new
+STDERR = IO.new
+
+module Kernel
+
+  def puts(stg)
+    arg stg: :String
+    result :none
+    STDOUT.puts(stg)
+  end
+
+  def print(stg)
+    arg stg: :String
+    result :none
+    STDOUT.print(stg)
+  end
+
+end

data/lib/rlang/lib/kernel.rb

@@ -0,0 +1,23 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Kernel methods
+#
+# Most of the Kernel methods are defined in other files
+# to avoid requiring classes that rely on Kernel methods
+# themselves.
+
+class String; end
+
+module Kernel
+
+  def raise(msg)
+    arg msg: :String
+    result :none
+    #$! = msg
+    #STDERR.puts msg
+    inline wat: '(unreachable)', wtype: :none
+  end
+
+end

data/lib/rlang/lib/malloc.rb

@@ -8,8 +8,8 @@
 # For a detailed explanation of the allocator code see
 # https://gnuchops.wordpress.com/2013/02/26/memory-allocator-for-embedded-system-k-r-ritchie-book/
 
-require 'rlang/lib/memory'
-require 'rlang/lib/unistd'
+require_relative './memory'
+require_relative './unistd'
 
 # minimum number of units to request
 $NALLOC = 1024
@@ -30,13 +30,14 @@ $NALLOC = 1024
 
 # Allocate some unused memory space to make 
 # sure so that freep doesn't point to memory
-# address 0 because it has a sepcial meaning
-# Allocate 20 bytes (5 x I32 integers)
-DAta[:dummy_malloc_data] = [0, 0, 0, 0, 0]
+# address 0 because it has a special meaning
+# Allocate 20 bytes (4 x I32 integers)
+DAta.align(4)
+DAta[:dummy_malloc_data] = [0, 0, 0, 0]
 
 class Header
   attr_accessor :ptr, :size
-  attr_type ptr: :Header, size: :I32
+  attr_type ptr: :Header, size: :UI32
 end
     
 class Malloc
@@ -47,13 +48,15 @@ class Malloc
   # declare ahead of time because is used in
   # the code before it is actually defined
   result :Malloc, :free, :nil
+  result :Malloc, :morecore, :Header
 
 # -------- Dynamic Memory Allocator Functions -----------
 
   # malloc: allocate n bytes of memory and return pointer
   # to data block
   def self.malloc(nbytes)
-    local p: :Header, prevp: :Header
+    arg nbytes: :UI32
+    local p: :Header, prevp: :Header, nunits: :UI32
 
     # allocate memory by chunk of units (the unit is
     # the size of a Header object here)
@@ -105,6 +108,7 @@ class Malloc
   
   # morecore: ask system for more memory
   def self.morecore(nu)
+    arg nu: :UI32
     result :Header
     local up: :Header
 
@@ -120,7 +124,7 @@ class Malloc
 
   # Free memory block
   def self.free(ap)
-    arg ap: :I32
+    arg ap: :UI32
     result :none
     local bp: :Header, p: :Header
 

data/lib/rlang/lib/memory.rb

@@ -1,4 +1,9 @@
-require 'rlang/lib/type'
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Web Assembly memory access methods
+#
 
 class Memory
 
@@ -25,5 +30,100 @@ class Memory
       idx += 1
     end
   end
-  
+
+  def self.load32_8(addr)
+    arg addr: :I32
+    result :I32
+    inline wat: '(i32.load8_u (local.get $addr))',
+           wtype: :I32
+  end
+
+  def self.load32_16(addr)
+    arg addr: :I32
+    result :I32
+    inline wat: '(i32.load16_u (local.get $addr))',
+           wtype: :I32
+  end
+
+  def self.load32(addr)
+    arg addr: :I32
+    result :I32
+    inline wat: '(i32.load (local.get $addr))',
+           wtype: :I32
+  end
+
+  def self.load64_8(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load8_u (local.get $addr))',
+           wtype: :I64
+  end
+
+  def self.load64_16(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load16_u (local.get $addr))',
+           wtype: :I64
+  end
+  def self.load64_32(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load32_u (local.get $addr))',
+           wtype: :I64
+  end
+  def self.load64(addr)
+    arg addr: :I32
+    result :I64
+    inline wat: '(i64.load (local.get $addr))',
+           wtype: :I64
+  end
+
+  def self.store32_8(addr, value)
+    arg addr: :I32, value: :I32
+    result :none
+    inline wat: '(i32.store8 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store32_16(addr, value)
+    arg addr: :I32, value: :I32
+    result :none
+    inline wat: '(i32.store16 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store32(addr, value)
+    arg addr: :I32, value: :I32
+    result :none
+    inline wat: '(i32.store (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64_8(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store8 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64_16(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store16 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64_32(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store32 (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
+
+  def self.store64(addr, value)
+    arg addr: :I32, value: :I64
+    result :none
+    inline wat: '(i64.store (local.get $addr) (local.get $value))',
+           wtype: :none
+  end
 end

data/lib/rlang/lib/object.rb

@@ -1,10 +1,18 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Base Object class
+
 require_relative './malloc'
+require_relative './kernel'
+require_relative './string'
 
 class Object
-  # don't use allocate as a name to avoid
-  # colliding with Ruby native method in 
-  # Rlang simulator
-  def self.alloc(nbytes)
+
+  include Kernel
+  
+  def self.allocate(nbytes)
     result :I32
     Malloc.malloc(nbytes)
   end
@@ -13,4 +21,32 @@ class Object
     result :none
     Malloc.free(object_ptr)
   end
+
+  def to_s
+    result :String
+    "Object <addr>"
+  end
+
+  def object_id
+    result :I32
+    self
+  end
+
+  def eql?(object)
+    result :I32
+    inline wat: '(i32.eq 
+      (local.get $_self_)
+      (local.get $object))',
+           wtype: :I32,
+           ruby: 'self.object_id == object.object_id'
+  end
+
+  def ==(object)
+    self.eql?(object)
+  end
+
+  def !=(object)
+    !(self == object)
+  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,15 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Rlang core library classes and modules
+#
+
+require_relative './memory'
+require_relative './unistd'
+require_relative './malloc'
+require_relative './object'
+require_relative './kernel'
+require_relative './string'
+require_relative './array'
+require_relative './type'