rlang 0.4.0 → 0.4.1

data/lib/rlang/parser/{wattr.rb → attr.rb}

@@ -9,61 +9,64 @@ require_relative './ivar'
 require_relative './wtype'
 
 module Rlang::Parser
-  class WAttr
+  class Attr
     include Log
-    attr_reader :name, :wtype, :getter, :setter, :ivar
+    attr_reader :name, :getter, :setter, :ivar
 
     # The name argument can either be the attribute name
     # (e.g. :size) or an ivar name (e.g. :@size)
     def initialize(class_wnode, name, wtype=WType::DEFAULT)
       @class_wnode = class_wnode
-      if name.to_s[0] == '@'
-        @ivar = IVar.new(@class_wnode, name, wtype)
-        @name = @ivar.wattr_name
-      else
-        @name = name
-        @ivar = IVar.new(@class_wnode, self.ivar_name, wtype)
-      end
-      @wtype = wtype
-      # Also create the corresponding getter and setter
-      # method objects (with default WType - wattr_type
-      # directives might later change this wtype)
-      # Don't generate WAT code yet
+      @name = name
+      @ivar = class_wnode.create_ivar(:"@#{name}", wtype)
+      @getter = nil
+      @setter = nil
+      @export = false
+      logger.debug "Class attribute #{name} created"
+    end
+
+    def attr_reader
       @getter = @class_wnode.find_or_create_method(self.getter_name, nil, wtype, :instance)
-      @getter.instance!
+      @getter.export! if @export
       logger.debug "Getter created: #{@getter.inspect}"
+      @getter
+    end
 
+    def attr_writer
       @setter = @class_wnode.find_or_create_method(self.setter_name, nil, wtype, :instance)
-      @setter.instance!
+      @setter.export! if @export
       logger.debug "Setter created: #{@setter.inspect}"
-      logger.debug "Class attribute #{name} created"
+      @setter
     end
 
-    def class_name
-      @class_wnode.class_name
+    def attr_accessor
+      [self.attr_reader, self.attr_writer]
     end
 
-    def wtype=(wtype)
-      @wtype = wtype
-      # Adjust corresponding method objects wtype accordingly
-      @getter.wtype = wtype
-      @setter.wtype = wtype
-      @ivar.wtype   = wtype
-      logger.debug "WAttr/Getter/Setter/ivar wtype updated : #{@getter.inspect}"
+    def export!
+      @export = true
     end
 
-    def size
-      @wtype.size
+    def class_name
+      @class_wnode.class_name
     end
 
-    def ivar_name
-      @ivar ? @ivar.name : :"@#{name}"
+    def wtype
+      @ivar.wtype
     end
 
-    def wasm_name
-      "$#{@name}"
+    def offset
+      @ivar.offset
     end
     
+    def wtype=(wtype)
+      # Adjust getter/setter and ivar wtype accordingly
+      @getter.wtype = wtype if @getter
+      @setter.wtype = wtype if @setter
+      @ivar.wtype = wtype
+      logger.debug "Attr/Getter/Setter/ivar wtype updated : #{@getter.inspect}"
+    end
+
     def getter_name
       @name
     end
@@ -71,8 +74,13 @@ module Rlang::Parser
     def setter_name
       "#{@name}=".to_sym
     end
+
+    def wasm_name
+      "$#{@name}"
+    end
+    
     def wasm_type
-      @wtype.wasm_type
+      self.wtype.wasm_type
     end
   end
 end

data/lib/rlang/parser/data.rb

@@ -17,6 +17,9 @@ module Rlang::Parser
 
     attr_reader :label, :wtype, :address, :value
 
+    # NOTE: new and append only takes individual DAta values
+    # not an array of values
+    # TODO: fix DAta.new and DAta.append not accepting an array of values
     def initialize(label, value, wtype=WType::DEFAULT)
       raise "Data label '#{label}' already initialized" \
         if self.class.exist? label

data/lib/rlang/parser/ivar.rb

@@ -2,7 +2,7 @@
 # Copyright (c) 2019, Laurent Julliard and contributors
 # All rights reserved.
 #
