HDLRuby 2.4.26 → 2.5.1

data/lib/HDLRuby/hruby_low2c.rb

@@ -178,6 +178,7 @@ module HDLRuby::Low
                 end
             end
             self.scope.each_block_deep do |block|
+            # puts "treating for block=#{Low2C.obj_name(block)} with=#{block.each_inner.count} inners"
                 block.each_inner do |signal|
                     # res << signal.value.to_c_make(level) if signal.value
                     signal.value.each_node_deep do |node|
@@ -837,6 +838,7 @@ module HDLRuby::Low
         ## Generates the content of the h file.
         def to_ch
             res = ""
+            # puts "to_ch for SignalI: #{self.to_c_signal()}"
             # Declare the global variable holding the signal.
             res << "extern SignalI #{self.to_c_signal()};\n\n"
 
@@ -1050,6 +1052,12 @@ module HDLRuby::Low
             raise AnyError, "Internal error: to_c should be implemented in class :#{self.class}"
         end
 
+        ## Generates the content of the h file.
+        def to_ch
+            # By default nothing to generate.
+            return ""
+        end
+
         # Adds the c code of the blocks to +res+ at +level+
         def add_blocks_code(res,level)
             if self.respond_to?(:each_node) then
@@ -1060,6 +1068,17 @@ module HDLRuby::Low
                 end
             end
         end
+        
+        # Adds the creation of the blocks to +res+ at +level+.
+        def add_make_block(res,level)
+            if self.respond_to?(:each_node) then
+                self.each_node do |node|
+                    if node.respond_to?(:add_blocks_code) then
+                        node.add_make_block(res,level)
+                    end
+                end
+            end
+        end
     end
 
     ## Extends the Transmit class with generation of HDLRuby::High text.
@@ -1143,6 +1162,18 @@ module HDLRuby::Low
             # Return the result.
             return res
         end
+
+        ## Generates the content of the h file.
+        def to_ch
+            res = ""
+            # Recurse on the sub statements.
+            res << self.yes.to_ch
+            self.each_noif do |cond,stmnt|
+                res << stmnt.to_ch
+            end
+            res << self.no.to_ch if self.no
+            return res
+        end
     end
 
     ## Extends the When class with generation of HDLRuby::High text.
@@ -1164,10 +1195,20 @@ module HDLRuby::Low
             return res
         end
 
+        ## Generates the content of the h file.
+        def to_ch
+            return self.statement.to_ch
+        end
+
         # Adds the c code of the blocks to +res+ at +level+
         def add_blocks_code(res,level)
             self.statement.add_blocks_code(res,level)
         end
+
+        # Adds the creation of the blocks to +res+ at +level+.
+        def add_make_block(res,level)
+            self.statement.add_make_block(res,level)
+        end
     end
 
     ## Extends the Case class with generation of HDLRuby::High text.
@@ -1215,6 +1256,16 @@ module HDLRuby::Low
             # Return the resulting string.
             return res
         end
+
+        ## Generates the content of the h file.
+        def to_ch
+            res = ""
+            # Recurse on the whens.
+            self.each_when {|w| res << w.to_ch }
+            # Recurse on the default statement.
+            res << self.default.to_ch if self.default
+            return res
+        end
     end
 
 
@@ -1272,6 +1323,12 @@ module HDLRuby::Low
             res << self.to_c_code(level)
         end
 
+        # Adds the creation of the blocks to +res+ at +level+.
+        def add_make_block(res,level)
+            res << " " * level*3
+            res << "#{Low2C.make_name(self)}();\n"
+        end
+
         # Generates the C text of the equivalent HDLRuby::High code.
         # +level+ is the hierachical level of the object.
         def to_c_code(level = 0)
@@ -1351,6 +1408,11 @@ module HDLRuby::Low
             res << " " * (level+1)*3
             res << "block->function = &#{Low2C.code_name(self)};\n"
 
+            # Generate creation of the sub blocks.
+            self.each_statement do |stmnt|
+                stmnt.add_make_block(res,level+1)
+            end
+
             # Generate the Returns of the result.
             res << "\n"
             res << " " * (level+1)*3
