HDLRuby 2.11.3 → 2.11.5

data/lib/HDLRuby/hruby_low2c.rb

@@ -843,6 +843,9 @@ module HDLRuby::Low
     ## Extends the SignalI class with generation of C text.
     class SignalI
 
+        # The id of a signal in the simulator.
+        @@signal_id = 0
+
         ## Generates the C text for an access to the signal.
         #  +level+ is the hierachical level of the object.
         # def to_c_signal(level = 0)
@@ -881,6 +884,8 @@ module HDLRuby::Low
             res << "SignalI signalI = malloc(sizeof(SignalIS));\n"
             res << " " * (level+1)*3
             res << "signalI->kind = SIGNALI;\n";
+            res << "signalI->id = #{@@signal_id};\n"
+            @@signal_id = @@signal_id+1;
 
             # Sets the global variable of the signal.
             res << "\n"
@@ -1803,20 +1808,39 @@ module HDLRuby::Low
     ## Extends the TimeRepeat class with generation of C text.
     class TimeRepeat
 
+        # # Generates the C text of the equivalent HDLRuby code.
+        # # +level+ is the hierachical level of the object.
+        # # def to_c(level = 0)
+        # def to_c(res,level = 0)
+        #     # The resulting string.
+        #     # res = " " * level*3
+        #     res << " " * level*3
+        #     # Generate an infinite loop executing the block and waiting.
+        #     res << "for(;;) {\n"
+        #     # res << "#{self.statement.to_c(level+1)}\n"
+        #     self.statement.to_c(res,level+1)
+        #     res << "\n"
+        #     res << " " * (level+1)*3
+        #     res << Low2C.wait_code(self,level)
+        #     # Return the resulting string.
+        #     return res
+        # end
+
         # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
             # The resulting string.
-            # res = " " * level*3
             res << " " * level*3
-            # Generate an infinite loop executing the block and waiting.
-            res << "for(;;) {\n"
-            # res << "#{self.statement.to_c(level+1)}\n"
+            if (number < 0) then
+                # Generate an infinite loop executing the block and waiting.
+                res << "for(;;) {\n"
+            else
+                # Generate a finite loop.
+                res << "for(long long i = 0; i<#{self.number}; ++i) {\n"
+            end
             self.statement.to_c(res,level+1)
-            res << "\n"
-            res << " " * (level+1)*3
-            res << Low2C.wait_code(self,level)
+            res << " " * level*3 << "}\n"
             # Return the resulting string.
             return res
         end

data/lib/HDLRuby/hruby_rcsim.rb

@@ -654,7 +654,21 @@ module HDLRuby::High
     ## Extends the TimeRepeat class for hybrid Ruby-C simulation.
     class TimeRepeat
         attr_reader :rcstatement
-        # TODO!!!
+
+        # Generate the C description of the hardware case.
+        # +owner+ is a link to the C description of the owner behavior if any.
+        def to_rcsim(owner = nil)
+            # Create the timeRepeat C object.
+            @rcstatement = RCSim.rcsim_make_timeRepeat(self.number,
+                                                       self.statement.to_rcsim)
+
+            # Sets the owner if any.
+            if owner then
+                RCSim.rcsim_set_owner(@rcstatement,owner)
+            end
+
+            return @rcstatement
+        end
     end
 
 
@@ -670,7 +684,7 @@ module HDLRuby::High
 
             # Sets the owner if any.
             if owner then
-                RCSim.rcsim_set_block_owner(@rcstatement,owner)
+                RCSim.rcsim_set_owner(@rcstatement,owner)
             end
 
             # Add the inner signals.

data/lib/HDLRuby/hruby_rsim.rb

@@ -16,6 +16,9 @@ module HDLRuby::High
     # Enhance a system type with Ruby simulation.
     class SystemT
 
+        # Tell if the simulation is in multithread mode or not.
+        attr_reader :multithread
+
         ## Add timed behavior +beh+.
         #  Returns the id of the timed behavior.
         def add_timed_behavior(beh)
@@ -36,6 +39,50 @@ module HDLRuby::High
             @sig_active << sig
         end
 
