HDLRuby 2.7.1 → 2.8.1

data/lib/HDLRuby/hdrcc.rb

@@ -647,12 +647,19 @@ elsif $options[:clang] then
         init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
                                            "init_default_visualizer"
 
+        # Gather the system to generate and sort them in the right order
+        # to ensure references are generated before being used.
+        # Base: reverse order of the tree.
+        # Then, multiple configuration of a system instance must be
+        # reverversed so that the base configuration is generated first.
+        c_systems = $top_system.each_systemT_deep_ref
         # Generate the code of the main function.
         # HDLRuby start code
         $main << HDLRuby::Low::Low2C.main("hruby_simulator",
                                          init_visualizer,
                                          $top_system,
-                                         $top_system.each_systemT_deep.to_a.reverse,$hnames)
+                                         c_systems,
+                                         $hnames)
         $main.close
 
         $top_system.each_systemT_deep do |systemT|

data/lib/HDLRuby/hruby_high.rb

@@ -133,6 +133,8 @@ module HDLRuby::High
     module Hmissing
         High = HDLRuby::High
 
+        NAMES = { }
+
         # Missing methods may be immediate values, if not, they are looked up
         # in the upper level of the namespace if any.
         def method_missing(m, *args, &ruby_block)
@@ -140,6 +142,20 @@ module HDLRuby::High
             # Is the missing method an immediate value?
             value = m.to_value
             return value if value and args.empty?
+            # Or is it a uniq name generator?
+            if (m[-1] == '?') then
+                # Yes
+                m = m[0..-2]
+                return NAMES[m] = HDLRuby.uniq_name(m)
+            end
+            # Is in a previous uniq name?
+            if (m[-1] == '!') then
+                pm = m[0..-2]
+                if NAMES.key?(pm) then
+                    # Yes, returns the current corresponding uniq name.
+                    return self.send(NAMES[pm],*args,&ruby_block)
+                end
+            end
             # No, is there an upper namespace, i.e. is the current object
             # present in the space?
             if High.space_index(self) then
@@ -256,9 +272,9 @@ module HDLRuby::High
                                     SignalI.new(name,type,:inner))
                             elsif name.is_a?(Hash) then
                                 # Names associated with values.
-                                names.each do |name,value|
+                                name.each do |key,value|
                                     res = self.add_inner(
-                                        SignalI.new(name,type,:inner,value))
+                                        SignalI.new(key,type,:inner,value))
                                 end
                             else
                                 raise AnyError,
@@ -550,10 +566,14 @@ module HDLRuby::High
             expanded = self.class.new(name.to_s) {}
             # Include the mixin systems given when declaring the system.
             @to_includes.each { |system| expanded.scope.include(system) }
+            # Include the previously includeds. */
+            self.scope.each_included { |system| expanded.scope.include(system) }
 
             # Sets the generators of the expanded result.
             expanded.add_generator(self)
             @to_includes.each { |system| expanded.add_generator(system) }
+            # Also for the previously includeds. */
+            self.scope.each_included.each { |system| expanded.add_generator(system) }
 
             # Fills the scope of the expanded class.
             # puts "Build top with #{self.name} for #{name}"
@@ -828,8 +848,7 @@ module HDLRuby::High
             # Initialize the set of included systems.
             @includes = {}
 
-            # Builds the scope if a ruby block is provided
-            # (which means the scope is not the top of a system).
+            # Builds the scope if a ruby block is provided.
             self.build(&ruby_block) if block_given?
         end
 
@@ -940,18 +959,20 @@ module HDLRuby::High
             # Set the namespace for buidling the scope.
             High.space_push(@namespace)
             # Build the scope.
-            # @return_value = High.top_user.instance_eval(&ruby_block)
-            res = High.top_user.instance_eval(&ruby_block)
+            @return_value = High.top_user.instance_eval(&ruby_block)
+            # res = High.top_user.instance_eval(&ruby_block)
             High.space_pop
