HDLRuby 3.7.9 → 3.8.0

data/lib/HDLRuby/std/hruby_enum.rb

@@ -13,9 +13,11 @@ module HDLRuby::High::Std
   # the to_a method.
   module HEnumerable
 
-    # Iterator on each element.
-    def heach(&ruby_block)
-      return self.to_a.each(&ruby_block)
+    # Convert to an array.
+    def h_to_a
+      res = []
+      self.heach {|e| res << e }
+      return res
     end
 
     # Iterator on each of the elements in range +rng+.
@@ -78,7 +80,8 @@ module HDLRuby::High::Std
 
     # Returns an HEnumerator generated from current enumerable and +arg+
     def hchain(arg)
-      return self.heach + arg
+      # return self.heach + arg
+      return self.hto_a + arg.hto_a
     end
 
     # HW implementation of the Ruby chunk.
@@ -101,7 +104,9 @@ module HDLRuby::High::Std
         return HEnumeratorWrapper.new(self,:hmap)
       end
       # A block given? Create the result HEnumerable (a Ruby array).
-      return self.heach.map(&ruby_block)
+      res = []
+      self.heach { |e| res << ruby_block.call(e) }
+      return res
     end
 
     # HW implementation of the Ruby flat_map.
@@ -111,7 +116,8 @@ module HDLRuby::High::Std
         return HEnumeratorWrapper.new(self,:hmap)
       end
       # A block given? Create the result HEnumerable (a Ruby array).
-      return self.heach.flat_map(&ruby_block)
+      # return self.heach.flat_map(&ruby_block)
+      return self.hto_a.flat_map(&ruby_block)
     end
 
     # HW implementation of the Ruby compact.
@@ -160,7 +166,7 @@ module HDLRuby::High::Std
         return ifnone.call
       end
       # Convert to an array.
-      ar = self.to_a
+      ar = self.hto_a
       # Use the ruby block in parallel.
       comp = ar.map { |elem| ruby_block.call(elem) }
       # Generate the look up circuit.
@@ -173,7 +179,15 @@ module HDLRuby::High::Std
 
     # HW implementation of the Ruby drop.
     def hdrop(n)
-      return self.heach.drop(n)
+      # return self.heach.drop(n)
+      res = []
+      size = self.hsize
+      self.heach do |e|
+        #   break if n == size
+        n += 1
+        res << e if n < size
+      end
+      return res
     end
 
     # HW implementation of the Ruby drop_while.
@@ -187,7 +201,8 @@ module HDLRuby::High::Std
       if !ruby_block then
         return HEnumeratorWrapper.new(self,:heach_cons,n)
       end
-      return self.heach.each_cons(n,&ruby_block)
+      # return self.heach.each_cons(n,&ruby_block)
+      return self.hto_a.each_cons(n,&ruby_block)
     end
 
     # HW implementation of the Ruby each_entry.
@@ -202,7 +217,8 @@ module HDLRuby::High::Std
       if !ruby_block then
         return HEnumeratorWrapper.new(self,:heach_slice,n)
       end
-      return self.heach.each_slice(n,&ruby_block)
+      # return self.heach.each_slice(n,&ruby_block)
+      return self.hto_a.each_slice(n,&ruby_block)
     end
 
     # HW implementation of the Ruby each_with_index.
@@ -212,7 +228,12 @@ module HDLRuby::High::Std
       if !ruby_block then
         return HEnumeratorWrapper.new(self,:heach_with_index)
       end
-      self.heach.each_with_index(*args,&ruby_block)
+      # self.heach.each_with_index(*args,&ruby_block)
+      idx = 0
+      self.heach do |e|
+        ruby_block.call(*args,e,idx)
+        idx += 1
+      end
     end
 
     # HW implementation of the Ruby each_with_object.
@@ -222,12 +243,19 @@ module HDLRuby::High::Std
       if !ruby_block then
         return HEnumeratorWrapper.new(self,:heach_with_object)
       end
-      self.heach.with_object(obj,&ruby_block)
+      # self.heach.with_object(obj,&ruby_block)
+      self.heach { |e| ruby_block.call(e,obj,&ruby_block) }
     end
 
-    # HW implementation of the Ruby to_a.
+    # # HW implementation of the Ruby to_a.
+    # def hto_a
+    #   return self.heach.to_a
+    # end
+
     def hto_a
-      return self.heach.to_a
+      res = []
+      self.heach { |e| res << e }
+      return res
     end
 
     # HW implementation of the Ruby select.