+        ## Advance the global simulator.
+        def advance
+            # Display the time
+            self.show_time
+            shown_values = {}
+            # Get the behaviors waiting on activated signals.
+            until @sig_active.empty? do
+                # # Update the signals.
+                # @sig_active.each { |sig| sig.c_value = sig.f_value }
+                # puts "sig_active.size=#{@sig_active.size}"
+                # Look for the behavior sensitive to the signals.
+                @sig_active.each do |sig|
+                    sig.each_anyedge { |beh| @sig_exec << beh }
+                    if (sig.c_value.zero? && !sig.f_value.zero?) then
+                        # puts "sig.c_value=#{sig.c_value.content}"
+                        sig.each_posedge { |beh| @sig_exec << beh }
+                    elsif (!sig.c_value.zero? && sig.f_value.zero?) then
+                        sig.each_negedge { |beh| @sig_exec << beh }
+                    end
+                end
+                # Update the signals.
+                @sig_active.each { |sig| sig.c_value = sig.f_value }
+                # puts "first @sig_exec.size=#{@sig_exec.size}"
+                @sig_exec.uniq! {|beh| beh.object_id }
+                # Display the activated signals.
+                @sig_active.each do |sig|
+                    if !shown_values[sig].eql?(sig.f_value) then
+                        self.show_signal(sig) 
+                        shown_values[sig] = sig.f_value
+                    end
+                end
+                # Clear the list of active signals.
+                @sig_active.clear
+                # puts "sig_exec.size=#{@sig_exec.size}"
+                # Execute the relevant behaviors and connections.
+                @sig_exec.each { |obj| obj.execute(:par) }
+                @sig_exec.clear
+                @sig_active.uniq! {|sig| sig.object_id }
+                # puts "@sig_active.size=#{@sig_active.size}"
+                # Advance time.
+                @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
+            end
+        end
+
         ## Run the simulation from the current systemT and outputs the resuts
         #  on simout.
         def sim(simout)
@@ -43,15 +90,6 @@ module HDLRuby::High
             HDLRuby.show "#{Time.now}#{show_mem}"
             # Merge the included.
             self.merge_included!
-            # Initializes the run mutex and the conditions.
-            @mutex = Mutex.new
-            @master = ConditionVariable.new
-            @master_flag = 0
-            @slave = ConditionVariable.new
-            @slave_flags_not = 0
-            @num_done = 0
-            # @lock = 0
-            # @runs = 0
             # Initializes the time.
             @time = 0
             # Initializes the time and signals execution buffers.
@@ -68,72 +106,93 @@ module HDLRuby::High
             self.init_sim(self)
             # Initialize the displayer.
             self.show_init(simout)
