rlang 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0e1f5809295de94b29d997b98d712156654bc60621394d0476b5fc048ee70c0
-  data.tar.gz: d35a2adf54dc40514dfa2f966b1ff9d992a11495c3c2c13f927e380be7616fda
+  metadata.gz: 45f6d0c347cfcf901dcd935e2b979098759f2c9b435ff5d900f77a830d5b2101
+  data.tar.gz: 88c0e8f7b79f3cb784f0dd0c85fc10b68427958893f3401998f9866fa9a9b50a
 SHA512:
-  metadata.gz: fcb55360cc77db0bf05466a419f876274f210f3af0ce66af88210f08899e9f45b473efde8657914ea8eb0c1fc32e8816e3c0849b282b22807fce7b297319e5d0
-  data.tar.gz: 9021a72e563ba1608d3fd5208929d619f4324b5274d8506e42e7a8a29d397178dd58254ba78b096fc29b0c16d4acb0ff92343e6e2e49e16c617c959298104080
+  metadata.gz: d6f959bc61a5f4f9548455244662a8b3d9482d9e4670fdb66fd9d5ea1101e062bb93d5fbaffabac5e24852c85058130f92680e76f7d01bbe1745914bee25640b
+  data.tar.gz: 30e4ecce3b01f850fd9515ab614e75d3cd915545b172bab7174872d0d5fab4875a96ade32dac2f1b7a95a3ca0f58ef0ef891544b926ba0e6c23fa38c4cb6fca2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.1
+* Class attributes syntac now identical to plain Ruby
+* Very preliminary version of Rlang String class
+
 ## 0.4.0
 * Object instances, instance methods and instance variables now supported
 * Test suite using parser directly

data/README.md

@@ -2,11 +2,13 @@
 
 Rlang is meant to generate fast and uncluttered [WebAssembly](https://webassembly.org) code from the comfort of the Ruby language.
 
-Rlang is two things: 1) a 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 supported subset of the Ruby language and 2) a **compiler** transforming this Ruby subset in a valid, fully runnable and native WebAssembly module.
 
 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).
 
