HDLRuby 2.5.0 → 2.6.5

data/lib/HDLRuby/hruby_decorator.rb

@@ -46,11 +46,13 @@ module HDLRuby
         # Iterate over all the id with their object.
         #
         # Returns an enumerator if no ruby block is given.
+        #
+        # NOTE: converts the hash to an array to allow on-the-fly modification.
         def self.each(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each) unless ruby_block
             # A ruby block? Apply it on each object.
-            @@id_map.each(&ruby_block)
+            @@id_map.to_a.each(&ruby_block)
         end
 
         # The decorator also need to add properties to the HDLRuby objects.

data/lib/HDLRuby/hruby_high.rb

@@ -620,8 +620,8 @@ module HDLRuby::High
             # Extend the instance.
             instance.eigen_extend(@singleton_instanceO)
             # puts "instance scope= #{instance.systemT.scope}"
-            # Add the instance.
-            High.top_user.send(:add_systemI,instance)
+            # Add the instance if instantiating within another system.
+            High.top_user.send(:add_systemI,instance) if High.top_user
             
             # Execute the post instantiation tasks.
             eigen.each_on_instance { |task| task.(instance) }
@@ -762,6 +762,7 @@ module HDLRuby::High
                                                    self.scope.to_low)
             # For debugging: set the source high object 
             systemTL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = systemTL
 
             # Fills the interface of the new system 
             # from the included systems.
@@ -936,8 +937,19 @@ 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)
+            # @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
+            # This will be the return value.
             @return_value
         end
 
@@ -1298,6 +1310,7 @@ module HDLRuby::High
             scopeL = HDLRuby::Low::Scope.new(self.name)
             # For debugging: set the source high object 
             scopeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = scopeL
 
             # Push the private namespace for the low generation.
             High.space_push(@namespace)
@@ -1531,6 +1544,7 @@ module HDLRuby::High
             typeL = HDLRuby::Low::Type.new(name)
             # For debugging: set the source high object 
             typeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeL
             return typeL
         end
     end
@@ -1616,6 +1630,18 @@ module HDLRuby::High
         include HbasicType
     end
 
+    # The string type
+    StringT = define_type(:string)
+    class << StringT
+        # Converts the type to HDLRuby::Low.
+        def to_low
+            return Low::StringT
+        end
+
+        include HbasicType
+    end
+
+
     # # The infer type.
     # # Unspecified, but automatically infered when connected.
     # Infer = define_type(:infer)
@@ -1672,6 +1698,7 @@ module HDLRuby::High
             typeDefL = HDLRuby::Low::TypeDef.new(name,self.def.to_low)
             # For debugging: set the source high object 
             typeDefL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeDefL
             return typeDefL
         end
     end
@@ -1724,6 +1751,7 @@ module HDLRuby::High
             typeDefL = HDLRuby::Low::TypeDef.new(name,self.def.to_low)
             # For debugging: set the source high object 
             typeDefL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeDefL
             return typeDefL
         end
     end
@@ -1741,6 +1769,7 @@ module HDLRuby::High
                                                 self.range.to_low)
             # For debugging: set the source high object 
             typeVectorL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeVectorL
             return typeVectorL
         end
     end
@@ -1820,6 +1849,7 @@ module HDLRuby::High
                                *@types.map { |type| type.to_low } )
             # For debugging: set the source high object 
             typeTupleL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeTupleL
             return typeTupleL
         end
     end
@@ -1840,6 +1870,7 @@ module HDLRuby::High
                                 @types.map { |name,type| [name,type.to_low] } )
             # For debugging: set the source high object 
             typeStructL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = typeStructL
             return typeStructL
         end
     end
@@ -2007,7 +2038,8 @@ module HDLRuby::High
             else
                 # No, perform a connection is order of declaration
                 connects.each.with_index do |csig,i|
-                    # puts "csig=#{csig.name} i=#{i}"
+                    csig = csig.to_expr
+                    # puts "csig=#{csig} i=#{i}"
                     # puts "systemT inputs=#{systemT.each_input.to_a.size}"
                     # Gets i-est signal to connect
                     ssig = self.systemT.get_interface_with_included(i)
@@ -2078,6 +2110,7 @@ module HDLRuby::High
                                              systemTL)
             # For debugging: set the source high object 
             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
@@ -2105,6 +2138,7 @@ module HDLRuby::High
             end)
             # For debugging: set the source high object 
             chunkL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = chunkL
             return chunkL
         end
     end
@@ -2118,6 +2152,7 @@ module HDLRuby::High
             codeL = HDLRuby::Low::Code.new
             # For debugging: set the source high object 
             codeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = codeL
             # Add the low-level events.
             self.each_event { |event| codeL.add_event(event.to_low) }
             # Add the low-level code chunks.
