HDLRuby 3.9.3 → 3.9.6

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) }
@@ -1435,7 +1435,8 @@ module HDLRuby::High
             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 +1492,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 +2367,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 +2381,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 +2400,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 +2555,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.
@@ -2826,7 +2861,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 +2970,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 +3006,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
@@ -3185,12 +3222,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 +3237,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 +3779,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)
@@ -4636,6 +4677,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 +5298,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
 
@@ -5399,6 +5451,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 +5551,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)
@@ -5604,7 +5699,7 @@ module HDLRuby::High
                 # Check the value
                 return nil unless value.match(/^[0-9]+$/)
                 # Compute it (base 10 values cannot be 4-state!)
-                value = value.to_i.to_s(2)
+                value = value.to_i.to_s(2).rjust(width,"0")
             when "h" then
                 # base 16, compute the width
                 width = width ? width.to_i : value.size * 4
@@ -5792,6 +5887,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_low_split_signals.rb

@@ -156,7 +156,7 @@ module HDLRuby::Low
               blk = self.block
               sig = blk ? blk.get_signal_up(expr.ref.name) : 
                 self.scope.get_signal_up(expr.ref.name)
-              sig.split_to_index(expr,expr.index,res)
+              sig.split_to_index(expr,expr.index,res) if sig
             elsif expr.is_a?(RefRange) and expr.ref.is_a?(RefName) and
               expr.range.first.is_a?(Value) and
               expr.range.last.is_a?(Value) then
@@ -164,7 +164,7 @@ module HDLRuby::Low
               blk = self.block
               sig = blk ? blk.get_signal_up(expr.ref.name) : 
                 self.scope.get_signal_up(expr.ref.name)
-              sig.split_to_range(expr,expr.range,res)
+              sig.split_to_range(expr,expr.range,res) if sig
             end
           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 }
@@ -904,8 +909,13 @@ module HDLRuby::High
                         return RCSim.rcsim_make_value_numeric(self.type.to_rcsim,
                                                               self.content)
                     else
+                      if (self.content >= 0 and self.content & 0x8000_0000_0000_0000 == 0) then
                         return RCSim.rcsim_make_value_numeric(self.type.to_rcsim,
-                                                              self.content & 0xFFFFFFFFFFFF)
+                                                              self.content & 0x7FFF_FFFF_FFFF_FFFF)
+                      else
+                        return RCSim.rcsim_make_value_numeric_63one(self.type.to_rcsim,
+                                                              self.content & 0x7FFF_FFFF_FFFF_FFFF)
+                      end
                     end
                 else
                     if self.content < 0 then

data/lib/HDLRuby/hruby_verilog.rb

@@ -1562,10 +1562,14 @@ module HDLRuby::Low
         # Converts the system to Verilog code.
         def to_verilog
             # if self.base.name.to_s != "bit"
+            first = self.range.first
+            first = first.to_verilog if first.is_a?(Expression)
+            last = self.range.last
+            last = last.to_verilog if last.is_a?(Expression)
             if VERILOG_BASE_TYPES.include?(self.base.name.to_s)
-                return " #{self.base.name.to_s}[#{self.range.first}:#{self.range.last}]"
+              return " #{self.base.name.to_s}[#{first}:#{last}]"
             end
-            return " [#{self.range.first}:#{self.range.last}]"
+            return " [#{first}:#{last}]"
         end
     end
 
@@ -1630,9 +1634,9 @@ module HDLRuby::Low
             res = ""
             sels = self.select.to_verilog
             @choices[0..-2].each_with_index do |choice,i|
-                res << "#{sels} == #{i} ? #{choice.to_verilog} : "
+                res << "(#{sels} == #{i} ? #{choice.to_verilog} : "
             end
-            res << @choices[-1].to_verilog
+            res << @choices[-1].to_verilog + (")" * @choices[0..-2].size)
             return res
         end
     end
@@ -1676,6 +1680,9 @@ module HDLRuby::Low
                 # return "#{self.type.width}'b#{str}"
             else
                 str = self.content.to_verilog
+                if str.length > self.type.width then
+                  str = str[str.length-self.type.width..-1]
+                end
                 if self.content.negative? then
                     return "#{str.length}'sb#{str}"
                 else
@@ -1738,7 +1745,11 @@ module HDLRuby::Low
 
             result = " " * spc # Indented based on space_count.
 
-            result << "case(#{self.value.to_verilog})\n"
+            if @mode == :casez then
+              result << "casez(#{self.value.to_verilog})\n"
+            else
+              result << "case(#{self.value.to_verilog})\n"
+            end
 
             # n the case statement, each branch is partitioned by when. Process each time when.
             self.each_when do |whens| 
@@ -2150,7 +2161,7 @@ module HDLRuby::Low
             inout = self.each_inout.to_a
 
             # Spelling necessary for simulation.
-            code = "`timescale 1ps/1ps\n\n"
+            code = "`timescale 10ps/1ps\n\n"
 
             # self.properties[:verilog_name] = vname
             # Output the module name.