rlang 0.4.1 → 0.6.0

data/lib/rlang/parser/wgenerator.rb

@@ -12,6 +12,9 @@
 
 require_relative '../../utils/log'
 require_relative './wnode'
+require_relative './klass'
+require_relative './module'
+require_relative './module'
 
 module Rlang::Parser
 
@@ -19,26 +22,29 @@ module Rlang::Parser
     :+  => :add,
     :-  => :sub,
     :*  => :mul,
-    :/  => :div_u,
-    :%  => :rem_u,
     :&  => :and,
     :|  => :or,
     :^  => :xor,
-    :>> => :shr_u,
     :<< => :shl
   }
 
+  ARITHMETIC_SIGNED_OPS_MAP = {
+    :/  => :div_x,
+    :%  => :rem_x,
+    :>> => :shr_x
+  }
+
   RELATIONAL_OPS_MAP = {
     :==    => :eq,
     :!=    => :ne,
-    :'<s'  => :lt_s,
-    :<     => :lt_u,
-    :'>s'  => :gt_s,
-    :>     => :gt_u,
-    :'<=s' => :le_s,
-    :<=    => :le_u,
-    :'>=s' => :ge_s,
-    :>=    => :ge_u
+
+  }
+
+  RELATIONAL_SIGNED_OPS_MAP = {
+    :<     => :lt_x,
+    :>     => :gt_x,
+    :<=    => :le_x,
+    :>=    => :ge_x
   }
 
   BOOLEAN_OPS_MAP = {
@@ -47,19 +53,40 @@ module Rlang::Parser
   }
 
   UNARY_OPS_MAP = {
-    :'!'   => :eqz
+    :'!'   => :eqz,
+    :'-@'  => :sub  # special case for unary - turned into (sub 0 x)
   }
 