-What you'll find in the current version is a first implementation of Rlang. It will improve over time, with more facilities and probably more Ruby features but always with the goal to generate 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 mproving over time, always with the goal of generating crisp and uncluttered WAT code.
+
+If you want to help with Rlang see [How you can help](#how-you-can-help).
 
 ## Dependencies
 
@@ -77,6 +79,14 @@ Yes I hear you: Rlang is already the name of the R language so why use that name
 
 The name **Rlang** itself is  a tribute to [Slang](http://wiki.squeak.org/squeak/slang), a subset of the Smalltalk language that can directly translate to C. It was created in 1995 to bootstrap the development of the virtual machine of Squeak, an open-source Smalltalk programming system. I highly encourage anyone interested in the history and the technology of virtual machines to read both the [Back to the future](http://www.vpri.org/pdf/tr1997001_backto.pdf) article as well as the now legendary [Blue Book](http://stephane.ducasse.free.fr/FreeBooks/BlueBook/Bluebook.pdf) explaining how the Smalltalk-80 Virtual Machine and Language were designed in the 80s. I would actually go as far as saying that you don't really know what (virtual) machines are until you have read this book :-)
 
+## How you can help
+* Test Rlang installation on different platforms (Linux, Mac, Windows) and different Ruby versions (Ruby 2.2 and above)
+* Write some real Rlang application code, compile it and test it.
+* Improve the documentation if you find it unclear or want to enrich it with further examples and tips
+* Growing the Rlang library that is still quite basic. For instance you can write the String class or the Array class,...). Just start with the the most popular methods in those classes.
+* If you feel like digging into the Rlang parser and Wasm code generator you can extend it with the support of Floats for instance
+* And of course writing tests for the parts of the code not yet covered is always welcome (running "rake test" also generates code coverage information)
+
 ## Credits
 A big thanks to:
 * [@whitequark](https://github.com/whitequark) for a fantastic [Ruby parser](https://github.com/whitequark/parser)

data/docs/RlangManual.md

@@ -71,46 +71,45 @@ This short piece of code shows several interesting points:
 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 attributes and instance variables
-Rlang support both the use of class attributes and instance variables. Class attribute declaration is happening through the `wattr` directive. I actually defines a couple of things for you:
-1. Define the corresponding accessors both getter and setter (like `attr_accessor` does in Ruby)
-2. Define the corresponding instance variable
+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:
 
-Here is an example showing the definition of a single attribute
+Here is an example showing the definition of a single attribute both in read and write mode.
 ```ruby
 class Square
-  wattr :side
+  attr_accessor :side
 
   def area
-    self.side * self.side
+    @side * @side
   end
 end
 ```
-Later in your code you could use this class in your code as follows
+Later in your code you could 
 
 ```ruby
 class Test
-  @@square = Square.new
 
   def self.my_method
-    @@square.side = 10
-    @@square.area
+    s = Square.new
+    s.side = 10
+    area = square.area
+    perimeter = s.side * 4
   end
 end
 ```
 
-The code is pretty straightforward: a new square instance is created (here it is created statically at compile time), its side attribute is set to 10 and, as you would expect, the call to the Square#area method returns 100.
+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).
 
 ```ruby
 class Square
-  wattr :side
-  wattr_type side: :I64
+  attr_accessor :side
+  attr_type side: :I64
 
   def area
     result :I64
-    self.side * self.side
+    @side * @side
   end
 end
 ```
@@ -119,19 +118,26 @@ end
 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.
 
 ### Static objects
-You have already seen how to perform static objects allocation in one of our previous example. A statement like `@@square = Square.new` appearing in the body of a class definition result in a portion of the WebAssembly memory being statically allocated and initialized at compile time by Rlang and the `@@square` variable points to that particular memory location. Similarly you can also statically instantiate and store an object in a global variable or in a constant like this:
+A statement like `@@square = Square.new` appearing in the body of a class definition result in a portion of the WebAssembly memory being statically allocated at compile time by Rlang. The `@@square` class variable points to that particular memory location. Similarly you can also statically instantiate and store an object in a global variable or in a constant like this:
 
 ```ruby
-SQUARE = Square.new
-$SQUARE = Square.new
+class Test
+  @@square = Square.new
+  SQUARE = Square.new
+  $SQUARE = Square.new
+
+  # Your methods below...
+  # ...
+end
 ```
 
+**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
+
 ### Dynamic objects
 At any point in the body of method you can dynamically instantiate a new object. Here is an exemple:
 
 ```ruby
 class Cube
-  wattr :x, :y, :z
 
   def initialize(x, y, z)
    @x = x; @y = y; @z = z
@@ -141,20 +147,26 @@ class Cube
     @x * @y * @z
   end
 end
+```
+In this example the `Cube` method uses 3 instance variables `@x`, `@y`, `@z`.
+
+Whenever you define a class, Rlang automatically generate the MyClass._size_ class method. Calling this method will tell you how many bytes MyClass objects uses in memory. As an example, a call to `Cube._size_` would return 12 as the 3 instance variables of Cube are of type `I32` using 4 bytes each in memory.
 
+### Garbage collection
+In its current version, Rlang doesn't come with a garbage collector. All dynamically allocated objects must eventually be freed explicitely using the `Object.free` method in your code when objects are no longer needed.
+
+Here is an example building on the Cube class that we just defined:
+```ruby
 class Main
   def self.run
+  # Dynamic allocation of a new Cube
     cube = Cube.new(10, 20, 30)
-    v = cube.volume # would be 6000
-    # ... Do what eveer you have to do...
+    v = cube.volume
+    # ... Do what ever you have to do...
     Object.free(cube)
   end
 end
 ```
-In this example the `Cube` method uses 3 instance variables `@x, @y, @z`. Those instance variables can be accessed through the usual attribute accessors like `Cube#x` and `Cube#x=`. In your code you can also use the `_size_` class method to know how much bytes an object consumes in meory. Here a call to `Cube._size_` would return 12 as each instance variable is an `I32` using 4 bytes each.
-
-### (Lack of) Garbage collection
-In its current version, Rlang doesn't come with a garbage collector. So all dynamically allocated objects must be eventually free'd explicitely using the `Object.free` method in your code when objects are no longer needed.
 
 ## 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.
@@ -199,7 +211,7 @@ Note: in this directive `:method_name` symbol starts with a `#` characters if it
 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.
 
 ### Local variables
-Local variable used in a method body doesn't have to be declared. They are auto-vivified the first time you assign a value to it. In some cases though, you may have to use the `local` directive as in the example below to explicitely state the type of a local variable.
+Local variable used in a method body doesn't have to be explicitely declared. They are auto-vivified the first time you assign a value to it. In some cases though, you may have to use the `local` directive as in the example below to explicitely state the type of a local variable.
 
 ```ruby
 def self.m_local_var(arg1)
@@ -209,7 +221,7 @@ def self.m_local_var(arg1)
   # ....
 end
 ```
-In this example, the `local` directive instructs the compiler that `lvar` is of type `:I64` and the local variable mysquare is of type `Square`.
+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. 
@@ -271,7 +283,7 @@ end
 
 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. In the absence of dynamic object instantiation this allows you to create your own object at runtime by allocating WebAssembly memory and pointing to it as if it was an object of you choice (see Rlang library below for memory management) 
+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`
 
@@ -424,10 +436,10 @@ Here is an example:
 class MyOtherClass
   def self.x10_square(arg1)
     arg1 *= 10
-    inline wat: '(i32.mul 
+    wasm wat: '(i32.mul 
                    (local.get $arg1)
                    (local.get $arg1))',
-           ruby: 'arg1 ** 2'
+         ruby: 'arg1 ** 2'
   end
 end
 ```
@@ -449,7 +461,8 @@ 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.
+* **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 provided with Rlang is quite simple. It is shamelessly adapted from 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).
+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).
 
 That's it! Enjoy Rlang and, as always, feedback and contributions are welcome.

data/lib/rlang/lib.rb

@@ -7,4 +7,5 @@ require_relative './lib/object'
 require_relative './lib/type'
 require_relative './lib/memory'
 require_relative './lib/unistd'
-require_relative './lib/malloc'
+require_relative './lib/malloc'
+require_relative './lib/string'

data/lib/rlang/lib/malloc.rb

@@ -35,8 +35,8 @@ $NALLOC = 1024
 DAta[:dummy_malloc_data] = [0, 0, 0, 0, 0]
 
 class Header
-  wattr :ptr, :size
-  wattr_type ptr: :Header, size: :I32
+  attr_accessor :ptr, :size
+  attr_type ptr: :Header, size: :I32
 end
     
 class Malloc

data/lib/rlang/lib/memory.rb

@@ -1,3 +1,5 @@
+require 'rlang/lib/type'
+
 class Memory
 
   def self.size
@@ -7,5 +9,21 @@ class Memory
   def self.grow(delta)
     inline wat: '(memory.grow (local.get $delta))'
   end
