rlang 0.4.1 → 0.6.0

data/lib/rlang/parser/ext/type.rb

@@ -2,6 +2,18 @@ module Type
 
   class I64 < Numeric
     MAX = 2**64 - 1
+    MIN = 0
+    def self.signed?; true; end
+    def size; 8; end  # size in bytes
+    def self.size; 8; end # size in bytes
+    def wasm_type; 'i64'; end
+    def self.wasm_type; 'i64'; end
+  end
+
+  class UI64 < Numeric
+    MAX = 2**63 - 1
+    MIN = -2**63
+    def self.signed?; false; end
     def size; 8; end  # size in bytes
     def self.size; 8; end # size in bytes
     def wasm_type; 'i64'; end
@@ -9,9 +21,23 @@ module Type
   end
 
   class I32 < Numeric
-    MAX = 2**64 - 1
+    MAX = 2**31 - 1
+    MIN = -2**31
+    def initialize(v); @v = Integer(v); end
+    def +(v); I32.new(v + @v); end
+    def self.signed?; true; end
+    def size; 4; end # size in bytes
+    def self.size; 4; end # size in bytes
+    def wasm_type; 'i32'; end
+    def self.wasm_type; 'i32'; end
+  end
+
+  class UI32 < Numeric
+    MAX = 2**32 - 1
+    MIN = 0
     def initialize(v); @v = Integer(v); end
     def +(v); I32.new(v + @v); end
+    def self.signed?; false; end
     def size; 4; end # size in bytes
     def self.size; 4; end # size in bytes
     def wasm_type; 'i32'; end
@@ -20,6 +46,7 @@ module Type
 
   class F64 < Numeric
     MAX = 1.7976931348623158E308
+    def self.signed?; true; end
     def size; 8; end # size in bytes
     def wasm_type; 'f64'; end
     def self.size; 8; end # size in bytes
@@ -29,6 +56,7 @@ module Type
   class F32 < Numeric
     MAX = 3.4028235E38
     # size in bytes
+    def self.signed?; true; end
     def size; 4; end  
     def wasm_type; 'f32'; end
     def self.size; 4; end  
@@ -60,5 +88,6 @@ module Type
   end
 
   DEFAULT = Type::I32
+  UNSIGNED_DEFAULT = Type::UI32
 
 end

data/lib/rlang/parser/global.rb

@@ -52,7 +52,15 @@ module Rlang::Parser
       '(export  "%s" (global %s (mut %s)))' % [self.export_name, self.wasm_name, self.wtype.wasm_type]
     end
 
-    def self.transpile
+    def self.transpile(depth)
+      # TODO : we should probably do that in a less "hardcoded" way
+      # Adjust the Heap base address to start after the static DAta
+      # section
+      g_heap = Global.find(:$HEAP)
+      g_heap.value = [DAta.align(8), g_heap.value].max if g_heap
+      
+      # Go generate code now
+      indent = ' ' * depth * 2
       output = []
       @@globals.each do |g|
         if g.mutable?
@@ -63,7 +71,7 @@ module Rlang::Parser
                     % {name: g.wasm_name, type: g.wtype.wasm_type, value: g.value}
         end
       end
-      output.join("\n")
+      indent + output.join("\n#{indent}")
     end
   end
 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,22 +13,32 @@ 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_writer :export_name
+    attr_accessor :klass, :margs, :lvars, :export_as
 
-    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
+
+      @export_name = nil
+    end
+
+    # Setup bidirectional links between
+    # wnode and method
+    def wnode=(wnode)
+      @wnode = wnode
+      wnode.method = self
     end
 
     def implemented?
@@ -58,10 +68,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,14 +82,26 @@ module Rlang::Parser
     end
 
     def export_name
+      return @export_name if @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
 
-    def export!
+    def imported!
+      @imported = true
+    end
+
+    def imported?
+      @imported
+    end
+
+    def export!(export_name=nil)
+      @export_name = export_name
       Export.new(self)
     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