rlang 0.4.0 → 0.4.1

data/lib/rlang/parser/wnode.rb

@@ -9,7 +9,7 @@ require_relative './wtype'
 require_relative './const'
 require_relative './cvar'
 require_relative './lvar'
-require_relative './wattr'
+require_relative './attr'
 require_relative './method'
 require_relative './klass'
 
@@ -26,7 +26,9 @@ module Rlang::Parser
       local: 'local %{name} %{wasm_type}',
       call: 'call %{func_name}',
       store: '%{wasm_type}.store',
+      store_offset: '%{wasm_type}.store offset=%{offset}',
       load: '%{wasm_type}.load',
+      load_offset: '%{wasm_type}.load offset=%{offset}',
       local_get: 'local.get %{var_name}',
       local_set: 'local.set %{var_name}',
       global_get: 'global.get %{var_name}',
@@ -48,11 +50,11 @@ module Rlang::Parser
       br_if: 'br_if %{label}',
       br: 'br %{label}',
       inline: '%{code}',
-      wattr_reader: %q{func %{func_name} (param $_self_ i32) (result %{wtype})
+      attr_getter: %q{func %{func_name} (param $_self_ i32) (result %{wtype})
   (%{wtype}.load offset=%{offset} (local.get $_self_))},
-      wattr_writer: %q{func %{func_name} (param $_self_ i32) (param %{wattr_name} %{wtype}) (result %{wtype})
-  (local.get %{wattr_name})
-  (%{wtype}.store offset=%{offset} (local.get $_self_) (local.get %{wattr_name}))},
+      attr_setter: %q{func %{func_name} (param $_self_ i32) (param %{attr_name} %{wtype}) (result %{wtype})
+  (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})}
     }
@@ -82,9 +84,14 @@ module Rlang::Parser
 
       # For root wnode
       @classes = [] # classes
-
+      # top level class needed only if const are
+      # defined at top level
+      # NOTE: can't use create_klass as it find_class
+      # which doesn't find root class ... endless loop!!
+    
       # For class wnode only
-      @klass = nil
+      @@klass = nil
+      self.klass = Klass.new(:Top__) if self.root?
 
       # For method wnode only
       @method = nil
@@ -164,26 +171,38 @@ module Rlang::Parser
 
     # Remove child to current node
     def remove_child(wnode)
-      logger.debug "Removing #{wnode.object_id} from #{self.children.map(&:object_id)}"
-      wn = self.children.delete(wnode) do 
-        logger.error "Couldn't find wnode ID #{wnode.object_id} (#{wnode})"
-        raise
+      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
+        raise "Couldn't find wnode ID #{wnode.object_id} (#{wnode})"
       end
       wn.parent = nil
       #logger.debug "Removed #{wnode.object_id} from #{self.object_id} (children: #{self.children.map(&:object_id)})"
-      wn
+      wnode
     end
     alias :>> :remove_child
     
     # Reparent self node to another wnode
     def reparent_to(wnode)
-      return if self.parent == wnode
-      logger.debug "Reparenting #{self.object_id} to #{wnode.object_id}"
-      old_parent, new_parent = self.parent, wnode
-      new_parent << self
-      old_parent >> self if old_parent
+      unless self.parent == wnode
+        logger.debug "Reparenting #{self.object_id} from #{self.parent.object_id} to #{wnode.object_id}"
+        old_parent, new_parent = self.parent, wnode
+        old_parent >> self if old_parent
+        new_parent << self
+      end
+      self
     end
 
+      # Reparent all children wnodes to another wnode
+      # (in the same order)
+      # WARNING!! Do not use self.children.each { } to
+      # reparent because we are modifying children list
+      # as we go
+      def reparent_children_to(wnode)
+        wnc = self.children
+        wnc.count.times { wnc.first.reparent_to(wnode) }
+        self
+      end
+
     # insert a blank wnode above self, so between self wnode 
     # and its parent (self -> parent becomes self -> wn -> parent)
     def insert(wtype=:none)
@@ -196,6 +215,7 @@ module Rlang::Parser
       @klass = klass
       @klass.wnode = self
       WNode.root.classes << klass
+      klass
     end
 
     # Find class name in this node and up the tree
@@ -212,19 +232,27 @@ module Rlang::Parser
     # if no name given or lookup the matching class from
     # the root level if class name given
     def find_class(class_name)
-      logger.debug "looking for class #{class_name ? class_name : 'current'}"
+      logger.debug "looking for class #{class_name ? class_name : 'current'} 
+        in scope #{self.scope} at wnode #{self}"
       if class_name
-        c = WNode.root.classes.find { |c| c.name == class_name }
+        c = WNode.root.classes.find { |c| 
+          logger.debug "**** looking for class #{class_name} in class object #{c} / #{c.name}"; c.name == class_name }
       else
