rlang 0.5.0 → 0.5.1

data/lib/rlang/parser/const.rb

@@ -68,7 +68,7 @@ module Rlang::Parser
     end
 
     def data=(value)
-      @data = DAta.new(self.wasm_name.to_sym, value, @wtype)
+      @data = DAta.new(self.path_name.to_sym, value, @wtype)
     end
 
     # the symbol form of this constant path

data/lib/rlang/parser/cvar.rb

@@ -26,7 +26,7 @@ module Rlang::Parser
     end
 
     def class_name
-      @klass.name
+      @klass.path_name
     end
 
     def address
@@ -38,7 +38,7 @@ module Rlang::Parser
     end
 
     def wasm_name
-      "$#{@class_name}::#{@name}"
+      "$#{self.class_name}::#{@name}"
     end
 
     def wasm_type

data/lib/rlang/parser/data.rb

@@ -39,14 +39,16 @@ module Rlang::Parser
     end
 
     def append_value(value, wtype)
+      logger.warn "Data type #{@wtype} misaligned!!! (Data[:#{@label}] value #{value} at address #{@address}" \
+        unless self.aligned?
       @value << value
       if value.is_a? String
         @@current_address += value.length
       else
-        logger.warn "Data type #{@wtype} misaligned!!! (Data[:#{@label}] value #{value} at address #{@address}" \
-          unless self.aligned?
         @@current_address += @wtype.size
       end
+      # Always make sure current address is aligned
+      self.class.align(WType::DEFAULT.size)
     end
 
     def aligned?
@@ -89,7 +91,8 @@ module Rlang::Parser
 
     # Transpile data to WAT code
     # in order of increasing address
-    def self.transpile
+    def self.transpile(depth)
+      indent = ' ' * depth * 2
       output = []
       @@label_table.sort_by {|s,d| d.address}.each do |s,d|
         logger.debug "Generating data #{d.inspect}"
@@ -109,7 +112,7 @@ module Rlang::Parser
           end
         end
       end
-      output.join("\n")
+      indent + output.join("\n #{indent}")
     end
   end
 

data/lib/rlang/parser/export.rb

@@ -17,10 +17,11 @@ module Rlang::Parser
 
     # Export Rlang funcs, etc... grouping them
     # by object type for Wasm code readability
-    def self.transpile
-      @@exports.sort_by {|e| e.object.class.to_s}.collect do |export|
+    def self.transpile(depth)
+      indent = ' ' * depth * 2
+      indent + @@exports.sort_by {|e| e.object.class.to_s}.collect do |export|
         export.object.export_wasm_code
-      end.join("\n")
+      end.join("\n#{indent}")
     end
   end
 end

data/lib/rlang/parser/global.rb

@@ -52,7 +52,8 @@ 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)
+      indent = ' ' * depth * 2
       output = []
       @@globals.each do |g|
         if g.mutable?
@@ -63,7 +64,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/method.rb

@@ -14,7 +14,8 @@ module Rlang::Parser
     include Log
 
     attr_reader :name, :wtype, :method_type, :wnode
-    attr_accessor :klass, :margs, :lvars
+    attr_writer :export_name
+    attr_accessor :klass, :margs, :lvars, :export_as
 
     METHOD_TYPES = [:instance, :class]
 
@@ -29,6 +30,8 @@ module Rlang::Parser
       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
@@ -79,6 +82,7 @@ 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?
@@ -88,7 +92,16 @@ module Rlang::Parser
       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/wgenerator.rb

@@ -112,7 +112,7 @@ 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
@@ -120,6 +120,20 @@ module Rlang::Parser
       @new_count = 0
       @static_count = 0
 
+      # 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], [])
@@ -222,17 +236,24 @@ module Rlang::Parser
     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_or_create_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_type = :instance
+        method_types << :instance
+        method_types << :class if klass.const.module?
         mth_name = method_name[1..-1].to_sym
       else
-        method_type = :class
+        method_types << :class
+        method_types << :instance if klass.const.module?
         mth_name = method_name.to_sym
       end