-            # exit
-            # First all the timed behaviors are to be executed.
-            @timed_behaviors.each {|beh| @tim_exec << beh }
-            # But starts locked.
-            @slave_flags_not = 2**@timed_behaviors.size - 1
-            # Starts the threads.
-            @timed_behaviors.each {|beh| beh.make_thread }
-
-            HDLRuby.show "Starting Ruby-level simulator..."
-            HDLRuby.show "#{Time.now}#{show_mem}"
-            # Run the simulation.
-            self.run_init do
-                # # Wake the behaviors.
-                # @timed_behaviors.each {|beh| beh.run }
-                until @tim_exec.empty? do
-                    # Display the time
-                    self.show_time
-                    # Execute the time behaviors that are ready.
-                    self.run_ack
-                    self.run_wait
-                    shown_values = {}
-                    # Get the behaviors waiting on activated signals.
-                    until @sig_active.empty? do
-                        # # Update the signals.
-                        # @sig_active.each { |sig| sig.c_value = sig.f_value }
-                        # puts "sig_active.size=#{@sig_active.size}"
-                        # Look for the behavior sensitive to the signals.
-                        @sig_active.each do |sig|
-                            sig.each_anyedge { |beh| @sig_exec << beh }
-                            if (sig.c_value.zero? && !sig.f_value.zero?) then
-                                # puts "sig.c_value=#{sig.c_value.content}"
-                                sig.each_posedge { |beh| @sig_exec << beh }
-                            elsif (!sig.c_value.zero? && sig.f_value.zero?) then
-                                sig.each_negedge { |beh| @sig_exec << beh }
-                            end
-                        end
-                        # Update the signals.
-                        @sig_active.each { |sig| sig.c_value = sig.f_value }
-                        # puts "first @sig_exec.size=#{@sig_exec.size}"
-                        @sig_exec.uniq! {|beh| beh.object_id }
-                        # Display the activated signals.
-                        @sig_active.each do |sig|
-                            if !shown_values[sig].eql?(sig.f_value) then
-                                self.show_signal(sig) 
-                                shown_values[sig] = sig.f_value
-                            end
+
+            # Is there more than one timed behavior.
+            if @total_timed_behaviors <= 1 then
+                # No, no need of multithreading.
+                @multithread = false
+                # Simple execute the block of the behavior.
+                @timed_behaviors[0].block.execute(:seq)
+            else
+                # Yes, need of multithreading.
+                @multithread = true
+                # Initializes the run mutex and the conditions.
+                @mutex = Mutex.new
+                @master = ConditionVariable.new
+                @master_flag = 0
+                @slave = ConditionVariable.new
+                @slave_flags_not = 0
+                @num_done = 0
+
+                # First all the timed behaviors are to be executed.
+                @timed_behaviors.each {|beh| @tim_exec << beh }
+                # But starts locked.
+                @slave_flags_not = 2**@timed_behaviors.size - 1
+                # Starts the threads.
+                @timed_behaviors.each {|beh| beh.make_thread }
+
+                HDLRuby.show "Starting Ruby-level simulator..."
+                HDLRuby.show "#{Time.now}#{show_mem}"
+                # Run the simulation.
+                self.run_init do
+                    # # Wake the behaviors.
+                    # @timed_behaviors.each {|beh| beh.run }
+                    until @tim_exec.empty? do
+                        # Execute the time behaviors that are ready.
+                        self.run_ack
+                        self.run_wait
+                        # Advance the global simulator.
+                        self.advance
+                        # # Display the time
+                        # self.show_time
+                        # shown_values = {}
+                        # # Get the behaviors waiting on activated signals.
+                        # until @sig_active.empty? do
+                        #     # # Update the signals.
+                        #     # @sig_active.each { |sig| sig.c_value = sig.f_value }
+                        #     # puts "sig_active.size=#{@sig_active.size}"
+                        #     # Look for the behavior sensitive to the signals.
+                        #     @sig_active.each do |sig|
+                        #         sig.each_anyedge { |beh| @sig_exec << beh }
+                        #         if (sig.c_value.zero? && !sig.f_value.zero?) then
+                        #             # puts "sig.c_value=#{sig.c_value.content}"
+                        #             sig.each_posedge { |beh| @sig_exec << beh }
+                        #         elsif (!sig.c_value.zero? && sig.f_value.zero?) then
+                        #             sig.each_negedge { |beh| @sig_exec << beh }
+                        #         end
+                        #     end
+                        #     # Update the signals.
+                        #     @sig_active.each { |sig| sig.c_value = sig.f_value }
+                        #     # puts "first @sig_exec.size=#{@sig_exec.size}"
+                        #     @sig_exec.uniq! {|beh| beh.object_id }
+                        #     # Display the activated signals.
+                        #     @sig_active.each do |sig|
+                        #         if !shown_values[sig].eql?(sig.f_value) then
+                        #             self.show_signal(sig) 
+                        #             shown_values[sig] = sig.f_value
+                        #         end
+                        #     end
+                        #     # Clear the list of active signals.
+                        #     @sig_active.clear
+                        #     # puts "sig_exec.size=#{@sig_exec.size}"
+                        #     # Execute the relevant behaviors and connections.
+                        #     @sig_exec.each { |obj| obj.execute(:par) }
+                        #     @sig_exec.clear
+                        #     @sig_active.uniq! {|sig| sig.object_id }
+                        #     # puts "@sig_active.size=#{@sig_active.size}"
+                        # end
+
+                        # # Advance time.
+                        # @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
+                        break if @timed_behaviors.empty?
+                        # Schedule the next timed behavior to execute.
+                        @tim_exec = []
+                        @timed_behaviors.each do |beh|
+                            @tim_exec << beh if beh.time == @time
                         end