+
+  # Copy memory from source to destination address
+  # TODO: optimize this method using 64 bits copy
+  # first then 32 bits, then 16, then 8 bits
+  def self.copy(src, dest, size)
+    arg src: :I32, dest: :I32
+    result :none
+    idx = 0
+    while idx < size
+      inline wat: '(i32.store8 
+      (i32.add (local.get $dest) (local.get $idx))
+      (i32.load8_u (i32.add (local.get $src) (local.get $idx)))
+      )', wtype: :none
+      idx += 1
+    end
+  end
   
 end

data/lib/rlang/lib/string.rb

@@ -0,0 +1,30 @@
+require_relative './malloc'
+
+class String
+  attr_reader :length, :ptr
+
+  # str is a pointer to a memory 
+  # location of type :String allocated either
+  # statically through a string litteral or
+  # through a dynamic allocation
+  # ptr is a simple memory address of type
+  # :I32 (see it as the equivalent of a
+  # char * in C)
+  def initialize(ptr, length)
+    @ptr = ptr
+    @length = length
+  end
+
+  def +(stg)
+    arg stg: :String
+    result :String
+    new_length = self.length + stg.length
+    # allocate space for concatenated string
+    new_ptr = Malloc.malloc(new_length)
+    Memory.copy(self.ptr, new_ptr, self.length)
+    Memory.copy(stg.ptr, new_ptr + self.length, stg.length)
+    # Create new object string
+    String.new(new_ptr, new_length)
+  end
+
+end

data/lib/rlang/parser.rb

@@ -213,6 +213,9 @@ module Rlang::Parser
       when :false
         wn = parse_false(node, wnode, keep_eval)
 
+      when :str
+        wn = parse_string(node, wnode, keep_eval)
+
       else
         raise "Unknown node type: #{node.type} => #{node}"
       end
@@ -262,13 +265,14 @@ module Rlang::Parser
       parse_node(body_node, wn_class) if body_node
 
       # We finished parsing the class body so
-      # 1) generate the wnodes for the new/initialize function
-      # 2) generate the wnodes for accessing attributes
+      # 1) postprocess instance variables
+      # 2) generate wnodes for the new/initialize function
+      # 2) generate wnodes for attribute accessors
+      @wgenerator.ivars_setup(wn_class)
       @wgenerator.def_initialize(wn_class) # generate **BEFORE** new
       @wgenerator.def_new(wn_class)
-      @wgenerator.def_wattr(wn_class)
-
-      return wn_class
+      @wgenerator.def_attr(wn_class)
+      wn_class
     end
 
     # TODO: the code for op_asgn is quite murky but I thought
@@ -320,9 +324,10 @@ module Rlang::Parser
     #     (int 1)))
     #
     def parse_op_asgn(node, wnode, keep_eval)
-      logger.debug "wnode: #{wnode}, keep_eval: #{keep_eval}"
+      op_asgn_type = node.children.first.type
+      logger.debug "op_asgn on #{op_asgn_type} / wnode: #{wnode}, keep_eval: #{keep_eval}"
 
-      case node.children.first.type
+      case op_asgn_type
       # Global variable case
       when :gvasgn
         var_asgn_node, op, exp_node = *node.children
@@ -336,7 +341,7 @@ module Rlang::Parser
         raise "Unknown global variable #{var_name}" unless gvar
 
         # Create the operator node (infer operator type from variable)
-        wn_op = @wgenerator.operator(wn_var_set, op, gvar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, op, gvar.wtype)
         # Create the var getter node as a child of operator node
         wn_var_get = @wgenerator.gvar(wn_op, gvar)
 
@@ -353,7 +358,7 @@ module Rlang::Parser
         raise "Unknown class variable #{var_name}" unless cvar
 
         # Create the operator node (infer operator type from variable)
-        wn_op = @wgenerator.operator(wn_var_set, op, cvar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, op, cvar.wtype)
         # Create the var getter node as a child of operator node
         wn_var_get = @wgenerator.cvar(wn_op, cvar)
       
@@ -370,7 +375,7 @@ module Rlang::Parser
         raise "Unknown local variable #{var_name}" unless lvar
 
         # Create the operator node (infer operator type from variable)
-        wn_op = @wgenerator.operator(wn_var_set, op, lvar.wtype)
+        wn_op = @wgenerator.send_method(wn_var_set, op, lvar.wtype)
         # Create the var getter node as a child of operator node
         wn_var_get = @wgenerator.lvar(wn_op, lvar)
 
@@ -381,36 +386,31 @@ module Rlang::Parser
       # s(:op_asgn,
       #    s(:ivasgn, :@stack_ptr), :-, s(:lvar, :nbytes))
       when :ivasgn
-        var_asgn_node, op, exp_node = *node.children
+        raise "Instance variable can only be accessed in instance method scope" \
+          unless wnode.in_instance_method_scope?
+        var_asgn_node, operator, exp_node = *node.children
         var_name = var_asgn_node.children.last
 
         # To op_asgn to work, ivar must already be declared
-        wattr = wnode.find_ivar(var_name)
-        raise "Unknown instance variable #{var_name}" unless wattr
-
-        # Instance variable op_asgn case is actually like
-        # the getter/setter case below where the receiver
-        # wnode is self
-        wn_recv = parse_self(node, wnode)
+        ivar = wnode.find_ivar(var_name)
+        raise "Unknown instance variable #{var_name}" unless ivar
 
         # Create the top level variable setter node
-        wn_var_set = @wgenerator.ivasgn(wnode, wn_recv, wattr)
+        wn_var_set = @wgenerator.ivasgn(wnode, ivar)
 
         # Second argument of the setter is the operator wnode