-# Instance variables
+# Instance variables class
 #
 require_relative '../../utils/log'
 require_relative './wtype'
@@ -11,22 +11,31 @@ require_relative './data'
 module Rlang::Parser
   class IVar
     include Log
-    attr_reader :name, :class_wnode
-    attr_accessor :wtype
+    attr_reader :name
+    attr_accessor :wtype, :offset
 
     def initialize(class_wnode, name, wtype=WType::DEFAULT)
-      @name = name
       @class_wnode = class_wnode
+      @name = name
       @wtype = wtype
-      logger.debug "creating instance variable #{name} in class #{self.class_name} / wtype #{wtype}"
+      # this is the offset of the instance variable
+      # in memory in the order they are declared
+      # It is computed at the end of a class
+      # definition
+      @offset = nil
+      logger.debug "Instance variable #{name} created"
     end
 
     def class_name
       @class_wnode.class_name
     end
 
-    def wattr_name
-      @name.to_s.tr('@','').to_sym
+    def size
+      @wtype.size
+    end
+
+    def wasm_name
+      "$#{@name}"
     end
 
     def wasm_type

data/lib/rlang/parser/klass.rb

@@ -13,7 +13,8 @@ module Rlang::Parser
     include Log
 
     attr_reader :wtype
-    attr_accessor :name, :wnode, :wattrs, :cvars, :consts, :methods
+    attr_accessor :name, :wnode, :attrs, :ivars, :cvars, 
+                  :consts, :methods, :offset
 
     def initialize(name)
       @name = name
@@ -23,14 +24,16 @@ module Rlang::Parser
       # the wnode implementing the code of the class
       @wnode = nil
       logger.debug "Klass created #{self.inspect}"
-      @wattrs  = [] # class attributes
+      @attrs  = [] # class attributes
+      @ivars   = [] # instance variables
       @cvars   = [] # class variables
       @consts  = [] # class constants
       @methods = [] # methods
+      @offset  = 0  # offset of the next class attribute in memory
     end
 
     def size
-      self.wattrs.sum(&:size)
+      @offset
     end
 
     def wtype=(wtype)

data/lib/rlang/parser/method.rb

@@ -16,32 +16,40 @@ module Rlang::Parser
     attr_reader :name, :wtype
     attr_accessor :class_name, :margs, :lvars, :wnode
 
-    def initialize(name, class_name, wtype=WType::DEFAULT)
+    METHOD_TYPES = [:class, :instance]
+
+    def initialize(name, class_name, wtype, method_type)
       raise "Wrong method wtype argument: #{wtype.inspect}" unless wtype.is_a? WType
       @name = name
       @class_name = class_name
-      @wtype = wtype
-      @instance = false
+      @wtype = wtype || WType::DEFAULT
+      @method_type = method_type
+      raise "Unknown method type: #{method_type}" unless METHOD_TYPES.include? @method_type
       @wnode = nil # wnode where method is implemented
       logger.debug "Method created #{self.inspect}"
       @margs = []   # method args
       @lvars = []   # local variables
     end
 
+    def implemented?
+      !@wnode.nil?
+    end
+    
     def instance!
-      @instance = true
+      @method_type = :instance
     end
 
     def instance?
-      @instance
+      @method_type == :instance
+
     end
 
     def class!
-      @instance = false
+      @method_type = :class
     end
 
     def class?
-      !@instance
+      @method_type == :class
     end
 
     def wtype=(wtype)
@@ -50,7 +58,7 @@ module Rlang::Parser
     end
 
     def wasm_name
-      if @instance
+      if self.instance?
         "$#{@class_name}##{@name}"
       else
         "$#{@class_name}::#{@name}"
@@ -62,7 +70,7 @@ module Rlang::Parser
     end
 
     def export_name
-      if @instance
+      if self.instance?
         "#{@class_name.downcase}_i_#{@name}"
       else
         "#{@class_name.downcase}_c_#{@name}"

data/lib/rlang/parser/wgenerator.rb

@@ -50,6 +50,8 @@ module Rlang::Parser
     :'!'   => :eqz
   }
 