-                        # Clear the list of active signals.
-                        @sig_active.clear
-                        # puts "sig_exec.size=#{@sig_exec.size}"
-                        # Execute the relevant behaviors and connections.
-                        @sig_exec.each { |obj| obj.execute(:par) }
-                        @sig_exec.clear
-                        @sig_active.uniq! {|sig| sig.object_id }
-                        # puts "@sig_active.size=#{@sig_active.size}"
-                    end
-                    break if @timed_behaviors.empty?
-                    # Advance time.
-                    @time = (@timed_behaviors.min {|b0,b1|  b0.time <=> b1.time }).time
-                    # Schedule the next timed behavior to execute.
-                    @tim_exec = []
-                    @timed_behaviors.each do |beh|
-                        @tim_exec << beh if beh.time == @time
+                        # puts "@tim_exec.size=#{@tim_exec.size}"
+                        # puts "@timed_bevaviors.size=#{@timed_behaviors.size}"
                     end
-                    # puts "@tim_exec.size=#{@tim_exec.size}"
-                    # puts "@timed_bevaviors.size=#{@timed_behaviors.size}"
                 end
             end
         end
@@ -358,7 +417,8 @@ module HDLRuby::High
                     begin
                         # puts "Starting thread"
                         systemT.run_req(@id)
-                        self.block.execute(:par)
+                        # self.block.execute(:par)
+                        self.block.execute(:seq)
                         # puts "Ending thread"
                     rescue => e
                         puts "Got exception: #{e.full_message}"
@@ -690,10 +750,16 @@ module HDLRuby::High
         def execute(mode)
             @behavior ||= self.behavior
             @behavior.time += self.delay.time_ps
-            # puts "Stopping #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
-            @sim.run_done(@behavior.id)
-            # puts "Rerunning #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
-            @sim.run_req(@behavior.id)
+            if @sim.multithread then
+                # Multi thread mode: synchronize.
+                # puts "Stopping #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
+                @sim.run_done(@behavior.id)
+                # puts "Rerunning #{@behavior.object_id} (@behavior.time=#{@behavior.time})..."
+                @sim.run_req(@behavior.id)
+            else
+                # No thread mode, need to advance the global simulator.
+                @sim.advance
+            end
         end
     end
 
@@ -701,7 +767,16 @@ module HDLRuby::High
     ## 
     # Describes a timed loop statement: not synthesizable!
     class TimeRepeat
-        ## Deprecated
+        ## Initialize the simulation for system +systemT+.
+        def init_sim(systemT)
+            # Recurde on the statement.
+            self.statement.init_sim(systemT)
+        end
+
+        ## Executes the statement.
+        def execute(mode)
+            self.number.times { self.statement.execute(mode) }
+        end
     end
 
 

data/lib/HDLRuby/hruby_rsim_vcd.rb

@@ -11,6 +11,35 @@ module HDLRuby::High
         return name.to_s.gsub(/[^a-zA-Z0-9_$]/,"$")
     end
 
+    ## Converts a bit string to a vcd format.
+    def self.vcd_bitstr(str)
+        if str.length > 1 then
+            return "b" + str + " "
+        else
+            return str
+        end
+    end
+
+    ## Converts a HDLRuby object to a VCD id string.
+    @@rsim_object_idstr = { }
+    @@rsim_object_idstr_count = 0
+    def self.vcd_idstr(obj)
+        idstr = @@rsim_object_idstr[obj]
+        unless idstr then
+            # Must generate a new id string.
+            chars = []
+            id = @@rsim_object_idstr_count
+            @@rsim_object_idstr_count += 1
+            loop do
+                chars << ((id % (127-33)) + 33).chr
+                break if ((id=id/(127-33)) == 0)
+            end
+            idstr = chars.join
+            @@rsim_object_idstr[obj] = idstr
+        end
+        return idstr
+    end
+
     ##
     # Enhance the system type class with VCD support.
     class SystemT