-        # Create it with wtype :none for now. We'll fix that
-        # with the operands call later on
-        wn_op = @wgenerator.operator(wn_var_set, op)
+        # Create it with wtype of receiver by default. We may
+        # change that wtype with the operands call later on
+        wn_op = @wgenerator.send_method(wn_var_set, operator, ivar.wtype)
 
-        # now create the getter node as the first child of the
+        # now create the getter node as a child of the
         # operator
-        wn_var_get = @wgenerator.ivar(wnode, wn_recv, wattr)
+        wn_var_get = @wgenerator.ivar(wn_op, ivar)
 
-        # If the setter returns something and last evaluated value
-        # must be ignored then drop it
-        unless keep_eval && !wn_var_set.wtype.blank?
-          @wgenerator.drop(wnode)
-          #@wgenerator.call(wnode, wn_recv.wtype.name, "#{method_name}", :instance)
-        end
+        # The wasm code for the ivar setter wnode doesn't leave
+        # any value on stack (store instruction). So if the last
+        # evaluated value must be kept then load the ivar again
+        @wgenerator.ivar(wnode, ivar) if keep_eval
 
       # setter/getter case
       # Example (setter/getter)
@@ -437,9 +437,9 @@ module Rlang::Parser
         wn_recv.reparent_to(wn_var_set)
 
         # Second argument of the setter is the operator wnode
-        # Create it with wtype :none for now. We'll fix that
-        # with the operands call later on
-        wn_op = @wgenerator.operator(wn_var_set, op)
+        # Create it with wtype of receiver by default. We may
+        # change that wtype with the operands call later on
+        wn_op = @wgenerator.send_method(wn_var_set, op, wn_recv.wtype)
 
         # Parsing the send node will create the getter wnode
         # this is the first argument of the operator wnode,
@@ -450,7 +450,7 @@ module Rlang::Parser
 
         # If the setter returns something and last evaluated value
         # must be ignored then drop it
-        unless keep_eval && !wn_var_set.wtype.blank?
+        unless (keep_eval || wn_var_set.wtype.blank?)
           @wgenerator.drop(wnode)
           #@wgenerator.call(wnode, wn_recv.wtype.name, "#{method_name}", :instance)
         end
@@ -476,23 +476,54 @@ module Rlang::Parser
     #   (int 2000))
     def parse_casgn(node, wnode, keep_eval)
       class_name_node, constant_name, exp_node = *node.children
-      raise "dynamic constant assignment" unless wnode.in_class_scope?
-      raise "constant initialization can only take a number" unless exp_node.type == :int
-
+#      raise "dynamic constant assignment" unless wnode.in_class_scope?
       unless class_name_node.nil?
         raise "constant assignment with class path not supported (got #{class_name_node})"
       end
-      if wnode.find_const(constant_name)
-        raise "constant #{constant_name} already initialized"
-      end
 
-      # TODO: const are I32 hardcoded for now. Must find a way to 
-      # initialize I64 constant too
-      value = exp_node.children.last
-      const = wnode.create_const(constant_name, nil, value, WType::DEFAULT)
+      if wnode.in_method_scope?
+        # if exp_node is nil then this is the form of 
+        # :casgn that comes from op_asgn
+        if exp_node        
+          if const.nil?
+            # first constant occurence
+            # type cast the constant to the wtype of the expression
+            const = wnode.create_const(constant_name, nil, 0, WType::DEFAULT)
+            wn_casgn = @wgenerator.casgn(wnode, const)
+            wn_exp = parse_node(exp_node, wn_casgn)
+            const.wtype = wn_exp.wtype
+          else
+            # if const already exists then type cast the 
+            # expression to the wtype of the existing const
+            wn_casgn = @wgenerator.casgn(wnode, const)
+            wn_exp = parse_node(exp_node, wn_casgn)
+            @wgenerator.cast(wn_exp, const.wtype, false)
+            logger.warning "Already initialized constant #{const.name}"
+          end
+        else
+          raise "Constant #{const_name} not declared before" unless const
+          wn_casgn = @wgenerator.casgn(wnode, const)
+        end
+        # to mimic Ruby push the constant value on stack if needed
+        @wgenerator.const(wnode, const) if keep_eval
+        return wn_casgn
 
-      wn_casgn = @wgenerator.casgn(wnode, const)
-      return wn_casgn
+      elsif wnode.in_class_scope? || wnode.in_root_scope?
+        # If we are in class scope
+        # then it is a class variable initialization
+        # Parse the expression node to see if it's a ixx.const
+        # in the end but get rid of it then because we are not
+        # executing this code. Just statically initiliazing the 
+        # const with the value
+        wn_exp = parse_node(exp_node, wnode)
+        raise "Constant initializer initializer can only be an int or a constant/class (got #{wn_exp}" \
+          unless wn_exp.const?
+        const = wnode.create_const(constant_name, nil, wn_exp.wargs[:value], wn_exp.wtype)
+        wnode.remove_child(wn_exp)
+        logger.debug "Constant #{constant_name} initialized with value #{const.value} and wtype #{const.wtype}"
+      else
+        raise "Constant can only be defined in method or class scope"
+      end
     end
 
     # Example
@@ -537,7 +568,7 @@ module Rlang::Parser
         # to mimic Ruby push the variable value on stack if needed
         @wgenerator.gvar(wnode, gvar) if keep_eval
         return wn_gvasgn
-      else
+      elsif true #wnode.in_class_scope?
         # If we are at root or in class scope
         # then it is a global variable initialization
         raise "Global op_asgn can only happen in method scope" unless exp_node