@@ -249,7 +277,7 @@ module HDLRuby::High::Std
       # If there is an objet, look for it.
       ruby_block = proc { |e| e == obj } if obj
       # Convert to an array.
-      ar = self.to_a
+      ar = self.hto_a
       size =ar.size
       # Use the ruby block in parallel.
       comp = self.hmap { |elem| ruby_block.call(elem) }
@@ -263,7 +291,14 @@ module HDLRuby::High::Std
 
     # HW implementation of the Ruby first.
     def hfirst(n=1)
-      return self.heach.first(n)
+      # return self.heach.first(n)
+      res = []
+      self.heach do |e|
+        # break if n == 0
+        res << e if n > 0
+        n -= 1
+      end
+      return res
     end
 
     # HW implementation of the Ruby grep.
@@ -290,15 +325,36 @@ module HDLRuby::High::Std
     end
 
     # HW implementation of the Ruby inject.
-    def hinject(*args,&ruby_block)
-      return self.heach.inject(*args,&ruby_block)
+    def hinject(*args, &ruby_block)
+      # return self.heach.inject(*args,&ruby_block)
+      # return self.hto_a.inject(*args,&ruby_block)
+      if ruby_block then
+        # Case when a block is given.
+        res = args[0]
+        self.heach do |e|
+          res = res ? ruby_block.call(res,e) : e
+        end
+      else
+        # Case when a symbol is given.
+        sym, res = args[0], args[1]
+        self.heach do |e|
+          res = res ? res.send(sym,e) : e
+        end
+      end
+      return res
     end
 
     alias_method :hreduce, :hinject
 
+    # Specific to HDLRuby: inject with no default value through the call
+    # operator.
+    def call(*args, &ruby_block)
+      return self.hinject(*args,&ruby_block)
+    end
+
     # HW implementation of the Ruby lazy.
     # NOTE: to do, or may be not.
-    def hlazy(*args,&ruby_block)
+    def hlazy(*args, &ruby_block)
       raise "hlazy is not supported yet."
     end
 
@@ -319,30 +375,11 @@ module HDLRuby::High::Std
       # The 2-value max unit.
       max2 = proc {|a,b| HDLRuby::High.top_user.mux(ruby_block.call(a,b),b,a) }
       # The single max hearch.
-      m = self.reduce(&max2)
+      m = self.hreduce(&max2)
       res = [m]
       if n > 1 then
         raise "hmax not supported for more than one max element."
       end
-      # # The other max hearch.
-      # ar = self.to_a
-      # sign = self.type.signed?
-      # (n-1).times do
-      #   # Exclude the previous max.
-      #   ar = ar.map do |a|
-      #     if sign then
-      #       HDLRuby::High.top_user.mux(a == m, a, HDLRuby::High.cur_system.send("_b1#{"0" * (a.type.width-1)}"))
-      #     else
-      #       HDLRuby::High.top_user.mux(a == m, a, HDLRuby::High.cur_system.send("_b0#{"0" * (a.type.width-1)}"))
-      #     end
-      #   end
-      #   puts "#2 ar.size=#{ar.size}"
-      #   m = ar.reduce(&max2)
-      # puts "#3"
-      #   res << m
-      # puts "#4"
-      # end
-      # puts "#5"
       if scalar then
         # Scalar result case.
         return m
@@ -381,7 +418,7 @@ module HDLRuby::High::Std
       # The 2-value max unit.
       min2 = proc {|a,b| HDLRuby::High.top_user.mux(ruby_block.call(a,b),a,b) }
       # The single max hearch.
-      m = self.reduce(&min2)
+      m = self.hreduce(&min2)
       res = [m]
       if n > 1 then
         raise "hmin not supported for more than one max element."
@@ -575,6 +612,13 @@ module HDLRuby::High::Std
         # The default comparator.
         ruby_block = proc { |a,b| a > b }
       end
+      # Create a namespace.
+      base_block = ruby_block
+      ruby_block = proc do |*args|
+        HDLRuby::High.top_user.sub do
+          base_block.call(*args)
+        end
+      end
       # Generate the compare and swap of two elements.
       compswap = proc do |a,b|
         if b then
@@ -625,7 +669,7 @@ module HDLRuby::High::Std
                  &ruby_block)
       # No block given? Generate a new wrapper enumerator for smin_by.
       if !ruby_block then
-        return SEnumeratorWrapper.new(self,:hsort_by,n)
+        return HEnumeratorWrapper.new(self,:hsort_by,n)
       end
       # A block is given, use smin with a proc that applies ruby_block
       # before comparing.
@@ -707,27 +751,9 @@ module HDLRuby::High::Std
   end
 
 