-      (m = wnode.find_or_create_method(klass, mth_name, method_type, nil)).wtype = WType.new(result_type)
-      logger.debug "Declared #{method_type} method #{m.name} in class #{m.klass.name} with wtype #{m.wtype.name}"
-      m
+      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
@@ -283,7 +304,7 @@ module Rlang::Parser
       size_method = wnc.find_or_create_method(klass, SIZE_METHOD, :class, WType::DEFAULT)
       unless size_method.wnode
         logger.debug("Generating #{size_method.klass.name}\##{size_method.name}")
-        wns = WNode.new(:insn, wnc, true)
+        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)
@@ -318,20 +339,41 @@ module Rlang::Parser
       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.wtype = method.wtype
       wn.c(:func, func_name: wn.method.wasm_name)
-      # On instance method also declare a first parameter
-      # called _self_ representing the pointer to the
-      # object instance
+
+      # Instance methods 1st argument is always self
       wn.create_marg(:_self_) if method.instance?
-      logger.debug("Building #{method_type} method: wn.wtype #{wn.wtype}, wn.method #{wn.method}")
+      logger.debug("Built #{method_type} method definition: wn.wtype #{wn.wtype}, wn.method #{wn.method}")
       wn
     end
 
+    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)
       wnm = wnode.method_wnode
       # use reverse to preserve proper param order
@@ -384,6 +426,13 @@ module Rlang::Parser
       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
@@ -450,6 +499,14 @@ module Rlang::Parser
       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
@@ -490,9 +547,8 @@ module Rlang::Parser
     # 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
@@ -702,7 +758,7 @@ module Rlang::Parser
       # no need to define new method for native types
       return if wnode_class.klass.wtype.native?
       if (new_mth = wnode_class.find_method(k, :new, :class, true))
-        return if new_mth.wnode # already implemented
+        return if new_mth.implemented? # already implemented
       end
       
       logger.debug "Creating code for #{k.name}.new"

data/lib/rlang/parser/wnode.rb

@@ -21,6 +21,7 @@ module Rlang::Parser
     # WASM code templates
     T = {
       func: 'func %{func_name}',
+      import: 'import "%{module_name}" "%{function_name}"',
       param: 'param %{name} %{wasm_type}',
       result: 'result %{wasm_type}',
       return: 'return',
@@ -57,12 +58,15 @@ module Rlang::Parser
   (local.get %{attr_name})
   (%{wtype}.store offset=%{offset} (local.get $_self_) (local.get %{attr_name}))},
       class_size: %q{func %{func_name} (result %{wtype})
-  (%{wtype}.const %{size})}
+  (%{wtype}.const %{size})},
+      comment: ';; %{comment}',
+      memory: 'memory $0 %{min} %{max}',
+      module: 'module %{module}'
     }
 
     attr_accessor :type, :wargs, :children, :parent, :comment, 
                   :method, :template, :keep_on_stack, :classes,
-                  :modules
+                  :modules, :link
     attr_reader :wtype, :label, :klass, :module
 
     @@label_index = 0
@@ -98,6 +102,10 @@ module Rlang::Parser
       # For insn wnode with 
       # label (.e.g block, loop)
       @label = nil
+
+      # link to a related node
+      # Semantic of the link depend on the wnode type
+      @link = nil
     end
 
     def self.root
@@ -168,7 +176,7 @@ module Rlang::Parser
     end
     alias :<< :add_child
 
-    # Remove child to current node
+    # Remove child from current node
     def remove_child(wnode)
       logger.debug "Removing #{wnode.object_id} from wnodes list #{self.children.map(&:object_id)} under parent #{self.parent.object_id}"
       unless (wn = self.children.delete(wnode)) && wn == wnode
@@ -204,8 +212,8 @@ module Rlang::Parser
 
     # insert a blank wnode above self, so between self wnode 
     # and its parent (self -> parent becomes self -> wn -> parent)
-    def insert(wtype=:none)
-      wn = WNode.new(wtype, self.parent)
+    def insert(type=:none)
+      wn = WNode.new(type, self.parent)
       self.reparent_to(wn)
       wn
     end
@@ -217,6 +225,13 @@ module Rlang::Parser
       self.parent.remove_child(self)
     end
 
+    # Silence the current wnode (which means
+    # inserting a silent type wnode between this
+    # and its parent)
+    def silence!
+      self.insert(:silent)
+    end
+
     def klass=(klass)
       @klass = klass
       @klass.wnode = self