@@ -1373,6 +1435,7 @@ module HDLRuby::Low
 
         ## Generates the content of the h file.
         def to_ch
+            # puts "to_ch for block=#{Low2C.obj_name(self)} with=#{self.each_inner.count} inners"
             res = ""
             # Declare the global variable holding the block.
             res << "extern Block #{Low2C.obj_name(self)};\n\n"
@@ -1383,6 +1446,10 @@ module HDLRuby::Low
             # Generate the accesses to the ports.
             self.each_inner  { |inner|  res << inner.to_ch }
 
+            # Recurse on the statements.
+            self.each_statement { |stmnt| res << stmnt.to_ch }
+
+
             return res
         end
     end

data/lib/HDLRuby/hruby_low_without_parinseq.rb

@@ -0,0 +1,151 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+
+
+module HDLRuby::Low
+
+
+##
+# Converts par blocks within seq blocks to seq blocks.
+# For matching the executing model of Verilog.
+#
+########################################################################
+    
+
+    ## Extends the SystemT class with functionality for converting par blocks
+    #  within seq blocks to seq blocks.
+    class SystemT
+
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            self.scope.par_in_seq2seq!
+        end
+    end
+
+    ## Extends the Scope class with functionality for breaking assingments
+    #  to concats.
+    class Scope
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            # Recruse on the sub scopes.
+            self.each_scope(&:par_in_seq2seq!)
+            # Recurse on the block.
+            self.each_behavior do |behavior|
+                behavior.block.par_in_seq2seq!
+            end
+        end
+    end
+
+
+    ## Extends the Statement class with functionality for breaking assingments
+    #  to concats.
+    class Statement
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            # By default nothing to do.
+            return self
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            # By default nothing to do.
+            return self
+        end
+    end
+
+
+    ## Extends the If class with functionality for breaking assingments
+    #  to concats.
+    class If
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            self.yes.par_in_seq2seq!
+            self.each_noif do |cond,blk|
+                blk.par_in_seq2seq!
+            end
+            self.no.par_in_seq2seq! if self.no
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            self.to_seq!
+            self.each_noif do |cond,blk|
+                blk.to_seq!
+            end
+            self.no.to_seq! if self.no
+        end
+    end
+
+
+    ## Extends the Case class with functionality for breaking assingments
+    #  to concats.
+    class Case
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            self.each_when do |w|
+                w.statement.par_in_seq2seq!
+            end
+            self.default.par_in_seq2seq! if self.default
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            self.each_when do |w|
+                w.statement.to_seq!
+            end
+            self.default.to_seq! if self.default
+        end
+    end
+
+
+    ## Extends the Block class with functionality for breaking assingments
+    #  to concats.
+    class Block
+        # Converts par blocks within seq blocks to seq blocks.
+        def par_in_seq2seq!
+            # Recurse on the sub blocks.
+            self.each_statement(&:par_in_seq2seq!)
+            # Is the current block a seq block?
+            if self.mode == :seq then
+                # Yes, convert its inner par blocks to seq blocks.
+                self.each_statement do |statement|
+                    if (statement.is_a?(Block)) then
+                        statement.to_seq! if statement.mode == :par
+                    end
+                end
+            end
+            return self
+        end
+
+        # Convert the block to seq.
+        def to_seq!
+            if self.mode == :par then
+                # Need to convert.
+                # First recurse on the sub blocks.
+                self.each_statement(&:to_seq!)
+                # Now replace each left value by a new signal for
+                # differed assingment in seq.
+                differeds = []
+                self.each_statement do |statement|
+                    left = statement.left
+                    if statement.is_a?(Transmit) then
+                        sig = SignalI.new(HDLRuby.uniq_name,left.type)
+                        self.add_inner(sig)
+                        diff = RefName.new(left.type,RefThis.new,sig.name)
+                        differeds << [left,diff]
+                        statement.set_left!(diff)
+                    end
+                end
+                # Adds the differed assignments.
+                differeds.each do |left,diff|
+                    self.add_statement(Transmit.new(left.clone,diff.clone))
+                end
+                # Change the mode.
+                self.set_mode!(:seq)
+            end
+            return self
+        end
+    end
+
+end