+  ALL_OPS_MAP = [*ARITHMETIC_OPS_MAP, *RELATIONAL_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},
@@ -60,6 +62,9 @@ module Rlang::Parser
     none: { I32: :cast_error, I64: :cast_error, F32: :cast_error, F64: :cast_error, Class: :cast_error, none: :cast_error},
   }
 
+  # Rlang class size method name
+  SIZE_METHOD = :_size_
+
   # new template when object size > 0
   NEW_TMPL = %q{
   result :Object, :alloc, :%{default_wtype}
@@ -71,7 +76,7 @@ module Rlang::Parser
   end
   }
 
-  # new template when object size iz 0 (no instance var)
+  # new template when object size is 0 (no instance var)
   # use 0 as the _self_ address in memory. It should never
   # be used anyway
   NEW_ZERO_TMPL = %q{
@@ -91,6 +96,11 @@ module Rlang::Parser
   end
   }
 
+  # Dynamically allocate a string object
+  STRING_NEW_TMPL = %q{
+    String.new(%{ptr}, %{length})
+  }
+
   # Generate the wasm nodes and tree structure
   # ***IMPORTANT NOTE***
   # Unless otherwise stated all methods receive
@@ -106,6 +116,7 @@ module Rlang::Parser
       @parser = parser
       @root = WTree.new().root
       @new_count = 0
+      @static_count = 0
     end
 
     def klass(wnode, class_name)
@@ -118,22 +129,51 @@ module Rlang::Parser
       k.wnode
     end
 
-    def def_wattr(wnode)
+    # Postprocess ivars
+    # (called at end of class parsing)
+    def ivars_setup(wnode)
       wnc = wnode.class_wnode
-      # Process each declared attribute
-      offset = 0
-      wnc.klass.wattrs.each do |wa|
-        logger.debug("Generating accessors for attribute #{wnc.klass.name}\##{wa.name}")
+      raise "Cannot find class for attributes definition!!" unless wnc
+      klass = wnc.klass
+      logger.debug "Postprocessing ivars for class #{klass.name}..."
+      klass.ivars.each do |iv|
+        iv.offset = klass.offset
+        logger.debug "... ivar #{iv.name} has offset #{iv.offset}"
+        # Update offset for next ivar
+        klass.offset += iv.size
+      end
+    end
+
+    # generate code for class attributes
+    # (called at end of class parsing)
+    def def_attr(wnode)
+      wnc = wnode.class_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}")
         # Generate getter and setter methods wnode
-        (wa.setter.wnode = wattr_setter(wnc, wa, offset)) unless wa.setter.wnode
-        (wa.getter.wnode = wattr_getter(wnc, wa, offset)) unless wa.getter.wnode
-        # Update offset
-        offset += wa.wtype.size
+        # unless method already implemented by user
+        if attr.setter
+          unless attr.setter.implemented?
+            attr.setter.wnode = self.attr_setter(wnc, attr)
+          else
+            logger.debug "Attribute setter #{attr.setter.name} already defined. Skipping"
+          end
+        end
+        if attr.getter
+          unless attr.getter.implemented?
+            attr.getter.wnode = self.attr_getter(wnc, attr)
+          else
+            logger.debug "Attribute getter #{attr.getter.name} already defined. Skipping"
+          end
+        end
       end
 
       # Also generate the Class::_size_ method
-      # always (needed by Object.allocate)
-      size_method = wnc.find_or_create_method(:_size_, wnc.klass.name, WType::DEFAULT, :class )
+      # (needed for dynamic memory allocation
+      #  by Object.allocate)
+      size_method = wnc.find_or_create_method(SIZE_METHOD, wnc.klass.name, WType::DEFAULT, :class)
       unless size_method.wnode
         logger.debug("Generating #{size_method.class_name}\##{size_method.name}")
         wns = WNode.new(:insn, wnc, true)
@@ -145,22 +185,22 @@ module Rlang::Parser
     end
 
     # Generate attribute setter method wnode
-    def wattr_setter(wnode, wattr, offset)
+    def attr_setter(wnode, attr)
       wnc = wnode.class_wnode
       wn_set = WNode.new(:insn, wnc, true)