@@ -550,7 +581,7 @@ module Rlang::Parser
         # Then remove the generated wnode because it is not for
         # execution. It is just to get the init value
         wn_exp = parse_node(exp_node, wnode)
-        raise "Global initializer can only be a straight number" \
+        raise "Global initializer can only be a int or a constant/class (got #{wn_exp})" \
           unless wn_exp.const?
         wnode.remove_child(wn_exp)
         if gvar
@@ -560,6 +591,8 @@ module Rlang::Parser
         end
         # Do not export global for now
         #gvar.export! if self.config[:export_all]
+      else
+        raise "Global can only be defined in method or class scope"
       end
     end
 
@@ -571,41 +604,35 @@ module Rlang::Parser
     def parse_ivasgn(node, wnode, keep_eval)
       iv_name, exp_node = *node.children
 
-      raise "Instance variable #{iv_name} can only be used in method scope" \
-        unless wnode.in_method_scope? 
-
-      unless (wattr = wnode.find_ivar(iv_name))
-        # first ivar occurence, create it 
-        wattr = wnode.create_ivar(iv_name)
-        new_ivar = true
-      end
-
-      # ivar assignment is like calling the corresponding
-      # setter on self. So create self wnode first
-      wn_recv = parse_self(node, wnode)
-      wn_ivasgn = @wgenerator.ivasgn(wnode, wn_recv, wattr)
+      raise "Instance variable #{iv_name} can only used in instance method scope" \
+        unless wnode.in_instance_method_scope? 
 
-      # Second argument is the expression
-      wn_exp = parse_node(exp_node, wn_ivasgn)
-
-      if new_ivar
-        # type cast the wattr and its ivar to the wtype 
-        # of the expression as this its first occurence
-        logger.debug "Setting new ivar #{wattr.name} wtype to #{wn_exp.wtype.name}"
-        wattr.wtype = wn_exp.wtype
-      else
+      if (ivar = wnode.find_ivar(iv_name))
         # if ivar already exists then type cast the 
         # expression to the wtype of the existing ivar
-        logger.debug "Casting exp. wtype #{wn_exp.wtype} to existing ivar #{wattr.name} wtype #{wattr.wtype}"
-        @wgenerator.cast(wn_exp, wattr.wtype, false)
+        wn_ivasgn = @wgenerator.ivasgn(wnode, ivar)
+        wn_exp = parse_node(exp_node, wn_ivasgn)
+        logger.debug "Casting exp. wtype #{wn_exp.wtype} to existing ivar #{ivar.name} wtype #{ivar.wtype}"
+        @wgenerator.cast(wn_exp, ivar.wtype, false)
+      else
+        # first ivar occurence, create it 
+        ivar = wnode.create_ivar(iv_name)
+        # parse the expression to determine its wtype
+        wn_phony = @wgenerator.phony(wnode)
+        wn_exp = parse_node(exp_node, wn_phony)
+        # the ivar wtype is defined by the
+        # wtype of the expression
+        ivar.wtype = wn_exp.wtype
+        wn_ivasgn = @wgenerator.ivasgn(wnode, ivar)
+        wn_phony.reparent_children_to(wn_ivasgn)
+        logger.debug "Setting new ivar #{ivar.name} wtype to #{wn_exp.wtype.name}"      
       end
 
-      # If the setter returns something and last evaluated value
-      # must be ignored then drop it
-      unless keep_eval && !wn_ivasgn.wtype.blank?
-        @wgenerator.drop(wnode)
-      end
-      return wn_ivasgn
+      # The wasm code for the ivar setter wnode doesn't leave
+      # any value on stack (store instruction). So if the last
+      # evaluated value must be kept then load the ivar again
+      @wgenerator.ivar(wnode, ivar) if keep_eval
+      wn_ivasgn
     end
 
     # Example
@@ -650,13 +677,13 @@ module Rlang::Parser
         # Parse the expression node to see if it's a ixx.const
         # in the end but get rid of it then because we are not
         # executing this code. Just statically initiliazing the 
-        #cvar with the value
+        # cvar with the value
         wn_exp = parse_node(exp_node, wnode)
-        raise "Class variable initializer can only be a straight number (got #{wn_exp}" \
+        raise "Class variable initializer can only be an int or a constant/class (got #{wn_exp}" \
           unless wn_exp.const?
         cvar = wnode.create_cvar(cv_name, wn_exp.wargs[:value], wn_exp.wtype)
         wnode.remove_child(wn_exp)
-        logger.debug "Class variable #{cv_name} initialzed with value #{cvar.value} and wtype #{cvar.wtype}"
+        logger.debug "Class variable #{cv_name} initialized with value #{cvar.value} and wtype #{cvar.wtype}"
       else
         raise "Class variable can only be defined in method or class scope"
       end
@@ -723,18 +750,17 @@ module Rlang::Parser
     # ---
     # ... s(:ivar, :@stack_ptr)
     def parse_ivar(node, wnode, keep_eval)
-      raise "Instance variable can only be accessed in method scope" \
-        unless wnode.in_method_scope?
+      raise "Instance variable can only be accessed in instance method scope" \
+        unless wnode.in_instance_method_scope?
       iv_name, = *node.children
-      if (wattr = wnode.find_ivar(iv_name))
-        wn_recv = parse_self(node, wnode)
-        wn_ivar = @wgenerator.ivar(wnode, wn_recv, wattr)
+      if (ivar = wnode.find_ivar(iv_name))
+        wn_ivar = @wgenerator.ivar(wnode, ivar)
       else
