HDLRuby 2.4.29 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a583dff628b7090369ac26e9136e3c911204ea3078135fecfd249e1cd4521d2b
-  data.tar.gz: 1ac0f7881ab17a0ac1bf69cccc2028ae129eb5ac99640440ddb05fdb18605fe1
+  metadata.gz: 99c77fd470dae8d84cb066923fc8ed89d18e2aafa8bc826df85e03cae674c4e2
+  data.tar.gz: 4ef6902aec739f56c398bd653dc30f0dc03227799e1f54a9900b762d1a077aaa
 SHA512:
-  metadata.gz: c6883993bfcd2f3956710c1a88550faa6bc892b579a1741c85f43c19a44baafa3429d0735cbbdc7cacba7f51cbf40d92bfa3b0b74ba5c6fe014779935b82f6b5
-  data.tar.gz: e94a1ea16d576f5b1424ac2a3274ff43d5ed8a95471ad6ee4c86d45ec7d956c375f64c8011f8bdf7c7c85d2f02c882f869ca3d4e81f986831263a633f60e14e8
+  metadata.gz: 8c9972c8567cb1fd496268c4385b7f3caa0bd8718769254542adeceafafdc26ed09d5ce7c47430e0b0732ecbcda4ea5d0220cf4bc7be9721faf5b99bf47057cf
+  data.tar.gz: d300640fdc354ed55f9210c95d4aee10e52768a59ac39a993b402d8da78dd091f31d97fe307fe96b729d9194b532bf958761070224663e3bf2cd37e165877c21

data/lib/HDLRuby/drivers/xcd.rb

@@ -0,0 +1,79 @@
+require "HDLRuby/template_expander"
+
+##
+# XCD file generator from 'xcd' properties
+##########################################
+
+
+# Generates a xcd file from the HDLRuby objects from +top+ using
+# their 'xcd' properties.
+# The file is saved in +path+ directory.
+def xcd_generator(top, path)
+    # Ensure top is a system.
+    if top.is_a?(HDLRuby::Low::SystemI) then
+        top = top.systemT
+    elsif !top.is_a?(HDLRuby::Low::SystemT) then
+        raise "The 'xcd_generator' driver can only be applied on SystemT objects."
+    end
+
+    # Get the name of the resulting file if any.
+    if (top.properties.key?(:xcd_file)) then
+        xcd_file = top.properties[:xcd_file].join
+    else
+        # Default file name.
+        xcd_file = "default.xcd"
+    end
+
+    # Get the target template.
+    xcd_target       = top.properties[:xcd_target].join
+    xcd_target_name  = xcd_target
+    xcd_target_name += ".xcd" unless xcd_target_name.end_with?(".xcd")
+    xcd_target_tries = [ xcd_target_name,
+                         File.join(path,xcd_target_name),
+                         File.join(File.dirname(__FILE__),"xcd",xcd_target_name) ]
+    xcd_target_file = xcd_target_tries.find { |fname| File.exist?(fname) }
+    unless xcd_target_file then
+        raise "XCD target template not found for #{xcd_target}."
+    end
+    # Load the template.
+    template = File.read(xcd_target_file)
+
+    # Gather the signals by xcd key.
+    xcd2sig = top.each_signal.reduce([]) do |ar,sig|
+        ar += sig.properties.each_with_key(:xcd).map do |val|
+            [val,sig.name.to_s]
+        end
+    end
+
+    # Create the template expander that will generate the xcd file.
+    expander = TemplateExpander.new([
+        [ /^\?.*(\n|\z)/, proc do |str| # Signal link to port
+            if xcd2sig.any? do |match,rep|
+                if str.include?(match) then
+                    str = str.gsub("<>",rep)[1..-1]
+                else
+                    false
+                end
+            end then
+            str
+            else
+                ""
+            end
+        end ]
+    ])
+
+    # # Generate the xcd file.
+    # File.open(File.join(path,xcd_file),"w") do |file|
+    #     # Generate the signals mapping.
+    #     top.each_signal do |signal|
+    #         signal.properties.each_with_key(:xcd) do |value|
+    #             file << "#{value}\n"
+    #         end
+    #     end
+    # end
+    
+    # Generate the xcd file.
+    File.open(File.join(path,xcd_file),"w") do |file|
+        expander.expand(template,file)
+    end
+end

