HDLRuby 3.9.1 → 3.9.3

data/lib/HDLRuby/hdr_samples/with_unary_reduction.rb

@@ -0,0 +1,23 @@
+# Sample code for testing unary reduction operators.
+
+system :with_unary_reduction do
+  [8].inner :val
+  inner :red0, :red1
+
+  red0 <= val.|()
+  red1 <= val.&()
+
+  timed do
+    val <= 0
+    !10.ns
+    val <= 1
+    !10.ns
+    val <= 2
+    !10.ns
+    val <= 3
+    !10.ns
+    val <= 255
+    !10.ns
+  end
+
+end

data/lib/HDLRuby/hdr_samples/with_values.rb

@@ -9,6 +9,8 @@ system :with_values do
     [64].inner :v64
     [96].inner :v96
 
+    _CST = _u8b1111_0000
+
 
     timed do
         v1  <= _b0
@@ -71,5 +73,7 @@ system :with_values do
         !10.ns
         v96 <= 0x1000000000000000000
         !10.ns
+        v8 <= _CST
+        !10.ns
     end
 end

data/lib/HDLRuby/hdrcc.rb

@@ -1079,6 +1079,9 @@ elsif $options[:vhdl] then
         end
     end
 elsif $options[:svg] then
+    # Requires to split the signals for better visibility and routability.
+    require "HDLRuby/hruby_low_split_signals.rb"
+    $top_system.split_signals
     # Requires the viz library.
     require "HDLRuby/hruby_viz.rb"
     # Generate the viz structure.

data/lib/HDLRuby/hruby_bstr.rb

@@ -100,7 +100,8 @@ module HDLRuby
             if @content.size < width then
                 @content.concat(content[-1]*(width-@content.size))
             else
-                @content.trunc!(width)
+                # @content.trunc!(width)
+              @content.slice!(width..-1)
             end
             @content.reverse!
         end

data/lib/HDLRuby/hruby_high.rb

@@ -934,10 +934,16 @@ module HDLRuby::High
         if condition.respond_to?(:to_i) then
           # The hif can be evaluate straight away. Do metaprograming.
           if condition.to_i != 0 then
+            caught = false
             HDLRuby::High.top_user.sub do
-              ruby_block.call
+              caught = true
+              catch(:HDLRubyThrow) do
+                ruby_block.call
+                caught = false
+              end
             end
             @metacond = :hif
+            throw(:HDLRubyThrow) if caught
           else
             @metacond = :helse
           end
@@ -956,10 +962,16 @@ module HDLRuby::High
           return :toif unless condition.respond_to?(:to_i)
           # The hif can be evaluate straight away. Do metaprograming.
           if condition.to_i != 0 then
+            caught = false
             HDLRuby::High.top_user.sub do
-              ruby_block.call
+              caught = true
+              catch(:HDLRubyThrow) do
+                ruby_block.call
+                caught = false
+              end
             end
             @metacond = :hif
+            throw(:HDLRubyThrow) if caught
           else
             @metacond = :helse
           end
@@ -990,10 +1002,16 @@ module HDLRuby::High
         if @metavalue and match.respond_to?(:to_i) then
           # The hwen can be evaluate straight away. Do metaprograming.
           if @metavalue == match.to_i then
+            caught = false
             HDLRuby::High.top_user.sub do
-              ruby_block.call
+              caught = true
+              catch(:HDLRubyThrow) do
+                ruby_block.call
+                caught = false
+              end
             end
             @metacond = :hwhen
+            throw(:HDLRubyThrow) if caught
           else
             @metacond = :helse
           end
@@ -1008,11 +1026,17 @@ module HDLRuby::High
         if @metacond then
           if @metacond == :helse then
             if ruby_block then
+              caught = false
               HDLRuby::High.top_user.sub do
-                ruby_block.call
+                caught = true
+                catch(:HDLRubyThrow) do
+                  ruby_block.call
+                  caught = false
+                end
               end
             end
             @metacond = nil
+            throw(:HDLRubyThrow) if caught
           end
           return true
         end
@@ -3273,14 +3297,18 @@ module HDLRuby::High
             end
         end
 
-        # Adds the binary operations generation.
+        # Adds the binary or unary-reduction operations generation.
         [:"+",:"-",:"*",:"/",:"%",:"**",
          :"&",:"|",:"^",
          :"<<",:">>",# :ls,:rs,:lr,:rr, # ls, rs lr and rr are treated separately
          :"==",:"!=",:"<",:">",:"<=",:">="].each do |operator|
