rlang 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45f6d0c347cfcf901dcd935e2b979098759f2c9b435ff5d900f77a830d5b2101
-  data.tar.gz: 88c0e8f7b79f3cb784f0dd0c85fc10b68427958893f3401998f9866fa9a9b50a
+  metadata.gz: 853a10a09ac23cc4cedb2c2b5bc966258cfc858673bbecc7a7bb625c8ddf4b92
+  data.tar.gz: f27458788eb2cccaa49bb319436979a91e93de4e54fb3fd83c28fd67b481a631
 SHA512:
-  metadata.gz: d6f959bc61a5f4f9548455244662a8b3d9482d9e4670fdb66fd9d5ea1101e062bb93d5fbaffabac5e24852c85058130f92680e76f7d01bbe1745914bee25640b
-  data.tar.gz: 30e4ecce3b01f850fd9515ab614e75d3cd915545b172bab7174872d0d5fab4875a96ade32dac2f1b7a95a3ca0f58ef0ef891544b926ba0e6c23fa38c4cb6fca2
+  metadata.gz: 78a5e6da19f10887854dd40fb85e4a48d2073c10ece4acc01c07651041110eceb4c13cb67fd7251b1e0abbc310bc25134ef32c27bd2bb4e6af3488eec3a2bdf5
+  data.tar.gz: 3bfc1ffe8b133f4b8b2621c810af522f51fa88d44ab5dcc00a679dd0bf3eab857321d311c9b156dcd63428e62222669d87a6c1f1a501203ba0e448b44300a60f

data/CHANGELOG.md

@@ -1,6 +1,22 @@
-## 0.4.1
-* Class attributes syntac now identical to plain Ruby
-* Very preliminary version of Rlang String class
+## 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
+
+## 0.5.0
+* Class attributes syntax now identical to plain Ruby
+* Class in class definition and module supported
+* Class inheritance
+* Basic Array and String class in Rlang library
 
 ## 0.4.0
 * Object instances, instance methods and instance variables now supported

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rlang (0.4.0)
+    rlang (0.5.1)
       parser
 
 GEM
@@ -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/README.md

