HDLRuby 2.4.29 → 2.6.4

data/lib/HDLRuby/hruby_high.rb

@@ -347,6 +347,12 @@ module HDLRuby::High
                 end
             end
             @to_includes = mixins
+
+            # The list of systems the current system is expanded from if any.
+            # The first one is the main system, the other ones are the
+            # mixins.
+            @generators = []
+
             # Prepare the instantiation methods
             make_instantiater(name,SystemI,&ruby_block)
         end
@@ -472,6 +478,24 @@ module HDLRuby::High
             @scope.each_export(&ruby_block)
         end
 
+        # Adds a generator system.
+        def add_generator(gen) 
+            unless gen.is_a?(SystemT) then
+                raise "Invalid class for a generator system"
+            end
+            @generators << gen
+        end
+
+        # Iterates over the origin systems.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_generator(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_generator) unless ruby_block
+            # A block? Apply it on each generator.
+            @generators.each(&ruby_block)
+        end
+
         # Gets class containing the extension for the instances.
         def singleton_instance
             @singleton_instanceO.singleton_class
@@ -527,6 +551,10 @@ module HDLRuby::High
             # Include the mixin systems given when declaring the system.
             @to_includes.each { |system| expanded.scope.include(system) }
 
+            # Sets the generators of the expanded result.
+            expanded.add_generator(self)
+            @to_includes.each { |system| expanded.add_generator(system) }
+
             # Fills the scope of the expanded class.
             # puts "Build top with #{self.name} for #{name}"
             expanded.scope.build_top(self.scope,*args)
@@ -592,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) }
@@ -730,13 +758,17 @@ module HDLRuby::High
                       "Cannot convert a system without a name to HDLRuby::Low."
             end
             # Create the resulting low system type.
-            systemTlow = HDLRuby::Low::SystemT.new(High.names_create(name),
+            systemTL = HDLRuby::Low::SystemT.new(High.names_create(name),
                                                    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.
-            self.fill_low(systemTlow)
+            self.fill_low(systemTL)
             # Return theresulting system.
-            return systemTlow
+            return systemTL
         end
     end
 
@@ -905,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
 
@@ -1213,26 +1256,26 @@ module HDLRuby::High
         # Fills a low level scope with self's contents.
         #
         # NOTE: name conflicts are treated in the current NameStack state.
-        def fill_low(scopeLow)
+        def fill_low(scopeL)
             # Adds the content of its included systems.
-            @includes.each_value {|system| system.scope.fill_low(scopeLow) }
+            @includes.each_value {|system| system.scope.fill_low(scopeL) }
             # Adds the declared local system types.
             # NOTE: in the current version of HDLRuby::High, there should not
             # be any of them (only eigen systems are real system types).
-            self.each_systemT { |systemT| scopeLow.add_systemT(systemT.to_low) }
+            self.each_systemT { |systemT| scopeL.add_systemT(systemT.to_low) }
             # Adds the local types.
-            self.each_type { |type| scopeLow.add_type(type.to_low) }
+            self.each_type { |type| scopeL.add_type(type.to_low) }
             # Adds the inner scopes.
-            self.each_scope { |scope| scopeLow.add_scope(scope.to_low) }
+            self.each_scope { |scope| scopeL.add_scope(scope.to_low) }
             # Adds the inner signals.
-            self.each_inner { |inner| scopeLow.add_inner(inner.to_low) }
+            self.each_inner { |inner| scopeL.add_inner(inner.to_low) }
             # Adds the instances.
             # Single ones.
             self.each_systemI do |systemI|
                 # puts "Filling with systemI=#{systemI.name}"
-                systemI_low = scopeLow.add_systemI(systemI.to_low)
+                systemI_low = scopeL.add_systemI(systemI.to_low)
                 # Also add the eigen system to the list of local systems.
-                scopeLow.add_systemT(systemI_low.systemT)
+                scopeL.add_systemT(systemI_low.systemT)
             end
             # Grouped ones.
             self.each_groupI do |name,systemIs|
@@ -1242,42 +1285,46 @@ module HDLRuby::High
                     # puts "systemI.respond_to?=#{systemI.respond_to?(:name=)}"
                     systemI.name = name.to_s + "[#{i}]"
                     # And convert it to low
-                    systemI_low = scopeLow.add_systemI(systemI.to_low())
+                    systemI_low = scopeL.add_systemI(systemI.to_low())
                     # Also add the eigen system to the list of local systems.
-                    scopeLow.add_systemT(systemI_low.systemT)
+                    scopeL.add_systemT(systemI_low.systemT)
                 }
             end
             # Adds the code chunks.
-            self.each_code { |code| scopeLow.add_code(code.to_low) }
+            self.each_code { |code| scopeL.add_code(code.to_low) }
             # Adds the connections.
             self.each_connection { |connection|
                 # puts "connection=#{connection}"
-                scopeLow.add_connection(connection.to_low)
+                scopeL.add_connection(connection.to_low)
             }
             # Adds the behaviors.
             self.each_behavior { |behavior|
-                scopeLow.add_behavior(behavior.to_low)
+                scopeL.add_behavior(behavior.to_low)
             }
         end
 
         # Converts the scope to HDLRuby::Low.
         def to_low()
             # Create the resulting low scope.
-            # scopeLow = HDLRuby::Low::Scope.new()
-            scopeLow = HDLRuby::Low::Scope.new(self.name)
+            # scopeL = HDLRuby::Low::Scope.new()
+            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)
             # Pushes on the name stack for converting the internals of
             # the system.
             High.names_push
             # Adds the content of the actual system.