-        logger.debug "Looking for class wnode from wnode #{self} / ID: #{self.object_id} / 
-        type: #{self.type} / class_wnode ID #{self.class_wnode.object_id} / 
-        class_wnode #{self.class_wnode} /
-        self klass : #{self.klass} / 
-        self klass wtype : #{self.klass&.wtype} / "
-        c = self.class_wnode.klass
+        if self.in_root_scope?
+          # if at root level and no class name given
+          # then it's the top level class
+          c = self.class.root.klass
+        else
+          logger.debug "Looking for class wnode from wnode #{self} / ID: #{self.object_id} / 
+          type: #{self.type} / class_wnode ID #{self.class_wnode.object_id} / 
+          class_wnode #{self.class_wnode} /
+          self klass : #{self.klass} / 
+          self klass wtype : #{self.klass&.wtype} / "
+          c = self.class_wnode.klass
+        end
       end    
       if c
-        logger.debug "Found class #{c}"
+        logger.debug "Found class #{c.name} / #{c}"
       else
         logger.debug "Class #{class_name} not found"
       end
@@ -234,14 +262,9 @@ module Rlang::Parser
     # Create a Class object. **NOTE** the self
     # wnode must be the parent of the new class
     def create_class(class_name)
-      if (k = self.find_class(class_name))
-        raise "Cannot create class #{class_name} for wnode #{self} as it already exists!!"
-      else
-        wnc = WNode.new(:class, self)
-        wnc.klass = Klass.new(class_name)
-        logger.debug "Created class #{wnc.klass} under wnode #{self} / id: #{self.object_id}"
-        logger.debug "k inspection: #{wnc.klass}"
-      end
+      wnc = WNode.new(:class, self)
+      wnc.klass = Klass.new(class_name)
+      logger.debug "Created class #{wnc.klass} under wnode #{self} / id: #{self.object_id}"
       wnc.klass
     end
 
@@ -251,65 +274,73 @@ module Rlang::Parser
 
     # create a constant 
     def create_const(c_name, class_name, value, wtype)
-      class_name ||= self.class_name
+      k = find_class(class_name)
+      logger.debug "Creating constant #{c_name} in class #{k&.name} / wtype: #{wtype} at wnode #{self.class_wnode}..."
       if (cn = self.class_wnode)
-        cn.klass.consts << (const = Const.new(class_name, c_name, value, wtype))
+        cn.klass.consts << (const = Const.new(k.name, c_name, value, wtype))
       else
         raise "No class found for class constant #{const}"
       end
       const
     end
 
-    # Look for constant in the appropriate class wnode
-    # (it can be the current class or another class)
+    # Look for constant 
     def find_const(c_name, class_name=nil)
+      logger.debug "looking for constant #{c_name} in class #{class_name ? class_name : 'current'} from wnode #{self}..."
       k = find_class(class_name)
-      raise "Can't find parent class for constant #{c_name}" unless k
-      class_name = k.name
-      logger.debug "looking for const #{c_name} in class #{class_name} at wnode #{self.class_wnode}..."
-      k.consts.find { |c| c.class_name == class_name && c.name == c_name }
+      # Look for the constant both in current class and a roor class level
+      const = [k, @@root.klass].map(&:consts).flatten.find do |c| 
+        logger.debug "exploring constant #{c} / name: #{c.name} / class_name: #{c.class_name}";
+        c.name == c_name
+      end
+      if const
+        logger.debug "Constant #{c_name} found in class #{k.name} at wnode #{k.wnode}..."
+      else
+        logger.debug "Constant #{c_name} not found in class #{k.name} or at top level..."
+      end
+      const
     end
 
     def find_or_create_const(c_name, class_name, value, wtype)
       self.find_const(c_name, class_name) || self.create_const(c_name, class_name, value, wtype)
     end
 
-    def find_wattr(wa_name, class_name=nil)
+    def find_attr(name, class_name=nil)
       k = find_class(class_name)
-      raise "Can't find parent class for wattr #{wa_name}" unless k
-      logger.debug "looking for wattr #{wa_name} in class #{k.name} at wnode #{self.class_wnode}..."
-      k.wattrs.find { |wa| wa.class_name == k.name && wa.name == wa_name }
+      raise "Can't find parent class for attr #{name}" unless k
+      logger.debug "looking for attr #{name} in class #{k.name} at wnode #{self.class_wnode}..."
+      k.attrs.find { |a| a.class_name == k.name && a.name == name }
     end
 
-    def create_wattr(wa_name, wtype=WType::DEFAULT)
+    def create_attr(name, wtype=WType::DEFAULT)
       if (cn = self.class_wnode)
-        logger.debug "creating wattr #{wa_name} in class #{self.class_name} at wnode #{self.class_wnode}..."
-        cn.klass.wattrs << (wattr = WAttr.new(cn, wa_name, wtype))
+        logger.debug "creating attr #{name} in class #{self.class_name} at wnode #{self.class_wnode}..."
+        cn.klass.attrs << (_attr = Attr.new(cn, name, wtype))
       else