-  # Describes hardware enumerator classes that allows to
-  # generate HW iteration over HW or SW objects.
-
-  # This is the abstract Enumerator class.
-  class HEnumerator
-    include HEnumerable
-
-    # The methods that need to be defined.
-    [:size, :type, :clone, :hto_a].each do |name|
-       define_method(:name) do
-         raise "Method '#{name}' must be defined for a valid sequencer enumerator."
-       end
-     end
-
-    # Iterate on each element.
-    def heach(&ruby_block)
-      # No block given, returns self.
-      return self unless ruby_block
-      return self.hto_a.each(&ruby_block)
-    end
-
+  # Module adding args in enumeration functionalities to object including
+  # the to_a method.
+  module HEnumArg
     # Iterator on each of the elements in range +rng+.
     # *NOTE*: 
     #   - Stop iteration when the end of the range is reached or when there
@@ -736,19 +762,18 @@ module HDLRuby::High::Std
     #     creating a array is very expensive.
     def heach_range(rng,&ruby_block)
       # No block given, returns a new enumerator.
-      return HEnumeratorWrapper.new(self,:heach_range) unless ruby_block
+      if !ruby_block then
+        return HEnumeratorWrapper.new(self,:heach_range)
+      end
       return self.to_a.each_range(rng,&ruby_block)
     end
 
-    # Iterate on each element with arbitrary object +obj+.
-    def heach_with_object(val,&ruby_block)
-      return self.with_object(val,&ruby_block)
-    end
-
     # Iterates with an index.
-    def with_index(&ruby_block)
+    def hwith_index(&ruby_block)
       # No block given, returns a new enumerator.
-      return HEnumeratorWrapper.new(self,:with_index) unless ruby_block
+      if !ruby_block then
+        return HEnumeratorWrapper.new(self,:hwith_index)
+      end
       # return self.hto_a.each_with_index(&ruby_block)
       i = 0
       return self.heach do |e|
@@ -758,15 +783,92 @@ module HDLRuby::High::Std
       end
     end
 
-    # Return a new SEnumerator with an arbitrary arbitrary object +obj+.
-    def with_object(obj)
+    # Return a new HEnumerator with an arbitrary arbitrary object +obj+.
+    def hwith_object(obj)
       # No block given, returns a new enumerator.
-      return HEnumeratorWrapper.new(self,:with_object) unless ruby_block
+      if !ruby_block then
+        return HEnumeratorWrapper.new(self,:with_object)
+      end
       # return self.hto_a.each_with_object(&ruby_block)
       return self.heach do |e|
         ruby_block.call(e,obj)
       end
     end
+  end
+
+  # Describes hardware enumerator classes that allows to
+  # generate HW iteration over HW or SW objects.
+
+  # This is the abstract Enumerator class.
+  class HEnumerator
+    include Enumerable
+    include HEnumerable
+    include HEnumArg
+
+    # The methods that need to be defined.
+    [:size, :type, :clone, :hto_a].each do |name|
+       define_method(:name) do
+         raise "Method '#{name}' must be defined for a valid sequencer enumerator."
+       end
+     end
+
+    # Iterate on each element.
+    def heach(&ruby_block)
+      # No block given, returns self.
+      return self unless ruby_block
+      # Create a namespace.
+      base_block = ruby_block
+      ruby_block = proc do |*args| 
+        HDLRuby::High.top_user.sub do
+          base_block.call(*args)
+        end
+      end
+      # Iterate.
+      if self.respond_to?(:[]) then
+        return self.size.times do |i|
+          ruby_block.call(self[i])
+        end
+      else
+        return self.hto_a.each(&ruby_block)
+      end
+    end
+
+    alias_method :each, :heach
+
+    # # Iterator on each of the elements in range +rng+.
+    # # *NOTE*: 
+    # #   - Stop iteration when the end of the range is reached or when there
+    # #     are no elements left
+    # #   - This is not a method from Ruby but one specific for hardware where
+    # #     creating a array is very expensive.
+    # def heach_range(rng,&ruby_block)
+    #   # No block given, returns a new enumerator.
+    #   return HEnumeratorWrapper.new(self,:heach_range) unless ruby_block
+    #   return self.to_a.each_range(rng,&ruby_block)
+    # end
+
+    # # Iterates with an index.
+    # def hwith_index(&ruby_block)
+    #   # No block given, returns a new enumerator.
+    #   return HEnumeratorWrapper.new(self,:hwith_index) unless ruby_block
+    #   # return self.hto_a.each_with_index(&ruby_block)
+    #   i = 0
+    #   return self.heach do |e|
+    #     res = ruby_block.call(e,i)
+    #     i += 1
+    #     res
+    #   end
+    # end
+
+    # # Return a new HEnumerator with an arbitrary arbitrary object +obj+.
+    # def hwith_object(obj)
+    #   # No block given, returns a new enumerator.
+    #   return HEnumeratorWrapper.new(self,:with_object) unless ruby_block
+    #   # return self.hto_a.each_with_object(&ruby_block)
+    #   return self.heach do |e|
+    #     ruby_block.call(e,obj)
+    #   end
+    # end
 
     # Return a new HEnumerator going on iteration over enumerable +obj+
     def +(obj)
