HDLRuby 3.9.5 → 3.9.7

data/lib/HDLRuby/hruby_high.rb

@@ -777,7 +777,6 @@ module HDLRuby::High
         #       registered in the namespace stack, and one for creating an
         #       array of instances being registered in the Array class.
         def make_instantiater(name,klass,&ruby_block)
-            # puts "make_instantiater with name=#{name}"
             # Set the instanciater.
             @instance_procs = [ ruby_block ]
             # Set the target instantiation class.
@@ -794,7 +793,8 @@ module HDLRuby::High
                 # If no arguments, return the system as is
                 return obj if args.empty?
                 # Are there any generic arguments?
-                if ruby_block.arity > 0 then
+                if ruby_block.arity > 0 or args.size > 1 or args[0].is_a?(Hash) then
+                # if ruby_block.parameters.size > 0 then
                     # Yes, must specialize the system with the arguments.
                     # If arguments, create a new system specialized with them
                     return SystemT.new(:"") { include(obj,*args) }
@@ -1431,11 +1431,20 @@ module HDLRuby::High
         # NOTE:
         #  * the else part is defined through the helse method.
         #  * a behavior is created to enclose the hif.
-        def hif(condition, mode = nil, &ruby_block)
+        def hif(condition, mode = nil, other = nil, &ruby_block)
+            if mode and !mode.is_a?(Symbol) then
+              if ruby_block then
+                raise AnyError, "Error: expression hif with a block."
+              end
+              # Expression hif case: 'mode' is interpreted as the 
+              # expression of the condition is true, 'other'if it is false.
+              return EIfMaker.new(condition,mode,other)
+            end
             return if self.metaif(condition,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
-            self.par do
+            # self.par do
+            self.seq do # Seq for combinatorial is good practice
               hif(condition,mode,&ruby_block)
             end
         end
@@ -1491,11 +1500,40 @@ module HDLRuby::High
         #  * a new behavior is created to enclose the hcase.
         def hcase(value)
             return if self.metacase(value)
-            self.par do
+            # self.par do
+            self.seq do # Seq for combinatorial is good practice
                 hcase(value)
             end
         end
 
+        # Creates a new case statement taking z was wildcard with a +value+ used for deciding which
+        # block to execute.
+        #
+        # NOTE: 
+        #  * the when part is defined through the hwhen method.
+        #  * a new behavior is created to enclose the hcase.
+        def hcasez(value)
+            return if self.metacase(value)
+            # self.par do
+            self.seq do # Seq for combinatorial is good practice
+                hcasez(value)
+            end
+        end
+
+        # Creates a new case statement taking z as wildcards with a +value+ used for deciding which
+        # block to execute.
+        #
+        # NOTE: 
+        #  * the when part is defined through the hwhen method.
+        #  * a new behavior is created to enclose the hcase.
+        def hcasez(value)
+            return if self.metacase(value)
+            # self.par do
+            self.seq do # Seq for combinatorial is good practice
+                hcasez(value)
+            end
+        end
+
         # Sets the block of a case structure executed when the +match+ is met
         # to the block in +mode+ generated by the execution of +ruby_block+.
         #
@@ -2337,6 +2375,7 @@ module HDLRuby::High
             end
             define_singleton_method(name.to_sym) do |*args|
                 if (args.size < ruby_block.arity) then
+                # if (args.size < ruby_block.parameters.size) then
                     # Not enough arguments get generic type as is.
                     type
                 else
@@ -2350,6 +2389,7 @@ module HDLRuby::High
         else
             define_method(name.to_sym) do |*args|
                 if (args.size < ruby_block.arity) then
+                # if (args.size < ruby_block.parameters.size) then
                     # Not enough arguments, get generic type as is.
                     type
                 else
@@ -2368,7 +2408,7 @@ module HDLRuby::High
     def system(name = :"", *includes, &ruby_block)
         # Ensure there is a block.
         ruby_block = proc {} unless block_given?
-        # print "system ruby_block=#{ruby_block}\n"
+        # print "system name=#{name} ruby_block=#{ruby_block}\n"
         # Creates the resulting system.
         return SystemT.new(name,*includes,&ruby_block)
     end
@@ -2523,6 +2563,9 @@ module HDLRuby::High
                 connects.each do |key,value|
                     # Gets the signal corresponding to connect.
                     signal = self.systemT.get_signal_with_included(key)
+                    unless signal then
+                      raise AnyError, "Invalid parameter: #{key}"
+                    end
                     # Check if it is an output.
                     isout = self.systemT.get_output_with_included(key)
                     # Convert it to a reference.
@@ -2565,6 +2608,32 @@ module HDLRuby::High
                     end
                 end
             end
+            return self
+        end
+
+        # Auto connects signals of the system instance.
+        #
+        # NOTE: the connections are looked for automatically by name in 
+        # the system the instance is placed.
+        def auto_connect
+          # Gather the names of the signals to connect.
+          names = self.systemT.each_signal_with_included.map do |sig| 
+            sig.name
+          end
+          # Look for the right signals in the current context.
+          signals = []
+          High.top_user.instance_eval do
+            names.dup.each_with_index do |name,i| 
+              begin
+                signals << send(name)
+              rescue NotDefinedError => e
+                # Signal not found so no connection.
+                names.delete(name)
+              end
+            end
+          end
+          # Do the connection.
+          self.call(names.zip(signals).to_h) 
         end
 
         # Gets an exported element (signal or system instance) by +name+.
@@ -2826,7 +2895,7 @@ module HDLRuby::High
             obj = self
             ::HDLRuby::High.cur_block.delete_statement!(obj)
             # Handles the metaprogramming.
-            return obj if self.metaif(condition,proc { add_statement(obj) })
+            return obj if self.metaif(condition) { add_statement(obj) }
             # Creates the if statement.
             stmnt = If.new(condition) { add_statement(obj) }
             # Add it to the current block.
@@ -2935,9 +3004,11 @@ module HDLRuby::High
 
         # Creates a new case statement with a +value+ that decides which
         # block to execute.
-        def initialize(value)
+        # +mode+ is the mode the case should run in. For now there are 
+        # only two possiblities: normal case :"", and casez :casez
+        def initialize(value, mode = :"")
             # Create the yes block.
-            super(value.to_expr)
+            super(value.to_expr, mode)
         end
 
         # Sets the block executed in +mode+ when the value matches +match+.
@@ -2969,7 +3040,7 @@ module HDLRuby::High
         # Converts the case to HDLRuby::Low.
         def to_low
             # Create the low level case.
-            caseL = HDLRuby::Low::Case.new(@value.to_low)
+            caseL = HDLRuby::Low::Case.new(@value.to_low,@mode)
             # # For debugging: set the source high object 
             # caseL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = caseL
@@ -3056,6 +3127,66 @@ module HDLRuby::High
 
 
 
+    ##
+    # Class for building multiplexers from expression ifs.
+    #
+    # Note: expression if does not exist in HDLRuby, this is a syntactic
+    # sugar.
+    class EIfMaker
+      # Create a new multiplexer generator from if expression with
+      # +cond+ as boolean selection, +texpr+ the expression to use if 
+      # +cond+ is true +fexpr+ the expression to use if false.
+      # Note: +fexpr+ can be false, it it is the case, the call operator
+      # has to be used to give it.
+      def initialize(cond,texpr,fexpr = nil)
+        @cond = cond
+        @texpr = texpr
+        @fexpr = fexpr
+      end
+
+      # Replace the expression (fexpr) to use if the condition is false.
+      # If +epxr1+ is given, create an expression whose condition is expr0
+      # otherwise, use expression as fexpr.
+      def call(expr0,expr1 = nil,expr2 = nil)
+        if @fexpr then
+          if @fexpr.is_a?(EIfMaker) then
+            # Complete the fexpr.
+            @fexpr = @fexpr.call(expr0,expr1,expr2)
+          else
+            raise AnyError, "The expression to use if the condition is false is already set."
+          end
+        elsif expr1 then
+          @fexpr = EIfMaker.new(expr0,expr1,expr2)
+        else
+          @fexpr = expr0
+        end
+        return self
+      end
+
+      # Convert the expression if to an expression mux.
+      def to_expr
+        return HDLRuby::High.top_user.mux(@cond.to_expr == 0, @texpr.to_expr, @fexpr.to_expr)
+      end
+
+      [:"-@",:"+@",:"~", :abs,
+       :boolean, :bit, :signed, :unsigned].each do |operator|
+         define_method(operator) do
+           self.to_expr.send(operator)
+         end
+       end
+
+      [:"+",:"-",:"*",:"/",:"%",:"**",
+       :"&",:"|",:"^",
+       :"<<",:">>",# :ls,:rs,:lr,:rr, # ls, rs lr and rr are treated separately
+       :"==",:"!=",:"<",:">",:"<=",:">="].each do |operator|
+         define_method(operator) do |expr|
+           self.to_expr.send(operator,expr)
+         end
+       end
+
+    end
+
+
     ##
     # Module giving high-level expression properties
     module HExpression
@@ -3185,12 +3316,12 @@ module HDLRuby::High
 
         # Extends on the left to +n+ bits filling with +v+ bit values.
         def ljust(n,v)
-            return [(v.to_s * (n-self.width)).to_expr, self]
+          return [(v.to_s * (n-self.width)).to_value, self].to_expr
         end
 
         # Extends on the right to +n+ bits filling with +v+ bit values.
         def rjust(n,v)
-            return [self, (v.to_s * (n-self.width)).to_expr]
+          return [self, (v.to_s * (n-self.width)).to_value].to_expr
         end
 
         # Extends on the left to +n+ bits filling with 0.
@@ -3200,7 +3331,8 @@ module HDLRuby::High
 
         # Extends on the left to +n+ bits preserving the signe.
         def sext(n)
-            return self.ljust(self[-1])
+            # return self.ljust(n,self[-1])
+          return self.as(HDLRuby::High.top_user.signed[self.type.width]).as(HDLRuby::High.top_user.signed[n])
         end
 
         # # Match the type with +typ+:
@@ -3741,6 +3873,9 @@ module HDLRuby::High
         # Creates a new reference from a +base+ reference and named +object+.
         def initialize(base,object)
             # puts "New RefObjet with base=#{base}, object=#{object}"
+            unless object
+              raise AnyError, "Empty object for reference."
+            end
             if object.respond_to?(:type) then
                 # Typed object, so typed reference.
                 super(object.type)
@@ -4574,7 +4709,15 @@ module HDLRuby::High
         #
         # NOTE: the else part is defined through the helse method.
         # def hif(condition, mode = nil, &ruby_block)
-        def hif(condition, mode = self.mode, &ruby_block)
+        def hif(condition, mode = self.mode, other = nil, &ruby_block)
+            if mode and !mode.is_a?(Symbol) then
+              if ruby_block then
+                raise AnyError, "Error: expression hif with a block."
+              end
+              # Expression hif case: 'mode' is interpreted as the 
+              # expression of the condition is true, 'other'if it is false.
+              return EIfMaker.new(condition,mode,other)
+            end
             return if self.metaif(condition,&ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
@@ -4636,6 +4779,16 @@ module HDLRuby::High
             self.add_statement(Case.new(value))
         end
 
+        # Creates a new case statement taking z as wildcard with a +value+ used for deciding which
+        # block to execute.
+        #
+        # NOTE: the when part is defined through the hwhen method.
+        def hcasez(value)
+            return if self.metacase(value)
+            # Creates the case statement.
+            self.add_statement(Case.new(value, :casez))
+        end
+
         # Sets the block of a case structure executed when the +match+ is met
         # to the block in +mode+ generated by the execution of +ruby_block+.
         #
@@ -5247,6 +5400,7 @@ module HDLRuby::High
     class ::Float
         # Converts to a new high-level expression.
         def to_expr
+          raise "Float not supported yet."
             return Value.new(Real,self)
         end
 
@@ -5256,6 +5410,13 @@ module HDLRuby::High
         end
     end
 
+    # Extends the NilClass to act as an empty statement.
+    class ::NilClass
+      # Does nothing.
+      def hif(*args)
+      end
+    end
+
     # Extends the String class for computing conversion to expression.
     class ::String
         # # Converts to a new high-level expression.
@@ -5399,6 +5560,38 @@ module HDLRuby::High
             expr
         end
 
+        # Casts to +typ+.
+        def as(typ)
+          return self.to_expr.as(typ)
+        end
+
+        # Converts to a bit vector.
+        def to_bit
+          return self.to_expr.to_bit
+        end
+
+        # Casts to an unsigned bit vector type.
+        def to_unsigned
+          return self.to_bit.to_unsigned
+        end
+
+        # Casts to a signed bit vector type.
+        def to_signed
+            return self.to_bit_to_signed
+        end
+
+        # Extends on the left to +n+ bits filling with 0.
+        def zext(n)
+          return self.to_bit.zext(n)
+        end
+
+        # Extends on the left to +n+ bits preserving the signe.
+        def sext(n)
+          return self.to_bit.sext(n)
+        end
+
+        # Add the methods of HExpression
+
         # Converts to a new high-level reference.
         def to_ref
             expr = RefConcat.new(TypeTuple.new(:"",:little,*self.map do |elem|
@@ -5467,6 +5660,17 @@ module HDLRuby::High
             end
         end
 
+        # Creates a hcase statement taking z as wildcard executing +ruby_block+ on the element of
+        # the array selected by +value+
+        def hcasez(value,&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
+            High.cur_block.hcasez(value)
+            self.each.with_index do |elem,i|
+                High.cur_block.hwhen(i) { ruby_block.call(elem) }
+            end
+        end
+
         # Moved to HArrow.
         # # Add support of the left arrow operator.
         # def <=(expr)
@@ -5537,7 +5741,8 @@ module HDLRuby::High
             # Get and check the type
             # type = str[0]
             type = str[1]
-            if ["0", "1", "z", "Z", "o", "d", "h"].include?(type) then
+            if ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+                "z", "Z", "o", "d", "h"].include?(type) then
                 # Default binary
                 type = "b"
             else
@@ -5639,6 +5844,9 @@ module HDLRuby::High
                 # Unknown type
                 return nil
             end
+            # Extends by duplicating the upper bit if the width is too 
+            # large.
+            value = value.rjust(width,value[0])
             # puts "type.width=#{type.width}, value=#{value}"
             # Create and return the value.
             return Value.new(type,value)
@@ -5792,6 +6000,20 @@ def self.configure_high
     end
 
 
+
+    ## Handling the properties that can be added to HDLRuby objects.
+
+    ## Add to object +obj+, property +prop+.
+    def self.add_property(obj,prop)
+      HDLRuby::Low.add_property(obj,prop)
+    end
+
+    ## Iterate on the properties of object +obj+.
+    def self.each_property(obj,&ruby_block)
+      HDLRuby::Low.each_property(obj,&ruby_block)
+    end
+
+
 end
 
 

data/lib/HDLRuby/hruby_low.rb

@@ -36,8 +36,6 @@ module HDLRuby::Low
     end
 
 
-    # Hdecorator = HDLRuby::Hdecorator
-
     ##
     # Gives parent definition and access properties to an hardware object.
     module Hparent
@@ -162,9 +160,6 @@ module HDLRuby::Low
             end
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(SystemT)
@@ -529,9 +524,6 @@ module HDLRuby::Low
             @behaviors = []
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Scope)
@@ -1293,8 +1285,11 @@ module HDLRuby::Low
             @name = name.to_sym
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
+        # Converts the system to HDLRuby::Low.
+        # Here already low.
+        def to_low
+          return self
+        end
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -1989,6 +1984,11 @@ module HDLRuby::Low
             return true
         end
 
+        # Gets thebitwidth
+        def width
+          return self.reduce(0) {|sum,elem| sum + elem.width }
+        end
+
         # Hash function.
         def hash
             return [super,@types].hash
@@ -2330,9 +2330,6 @@ module HDLRuby::Low
             # @block = block
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Sets the block if not already set.
         def block=(block)
             # Check the block.
@@ -2561,9 +2558,6 @@ module HDLRuby::Low
             ref.parent = self
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Comparison for hash: structural comparison.
         def eql?(obj)
             return false unless obj.is_a?(Event)
@@ -2698,9 +2692,6 @@ module HDLRuby::Low
             @signals.each(&ruby_block) if @signals
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Iterates over each object deeply.
         #
         # Returns an enumerator if no ruby block is given.
@@ -2783,9 +2774,6 @@ module HDLRuby::Low
             @systemTs = [ @systemT ]
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Iterates over each object deeply.
         #
         # Returns an enumerator if no ruby block is given.
@@ -2919,9 +2907,6 @@ module HDLRuby::Low
             lumps.each { |lump| self.add_lump(lump) }
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Adds a +lump+ of code, it is ment to become an expression or
         # some text.
         def add_lump(lump)
@@ -3101,9 +3086,6 @@ module HDLRuby::Low
             @chunks = HashName.new
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Adds a +chunk+ to the sensitivity list.
         def add_chunk(chunk)
             # Check and add the chunk.
@@ -3212,7 +3194,6 @@ module HDLRuby::Low
     # NOTE: this is an abstract class which is not to be used directly.
     class Statement
         include Hparent
-        # include Hdecorator
         
         # Clones (deeply)
         def clone
@@ -3700,9 +3681,6 @@ module HDLRuby::Low
             match.parent = statement.parent = self
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Iterates over each object deeply.
         #
         # Returns an enumerator if no ruby block is given.
@@ -3818,15 +3796,18 @@ module HDLRuby::Low
         attr_reader :default
 
         # Creates a new case statement whose excution flow is decided from
-        # +value+ with a possible cases given in +whens+ and +default
-        # + (can be set later)
-        def initialize(value, default = nil, whens = [])
+        # +value+ with a possible cases given in +whens+ and +default+
+        # (can be set later)
+        # +mode+ is the mode the case should run in. For now there are two
+        # possible modes: normal case :"", and in a mode where z are taken as wildcards :casez.
+        def initialize(value, mode = :"", default = nil, whens = [])
             # Check and set the value.
             unless value.is_a?(Expression)
                 raise AnyError, "Invalid class for a value: #{value.class}"
             end
             super()
             @value = value
+            @mode = mode.to_sym
             # And set its parent.
             value.parent = self
             # Checks and set the default case if any.
@@ -3994,7 +3975,7 @@ module HDLRuby::Low
             # Clone the default if any.
             default = @default ? @default.clone : nil
             # Clone the case.
-            return Case.new(@value.clone,default,(@whens.map do |w|
+            return Case.new(@value.clone,@mode,default,(@whens.map do |w|
                 w.clone
             end) )
         end
@@ -4025,9 +4006,6 @@ module HDLRuby::Low
             @unit = unit.to_sym
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
-
         # Iterates over each object deeply.
         #
         # Returns an enumerator if no ruby block is given.
@@ -4918,8 +4896,10 @@ module HDLRuby::Low
             end
         end
 
-        # # Add decorator capability (modifies intialize to put after).
-        # include Hdecorator
+        # Gets the bit width of the expression.
+        def width
+            return @type.width
+        end
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -5023,6 +5003,7 @@ module HDLRuby::Low
 
         # Creates a new value typed +type+ and containing +content+.
         def initialize(type,content)
+            # puts "New value with content=#{content} (content.class=#{content.class})"
             super(type)
             if content.nil? then
                 # Handle the nil content case.
@@ -5041,7 +5022,11 @@ module HDLRuby::Low
                 unless content.is_a?(Numeric) or
                         content.is_a?(HDLRuby::BitString)
                     # content = HDLRuby::BitString.new(content.to_s)
-                    content = content.to_s
+                    if content.is_a?(Array) then
+                      content = content.map(&:to_s).join
+                    else
+                      content = content.to_s
+                    end
                     if self.type.unsigned? && content[0] != "0" then
                         # content = "0" + content.rjust(self.type.width,content[0])
                         if content[0] == "1" then
@@ -5108,10 +5093,10 @@ module HDLRuby::Low
             return self.content <=> value
         end
 
-        # Gets the bit width of the value.
-        def width
-            return @type.width
-        end
+        # # Gets the bit width of the value.
+        # def width
+        #     return @type.width
+        # end
 
         # Tells if the value is even.
         def even?
@@ -6449,4 +6434,23 @@ module HDLRuby::Low
         end
 
     end
+
+
+    ## Handling the properties that can be added to HDLRuby objects.
+
+    Properties = Hash.new
+
+    ## Add to object +obj+, property +prop+.
+    def self.add_property(obj,prop)
+      Properties[obj] ||= Set.new
+      Properties[obj] << prop
+      obj
+    end
+
+    ## Iterate on the properties of object +obj+.
+    def self.each_property(obj,&ruby_block)
+      Properties[obj].each(&ruby_block)
+    end
+
+
 end

data/lib/HDLRuby/hruby_rcsim.rb

@@ -719,8 +719,13 @@ module HDLRuby::High
         # Generate the C description of the hardware case.
         def to_rcsim
             # Create the hardware case C object.
-            @rcstatement = RCSim.rcsim_make_hcase(self.value.to_rcsim,
-                                    self.default ? self.default.to_rcsim : nil)
+            if(@mode == :casez) then
+              @rcstatement = RCSim.rcsim_make_hcasez(self.value.to_rcsim,
+                               self.default ? self.default.to_rcsim : nil)
+            else
+              @rcstatement = RCSim.rcsim_make_hcase(self.value.to_rcsim,
+                               self.default ? self.default.to_rcsim : nil)
+            end
 
             # Add the hardware whens.
             rcsim_matches = self.each_when.map {|wh| wh.match.to_rcsim }