-            self.fill_low(scopeLow)
+            self.fill_low(scopeL)
             # Restores the name stack.
             High.names_pop
             # Restores the namespace stack.
             High.space_pop
             # Return theresulting system.
-            return scopeLow
+            return scopeL
         end
     end
     
@@ -1493,7 +1540,12 @@ module HDLRuby::High
         #
         # NOTE: should be overridden by other type classes.
         def to_low(name = self.name)
-            return HDLRuby::Low::Type.new(name)
+            # return HDLRuby::Low::Type.new(name)
+            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
 
@@ -1578,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)
@@ -1630,7 +1694,12 @@ module HDLRuby::High
         #
         # NOTE: should be overridden by other type classes.
         def to_low(name = self.name)
-            return HDLRuby::Low::TypeDef.new(name,self.def.to_low)
+            # return HDLRuby::Low::TypeDef.new(name,self.def.to_low)
+            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
 
@@ -1678,7 +1747,12 @@ module HDLRuby::High
         #
         # NOTE: should be overridden by other type classes.
         def to_low(name = self.name)
-            return HDLRuby::Low::TypeDef.new(name,self.def.to_low)
+            # return HDLRuby::Low::TypeDef.new(name,self.def.to_low)
+            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
 
@@ -1689,8 +1763,14 @@ module HDLRuby::High
         # Converts the type to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
             # Generate and return the new type.