data/lib/HDLRuby/drivers/xcd/dummy.xcd

@@ -0,0 +1,4 @@
+<Dummy xcd template>
+?<PORT <> CLK>
+?<PORT <> RST>
+

data/lib/HDLRuby/hdr_samples/dff_properties.rb

@@ -0,0 +1,19 @@
+# A simple D-FF
+system :dff do
+    input :clk, :rst, :d
+    output :q, :qb
+
+    qb <= ~q
+
+    par(clk.posedge) { q <= d & ~rst }
+
+    clk.properties[:xcd] = "CLK"
+    rst.properties[:xcd] = "RST"
+    d.properties[:xcd]   = "PORT0"
+    q.properties[:xcd]   = "PORT1"
+    qb.properties[:xcd]  = "PORT2"
+    cur_system.properties[:xcd_target] = "dummy"
+    cur_system.properties[:xcd_file] = "dff.xcd"
+    cur_system.properties[:post_driver] = "drivers/xcd.rb", :xcd_generator
+end
+

data/lib/HDLRuby/hdrcc.rb

@@ -316,9 +316,9 @@ $optparse = OptionParser.new do |opts|
     opts.on("-p", "--param x,y,z", "Specify the generic parameters") do |p|
         $options[:param] = p
     end
-    opts.on("--version", "Print the version number, then exit") do
-        puts "hdrcc: HDLRuby #{HDLRuby::VERSION} compiler"
-        exit
+    opts.on("--dump","Dump all the properties to yaml files") do |v|
+        $options[:dump] = v
+        $options[:multiple] = v
     end
     # opts.on_tail("-h", "--help", "Show this message") do
     opts.on("-h", "--help", "Show this message") do
@@ -678,3 +678,31 @@ elsif $options[:vhdl] then
         end
     end
 end
+
+# Apply the post drivers if any.
+Hdecorator.each_with_property(:post_driver) do |obj, value|
+    # Load the driver.
+    require_relative(value[0].to_s)
+    # Execute it.
+    send(value[1].to_sym,obj,$output)
+end
+
+# Dump the properties
+if $options[:dump] then
+    # Decorate with the parent ids.
+    Hdecorator.decorate_parent_id
+    
+    # Generate the directory for the properties
+    property_dir = $output + "/properties"
+    unless File.directory?(property_dir)
+        FileUtils.mkdir_p(property_dir)
+    end
+
+    # Dump to one file per key
+    Properties.each_key do |key|
+        File.open(property_dir + "/#{key}.yaml", "w") do |f|
+            Hdecorator.dump(key,f)
+        end
+    end
+    
+end

data/lib/HDLRuby/hruby_decorator.rb