@@ -40,14 +69,24 @@ module HDLRuby::High
             # Closes the header.
             @vcdout << "$enddefinitions $end\n"
             # Initializes the variables with their name.
-            @vars_with_fullname = self.get_vars_with_fullname
+            # @vars_with_fullname = self.get_vars_with_fullname
+            @vars_with_idstr = self.get_vars_with_idstr
             @vcdout << "$dumpvars\n"
-            @vars_with_fullname.each_pair do |sig,fullname|
+            # @vars_with_fullname.each_pair do |sig,fullname|
+            #     if sig.f_value then
+            #         @vcdout << "   b#{sig.f_value.to_vstr} #{fullname}\n"
+            #     else
+            #         @vcdout << "   b#{"x"} #{fullname}\n"
+            #     end
+            # end
+            @vars_with_idstr.each_pair do |sig,idstr|
                 if sig.f_value then
-                    @vcdout << "   b#{sig.f_value.to_vstr} #{fullname}\n"
+                    # @vcdout << "   b#{sig.f_value.to_vstr} #{idstr}\n"
+                    @vcdout << HDLRuby::High.vcd_bitstr(sig.f_value.to_vstr) <<
+                               idstr << "\n"
                 else
-                    # @vcdout << "   b#{"x"*sig.type.width} #{fullname}\n"
-                    @vcdout << "   b#{"x"} #{fullname}\n"
+                    # @vcdout << "   b#{"x"} #{idstr}\n"
+                    @vcdout << HDLRuby::High.vcd_bitstr("x") << idstr << "\n"
                 end
             end
             @vcdout << "$end\n"
@@ -63,6 +102,16 @@ module HDLRuby::High
             return self.scope.get_vars_with_fullname(vars_with_fullname)
         end
 
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Adds the signals of the interface of the system.
+            self.each_signal do |sig|
+                vars_with_idstr[sig] = HDLRuby::High.vcd_idstr(sig)
+            end
+            # Recurse on the scope.
+            return self.scope.get_vars_with_idstr(vars_with_idstr)
+        end
+
         ## Shows the hierarchy of the variables.
         def show_hierarchy(vcdout)
             # puts "show_hierarchy for module #{self} (#{self.name})"
@@ -72,7 +121,8 @@ module HDLRuby::High
             self.each_signal do |sig|
                 # puts "showing signal #{HDLRuby::High.vcd_name(sig.fullname)}"
                 vcdout << "$var wire #{sig.type.width} "
-                vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                # vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                vcdout << "#{HDLRuby::High.vcd_idstr(sig)} "
                 vcdout << "#{HDLRuby::High.vcd_name(sig.name)} $end\n"
             end
             # Recurse on the scope.
@@ -88,8 +138,9 @@ module HDLRuby::High
 
         ## Displays the value of signal +sig+.
         def show_signal(sig)
-            @vcdout << "b#{sig.f_value.to_vstr} "
-            @vcdout << "#{@vars_with_fullname[sig]}\n"
+            # @vcdout << "b#{sig.f_value.to_vstr} "
+            @vcdout << HDLRuby::High.vcd_bitstr(sig.f_value.to_vstr)
+            @vcdout << "#{@vars_with_idstr[sig]}\n"
         end
 
         ## Displays value +val+.
@@ -121,7 +172,8 @@ module HDLRuby::High
             self.each_inner do |sig|
                 # puts "showing inner signal #{HDLRuby::High.vcd_name(sig.fullname)}"
                 vcdout << "$var wire #{sig.type.width} "
-                vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                # vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                vcdout << "#{HDLRuby::High.vcd_idstr(sig)} "
                 vcdout << "#{HDLRuby::High.vcd_name(sig.name)} $end\n"
             end
             # Recurse on the behaviors' blocks