-             meth = proc do |right|
+             meth = proc do |right = nil|
                  expr = self.to_expr
-                 return expr.type.binary(operator,expr,right.to_expr)
+                 if right then
+                   return expr.type.binary(operator,expr,right.to_expr)
+                 else
+                   return expr.type.unary(operator,expr)
+                 end
              end
              # Defines the operator method.
              define_method(operator,&meth) 

data/lib/HDLRuby/hruby_low.rb

@@ -419,15 +419,15 @@ module HDLRuby::Low
             return @inouts[name.to_sym]
         end
 
-        # # Gets an inner signal by +name+.
-        # def get_inner(name)
-        #     return @inners[name.to_sym]
-        # end
-
         # Gets a signal by +name+.
         def get_signal(name)
-            return get_input(name) || get_output(name) || get_inout(name) # ||
-                   # get_inner(name)
+            return get_input(name) || get_output(name) || get_inout(name) 
+        end
+
+        # Gets a signal by +name+ up to the systemT.
+        # Here it is a systemT, so stop here if not found.
+        def get_signal_up(name)
+          return self.get_signal(name)
         end
 
         # Gets an interface signal by order of declaration +i+.
@@ -435,41 +435,6 @@ module HDLRuby::Low
             return @interface[i]
         end
 
-        # # Deletes input +signal+.
-        # def delete_input(signal)
-        #     if @inputs.key?(signal) then
-        #         # The signal is present, delete it.
-        #         @inputs.delete(signal.name)
-        #         @interface.delete(signal)
-        #         # And remove its parent.
-        #         signal.parent = nil
-        #     end
-        #     signal
-        # end
-
-        # # Deletes output +signal+.
-        # def delete_output(signal)
-        #     if @outputs.key?(signal) then
-        #         # The signal is present, delete it.
-        #         @outputs.delete(signal.name)
-        #         @interface.delete(signal)
-        #         # And remove its parent.
-        #         signal.parent = nil
-        #     end
-        #     signal
-        # end
-
-        # # Deletes inout +signal+.
-        # def delete_inout(signal)
-        #     if @inouts.key?(signal) then
-        #         # The signal is present, delete it.
-        #         @inouts.delete(signal.name)
-        #         @interface.delete(signal)
-        #         # And remove its parent.
-        #         signal.parent = nil
-        #     end
-        #     signal
-        # end
     
         # Iterates over each object deeply.
         #
@@ -993,56 +958,20 @@ module HDLRuby::Low
             return @inners[name.to_sym]
         end
 
-        # ## Gets a signal by +path+.
-        # #
-        # #  NOTE: +path+ can also be a single name or a reference object.
-        # def get_signal(path)
-        #     path = path.path_each if path.respond_to?(:path_each) # Ref case.
-        #     if path.respond_to?(:each) then
-        #         # Path is iterable: look for the first name.
-        #         path = path.each
-        #         name = path.each.next
-        #         # Maybe it is a system instance.
-        #         systemI = self.get_systemI(name)
-        #         if systemI then
-        #             # Yes, look for the remaining of the path into the
-        #             # corresponding system type.
-        #             return systemI.systemT.get_signal(path)
-        #         else
-        #             # Maybe it is a signal name.
-        #             return self.get_signal(name)
-        #         end
-        #     else
-        #         # Path is a single name, look for the signal in the system's
-        #         # Try in the inputs.
-        #         signal = get_input(path)
-        #         return signal if signal
-        #         # Try in the outputs.
-        #         signal = get_output(path)
-        #         return signal if signal
-        #         # Try in the inouts.
-        #         signal = get_inout(path)
-        #         return signal if signal
-        #         # Not found yet, look into the inners.
-        #         return get_inner(path)
-        #     end
-        # end
-
         # Gets an inner signal by +name+, equivalent to get_inner.
         def get_signal(name)
             return @inners[name]
         end
 
-        # # Deletes inner +signal+.
-        # def delete_inner(signal)
-        #     if @inners.key?(signal) then
-        #         # The signal is present, delete it. 
-        #         @inners.delete(signal.name)
-        #         # And remove its parent.
-        #         signal.parent = nil
-        #     end
-        #     signal
-        # end
+        # Gets a signal by +name+ up to the systemT.
+        # Here it is a systemT, so stop here if not found.
+        def get_signal_up(name)
+          # Maybe its an inner.
+          sig = self.get_inner(name)
+          # If not, look in the parent.
+          sig = self.parent.get_signal(name) unless sig
+          return sig
+        end
 
         # Handling the connections.
 