data/lib/HDLRuby/hruby_unit.rb

@@ -0,0 +1,43 @@
+require "HDLRuby/hruby_high"
+
+
+
+##
+# Library for building unit test systems.
+#
+########################################################################
+module HDLRuby::Unit
+
+    ## The HDLRuby unit test error class.
+    class UnitError < ::StandardError
+    end
+
+    # The set of the unit systems by name.
+    @@unit_systems = {}
+
+    # Declares system +name+ for unit testing.
+    # The system is built by executing +ruby_block+.
+    #
+    # NOTE: the name of the system is not registered within the HDLRuby
+    #       namespace since it is not meant to be used directly.
+    def self.system(name,&ruby_block)
+        # Ensure name is a symbol.
+        name = name.to_s.to_sym
+        # Check if the name is already used or not.
+        if @@unit_systems.key?(name) then
+            raise UnitError, "Unit test system #{name} already declared."
+        end
+        @@unit_systems[name] = HDLRuby::High.system(&ruby_block)
+    end
+
+
+    # Create a system named +test_name+ executing all the unit tests.
+    def self.test(test_name = "test")
+        # Declare the system.
+        HDLRuby::High.system test_name do
+            @@unit_systems.each do |name,sys|
+                sys.instantiate(name)
+            end
+        end
+    end
+end

data/lib/HDLRuby/hruby_verilog.rb

@@ -14,6 +14,9 @@ module HDLRuby::Low
     # The list of base types used both in verilog and HDLRuby
     VERILOG_BASE_TYPES = ["signed"]
 
+    # The list of signals that are actually verilog regs.
+    VERILOG_REGS = []
+
 
 # Sample of very handy for programming.
 # puts "class=#{self.yes.class}"       # Confirm class of self.yes.
@@ -25,7 +28,7 @@ module HDLRuby::Low
 # end
 
 # Global variable used for indentation and structure (temporary).
-$space_count = 0   # Count used for increasing indent by if statement. (temporary)
+# $space_count = 0   # Count used for increasing indent by if statement. (temporary)
 $vector_reg = ""   # For storing signal type at structure declaration. (temporary)
 $vector_cnt = 0    # For allocating numbers at structure declaration.  (temporary)
 
@@ -101,9 +104,11 @@ end
 # Enhance Transmit with generation of verilog code.
 class Transmit
     # Converts the system to Verilog code.
-    def to_verilog(mode = nil)
+    # def to_verilog(mode = nil)
+    def to_verilog(spc = 3)
         # Determine blocking assignment or nonblocking substitution from mode and return it.
-        code = "#{self.left.to_verilog} #{mode == "seq" ? "=" : "<="} #{self.right.to_verilog};\n"
+        # code = "#{self.left.to_verilog} #{mode == "seq" ? "=" : "<="} #{self.right.to_verilog};\n"
+        code = "#{" " * spc}#{self.left.to_verilog} #{self.block.mode == :seq ? "=" : "<="} #{self.right.to_verilog};"
         return code
     end
 end
@@ -111,12 +116,73 @@ end
 # To scheduling to the Block.
 # Enhance Block with generation of verilog code.
 class Block