-            # Now gain access to the result within the sub scope.
-            if (res.is_a?(HRef)) then
-                @return_value = res.type.inner(HDLRuby.uniq_name)
-                High.space_push(@namespace)
-                @return_value <= res
-                High.space_pop
-            else
-                @return_value = res
-            end
+            # # Now gain access to the result within the sub scope.
+            # # if (res.is_a?(HRef)) then
+            # if (res.is_a?(HExpression)) then
+            #     High.space_push(@namespace)
+            #     @return_value = res.type.inner(HDLRuby.uniq_name)
+            #     @return_value <= res
+            #     High.space_pop
+            #     @return_value = RefObject.new(self,@return_value)
+            # else
+            #     @return_value = res
+            # end
             # This will be the return value.
             @return_value
         end
@@ -1083,10 +1104,12 @@ module HDLRuby::High
         # Declares a sub scope with possible +name+ and built from +ruby_block+.
         def sub(name = :"", &ruby_block)
             # Creates the new scope.
-            scope = Scope.new(name,&ruby_block)
-            # puts "new scope=#{scope}"
+            # scope = Scope.new(name,&ruby_block)
+            scope = Scope.new(name)
             # Add it
             self.add_scope(scope)
+            # Build it.
+            scope.build(&ruby_block)
             # puts "self=#{self}"
             # puts "self scopes=#{self.each_scope.to_a.join(",")}"
             # Use its return value
@@ -1237,6 +1260,7 @@ module HDLRuby::High
             end
             # Adds it the list of includeds
             @includes[include_name] = system
+            # puts "@includes=#{@includes}"
             
         end
 
@@ -1960,9 +1984,6 @@ module HDLRuby::High
                                                          &ruby_block)
                     # ruby_block.call(*args)
                 end
-                # sub do
-                #     ruby_block.call(*args,*other_block)
-                # end
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
@@ -1970,10 +1991,8 @@ module HDLRuby::High
                 sub(HDLRuby.uniq_name(name)) do
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
+                    # ruby_block.call(*args,*other_block)
                 end
-                # sub do
-                #     ruby_block.call(*args,*other_block)
-                # end
             end
         end
     end
@@ -2033,10 +2052,25 @@ module HDLRuby::High
                 connects.each do |key,value|
                     # Gets the signal corresponding to connect.
                     signal = self.get_signal(key)
+                    unless signal then
+                        # Look into the included systems.
+                        self.systemT.scope.each_included do |included|
+                            signal = included.get_signal(key)
+                            break if signal
+                        end
+                    end
                     # Check if it is an output.
                     isout = self.get_output(key)
+                    unless isout then
+                        # Look into the inlucded systems.
+                        self.systemT.scope.each_included do |included|
+                            isout = included.get_output(key)
+                            break if isout
+                        end
+                    end
                     # Convert it to a reference.
                     ref = RefObject.new(self.to_ref,signal)
+                    # puts "key=#{key} value=#{value} signal=#{signal} ref=#{ref}"
                     # Make the connection.
                     if isout then
                         value <= ref
@@ -2085,6 +2119,54 @@ module HDLRuby::High
             self.eigen_extend(@systemT.public_namespace)
         end
 
+        # Adds alternative system +systemT+
+        def choice(configuration = {})
+            # Process the argument.
+            configuration.each do |k,v|
+                k = k.to_sym
+                unless v.is_a?(SystemT) then
+                    raise "Invalid class for a system type: #{v.class}"
+                end
+                # Create an eigen system.
+                eigen = v.instantiate(HDLRuby.uniq_name(self.name)).systemT
+                # Ensure its interface corresponds.
+                my_signals = self.each_signal.to_a
+                if (eigen.each_signal.with_index.find { |sig,i|
+                    !sig.eql?(my_signals[i])
+                }) then
+                raise "Invalid system for configuration: #{systemT.name}." 
+                end
+                # Add it.
+                # At the HDLRuby::High level
+                @choices = { self.name => self.systemT } unless @choices
+                @choices[k] = eigen
+                # At the HDLRuby::Low level
+                self.add_systemT(eigen)
+            end
+        end
+
+        # (Re)Configuration of system instance to systemT designated by +sys+.
+        # +sys+ may be the index or the name of the configuration, the first
+        # configuration being named by the systemI name.
+        def configure(sys)
+            if sys.respond_to?(:to_i) then
+                # The argument is an index.
+                # Create the (re)configuration node.
+                High.top_user.add_statement(
+                    Configure.new(RefObject.new(RefThis.new,self),sys.to_i))
+            else
+                # The argument is a name (should be).
+                # Get the index corresponding to the name.
+                num = @choices.find_index { |k,_| k == sys.to_sym }
+                unless num then
+                    raise "Invalid name for configuration: #{sys.to_s}"
+                end
+                # Create the (re)configuration node.
+                High.top_user.add_statement(
+                    Configure.new(RefObject.new(RefThis.new,self),num))
+            end
+        end
+
         # include Hmissing
 
         # Missing methods are looked for in the public namespace of the
