rlang 0.4.1 → 0.5.0

data/lib/rlang/parser/cvar.rb

@@ -12,17 +12,21 @@ require_relative './data'
 module Rlang::Parser
   class CVar
     include Log
-    attr_reader :name, :class_name
+    attr_reader :name, :klass
     attr_accessor :wtype
 
-    def initialize(class_name, name, value=0, wtype=WType::DEFAULT)
+    def initialize(klass, name, value=0, wtype=WType::DEFAULT)
+      @klass = klass
       @name = name
-      @class_name = class_name
       @wtype = wtype
       # Allocate and initialize the new cvar
-      raise "Error: Class variable #{self.wasm_name} already created!" if DAta.exist? self.wasm_name.to_sym
-      @data = DAta.new(self.wasm_name.to_sym, value, wtype)
-      logger.debug "creating #{self.class} #{class_name}::#{name} @ #{@address} with value #{value} / wtype #{wtype}"
+      raise "Error: #{self.class} #{self.wasm_name} already created!" if DAta.exist? self.wasm_name.to_sym
+      @data = DAta.new(self.wasm_name.to_sym, value, wtype) unless wtype.name == :Class
+      logger.debug "creating #{self.class} #{self.class_name}::#{name} @ #{@address} with value #{value} / wtype #{wtype}"
+    end
+
+    def class_name
+      @klass.name
     end
 
     def address

data/lib/rlang/parser/data.rb

@@ -23,13 +23,14 @@ module Rlang::Parser
     def initialize(label, value, wtype=WType::DEFAULT)
       raise "Data label '#{label}' already initialized" \
         if self.class.exist? label
+      logger.debug "@@current_address: #{@@current_address}"
       @label = label
       @wtype = wtype
       @address = @@current_address
       @@label_table[@label] = self
       @value = []
       self.append_value(value, wtype)
-      logger.debug "New Data[#{@label}] initialized with #{@value} at address #{@address}"
+      logger.debug "New Data[#{@label}] initialized with #{@value} at address #{@address} / new current address: #{@@current_address}"
     end
 
     def self.reset!
@@ -39,7 +40,7 @@ module Rlang::Parser
 
     def append_value(value, wtype)
       @value << value
-      if value.is_a?(String) 
+      if value.is_a? String
         @@current_address += value.length
       else
         logger.warn "Data type #{@wtype} misaligned!!! (Data[:#{@label}] value #{value} at address #{@address}" \
@@ -71,6 +72,8 @@ module Rlang::Parser
     end
 
     def self.address=(address)
+      logger.fatal "ERROR!! Cannot decrease current DAta address (was #{@@current_address}, got #{address}) " \
+        if address < @@current_address
       @@current_address = address
     end
 

data/lib/rlang/parser/ivar.rb

@@ -11,11 +11,11 @@ require_relative './data'
 module Rlang::Parser
   class IVar
     include Log
-    attr_reader :name
+    attr_reader :name, :klass
     attr_accessor :wtype, :offset
 
-    def initialize(class_wnode, name, wtype=WType::DEFAULT)
-      @class_wnode = class_wnode
+    def initialize(klass, name, wtype=WType::DEFAULT)
+      @klass = klass
       @name = name
       @wtype = wtype
       # this is the offset of the instance variable
@@ -26,10 +26,6 @@ module Rlang::Parser
       logger.debug "Instance variable #{name} created"
     end
 
-    def class_name
-      @class_wnode.class_name
-    end
-
     def size
       @wtype.size
     end

data/lib/rlang/parser/klass.rb

@@ -1,52 +1,25 @@
 # Rubinius WebAssembly VM
-# Copyright (c) 2019, Laurent Julliard and contributors
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
 # All rights reserved.
 
 # Rlang classes
 require_relative '../../utils/log'
 require_relative './wtype'
+require_relative './const'
+require_relative './module'
 
 module Rlang::Parser
   # Note: Cannot use Class as class name
   # because it's already used by Ruby
-  class Klass
+  class Klass < Module
     include Log
 
-    attr_reader :wtype
-    attr_accessor :name, :wnode, :attrs, :ivars, :cvars, 
-                  :consts, :methods, :offset
+    attr_accessor   :super_class
 
-    def initialize(name)
-      @name = name
-      # the type of a class is its name by definition
-      @wtype = WType.new(name)
-      @size = 0
-      # the wnode implementing the code of the class
-      @wnode = nil
-      logger.debug "Klass created #{self.inspect}"
-      @attrs  = [] # class attributes
-      @ivars   = [] # instance variables
-      @cvars   = [] # class variables
-      @consts  = [] # class constants
-      @methods = [] # methods
-      @offset  = 0  # offset of the next class attribute in memory
+    def initialize(const, scope_class, super_class)
+      super(const, scope_class)
+      self.super_class = super_class
     end
 
-    def size
-      @offset
-    end
-
-    def wtype=(wtype)
-      @wtype = wtype
-      logger.debug "Klass #{@name} wtype updated: #{self.inspect}"
-    end
-
-    def wasm_name
-      @name
-    end
-
-    def wasm_type
-      @wtype.wasm_type
-    end
   end
 end

data/lib/rlang/parser/method.rb

@@ -13,24 +13,31 @@ module Rlang::Parser
   class MEthod
     include Log
 
-    attr_reader :name, :wtype
-    attr_accessor :class_name, :margs, :lvars, :wnode
+    attr_reader :name, :wtype, :method_type, :wnode
+    attr_accessor :klass, :margs, :lvars
 
-    METHOD_TYPES = [:class, :instance]
+    METHOD_TYPES = [:instance, :class]
 
