HDLRuby 2.4.28 → 2.6.3

data/lib/HDLRuby/hruby_low2c.rb

@@ -32,6 +32,13 @@ module HDLRuby::Low
             return [1.to_i].pack("i").size*8
         end
 
+        ## Converts string +str+ to a C-compatible string.
+        def self.c_string(str)
+            str = str.gsub(/\n/,"\\n")
+            str.gsub!(/\t/,"\\t")
+            return str
+        end
+
         ## Tells if a +name+ is C-compatible.
         #  To ensure compatibile, assume all the character must have the
         #  same case.
@@ -139,10 +146,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the SystemT class with generation of HDLRuby::High C text.
+    ## Extends the SystemT class with generation of C text.
     class SystemT
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and +hnames+
         # is the list of extra h files to include.
         def to_c(level = 0, *hnames)
@@ -178,6 +185,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|
@@ -344,10 +352,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Scope class with generation of HDLRuby::High C text.
+    ## Extends the Scope class with generation of C text.
     class Scope
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The resulting string.
@@ -497,10 +505,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Type class with generation of HDLRuby::High text.
+    ## Extends the Type class with generation of C text.
     class Type
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # return Low2C.c_name(self.name)
@@ -515,10 +523,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the TypeDef class with generation of HDLRuby::High text.
+    ## Extends the TypeDef class with generation of C text.
     class TypeDef
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # # Simply use the name of the type.
@@ -528,10 +536,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the TypeVector class with generation of HDLRuby::High text.
+    ## Extends the TypeVector class with generation of C text.
     class TypeVector
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The resulting string.
@@ -540,10 +548,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the TypeTuple class with generation of HDLRuby::High text.
+    ## Extends the TypeTuple class with generation of C text.
     class TypeTuple
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         #
         # NOTE: type tuples are converted to bit vector of their contents.
@@ -556,10 +564,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the TypeStruct class with generation of HDLRuby::High text.
+    ## Extends the TypeStruct class with generation of C text.
     class TypeStruct
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             return "get_type_struct(#{self.each.join(",") do |key,type|
@@ -569,10 +577,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Behavior class with generation of HDLRuby::High text.
+    ## Extends the Behavior class with generation of C text.
     class Behavior
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and
         # +time+ is a flag telling if the behavior is timed or not.
         def to_c(level = 0, time = false)
@@ -705,10 +713,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the TimeBehavior class with generation of HDLRuby::High text.
+    ## Extends the TimeBehavior class with generation of C text.
     class TimeBehavior
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             super(level,true)
@@ -716,10 +724,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Event class with generation of HDLRuby::High text.
+    ## Extends the Event class with generation of C text.
     class Event
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             edge = "ANYEDGE"
@@ -731,7 +739,7 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the SignalI class with generation of HDLRuby::High text.
+    ## Extends the SignalI class with generation of C text.
     class SignalI
 
         ## Generates the C text for an access to the signal.
@@ -747,7 +755,7 @@ module HDLRuby::Low
             return res
         end
 
-        ## Generates the C text of the equivalent HDLRuby::High code.
+        ## Generates the C text of the equivalent HDLRuby code.
         #  +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The resulting string.
@@ -837,6 +845,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"
 
@@ -848,10 +857,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the SystemI class with generation of HDLRuby::High text.
+    ## Extends the SystemI class with generation of C text.
     class SystemI
 
-        ## Generates the C text of the equivalent HDLRuby::High code.
+        ## Generates the C text of the equivalent HDLRuby code.
         #  +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The resulting string.
@@ -917,7 +926,7 @@ module HDLRuby::Low
     # Extend the Chunk cass with generation of text code.
     class HDLRuby::Low::Chunk
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             res = " " * level
@@ -933,9 +942,9 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the SystemI class with generation of HDLRuby::High text.
+    ## Extends the SystemI class with generation of C text.
     class Code
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # puts "For behavior: #{self}"
@@ -1040,16 +1049,22 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Statement class with generation of HDLRuby::High text.
+    ## Extends the Statement class with generation of C text.
     class Statement
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # Should never be here.
             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,12 +1075,23 @@ 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.
+    ## Extends the Transmit class with generation of C text.
     class Transmit
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # Save the state of the value pool.
@@ -1097,11 +1123,48 @@ module HDLRuby::Low
         end
     end
 