-        raise "unknown instance variable #{cv_name}"
+        raise "unknown instance variable #{ivar_name}"
       end
       # Drop last evaluated result if asked to
       @wgenerator.drop(wnode) unless keep_eval
-      return wn_ivar
+      wn_ivar
     end
 
     # Example
@@ -803,6 +829,29 @@ module Rlang::Parser
       return wn_false
     end
 
+    # Whenever a string literal is used in Rlang
+    # in whatever scope (root, class or method scope)
+    # the string literal must be allocated
+    # statically.
+    # Then if the literal is used in a method scope
+    # we must instantiate a dynamic string object
+    # and copy the initial static value in it
+    def parse_string(node, wnode, keep_eval)
+      string = node.children.last
+      if wnode.in_method_scope?
+        # allocate string dynamically
+        wn_string = @wgenerator.string_dynamic_new(wnode, string)
+      else
+        # allocate string statically
+        wn_string = @wgenerator.string_static_new(wnode, string)
+      end
+      # Drop last evaluated result if asked to
+      @wgenerator.drop(wnode) unless keep_eval
+
+      logger.debug "wn_string:#{wn_string} wtype:#{wn_string.wtype} keep_eval:#{keep_eval}"
+      return wn_string
+    end
+
     # Example
     # TestA::C::MYCONST
     # -------
@@ -1173,15 +1222,8 @@ module Rlang::Parser
 
       # A that stage it's a method call of some sort
       # (call on class or instance)
-      if ARITHMETIC_OPS.include?(method_name) ||
-         RELATIONAL_OPS.include?(method_name) ||
-         UNARY_OPS.include?(method_name)
-        return parse_operator(node, wnode, keep_eval)
-      else
-        return parse_send_method_lookup(node, wnode, keep_eval)
-      end
+      return parse_send_method_lookup(node, wnode, keep_eval)
 
-      raise "FATAL ERROR!! Unreachable point at end of parse_send (node: #{node})"
     end
 
     def parse_send_nil_receiver(node, wnode, keep_eval)
@@ -1214,12 +1256,12 @@ module Rlang::Parser
         return parse_send_result(node, wnode, keep_eval)
       end
 
-      if recv_node.nil? && method_name == :wattr
-        return parse_send_wattr(node, wnode, keep_eval)
+      if recv_node.nil? && method_name.to_s =~ /^attr_(reader|writer|accessor)/
+        return parse_send_attr(node, wnode, keep_eval)
       end
 
-      if recv_node.nil? && method_name == :wattr_type
-        return parse_send_wattr_type(node, wnode, keep_eval)
+      if recv_node.nil? && method_name == :attr_type
+        return parse_send_attr_type(node, wnode, keep_eval)
       end
 
       if recv_node.nil? &&  method_name == :inline
@@ -1366,9 +1408,15 @@ module Rlang::Parser
         # Create class and method objects as we known we'll
         # be calling them later on
         WNode.root.find_or_create_class(cn_name)
-        method_type = (mn_name[0] == '#' ? :instance : :class)
-        (mwn = wnode.find_or_create_method(mn_name, cn_name, nil, method_type)).wtype = WType.new(result_type)
-        logger.debug "result_type #{mwn.wtype} for method #{mwn.name}"
+        if mn_name[0] == '#'
+          method_type = :instance
+          mth_name = mn_name[1..-1].to_sym
+        else
+          method_type = :class
+          mth_name = mn_name.to_sym
+        end
+        (mth = wnode.find_or_create_method(mth_name, cn_name, nil, method_type)).wtype = WType.new(result_type)
+        logger.debug "Declared #{method_type} method #{mth.name} in class #{mth.class_name} with wtype #{mth.wtype.name}"
       else
         raise "result declaration not supported #{wn.scope} scope"
       end
@@ -1380,38 +1428,46 @@ module Rlang::Parser
     # memory with an offset from the base address given as
     # an argument.
     #
+    # xxxxx below can be reader, writer, accessor
+    #
     # Example
-    # wattr :ptr, :size
+    # attr_xxxxx :ptr, :size
     # ---------
-    # s(:send, nil, :wattr,
+    # s(:send, nil, :attr,
     #   s(:sym, :ptr),
     #   s(:sym, :size))
-    def parse_send_wattr(node, wnode, keep_eval)
-      raise "wattr directives can only happen in class scope" \
+    def parse_send_attr(node, wnode, keep_eval)
+      raise "attr directives can only happen in class scope" \
         unless wnode.in_class_scope?
-      wattr_nodes = node.children[2..-1]
-      wattr_nodes.each do |wan|
-        logger.debug "processing wattr node #{wan}"
-        raise "attribute name must be a symbol (got #{wan})" unless wan.type == :sym
-        wattr_name = wan.children.last
-        if (wattr = wnode.find_wattr(wattr_name))
-          raise "attribute #{wattr_name} already declared" if wattr
+      
+      # check accessor directive is valid
+      attr_access = node.children[1].to_s
+      raise "Unknown kind of attribute accessor: #{attr_access}" \
+        unless ['attr_reader', 'attr_writer', 'attr_accessor'].include? attr_access
+      # scan through all attributes
+      attr_nodes = node.children[2..-1]
+      attr_nodes.each do |an|
+        logger.debug "processing attr node #{an}"
+        raise "attribute name must be a symbol (got #{an})" unless an.type == :sym
+        attr_name = an.children.last
+        if (attr = wnode.find_attr(attr_name))
+          raise "attribute #{attr_name} already declared" if attr
         else
