HDLRuby 3.3.1 → 3.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 799d3cd620af47b1f1c7b621769ae0d625b58f86b07694f896d9c6d0ce47b1f8
-  data.tar.gz: b47447cba1f1bbff81f27a6228f9a76eb1ec5857c8c11ccb7fdf3d36d4503b0c
+  metadata.gz: 3fc400e683cbefc6a77e8e6c4394f67e88df74fccd3bcb4ba420f6babc2542c8
+  data.tar.gz: e4619579f4ef6703c38cb1ee5cc95197b37b929eb630f93497a4b7bde0a4955f
 SHA512:
-  metadata.gz: 183e0d9ae85a4fd89503bd9e14a1eb084e67bf1726f06cba86cbd036336ecac4b11b78501ff28f7ace889b14816be42316e0575be003a5d94109124a0f740514
-  data.tar.gz: e6f05f913068f4098aac6b9d119d9b9fe924585a348c237071a216037b982972271b19e415752e813a0fc2e967897b219da75cb4feec68749c86909400c6f2ae
+  metadata.gz: 581b6f3029bc63108c0408495dcebaf6305f61697099985c7b2f043f3250d377e5640f0db7305f62ed2a4430f60f6dfc85495a382e84f89a1d595ac5519cebaa
+  data.tar.gz: 1821cb1ee95bb0abfdfd8d99318b1a5a103baabc3c3d3c58e50cd965f54059d0636b3cd352f1c9e726c7c04d3282f06820896cc9cf74e92b6e7a721bcd254560

data/lib/HDLRuby/hdr_samples/with_board_sequencer.rb

@@ -0,0 +1,69 @@
+
+# A benchmark for testing the use of a board model in conjuction
+# with a sequencer implementing:
+# * a simple adder whose input are set using slide switches, and
+#   whose output bits are showns on LEDs.
+# * simple unsigned and signed counters whose values are shown using
+#   decimal or hexadecimal displays, and oscilloscopes.
+system :with_board_sequencer do
+    inner :clk, :clk2
+    [8].inner clk_cnt: 0
+    inner rst: 0
+    [8].inner :sw_a, :sw_b
+    [9].inner :led_z
+    [16].inner counter: 0
+    [8].inner :counter8
+    signed[8].inner :scounter8
+
+    # Description of the board.
+    # It is updated at each rising edge of +clk2+.
+    board(:some_board) do
+        actport clk2.posedge
+        bt  reset:    rst
+        row
+        sw  sw_a:     sw_a
+        sw  sw_b:     sw_b
+        led led_z:    led_z
+        row
+        digit cnt_d:  counter
+        hexa  cnt_h:  counter
+        digit cnt_s:  scounter8
+        row
+        scope scope:  counter8
+        scope scope_s:scounter8
+    end
+
+    # The adder.
+    led_z <= sw_a.as(bit[9]) + sw_b
+
+    # The counters and the generation of +clk2+.
+    counter8 <= counter[7..0]
+    scounter8 <= counter[7..0]
+
+    seq(clk.posedge) do
+      clk_cnt <= clk_cnt + 1
+      hif(clk_cnt & 3 == 0) { clk2 <= ~clk2 }
+    end
+
+    sequencer(clk.posedge,rst) do
+      counter <= 0
+      sloop do
+        counter <= counter + 1 
+      end
+    end
+
+
+
+    timed do
+        clk <= 0
+        clk2 <= 0
+        !10.ns
+        repeat(1000) do
+            clk <= 1
+            !10.ns
+            clk <= 0
+            !10.ns
+        end
+
+    end
+end

data/lib/HDLRuby/hdr_samples/with_nand_board.rb

@@ -0,0 +1,32 @@
+
+# A benchmark for testing the use of a board model implementing:
+# * a simple NAND whose input are set using slide switches, and
+#   whose output bits are showns on LEDs and an oscilloscope.
+system :nand_board do
+    [8].input :din0, :din1
+    [8].output :dout
+
+    dout <= ~(din0 & din1)
+
+    inner :clk
+    # Description of the board.
+    # It is updated at each rising edge of +clk+.
+    board(:nand,8080) do
+        actport clk.posedge
+        sw din0: din0
+        sw din1: din1
+        row
+        led dout: dout
+        row
+        scope doutS: dout
+    end
+
+    timed do
+        clk <= 0
+        !10.ns
+        repeat(2000) do
+            clk <= ~clk
+            !10.ns
+        end
+    end
+end