@@ -779,21 +881,22 @@ module HDLRuby::High::Std
   # other interation method over the first one.
   class HEnumeratorWrapper < HEnumerator
 
-    # Create a new SEnumerator wrapper over +enum+ with +iter+ iteration
+    # Create a new HEnumerator wrapper over +enum+ with +iter+ iteration
     # method and +args+ argument.
-    def initialize(enum,iter,*args)
-      if enum.is_a?(HEnumerator) then
-        @enumerator = enum.clone
-      else
-        @enumerator = enum.heach
-      end
-      @iterator  = iter.to_sym
+    def initialize(enum,iter = nil,*args)
+      # if enum.is_a?(HEnumerator) then
+      #   @enumerator = enum.clone
+      # else
+      #   @enumerator = enum.heach
+      # end
+      @enumerator = enum
+      @iterator  = iter ? iter.to_sym : nil
       @arguments = args
     end
 
     # The directly delegate methods.
     def size
-      return @enumertor.size
+      return @enumerator.size
     end
     alias_method :hsize, :size
 
@@ -801,12 +904,6 @@ module HDLRuby::High::Std
       return @enumerator.type
     end
 
-    def hto_a
-      res = []
-      self.heach { |e| res << e }
-      return res
-    end
-
     # Iterator on each of the elements in range +rng+.
     # *NOTE*: 
     #   - Stop iteration when the end of the range is reached or when there
@@ -827,29 +924,128 @@ module HDLRuby::High::Std
       # No block given, returns self.
       return self unless ruby_block
       # A block is given, iterate.
-      return @enumerator.send(@iterator,*@arguments,&ruby_block)
+      if @iterator then
+        return @enumerator.send(@iterator,*@arguments,&ruby_block)
+      else
+        return @enumerator.heach(*@arguments,&ruby_block)
+      end
     end
   end
 
 
-  module HDLRuby::High::HRef
-    # Enhance the HRef module with sequencer iteration.
-    # Properties of expressions are also required
-    def self.included(klass)
-      klass.class_eval do
-        include HEnumerable
+  # module HDLRuby::High::HRef
+  module HDLRuby::High::HExpression
+    # # Enhance the HRef module with sequencer iteration.
+    # # Properties of expressions are also required
+    # def self.included(klass)
+    #   klass.class_eval do
+    #     include HEnumerable
+    #     puts "current class=#{klass}"
+
+    #     # Iterate over the elements.
+    #     #
+    #     # Returns an enumerator if no ruby block is given.
+    #     def heach(&ruby_block)
+    #       # No ruby block? Return an enumerator.
+    #       # return to_enum(:each) unless ruby_block
+    #       return self unless ruby_block
+    #       # A block? Apply it on each element.
+    #       self.type.range.heach do |i|
+    #         yield(self[i])
+    #       end
+    #     end
+
+    #     # Size.
+    #     def hsize
+    #       self.type.size
+    #     end
+    #   end
+    # end
+
+    # Iterate over the elements.
+    #
+    # Returns an enumerator if no ruby block is given.
+    def heach(&ruby_block)
+      # No ruby block? Return an enumerator.
+      # return self unless ruby_block
+      if !ruby_block then
+        return HEnumeratorWrapper.new(self)
+      end
+      # A block? Apply it on each element.
+      # Create a namespace.
+      base_block = ruby_block
+      ruby_block = proc do |*args|
+        HDLRuby::High.top_user.sub do
+          base_block.call(*args)
+        end
+      end
+      # Iterate.
+      self.type.range.heach do |i|
+        # yield(self[i])
+        ruby_block.call(self[i])
       end
     end
 
-    # Convert to an array.
-    alias_method :hto_a, :to_a
-
     # Size.
     def hsize
       self.type.size
     end