-          wattr = wnode.create_wattr(wattr_name)
-          wattr.getter.export! if (@@export || self.config[:export_all])
-          wattr.setter.export! if (@@export || self.config[:export_all])
+          attr = wnode.create_attr(attr_name)
+          attr.export!
         end
+        attr.send(attr_access)
       end
-      return
+      nil
     end
 
     # Directive to specify wasm type of class attributes
     # in case it's not the default type 
     #
     # Example
-    # wattr_type ptr: :I64, size: :I32
+    # attr_type ptr: :I64, size: :I32
     # ---------
-    # s(:send, nil, :wattr_type,
+    # s(:send, nil, :attr_type,
     #   (hash
     #     (pair
     #       s(:sym, :ptr)
@@ -1420,16 +1476,16 @@ module Rlang::Parser
     #       s(:sym, :size)
     #       s(:sym, :I32))   ))
     #
-    def parse_send_wattr_type(node, wnode, keep_eval)
-      raise "wattr directives can only happen in class scope" \
+    def parse_send_attr_type(node, wnode, keep_eval)
+      raise "attr directives can only happen in class scope" \
         unless wnode.in_class_scope?
       hash_node = node.children.last
-      wattr_types = parse_type_args(hash_node, :attribute)
-      wattr_types.each do |name, wtype|
-        if (wattr = wnode.find_wattr(name))
-          logger.debug "Setting wattr #{name} type to #{wtype}"
+      attr_types = parse_type_args(hash_node, :attribute)
+      attr_types.each do |name, wtype|
+        if (attr = wnode.find_attr(name))
+          logger.debug "Setting attr #{name} type to #{wtype}"
           # TODO find a way to update both wtype at once
-          wattr.wtype = wattr.ivar.wtype = WType.new(wtype)
+          attr.wtype = WType.new(wtype)
         else
           raise "Unknown class attribute #{name} in #{wnode}"
         end          
@@ -1477,18 +1533,21 @@ module Rlang::Parser
 
       # Find the :wat entry in hash
       logger.debug "Hash node: #{hash_node} "
-      wat_node = hash_node.children. \
+      wat_node = hash_node.children.\
         find {|pair| sym_node, = *pair.children; sym_node.children.last == :wat}
       raise "inline has no wat: hash entry" unless wat_node
+      logger.debug "inline wat entry: #{wat_node}"
 
       # Find the :wtype entry in hash if any
-      wtype_node = hash_node.children. \
+      wtype_node = hash_node.children.\
         find {|pair| sym_node, = *pair.children; sym_node.children.last == :wtype}
       if wtype_node
         wtype = WType.new(wtype_node.children.last.children.last)
+        logger.debug "inline wtype entry: #{wtype_node}"
       else
         wtype = WType::DEFAULT
       end
+      logger.debug "wtype: #{wtype} "
 
       # Now extract the WAT code itself
       raise "inline has no wat: hash entry" unless wat_node
@@ -1503,72 +1562,15 @@ module Rlang::Parser
       end
       wn_inline = @wgenerator.inline(wnode, wat_code, wtype)
       # Drop last evaluated result if asked to
-      @wgenerator.drop(wnode) unless keep_eval
+      @wgenerator.drop(wnode) unless (keep_eval || wtype.blank?)
       return wn_inline
     end
 
-    # If receiver not self or const then it could
-    # be an arithmetic or relational expression
-    # a method call on class "instance"
-    #
-    # Example for binary op
-    # 1 + 2
-    # ----------
-    # (send
-    #   (int 1) :+
-    #   (int 2)
-    # )
-    #
-    # Example unary op
-    # !(n==1)
-    # ----------
-    # (send
-    #   (begin
-    #     (send (lvar :n) :== (int 1))
-    #  ) :!)
-    #
-    def parse_operator(node, wnode, keep_eval)
-      recv_node = node.children[0]
-      operator = node.children[1]
-      wn_op = @wgenerator.operator(wnode, operator)
-      wn_recv = parse_node(recv_node, wn_op, true)
-      # now process the 2nd op arguments (there should
-      # be only one but do as if we had several
-      arg_nodes = node.children[2..-1]
-      raise "method #{operator} got #{arg_nodes.count} arguments (expected 0 or 1)" \
-        unless arg_nodes.count <= 1
-      wn_args = arg_nodes.collect {|n| parse_node(n, wn_op, true)}
-      @wgenerator.operands(wn_op, wn_recv, wn_args)
-      logger.debug "  After type cast:  #{wn_op} wtype: #{wn_op.wtype}, op children types: #{wn_op.children.map(&:wtype)}"
-      # Drop last evaluated result if asked to
-      @wgenerator.drop(wnode) unless keep_eval
-      return wn_op
-    end
-
-    # Method lookup
-    # In the example below mem_size wasn' t 
-    # recognized as a local var because it was not 
-    # assigned a value before. It's recognized as
-    # a tentative method call
-    # Example
-    #  some_var = mem_size + 10
-    # ------
-    # (send
-    #   (send nil :mem_size) :+
-    #   (int 10))
-    #  
-    #
-    # Example for method call on class instance
-    # @@cvar.x = 100
-    # ----------
-    # (send
-    #   (cvar :@@cvar) :x= (int 100)
-    # )
-    # TODO must guess type arg from operator type
+    # Determine whether it's an instance or class method call
     def parse_send_method_lookup(node, wnode, keep_eval)
       recv_node = node.children[0]
       #method_name = node.children[1]
-      if wnode.in_class_scope? || wnode.in_class_method_scope?
+      if wnode.in_class_scope? || wnode.in_class_method_scope? || wnode.in_root_scope?
         if recv_node.nil? || recv_node.type == :self 
           return parse_send_class_method_call(node, wnode, keep_eval)
         elsif recv_node.type == :const
