rlang 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38b11b7ed747a6a72f0a46a2c498efef419039a9bf85b5ba6442b7fd8f5300fc
-  data.tar.gz: 2e1c220542d7b7356c6b963edb2d34e45cdbd0cd556dec6a718a4f663b5651b5
+  metadata.gz: 853a10a09ac23cc4cedb2c2b5bc966258cfc858673bbecc7a7bb625c8ddf4b92
+  data.tar.gz: f27458788eb2cccaa49bb319436979a91e93de4e54fb3fd83c28fd67b481a631
 SHA512:
-  metadata.gz: 71fc2a6a83c414edbc2dbfca1b1e465a1d265ba80350101e4536178e1959ccf4a823478c7c139acde6d3e88d56d25d0a2fd9d4a781b2c1da919b4de0f5a4268a
-  data.tar.gz: 65969682077beb48030e5f9ffff0f1d97aa2ee2ea48e2142feac74e3a687661aa5b7afcbb8db26b8b1da8936e7dbeca4d09e9a8be5108dda8dd6325fb15a3c99
+  metadata.gz: 78a5e6da19f10887854dd40fb85e4a48d2073c10ece4acc01c07651041110eceb4c13cb67fd7251b1e0abbc310bc25134ef32c27bd2bb4e6af3488eec3a2bdf5
+  data.tar.gz: 3bfc1ffe8b133f4b8b2621c810af522f51fa88d44ab5dcc00a679dd0bf3eab857321d311c9b156dcd63428e62222669d87a6c1f1a501203ba0e448b44300a60f

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.6.0
+* Support for signed/unsigned integers (arithmetics, relational operatos, explicit and implicit type cast)
+* More methods in String ([], []=, +, *, ==, !=, chr,...)
+* More methods in Array  ([], []=, ==, !=,...)
+* More methods in I32 and I64 classes (to_s,...)
+* Base 64 encoding and decidong module (same methods as in Ruby)
+* Array literal ([]) supported as initializer
+* Automatically adjust HEAP base address at compile time
+* Various bug fixes and code cleanup
+
 ## 0.5.1
 * Imported WASM methods can now be defined
 * Preliminary version of WASI interface and IO class added to Rlang library

data/Gemfile.lock

@@ -13,13 +13,11 @@ GEM
     parser (2.7.0.2)
       ast (~> 2.4.0)
     rake (12.3.3)
-    rutie (0.0.4)
     simplecov (0.18.1)
       docile (~> 1.1)
       simplecov-html (~> 0.11.0)
     simplecov-html (0.11.0)
-    wasmer (0.3.0)
-      rutie (~> 0.0.3)
+    wasmer (1.0.0)
 
 PLATFORMS
   ruby
@@ -30,7 +28,7 @@ DEPENDENCIES
   rake (~> 12.0)
   rlang!
   simplecov (~> 0.18)
-  wasmer (~> 0.3)
+  wasmer (~> 1.0)
 
 BUNDLED WITH
-   2.0.2
+   2.3.13

data/README

@@ -0,0 +1,11 @@
+All contents here come from http://www.wolczko.com/st80/
+
+image.tar.gz:original Xerox virtual image (as provided on tape by Xerox PARC) 
+manual.pdf: the manual that came with the tape (incl. errata for the Blue Book implementation section)
+st.tar.gz: C implementation of the Smalltalk VM from Mario Wolczko
+VMsrc.shar: Smalltalk VM sourcesas re-keyed from the Blue Book by Mario Wolczko 
+
+Xerox Star
+----------
+8010_hd_images.zip: Xerox Star images. hard disk images for Viewpoint 2.0, XDE 5.0, and The Harmony release of Interlisp-D (Not Smalltalk)
+See article at https://engblg.livingcomputers.org/index.php/2019/01/19/introducing-darkstar-a-xerox-star-emulator/

data/bin/rlang

@@ -70,6 +70,10 @@ options:
     options[:wasm] = v
   end
 
+  opts.on("-c", "--comments", "Include comments in WAT source file") do |v|
+    options[:comments] = v
+  end
+
   opts.on("-S", "--start FUNCTION", "Function name where execution starts (default '_start')") do |function|
     options[:start] = function
   end

data/docs/RlangCompiler.md

@@ -19,6 +19,7 @@ Usage: rlang [options] rlang_file.rb
     -w, --wat                        Generate WAT source file
     -a, --ast                        Generate Ruby AST file
     -s, --wasm                       Generate WASM bytecode file