data/lib/HDLRuby/hruby_high.rb

@@ -1529,15 +1529,19 @@ module HDLRuby::High
             self.each_program { |prog| scopeL.add_program(prog.to_low) }
             # Adds the code chunks.
             self.each_code { |code| scopeL.add_code(code.to_low) }
+            # Adds the behaviors.
+            self.each_behavior { |behavior|
+                scopeL.add_behavior(behavior.to_low)
+            }
             # Adds the connections.
             self.each_connection { |connection|
                 # puts "connection=#{connection}"
                 scopeL.add_connection(connection.to_low)
             }
-            # Adds the behaviors.
-            self.each_behavior { |behavior|
-                scopeL.add_behavior(behavior.to_low)
-            }
+            # # Adds the behaviors.
+            # self.each_behavior { |behavior|
+            #     scopeL.add_behavior(behavior.to_low)
+            # }
         end
 
         # Converts the scope to HDLRuby::Low.
@@ -2247,17 +2251,21 @@ module HDLRuby::High
         ruby_block = proc {} unless block_given?
         if HDLRuby::High.in_system? then
             define_singleton_method(name.to_sym) do |*args,&other_block|
+                res = nil
                 sub(HDLRuby.uniq_name(name)) do
-                    HDLRuby::High.top_user.instance_exec(*args,*other_block,
-                                                         &ruby_block)
+                    res = HDLRuby::High.top_user.instance_exec(*args,
+                                            *other_block, &ruby_block)
                 end
+                res
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
+                res = nil
                 sub(HDLRuby.uniq_name(name)) do
-                    HDLRuby::High.top_user.instance_exec(*args,*other_block,
-                                                         &ruby_block)
+                    res = HDLRuby::High.top_user.instance_exec(*args,
+                                            *other_block, &ruby_block)
                 end
+                res
             end
         end
     end
@@ -2523,15 +2531,15 @@ module HDLRuby::High
         # Converts the if to HDLRuby::Low.
         def to_low
             # Create the resulting program.
-            progL = HDLRuby::Low::Program.new(self.lang,self.function)
+            progL = HDLRuby::Low::Program.new(self.language,self.function)
             # Add the wakening events.
-            self.each_event  { |ev| progL.add_event(ev.to_low) }
+            self.each_actport  { |ev| progL.add_actport(ev.to_low) }
             # Add the code files.
             self.each_code   { |ev| progL.add_code(code) }
             # Add the input signals references.
-            self.each_input  { |ref| progL.add_input(ref.to_low) }
+            self.each_inport  { |p| progL.add_inport(p[0],p[1].to_low) }
             # Add the output signals references.
-            self.each_output { |ref| progL.add_output(ref.to_low) }
+            self.each_outport { |p| progL.add_outport(p[0],p[1].to_low) }
             # Return the resulting program.
             return progL
         end
@@ -3089,10 +3097,14 @@ module HDLRuby::High
          end
 
 
-         # Creates an access to elements of range +rng+ of the signal.
+         # Creates an access to elements of range +rng+ of the signal,
+         # and set the type of elements as +typ+ if given.
          #
          # NOTE: +rng+ can be a single expression in which case it is an index.
-         def [](rng)
+         def [](typ,rng=nil)
+             # Treat the number of arguments
+             rng, typ = typ, nil unless rng
+             # Process the range.
              if rng.is_a?(::Range) then
                  first = rng.first
                  if (first.is_a?(::Integer)) then
@@ -3113,14 +3125,23 @@ module HDLRuby::High
              end 
              if rng.is_a?(HDLRuby::Low::Expression) then
                  # Index case
-                 return RefIndex.new(self.type.base,self.to_expr,rng)
+                 if typ then
+                    return RefIndex.new(typ,self.to_expr,rng)
+                 else
+                    return RefIndex.new(self.type.base,self.to_expr,rng)
+                 end
              else
                  # Range case, ensure it is made among expression.
                  first = rng.first.to_expr
                  last = rng.last.to_expr