-    # Converts the system to Verilog code.
-    def to_verilog(mode = nil)
-        # No translation is done in this class.
-        puts "Block to_verilog not found" # For debugging
+    # # Converts the system to Verilog code.
+    # def to_verilog(mode = nil)
+    #     # No translation is done in this class.
+    #     puts "Block to_verilog not found" # For debugging
+    # end
+
+    # Converts the system to Verilog code adding 'spc' spaces at the begining
+    # of each line.
+    def to_verilog(spc = 3)
+            code = "begin"
+            # code << " : #{name_to_verilog(self.name)}" if self.name && !self.name.empty?
+            if self.name && !self.name.empty? then
+                vname = name_to_verilog(self.name)
+                code << " : #{vname}"
+                self.properties[:verilog_name] = vname
+            end
+            code << "\n" if block.each_inner.any?
+            # Declaration of "inner" part within "always".
+            block.each_inner do |inner|
+                # if regs.include?(inner.name) then
+                if HDLRuby::Low::VERILOG_REGS.include?(inner.to_verilog) then
+                    # code << "      reg"
+                    code << "#{" " * (spc+3)}reg"
+                else
+                    code << "#{" " * (spc+3)}wire"
+                end
+
+                # Variable has "base", but if there is width etc, it is not in "base".
+                # It is determined by an if.
+                if inner.type.base? 
+                    if inner.type.base.base? 
+                        # code << "#{inner.type.base.to_verilog} #{inner.to_verilog} #{inner.type.to_verilog};\n"
+                        code << "#{inner.type.base.to_verilog} #{inner.to_verilog} #{inner.type.to_verilog}"
+                    else
+                        # code << "#{inner.type.to_verilog} #{inner.to_verilog};\n"
+                        code << "#{inner.type.to_verilog} #{inner.to_verilog}"
+                    end
+                else
+                    # code << " #{inner.type.to_verilog}#{inner.to_verilog};\n"
+                    code << " #{inner.type.to_verilog}#{inner.to_verilog}"
+                end
+                if inner.value then
+                    # There is an initial value.
+                    code << " = #{inner.value.to_verilog}"
+                end
+                code << ";\n"
+            end
+
+            # Translate the block that finished scheduling.
+            block.each_statement do |statement|
+                #code  << "\n      #{statement.to_verilog(behavior.block.mode.to_s)}"
+                # code  << "\n#{" "*spc}#{statement.to_verilog(behavior.block.mode.to_s)}"
+                if statement.is_a?(Block) then
+                    code << "\n#{" " * (spc+3)}#{statement.to_verilog(spc+3)}"
+                else
+                    code  << "\n#{statement.to_verilog(spc+3)}"
+                end
+            end
+            # Close the block."
+            code << "\n#{" "*spc}end"
+            return code
     end
 
+
+
+
+
     # Extract and convert to verilog the TimeRepeat statements.
     # NOTE: work only on the current level of the block (should be called
     # through each_block_deep).
@@ -136,7 +202,7 @@ class Block
             # Declaration of "inner" part within "always".
             block.each_inner do |inner|
                 # if regs.include?(inner.name) then
-                if regs.include?(inner.to_verilog) then
+                if HDLRuby::Low::VERILOG_REGS.include?(inner.to_verilog) then
                     code << "      reg"
                 else
                     code << "      wire"
@@ -1323,8 +1389,10 @@ end
 class RefName
     # Converts the system to Verilog code using +renamer+ for producing Verilog-compatible names.
     def to_verilog
-        # return "#{self.name.to_s}"
-        return "#{name_to_verilog(self.name)}"
+        # return "#{name_to_verilog(self.name)}"
+        vname = name_to_verilog(self.name)
+        self.properties[:verilog_name] = vname
+        return "#{vname}"
     end
 
     # Used for instantiation (emergency procedure).
@@ -1431,66 +1499,82 @@ class Value
     end
 end
 
+
 # Used to transrate if.
 # Enhance If with generation of verilog code.
 class If
-    # Converts the system to Verilog code.
-    def to_verilog(mode = nil)
+    # # Converts the system to Verilog code.
+    # def to_verilog(mode = nil)
+    # Converts to Verilog code, checking adding 'spc' spaces at the begining
+    # of each line.
+    def to_verilog(spc = 3)
 
         $blocking = false
 
-        if ($space_count == 0) then
-            result = "   " * ($space_count)  # Indented based on space_count.
-        else
-            result = ""
-        end
-        $space_count += 1                  # Add count to be used for indentation.
+        # if ($space_count == 0) then
+        #     result = "   " * ($space_count)  # Indented based on space_count.
+        # else
+        #     result = ""
+        # end
+        # $space_count += 1                  # Add count to be used for indentation.
+        result = " " * spc  # Indented based on space_count.
 
-        result << "if (#{self.condition.to_verilog}) begin\n"
+        # result << "if (#{self.condition.to_verilog}) begin\n"
+        result << "if (#{self.condition.to_verilog}) "
 
 
         # Check if there is yes (if) and output yes or less.
         if self.respond_to? (:yes)