-            return HDLRuby::Low::TypeVector.new(name,self.base.to_low,
+            # return HDLRuby::Low::TypeVector.new(name,self.base.to_low,
+            #                                     self.range.to_low)
+            typeVectorL = HDLRuby::Low::TypeVector.new(name,self.base.to_low,
                                                 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
 
@@ -1763,8 +1843,14 @@ module HDLRuby::High
 
         # Converts the type to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
-            return HDLRuby::Low::TypeTuple.new(name,self.direction,
+            # return HDLRuby::Low::TypeTuple.new(name,self.direction,
+            #                    *@types.map { |type| type.to_low } )
+            typeTupleL = HDLRuby::Low::TypeTuple.new(name,self.direction,
                                *@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
 
@@ -1778,8 +1864,14 @@ module HDLRuby::High
 
         # Converts the type to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
-            return HDLRuby::Low::TypeStruct.new(name,self.direction,
+            # return HDLRuby::Low::TypeStruct.new(name,self.direction,
+            #                     @types.map { |name,type| [name,type.to_low] } )
+            typeStructL = HDLRuby::Low::TypeStruct.new(name,self.direction,
                                 @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
 
@@ -1946,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)
@@ -2011,15 +2104,18 @@ module HDLRuby::High
         def to_low(name = self.name)
             # puts "to_low with #{self} (#{self.name}) #{self.systemT}"
             # Converts the system of the instance to HDLRuby::Low
-            systemTlow = self.systemT.to_low
+            systemTL = self.systemT.to_low
             # Creates the resulting HDLRuby::Low instance
-            systemIlow = HDLRuby::Low::SystemI.new(High.names_create(name),
-                                             systemTlow)
+            systemIL = HDLRuby::Low::SystemI.new(High.names_create(name),
+                                             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|
-                systemIlow.add_systemT(systemT.to_low) unless systemT == self.systemT
+                systemIL.add_systemT(systemT.to_low) unless systemT == self.systemT
             end
-            return systemIlow
+            return systemIL
         end
     end
 
@@ -2030,11 +2126,20 @@ module HDLRuby::High
     class Chunk < HDLRuby::Low::Chunk
         # Converts the if to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Chunk.new(self.name,
+            # return HDLRuby::Low::Chunk.new(self.name,
+            #                                *self.each_lump.map do |lump|
+            #     lump = lump.respond_to?(:to_low) ? lump.to_low : lump.to_s
+            #     lump
+            # end)
+            chunkL = HDLRuby::Low::Chunk.new(self.name,
                                            *self.each_lump.map do |lump|
                 lump = lump.respond_to?(:to_low) ? lump.to_low : lump.to_s
                 lump
             end)
+            # For debugging: set the source high object 
+            chunkL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = chunkL
+            return chunkL
         end
     end
 
@@ -2044,13 +2149,16 @@ module HDLRuby::High
         # Converts the if to HDLRuby::Low.
         def to_low
             # Create the resulting code.
-            res = HDLRuby::Low::Code.new
+            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| res.add_event(event.to_low) }
+            self.each_event { |event| codeL.add_event(event.to_low) }
             # Add the low-level code chunks.
-            self.each_chunk { |chunk| res.add_chunk(chunk.to_low) }
+            self.each_chunk { |chunk| codeL.add_chunk(chunk.to_low) }
             # Return the resulting code.
-            return res
+            return codeL
         end
     end
 
@@ -2133,10 +2241,13 @@ module HDLRuby::High
             # no may be nil, so treat it appart
             noL = self.no ? self.no.to_low : nil
             # Now generate the low-level if.
-            low = HDLRuby::Low::If.new(self.condition.to_low,
+            ifL = HDLRuby::Low::If.new(self.condition.to_low,
                                        self.yes.to_low,noL)
-            self.each_noif {|cond,block| low.add_noif(cond.to_low,block.to_low)}
-            return low
+            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
 
@@ -2154,8 +2265,14 @@ module HDLRuby::High
 
         # Converts the if to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::When.new(self.match.to_low,
+            # return HDLRuby::Low::When.new(self.match.to_low,
+            #                               self.statement.to_low)
+            whenL = HDLRuby::Low::When.new(self.match.to_low,
                                           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
 
@@ -2200,6 +2317,9 @@ module HDLRuby::High
         def to_low
             # Create the low level case.
             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)
@@ -2226,7 +2346,12 @@ module HDLRuby::High
 
         # Converts the delay to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Delay.new(self.value, self.unit)
+            # return HDLRuby::Low::Delay.new(self.value, self.unit)
+            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
 
@@ -2237,7 +2362,12 @@ module HDLRuby::High
 
         # Converts the wait statement to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::TimeWait.new(self.delay.to_low)
+            # return HDLRuby::Low::TimeWait.new(self.delay.to_low)
+            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
 
@@ -2249,8 +2379,14 @@ module HDLRuby::High
 
         # Converts the repeat statement to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
+            # return HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
+            #                                     self.delay.to_low)
+            timeRepeatL = HDLRuby::Low::TimeRepeat.new(self.statement.to_low,
                                                 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
 
@@ -2398,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
@@ -2546,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
@@ -2571,7 +2741,12 @@ module HDLRuby::High
 
         # Converts the unary expression to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
+            # return HDLRuby::Low::Cast.new(self.type.to_low,self.child.to_low)
+            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
 
@@ -2588,8 +2763,14 @@ module HDLRuby::High
 
         # Converts the unary expression to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Unary.new(self.type.to_low, self.operator,
+            # return HDLRuby::Low::Unary.new(self.type.to_low, self.operator,
+            #                                self.child.to_low)
+            unaryL = HDLRuby::Low::Unary.new(self.type.to_low, self.operator,
                                            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
 
@@ -2607,9 +2788,14 @@ module HDLRuby::High
 
         # Converts the binary expression to HDLRuby::Low.
         def to_low
-            # return HDLRuby::Low::Binary.new(self.operator,
-            return HDLRuby::Low::Binary.new(self.type.to_low, self.operator,
+            # return HDLRuby::Low::Binary.new(self.type.to_low, self.operator,
+            #                                self.left.to_low, self.right.to_low)
+            binaryL = HDLRuby::Low::Binary.new(self.type.to_low, self.operator,
                                            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
 
@@ -2631,11 +2817,20 @@ module HDLRuby::High
 
         # Converts the selection expression to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Select.new(self.type.to_low,"?",
+            # return HDLRuby::Low::Select.new(self.type.to_low,"?",
+            #                                 self.select.to_low,
+            # *self.each_choice.map do |choice|
+            #     choice.to_low
+            # end)
+            selectL = HDLRuby::Low::Select.new(self.type.to_low,"?",
                                             self.select.to_low,
             *self.each_choice.map do |choice|
                 choice.to_low
             end)
+            # For debugging: set the source high object 
+            selectL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = selectL
+            return selectL
         end
     end
 
@@ -2656,11 +2851,20 @@ module HDLRuby::High
 
         # Converts the concatenation expression to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Concat.new(self.type.to_low,
+            # return HDLRuby::Low::Concat.new(self.type.to_low,
+            #     self.each_expression.map do |expr|
+            #         expr.to_low
+            #     end
+            # )
+            concatL = HDLRuby::Low::Concat.new(self.type.to_low,
                 self.each_expression.map do |expr|
                     expr.to_low
                 end
             )
+            # For debugging: set the source high object 
+            concatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = concatL
+            return concatL
         end
     end
 
@@ -2699,7 +2903,12 @@ module HDLRuby::High
             # Clone the content if possible
             content = self.content.frozen? ? self.content : self.content.clone
             # Create and return the resulting low-level value
-            return HDLRuby::Low::Value.new(self.type.to_low,self.content)
+            # return HDLRuby::Low::Value.new(self.type.to_low,self.content)
+            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
 
     end
@@ -2801,9 +3010,13 @@ module HDLRuby::High
 
         # Converts the name reference to a HDLRuby::Low::RefName.
         def to_low
-            # return HDLRuby::Low::RefName.new(@base.to_ref.to_low,@object.name)
-            return HDLRuby::Low::RefName.new(self.type.to_low,
+            # 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
 
         # Missing methods are looked for into the refered object.
@@ -2830,11 +3043,20 @@ module HDLRuby::High
 
         # Converts the concat reference to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::RefConcat.new(self.type.to_low,
+            # return HDLRuby::Low::RefConcat.new(self.type.to_low,
+            #     self.each_ref.map do |ref|
+            #         ref.to_low
+            #     end
+            # )
+            refConcatL = HDLRuby::Low::RefConcat.new(self.type.to_low,
                 self.each_ref.map do |ref|
                     ref.to_low
                 end
             )
+            # For debugging: set the source high object 
+            refConcatL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = refConcatL
+            return refConcatL
         end
     end
 
@@ -2851,8 +3073,14 @@ module HDLRuby::High
 
         # Converts the index reference to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::RefIndex.new(self.type.to_low,
-                                              self.ref.to_low,self.index.to_low)
+            # return HDLRuby::Low::RefIndex.new(self.type.to_low,
+            #                                 self.ref.to_low,self.index.to_low)
+            refIndexL = HDLRuby::Low::RefIndex.new(self.type.to_low,
+                                            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
 
@@ -2869,8 +3097,14 @@ module HDLRuby::High
 
         # Converts the range reference to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::RefRange.new(self.type.to_low,
+            # return HDLRuby::Low::RefRange.new(self.type.to_low,
+            #     self.ref.to_low,self.range.to_low)
+            refRangeL = HDLRuby::Low::RefRange.new(self.type.to_low,
                 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
 
@@ -2881,14 +3115,19 @@ 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.
         def to_low
-            # puts "To low for ref with name=#{self.name} and subref=#{self.ref}"
-            return HDLRuby::Low::RefName.new(self.type.to_low,
+            # return HDLRuby::Low::RefName.new(self.type.to_low,
+            #                                  self.ref.to_low,self.name)
+            refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              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
 
@@ -2920,14 +3159,53 @@ module HDLRuby::High
 
         # Converts the this reference to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::RefThis.new
+            # return HDLRuby::Low::RefThis.new
+            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
 
 
@@ -2954,7 +3232,12 @@ module HDLRuby::High
 
         # Converts the event to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Event.new(self.type,self.ref.to_low)
+            # return HDLRuby::Low::Event.new(self.type,self.ref.to_low)
+            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
 
@@ -2990,11 +3273,39 @@ module HDLRuby::High
 
         # Converts the transmit to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Transmit.new(self.left.to_low,
+            # return HDLRuby::Low::Transmit.new(self.left.to_low,
+            #                                   self.right.to_low)
+            transmitL = HDLRuby::Low::Transmit.new(self.left.to_low,
                                               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
@@ -3055,8 +3366,14 @@ module HDLRuby::High
 
         # Converts the connection to HDLRuby::Low.
         def to_low
-            return HDLRuby::Low::Connection.new(self.left.to_low,
+            # return HDLRuby::Low::Connection.new(self.left.to_low,
+            #                                     self.right.to_low)
+            connectionL = HDLRuby::Low::Connection.new(self.left.to_low,
                                                 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
 
@@ -3086,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)
 
@@ -3165,7 +3482,12 @@ 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)
+            # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
+            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
 
@@ -3181,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
@@ -3224,8 +3546,14 @@ module HDLRuby::High
 
         # Converts the system to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
-            return HDLRuby::Low::SignalC.new(name,self.type.to_low,
+            # return HDLRuby::Low::SignalC.new(name,self.type.to_low,
+            #                                  self.value.to_low)
+            signalCL = HDLRuby::Low::SignalC.new(name,self.type.to_low,
                                              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
     
@@ -3298,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
@@ -3402,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
 
 
@@ -3436,6 +3763,9 @@ module HDLRuby::High
         def to_low
             # Create the resulting block
             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
@@ -3503,6 +3833,9 @@ module HDLRuby::High
         def to_low
             # Create the resulting block
             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
@@ -3594,6 +3927,9 @@ module HDLRuby::High
             eventLs = self.each_event.map { |event| event.to_low }
             # 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
             eventLs.each(&behaviorL.method(:add_event))
             return behaviorL
         end
@@ -3620,9 +3956,12 @@ module HDLRuby::High
             # 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::TimeBehavior.new(blockL)
-            eventLs.each(&behaviorL.method(:add_event))
-            return behaviorL
+            timeBehaviorL = HDLRuby::Low::TimeBehavior.new(blockL)
+            # For debugging: set the source high object 
+            timeBehaviorL.properties[:low2high] = self.hdr_id
+            self.properties[:high2low] = timeBehaviorL
+            eventLs.each(&timeBehaviorL.method(:add_event))
+            return timeBehaviorL
         end
     end
 
@@ -3927,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
 
 
@@ -4027,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
 
@@ -4102,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
@@ -4394,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__