@@ -2556,6 +2485,13 @@ module HDLRuby::Low
         def parent_system
             return self.top_scope.parent
         end
+
+        # Gets a signal by +name+ up to the systemT.
+        # Here it is a systemT, so stop here if not found.
+        def get_signal_up(name)
+          # Look in the parent.
+          return self.parent.get_signal(name)
+        end
     end
 
 
@@ -2710,6 +2646,24 @@ module HDLRuby::Low
             false
         end
 
+        # Give the direction of the signal if possible.
+        def direction
+          # No parent? No direction.
+          return nil unless self.parent
+          if self.parent.is_a?(Block) or self.parent.is_a?(Scope) then
+            # Inner direction.
+            return :inner
+          else
+            if parent.get_input(self.name) then
+              return :input
+            elsif parent.get_output(self.name) then
+              return :output
+            else
+              return :inout
+            end
+          end
+        end
+
         # Adds sub signal +sig+
         def add_signal(sig)
             # puts "add sub=#{sig.name} in signal=#{self}"
@@ -2938,6 +2892,7 @@ module HDLRuby::Low
                        :each_signal, :each_signal_deep,
                        :get_input, :get_output, :get_inout, :get_inner,
                        :get_signal, :get_interface,
+                       :get_signal_up,
                        :each_systemI, :get_systemI,
                        :each_connection, :each_connection_deep,
                        :each_statement_deep, :each_arrow_deep,
@@ -4700,6 +4655,16 @@ module HDLRuby::Low
         end
         alias_method :get_signal, :get_inner
 
+        # Gets a signal by +name+ up to the systemT.
+        # Here it is a systemT, so stop here if not found.
+        def get_signal_up(name)
+          # Maybe its an inner.
+          sig = self.get_inner(name)
+          # If not, look in the parent.
+          sig = self.parent.get_signal_up(name) unless sig
+          return sig
+        end
+
         # Iterates over all the signals of the block and its sub block's ones.
         def each_signal_deep(&ruby_block)
             # No ruby block? Return an enumerator.

data/lib/HDLRuby/hruby_low_split_signals.rb