-        raise "No class found for class attribute #{wa_name}"
+        raise "No class found for class attribute #{name}"
       end
-      wattr
+      _attr
     end
 
-    def find_or_create_wattr(wa_name, class_name=nil, wtype=WType::DEFAULT)
-      find_wattr(wa_name, class_name) || create_wattr(wa_name, wtype)
+    def find_or_create_attr(name, class_name=nil, wtype=WType::DEFAULT)
+      find_attr(name, class_name) || create_attr(name, wtype)
     end
 
     def create_ivar(iv_name, wtype=WType::DEFAULT)
       if (cn = self.class_wnode)
         logger.debug "creating ivar #{iv_name} in class #{self.class_name} at wnode #{self.class_wnode}..."
-        cn.klass.wattrs << (wattr = WAttr.new(cn, iv_name, wtype))
+        cn.klass.ivars << (ivar = IVar.new(cn, iv_name, wtype))
       else
         raise "No class found for instance variable #{iv_name}"
       end
-      wattr
+      ivar
     end
 
     def find_ivar(iv_name, class_name=nil)
       klass = find_class(class_name)
       raise "Can't find parent class for ivar #{iv_name}" unless klass
       logger.debug "looking for ivar #{iv_name} in class #{class_name} at wnode #{self.class_wnode}..."
-      self.class_wnode.klass.wattrs.find { |wa| wa.ivar.class_name == klass.name && wa.ivar.name == iv_name }
+      self.class_wnode.klass.ivars.find { |iv| iv.class_name == klass.name && iv.name == iv_name }
     end
 
     def find_or_create_ivar(iv_name)
@@ -369,30 +400,30 @@ module Rlang::Parser
       end
       if (cn = self.class_wnode)
         class_name ||= cn.klass.name
-        cn.klass.methods << (method = MEthod.new(method_name, class_name, wtype))
+        cn.klass.methods << (method = MEthod.new(method_name, class_name, wtype, method_type))
       else
         raise "No class wnode found to create method #{method_name}"
       end
-      method_type == :class ? method.class! : method.instance!
       logger.debug "Created MEthod: #{method}"
       method
     end
 
     # method_type is either :instance or :class
     def find_method(method_name, class_name, method_type)
+      logger.debug "looking for #{method_type} method '#{method_name}' in class name '#{class_name}' from wnode #{self}"
       k = self.find_class(class_name)
-      raise "Couldn't find class wnode for class_name #{class_name}" unless k
+      return nil unless k
       if method_type == :class
-        method = k.methods.find { |m| m.name == method_name && m.class_name == class_name && m.class? }
+        method = k.methods.find { |m| m.name == method_name && m.class_name == k.name && m.class? }
       elsif method_type == :instance
-        method = k.methods.find { |m| m.name == method_name && m.class_name == class_name && m.instance? }
+        method = k.methods.find { |m| m.name == method_name && m.class_name == k.name && m.instance? }
       else
         raise "Unknown method type : #{method_type.inspect}"
       end
       if method
-        logger.debug "Found MEthod: #{method}"
+        logger.debug "Found #{method_type} MEthod: #{k.name},#{method}"
       else
-        logger.debug "Couldn't find MEthod: #{k.name},#{method_name}"
+        logger.debug "Couldn't find #{method_type} MEthod: #{k.name},#{method_name}"
       end
       method
     end
@@ -463,7 +494,7 @@ module Rlang::Parser
     end
 
     def in_root_scope?
-      self.root? || self.parent.root?
+      self.root? || (self.parent.root? && !in_class_scope?)
     end
 
     def method?
@@ -471,7 +502,7 @@ module Rlang::Parser
     end
 
     def class?
-      self.type == :class
+      self.type == :class || self.type == :root 
     end
 
     # format the wnode and tree below

data/lib/rlang/version.rb

@@ -1,3 +1,3 @@
 module Rlang
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rlang
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Laurent Julliard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-13 00:00:00.000000000 Z
+date: 2020-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -135,11 +135,13 @@ files:
 - lib/rlang/lib/malloc.rb
 - lib/rlang/lib/memory.rb
 - lib/rlang/lib/object.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/parser.rb
+- lib/rlang/parser/attr.rb
 - lib/rlang/parser/const.rb
 - lib/rlang/parser/cvar.rb
 - lib/rlang/parser/data.rb
@@ -153,7 +155,6 @@ files:
 - lib/rlang/parser/lvar.rb
 - lib/rlang/parser/marg.rb
 - lib/rlang/parser/method.rb
-- lib/rlang/parser/wattr.rb
 - lib/rlang/parser/wgenerator.rb
 - lib/rlang/parser/winstruction.rb
 - lib/rlang/parser/wnode.rb