-                 # Abd create the reference.
-                 return RefRange.new(self.type.slice(first..last),
-                                     self.to_expr,first..last)
+                 # And create the reference.
+                 if typ then
+                    return RefRange.new(typ,
+                                        self.to_expr,first..last)
+                 else
+                    return RefRange.new(self.type.slice(first..last),
+                                        self.to_expr,first..last)
+                 end
              end
          end
 
@@ -3524,8 +3545,8 @@ module HDLRuby::High
             if @base.is_a?(RefThis) && 
                     (@object.parent != High.top_user) &&
                     (@object.parent != High.cur_system) &&
-                    (@object.parent != High.cur_system.scope) &&
-                    (!@object.parent.name.empty?) then
+                    (@object.parent != High.cur_system.scope) then # &&
+                    # (!@object.parent.name.empty?) then
                 # Need to have a hierachical access.
                 if @object.respond_to?(:low_object) && @object.low_object then
                     # There where already a low object, create the ref from it.
@@ -4387,9 +4408,15 @@ module HDLRuby::High
         end
 
         # Converts the block to HDLRuby::Low.
-        def to_low
+        # def to_low
+        def to_low(low_parent = nil)
             # Create the resulting block
             blockL = HDLRuby::Low::Block.new(self.mode,self.name)
+            # Is there a low parent?
+            if low_parent then
+                # Set it straight away to have correct references.
+                low_parent.block = blockL
+            end
             # # For debugging: set the source high object 
             # blockL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = blockL
@@ -4555,12 +4582,16 @@ module HDLRuby::High
 
         # Converts the time behavior to HDLRuby::Low.
         def to_low
+            # Create an empty low behavior for the result.
+            behaviorL = HDLRuby::Low::Behavior.new
+            # Then fill it.
             # Create the low level block.
-            blockL = self.block.to_low
+            # blockL = self.block.to_low
+            blockL = self.block.to_low(behaviorL)
             # Create the low level events.
             eventLs = self.each_event.map { |event| event.to_low }
-            # Create and return the resulting low level behavior.
-            behaviorL = HDLRuby::Low::Behavior.new(blockL)
+            # # Create and return the resulting low level behavior.
+            # behaviorL = HDLRuby::Low::Behavior.new(blockL)
             # # For debugging: set the source high object 
             # behaviorL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = behaviorL
@@ -4908,6 +4939,11 @@ module HDLRuby::High
         def width
             return self.bit_length
         end
+
+        # Cast.
+        def as(typ)
+            return self.to_expr.as(typ)
+        end
     end
 
     # Extends the Float class for computing the bit width and conversion

data/lib/HDLRuby/hruby_low.rb

@@ -74,6 +74,7 @@ module HDLRuby::Low
             res = []
             cur = self
             while(cur) do
+                # puts "cur=#{cur} cur.parent=#{cur.parent}"
                 res << cur
                 cur = cur.parent
             end
@@ -82,6 +83,7 @@ module HDLRuby::Low
 
         # Get an absolute reference to the object.
         def absolute_ref
+            # puts "absolute_ref for self=#{self}"
             # Get the full hierarchy up to the object.
             path = self.hierarchy
             # Create the reference.
@@ -2379,7 +2381,7 @@ module HDLRuby::Low
         attr_reader :block
 
         # Creates a new behavior executing +block+.
-        def initialize(block)
+        def initialize(block = nil)
             # Initialize the sensitivity list.
             @events = []
             # Check and set the block.
@@ -2417,7 +2419,7 @@ module HDLRuby::Low
             # And set the block
             @block = block
         end
-        private :block=
+        # private :block=
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
@@ -6078,6 +6080,10 @@ module HDLRuby::Low
                 raise AnyError, "Invalid class for a range last: #{last.class}."
             end
             @range = first..last
+            # Clears the parent of first and last that is automatically added
+            # by Ruby when creating a range.
+            first.no_parent! if first.is_a?(Hparent)
+            last.no_parent! if last.is_a?(Hparent)
             # And set their parents.
             first.parent = last.parent = self
         end

data/lib/HDLRuby/hruby_low_without_namespace.rb