-            self.yes.each_statement do |statement|
-                result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
-            end
-            result << "#{"   " * $space_count}   end\n"
+            # self.yes.each_statement do |statement|
+            #     result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
+            # end
+            # result << "#{"   " * $space_count}   end\n"
+            result << self.yes.to_verilog(spc)
         end
 
         # If noif (else if) exists, it outputs it.
         # Since noif is directly under, respond_to is unnecessary.
         self.each_noif do |condition, block|
-            result << "#{"   " * $space_count}   else if (#{condition.to_verilog}) begin\n"
-            block.each_statement do |statement|
-                result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
-            end
-            result << "#{"   "* $space_count}   end\n"
+            # result << "#{"   " * $space_count}   else if (#{condition.to_verilog}) begin\n"
+            result << "\n#{" "*spc}else if (#{condition.to_verilog}) "
+            # block.each_statement do |statement|
+            #     result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
+            # end
+            # result << "#{"   "* $space_count}   end\n"
+            result << block.to_verilog(spc)
         end
 
         # Check if there is no (else) and output no or less.
-        if self.no.respond_to? (:mode)
-            result << "#{"   " * $space_count}   else begin\n"
-            self.no.each_statement do |statement|
-                result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
-            end
-            result << "#{"   " * $space_count}   end\n"
+        if self.no.respond_to?(:mode)
+            # result << "#{"   " * $space_count}   else begin\n"
+            result << "\n#{" " * spc}else "
+            # self.no.each_statement do |statement|
+            #     result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
+            # end
+            # result << "#{"   " * $space_count}   end\n"
+            result << self.no.to_verilog(spc)
         end
 
-        $space_count -= 1 # Since the output ends, reduce the count.
+        # $space_count -= 1 # Since the output ends, reduce the count.
         return result
     end
 end
 
 # Used to translate case
 class Case
-    def to_verilog(mode = nil)
+    # def to_verilog(mode = nil)
+    #
+    # Converts to Verilog code, checking if variables are register
+    # or wire adding 'spc' spaces at the begining of each line.
+    def to_verilog(spc = 3)
 
-        if ($space_count == 0) then
-            result = "   " * ($space_count) # Indented based on space_count.
-        else
-            result = ""
-        end
-        $space_count += 1                 # Add count to be used for indentation.
+        # if ($space_count == 0) then
+        #     result = "   " * ($space_count) # Indented based on space_count.
+        # else
+        #     result = ""
+        # end
+        # $space_count += 1                 # Add count to be used for indentation.
+        result = " " * spc # Indented based on space_count.
 
         result = ""
         result << "case(#{self.value.to_verilog})\n"
@@ -1498,40 +1582,55 @@ class Case
         # n the case statement, each branch is partitioned by when. Process each time when.
         self.each_when do |whens| 
             # Reads and stores the numbers and expressions stored in when.
-            result << "      " + "   " *$space_count + "#{whens.match.to_verilog}: "
-            if whens.statement.each_statement.count > 1 then
-                result << "begin\n"
-                whens.statement.each_statement do |statement|
-                    result << "                  "+ "   " *$space_count +"#{statement.to_verilog}"
-                end
-                result << "             " + "   " *$space_count + "end\n"
-            elsif whens.statement.each_statement.count == 1 then
-                whens.statement.each_statement do |statement|
-                    result << "#{statement.to_verilog}"
-                end
+            # result << "      " + "   " *$space_count + "#{whens.match.to_verilog}: "
+            result << " " * (spc+3) + "#{whens.match.to_verilog}: "
+            
+            # if whens.statement.each_statement.count > 1 then
+            #     result << "begin\n"
+            #     whens.statement.each_statement do |statement|
+            #         result << "                  "+ "   " *$space_count +"#{statement.to_verilog}"
+            #     end
+            #     result << "             " + "   " *$space_count + "end\n"
+            # elsif whens.statement.each_statement.count == 1 then
+            #     whens.statement.each_statement do |statement|
+            #         result << "#{statement.to_verilog}"
+            #     end
+            # else
+            #     # Empty statement case.
+            #     result << "\n"
+            # end
+            if whens.statement.each_statement.count >= 1 then
+                result << whens.statement.to_verilog(spc+3)
             else