@@ -2121,8 +2203,11 @@ module HDLRuby::High
             # systemIL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = systemIL
             # Adds the other systemTs.
-            self.each_systemT do |systemT|
-                systemIL.add_systemT(systemT.to_low) unless systemT == self.systemT
+            self.each_systemT do |systemTc|
+                if systemTc != self.systemT
+                    systemTcL = systemTc.to_low
+                    systemIL.add_systemT(systemTcL)
+                end
             end
             return systemIL
         end
@@ -2399,6 +2484,18 @@ module HDLRuby::High
         end
     end
 
+    ## 
+    # Describes a timed terminate statement: not synthesizable!
+    class TimeTerminate < Low::TimeTerminate
+        include HStatement
+
+        # Converts the repeat statement to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::TimeTerminate.new
+        end
+    end
+
+
 
     ##
     # Module giving high-level expression properties
@@ -2651,6 +2748,20 @@ module HDLRuby::High
         #
         # NOTE: +rng+ can be a single expression in which case it is an index.
         def [](rng)
+            if rng.is_a?(::Range) then
+                first = rng.first
+                if (first.is_a?(::Integer)) then
+                    first = self.type.size+first if first < 0
+                end
+                last = rng.last
+                if (last.is_a?(::Integer)) then
+                    last = self.type.size+last if last < 0
+                end
+                rng = first..last
+            end
+            if rng.is_a?(::Integer) && rng < 0 then
+                rng = self.type.size+rng
+            end
             if rng.respond_to?(:to_expr) then
                 # Number range: convert it to an expression.
                 rng = rng.to_expr
@@ -2987,6 +3098,7 @@ 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.name}"
             if object.respond_to?(:type) then
                 # Typed object, so typed reference.
                 super(object.type)
@@ -3023,7 +3135,7 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # puts "to_low with base=#{@base} @object=#{@object}"
+            # puts "to_low with base=#{@base} @object=#{@object.name}"
             refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              @base.to_ref.to_low,@object.name)
             # # For debugging: set the source high object 
@@ -3081,7 +3193,8 @@ module HDLRuby::High
         # Converts to a new reference.
         def to_ref
             return RefIndex.new(self.type,
-                                self.ref.to_ref,self.index.to_expr)
+                                # self.ref.to_ref,self.index.to_expr)
+                                self.ref.to_expr,self.index.to_expr)
         end
 
         # Converts the index reference to HDLRuby::Low.
@@ -3319,6 +3432,27 @@ module HDLRuby::High
     end
 
 
+    ## 
+    # Describes a systemI (re)configure statement: not synthesizable!
+    class Configure < Low::Configure
+        High = HDLRuby::High
+
+        include HStatement
+
+        # Creates a new (re)configure statement for system instance refered
+        # by +ref+ with system number +num+.
+        def initialize(ref,num)
+            super(ref,num)
+        end
+
+        # Converts the connection to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::Configure.new(self.ref.to_low, self.index)
+        end
+
+    end
+
+
     ## 
     # Describes a connection.
     class Connection < Low::Connection
@@ -3496,7 +3630,8 @@ module HDLRuby::High
         # Converts the system to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
             # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
-            signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low)
+            valueL = self.value ? self.value.to_low : nil
+            signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low,valueL)
             # # For debugging: set the source high object 
             # signalIL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = signalIL