@@ -519,7 +534,7 @@ module Rlang::Parser
       if (mn = self.method_wnode)
         mn.method.margs << (marg = MArg.new(name))
       else
-        raise "No class found for class variable #{marg}"
+        raise "No class found for method argument #{marg}"
       end
       marg
     end
@@ -659,6 +674,10 @@ module Rlang::Parser
       !self.module_wnode.nil? && !self.in_method_scope?
     end
 
+    def in_class_or_module_scope?
+      self.in_class_scope? || self.in_module_scope?
+    end
+
     def in_root_scope?
       self.root? || (self.parent.root? && !self.in_class_scope?)
     end
@@ -688,17 +707,41 @@ module Rlang::Parser
     end
 
     # Generate WAT code starting for this node and tree branches below
-    def transpile(indent=0)
+    def transpile(depth=0)
+      # follow children first and then go on with
+      # the wnode link if it exits
+      children = self.children + (self.link ? [self.link] : [])
+      indent = ' ' * depth * 2
+      logger.debug "children: #{self} / #{children.map(&:head)}" if self.link
+
       case @type
-      when :insn, :method
+      # Section nodes  
+      when :imports
+        "\n%s;;============= %s SECTION ===============\n" % [indent, @type.to_s.upcase] +
+        children.map { |wn| wn.transpile(depth) }.join('')
+      when :data
+        "\n\n%s;;============= %s SECTION ===============\n" % [indent, @type.to_s.upcase] +
+        DAta.transpile(depth)
+      when :globals
+        "\n\n%s;;============= %s SECTION ===============\n" % [indent, @type.to_s.upcase] +
+        Global.transpile(depth)
+      when :exports
+        "\n\n%s;;============= %s SECTION ===============\n" % [indent, @type.to_s.upcase] +
+        "%s(export \"memory\" (memory $0))\n" % [indent] +
+        Export.transpile(depth)        
+      when :insn, :method, :root
         if @template == :inline
-          "\n%s%s" % [' '*2*indent, self.wasm_code]
+          "\n%s%s" % [indent, self.wasm_code]
         else
-          "\n%s(%s" % [' '*2*indent, self.wasm_code] + self.children.map { |wn| wn.transpile(indent+1) }.join('') + ')'
+          "\n%s(%s" % [indent, self.wasm_code] + children.map { |wn| wn.transpile(depth+1) }.join('') + ')'
         end
-      when :root, :class, :module, :none
+      when :class, :module, :none, :memory
         # no WAT code to generate for these nodes. Process children directly.
-        self.children.map { |wn| wn.transpile(indent) }.join('')
+        children.map { |wn| wn.transpile(depth) }.join('')
+      when :silent
+        # Do not generate any WAT code for a silent node and
+        # and its children
+        ''
       else
         raise "Error: Unknown wnode type #{@type}. No WAT code generated"
       end

data/lib/rlang/version.rb

@@ -1,3 +1,3 @@
 module Rlang
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rlang
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Laurent Julliard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-25 00:00:00.000000000 Z
+date: 2020-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -130,20 +130,23 @@ files:
 - lib/builder/wat/builder.rb
 - lib/builder/wat/renderer.rb
 - lib/rlang.rb
-- lib/rlang/lib.rb
 - lib/rlang/lib/array.rb
 - lib/rlang/lib/array/array32.rb
 - lib/rlang/lib/array/array64.rb
+- lib/rlang/lib/io.rb
 - lib/rlang/lib/kernel.rb
 - lib/rlang/lib/malloc.c
 - lib/rlang/lib/malloc.rb
 - lib/rlang/lib/memory.rb
 - lib/rlang/lib/object.rb
+- lib/rlang/lib/rlang.rb
+- lib/rlang/lib/rlang_core.rb
 - lib/rlang/lib/string.rb
 - lib/rlang/lib/type.rb
 - lib/rlang/lib/type/i32.rb
 - lib/rlang/lib/type/i64.rb
 - lib/rlang/lib/unistd.rb
+- lib/rlang/lib/wasi.rb
 - lib/rlang/parser.rb
 - lib/rlang/parser/attr.rb
 - lib/rlang/parser/const.rb