-      wn_set.c(:wattr_writer, func_name: wattr.setter.wasm_name, 
-            wattr_name: wattr.wasm_name, wtype: wattr.wasm_type,
-            offset: offset)
+      wn_set.c(:attr_setter, func_name: attr.setter.wasm_name, 
+            attr_name: attr.wasm_name, wtype: attr.wasm_type,
+            offset: attr.offset)
       wn_set
     end
 
     # Generate attribute getter method wnode
-    def wattr_getter(wnode, wattr, offset)
+    def attr_getter(wnode, attr)
       wnc = wnode.class_wnode
       wn_get = WNode.new(:insn, wnc, true)
-      wn_get.c(:wattr_reader, func_name: wattr.getter.wasm_name, 
-            wattr_name: wattr.wasm_name, wtype: wattr.wasm_type,
-            offset: offset)
+      wn_get.c(:attr_getter, func_name: attr.getter.wasm_name, 
+            attr_name: attr.wasm_name, wtype: attr.wasm_type,
+            offset: attr.offset)
       wn_get
     end
 
@@ -225,11 +265,12 @@ module Rlang::Parser
       wn    
     end
 
-    # Set class variable
-    # Constant assignment doesn't generate any code
-    # A Data object is instantiated and initialized
-    # when the Const object is created in parser
+    # Set constant
     def casgn(wnode, const)
+      (wn = WNode.new(:insn, wnode)).wtype = const.wtype
+      wn.c(:store, wtype: const.wtype)
+      WNode.new(:insn, wn).c(:addr, value: const.address)
+      wn
     end
 
     # Get class variable
@@ -254,34 +295,38 @@ module Rlang::Parser
       wn
     end
 
-    # Call setter (on wattr or instance variable)
+    # Call setter (on attr or instance variable)
     # This is the same as calling the corresponding setter
-    def call_setter(wnode, wnode_recv, wattr)
-      wn = self.call(wnode, wnode_recv.wtype.name, wattr.setter_name, :instance)
+    def call_setter(wnode, wnode_recv, attr)
+      wn = self.call(wnode, wnode_recv.wtype.name, attr.setter_name, :instance)
       # First argument of the setter must be the receiver
       wnode_recv.reparent_to(wn)
       wn
     end
 
-    # Call getter (on wattr or instance variable)
+    # Call getter (on attr or instance variable)
     # This is the same as calling the corresponding getter
-    def call_getter(wnode, wnode_recv, wattr)
-      wn = self.call(wnode, wnode_recv.wtype.name, wattr.getter_name, :instance)
+    def call_getter(wnode, wnode_recv, attr)
+      wn = self.call(wnode, wnode_recv.wtype.name, attr.getter_name, :instance)
       # First argument of the getter must always be the receiver
       wnode_recv.reparent_to(wn)
       wn
     end
 
     # Set instance variable
-    # This is the same as calling the corresponding setter
-    def ivasgn(wnode, wnode_recv, wattr)
-      self.call_setter(wnode, wnode_recv, wattr)
+    def ivasgn(wnode, ivar)
+      (wn = WNode.new(:insn, wnode)).wtype = ivar.wtype
+      wn.c(:store_offset, wtype: ivar.wasm_type, offset: lambda { ivar.offset })
+      self._self_(wn)
+      wn
     end
 
     # Get instance variable. 
-    # This is the same as calling the corresponding getter
-    def ivar(wnode, wnode_recv, wattr)
-      self.call_getter(wnode, wnode_recv, wattr)
+    def ivar(wnode, ivar)
+      (wn = WNode.new(:insn, wnode)).wtype = ivar.wtype
+      wn.c(:load_offset, wtype: ivar.wasm_type, offset: lambda { ivar.offset })
+      self._self_(wn)
+      wn
     end
 
     # Set class variable
@@ -339,6 +384,52 @@ module Rlang::Parser
       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