-  ALL_OPS_MAP = [*ARITHMETIC_OPS_MAP, *RELATIONAL_OPS_MAP, *BOOLEAN_OPS_MAP, *UNARY_OPS_MAP].to_h
+  SIGNED_OPS = {
+    signed: {div_x: :div_s, rem_x: :rem_s, shr_x: :shr_s, lt_x: :lt_s, gt_x: :gt_s,
+      le_x: :le_s, ge_x: :ge_s},
+    unsigned: {div_x: :div_u, rem_x: :rem_u, shr_x: :shr_u, lt_x: :lt_u, gt_x: :gt_u,
+        le_x: :le_u, ge_x: :ge_u},
+  }
+
+  # Operators that can be legally used when doing
+  # arithmetic on class instance (= object) pointers
+  # Only unsigned relational operators make sense as pointers
+  # are by nature unsigned integers
+  LEGAL_CLASS_WASM_OPS = [:eq, :ne, :lt_u, :gt_u, :le_u, :ge_u, :add, :sub]
+
+  # All operators with signed / unsigned variants
+  ALL_SIGNED_OPS_MAP = [*ARITHMETIC_SIGNED_OPS_MAP, *RELATIONAL_SIGNED_OPS_MAP].to_h
+
+  # All operators in on hash
+  ALL_OPS_MAP = [*ARITHMETIC_OPS_MAP, *ARITHMETIC_SIGNED_OPS_MAP, *RELATIONAL_OPS_MAP, *RELATIONAL_SIGNED_OPS_MAP,
+                 *BOOLEAN_OPS_MAP, *UNARY_OPS_MAP].to_h
 
   # Matrix of how to cast a WASM type to another
   CAST_OPS = {
-    I32: { I32: :cast_nope, I64: :cast_extend, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_wtype, none: :cast_error},
-    I64: { I32: :cast_wrap, I64: :cast_nope, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
-    F32: { I32: :cast_notyet, I64: :cast_notyet, F32: :cast_nope, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
-    F64: { I32: :cast_notyet, I64: :cast_notyet, F32: :cast_notyet, F64: :cast_nope, Class: :cast_error, none: :cast_error},    
-    Class: { I32: :cast_wtype, I64: :cast_extend, F32: :cast_error, F64: :cast_error, Class: :cast_wtype, none: :cast_error},
-    none: { I32: :cast_error, I64: :cast_error, F32: :cast_error, F64: :cast_error, Class: :cast_error, none: :cast_error},
+    UI32:  { UI32: :cast_nope,   I32: :cast_wtype,  UI64: :cast_extend, I64: :cast_extend, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_wtype, none: :cast_error},
+    I32:   { UI32: :cast_wtype,  I32: :cast_nope,   UI64: :cast_extend, I64: :cast_extend, F32: :cast_notyet, F64: :cast_notyet, Class: :cast_wtype, none: :cast_error},
+    UI64:  { UI32: :cast_wrap,   I32: :cast_wrap,   UI64: :cast_nope,   I64: :cast_wtype,  F32: :cast_notyet, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
+    I64:   { UI32: :cast_wrap,   I32: :cast_wrap,   UI64: :cast_wtype,   I64: :cast_nope,   F32: :cast_notyet, F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
+    F32:   { UI32: :cast_notyet, I32: :cast_notyet, UI64: :cast_notyet, I64: :cast_notyet, F32: :cast_nope,   F64: :cast_notyet, Class: :cast_error, none: :cast_error},    
+    F64:   { UI32: :cast_notyet, I32: :cast_notyet, UI64: :cast_notyet, I64: :cast_notyet, F32: :cast_notyet, F64: :cast_nope,   Class: :cast_error, none: :cast_error},    
+    Class: { UI32: :cast_wtype,  I32: :cast_wtype,  UI64: :cast_extend, I64: :cast_extend, F32: :cast_error,  F64: :cast_error,  Class: :cast_wtype, none: :cast_error},
+    none:  { UI32: :cast_error,  I32: :cast_error,  UI64: :cast_error,  I64: :cast_error,  F32: :cast_error,  F64: :cast_error,  Class: :cast_error, none: :cast_error},
   }
 
   # Rlang class size method name
@@ -67,10 +94,10 @@ module Rlang::Parser
 
   # new template when object size > 0
   NEW_TMPL = %q{
-  result :Object, :alloc, :%{default_wtype}
+  result :Object, :allocate, :%{default_wtype}
   def self.new(%{margs})
-    result :%{class_name}
-    object_ptr = Object.alloc(%{class_name}._size_).cast_to(:%{class_name})
+    result :"%{class_name}"
+    object_ptr = Object.allocate(%{class_name}._size_).cast_to(:"%{class_name}")
     object_ptr.initialize(%{margs})
     return object_ptr
   end
@@ -80,14 +107,13 @@ module Rlang::Parser
   # use 0 as the _self_ address in memory. It should never
   # be used anyway
   NEW_ZERO_TMPL = %q{
-    result :Object, :alloc, :%{default_wtype}
-    def self.new(%{margs})
-      result :%{class_name}
-      object_ptr = 0.cast_to(:%{class_name})
-      object_ptr.initialize(%{margs})
-      return object_ptr
-    end
-    }
+  def self.new(%{margs})
+    result :"%{class_name}"
+    object_ptr = 0.cast_to(:"%{class_name}")
+    object_ptr.initialize(%{margs})
+    return object_ptr
+  end
+  }
 
   # Do nothing initialize method
   DUMB_INIT_TMPL = %q{
@@ -101,6 +127,11 @@ module Rlang::Parser
     String.new(%{ptr}, %{length})
   }
 
+  # Dynamically allocate a string object
+  ARRAY_NEW_TMPL = %q{
+    Array%{elt_size_in_bits}.new(%{ptr}, %{length})
+  }
+
   # Generate the wasm nodes and tree structure
   # ***IMPORTANT NOTE***
   # Unless otherwise stated all methods receive
@@ -110,25 +141,157 @@ module Rlang::Parser
   class WGenerator
     include Log
     attr_accessor :parser
-    attr_reader :root
+    attr_reader :root, :wn_imports, :wn_exports, :wn_globals, :wn_data, :wn_code
 
     def initialize(parser)
       @parser = parser
       @root = WTree.new().root
       @new_count = 0
       @static_count = 0
-    end
 
-    def klass(wnode, class_name)
+      # Create section wnodes
+      @wn_imports = WNode.new(:imports, @root)
+      @wn_memory  = WNode.new(:memory, @root)
+      @wn_exports = WNode.new(:exports, @root)
+      @wn_globals = WNode.new(:globals, @root)
+      @wn_data = WNode.new(:data, @root)
+
+      # Module code generation
+      @root.c(:module, module: parser.config[:module])
+
+      # Memory code generation
+      WNode.new(:insn, @wn_memory). \
+        c(:memory, min: parser.config[:memory_min], max: parser.config[:memory_max])
+
+      # define Object class and Kernel modules
+      # and include Kernel in Object
+      wn_object_class = self.klass(@root, [:Object], [])
+      @object_class = wn_object_class.klass
+      @root.klass = @object_class
+      wn_kernel_module = self.module(@root, [:Kernel])
+      self.include(wn_object_class, [:Kernel])
+
+      # Create Class and Module classes
+      # And Class inherits from module
+      self.klass(@root, [:Module], [:Object])
+      self.klass(@root, [:Class], [:Module])
+    end
+
+    # Create class and its basic methods (new, initialize and _size_)
+    def klass(wnode, class_path, super_class_path)
+      logger.debug "Defining klass #{class_path} < #{super_class_path}"
+      # See if class already created
+      if (k = wnode.find_class_or_module(class_path))
+        return k.wnode
+      end
+
+      # Make sure super class is known like Ruby does
+      if super_class_path.empty?
+        # special case to bootstrap Object class
+        if (class_path == [:Object] && wnode.in_root_scope?)
+          sk = nil
+        else
+          sk = @object_class
+          super_class_path << sk.path_name
+        end
+      else
+        sk = wnode.find_class_or_module(super_class_path)
+        raise "Unknown super class #{super_class_path}" unless sk
+      end
       # Create class object and class wnode if it doesn't exist yet
-      k = wnode.find_or_create_class(class_name)
-      # Create the Class.new method object too (not 
-      # the code yet in case the end user code defines
-      # its own implementation in the class body)
-      k.wnode.find_or_create_method(:new, k.name, k.wtype, :class)     
+      # only one level deep class for now so scope class is always
+      # Object class
+      if (class_path == [:Object] && wnode.in_root_scope?)
+        k = wnode.create_class(class_path, super_class_path)
+      else
+        k = wnode.find_or_create_class(class_path, super_class_path)
+      end
+      # make sure the super class is correct in case class
+      # was previously declared in a result directive where
+      # no super class can be specified
+      k.super_class = sk if sk
+      # Create methods Class::new, Class#initialize and Class::_size_
+      # (do not generate the code yet as the end user code may 
+      # define its own implementation in the class body)
+      k.wnode.find_or_create_method(k, :new, :class, k.wtype, true)
+      k.wnode.find_or_create_method(k, :_size_, :class, WType::DEFAULT, true)    
+      k.wnode.find_or_create_method(k, :initialize, :instance, WType.new(:none), true)    
       k.wnode
     end
 
+    def comments(wnode, comments)
+      # The gsub below is to handle =begin...=end block comments
+      comments.each do |c|
+        WNode.new(:comment, wnode).c(:comment, text: c.text.sub(/^\s*#/,'').gsub("\n", "\n;;"))
+      end
+    end
+
+    # Create module object and module wnode 
+    # if it doesn't exist yet
+    def module(wnode, module_path)
+      m = wnode.find_or_create_module(module_path)
+      m.wnode
+    end
+
+    def include(wnode, module_path)
+      m = wnode.find_module(module_path)
+      raise "Unknown module #{module_path}. Please require module first." \
+        unless m
+      wnc = wnode.class_or_module_wnode
+      raise "Cannot find scope class/module for included module!!" unless wnc
+      wnc.klass.include(m) 
+      m.included!
+      wnc
+    end
+
+    def prepend(wnode, module_path)
+      m = wnode.find_module(module_path)
+      raise "Unknown module #{module_path}. Please require module first." \
+        unless m
+      wnc = wnode.class_or_module_wnode
+      raise "Cannot find scope class/module for prepended module!!" unless wnc
+      wnc.klass.prepend(m) 
+      m.prepended!
+      wnc
+    end
+
+    def extend(wnode, module_path)
+      m = wnode.find_module(module_path)
+      raise "Cannot find module #{module_path}. Please require module first." \
+        unless m
+      wnc = wnode.class_or_module_wnode
+      raise "Cannot find scope class/module for included module!!" unless wnc
+      wnc.klass.extend(m)
+      m.extended!
+      wnc
+    end
+
+    # Ahead of time method declaration and return type
+    # Create corresponding classes and method objects as we known we'll
+    # be calling them later on
+    def declare_method(wnode, wtype, method_name, result_type)
+      class_path = wtype.class_path
+      logger.debug "Declaring method #{method_name} in class #{class_path}"
+      klass = WNode.root.find_class_or_module(class_path)
+      raise "Can't find class or module #{class_path} in method declaration" unless klass
+      method_types = []
+      if method_name[0] == '#'
+        method_types << :instance
+        method_types << :class if klass.const.module?
+        mth_name = method_name[1..-1].to_sym
+      else
+        method_types << :class
+        method_types << :instance if klass.const.module?
+        mth_name = method_name.to_sym
+      end
+      mth = method_types.each do |mt|
+        (m = wnode.find_or_create_method(klass, mth_name, mt, nil)).wtype = WType.new(result_type)
+        logger.debug "Declared #{mt} method #{m.name} in class #{m.klass.name} with wtype #{m.wtype.name}"
+        m
+      end
+      mth
+    end
+  
     # Postprocess ivars
     # (called at end of class parsing)
     def ivars_setup(wnode)
@@ -147,11 +310,12 @@ module Rlang::Parser
     # generate code for class attributes
     # (called at end of class parsing)
     def def_attr(wnode)
-      wnc = wnode.class_wnode
+      klass = wnode.find_current_class_or_module()
+      wnc = klass.wnode
       raise "Cannot find class for attributes definition!!" unless wnc
       # Process each declared class attribute
-      wnc.klass.attrs.each do |attr|
-        logger.debug("Generating accessors for attribute #{wnc.klass.name}\##{attr.name}")
+      klass.attrs.each do |attr|
+        logger.debug("Generating accessors for attribute #{klass.name}\##{attr.name}")
         # Generate getter and setter methods wnode
         # unless method already implemented by user
         if attr.setter
@@ -173,13 +337,13 @@ module Rlang::Parser
       # Also generate the Class::_size_ method
       # (needed for dynamic memory allocation
       #  by Object.allocate)
-      size_method = wnc.find_or_create_method(SIZE_METHOD, wnc.klass.name, WType::DEFAULT, :class)
+      size_method = wnc.find_or_create_method(klass, SIZE_METHOD, :class, WType::DEFAULT)
       unless size_method.wnode
-        logger.debug("Generating #{size_method.class_name}\##{size_method.name}")
-        wns = WNode.new(:insn, wnc, true)
-        wns.wtype = WType::DEFAULT 
+        logger.debug("Generating #{size_method.klass.name}\##{size_method.name}")
+        wns = WNode.new(:insn, wnc)
+        wns.wtype = WType::DEFAULT
         wns.c(:class_size, func_name: size_method.wasm_name, 
-              wtype: wns.wasm_type, size: wnc.class_size)
+              wasm_type: wns.wasm_type, size: wnc.class_size)
         size_method.wnode = wns
       end
     end
@@ -189,7 +353,7 @@ module Rlang::Parser
       wnc = wnode.class_wnode
       wn_set = WNode.new(:insn, wnc, true)
       wn_set.c(:attr_setter, func_name: attr.setter.wasm_name, 
-            attr_name: attr.wasm_name, wtype: attr.wasm_type,
+            attr_name: attr.wasm_name, wasm_type: attr.wasm_type,
             offset: attr.offset)
       wn_set
     end
@@ -199,34 +363,50 @@ module Rlang::Parser
       wnc = wnode.class_wnode
       wn_get = WNode.new(:insn, wnc, true)
       wn_get.c(:attr_getter, func_name: attr.getter.wasm_name, 
-            attr_name: attr.wasm_name, wtype: attr.wasm_type,
-            offset: attr.offset)
+            wasm_type: attr.wasm_type, offset: attr.offset)
       wn_get
     end
 
-    def instance_method(wnode, method)
-      logger.debug("Generating wnode for instance method #{method.inspect}")
+    def def_method(wnode, method_name, method_type)
+      logger.debug("Defining #{method_type} method #{method_name}...")
+      if (method = wnode.find_method(nil, method_name, method_type, true))
+        logger.warn "Redefining #{method.klass.name},#{method_name}" if method.wnode
+      else
+        method = wnode.create_method(nil, method_name, method_type, nil, true)
+      end
+
+      # If it's the main method, give it the proper name in export if
+      # specified on command line
+      if method.klass.path_name == :Object && method.name == :main
+        method.export_name = @parser.config[:start]
+      end
+
+      # Generate method definition wnode
+      logger.debug("Generating wnode for #{method_type} method #{method_name}")
       wn = WNode.new(:method, wnode)
       method.wnode = wn
-      wn.method = method # must be set before calling func_name
       wn.wtype = method.wtype
       wn.c(:func, func_name: wn.method.wasm_name)
-      # Also declare a "hidden" parameter representing the
-      # pointer to the instance (always default wtype)
-      wn.create_marg(:_self_)
-      logger.debug("Building instance method: wn.wtype #{wn.wtype}, wn.method #{wn.method}")
+
+      # Instance methods 1st argument is always self
+      wn.create_marg(:_self_) if method.instance?
+      logger.debug("Built #{method_type} method definition: wn.wtype #{wn.wtype}, wn.method #{wn.method}")
       wn
     end
 
-    def class_method(wnode, method)
-      logger.debug("Generating wnode for class method #{method}")
-      wn = WNode.new(:method, wnode)
-      method.wnode = wn
-      wn.method = method # must be set before calling func_name
-      wn.wtype = method.wtype
-      wn.c(:func, func_name: wn.method.wasm_name)
-      logger.debug("Building class method: wn.wtype #{wn.wtype}, wn.method #{wn.method}")
-      wn
+    def import_method(wnode, module_name, function_name)
+      # Create the import node
+      (wn_import = WNode.new(:insn, self.wn_imports)).c(:import, module_name: module_name, function_name: function_name)
+      wn_import.link = wnode
+      wnode.method.imported!
+      # now silence the method wnode so that
+      # it doesn't generate WASM code in the code section
+      wnode.silence!
+      wn_import
+    end
+
+    def export_method(wnode, export_name)
+      wnode.method.export!(export_name)
     end
 
     def params(wnode)
@@ -236,7 +416,7 @@ module Rlang::Parser
         logger.debug("Prepending param #{marg}")
         wn = WNode.new(:insn, wnm, true)
         wn.wtype = marg.wtype
-        wn.c(:param, name: marg.wasm_name)
+        wn.c(:param, name: marg.wasm_name, wasm_type: wn.wasm_type)
       end
     end
 
@@ -244,7 +424,7 @@ module Rlang::Parser
       unless wnode.wtype.blank?
         wn = WNode.new(:insn, wnode, true)
         wn.wtype = wnode.wtype
-        wn.c(:result)      
+        wn.c(:result, wasm_type: wn.wasm_type)      
       end
     end
 
@@ -254,7 +434,7 @@ module Rlang::Parser
         logger.debug("Prepending local #{lvar.inspect}")
         wn = WNode.new(:insn, wnm, true)
         wn.wtype = lvar.wtype
-        wn.c(:local, name: lvar.wasm_name)
+        wn.c(:local, name: lvar.wasm_name, wasm_type: wn.wasm_type)
       end
     end
 
@@ -268,19 +448,26 @@ module Rlang::Parser
     # Set constant
     def casgn(wnode, const)
       (wn = WNode.new(:insn, wnode)).wtype = const.wtype
-      wn.c(:store, wtype: const.wtype)
+      wn.c(:store, wasm_type: const.wtype)
       WNode.new(:insn, wn).c(:addr, value: const.address)
       wn
     end
 
-    # Get class variable
+    # Get constant
     def const(wnode, const)
       (wn = WNode.new(:insn, wnode)).wtype = const.wtype
-      wn.c(:load, wtype: const.wtype, var_name: const.wasm_name)
+      wn.c(:load, wasm_type: const.wasm_type)
       WNode.new(:insn, wn).c(:addr, value: const.address)
       wn
     end
 
+    # Get constant addres
+    def const_addr(wnode, const)
+      (wn = WNode.new(:insn, wnode)).wtype = const.wtype
+      wn.c(:addr, value: const.address)
+      wn
+    end
+
     # Set Global variable
     def gvasgn(wnode, gvar)
       (wn = WNode.new(:insn, wnode)).wtype = gvar.wtype
@@ -298,7 +485,7 @@ module Rlang::Parser
     # Call setter (on attr or instance variable)
     # This is the same as calling the corresponding setter
     def call_setter(wnode, wnode_recv, attr)
-      wn = self.call(wnode, wnode_recv.wtype.name, attr.setter_name, :instance)
+      wn = self.send_method(wnode, wnode_recv.wtype, attr.setter_name, :instance)
       # First argument of the setter must be the receiver
       wnode_recv.reparent_to(wn)
       wn
@@ -307,7 +494,7 @@ module Rlang::Parser
     # Call getter (on attr or instance variable)
     # This is the same as calling the corresponding getter
     def call_getter(wnode, wnode_recv, attr)
-      wn = self.call(wnode, wnode_recv.wtype.name, attr.getter_name, :instance)
+      wn = self.send_method(wnode, wnode_recv.wtype, attr.getter_name, :instance)
       # First argument of the getter must always be the receiver
       wnode_recv.reparent_to(wn)
       wn
@@ -316,7 +503,7 @@ module Rlang::Parser
     # Set instance variable
     def ivasgn(wnode, ivar)
       (wn = WNode.new(:insn, wnode)).wtype = ivar.wtype
-      wn.c(:store_offset, wtype: ivar.wasm_type, offset: lambda { ivar.offset })
+      wn.c(:store_offset, wasm_type: ivar.wasm_type, offset: lambda { ivar.offset })
       self._self_(wn)
       wn
     end
@@ -324,7 +511,7 @@ module Rlang::Parser
     # Get instance variable. 
     def ivar(wnode, ivar)
       (wn = WNode.new(:insn, wnode)).wtype = ivar.wtype
-      wn.c(:load_offset, wtype: ivar.wasm_type, offset: lambda { ivar.offset })
+      wn.c(:load_offset, wasm_type: ivar.wasm_type, offset: lambda { ivar.offset })
       self._self_(wn)
       wn
     end
@@ -334,7 +521,7 @@ module Rlang::Parser
     # an empty expression node to populate later
     def cvasgn(wnode, cvar)
       (wn = WNode.new(:insn, wnode)).wtype = cvar.wtype
-      wn.c(:store, wtype: cvar.wtype)
+      wn.c(:store, wasm_type: cvar.wasm_type)
       WNode.new(:insn, wn).c(:addr, value: cvar.address)
       wn
     end
@@ -342,22 +529,30 @@ module Rlang::Parser
     # Get class variable
     def cvar(wnode, cvar)
       (wn = WNode.new(:insn, wnode)).wtype = cvar.wtype
-      wn.c(:load, wtype: cvar.wtype, var_name: cvar.wasm_name)
+      wn.c(:load, wasm_type: cvar.wasm_type)
       WNode.new(:insn, wn).c(:addr, value: cvar.address)
       wn
     end
 
+
+    # Get class variable address
+    def cvar_addr(wnode, cvar)
+      (wn = WNode.new(:insn, wnode)).wtype = cvar.wtype
+      wn.c(:addr, value: cvar.address)
+      wn
+    end
+
     # Create the local variable storage node 
     def lvasgn(wnode, lvar)
       (wn = WNode.new(:insn, wnode)).wtype = lvar.wtype
-      wn.c(:local_set, wtype: lvar.wtype, var_name: lvar.wasm_name)
+      wn.c(:local_set, var_name: lvar.wasm_name)
       wn
     end
 
     # Read local variable
     def lvar(wnode, lvar)
       (wn = WNode.new(:insn, wnode)).wtype = lvar.wtype
-      wn.c(:local_get, wtype: lvar.wtype, var_name: lvar.wasm_name)
+      wn.c(:local_get, var_name: lvar.wasm_name)
       wn
     end
 
@@ -374,42 +569,42 @@ module Rlang::Parser
 
     def int(wnode, wtype, value)
       (wn = WNode.new(:insn, wnode)).wtype = wtype
-      wn.c(:const, wtype: wtype, value: value)
+      wn.c(:const, wasm_type: wn.wasm_type, value: value)
       wn
     end
 
     def float(wnode, wtype, value)
       (wn = WNode.new(:insn, wnode)).wtype = wtype
-      wn.c(:const, wtype: wtype, value: value)
+      wn.c(:const, wasm_type: wn.wasm_type, value: value)
       wn
     end
 
     # Generate a phony node (generally used to create 
     # a wnode subtree under the phony node and later
     # reparent it to the proper place in the wtree)
-    def phony(wnode)
-      phony = WNode.new(:none, wnode)
-      phony
+    def phony(wnode, type=:none)
+      WNode.new(type, wnode)
     end
 
-    # Static string allocation
-    def string_static(string, data_label)
-      # Allocate string itself and the attributes
-      # of String object pointing to that string
-      data_stg = DAta.append(data_label.to_sym, string)
-      data_stg
+    # Static string data allocation
+    def allocate_string_static_data(string, data_label)
+      # if string is empty do not allocate any memory space
+      DAta.append(data_label.to_sym, string) unless string.empty?
     end
 
     # Static new string object
     def string_static_new(wnode, string)
-      klass = wnode.find_class(nil)
+      klass = wnode.find_current_class_or_module()
       data_label = "#{klass.name}_string_#{@static_count += 1}"
-      # Statically 
-      data_stg = self.string_static(string, data_label)
+      # Allocate string data statically
+      # Note : data_stg is nil if string is empty
+      data_stg = self.allocate_string_static_data(string, data_label)
       # align on :I32 boundary
+      # then allocate the String object attributes
+      # and set them up
       DAta.align(4)
       data_len = DAta.append("#{data_label}_len".to_sym, string.length, WType::DEFAULT)
-      data_ptr = DAta.append("#{data_label}_ptr".to_sym, data_stg.address, WType::DEFAULT)
+      data_ptr = DAta.append("#{data_label}_ptr".to_sym, data_stg ? data_stg.address : 0, WType::DEFAULT)
       # Generate address wnode
       (wn_object_addr = WNode.new(:insn, wnode)).c(:addr, value: data_len.address)
       wn_object_addr.wtype = WType.new(:String)
@@ -418,27 +613,75 @@ module Rlang::Parser
 
     # Dynamic new string object
     def string_dynamic_new(wnode, string)
-      klass = wnode.find_class(nil)
+      klass = wnode.find_current_class_or_module()
       data_label = "#{klass.name}_string_#{@static_count += 1}"
-      data_stg = self.string_static(string, data_label)
+      # Note : data_stg is nil if string is empty
+      data_stg = self.allocate_string_static_data(string, data_label)
       string_new_source = STRING_NEW_TMPL % {
-        string: string,
-        ptr: data_stg.address,
+        ptr: data_stg ? data_stg.address : 0,
         length: string.length
       }
       #puts string_new_source;exit
-      wn_string = self.parser.parse(string_new_source, wnode)
+      self.parser.parse(string_new_source, wnode)
+    end
+
+    # Static array data allocation
+    def allocate_array_static_data(array, data_label)
+      # Append each array element to the same data section
+      label = data_label.to_sym
+      data_arr = nil
+      # Do not allocate memory space if array is empty
+      array.each { |elt| data_arr = DAta.append(label, elt) }
+      data_arr
+    end
+
+    # Static new array object
+    def array_static_new(wnode, array)
+      klass = wnode.find_current_class_or_module()
+      data_label = "#{klass.name}_array_#{@static_count += 1}"
+      # Allocate array data statically
+      # Note : data_arr is nil if string is empty
+      data_arr = self.allocate_array_static_data(array, data_label)
+      # align on :I32 boundary
+      # then allocate the Array object attributes
+      # and set them up
+      DAta.align(4)
+      data_count = DAta.append("#{data_label}_count".to_sym, array.length, WType::DEFAULT)
+      data_ptr   = DAta.append("#{data_label}_ptr".to_sym, data_arr ? data_arr.address : 0, WType::DEFAULT)
+      # Generate address wnode
+      (wn_object_addr = WNode.new(:insn, wnode)).c(:addr, value: data_count.address)
+      wn_object_addr.wtype = WType.new(:Array32)
+      wn_object_addr
+    end
+
+    # Dynamic new array object
+    def array_dynamic_new(wnode, array)
+      klass = wnode.find_current_class_or_module()
+      data_label = "#{klass.name}_array_#{@static_count += 1}"
+      # Note : data_arr is nil if string is empty
+      data_arr = self.allocate_array_static_data(array, data_label)
+      array_new_source = ARRAY_NEW_TMPL % {
+        elt_size_in_bits: WTYPE::DEFAULT.size * 8,
+        ptr: data_arr ? data_arr.address : 0,
+        count: array.length
+      }
+      #puts array_new_source;exit
+      self.parser.parse(array_new_source, wnode)
     end
 
+    # TYPE CASTING methods
     # All the cast_xxxx methods below returns
     # the new wnode doing the cast operation
     # or the same wnode if there is no additional code
     # for the cast operation
+
+    # No casting. Return node as is.
     def cast_nope(wnode, wtype, signed)
-      # Do nothing
       wnode
     end
 
+    # Cast by extending to a wtype of larger bit size
+    # (e.g. I32 to I64)
     def cast_extend(wnode, wtype, signed)
       if (wnode.template == :const)
         # it's a WASM const, simply change the wtype
@@ -447,15 +690,19 @@ module Rlang::Parser
       else
         wn_cast_op = wnode.insert(:insn)
         wn_cast_op.wtype = wtype
-        wn_cast_op.c(signed ? :extend_i32_s : :extend_i32_u , wtype: wtype)
+        wn_cast_op.c(signed ? :extend_i32_s : :extend_i32_u , wasm_type: wn_cast_op.wasm_type)
       end
       wn_cast_op
     end
 
+    # Cast by simply changing the node wtype
+    # No change in native WASM type
+    # (e.g. casting an object pointer to I32)
     def cast_wtype(wnode, wtype, signed)
-      if (wnode.wtype.default? && wtype.class?) || 
-         (wnode.wtype.class? && wtype.default?) ||
-         (wnode.wtype.class? && wtype.class?)
+      # Don't cast blindly. Check that source and target
+      # have the same bit size (e.g. Object pointers, I32, UI32
+      # are the same size, )
+      if wnode.wtype.size == wtype.size
         wnode.wtype = wtype
       else
         cast_error(wnode, wtype, signed)
@@ -463,6 +710,8 @@ module Rlang::Parser
       wnode
     end
 
+    # Cast by wraping a wtype to a smaller size
+    # (e.g. I64 to I32)
     def cast_wrap(wnode, wtype, signed)
       if (wnode.template == :const)
         # it's a WASM const, simply change the wtype
@@ -471,17 +720,19 @@ module Rlang::Parser
       else
         wn_cast_op = wnode.insert(:insn)
         wn_cast_op.wtype = wtype
-        wn_cast_op.c(:wrap_i64, wtype: wtype)
+        wn_cast_op.c(:wrap_i64, wasm_type: wn_cast_op.wasm_type)
       end
       wn_cast_op
     end
 
+    # Cast operation not yet supported
     def cast_notyet(wnode, wtype, signed)
       raise "Type cast from #{wnode.wtype} to #{wtype} not supported yet"
     end
 
+    # Cast operation is invalid
     def cast_error(wnode, wtype, signed)
-      raise "Cannot cast type #{src} to #{dest}. Time to fix your code :-)"
+      raise "Cannot cast type #{wnode.wtype} to #{wtype}. Time to fix your code :-)"
     end
 
     # cast an expression to a different type
@@ -503,42 +754,26 @@ module Rlang::Parser
       wn_cast_op
     end
 
-    # before generating native operator Wasm code check
-    # if the operator was overloaded
-    def send_method(wnode, method_name, wtype=WType.new(:none))
-      class_name = wtype.name
-      if wnode.find_method(method_name, class_name, :instance)
-        # it's an instance method call
-        logger.debug "Overloaded operator #{method_name} found in class #{class_name}"
-        wn_op = self.call(wnode, class_name, method_name, :instance)
-      else
-        # it's a native Wasm operator
-        if ALL_OPS_MAP.has_key? method_name
-          wn_op = self.native_operator(wnode, method_name, wtype)
-        else
-          raise "Unknown method '#{method_name}' in class #{class_name}"
-        end
-      end
-      wn_op
-    end
-
     # just create a wnode for the WASM operator
     # Do not set wtype or a code template yet,
     # wait until operands type is known (see
     # operands below)
     def native_operator(wnode, operator, wtype=WType.new(:none))
       if (op = ALL_OPS_MAP[operator])
-        (wn_op = WNode.new(:insn, wnode)).c(:operator, operator: op)
-        wn_op.wtype = wtype
+        (wn_op = WNode.new(:insn, wnode)).wtype = wtype
+        wn_op.c(:operator, wasm_type: wn_op.wasm_type, operator: op)
         logger.debug "Creating operator #{operator} wnode: #{wn_op}"
+        # special case for - unary operator transformed into (0 - x)
+        WNode.new(:insn, wn_op).c(:const, wasm_type: wn_op.wasm_type, value: 0) if operator == :-@
         wn_op
       else
         raise "operator '#{operator}' not supported"
       end
     end
 
-    # finish the setting of the operator node and
-    # attach operands
+    # Finish the setting of the operator node, 
+    # attach operands and see if they need implicit
+    # type casting
     def operands(wnode_op, wnode_recv, wnode_args)
       logger.debug "Processing operands in operator wnode: #{wnode_op}..."
       # Do not post process operands if the operator
@@ -556,26 +791,48 @@ module Rlang::Parser
       #wnode_recv = wnode_op.children[0]
       #wnode_args = wnode_op.children[1..-1]
       # First find out the wtype that has precedence
-      wtype = self.class.leading_wtype(wnode_recv, *wnode_args)
+      leading_wtype = self.class.leading_wtype(wnode_recv, *wnode_args)
       
-      wnode_op.wtype = wtype
-      logger.debug "leading type cast: #{wtype}"
+      wnode_op.wtype = leading_wtype
+      logger.debug "leading type cast: #{leading_wtype}"
 
       # Attach receiver and argument to the operator wnode
-      # type casting them if necessary    
-      self.cast(wnode_recv, wtype).reparent_to(wnode_op)
-      self.cast(wnode_args.first, wtype).reparent_to(wnode_op) unless wnode_args.empty?
+      # type casting them if necessary
+      # Note : normally for an operator there is only one argument
+      # but process args as if they were many one day.
+      logger.debug "Perform implicit type casting of receviver and operator arg(s)"
+      self.cast(wnode_recv, leading_wtype).reparent_to(wnode_op)
+      wnode_args.each do |wna|
+        self.cast(wna, leading_wtype).reparent_to(wnode_op)
+      end
+
+      # Once operands casting is done, see if we need the signed or unsigned
+      # version of the native operator
+      # NOTE : At this stage, after the operands casting both of them
+      # should either be signed or unsigned, hence the XNOR sanity check
+      # below
+      if ALL_SIGNED_OPS_MAP.values.include? op
+        if !((signed = wnode_recv.wtype.signed?) ^ (wnode_args.empty? ? true : wnode_args.first.wtype.signed?))
+          wnode_op.wargs[:operator] = SIGNED_OPS[signed ? :signed : :unsigned][op]
+          logger.debug "Receiver has wtype #{wnode_recv.wtype} / Argument has wtype #{wnode_args.first.wtype}"
+          logger.debug "Replacing #{op} operator with #{wnode_op.wargs[:operator]}"
+          op = wnode_op.wargs[:operator]
+        else
+          raise "Type mismatch between operands. Receiver is #{wnode_recv.wtype} and argument is #{wnode_args.first.wtype}"
+        end
+      end
 
       # if the receiver is a class object and not
       # a native integer then pointer arithmetic
       # applies (like in C)
       if wnode_recv.wtype.class?
-        legal_ops = RELATIONAL_OPS_MAP.values + [:add, :sub]
-        raise "Only #{legal_ops.join(', ')} operators are supported on objects (got #{op} in #{wnode_op})" \
-          unless legal_ops.include?(op)
-        # if + or - operator then multiply arg by size of object
-        if [:add, :sub].include? wnode_op.wargs[:operator]
-          (wn_mulop = WNode.new(:insn, wnode_op)).c(:operator, operator: :mul)
+        raise "Only #{LEGAL_CLASS_WASM_OPS.join(', ')} operators are supported on objects (got #{op} in #{wnode_op})" \
+          unless LEGAL_CLASS_WASM_OPS.include?(op)
+        # if :add or :sub operator then multiply arg by size of object
+        # like in C
+        if [:add, :sub].include? op
+          (wn_mulop = WNode.new(:insn, wnode_op)).wtype = WType::DEFAULT
+          wn_mulop.c(:operator, wasm_type: wn_mulop.wasm_type, operator: :mul)
           WNode.new(:insn, wn_mulop).c(:call, func_name: "$#{wnode_recv.wtype.name}::#{SIZE_METHOD}")
           wnode_args.first.reparent_to(wn_mulop)
         else
@@ -592,10 +849,10 @@ module Rlang::Parser
 
     # Statically allocate an object in data segment
     # with the size of the class
-    def static_new(wnode, class_name)
-      klass = wnode.find_class(class_name)
+    def static_new(wnode, class_path)
+      klass = wnode.find_class_or_module(class_path)
       if klass.size > 0
-        data_label = "#{class_name}_new_#{@new_count += 1}"
+        data_label = "#{klass.path_name}_new_#{@new_count += 1}"
         data = DAta.new(data_label.to_sym, "\x00"*klass.wnode.class_size)
         address = data.address
       else
@@ -606,50 +863,87 @@ module Rlang::Parser
       end
       (wn_object_addr = WNode.new(:insn, wnode)).c(:addr, value: address)
       # VERY IMPORTANT the wtype of this node is the Class name !!!
-      wn_object_addr.wtype = WType.new(class_name.to_sym)
+      wn_object_addr.wtype = WType.new(klass.path_name)
       wn_object_addr
     end
 
     # Create the dynamic new method. It allocates memory
     # for the object created and calls initialize
     def def_new(wnode_class)
-      # no new method for native types
+      k = wnode_class.find_current_class_or_module()
+      logger.debug "Defining new method for #{k.name}"
+      # no need to define new method for native types
       return if wnode_class.klass.wtype.native?
-      new_method = wnode_class.find_method(:new, wnode_class.class_name, :class)
-      return if new_method.wnode # already implemented
-
-      init_method = wnode_class.find_method(:initialize, wnode_class.class_name, :instance)
-      logger.debug "Creating code for #{wnode_class.class_name}.new"
+      if (new_mth = wnode_class.find_method(k, :new, :class, true))
+        return if new_mth.implemented? # already implemented
+      end
+      
+      logger.debug "Creating code for #{k.name}.new"
+      # Find initialize method and use the same method args for new
+      init_method = wnode_class.find_method(k, :initialize, :instance, true)
       new_tmpl = wnode_class.class_size.zero? ? NEW_ZERO_TMPL : NEW_TMPL
       new_source = new_tmpl % {
         default_wtype: WType::DEFAULT.name,
-        class_name: wnode_class.class_name,
+        class_name: k.path_name,
         # Do not pass _self_ argument to the new method of course !!
         margs: init_method.margs.reject {|ma| ma._self_?}.map(&:name).join(', '), 
         class_size: wnode_class.class_size
       }
-      new_method.wnode = self.parser.parse(new_source, wnode_class)
+      new_mth.wnode = self.parser.parse(new_source, wnode_class)
     end
 
     # Define a dumb initialize method if not implemented
     # already in user code
     def def_initialize(wnode_class)
+      k = wnode_class.find_current_class_or_module()
       # no new/initialize method for native types
-      return if WType.new(wnode_class.class_name).native? 
+      return if WType.new(k.path_name).native? 
       # generate code for a dumb initialize method if not defined
       # in user code
-      unless wnode_class.find_method(:initialize, wnode_class.class_name, :instance)
-        logger.debug "Creating MEthod and code for #{wnode_class.class_name}#initialize"
-        init_source = DUMB_INIT_TMPL
-        self.parser.parse(init_source, wnode_class)
+      if (init_mth = wnode_class.find_method(k, :initialize, :instance, true))
+        return if init_mth.wnode # already implemented
+      end
+      logger.debug "Creating MEthod and code for #{k.name}#initialize"
+      init_source = DUMB_INIT_TMPL
+      init_mth.wnode = self.parser.parse(init_source, wnode_class)
+    end
+
+    # generate code for method call
+    def send_method(wnode, class_path, method_name, method_type)
+      logger.debug "In call generator for #{class_path}::#{method_name}"
+      if k = wnode.find_class_or_module(class_path)
+        method = wnode.find_method(k, method_name, method_type)
+        if k.wtype.native? && ALL_OPS_MAP.has_key?(method_name)
+          # An Rlang method exist for this class but methods corresponding to 
+          # Webassembly native operators applied to native Webassembly types
+          # (I32, I64, F32, F64) **cannot** be overriden by instance methods
+          # in Rlang code
+          if method
+            logger.warn "Rlang #{class_path}::#{method_name} method ignored. Native operator has precedence"
+          end
+          logger.debug "Apply native operator #{method_name} to native wtype  #{class_path}"
+          wn_call = self.native_operator(wnode, method_name, WType.new(class_path))
+        elsif !k.wtype.native? && ALL_OPS_MAP.has_key?(method_name) && method.nil?
+          # Similarly if the Class is not a native type (a regular class)
+          # and the Class doesn't provide its own method implementation of the native
+          # operator then apply the native operands
+          logger.debug "Apply native operator #{method_name} to class found : #{class_path}"
+          wn_call = self.native_operator(wnode, method_name, WType.new(class_path))
+        elsif method
+          logger.debug "Found method #{method.name} in class #{method.klass.name}"
+          (wn_call = WNode.new(:insn, wnode)).c(:call, func_name: method.wasm_name)
+          wn_call.wtype = method.wtype
+          wn_call
+        else
+          raise "Unknown method '#{method_name}' in class #{class_path}"
+        end
+      elsif ALL_OPS_MAP.has_key? method_name
+        # It is a native Wasm operator
+        logger.debug "Native operator found : #{class_path}::#{method_name}"
+        wn_call = self.native_operator(wnode, method_name, WType.new(class_path))
+      else
+        raise "Unknown method '#{method_name}' in class #{class_path}"
       end
-    end
-
-    def call(wnode, class_name, method_name, method_type)
-      method = wnode.find_or_create_method(method_name, class_name, nil, method_type)
-      logger.debug "found method #{method}"
-      (wn_call = WNode.new(:insn, wnode)).c(:call, func_name: method.wasm_name)
-      wn_call.wtype = method.wtype
       wn_call
     end
 
@@ -682,8 +976,8 @@ module Rlang::Parser
     end
 
     def while(wnode)
-      (wnb = WNode.new(:insn, wnode)).c(:block) 
-      (wnl = WNode.new(:insn, wnb)).c(:loop) 
+      (wnb = WNode.new(:insn, wnode)).c(:block, label: wnb.set_label) 
+      (wnl = WNode.new(:insn, wnb)).c(:loop, label: wnl.set_label) 
       (wnbi = WNode.new(:insn, wnl)).c(:br_if, label: wnb.label)
       return wnb,wnbi,wnl
     end
@@ -693,7 +987,7 @@ module Rlang::Parser
     # negate the original while condition
     def while_cond(wnode, wnode_cond_exp)
       wn_eqz = WNode.new(:insn, wnode)
-      wn_eqz.c(:eqz, wtype: wnode_cond_exp.wtype)
+      wn_eqz.c(:eqz, wasm_type: wnode_cond_exp.wasm_type)
       wnode_cond_exp.reparent_to(wn_eqz)
       wn_eqz
     end