@@ -162,6 +214,27 @@ module HDLRuby::High
             end
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Adds the inner signals.
+            self.each_inner do |sig|
+                vars_with_idstr[sig] = HDLRuby::High.vcd_idstr(sig)
+            end
+            # Recurse on the behaviors' blocks
+            self.each_behavior do |beh|
+                beh.block.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recurse on the systemI's Eigen system.
+            self.each_systemI do |sys|
+                sys.systemT.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recurse on the subscopes.
+            self.each_scope do |scope|
+                scope.get_vars_with_idstr(vars_with_idstr)
+            end
+            return vars_with_idstr
+        end
     end
 
 
@@ -177,6 +250,31 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
+    end
+
+    ##
+    # Enhance the TimeRepeat class with VCD support.
+    class TimeRepeat
+        ## Shows the hierarchy of the variables.
+        def show_hierarchy(vcdout)
+            # Recurse on the statement.
+            self.statement.show_hierarchy(vcdout)
+        end
+
+        ## Gets the VCD variables with their long name.
+        def get_vars_with_fullname(vars_with_fullname = {})
+            # By default: nothing to do
+        end
+
+        ## Gets the VCD variables with their idstr.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
     ##
@@ -191,6 +289,11 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
     ##
@@ -205,6 +308,11 @@ module HDLRuby::High
         def get_vars_with_fullname(vars_with_fullname = {})
             # By default: nothing to do
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # By default: nothing to do
+        end
     end
 
 
@@ -223,7 +331,8 @@ module HDLRuby::High
             self.each_inner do |sig|
                 # puts "showing inner signal #{HDLRuby::High.vcd_name(sig.fullname)}"
                 vcdout << "$var wire #{sig.type.width} "
-                vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                # vcdout << "#{HDLRuby::High.vcd_name(sig.fullname)} "
+                vcdout << "#{HDLRuby::High.vcd_idstr(sig)} "
                 vcdout << "#{HDLRuby::High.vcd_name(sig.name)} $end\n"
             end
             # Recurse on the statements
@@ -248,6 +357,19 @@ module HDLRuby::High
             end
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Adds the inner signals.
+            self.each_inner do |sig|
+                vars_with_idstr[sig] = HDLRuby::High.vcd_idstr(sig)
+            end
+            # Recurse on the statements.
+            self.each_statement do |stmnt|
+                stmnt.get_vars_with_idstr(vars_with_idstr)
+            end
+            return vars_with_idstr
+        end
     end
 
 
@@ -292,6 +414,19 @@ module HDLRuby::High
             self.no.get_vars_with_fullname(vars_with_fullname) if self.no
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Recurse on the yes.
+            self.yes.get_vars_with_idstr(vars_with_idstr)
+            # Recurse on the noifs.
+            self.each_noif do |cond,stmnt|
+                stmnt.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recure on the no if any.
+            self.no.get_vars_with_idstr(vars_with_idstr) if self.no
+            return vars_with_idstr
+        end
     end
 
 
@@ -318,5 +453,41 @@ module HDLRuby::High
             self.default.get_vars_with_fullname(vars_with_fullname)
             return vars_with_fullname
         end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Recurse on each when.
+            self.each_when do |w|
+                w.statement.get_vars_with_idstr(vars_with_idstr)
+            end
+            # Recurse on the default if any.
+            self.default.get_vars_with_idstr(vars_with_idstr)
+            return vars_with_idstr
+        end
     end
+
+    ##
+    # Enhance the TimeRepeat class with VCD support.
+    class TimeRepeat
+        ## Shows the hierarchy of the variables.
+        def show_hierarchy(vcdout)
+            # Recurse on the statement.
+            self.statement.show_hierarchy(vcdout)
+        end
+
+        ## Gets the VCD variables with their long name.
+        def get_vars_with_fullname(vars_with_fullname = {})
+            # Recurse on the statement.
+            self.statement.get_vars_with_fullname(vars_with_fullname)
+            return vars_with_fullname
+        end
+
+        ## Gets the VCD variables with their id string.
+        def get_vars_with_idstr(vars_with_idstr = {})
+            # Recurse on the statement.
+            self.statement.get_vars_with_idstr(vars_with_idstr)
+            return vars_with_idstr
+        end
+    end
+
 end