@@ -0,0 +1,248 @@
+require 'yaml'
+require 'set'
+
+module HDLRuby
+
+##
+# Library for describing a decorator used for adding properties to
+# HDLRuby objects that are persistent and can be used for back annotation
+########################################################################
+
+    ##
+    # Gives a decorator the HDLRuby object.
+    module Hdecorator
+        # The decorator requires that each HDLRuby object has a uniq
+        # persistent id
+
+        # The id
+        attr_reader :hdr_id
+
+        # The id to object table
+        @@id_map = {}
+
+        # Generate the ID
+        @@id_gen = 0
+
+        # Ensures the ID is generated when object is initialized
+        def self.included(base) # built-in Ruby hook for modules
+            base.class_eval do    
+                original_method = instance_method(:initialize)
+                define_method(:initialize) do |*args, &block|
+                    original_method.bind(self).call(*args, &block)
+                    # Generate the id.
+                    @hdr_id = @@id_gen
+                    @@id_gen += 1
+                    # Update the id to object table
+                    @@id_map[@hdr_id] = self
+                end
+            end
+        end
+
+        # Get an object by id.
+        def self.get(id)
+            return @@id_map[id]
+        end
+
+        # Iterate over all the id with their object.
+        #
+        # Returns an enumerator if no ruby block is given.
+        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)
+        end
+
+        # The decorator also need to add properties to the HDLRuby objects.
+
+        # Access the set of properties
+        def properties
+            # Create the properties if not present.
+            unless @properties then
+                @properties = Properties.new(self)
+            end
+            return @properties
+        end
+
+        # Iterate over all the objects from +top+ with +prop+ property.
+        #
+        # Returns an enumerator if no ruby block is given.
+        # NOTE: if +top+ is not given, iterate over all the objects.
+        def self.each_with_property(prop, top = nil, &ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_with_property) unless ruby_block
+            # A ruby block? Apply the ruby_block...
+            if (top) then
+                # A top... on each object from it.
+                top.each_deep do |obj|
+                    if (obj.properties.key?(prop)) then
+                        ruby_block.call(obj, *obj.properties[prop])
+                    end
+                end
+            else
+                # No top... on all the objects.
+                self.each do |id,obj|
+                    if (obj.properties.key?(prop)) then
+                        ruby_block.call(obj, *obj.properties[prop])
+                    end
+                end
+            end
+        end
+
+        # # Access the set of properties and the inherited properties from
+        # # the high objects.
+        # def all_properties
+        #     high_id = self.properties[:low2high]
+        #     if high_id && high_id >= 0 then
+        #         return properties.merge(Hdecorator.get(high_id))
+        #     else
+        #         return properties.clone
+        #     end
+        # end
+
+        # Saves properties +key+ of all the object associated with
+        # their id to +target+.
+        def self.dump(key, target = "")
+            # Build the table to dump
+            tbl = {}
+            self.each do |id,obj|
+                value = obj.properties[key]
+                if value.any? then
+                    tbl[id] = value
+                end
+            end
+            # Dump the table.
+            target << YAML.dump(tbl)
+            return target
+        end
+
+        # Loads properties to +key+ for all objects from +source+.
+        def self.load(source,key)
+            # Load the id to property table.
+            tbl = YAML.load(source)
+            # Adds the property of each object according to tbl
+            tbl.each do |id,value|
+                @@id_map[id].properties[key] = value
+            end
+        end
+
+        # Some predefined properties to set.
+
+        def self.decorate_parent_id
+            @@id_map.each do |id, obj|
+                parent = obj.parent
+                if parent then
+                    obj.properties[:parent_id] = obj.parent.hdr_id
+                else
+                    obj.properties[:parent_id] = -1
+                end
+            end
+        end
+
+    end
+
+
+    ## A HDLRuby set of properties
+    class Properties
+
+        # The set of all the property keys
+        @@property_keys = Set.new
+
+        # The HDLRuby object owning of the set of properties
+        attr_reader :owner
+
+        # Create a new set of properties and attach it to HDLRuby object
+        # +owner+.
+        def initialize(owner)
+            # Attach the owner.
+            @owner = owner
+            # Create the set.
+            @content = {}
+        end
+
+        # Clones the properties: also clone the contents.
+        def clone
+            result = Properties.new(owner)
+            @contents.each do |k,vals|
+                vals.each { |v| result[k] = v }
+            end
+            return result
+        end
+
+        # Create a new set of properties by merging with +prop+
+        def merge(prop)
+            result = self.clone
+            prop.each do |k,vals|
+                vals.each { |v| result[k] = v }
+            end
+            return result
+        end
+
+        # Tells if +key+ is present.
+        def key?(key)
+           @content.key?(key)
+        end
+
+        # Add a property
+        def []=(key,value)
+            @@property_keys << key
+            # Add an entry if not present.
+            @content[key] = [] unless @content.key?(key)
+            # Add the value to the entry.
+            @content[key] << value
+        end
+
+        # Get a property
+        def [](key)
+            return @content[key]
+        end
+
+        # Iterate over each value associated with +key+.
+        def each_with_key(key,&ruby_block)
+            return unless @content.key?(key)
+            @content[key].each(&ruby_block)
+        end
+
+        # Iterate over the properties of the current set.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each) unless ruby_block
+            # A ruby block? Apply it on each input signal instance.
+            @content.each(&ruby_block)
+        end
+
+        # Iterator over all the property keys
+        #
+        # Returns an enumerator if no ruby block is given.
+        def self.each_key(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_key) unless ruby_block
+            # A ruby block? Apply it on each input signal instance.
+            @@property_keys.each(&ruby_block)
+        end
+
+        # # Iterate over the property set of all the objects from current owner.
+        # #
+        # # Returns an enumerator if no ruby block is given.
+        # def each_properties(&ruby_block)
+        #     # No ruby block? Return an enumerator.
+        #     return to_enum(:each_properties) unless ruby_block
+        #     # A ruby block? Apply it.
+        #     # On current property set
+        #     ruby_block.call(self)
+        #     # And on the properties set of sub objects of the owner.
+        #     self.owner.instance_variables.each do |var|
+        #         obj = owner.instance_variable_get(var)
+        #         if (obj.is_a?(Hproperties)) then
+        #             # obj has properties, recurse on them.
+        #             obj.properties.each_properties(&ruby_block)
+        #         end
+        #     end
+        # end
+
+    end
+
+    
+end

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)
@@ -730,13 +758,16 @@ 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
+
             # 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
 