+
+    # Also adds the methods of HEnumerable.
+    HEnumerable.instance_methods.each do |meth|
+      define_method(meth,HEnumerable.instance_method(meth))
+    end
+
+    alias_method :to_a, :hto_a
+  end
+
+
+  module HDLRuby::High::HExpression
+    # Enhance the HExpression module with sequencer iterations.
+
+    # HW times iteration.
+    def htimes(&ruby_block)
+      unless self.respond_to?(:to_i) then
+        raise "htimes unsupported for such an expression: #{self}."
+      end
+      return self.to_i.htimes(&ruby_block)
+    end
+
+    # HW upto iteration.
+    def hupto(val,&ruby_block)
+      unless self.respond_to?(:to_i) then
+        raise "hupto unsupported for such an expression: #{self}."
+      end
+      return self.to_i.hupto(val,&ruby_block)
+    end
+
+    # HW downto iteration.
+    def sdownto(val,&ruby_block)
+      unless self.respond_to?(:to_i) then
+        raise "hupto unsupported for such an expression: #{self}."
+      end
+      return self.to_i.hdownto(val,&ruby_block)
+    end
   end
 
+  # class HDLRuby::High::Value
+  #   # Enhance the HRef module with sequencer iteration.
+  #   # Properties of expressions are also required
+  #   def self.included(klass)
+  #     klass.class_eval do
+  #       include HEnumerable
+  #     end
+  #   end
+
+  #   # Convert to an array.
+  #   alias_method :hto_a, :to_a
+
+  #   # Size.
+  #   def hsize
+  #     self.type.size
+  #   end
+  # end
+
 
   module ::Enumerable
     # Enhance the Enumerable module with sequencer iteration.
@@ -869,23 +1065,59 @@ module HDLRuby::High::Std
   end
 
 
+  class ::Array
+    # alias :heach :each
+    # alias :hto_a :to_a
+    
+    # Enhance the Array class with henumerable methods.
+    include HEnumerable
+
+    # # Enhance the Array class with extra arguments in interation.
+    # include HEnumArg
+
+    def heach(&ruby_block)
+      if !ruby_block then
+        return HEnumeratorWrapper.new(self)
+      end
+      # self.each { |e| HDLRuby::High.top_user.sub { ruby_block.call(e) } }
+      self.each do |e|
+        HDLRuby::High.top_user.sub do
+          # HDLRuby::High.top_user.instance_exec(e,&ruby_block)
+          ruby_block.call(e)
+        end
+      end
+    end
+  end
+
+
   class ::Range
     # Enhance the Range class with sequencer iteration.
     include HEnumerable
 
-    # Conversion to array.
-    def hto_a
-      res = []
-      self.heach { |i| res << i }
-      return res
-    end
+    # # Enhance the Array class with extra arguments in interation.
+    # include HEnumArg
+
+    # # Conversion to array.
+    # def hto_a
+    #   res = []
+    #   self.heach { |i| res << i }
+    #   return res
+    # end
 
     # Redefinition of heach to support also HDLRuby Values.
     def heach(&ruby_block)
       if self.first.is_a?(Value) or self.last.is_a?(Value) then
+        # Value range case.
         # No block given.
         return self unless ruby_block
         # A block is given, iterate on each element of the range
+        # Create a namespace.
+        base_block = ruby_block
+        ruby_block = proc do |*args|
+          HDLRuby::High.top_user.sub do
+            base_block.call(*args)
+          end
+        end
         # converted to values of the right type.
         if first.is_a?(Value) then
           typ = self.first.type
@@ -894,11 +1126,22 @@ module HDLRuby::High::Std
         end
         first = self.first.to_i
         last = self.last.to_i
-        (first..last).each do |i|
-          ruby_block.call(i.as(typ))
+        if first <= last then
+          (first..last).each do |i|
+            ruby_block.call(i.as(typ))
+          end
+        else
+          (last..first).reverse_each do |i|
+            ruby_block.call(i.as(typ))
+          end
         end
       else
-        return self.each(&ruby_block)
+        # Other range cases.
+        if self.first <= self.last then
+          return self.each(&ruby_block)
+        else
+          return (self.last..self.first).reverse_each(&ruby_block)
+        end
       end
     end
 

data/lib/HDLRuby/std/sequencer.rb

@@ -2150,7 +2150,8 @@ module HDLRuby::High::Std
 
     # class HDLRuby::High::Value
     module HDLRuby::High::HExpression
-        # Enhance the Value class with sequencer iterations.
+        # # Enhance the Value class with sequencer iterations.
+        # Enhance the HExpression module with sequencer iterations.
 
         # HW times iteration.
         def stimes(&ruby_block)

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "3.7.9"
+  VERSION = "3.8.0"
 end