@@ -2211,6 +2246,7 @@ module HDLRuby::High
             self.each_noif {|cond,block| ifL.add_noif(cond.to_low,block.to_low)}
             # For debugging: set the source high object 
             ifL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = ifL
             return ifL
         end
     end
@@ -2235,6 +2271,7 @@ module HDLRuby::High
                                           self.statement.to_low)
             # For debugging: set the source high object 
             whenL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = whenL
             return whenL
         end
     end
@@ -2282,6 +2319,7 @@ module HDLRuby::High
             caseL = HDLRuby::Low::Case.new(@value.to_low)
             # For debugging: set the source high object 
             caseL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = caseL
             # Add each when case.
             self.each_when do |w|
                 caseL.add_when(w.to_low)
@@ -2312,6 +2350,7 @@ module HDLRuby::High
             delayL = HDLRuby::Low::Delay.new(self.value, self.unit)
             # For debugging: set the source high object 
             delayL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = delayL
             return delayL
         end
     end
@@ -2327,6 +2366,7 @@ module HDLRuby::High
             timeWaitL = HDLRuby::Low::TimeWait.new(self.delay.to_low)
             # For debugging: set the source high object 
             timeWaitL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = timeWaitL
             return timeWaitL
         end
     end
@@ -2345,6 +2385,7 @@ module HDLRuby::High
                                                 self.delay.to_low)
             # For debugging: set the source high object 
             timeRepeatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = timeRepeatL
             return timeRepeatL
         end
     end
@@ -2493,6 +2534,35 @@ module HDLRuby::High
             return self.ljust(self[-1])
         end
 
+        # Match the type with +typ+:
+        # - Recurse on the sub expr if hierachical type, raising an arror
+        #   if the expression is not hierarchical.
+        # - Directly cast otherwise.
+        def match_type(typ)
+            # Has the type sub types?
+            if typ.types? then
+                unless self.is_a?(Concat) then
+                    raise AnyError,
+                        "Invalid class for assignment to hierarchical: #{self.class}."
+                end
+                return Concat.new(typ,
+                  self.each_expression.zip(typ.each_type).map do |e,t|
+                    e.match_type(t)
+                end)
+            elsif typ.vector? && typ.base.hierarchical? then
+                unless self.is_a?(Concat) then
+                    raise AnyError,
+                        "Invalid class for assignment to hierarchical: #{self.class}."
+                end
+                return Concat.new(typ,
+                  self.each_expression.map do |e|
+                    e.match_type(typ.base)
+                end)
+            else
+                return self.as(typ)
+            end
+        end
+
         # Gets the origin method for operation +op+.
         def self.orig_operator(op)
             return (op.to_s + "_orig").to_sym
@@ -2641,14 +2711,19 @@ module HDLRuby::High
         #
         # NOTE: it is converted afterward to an expression if required.
         def <=(expr)
+            # Cast expr to self if required.
+            expr = expr.to_expr.match_type(self.type)
+            # Generate the transmit.
             if High.top_user.is_a?(HDLRuby::Low::Block) then
                 # We are in a block, so generate and add a Transmit.
                 High.top_user.
-                    add_statement(Transmit.new(self.to_ref,expr.to_expr))
+                    # add_statement(Transmit.new(self.to_ref,expr.to_expr))
+                    add_statement(Transmit.new(self.to_ref,expr))
             else
                 # We are in a system type, so generate and add a Connection.
                 High.top_user.
-                    add_connection(Connection.new(self.to_ref,expr.to_expr))
+                    # add_connection(Connection.new(self.to_ref,expr.to_expr))
+                    add_connection(Connection.new(self.to_ref,expr))
             end
         end
     end
@@ -2670,6 +2745,7 @@ module HDLRuby::High
             castL =HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
             # For debugging: set the source high object 
             castL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = castL
             return castL
         end
     end
@@ -2693,6 +2769,7 @@ module HDLRuby::High
                                            self.child.to_low)
             # For debugging: set the source high object 
             unaryL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = unaryL
             return unaryL
         end
     end
@@ -2717,6 +2794,7 @@ module HDLRuby::High
                                            self.left.to_low, self.right.to_low)
             # For debugging: set the source high object 
             binaryL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = binaryL
             return binaryL
         end
     end
@@ -2751,6 +2829,7 @@ module HDLRuby::High
             end)
             # For debugging: set the source high object 
             selectL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = selectL
             return selectL
         end
     end
@@ -2784,6 +2863,7 @@ module HDLRuby::High
             )
             # For debugging: set the source high object 
             concatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = concatL
             return concatL
         end
     end
@@ -2827,6 +2907,7 @@ module HDLRuby::High
             valueL = HDLRuby::Low::Value.new(self.type.to_low,self.content)
             # For debugging: set the source high object 
             valueL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = valueL
             return valueL
         end
 