@@ -1213,26 +1244,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 +1273,45 @@ 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
+
             # 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 +1527,11 @@ 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
+            return typeL
         end
     end
 
@@ -1630,7 +1668,11 @@ 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
+            return typeDefL
         end
     end
 
@@ -1678,7 +1720,11 @@ 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
+            return typeDefL
         end
     end
 
@@ -1689,8 +1735,13 @@ 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
+            return typeVectorL
         end
     end
 
@@ -1763,8 +1814,13 @@ 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
+            return typeTupleL
         end
     end
 
@@ -1778,8 +1834,13 @@ 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
+            return typeStructL
         end
     end
 
@@ -2011,15 +2072,17 @@ 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
             # 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 +2093,19 @@ 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
+            return chunkL
         end
     end
 
@@ -2044,13 +2115,15 @@ 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
             # 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 +2206,12 @@ 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
+            return ifL
         end
     end
 
@@ -2154,8 +2229,13 @@ 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
+            return whenL
         end
     end
 
@@ -2200,6 +2280,8 @@ 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
             # Add each when case.
             self.each_when do |w|
                 caseL.add_when(w.to_low)
@@ -2226,7 +2308,11 @@ 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
+            return delayL
         end
     end
 
@@ -2237,7 +2323,11 @@ 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
+            return timeWaitL
         end
     end
 
@@ -2249,8 +2339,13 @@ 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
+            return timeRepeatL
         end
     end
 
@@ -2571,7 +2666,11 @@ 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
+            return castL
         end
     end
 
@@ -2588,8 +2687,13 @@ 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
+            return unaryL
         end
     end
 
@@ -2607,9 +2711,13 @@ 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
+            return binaryL
         end
     end
 
@@ -2631,11 +2739,19 @@ 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
+            return selectL
         end
     end
 
@@ -2656,11 +2772,19 @@ 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
+            return concatL
         end
     end
 
@@ -2699,7 +2823,11 @@ 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
+            return valueL
         end
 
     end
@@ -2801,9 +2929,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,
+            # return HDLRuby::Low::RefName.new(self.type.to_low,
+            #                                  @base.to_ref.to_low,@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 
+            refNameL.properties[:low2high] = self.hdr_id
+            return refNameL
         end
 
         # Missing methods are looked for into the refered object.
@@ -2830,11 +2962,19 @@ 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
+            return refConcatL
         end
     end
 
@@ -2851,8 +2991,13 @@ 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
+            return refIndexL
         end
     end
 
@@ -2869,8 +3014,13 @@ 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
+            return refRangeL
         end
     end
 
@@ -2886,9 +3036,13 @@ module HDLRuby::High
 
         # 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
+            return refNameL
         end
     end
 
@@ -2920,7 +3074,11 @@ 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
+            return refThisL
         end
     end
 
@@ -2954,7 +3112,11 @@ 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
+            return eventL
         end
     end
 
@@ -2990,8 +3152,13 @@ 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
+            return transmitL
         end
     end
 
@@ -3055,8 +3222,13 @@ 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
+            return connectionL
         end
     end
 
@@ -3165,7 +3337,11 @@ 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
+            return signalIL
         end
     end
 
@@ -3224,8 +3400,13 @@ 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
+            return signalCL
         end
     end
     
@@ -3436,6 +3617,8 @@ 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
             # Push the namespace for the low generation.
             High.space_push(@namespace)
             # Pushes on the name stack for converting the internals of
@@ -3503,6 +3686,8 @@ 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
             # Add the inner signals
             self.each_inner { |inner| blockL.add_inner(inner.to_low) }
             # Add the statements
@@ -3594,6 +3779,8 @@ 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
             eventLs.each(&behaviorL.method(:add_event))
             return behaviorL
         end
@@ -3620,9 +3807,11 @@ 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)
+            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))
-            return behaviorL
+            return timeBehaviorL
         end
     end