@@ -3586,6 +3721,15 @@ module HDLRuby::High
             High.space_push(@namespace)
             @return_value = High.top_user.instance_eval(&ruby_block)
             High.space_pop
+            # if @return_value.is_a?(HExpression) then
+            #     res = @return_value
+            #     High.space_push(@namespace)
+            #     @return_value = res.type.inner(HDLRuby.uniq_name)
+            #     puts "@return_value name=#{@return_value.name}"
+            #     @return_value <= res
+            #     High.space_pop
+            #     @return_value = RefObject.new(self,@return_value)
+            # end
             @return_value
         end
 
@@ -3742,6 +3886,11 @@ module HDLRuby::High
         def hprint(*args)
             self.add_statement(Print.new(*args))
         end
+
+        # Terminate the simulation.
+        def terminate
+            self.add_statement(TimeTerminate.new)
+        end
     end
 
 
@@ -3775,7 +3924,7 @@ module HDLRuby::High
         # Converts the block to HDLRuby::Low.
         def to_low
             # Create the resulting block
-            blockL = HDLRuby::Low::Block.new(self.mode)
+            blockL = HDLRuby::Low::Block.new(self.mode,self.name)
             # # For debugging: set the source high object 
             # blockL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = blockL

data/lib/HDLRuby/hruby_low.rb

@@ -165,6 +165,22 @@ module HDLRuby::Low
 
 
 
+        # Handling the (re)configuration.
+
+        # Gets the configuration wrapper if any.
+        def wrapper
+            return defined? @wrapper ? @wrapper : nil
+        end
+
+        # Sets the configuration wrapper to +systemT+.
+        def wrapper=(systemT)
+            unless systemT.is_a?(SystemT) then
+                raise "Invalid class for a wrapper system type: #{systemT}."
+            end
+            @wrapper = systemT
+        end
+
+
         # Handling the signals.
 
         # Adds input +signal+.
@@ -432,6 +448,27 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Iterates over the systemT deeply if any in order of reference
+        # to ensure the refered elements are processed first.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_systemT_deep_ref(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_systemT_deep_ref) unless ruby_block
+            # A ruby block? 
+            # Recurse on the systemT accessible through the instances.
+            self.scope.each_scope_deep do |scope|
+                scope.each_systemI do |systemI|
+                    # systemI.systemT.each_systemT_deep(&ruby_block)
+                    systemI.each_systemT do |systemT|
+                        systemT.each_systemT_deep_ref(&ruby_block)
+                    end
+                end
+            end
+            # Finally apply it to current.
+            ruby_block.call(self)
+        end
     end
 
 
@@ -2500,8 +2537,8 @@ module HDLRuby::Low
     # NOTE: an instance can actually represented muliple layers
     #       of systems, the first one being the one actually instantiated
     #       in the final RTL code.
-    #       This layring can be used for describing software or partial
-    #       reconfiguration.
+    #       This layering can be used for describing software or partial
+    #       (re)configuration.
     class SystemI
 
         include Hparent
@@ -2564,13 +2601,16 @@ module HDLRuby::Low
             @name = name.to_sym
         end
 
-        ## Adds a system layer.
+        ## Adds a system configuration.
         def add_systemT(systemT)
             # puts "add_systemT #{systemT.name} to systemI #{self.name}"
             # Check and add the systemT.
             if !systemT.is_a?(SystemT) then
                 raise AnyError, "Invalid class for a system type: #{systemT.class}"
             end
+            # Set the base configuration of the added system.
+            systemT.wrapper = self.systemT
+            # Add it.
             @systemTs << systemT
         end
 
@@ -3781,6 +3821,93 @@ module HDLRuby::Low
                 end
             end
         end