+    -c, --comments                   Include comments in WAT source file
     -S, --start FUNCTION             Function name where execution starts (default '_start')
     -o, --output FILE                Write output to file
     -v, --verbose [LEVEL]            Verbosity level (fatal, error, warn, info, debug)
@@ -32,6 +33,7 @@ Usage: rlang [options] rlang_file.rb
 * **-w, --wat**: parse Rlang file and generate WAT source code
 * **-a, --ast**: parse Rlang file and generate the Ruby abstract syntax tree
 * **-s, --wasm**: parse Rlang file, generate WAT source code and compile it to WASM bytecode
+* **-c, --comments**: include the Rlang comments at the corresponding location in the generated WAT source file.
 * **-S, --start**: function to use as the execution starting point of the WASM module (default is `_start`)
 * **-o, --output FILE**: send rlang output to FILE
 * **-v, --verbose [LEVEL]**: verbosity level (fatal, error, warn, info, debug). Default is warn

data/docs/RlangManual.md

@@ -1,6 +1,6 @@
 # The Rlang language
 
-Rlang is a subset of the Ruby language that is meant to provide a certain level of abstration and expressiveness while keeping its translation to WebAssembly straightforward. 
+Rlang is a subset of the Ruby language that is meant to provide a good level of abstraction and expressiveness while keeping its compilation to WebAssembly straightforward. 
 
 Ruby programmers will feel at home with Rlang and non Ruby programmers will find it useful to generate efficient WebAssembly code from a language that is much easier to use.
 
@@ -21,6 +21,7 @@ Rlang provides:
 * Arithmetic, relational and logical operators
 * WebAssembly source code (WAT) inlining
 * Requiring other Rlang or WAT files
+* Importing and exporting WASM functions
 * A Rlang library (written in Rlang of course) that you can reuse in your own WebAssembly module
 
 Here is a sample of Rlang code to whet your appetite:
@@ -117,7 +118,7 @@ end
 The code is pretty straightforward: a new square instance is created, its side attribute is set to 10. As you would expect, the call to the Square#area method returns 100 and the perimeter is 40.
 
 ### Class attribute type
-In the example above the `side` attribute is implicitely using the `:I32` (long integer) WebAssembly type. It's the default Rlang type. Assuming you want to manage big squares, you'd have to use `:I64` (double integer) like this for the `side` attribute and also instruct Rlang that the return value of area is also `:I64` (more on this later).
+In the example above the `side` attribute is implicitely using the `:I32` (signed 32-bit integer) WebAssembly type. It's the default Rlang type. Assuming you want to manage big squares, you'd have to use `:I64` (double integer) like this for the `side` attribute and also instruct Rlang that the return value of area is also `:I64` (more on this later).
 
 ```ruby
 class Square
@@ -229,9 +230,9 @@ Rlang also gives you the ability to declare the return type of a method like thi
 result :class_name, :method_name, :your_type_here
 ```
 
-This result directive must be used to instruct the compiler about the return type of a method if it has not seen it yet (e.g. the method definition is coming later in your source code) or when calling a method from another class defined in a different file not yet compiled. But keep in mind that this is only needed if the method returns something different than the default type (`:I32`).
+This result directive must be used to instruct the compiler about the return type of a method if the compiler has not yet compiled this method (e.g. the method definition is coming later in your source code) or when calling a method from another class defined in a different file not yet compiled. Keep in mind that this is only needed if the method returns something different than the default type (`:I32`).
 