+
+    ## Extends the Print class with generation of C text.
+    class Print
+
+        # Generates the C text of the equivalent HDLRuby code.
+        # +level+ is the hierachical level of the object.
+        def to_c(level = 0)
+            # Save the state of the value pool.
+            res = (" " * ((level)*3))
+            res << "{\n"
+            res << (" " * ((level+1)*3))
+            res << "unsigned int pool_state = get_value_pos();\n"
+            # Perform the copy and the touching only if the new content
+            # is different.
+            res << (" " * ((level+1)*3))
+            # Is it a sequential execution model?
+            seq = self.block.mode == :seq ? "_seq" : ""
+            # Generate the print.
+            self.each_arg do |arg|
+                if (arg.is_a?(StringE)) then
+                    res << "printer.print_string(\"" + 
+                        Low2C.c_string(arg.content) + "\");\n"
+                elsif (arg.is_a?(Expression)) then
+                    res << "printer.print_string_value(" + arg.to_c + ");\n"
+                else
+                    res << "printer.print_string_name(" + arg.to_c + ");\n"
+                end
+            end
+            # Restore the value pool state.
+            res << (" " * ((level+1)*3))
+            res << "set_value_pos(pool_state);\n"
+            res << (" " * ((level)*3))
+            res << "}\n"
+            return res
+        end
+    end
+
     
-    ## Extends the If class with generation of HDLRuby::High text.
+    ## Extends the If class with generation of C text.
     class If
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The result string.
@@ -1143,12 +1206,24 @@ 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.
+    ## Extends the When class with generation of C text.
     class When
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The result string.
@@ -1164,16 +1239,26 @@ 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.
+    ## Extends the Case class with generation of C text.
     class Case
 
-        # Generates the text of the equivalent HDLRuby::High code.
+        # Generates the text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             res = ""
@@ -1215,13 +1300,23 @@ 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
 
 
-    ## Extends the Delay class with generation of HDLRuby::High text.
+    ## Extends the Delay class with generation of C text.
     class Delay
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             return "make_delay(#{self.value.to_s}," +
@@ -1230,10 +1325,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the TimeWait class with generation of HDLRuby::High text.
+    ## Extends the TimeWait class with generation of C text.
     class TimeWait
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The resulting string.
@@ -1246,10 +1341,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the TimeRepeat class with generation of HDLRuby::High text.
+    ## Extends the TimeRepeat class with generation of C text.
     class TimeRepeat
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # The resulting string.
@@ -1264,7 +1359,7 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Block class with generation of HDLRuby::High text.
+    ## Extends the Block class with generation of C text.
     class Block
 
         # Adds the c code of the blocks to +res+ at +level+
@@ -1272,7 +1367,13 @@ module HDLRuby::Low
             res << self.to_c_code(level)
         end
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # 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 code.
         # +level+ is the hierachical level of the object.
         def to_c_code(level = 0)
             # The resulting string.
@@ -1351,6 +1452,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
@@ -1363,7 +1469,7 @@ module HDLRuby::Low
         end
 
         # Generates the execution of the block C text of the equivalent
-        # HDLRuby::High code.
+        # HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             res = " " * (level)
@@ -1373,6 +1479,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,27 +1490,31 @@ 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
 
 
-    ## Extends the Block class with generation of HDLRuby::High text.
+    ## Extends the Block class with generation of C text.
     class TimeBlock
         # TimeBlock is identical to Block in C
     end
 
 
-    ## Extends the Connection class with generation of HDLRuby::High text.
+    ## Extends the Connection class with generation of C text.
     class Connection
         # Nothing required, Transmit is generated identically.
     end
 
 
-    ## Extends the Expression class with generation of HDLRuby::High text.
+    ## Extends the Expression class with generation of C text.
     class Expression
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # Should never be here.
@@ -1412,7 +1523,7 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Value class with generation of HDLRuby::High text.
+    ## Extends the Value class with generation of C text.
     class Value
 
         ## Generates the C text for an access to the value.
@@ -1491,10 +1602,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Cast class with generation of HDLRuby::High text.
+    ## Extends the Cast class with generation of C text.
     class Cast
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             res = "({\n"
@@ -1522,10 +1633,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Operation class with generation of HDLRuby::High text.
+    ## Extends the Operation class with generation of C text.
     class Operation
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # Should never be here.
@@ -1533,10 +1644,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Unary class with generation of HDLRuby::High text.
+    ## Extends the Unary class with generation of C text.
     class Unary
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             res = "({\n"
@@ -1578,80 +1689,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Binary class with generation of HDLRuby::High text.
+    ## Extends the Binary class with generation of C text.
     class Binary
 