@@ -0,0 +1,213 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+require 'HDLRuby/hruby_low_with_bool'
+
+
+module HDLRuby::Low
+
+
+##
+# Split signals with determined bit and range accesses.
+#
+########################################################################
+    
+
+    class SystemT
+
+      # Get the signals than can be split, where they are used and their
+      # resulting sub signals.
+      # The result is to be put in the +res+ table.
+      def get_signal_splits(res = { })
+        # Search in the scope.
+        return self.scope.get_signal_splits(res)
+      end
+
+      # Split the signals of a system if they have determined bit or range 
+      # accessed.
+      def split_signals(signals_splits = nil)
+        # puts "split_signals for systemT=#{self.name}"
+        # Gather the signals to split and their splitting.
+        signal_splits = self.get_signal_splits unless signals_splits
+
+        # Do the splitting.
+        signal_splits.each do |sig,splits|
+          # Get the owner of the signal.
+          owner = sig.parent
+          dir = sig.direction
+          # # Remove the signal from the owner since it is split.
+          # case dir
+          # when :input
+          #   owner.delete_input!(sig)
+          # when :output
+          #   owner.delete_output!(sig)
+          # when :inout
+          #   owner.delete_inout!(sig)
+          # when :inner
+          #   owner.delete_inner!(sig)
+          # end
+
+          # Add instead the corresponding sub signals.
+          splits.each do |idx,(sub,places)|
+            # puts "owner.class=#{owner.class} sub.class=#{sub.class}"
+            # In the owner.
+            case dir
+            when :input
+              owner.add_input(sub)
+            when :output
+              owner.add_output(sub)
+            when :inout
+              owner.add_input(sub)
+            when :inner
+              owner.add_inner(sub)
+            end
+
+            # Replace the references of the signal by its subs.
+            places.each do |place|
+              place.parent.map_nodes! do |node|
+                node == place ? HDLRuby::Low::RefName.new(Bit,RefThis.new,sub.name) : node
+              end
+            end
+          end
+        end
+      end
+    end
+
+
+    class Scope
+      # Get the signals than can be split, where they are used and their
+      # resulting sub signals.
+      # The result is to be put in the +res+ table.
+      def get_signal_splits(res = {})
+        # Search in the sub systems.
+        self.each_systemT { |sysT| sysT.get_signal_splits(res) }
+        # Search in the sub scopes.
+        self.each_scope { |scop| scop.get_signal_splits(res) }
+        # Search in the instances.
+        self.each_systemI { |sysI| sysI.get_signal_splits(res) }
+        # Search in the connections.
+        self.each_connection { |cnx| cnx.get_signal_splits(res) }
+        # Search in the behaviors.
+        self.each_behavior { |beh| beh.get_signal_splits(res) }
+        return res
+      end
+    end
+
+
+    class Behavior
+      # Get the signals than can be split, where they are used and their
+      # resulting sub signals.
+      # The result is to be put in the +res+ table.
+      def get_signal_splits(res = {})
+        # Recurse on the events.
+        self.each_event { |ev| ev.get_signal_splits(res) }
+        # Recurse on the block.
+        self.block.get_signal_splits(res)
+        return res
+      end
+    end
+
+
+    class Event
+      # Get the signals than can be split, where they are used and their
+      # resulting sub signals.
+      # The result is to be put in the +res+ table.
+      def get_signal_splits(res = {})
+        if self.ref.is_a?(RefIndex) and self.ref.ref.is_a?(RefName) and
+           self.ref.index.is_a?(Value) then
+          sigref = self.ref
+          # A split is found. Get the signal upward.
+          sig = self.parent.parent.get_signal_upward(self.ref.name)
+          sig.split_to_index(self.ref.index,res)
+        elsif self.ref.is_a?(RefRange) and self.ref.ref.is_a?(RefName) and
+          self.ref.range.first.is_a?(Value) and 
+          self.ref.range.last.is_a?(Value) then
+          sigref = self.ref
+          # A split is found. Get the signal upward.
+          sig = self.parent.parent.get_signal_upward(self.ref.name)
+          sig.split_to_range(self.ref.range,res)
+        end
+        return res
+      end
+    end
+
+
+    class SystemI
+      # Get the signals than can be split, where they are used and their
+      # resulting sub signals.
+      # The result is to be put in the +res+ table.
+      def get_signal_splits(res = {})
+        return self.systemT.get_signal_splits(res)
+      end
+    end
+
+
+    class Statement
+      # Get the signals than can be split, where they are used and their
+      # resulting sub signals.
+      # The result is to be put in the +res+ table.
+      def get_signal_splits(res = {})
+        # Recurse on the sub statements.
+        self.each_statement_deep do |stmnt|
+          stmnt.each_node_deep do |expr|
+            if expr.is_a?(RefIndex) and expr.ref.is_a?(RefName) and
+               expr.index.is_a?(Value) then
+              # A split is found. Get the signal upward.
+              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)
+            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
+              # A split is found. Get the signal upward.
+              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)
+            end
+          end
+        end
+        return res
+      end
+    end
+
+
+    class SignalI
+      # Split the signal at place +place+ for +index+ and register it to
+      # +res+ table.
+      def split_to_index(place ,index, res)
+        index = index.to_i
+        entry = res[self]
+        unless entry then
+          entry = {}
+          res[self] = entry
+        end
+        split = entry[index]
+        unless split then
+          split = [SignalI.new(self.name.to_s + "[#{index}]",Bit), []]
+          entry[index] = split
+        end
+        split[1] << place
+        return res
+      end
+
+      # Split the signal at place +place+ for +index+ and register it to
+      # +res+ table.
+      def split_to_range(place ,range, res)
+        range = range.first.to_i..range.last.to_i
+        entry = res[self]
+        unless entry then
+          entry = {}
+          res[self] = entry
+        end
+        split = entry[range]
+        unless split then
+          split = [SignalI.new(self.name.to_s + "[#{range}]",Bit), []]
+          entry[range] = split
+        end
+        split[1] << place
+        return res
+      end
+    end
+end

data/lib/HDLRuby/hruby_types.rb

@@ -156,7 +156,7 @@ module HDLRuby
         
 
         # And
-        def &(type)
+        def &(type = nil)
             # # puts "compute types with=#{self} and #{type}"
             # # Resolve the type class.
             # resolved = self.resolve(type)
@@ -178,7 +178,11 @@ module HDLRuby
             #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
             # end
             # The result is the resolve result now!
-            return self.resolve(type)
+            if type then
+              return self.resolve(type)
+            else
+              return self
+            end
         end
 
         # Or