-                # Empty statement case.
                 result << "\n"
             end
         end
-        # The default part is stored in default instead of when. Reads and processes in the same way as when.
+        # # The default part is stored in default instead of when. Reads and processes in the same way as when.
+        # if self.default then
+        #     if self.default.each_statement.count > 1 then
+        #         result << "      " + "   " *$space_count + "default: begin\n"
+        #         self.default.each_statement do |statement|
+        #             result << "                  " + "   " *$space_count + "#{statement.to_verilog}"
+        #         end
+        #         result << "                  end\n"
+        #     elsif self.default.each_statement.count == 1 then
+        #         result << "      " + "   " *$space_count + "default: "
+        #         self.default.each_statement do |statement|
+        #             result << "#{statement.to_verilog}"
+        #         end
+        #     end  
+        # end
         if self.default then
-            if self.default.each_statement.count > 1 then
-                result << "      " + "   " *$space_count + "default: begin\n"
-                self.default.each_statement do |statement|
-                    result << "                  " + "   " *$space_count + "#{statement.to_verilog}"
-                end
-                result << "                  end\n"
-            elsif self.default.each_statement.count == 1 then
-                result << "      " + "   " *$space_count + "default: "
-                self.default.each_statement do |statement|
-                    result << "#{statement.to_verilog}"
-                end
-            end  
+            if self.default.each_statement.count >= 1 then
+                result << self.default.each_statement.to_verilog(spc+3)
+            else
+                result << "\n"
+            end
         end
-        result << "   " + "   " *$space_count + "endcase\n" # Conclusion.
+        # result << "   " + "   " *$space_count + "endcase\n" # Conclusion.
+        result << " " * spc + "endcase\n" # Conclusion.
 
-        $space_count -= 1           # Since the output ends, reduce the count.
+        # $space_count -= 1           # Since the output ends, reduce the count.
         return result               # Return case after translation.
     end
 end
@@ -1658,7 +1757,10 @@ class SignalI
     # Converts the system to Verilog code.
     def to_verilog
         # Convert unusable characters and return them.
-        return "#{name_to_verilog(self.name)}"
+        # return "#{name_to_verilog(self.name)}"
+        vname = name_to_verilog(self.name)
+        self.properties[:verilog_name] = vname
+        return "#{vname}"
     end
 end
 
@@ -1697,8 +1799,9 @@ end
 # Look at the unit of time, convert the time to ps and output it.
 # One of two people, TimeWait and Delay.
 class TimeWait
-    def to_verilog(mode=nil)
-        return self.delay.to_verilog + "\n"
+    # def to_verilog(mode=nil)
+    def to_verilog(spc = 3)
+        return (" " * spc) + self.delay.to_verilog + "\n"
     end
 end
 class Delay
@@ -1776,9 +1879,9 @@ class SystemT
 
     # Converts the system to Verilog code.
     def to_verilog
-        # Preprocessing
         # Detect the registers
-        regs = []
+        # regs = []
+        HDLRuby::Low::VERILOG_REGS.clear
         # The left values.
         self.each_behavior do |behavior|
             # behavior.block.each_statement do |statement|
@@ -1786,7 +1889,9 @@ class SystemT
             # end
             behavior.each_block_deep do |block|
                 block.each_statement do |statement|
-                    regs << statement.left.to_verilog if statement.is_a?(Transmit)
+                    if statement.is_a?(Transmit)
+                        HDLRuby::Low::VERILOG_REGS << statement.left.to_verilog
+                    end
                 end
             end
         end
@@ -1803,19 +1908,27 @@ class SystemT
         # # puts "Now regs has clk?: #{regs.include?("clk")}"
         # And the initialized signals.
         self.each_output do |output|
-            regs << output.to_verilog if output.value
+            # regs << output.to_verilog if output.value
+            HDLRuby::Low::VERILOG_REGS << output.to_verilog if output.value
         end
         self.each_inner do |inner|