-    def initialize(name, class_name, wtype, method_type)
+    def initialize(name, klass, wtype, method_type)
       raise "Wrong method wtype argument: #{wtype.inspect}" unless wtype.is_a? WType
       @name = name
-      @class_name = class_name
+      @klass = klass
       @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}"
+      @wnode = nil  # wnode where this method is implemented
+      logger.debug "Method created #{name} in class #{klass.name} / ID:#{self}"
       @margs = []   # method args
       @lvars = []   # local variables
     end
 
+    # Setup bidirectional links between
+    # wnode and method
+    def wnode=(wnode)
+      @wnode = wnode
+      wnode.method = self
+    end
+
     def implemented?
       !@wnode.nil?
     end
@@ -58,10 +65,12 @@ module Rlang::Parser
     end
 
     def wasm_name
+      # [] method name is illegal in Wasm function name
+      name = @name.to_s.sub(/\[\]/, 'brackets').to_sym
       if self.instance?
-        "$#{@class_name}##{@name}"
+        "$#{@klass.path_name}##{name}"
       else
-        "$#{@class_name}::#{@name}"
+        "$#{@klass.path_name}::#{name}"
       end
     end
 
@@ -70,10 +79,12 @@ module Rlang::Parser
     end
 
     def export_name
+      # [] method name is illegal in Wasm function name
+      name = @name.to_s.sub(/\[\]/, 'brackets').to_sym
       if self.instance?
-        "#{@class_name.downcase}_i_#{@name}"
+        "#{@klass.path_name.downcase}_i_#{name}"
       else
-        "#{@class_name.downcase}_c_#{@name}"
+        "#{@klass.path_name.downcase}_c_#{name}"
       end
     end
 

data/lib/rlang/parser/module.rb

@@ -0,0 +1,143 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+
+# Rlang classes
+require_relative '../../utils/log'
+require_relative './const'
+
+module Rlang::Parser
+  class Module
+    include Log
+
+    attr_reader   :wtype, :const
+    attr_accessor :wnode, :attrs, :ivars, :cvars, 
+                  :consts, :methods, :offset,
+                  :includes, :extends
+
+    def initialize(const, scope_class)
+      @const = const
+      # upper lexical class or module
+      logger.debug "scope_class: #{scope_class}"
+      @const.scope_class = scope_class
+      # the wtype of a Class/Module is either :Class or :Module
+      @wtype = WType.new(@const.path_name)
+      # memory space used by ivars in bytes
+      @size = 0
+      # the wnode implementing the code of the class
+      @wnode = nil
+      @super_class = nil
+      @attrs     = [] # class attributes
+      @ivars     = [] # instance variables
+      @cvars     = [] # class variables
+      # Note: the consts list is fed from the Const class
+      # on purpose so that it applies to any constant not jus
+      # Classes and modules
+      @consts    = [] # class constants
+      @methods   = [] # methods
+      @offset    = 0  # memory offset of next ivar
+
+      # Modules included/extended/prepended in 
+      # this module/class
+      @modules   = [] # all modules included, prepended, extended
+      @includes  = [] # modules included
+      @prepends  = [] # modules prepended
+      @extends   = [] # modules extended
+
+      # Is this module extended, included, prepended ?
+      @extended  = false
+      @included  = false
+      @prepended = false
+
+      # Associated constant/value points to the class/module
+      @const.value = self
+      logger.debug "Created Class/Module #{@const} / #{self}"
+    end
+
+    def object_class?
+      self.const.name == :Object && self.const.scope_class == self
+    end
+
+    def name
+      @const.name
+    end
+
+    def path
+      @const.path
+    end
+
+    def path_name
+      @const.path_name
+    end
+
+    # Do not include the top class Object in nesting
+    def nesting
+      sk = nil; k = self; n = [k]
+      while (sk = k.const.scope_class) && (sk != k) && !sk.object_class?
+        logger.debug "k: #{k.name}/#{k}, sk: #{sk.name}/#{sk}, sk.object_class? #{sk.object_class?}"
+        n.unshift(sk)
+        k = sk
+      end
+      logger.debug "Class#nesting : #{n.map(&:name)}"
+      n
+    end
+
+    def include(klass)
+      @modules   |= [klass]
+      @includes  |= [klass]
+    end
+
+    def prepend(klass)
+      @modules   |= [klass]
+      @prepends  |= [klass]
+    end
+
+    def extend(klass)
+      @modules   |= [klass]
+      @extends   |= [klass]
+    end
+
+    def ancestors
+      @prepends.reverse + [self] + @includes.reverse + @extends.reverse + \
+        (@super_class ? @super_class.ancestors : [])
+    end
+
+    def const_get(name)
+      consts.find { |c| c.name == name}
+    end
+
+    def delete_instance_methods
+      @methods.select { |m| m.instance? }.each { |m| m.wnode.delete!; @methods.delete(m) }
+    end
+
+    def delete_class_methods
+      self.methods.select { |m| m.class? }.each { |m| m.wnode.delete!; @methods.delete(m) }
+    end
+
+    def size
+      @offset
+    end
+
+    def wtype=(wtype)
+      @wtype = wtype
+      logger.debug "#{self.class} #{@name} wtype updated: #{self.inspect}"
+    end
+
+    def wasm_name
+      @name
+    end
+
+    def wasm_type
+      @wtype.wasm_type
+    end
+
+    def extended?; @extended; end
+    def extended!; @extended = true; end
+
+    def included?; @included; end
+    def included!; @included = true; end
+
+    def prepended?; @prepended; end
+    def prepended!; @prepended = true; end
+  end
+end