@@ -88,6 +88,7 @@ module HDLRuby::Low
 
         # Moves the declarations to the upper namespace.
         def to_upper_space!
+            # puts "to_upper_space for scope=#{self}"
             # First recurse.
             # On the sub scopes.
             self.each_scope(&:to_upper_space!)
@@ -472,6 +473,7 @@ module HDLRuby::Low
         # Fix the references names using scopes given in +scopes + list (they
         # are marked to be deleted).
         def fix_scope_refnames!(scopes)
+          # puts "fix_scope_refnames for self=#{self}"
           self.block.fix_scope_refnames!(scopes)
           return self
         end
@@ -834,10 +836,13 @@ module HDLRuby::Low
 
         # Replaces recursively +former+ name by +nname+ until it is redeclared.
         def replace_names!(former,nname)
+            # Already processed with fix_scope_refnames, so nothing to do
+            # here.
+            return
             # Stop here if the name is redeclared.
-            return if self.each_inner.find {|inner| inner.name == former }
+            # return if self.each_inner.find {|inner| inner.name == former }
             # Recurse on the sub scopes and behaviors.
-            replace_names_subs!(former,nname)
+            # replace_names_subs!(former,nname)
         end
 
         # Fix the references names using scopes given in +scopes + list (they
@@ -856,14 +861,16 @@ module HDLRuby::Low
         # are marked to be deleted).
         def fix_scope_refnames!(scopes)
             return self unless self.ref.is_a?(RefName)
-            # puts "fix_scope_refnames! with self.name=#{name} and self.ref=#{self.ref}"
+            # puts "fix_scope_refnames! with self=#{self} self.name=#{name} and self.ref=#{self.ref}"
             # Recurse on the ref.
-            self.set_ref!(self.ref.fix_scope_refnames!(scopes))
+            # self.set_ref!(self.ref.fix_scope_refnames!(scopes))
             # Rename and curt the subref if referening to one of the scopes.
             if scopes.find {|scope| scope.name == self.ref.name } then
                 self.ref.extend_name!(self)
+                # But need to remove the scope reference.
                 self.set_ref!(RefThis.new)
             end
+            # puts "Now self=#{self} self.name=#{self.name} self.ref=#{self.ref}"
             return self
         end
     end

data/lib/HDLRuby/hruby_low_without_subsignals.rb

@@ -243,6 +243,7 @@ module HDLRuby::Low
         # Flatten a reference to a list of reference to leaf signals
         # from signal +sig+ and add to result to +subrefs+
         def flatten_to(sig,subrefs)
+            # puts "flatten_to with sig=#{sig}"
             # Shall we decompose 2d vectors, and is the current signal
             # for one of them?
             if SystemT.decompose_vec2d? and sig.type.is_a?(TypeVector) and

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "3.3.1"
+  VERSION = "3.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 3.3.3
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-04 00:00:00.000000000 Z
+date: 2024-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -186,6 +186,7 @@ files:
 - lib/HDLRuby/hdr_samples/tuple.rb
 - lib/HDLRuby/hdr_samples/type_minmax_bench.rb
 - lib/HDLRuby/hdr_samples/with_board.rb
+- lib/HDLRuby/hdr_samples/with_board_sequencer.rb
 - lib/HDLRuby/hdr_samples/with_bram.rb
 - lib/HDLRuby/hdr_samples/with_bram_frame_stack.rb
 - lib/HDLRuby/hdr_samples/with_bram_stack.rb
@@ -214,6 +215,7 @@ files:
 - lib/HDLRuby/hdr_samples/with_memory.rb
 - lib/HDLRuby/hdr_samples/with_memory_rom.rb
 - lib/HDLRuby/hdr_samples/with_multi_channels.rb
+- lib/HDLRuby/hdr_samples/with_nand_board.rb
 - lib/HDLRuby/hdr_samples/with_of.rb
 - lib/HDLRuby/hdr_samples/with_program_c.rb
 - lib/HDLRuby/hdr_samples/with_program_ruby.rb
@@ -474,7 +476,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.13
 signing_key:
 specification_version: 4
 summary: HDLRuby is a library for describing and simulating digital electronic systems.