-Note: in this directive `:method_name` symbol starts with a `#` characters if it refers to an instance method. Without it it refers to a class method.
+Note: in this directive `:method_name` symbol starts with a `#` characters if it refers to an instance method. Without the `#` it refers to a class method.
 
 For an example see the [test_def_result_type_declaration.rb](https://github.com/ljulliar/rlang/blob/master/test/rlang_test_files/test_def_result_type_declaration.rb), a Rlang file that is part of the Rlang test suite.
 
@@ -294,10 +295,10 @@ The example above is taken from the Rlang WASI class that defines the interface
 
 
 ## Rlang types
-The types currently supported by Rlang are integers either long (`:I32`) or double (`:I64`) or a class type. Float types (`:F32`, `:F64`) may follow in a future version. By default Rlang assumes that any integer literal, variable, argument,... is of type `:I32`. If you need it to be of a different type you must state it explicitely in the method body (see above).
+The types currently supported by Rlang are integers either signed long (`:I32`), unsigned long (`:UI32`), signed double (`:I64`), unsigned double (`:UI64`) or a class type. Float types (`:F32`, `:F64`) may follow in a future version. By default Rlang assumes that any integer literal, variable, argument,... is of type `:I32`. If you need it to be of a different type you must declare it explicitely in the method body (see above) or cast it explicitely (see below).
 
 ### Implicit type cast
-Only in rare cases will you use the `local` directive in methods as Rlang does its best to infer the type of a variable from its first assigned value. As an example, in the code below, the fact that `arg1` is known to be an `:I64` type of argument is enough to auto-magically create lvar as in `:I64` local variable too.
+Only in rare cases will you use the `local` directive in methods as Rlang does its best to infer the type of a variable from its first assigned value. As an example, in the code below, the fact that `arg1` is known to be an `:I64` type of argument is enough to auto-magically create lvar as an `:I64` local variable too.
 
 ```ruby
 def m_local_var(arg1)
@@ -307,7 +308,7 @@ def m_local_var(arg1)
 end
 ```
 
-Conversely in the method below the first statement `lvar = 10` auto-vivifies `lvar` as a variable of type `:I32` (the default Rlang type). On the next line, Rlang evaluates `arg1 * 100` as an `:I64` result because `arg1` is declared as being of type `:I64`. Similarly as the type of `lvar` local variable was auto-vivified as `:I32`, the result of the expression `arg1 * 100` will be type cast from `:I64` to `:I32`. Note that Such a type cast may of course result in the value being truncated and the Rlang compiler will emit a warning accordingly.
+Conversely in the method below the first statement `lvar = 10` auto-vivifies `lvar` as a variable of type `:I32` (the default Rlang type). On the next line, Rlang evaluates `arg1 * 100` as an `:I64` result because `arg1` is declared as being of type `:I64`. Similarly as the type of `lvar` local variable was auto-vivified as `:I32`, the result of the expression `arg1 * 100` will be type cast from `:I64` to `:I32`. Note that such a type cast may of course result in the value being truncated and the Rlang compiler will emit a warning accordingly.
 
 ```ruby
 def self.m_local_var(arg1)
@@ -318,6 +319,33 @@ def self.m_local_var(arg1)
 end
 ```
 
+### Implicit type cast precedence
+
+Rlang follows the C IEC/ISO Standard to implicitely convert types. When operands of different types are mixed in arithmetic or relational operators, Rlang will conver them according to the following priority order from the highest priority to the lowest:
+
+`:F64`, `:F32`, `:UI64`, `:I64`, `:Class`, `:UI32`, `:I32`
+
+Let's take a few examples:
+* If you use 32 bit floating point numbers and 64 bit floating point numbers in the same expression all `:F32` values will be converted to `:F64`
+* Similarly if you mix `:F32` values and `:I64` values, all 64-bit integers will be converted to 32-bit floating point values before evaluating the expression
+* **IMPORTANT** note that unsigned integers `:UI64` and `:UI32`have a higher priority than their signed counter part `:I64` and `:I32`. This means that when mixing signed and unsigned integer values in the same expression, the signed integers will be reinterpreted as its unsigned equivalent bitwise. As an example in this context an `:I32` with a value of -6 will be reinterpreted as an`:UI32` with a value of 4294967290. So be very cautious when mixing signed and unsigned integers as this may be give somewhat suprising results especially when using relational operators such >, <, >=,...
+
+### Pointer arithmetics
+
+In the types priority order mentioned above, the `:Class` type designate any value pointing to a class instance, in other word an object. This means that object pointers are values that you can process through arithmetic and relational operators like in C. A pointer to an object is a 32 bit memory address that has type casting precedence over `:UI32` and `:I32` types.
+
+Consequently when doing some arithmetics on object pointers like an addition or a substraction the integer vale will be interpreted as a multiple of the object size as if you were moving an index over objects of the same type in memory. Again this behavior is similar to the C language.
+
+
+```ruby
+class MyClass
+  up = Header.new
+  next_hdr = up + 1 
+  #...
+end
+```
+In the example above, a new header object is created and it meory location is stored in the up variable. When adding 1 to the up variable, Rlang knows that up is of type Header and will therefore increase up not by 1 but by the size in byted of the Header Object in memory. You can see examples of pointer arithmetics in the memory allocator of Rlang in lib/malloc.rb.
+
 ### Explicit type cast
 If Rlang is not capable of guessing the proper type of an expression or variable, you can explicitely cast it to any known type. Look at this example:
 
@@ -334,7 +362,7 @@ The first line will auto-vivify the `@@cvar` class variable as type `:I64`.
 
 The second example turns the value `123876` into a pointer to a `Square` object. It's pretty much like turning an integer into a pointer to a memory address in C.
 
-For `:I32` and `:I64` type cast you can also use the following shortcuts `100.to_I64` or `100.to_I32`
+For type cast a number or an expression to native type you can also use shortcuts like `100.to_I64` or `100.to_UI32`, etc...
 
 Note that type cast can be used anywhere in the code whether in class body or method definition.
 
@@ -510,6 +538,7 @@ For now, the Rlang library is very modest and containoffers the following classe
   * Malloc.malloc(nbytes) : dynamically allocates nbytes of memory and return address of the allocated memory space or -1 if it fails
   * Malloc.free(address) : frees the block of memory at the given address
 * **Object** class: provides a couple of object management method. Use `Object.free` to free an object.
+* **Array32**, **Array64** : Arrays can be initialized with the usual bracket operator '[]'. When the array is initialized at compile time (statically) such as for constants or class variables you can only use integers in the array initializers (e.g.`[0, 100, 200]`). When the array is initialized at runtime (dynamically) such as in the body of a method definition you can either use integers or any Rlang object (e.g. `[ 1, 2, "A string", my_object]`)
 * **String** class: string are initialized in Rlang by using a string literal like `"This is my string"`. String methods supported are very minimal for the moment. See [rlang/lib/String.rb](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/string.rb). Feel free to improve.
 
 As a side note, the dynamic memory allocator currently used in Rlang is shamelessly adapted from the example provided in the famous Kernigan & Richie C book 2nd edition. Take a look at the [C version](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/malloc.c) and see how easy it is to rewrite it in [Rlang](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/malloc.rb).

data/lib/rlang/lib/array/array32.rb

@@ -5,6 +5,7 @@
 # 4 bytes object array class
 require_relative '../memory'
 require_relative '../kernel'
+require_relative '../type'
 #require_relative '../string'
 
 
@@ -18,16 +19,23 @@ class Array32
   # pointers to objects
   # Arrays are fixed size for now
   def initialize(count)
-    @ptr = Object.allocate(count * 4)
+    if count == 0
+      @ptr = 0
+    else
+      # Memory size is count * 4 bytes
+      @ptr = Object.allocate(count << 2)
+    end
     @count = count
   end
 
-  def size; @count; end
+  def size;   @count; end
   def length; @count; end
+  def empty?; @count == 0; end
 
   def [](idx)
     result :I32
-    raise "Index out of bound" if idx >= @count
+    raise "Index out of bound" if idx >= @count || idx < -@count
+    idx = @count + idx if idx <0
     # offset in memory for elt #idx is idx * 4
     Memory.load32(@ptr + (idx << 2))
   end
@@ -35,7 +43,8 @@ class Array32
   def []=(idx, value)
     arg value: :I32
     result :I32
-    raise "Index out of bound" if idx >= @count
+    raise "Index out of bound" if idx >= @count || idx < -@count
+    idx = @count + idx if idx <0
     # offset in memory for elt #idx is idx * 4
     Memory.store32(@ptr + (idx << 2), value)
     value

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

@@ -5,6 +5,7 @@
 # 4 bytes object array class
 require_relative '../memory'
 require_relative '../object'
+require_relative '../type'
 require_relative '../string'
 
 
@@ -16,16 +17,23 @@ class Array64
   # pointers to objects
   # Arrays are fixed size for now
   def initialize(count)
-    @ptr = Object.allocate(count * 8)
+    # 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
+    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
@@ -33,7 +41,7 @@ class Array64
   def []=(idx, value)
     arg value: :I64
     result :I64
-    raise "Index out of bound" if idx >= @count
+    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

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

@@ -40,11 +40,16 @@ class IO
   end   
 
   def read
-    result :I32 #:String
+    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
-    String.new(iovec.iovs[0], @@num_bytes_read-1) 
+    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

data/lib/rlang/lib/malloc.rb

@@ -37,7 +37,7 @@ 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
@@ -55,7 +55,8 @@ class Malloc
   # 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)
@@ -107,6 +108,7 @@ class Malloc
   
   # morecore: ask system for more memory
   def self.morecore(nu)
+    arg nu: :UI32
     result :Header
     local up: :Header
 
@@ -122,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/object.rb

@@ -26,4 +26,27 @@ class Object
     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_core.rb

@@ -4,7 +4,7 @@
 #
 # Rlang core library classes and modules
 #
-require_relative './type'
+
 require_relative './memory'
 require_relative './unistd'
 require_relative './malloc'
@@ -12,3 +12,4 @@ require_relative './object'
 require_relative './kernel'
 require_relative './string'
 require_relative './array'
+require_relative './type'