@@ -2929,12 +3010,12 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # return HDLRuby::Low::RefName.new(self.type.to_low,
-            #                                  @base.to_ref.to_low,@object.name)
+            # puts "to_low with base=#{@base} @object=#{@object}"
             refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              @base.to_ref.to_low,@object.name)
             # For debugging: set the source high object 
             refNameL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refNameL
             return refNameL
         end
 
@@ -2974,6 +3055,7 @@ module HDLRuby::High
             )
             # For debugging: set the source high object 
             refConcatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refConcatL
             return refConcatL
         end
     end
@@ -2997,6 +3079,7 @@ module HDLRuby::High
                                             self.ref.to_low,self.index.to_low)
             # For debugging: set the source high object 
             refIndexL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refIndexL
             return refIndexL
         end
     end
@@ -3020,6 +3103,7 @@ module HDLRuby::High
                 self.ref.to_low,self.range.to_low)
             # For debugging: set the source high object 
             refRangeL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refRangeL
             return refRangeL
         end
     end
@@ -3031,7 +3115,7 @@ module HDLRuby::High
 
         # Converts to a new reference.
         def to_ref
-            return RefName.new(self.ref.to_ref,self.name)
+            return RefName.new(self.type,self.ref.to_ref,self.name)
         end
 
         # Converts the name reference to HDLRuby::Low.
@@ -3042,6 +3126,7 @@ module HDLRuby::High
                                              self.ref.to_low,self.name)
             # For debugging: set the source high object 
             refNameL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refNameL
             return refNameL
         end
     end
@@ -3078,14 +3163,49 @@ module HDLRuby::High
             refThisL = HDLRuby::Low::RefThis.new
             # For debugging: set the source high object 
             refThisL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refThisL
             return refThisL
         end
     end
 
+    ##
+    # Describes a string.
+    #
+    # NOTE: This is not synthesizable!
+    class StringE < Low::StringE
+        include HExpression
+
+        # Converts to an expression.
+        def to_expr
+            return StringE.new(self.content,*self.each_arg.map(&:to_expr))
+        end
+
+        # Converts the connection to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::StringE.new(self.content,
+                                             *self.each_arg.map(&:to_low))
+        end
+    end
+
+
+
+    
+    # Sets the current this to +obj+.
+    #
+    # NOTE: do not use a this= style to avoid confusion.
+    def set_this(obj = proc { RefThis.new })
+        if (obj.is_a?(Proc)) then
+            @@this = obj
+        else
+            @@this = proc { RefObject.new(RefThis.new,obj) }
+        end
+    end
+
 
     # Gives access to the *this* reference.
     def this
-        RefThis.new
+        # RefThis.new
+        @@this.call
     end
 
 
@@ -3116,6 +3236,7 @@ module HDLRuby::High
             eventL = HDLRuby::Low::Event.new(self.type,self.ref.to_low)
             # For debugging: set the source high object 
             eventL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = eventL
             return eventL
         end
     end
@@ -3158,10 +3279,33 @@ module HDLRuby::High
                                               self.right.to_low)
             # For debugging: set the source high object 
             transmitL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = transmitL
             return transmitL
         end
     end
 
+
+    ## 
+    # Describes a print statement: not synthesizable!
+    class Print < Low::Print
+        High = HDLRuby::High
+
+        include HStatement
+
+        # Creates a new statement for printing +args+.
+        def initialize(*args)
+            # Process the arguments.
+            super(*args.map(&:to_expr))
+        end
+
+        # Converts the connection to HDLRuby::Low.
+        def to_low
+            return HDLRuby::Low::Print.new(*self.each_arg.map(&:to_low))
+        end
+
+    end
+
+
     ## 
     # Describes a connection.
     class Connection < Low::Connection
@@ -3228,6 +3372,7 @@ module HDLRuby::High
                                                 self.right.to_low)
             # For debugging: set the source high object 
             connectionL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = connectionL
             return connectionL
         end
     end
@@ -3258,7 +3403,7 @@ module HDLRuby::High
         # NOTE: +dir+ can be :input, :output, :inout or :inner
         def initialize(name,type,dir,value =  nil)
             # Check the value.
-            value = value.to_expr if value
+            value = value.to_expr.match_type(type) if value
             # Initialize the type structure.
             super(name,type,value)
 
@@ -3341,6 +3486,7 @@ module HDLRuby::High
             signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low)
             # For debugging: set the source high object 
             signalIL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = signalIL
             return signalIL
         end
     end
@@ -3357,7 +3503,7 @@ module HDLRuby::High
         # and +value+.
         def initialize(name,type,value)
             # Check the value is a constant.
-            value = value.to_expr
+            value = value.to_expr.match_type(type)
             unless value.constant? then
                 raise AnyError,"Non-constant value assignment to constant."
             end