+    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
+    end
+
+    # Static new string object
+    def string_static_new(wnode, string)
+      klass = wnode.find_class(nil)
+      data_label = "#{klass.name}_string_#{@static_count += 1}"
+      # Statically 
+      data_stg = self.string_static(string, data_label)
+      # align on :I32 boundary
+      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)
+      # Generate address wnode
+      (wn_object_addr = WNode.new(:insn, wnode)).c(:addr, value: data_len.address)
+      wn_object_addr.wtype = WType.new(:String)
+      wn_object_addr
+    end
+
+    # Dynamic new string object
+    def string_dynamic_new(wnode, string)
+      klass = wnode.find_class(nil)
+      data_label = "#{klass.name}_string_#{@static_count += 1}"
+      data_stg = self.string_static(string, data_label)
+      string_new_source = STRING_NEW_TMPL % {
+        string: string,
+        ptr: data_stg.address,
+        length: string.length
+      }
+      #puts string_new_source;exit
+      wn_string = self.parser.parse(string_new_source, wnode)
+    end
+
     # All the cast_xxxx methods below returns
     # the new wnode doing the cast operation
     # or the same wnode if there is no additional code
@@ -402,27 +493,44 @@ module Rlang::Parser
     # TODO: simplify this complex method (possibly by using
     # a conversion table source type -> destination type)
     def cast(wnode, wtype, signed=false)
-      logger.debug "wnode: #{wnode}, wtype: #{wtype}"
+      logger.debug "Casting wnode: #{wnode}, wtype: #{wtype}, wnode ID: #{wnode.object_id}"
       src_type  = (wnode.wtype.native? ? wnode.wtype.name : :Class)
       dest_type = (wtype.native? ? wtype.name : :Class)
       cast_method = CAST_OPS[src_type] && CAST_OPS[src_type][dest_type] || :cast_error
-
+      logger.debug "Calling cast method: #{cast_method}"
       wn_cast_op = self.send(cast_method, wnode, wtype, signed)
-      logger.debug "After type cast: wnode: #{wn_cast_op}, wtype: #{wtype}"
+      logger.debug "After type cast: wnode: #{wn_cast_op}, wtype: #{wtype}, wnode ID: #{wn_cast_op.object_id}"
       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 operator(wnode, operator, wtype=WType.new(:none))
-      if (op = (ARITHMETIC_OPS_MAP[operator] || 
-                RELATIONAL_OPS_MAP[operator] ||
-                BOOLEAN_OPS_MAP[operator]    ||
-                UNARY_OPS_MAP[operator]  ))
+    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
+        logger.debug "Creating operator #{operator} wnode: #{wn_op}"
         wn_op
       else
         raise "operator '#{operator}' not supported"
@@ -432,8 +540,21 @@ module Rlang::Parser
     # finish the setting of the operator node and
     # attach operands
     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
+      # wnode is a call (= overloaded operator)
+      # and not a native operand
+      if wnode_op.template == :call
+        logger.debug "Doing nothing because it's a func call..."
+        return wnode_op
+      end
+
+      # A native operator only expects 0 (unary) or 1 (binary)
+      # argument in addition to the receiver 
       raise "only 0 or 1 operand expected (got #{wnode_args.count})" if wnode_args.count > 1
       op = wnode_op.wargs[:operator]
+      #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)
       
@@ -441,7 +562,7 @@ module Rlang::Parser
       logger.debug "leading type cast: #{wtype}"
 
       # Attach receiver and argument to the operator wnode
-      # type casting them if necessary
+      # 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?
 
@@ -455,8 +576,7 @@ module Rlang::Parser
         # 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)
-          WNode.new(:insn, wn_mulop).c(:const, 
-            value: lambda { wnode_recv.find_class(wnode_recv.wtype.name).size })
+          WNode.new(:insn, wn_mulop).c(:call, func_name: "$#{wnode_recv.wtype.name}::#{SIZE_METHOD}")
           wnode_args.first.reparent_to(wn_mulop)
         else
           # It's a relational operator. In this case
@@ -466,6 +586,7 @@ module Rlang::Parser
           wnode_op.wtype = WType::DEFAULT
         end
       end
+      logger.debug "Operands in operator wnode after postprocessing: #{wnode_op}..."
       wnode_op
     end