@@ -1,12 +1,17 @@
-# Rlang : a (subset of) Ruby to WebAssembly compiler
+# Rlang : a Ruby-like language compiled to WebAssembly
 
 Rlang is meant to generate fast and uncluttered [WebAssembly](https://webassembly.org) code from the comfort of the Ruby language.
 
-Rlang is actually two things: 1) a supported subset of the Ruby language and 2) a **compiler** transforming this Ruby subset in a valid, fully runnable and native WebAssembly module.
+Rlang is actually two things: 1) a subset of the Ruby language and 2) a **compiler** transforming this Ruby subset in a native, fully runnable WebAssembly module.
+
+So in summary what Rlang does is:
+<p align="center"><b>
+Rlang source code &rarr; Rlang compiler &rarr; WebAssembly bytecode
+</b></p>
 
 Rlang can be seen as a foundational language that can help you quickly develop and debug high performance WebAssembly modules. For the rationale behind the creation of Rlang see [below](#why-rlang).
 
-This is still a young project but Rlang has already been successfully tested with some real code such as the dynamic memory allocator provided with the Rlang library. It will keep mproving over time, always with the goal of generating crisp and uncluttered WAT code.
+This is still a young project but Rlang has already been successfully tested with some real code such as the dynamic memory allocator provided with the Rlang library. It will keep improving over time, always with the goal of generating crisp and uncluttered WebAssembly code.
 
 If you want to help with Rlang see [How you can help](#how-you-can-help).
 
@@ -15,6 +20,8 @@ If you want to help with Rlang see [How you can help](#how-you-can-help).
 * **WABT toolkit**: the rlang compiler can generate both WebAssembly source code (WAT file) and WebAssembly bytecode (WASM file). To generate WASM bytecode the rlang compiler uses wat2wasm. This utility is part of the [WABT toolkit](https://github.com/WebAssembly/wabt)
 * **wasmer runtime** (optional): [Wasmer](https://wasmer.io/) is a fast WebAssembly runtime. You'll need it if you want to run the test suite from the source repo. You can also use it to run the compiled WASM code generated by the rlang compiler. You can get Wasmer at  [wasmer.io](https://wasmer.io/)
 
+Rlang has also been successfully tested with the [Wasmtime](https://wasmtime.dev/) WebAssembly runtime.
+
 
 ## Installing Rlang
 Rlang is available as a gem from rubygems.org. So simply run the following command to install it:
@@ -22,7 +29,7 @@ Rlang is available as a gem from rubygems.org. So simply run the following comma
 ```
 $ gem install rlang
 ```
-Alternatively, if you clone this git repo and play with the Rlang source code you can generate your own local gem and install it like this:
+Alternatively, if you clone this git repo and play with the Rlang source code you can generate your own local gem and install it as follows:
 
 ```
 $ bundle install
@@ -33,7 +40,7 @@ $ gem install --local rlang-x.y.z.gem
 To check that the installation went well, run `rlang --help` and see if the help message displays correctly.
 
 ## A Quick example
-An example is always worth a thousand words, so here is a quick one that'll show you how to compile some Rang code and run it from your browser. Since Chrome, Chromium, Firefox and Safari all natively embed a WebAssembly runtime it is the easiest way to test compiled Rlang code.
+An example is always worth a thousand words, so here is a quick one showing you how to compile some Rang code and run it from your browser. Since Chrome, Chromium, Firefox and Safari embed a WebAssembly runtime it is the easiest way to test your compiled Rlang code.
 
 Navigate to the Fibonacci directory in [examples/fib](https://github.com/ljulliar/rlang/blob/master/examples/fib/) and download the three files from this directory: fib.rb, index.html, server.rb. Alternatively you can git clone the repo and go directly in that directory.
 
@@ -50,15 +57,14 @@ Point your browser to [http://localhost:8080](http://localhost:8080), a simple p
 
 That was easy, right ?
 
-
 ## The Rlang language
 Ruby features supported by Rlang are detailed in the [Rlang Manual](https://github.com/ljulliar/rlang/blob/master/docs/RlangManual.md)
 
 You can look at the rlang test suite in [test/rlang_test_files](https://github.com/ljulliar/rlang/blob/master/test/rlang_test_files/) to get a flavor of the subset of Ruby currently supported.
 
-For a more involved example of Ruby code, I invite you to look at the [dynamic memory allocator](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/malloc.rb) provided with the Rlang library.
+For a more involved example of Rlang code, I invite you to look at the [dynamic memory allocator](https://github.com/ljulliar/rlang/blob/master/lib/rlang/lib/malloc.rb) provided with the Rlang library.
 
-## rlang compiler
+## The rlang compiler
 The Rlang compiler can be invoked through the `rlang` command. See the [Rlang Compiler Documentation](https://github.com/ljulliar/rlang/blob/master/docs/RlangCompiler.md) for more details about the command line options.
 
 Keep in mind that Rlang is **NOT** a Ruby interpreter or a Ruby VM executing some kind of bytecode. It does actually statically **compile** the Rlang language to WebAssembly code pretty much like gcc or llvm compiles C/C++ code to machine assembly language.
@@ -70,9 +76,11 @@ One of the big benefits of Rlang being a subset of the Ruby language is that you
 ## Why Rlang?
 This project was created out of the need to develop a Virtual Machine written in WebAssembly capable of interpreting the [Rubinius](https://github.com/rubinius/rubinius) bytecode. And yes, ultimately run a native Ruby VM in a browser :-)
 
-After a first proof of concept written directly by hand in WebAssembly (WAT code) it became clear that writing a full fledged VM directly in WebAssembly was going to be tedious, complex and unnecessarily painful.
+After a first proof of concept written directly by hand in WebAssembly (WAT source code) it became clear that writing a full fledged VM directly in WebAssembly was going to be tedious, complex and unnecessarily painful.
+
+Sure I could have written this VM in any of the language that can already be compiled directly to WebAssembly (C, C++, Rust, Go,...) but being fond of Ruby since 2000 I decided that I would go for a compiler capable of transforming a subset of the Ruby language directly into WebAssembly with a minimum overhead.
 
-Sure I could have written this VM in any of the language that can already be compiled directly to WebAssembly (C, C++, Rust, Go,...) but being fond of Ruby since 2000 I decided that I would go for a compiler capable of transforming a subset of the Ruby language directly into WebAssembly with a minimum overhead. So in a nutshell: the goal of Rlang is to let you develop efficient WebAssembly code with a reasonably high level of abstraction while keeping the generated WebAssembly code straightforward and human readable.
+So in a nutshell: the goal of Rlang is to let you develop efficient WebAssembly code with a reasonably high level of abstraction while keeping the generated WebAssembly code straightforward,  human readable and slim.
 
 ## Why the name Rlang?
 Yes I hear you: Rlang is already the name of the R language so why use that name and aren't you introducing some confusion? Well for one I couldn't resist using that name to honor software engineering history (see below) and because, after all, the intersection between the Ruby/WebAssembly community and the R language community focused on data processing and machine learning must be quite small to say the least.

data/bin/rlang

@@ -13,13 +13,16 @@
 
 require 'optparse'
 require 'fileutils'
-require 'rlang'
+require 'rlang' # setup RLANG_BASE_DIR
 require 'builder'
 
+RLANG_LIB_DIR = File.expand_path('./rlang/lib', RLANG_BASE_DIR)
+
 include Log
 logger.level = Logger::INFO
 
 options = {}
+custom_load_path = []
 OptionParser.new do |opts|
   opts.banner = %q{Usage: rlang [options] filename
   read a Rlang file, check it for errors, and convert it
@@ -39,8 +42,8 @@ options:
 }
 
   opts.on("-I DIR", "--load_path DIRECTORY", "specify $LOAD_PATH directory (may be used more than once)") do |dir|
-    options[:LOAD_PATH] ||= []
-    options[:LOAD_PATH] << dir
+    custom_load_path ||= []
+    custom_load_path << dir
   end
 
   opts.on("-M", "--module NAME", "WASM module name") do |name|
@@ -67,6 +70,14 @@ 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
+
   opts.on("-o", "--output FILE", "Write output to file") do |file|
     options[:output] = file
   end
@@ -87,9 +98,10 @@ options:
   end
 end.parse!(ARGV)
 
-options[:module] ||= ''
+options[:module]     ||= '' 
 options[:memory_min] ||= 4
-options[:LOAD_PATH] ||= []
+options[:LOAD_PATH]  = custom_load_path << RLANG_LIB_DIR
+options[:start]      ||= '_start'
 
 fh_out = options[:output] ? File.open(options[:output], 'w') : STDOUT
 

data/docs/RlangCompiler.md

@@ -19,6 +19,8 @@ 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)
     -V, --version                    Displays Rlang version
@@ -30,7 +32,9 @@ Usage: rlang [options] rlang_file.rb
 * **-m, --memory MIN[,MAX]**: size of the WASM memory allocated at run time. The first argument is the initial amount of memory allocated and the second one (optional) is the maximum memory that your WASM module can allocate while running. The unit of both arguments is in number of WASM pages (4 KBytes)
 * **-w, --wat**: parse Rlang file and generate WAT source code
 * **-a, --ast**: parse Rlang file and generate the Ruby abstract syntax tree
-* **-w, --wat**: parse Rlang file, generate WAT source code and compile it to WASM bytecode
+* **-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
 * **-V, --version**: Displays Rlang version

data/docs/RlangManual.md

@@ -1,19 +1,16 @@
 # 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.
 
 Still, to make this Ruby to WebAssembly compilation possible a number of trade-offs had to be made. The goal of this document is to explain the features of Rlang are how it differs from plain Ruby.
 
-## The Rlang object model
-
-In Rlang you can define classes and those classes can be instantiated either statically at compile time or  dynamically at runtime. There is no inheritance mechanism today between classes in the current version. Classes cannot be nested.
-
 ## What Rlang does
 
 Rlang provides:
 * Classes, class attributes and class variables
+* Modules
 * Object instantiation, attribute accessors and instance variables
 * Method definition and method calls
 * Integers and booleans 
@@ -24,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:
@@ -46,8 +44,6 @@ calling that method later in your code is as simple as invoking `Math.fib(20)`
 ## Classes
 Classes are core constructs of Rlang and are very similar to Ruby classes.
 
-In Rlang, all methods must be defined within the scope of a class. In other words you can not define a method at the top level of your Rlang code (not a very good practice anyway, even in plain Ruby). Also there is no inheritance mechanism in Rlang in the current version.
-
 Here is an example of a class definition and the initialization and use of a class variable written in Rlang (note: this example uses only class methods on purpose. Instance methods are covered later in this document):
 
 ```ruby
@@ -70,6 +66,28 @@ This short piece of code shows several interesting points:
 1. Methods in this example are class methods, hence the use of `self.take_one` and `self.refill` in method definitions but instance methods are also supported (more on this later)
 1. In `MyClass::take_one` you can see that Rlang also supports convenient syntactic sugar like `if` as a modifier or combined operation and assignment as in Ruby (here the `-=` operator)
 
+### Class scope and inheritance
+Rlang supports the definition of classes in class at any depth and class naming follows the exact same convention as in Ruby. In the example below the `B` class can be referred to as `A::B`. 
+
+```ruby
+class A
+  class B
+  end
+end
+
+def main
+  new_object = A::B.new
+end
+```
+A Class in RLang can also inherit from another class as in Ruby. Whan a superclass is not specified, a newly defined class automatically inherits from the Object class.
+
+If you need to use a class name in your code before the class is actually processed by the compiler you can use the following empty class notation to declare that the corresponding constant is actually a class. You can later reopen the class definition and define methods.
+
+```ruby
+class String; end
+```
+
+
 ### Class attributes and instance variables
 Rlang support both the use of class attributes and instance variables. Class attribute declaration is happening through the `attr_accessor`, `attr_reader` or `attr_writer` directives as in plain Ruby. It actually defines a couple of things for you:
 
@@ -100,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
@@ -113,6 +131,8 @@ class Square
   end
 end
 ```
+## Modules
+Modules in Rlang behaves exactly like modules in Ruby. Modules can be included, extended or prepended in other classes and modules. .
 
 ## Object instantiation
 Starting with version 0.4.0, Rlang is equipped with a dynamic memory allocator (see [Rlang library](#the-rlang-library) section). It is therefore capable of allocating objects in a dynamic way at *runtime*. Prior versions were only capable of allocating objects statically at *compile* time.
@@ -130,8 +150,9 @@ class Test
   # ...
 end
 ```
+The address in memory of both class variables and constants can be accessed by using the `addr` method as in `SQUARE.addr` for instance.
 
-**IMPORTANT NOTE**: in the current version of Rlang the new method call used to allocate the object sape doesn't do any initialization. That's why the new method in this context (class body or top level) doesn't accept any parameter
+**IMPORTANT NOTE**: in the current version of Rlang the new method call used to allocate static objects doesn't do any initialization. That's why the new method in this context (class body or top level) doesn't accept any parameter.
 
 ### Dynamic objects
 At any point in the body of method you can dynamically instantiate a new object. Here is an exemple:
@@ -163,7 +184,7 @@ class Main
     cube = Cube.new(10, 20, 30)
     v = cube.volume
     # ... Do what ever you have to do...
-    Object.free(cube)
+    cube.free
   end
 end
 ```
@@ -171,6 +192,11 @@ end
 ## Methods
 Methods in Rlang are defined as you would normally do in Ruby by using the `def` reserved keyword. They can be either class or instance methods.
 
+### Method definition
+A method in Rlang can either be defined in a class, a module or at the top level. In that case the method is implicitely defined within the context of the Object class as Ruby does.
+
+Class methods must be defined using the `def self.mymethod` syntax. The `class << self ... end` form is not supported.
+
 ### Method arguments
 Rlang method definition supports fixed name arguments in any number. The  *args and **args notation are not supported.
 
@@ -204,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.
 
@@ -224,7 +250,9 @@ end
 The `local` directive above instructs the compiler that `lvar` is of type `:I64` and the local variable mysquare is of type `Square`. Without it `lvar` would have been auto-vivified with the Wasm default type or `:I32`.
 
 ### Exporting a method
-In WebAssembly, you can make functions visible to the outside world by declaring them in the export section. To achieve a similar result in Rlang, you can use the `export` keyword right before a method definition. 
+In WebAssembly, you can make functions visible to the outside world by declaring them in the export section. To achieve a similar result in Rlang, you can use the `export` keyword right before a method definition with an optional export name of your choice.
+
+If no function name is specified, Rlang will build it for you. WASM exported functions are named after the class name (in lower case), the method type (class or instance) and the method name. As an example the exported method in the example above will be known to the WASM runtime as the `myclass_c_visible` function (where the `_c_` means it's a class function and `_i_` an instance method).
 
 ```ruby
 class MyClass
@@ -234,31 +262,53 @@ class MyClass
     # ...
   end
 
+  export :seeable
+  def self.visible_too(arg1)
+    # ...
+  end
+
   def self.not_visible
     # ...
   end
 end
 ```
 
-Note that the `export` keyword only applies to the method definition that immediately follows. In the example above `MyClass::m_visible` will be exported by the generated WASM module whereas `MyClass::m_not_visible` will not
+Note that the `export` keyword only applies to the method definition that immediately follows. In the example above `MyClass::visible` and `MyClass::visible_too` will be exported by the generated WASM module whereas `MyClass::not_visible` will not.
+
+### Importing a method
+An import statement in WebAssembly is a way to declare the signature of a method defined outside of the current WebAssembly module and then call it from your code.
+
+Rlang has an equivalent import statement as shown in the example below:
+```ruby
+import :wasi_unstable, :proc_exit
+def self.proc_exit(exitcode)
+  arg exitcode: :I32
+  result :none
+end
+```
+
+The first 2 arguments of import are the imported module name and function name as in WebAssembly and then follows a regular method definition with arguments and possibly the `arg` directive to specify argument types and a `result` directive to indicate the nature of the returned value. Two points worth highlighting here:
+1. The Rlang method name doesn't have to be the same as the function name in the import statement.
+2. As imported function are external to your Rlang module they must be declared as class methods. This is bacause defining them as instance method would automatically pass `self` as the first argument in the method call therefore changing the signature of the method.
+
+The example above is taken from the Rlang WASI class that defines the interface with [WASI (WebAssembly System Interface)](https::wasi.dev).
 
-WASM exported functions are named after the class name (in lower case) followed by an underscore and the method name. So the exported method in the example above is known to the WASM runtime as the `myclass_c_visible` function (where the `_c_` means it's a class function and `_i_` an instance method)
 
 ## 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 self.m_local_var(arg1)
+def m_local_var(arg1)
   arg :arg1, :I64
   lvar = arg1 * 100
   # ....
 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)
@@ -269,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:
 
@@ -285,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.
 
@@ -461,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/examples/fib/fib.rb

@@ -8,4 +8,8 @@ class Math
     end
     return f
   end
-end
+end
+
+def self.main
+  Math.fib(12)
+end

data/lib/builder/rlang/compiler.rb

@@ -17,23 +17,10 @@ module Builder::Rlang
     # WAT source frame
     WAT_FRAME = %q{
 ;; Generated by Rlang compiler version %{version} on %{time}\n"
-(module %{module}
-  (memory $0 %{memory_min} %{memory_max})
 
-  ;; ======= EXPORTS =======
-  (export "memory" (memory $0))
-  %{exports}
+%{code}
 
-  ;; ======= GLOBAL VARIABLES =======
-  %{globals}
-
-  ;; ======= STATIC DATA =======
-  %{data}
-
-  ;; ======= CODE =======
-  %{code}
-)
-    }
+}
 
     # source: Path to Rlang file (.rb)
     # target: Path to Wat file (.wat)
@@ -64,12 +51,6 @@ module Builder::Rlang
       end
       @tf.write(WAT_FRAME % {version: Rlang::VERSION,
                           time: Time.now,
-                          module: @options[:module], 
-                          memory_min: @options[:memory_min],
-                          memory_max: @options[:memory_max],
-                          exports: Rlang::Parser::Export.transpile,
-                          globals: Rlang::Parser::Global.transpile,
-                          data: Rlang::Parser::DAta.transpile,
                           code: @wgenerator.root.transpile
                         })
       @tf.close

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

@@ -0,0 +1,59 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+#
+# 4 bytes object array class
+require_relative '../memory'
+require_relative '../kernel'
+require_relative '../type'
+#require_relative '../string'
+
+
+class Array32
+  attr_reader :count, :ptr
+
+  result :Kernel, :raise, :none
+
+  # count: number of elements in Array
+  # Array elements are native types or
+  # pointers to objects
+  # Arrays are fixed size for now
+  def initialize(count)
+    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 length; @count; end
+  def empty?; @count == 0; end
+
+  def [](idx)
+    result :I32
+    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
+
+  def []=(idx, value)
+    arg value: :I32
+    result :I32
+    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
+  end
+
+  def free
+    result :none
+    Object.free(@ptr)
+    Object.free(self)
+  end
+
+end