@@ -3406,6 +3552,7 @@ module HDLRuby::High
                                              self.value.to_low)
             # For debugging: set the source high object 
             signalCL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = signalCL
             return signalCL
         end
     end
@@ -3479,13 +3626,6 @@ module HDLRuby::High
             # Use its return value.
             return block.return_value
         end
-
-        # # Get the current mode of the block.
-        # #
-        # # NOTE: for name coherency purpose only. 
-        # def block
-        #     return self.mode
-        # end
         
         # Gets the current block.
         def cur_block
@@ -3583,6 +3723,12 @@ module HDLRuby::High
             end
             statement.hwhen(match, mode, &ruby_block)
         end
+
+
+        # Prints.
+        def hprint(*args)
+            self.add_statement(Print.new(*args))
+        end
     end
 
 
@@ -3619,6 +3765,7 @@ module HDLRuby::High
             blockL = HDLRuby::Low::Block.new(self.mode)
             # For debugging: set the source high object 
             blockL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = blockL
             # Push the namespace for the low generation.
             High.space_push(@namespace)
             # Pushes on the name stack for converting the internals of
@@ -3688,6 +3835,7 @@ module HDLRuby::High
             blockL = HDLRuby::Low::TimeBlock.new(self.mode)
             # For debugging: set the source high object 
             blockL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = blockL
             # Add the inner signals
             self.each_inner { |inner| blockL.add_inner(inner.to_low) }
             # Add the statements
@@ -3781,6 +3929,7 @@ module HDLRuby::High
             behaviorL = HDLRuby::Low::Behavior.new(blockL)
             # For debugging: set the source high object 
             behaviorL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = behaviorL
             eventLs.each(&behaviorL.method(:add_event))
             return behaviorL
         end
@@ -3810,7 +3959,8 @@ module HDLRuby::High
             timeBehaviorL = HDLRuby::Low::TimeBehavior.new(blockL)
             # For debugging: set the source high object 
             timeBehaviorL.properties[:low2high] = self.hdr_id
-            eventLs.each(&behaviorL.method(:add_event))
+            self.properties[:high2low] = timeBehaviorL
+            eventLs.each(&timeBehaviorL.method(:add_event))
             return timeBehaviorL
         end
     end
@@ -4116,13 +4266,40 @@ module HDLRuby::High
 
     # Extends the String class for computing conversion to expression.
     class ::String
-        # Converts to a new high-level expression.
-        def to_expr
+        # # Converts to a new high-level expression.
+        # def to_expr
+        #     # Convert the string to a bit string.
+        #     bstr = BitString.new(self)
+        #     # Use it to create the new value.
+        #     return Value.new(Bit[bstr.width],self)
+        # end
+
+        # Converts to a new high-level value.
+        def to_value
             # Convert the string to a bit string.
             bstr = BitString.new(self)
             # Use it to create the new value.
             return Value.new(Bit[bstr.width],self)
         end
+        
+        # Convert to a new high-level string expression
+        def to_expr
+            return StringE.new(self)
+        end
+
+        # For now deactivated, needs rethinking.
+        # # Rework format to generate HDLRuby string.
+        # alias_method :__format_old__, :%
+        # def %(args)
+        #     # Is there any HW argument?
+        #     if args.any? { |arg| arg.is_a?(HDLRuby::Low::Hparent) } then
+        #         # Yes generate a HDLRuby string.
+        #         return StringE.new(self,*args)
+        #     else
+        #         # No process the format normally.
+        #         self.__format_old__(args)
+        #     end
+        # end
     end
 
 
@@ -4216,11 +4393,14 @@ module HDLRuby::High
 
         # Converts to a new high-level expression.
         def to_expr
-            # expr = Concat.new
-            expr = Concat.new(TypeTuple.new(:"",:little,*self.map do |elem|
-                elem.to_expr.type
-            end))
-            self.each {|elem| expr.add_expression(elem.to_expr) }
+            # expr = Concat.new(TypeTuple.new(:"",:little,*self.map do |elem|
+            #     elem.to_expr.type
+            # end))
+            elems = self.map {|elem| elem.to_expr }
+            typ= TypeTuple.new(:"",:little)
+            elems.each {|elem| typ.add_type(elem.type) }
+            expr = Concat.new(typ)
+            elems.each {|elem| expr.add_expression(elem) }
             expr
         end
 
@@ -4291,6 +4471,11 @@ module HDLRuby::High
             end
         end
 
+        # Add support of the left arrow operator.
+        def <=(expr)
+            self.to_expr <= expr
+        end
+
         # Array construction shortcuts
 
         # Create an array whose number of elements is given by the content
@@ -4583,6 +4768,9 @@ def self.configure_high
         end
     end
 
+    # Initialize the this.
+    set_this
+
     # Generate the standard signals
     $clk = Universe.scope.inner :__universe__clk__
     $rst = Universe.scope.inner :__universe__rst__