+    end
+
+
+    ## 
+    # Describes a system instance (re)configuration statement: not synthesizable!
+    class Configure < Statement
+
+        # attr_reader :systemI, :systemT, :index
+        attr_reader :ref, :index
+
+        # Creates a new (re)configure statement of system instance refered by
+        # +ref+ with system number +index+
+        def initialize(ref,index)
+            super()
+            # Process the arguments.
+            index = index.to_i
+            unless ref.is_a?(Ref) then
+                raise "Invalid class for a reference: #{ref.class}."
+            end
+            # Sets the arguments.
+            @ref = ref
+            ref.parent = self
+            @index = index
+            # @systemT = systemI.each_systemT.to_a[index]
+            # # Check the systemT is valid.
+            # unless @systemT then
+            #     raise "Invalid configuration index: #{index}."
+            # end
+        end
+
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(Configure)
+            return false unless @ref.eql?(obj.ref)
+            return false unless @index.eql?(obj.index)
+            return true
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # Then apply on the reference.
+            @ref.each_deep(&ruby_block)
+        end
+
+        # Hash function.
+        def hash
+            return (@ref.hash + @index.hash).hash
+        end
+
+        # Clones (deeply)
+        def clone
+            return Configure.new(@ref.clone,@index)
+        end
+
+        # Iterates over the nodes deeply if any.
+        def each_node_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # And recurse on the reference.
+            @ref.each_node_deep(&ruby_block)
+        end
+
+        # Iterates over all the blocks contained in the current block.
+        def each_block_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block_deep) unless ruby_block
+            # A ruby block?
+            # Nothing more to do anyway.
+        end
+
+        # Iterates over all the statements contained in the current block.
+        def each_statement_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement_deep) unless ruby_block
+            # A ruby block?
+            # Apply it on self.
+            ruby_block.call(self)
+            # And that's all.
+        end
 
     end
 
@@ -3989,6 +4116,82 @@ module HDLRuby::Low
     end
 
 
+    ## 
+    # Describes a timed terminate statement: not synthesizable!
+    class TimeTerminate < Statement
+
+        # Creates a new timed terminate statement that terminate execution.
+        def initialize
+            super()
+        end
+
+        # Iterates over each object deeply.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_deep) unless ruby_block
+            # A ruby block? First apply it to current.
+            ruby_block.call(self)
+            # And that's all.
+        end
+
+        # Iterates over all the nodes.
+        def each_node(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node) unless ruby_block
+            # A ruby block?
+            # Nothing to do anyway.
+        end
+
+        # Iterates over all the nodes deeply.
+        def each_node_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_node_deep) unless ruby_block
+            # A ruby block?
+            # Apply of current node.
+            ruby_block.call(self)
+            # And that's all.
+        end
+
+        # Iterates over all the statements deeply.
+        def each_statement_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_statement_deep) unless ruby_block
+            # A ruby block?
+            # Apply of current node.
+            ruby_block.call(self)
+            # And that's all.
+        end
+
+        # Iterates over all the blocks contained in the current block.
+        def each_block_deep(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_block_deep) unless ruby_block
+            # A ruby block?
+            # Nothing to do anyway.
+        end
+
+        # Comparison for hash: structural comparison.
+        def eql?(obj)
+            return false unless obj.is_a?(TimeTerminate)
+            return true
+        end
+
+        # Hash function.
+        def hash
+            return TimeTerminate.hash
+        end
+
+        # Clones the TimeRepeat (deeply)
+        def clone
+            return TimeTerminate.new
+        end
+    end
+
+
+
+
     ## 
     # Describes a block.
     class Block < Statement
@@ -4058,6 +4261,7 @@ module HDLRuby::Low
 
         # Adds inner signal +signal+.
         def add_inner(signal)
+            # puts "add inner=#{signal.name} in block=#{self}"
             # Check and add the signal.
             unless signal.is_a?(SignalI)
                 raise AnyError,
@@ -4087,6 +4291,7 @@ module HDLRuby::Low
 
         ## Gets an inner signal by +name+.
         def get_inner(name)
+            # puts "name=#{name}, inners=#{@inners.each_key.to_a}"
             return @inners[name.to_sym]
         end
         alias_method :get_signal, :get_inner
@@ -5342,7 +5547,8 @@ module HDLRuby::Low
         def initialize(type,ref,index)
             super(type)
             # Check and set the accessed reference.
-            unless ref.is_a?(Ref) then
+            # unless ref.is_a?(Ref) then
+            unless ref.is_a?(Expression) then
                 raise AnyError, "Invalid class for a reference: #{ref.class}."
             end
             @ref = ref