-        # # Generates the C text of the equivalent HDLRuby::High code.
-        # # +level+ is the hierachical level of the object.
-        # def to_c(level = 0)
-        #     res = ""
-        #     case self.operator
-        #     when :+ then
-        #         return "add_value(#{self.left.to_c(level)}," + 
-        #                "#{self.right.to_c(level)})"
-        #     when :- then
-        #         return "sub_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :* then
-        #         return "mul_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :/ then
-        #         return "div_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :% then
-        #         return "mod_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :** then
-        #         return "pow_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :& then
-        #         return "and_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :| then
-        #         return "or_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :^ then
-        #         return "xor_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :<<,:ls then
-        #         return "shift_left_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :>>,:rs then
-        #         return "shift_right_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :lr then
-        #         return "rotate_left_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :rr then
-        #         return "rotate_right_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :== then
-        #         return "equal_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :!= then
-        #         # return "not_equal_value(#{self.left.to_c(level)}," +
-        #         #        "#{self.right.to_c(level)})"
-        #         return "xor_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :> then
-        #         return "greater_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :< then
-        #         return "lesser_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :>= then
-        #         return "greater_equal_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     when :<= then
-        #         return "lesser_equal_value(#{self.left.to_c(level)}," +
-        #                "#{self.right.to_c(level)})"
-        #     else
-        #         raise "Invalid binary operator: #{self.operator}."
-        #     end
-        #     return res
-        # end
-
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # res = " " * (level*3)
@@ -1728,17 +1769,12 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Select class with generation of HDLRuby::High text.
+    ## Extends the Select class with generation of C text.
     class Select
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
-            # res = "select_value(#{self.select.to_c(level)}," + 
-            #       "#{self.each_choice.to_a.size}"
-            # self.each_choice { |choice| res << ",#{choice.to_c(level)}" }
-            # res << ")"
-            # return res
             # Gather the possible selection choices.
             expressions = self.each_choice.to_a
             # Create the resulting string.
@@ -1779,10 +1815,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Concat class with generation of HDLRuby::High text.
+    ## Extends the Concat class with generation of C text.
     class Concat
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(level = 0)
             # Gather the content to concat.
@@ -1826,10 +1862,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Ref class with generation of HDLRuby::High text.
+    ## Extends the Ref class with generation of C text.
     class Ref
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and
         # +left+ tells if it is a left value or not.
         def to_c(level = 0, left = false)
@@ -1838,10 +1874,11 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the RefConcat class with generation of HDLRuby::High text.
+
+    ## Extends the RefConcat class with generation of C text.
     class RefConcat
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and
         # +left+ tells if it is a left value or not.
         def to_c(level = 0, left = false)
@@ -1870,10 +1907,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the RefIndex class with generation of HDLRuby::High text.
+    ## Extends the RefIndex class with generation of C text.
     class RefIndex
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is thehierachical level of the object and
         # +left+ tells if it is a left value or not.
         def to_c(level = 0, left = false)
@@ -1914,22 +1951,13 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the RefRange class with generation of HDLRuby::High text.
+    ## Extends the RefRange class with generation of C text.
     class RefRange
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and
         # +left+ tells if it is a left value or not.
         def to_c(level = 0, left = false)
-            # if left then
-            #     res = "write_range(#{self.ref.to_c(level,left)},"
-            # else
-            #     res = "read_range(#{self.ref.to_c(level,left)},"
-            # end
-            # res << "read64(#{self.range.first.to_c(level)})," +
-            #        "read64(#{self.range.last.to_c(level)})," +
-            #        "#{self.type.base.to_c(level)})"
-            # return res
             # Decide if it is a read or a write
             command = left ? "write" : "read"
             res = "({\n"
@@ -1974,10 +2002,11 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the RefName class with generation of HDLRuby::High text.
+
+    ## Extends the RefName class with generation of C text.
     class RefName
 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and
         # +left+ tells if it is a left value or not.
         def to_c(level = 0, left = false)
@@ -1994,9 +2023,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the RefThis class with generation of HDLRuby::High text.
+
+    ## Extends the RefThis class with generation of C text.
     class RefThis 
-        # Generates the C text of the equivalent HDLRuby::High code.
+        # Generates the C text of the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object and
         # +left+ tells if it is a left value or not.
         def to_c(level = 0, left = false)
@@ -2010,14 +2040,5 @@ module HDLRuby::Low
         end
     end
 
-    # ## Extends the Numeric class with generation of HDLRuby::High text.
-    # class ::Numeric
-
-    #     # Generates the text of the equivalent HDLRuby::High code.
-    #     # +level+ is the hierachical level of the object.
-    #     def to_c(level = 0)
-    #         return self.to_s
-    #     end
-    # end
 
 end