@@ -1585,10 +1587,10 @@ module Rlang::Parser
         end
       elsif wnode.in_instance_method_scope?
         if recv_node&.type == :const
-          const_name = recv_node.children.last
+          recv_name = recv_node.children.last
           # if this is a Constant, not a class
           # then it's actually an instance method call
-          if wnode.find_const(const_name)
+          if wnode.find_const(recv_name)
             return parse_send_instance_method_call(node, wnode, keep_eval)
           else
             return parse_send_class_method_call(node, wnode, keep_eval)
@@ -1647,7 +1649,7 @@ module Rlang::Parser
         raise "Can only call method class on self or class objects (got #{recv_node} in node #{node})"
       end
       logger.debug "...#{class_name}::#{method_name}"
-      if method_name == :new && wnode.in_class_scope?
+      if method_name == :new && (wnode.in_class_scope? || wnode.in_root_scope?)
         # This is class object instantiation. Statically 
         # allocated though. So it can only happen in the
         # class scope for a class variable or a constant
@@ -1666,33 +1668,88 @@ module Rlang::Parser
       raise "FATAL ERROR!! Unreachable point at end of parse_send_class_method_call (node: #{node})"
     end
 
+    # Instance Method lookup and native operator
+    #
+    # In the example below mem_size would be
+    # recognized as a local var because it was not 
+    # assigned a value before. It's recognized as
+    # a tentative method call
+    # Example
+    #  some_var = mem_size + 10
+    # ------
+    # (send
+    #   (send nil :mem_size) :+
+    #   (int 10))
+    #
+    # Example for method call on class instance
+    # @@cvar.x = 100
+    # ----------
+    # (send
+    #   (cvar :@@cvar) :x= (int 100)
+    # )
+    # 
+    # If receiver not self or const then it could
+    # be an arithmetic or relational operator or
+    # an operato overloaded in the related class
+    #
+    # Example for binary op
+    # 1 + 2
+    # ----------
+    # (send
+    #   (int 1) :+
+    #   (int 2)
+    # )
+    #
+    # Example unary op
+    # !(n==1)
+    # ----------
+    # (send
+    #   (begin
+    #     (send (lvar :n) :== (int 1))
+    #  ) :!)
+    #
     def parse_send_instance_method_call(node, wnode, keep_eval)
       recv_node = node.children[0]
       method_name = node.children[1]
       # Parse receiver node and temporarily attach it
       # to parent wnode. It will later become the first
       # argument of the method call by reparenting it
-      logger.debug "Parsing instance method call #{method_name}..."
-      # parse the receiver node
+      logger.debug "Parsing instance method call #{method_name}, keep_eval: #{keep_eval}..."
+      logger.debug "... on receiver #{recv_node}..."
+
+      # parse the receiver node just to know its wtype
       # if nil it means self
-      wn_recv = recv_node.nil? ? parse_self(recv_node, wnode) : parse_node(recv_node, wnode)
-      logger.debug "... on #{wn_recv}"
-      class_name = wn_recv.wtype.name
+      wn_phony = @wgenerator.phony(wnode)
+
+      wn_recv = recv_node.nil? ? parse_self(recv_node, wn_phony) : parse_node(recv_node, wn_phony)
+      logger.debug "Parsed receiver : #{wn_recv} / wtype: #{wn_recv.wtype}"
 
-      wn_call = @wgenerator.call(wnode, class_name, method_name, :instance)
-      wn_recv.reparent_to(wn_call) if wn_recv
+      # If it's a Wasm natively supported operator and it
+      # is not overloaded by the receiver's class
+      # then generate native operator Wasm code instead of
+      # a method call
+      wn_op = @wgenerator.send_method(wnode, method_name, wn_recv.wtype)
+
+      # reparent the receiver wnode(s) to operator wnode
+      wn_phony.reparent_children_to(wn_op)
+      wnode.remove_child(wn_phony)
 
       # Grab all arguments and add them as child of the call node
       arg_nodes = node.children[2..-1]
-      arg_nodes.each do |node| 
-        wn = parse_node(node, wn_call) 
-        logger.debug "...with arg #{wn}"
+      wn_args = arg_nodes.collect do |n| 
+        logger.debug "...with arg #{n}"
+        parse_node(n, wn_op, true)
       end
-      logger.debug "Resulting in call node #{wn_call}"
+
+      # now cast operands (will do nothing if it's a method call)
+      @wgenerator.operands(wn_op, wn_recv, wn_args)
+      logger.debug "After operands, call wnode: #{wn_op} wtype: #{wn_op.wtype}, wn_op children types: #{wn_op.children.map(&:wtype)}"
+
       # Drop last evaluated result if asked to or if
       # the method called doesn't return any value
-      @wgenerator.drop(wnode) unless (keep_eval || wn_call.wtype.blank?)
-      return wn_call
+      @wgenerator.drop(wnode) unless (keep_eval || wn_op.wtype.blank?)
+
+      return wn_op
     end
 
     def parse_type_args(hash_node, entity)
@@ -1966,7 +2023,7 @@ module Rlang::Parser
       logger.debug "logical operator section : #{node.type}"
       cond1_node, cond2_node = *node.children
       # Prepare the operator wnode
-      wn_op = @wgenerator.operator(wnode, node.type)
+      wn_op = @wgenerator.native_operator(wnode, node.type)
       # Parse operand nodes and attach them to the
       # operator wnode
       wn_cond1 = parse_node(cond1_node, wn_op)