-            regs << inner.to_verilog if inner.value
+            # regs << inner.to_verilog if inner.value
+            HDLRuby::Low::VERILOG_REGS << inner.to_verilog if inner.value
         end
         # And the array types signals.
         self.each_signal do |sig|
-            # regs << sig.to_verilog if sig.type.is_a?(TypeVector) && sig.type.base.is_a?(TypeVector)
-            regs << sig.to_verilog if sig.type.vector? && sig.type.base.vector?
+            # # regs << sig.to_verilog if sig.type.is_a?(TypeVector) && sig.type.base.is_a?(TypeVector)
+            # regs << sig.to_verilog if sig.type.vector? && sig.type.base.vector?
+            if sig.type.vector? && sig.type.base.vector? then
+                HDLRuby::Low::VERILOG_REGS << sig.to_verilog
+            end
         end
         self.each_inner do |sig|
-            # regs << sig.to_verilog if sig.type.is_a?(TypeVector) && sig.type.base.is_a?(TypeVector)
-            regs << sig.to_verilog if sig.type.vector? && sig.type.base.vector?
+            # # regs << sig.to_verilog if sig.type.is_a?(TypeVector) && sig.type.base.is_a?(TypeVector)
+            # regs << sig.to_verilog if sig.type.vector? && sig.type.base.vector?
+            if sig.type.vector? && sig.type.base.vector? then
+                HDLRuby::Low::VERILOG_REGS << sig.to_verilog
+            end
         end
 
         # Code generation
@@ -1829,8 +1942,14 @@ class SystemT
 
         # Spelling necessary for simulation.
         code = "`timescale 1ps/1ps\n\n"
+
+        # # Output the module name.
+        # code << "module #{name_to_verilog(self.name)}("
+
+        vname = name_to_verilog(self.name)
+        self.properties[:verilog_name] = vname
         # Output the module name.
-        code << "module #{name_to_verilog(self.name)}("
+        code << "module #{vname}("
 
         # Output the last two to the input. 
         inputs[0..-2].each do |input|
@@ -1884,7 +2003,8 @@ class SystemT
                 $vector_reg = "#{output.to_verilog}"
                 $vector_cnt = 0
                 output.type.each_type do |type|
-                    if regs.include?(type.name) then
+                    # if regs.include?(type.name) then
+                    if HDLRuby::Low::VERILOG_REGS.include?(type.name) then
                         code << "   output reg"
                     else
                         code << "   output"
@@ -1900,7 +2020,8 @@ class SystemT
                 end        
             else
                 # if regs.include?(output.name) then
-                if regs.include?(output.to_verilog) then
+                # if regs.include?(output.to_verilog) then
+                if HDLRuby::Low::VERILOG_REGS.include?(output.to_verilog) then
                     code << "   output reg"
                 else
                     code << "   output"
@@ -1931,8 +2052,9 @@ class SystemT
 
         # Declare "inner".
         self.each_inner do |inner|
-            # if regs.include?(inner.name) then
-            if regs.include?(inner.to_verilog) then
+            # # if regs.include?(inner.name) then
+            # if regs.include?(inner.to_verilog) then
+            if HDLRuby::Low::VERILOG_REGS.include?(inner.to_verilog) then
                 code << "   reg"
             else
                 code << "   wire"
@@ -1960,8 +2082,9 @@ class SystemT
         # If there is scope in scope, translate it.
         self.each_scope do |scope|
             scope.each_inner do |inner|
-                # if regs.include?(inner.name) then
-                if regs.include?(inner.to_verilog) then
+                # # if regs.include?(inner.name) then
+                # if regs.include?(inner.to_verilog) then
+                if HDLRuby::Low::VERILOG_REGS.include?(inner.to_verilog) then
                     code << "   reg "
                 else
                     code << "   wire "
@@ -2003,7 +2126,10 @@ class SystemT
             code << " " * 3
             systemT = systemI.systemT
             code << name_to_verilog(systemT.name) << " "
-            code << name_to_verilog(systemI.name) << "("
+            # code << name_to_verilog(systemI.name) << "("
+            vname = name_to_verilog(systemI.name)
+            systemI.properties[:verilog_name] = vname
+            code << vname << "("
             # Its ports connections
             # Inputs
             systemT.each_input do |input|
@@ -2052,7 +2178,8 @@ class SystemT
                     code << blk.repeat_to_verilog!
                 end
                 # And generate an initial block.
-                code << "   initial begin\n"
+                # code << "   initial begin\n"
+                code << "   initial "
             else
                 # Generate a standard process.
                 code << "   always @( "
@@ -2077,54 +2204,57 @@ class SystemT
                         code << "#{event.last.type.to_s} #{event.last.ref.to_verilog}"
                     end
                 end
-                code << " ) begin\n"
+                # code << " ) begin\n"
+                code << " ) "
             end
 
-            # Perform "scheduling" using the method "flatten".
-            block = behavior.block.flatten(behavior.block.mode.to_s)
-
-            # Declaration of "inner" part within "always".
-            block.each_inner do |inner|
-                # if regs.include?(inner.name) then
-                if regs.include?(inner.to_verilog) then
-                    code << "      reg"
-                else
-                    code << "      wire"
-                end
-
-                # Variable has "base", but if there is width etc, it is not in "base".
-                # It is determined by an if.
-                if inner.type.base? 
-                    if inner.type.base.base? 
-                        # code << "#{inner.type.base.to_verilog} #{inner.to_verilog} #{inner.type.to_verilog};\n"
-                        code << "#{inner.type.base.to_verilog} #{inner.to_verilog} #{inner.type.to_verilog}"
-                    else
-                        # code << "#{inner.type.to_verilog} #{inner.to_verilog};\n"
-                        code << "#{inner.type.to_verilog} #{inner.to_verilog}"
-                    end
-                else
-                    # code << " #{inner.type.to_verilog}#{inner.to_verilog};\n"
-                    code << " #{inner.type.to_verilog}#{inner.to_verilog}"
-                end
-                if inner.value then
-                    # There is an initial value.
-                    code << " = #{inner.value.to_verilog}"
-                end
-                code << ";\n"
-            end
+            # # Perform "scheduling" using the method "flatten".
+            # block = behavior.block.flatten(behavior.block.mode.to_s)
+            # code << block.to_verilog(regs)
+            code << behavior.block.to_verilog
+
+            # # Declaration of "inner" part within "always".
+            # block.each_inner do |inner|
+            #     # if regs.include?(inner.name) then
+            #     if regs.include?(inner.to_verilog) then
+            #         code << "      reg"
+            #     else
+            #         code << "      wire"
+            #     end
+
+            #     # Variable has "base", but if there is width etc, it is not in "base".
+            #     # It is determined by an if.
+            #     if inner.type.base? 
+            #         if inner.type.base.base? 
+            #             # code << "#{inner.type.base.to_verilog} #{inner.to_verilog} #{inner.type.to_verilog};\n"
+            #             code << "#{inner.type.base.to_verilog} #{inner.to_verilog} #{inner.type.to_verilog}"
+            #         else
+            #             # code << "#{inner.type.to_verilog} #{inner.to_verilog};\n"
+            #             code << "#{inner.type.to_verilog} #{inner.to_verilog}"
+            #         end
+            #     else
+            #         # code << " #{inner.type.to_verilog}#{inner.to_verilog};\n"
+            #         code << " #{inner.type.to_verilog}#{inner.to_verilog}"
+            #     end
+            #     if inner.value then
+            #         # There is an initial value.
+            #         code << " = #{inner.value.to_verilog}"
+            #     end
+            #     code << ";\n"
+            # end
 
-            # Translate the block that finished scheduling.
-            block.each_statement do |statement|
-                code  << "\n      #{statement.to_verilog(behavior.block.mode.to_s)}"
-            end
+            # # Translate the block that finished scheduling.
+            # block.each_statement do |statement|
+            #     code  << "\n      #{statement.to_verilog(behavior.block.mode.to_s)}"
+            # end
 
-            $fm.fm_par.clear()
+            # $fm.fm_par.clear()
 
-            code << "\n   end\n\n"
+            # code << "\n   end\n\n"
         end
 
         # Conclusion.
-        code << "endmodule"
+        code << "\nendmodule"
         return code
     end
 end