HDLRuby 2.11.4 → 2.11.7

data/lib/HDLRuby/hdr_samples/arith_bench.rb

@@ -0,0 +1,92 @@
+
+# A benchmark for the arithmetic operations.
+system :arith_bench do
+    signed[8].inner :x8,:y8,:z8,:s8
+    signed[10].inner :s10
+    signed[16].inner :x16,:y16,:z16,:s16
+    signed[18].inner :s18
+    signed[32].inner :x32,:y32,:z32,:s32
+    signed[34].inner :s34
+
+    s8 <= x8+y8+z8
+    s10 <= x8.as(signed[10])+y8+z8
+
+    s16 <= x16+y16+z16
+    s18 <= x16.as(signed[18])+y16+z16
+
+    s32 <= x32+y32+z32
+    s34 <= x32.as(signed[34])+y32+z32
+
+    timed do
+        x8  <= 0
+        y8  <= 0
+        z8  <= 0
+        x16 <= 0
+        y16 <= 0
+        z16 <= 0
+        x32 <= 0
+        y32 <= 0
+        z32 <= 0
+        !10.ns
+        x8  <= 1
+        y8  <= 1
+        z8  <= 1
+        x16 <= 1
+        y16 <= 1
+        z16 <= 1
+        x32 <= 1
+        y32 <= 1
+        z32 <= 1
+        !10.ns
+        x8  <= 2
+        y8  <= 2
+        z8  <= 2
+        x16 <= 4
+        y16 <= 4
+        z16 <= 4
+        x32 <= 8
+        y32 <= 8
+        z32 <= 8
+        !10.ns
+        x8  <= 0x7F
+        y8  <= 0x7F
+        z8  <= 0x7F
+        x16 <= 0x7FFF
+        y16 <= 0x7FFF
+        z16 <= 0x7FFF
+        x32 <= 0x7FFFFFFF
+        y32 <= 0x7FFFFFFF
+        z32 <= 0x7FFFFFFF
+        !10.ns
+        x8  <= -1
+        y8  <= -1
+        z8  <= -1
+        x16 <= -1
+        y16 <= -1
+        z16 <= -1
+        x32 <= -1
+        y32 <= -1
+        z32 <= -1
+        !10.ns
+        x8  <= -2
+        y8  <= -2
+        z8  <= -2
+        x16 <= -4
+        y16 <= -4
+        z16 <= -4
+        x32 <= -8
+        y32 <= -8
+        z32 <= -8
+        !10.ns
+        x8  <= -0x80
+        y8  <= -0x80
+        z8  <= -0x80
+        x16 <= -0x8000
+        y16 <= -0x8000
+        z16 <= -0x8000
+        x32 <= -0x80000000
+        y32 <= -0x80000000
+        z32 <= -0x80000000
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/constant_prop_bench.rb

@@ -0,0 +1,58 @@
+# A simple counter
+system :counter do
+    input :clk, :rst
+    [8].input  :inc
+    [8].output :count
+
+    par(clk.posedge) do
+        hif(rst) { count <= 0 }
+        helse    { count <= count + inc }
+    end
+end
+
+# A benchmark for the counter using a constant as the inc input.
+system :dff_bench do
+    inner :clk, :rst
+    [8].inner :count
+    [8].constant inc: 5
+
+    # counter(:my_counter).(clk,rst,inc,count)
+    counter(:my_counter).(clk,rst,5,count)
+
+    # par do
+    #     my_counter.inc <= 5
+    #     count <= my_counter.count
+    # end
+
+    timed do
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        rst <= 0
+        !10.ns
+        clk <= 0
+        rst <= 1
+        !10.ns
+        clk <= 1
+        rst <= 1
+        !10.ns
+        clk <= 0
+        rst <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+        clk <= 0
+        !10.ns
+        clk <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -380,6 +380,9 @@ $optparse = OptionParser.new do |opts|
         $options[:rcsim] = v
         $options[:multiple] = v
     end
+    opts.on("--mute", "The simulator will not generate any output") do |v|
+        $options[:mute] = v
+    end
     opts.on("--vcd", "The simulator will generate a vcd file") do |v|
         $options[:vcd] = v
     end
@@ -712,8 +715,9 @@ elsif $options[:clang] then
         $main = File.open($name,"w")
 
         # Select the vizualizer depending on the options.
-        init_visualizer = $options[:vcd] ? "init_vcd_visualizer" :
-                                           "init_default_visualizer"
+        init_visualizer = $options[:mute] ? "init_mute_visualizer" :
+                          $options[:vcd]  ? "init_vcd_visualizer" :
+                                            "init_default_visualizer"
 
         # Gather the system to generate and sort them in the right order
         # to ensure references are generated before being used.
@@ -857,9 +861,13 @@ elsif $options[:rsim] then
     HDLRuby.show "#{Time.now}#{show_mem}"
     # Ruby-level simulation.
     require 'HDLRuby/hruby_rsim.rb'
-    # Is VCD output is required.
-    if $options[:vcd] then
-        # Yes
+    # Is mute or VCD output is required.
+    if $options[:mute] then
+        # Yes for mute.
+        require "HDLRuby/hruby_rsim_mute.rb"
+        $top_system.sim($stdout)
+    elsif $options[:vcd] then
+        # Yes for VCD
         require "HDLRuby/hruby_rsim_vcd.rb"
         vcdout = File.open($output+"/hruby_simulator.vcd","w")
         $top_system.sim(vcdout)
@@ -881,7 +889,8 @@ elsif $options[:rcsim] then
     $top_system.to_rcsim
     HDLRuby.show "Executing the hybrid C-Ruby-level simulator..."
     HDLRuby.show "#{Time.now}#{show_mem}"
-    HDLRuby::High.rcsim($top_system,"hruby_simulator",$output,$options[:vcd] && true)
+    HDLRuby::High.rcsim($top_system,"hruby_simulator",$output,
+                        ($options[:mute] && 1) || ($options[:vcd] && 2) || 0)
     HDLRuby.show "End of hybrid C-Ruby-level simulation..."
     HDLRuby.show "#{Time.now}#{show_mem}"
 elsif $options[:vhdl] then

data/lib/HDLRuby/hruby_bstr.rb

@@ -51,7 +51,9 @@ module HDLRuby
             elsif val.is_a?(Numeric) then
                 # Content is a numeric.
                 @content = []
-                if val > 0 then
+                if val == 0 then
+                    @content << 0
+                elsif val > 0 then
                     while val > 0 do
                         @content << (val & 1)
                         val /= 2
@@ -110,6 +112,11 @@ module HDLRuby
             return @content
         end
 
+        # Hash comparison.
+        def eql?(bstr)
+            return @content.eql?(bstr.raw_content)
+        end
+
         # Tells if the bit string is strictly.
         #
         # NOTE: return false if the sign is undefined of if it is unknown
@@ -180,10 +187,14 @@ module HDLRuby
                 if right >= left then
                     # puts "left=#{left} right=#{right}"
                     # Get the corresponding bits as a BitString
-                    return BitString.new(@content[left..right],:raw)
+                    # return BitString.new(@content[left..right],:raw)
+                    # set to positive.
+                    return BitString.new(@content[left..right]+[0],:raw)
                 else
                     # Get the corresponding bits as a BitString
-                    return BitString.new(@content[right..left].reverse,:raw)
+                    # return BitString.new(@content[right..left].reverse,:raw)
+                    # set to positive.
+                    return BitString.new(@content[right..left].reverse+[0],:raw)
                 end
             else
                 # Process the index.
@@ -532,6 +543,7 @@ module HDLRuby
                     val = BitString.new(val)
                 end
                 vcontent = val.raw_content
+                # puts "vcontent=#{vcontent}"
                 width = vcontent.size > @content.size ? vcontent.size : @content.size
                 res_content = width.times.map do |i|
                     # Get the bits to compute with

data/lib/HDLRuby/hruby_high.rb

@@ -4213,7 +4213,7 @@ module HDLRuby::High
         # Creates a new +type+ sort of block with possible +name+
         # and build it by executing +ruby_block+.
         def initialize(type, name = :"", &ruby_block)
-            # Initialize the block.
+            # Initialize the behavior.
             super(type,name)
 
             unless name.empty? then
@@ -4674,7 +4674,11 @@ module HDLRuby::High
     class ::Integer
         # Converts to a new high-level expression.
         def to_expr
-            return Value.new(Integer,self)
+            if (self.bit_length <= 63) then
+                return Value.new(Integer,self)
+            else
+                return Value.new(TypeSigned.new(:"",self.bit_length..0),self)
+            end
         end
     end
     
@@ -5168,9 +5172,9 @@ module HDLRuby::High
 
 
     # Standard vector types.
-    Integer = TypeSigned.new(:integer)
+    Integer = TypeSigned.new(:integer,63..0)
     Char    = TypeSigned.new(:char,7..0)
-    Natural = TypeUnsigned.new(:natural)
+    Natural = TypeUnsigned.new(:natural,63..0)
     Bignum  = TypeSigned.new(:bignum,HDLRuby::Infinity..0)
     Real    = TypeFloat.new(:float)
 

data/lib/HDLRuby/hruby_low.rb

@@ -4615,8 +4615,8 @@ module HDLRuby::Low
                 # Yes so it is also a left value if it is a sub ref.
                 if parent.respond_to?(:ref) then
                     # It might nor be a sub ref.
-                    # return parent.ref == self
-                    return parent.ref.eql?(self)
+                    # return parent.ref.eql?(self)
+                    return parent.ref.equal?(self)
                 else
                     # It is necessarily a sub ref (case of RefConcat for now).
                     return true
@@ -4624,8 +4624,8 @@ module HDLRuby::Low
             end
             # No, therefore maybe it is directly a left value.
             return (parent.is_a?(Transmit) || parent.is_a?(Connection)) &&
-                    # parent.left == self
-                parent.left.eql?(self)
+                # parent.left.eql?(self)
+                parent.left.equal?(self)
         end
 
         # Tells if the expression is a right value.
@@ -4715,9 +4715,18 @@ module HDLRuby::Low
                 # converted to BitString.
                 unless content.is_a?(Numeric) or
                         content.is_a?(HDLRuby::BitString)
-                    content = HDLRuby::BitString.new(content.to_s)
+                    # content = HDLRuby::BitString.new(content.to_s)
+                    content = content.to_s
+                    if self.type.unsigned? && content[0] != 0 then
+                        content = "0" + content.rjust(self.type.width,content[0])
+                    end
+                    content = HDLRuby::BitString.new(content)
                 end
                 @content = content 
+                if (@content.is_a?(Numeric) && self.type.unsigned?) then
+                    # Adjust the bits for unsigned.
+                    @content = @content & (2**self.type.width-1)
+                end
             end
         end
 

data/lib/HDLRuby/hruby_low2c.rb

@@ -20,6 +20,7 @@ module HDLRuby::Low
         #  h files.
         def self.includes(*names)
             res =  '#include <stdlib.h>' + "\n" + 
+                   '#include <string.h>' + "\n" +
                    '#include "hruby_sim.h"' + "\n"
             names.each { |name| res << "#include \"#{name}\"\n" }
             res << "\n"
@@ -687,6 +688,10 @@ module HDLRuby::Low
             if time then
                 res << " " * (level+1)*3
                 res << "register_timed_behavior(behavior);\n"
+            else
+                # Otherwise register it as a behavior to initialize. */
+                res << " " * (level+1)*3
+                res << "register_init_behavior(behavior);\n"
             end
 
             # Set the owner if any.
@@ -724,12 +729,39 @@ module HDLRuby::Low
                 refs = self.block.each_node_deep.select do |node|
                     node.is_a?(RefName) && !node.leftvalue? && 
                         !node.parent.is_a?(RefName) 
+                    # node.is_a?(RefName) && !node.parent.is_a?(RefName) 
                 end.to_a
                 # Keep only one ref per signal.
-                refs.uniq! { |node| node.full_name }
+                refs.uniq! { |ref| ref.full_name }
+                # # Remove the intermediate left values if sequential.
+                # self.each_block_deep do |blk|
+                #     if blk.mode == :seq && !blk.parent.is_a?(Behavior) then
+                #         blk.each_node_deep do |node|
+                #             if node.is_a?(RefName) && node.leftvalue? &&
+                #                 !node.parent.is_a?(RefName) then
+                #                 puts "removing ref=#{node.full_name}"
+                #                 refs.delete_if {|ref| ref.full_name == node.full_name }
+                #             end
+                #         end
+                #     end
+                # end
+                # # Remove left values.
+                # lefts = refs.select {|ref| ref.leftvalue? }.map do |ref|
+                #     ref.full_name
+                # end
+                # puts "lefts=#{lefts}"
+                # puts "first refs.size=#{refs.size}"
+                # refs.delete_if { |ref| lefts.include?(ref.full_name) }
+                # puts "now refs.size=#{refs.size}"
+                # puts "refs=#{refs.map {|r| r.full_name}}"
                 # Remove the inner signals from the list.
-                self.block.each_inner do |inner|
-                    refs.delete_if {|r| r.name == inner.name }
+                # self.block.each_inner do |inner|
+                #     refs.delete_if {|r| r.name == inner.name }
+                # end
+                self.each_block_deep do |blk|
+                    blk.each_inner do |inner|
+                        refs.delete_if {|r| r.name == inner.name }
+                    end
                 end
                 # Generate the event.
                 events = refs.map {|ref| Event.new(:anyedge,ref.clone) }
@@ -843,6 +875,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 +916,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"
@@ -918,9 +955,9 @@ module HDLRuby::Low
             if self.value then
                 # There is an initial value.
                 res << " " * (level+1)*3
-                # res << "copy_value("
-                # self.value.to_c_expr(res,level+2)
-                # res << ",signalI->c_value);\n"
+                res << "copy_value("
+                self.value.to_c_expr(res,level+2)
+                res << ",signalI->c_value);\n"
                 res << "copy_value("
                 self.value.to_c_expr(res,level+2)
                 res << ",signalI->f_value);\n"
@@ -1720,26 +1757,49 @@ module HDLRuby::Low
             res << "if (is_defined()) {\n"
             # The condition is testable.
             # Generate the case as a succession of if statements.
-            self.each_when do |w|
+            # self.each_when do |w|
+            #     res << " " * ((level+2)*3)
+            #     res << "dup();\n"
+            #     res << " " * ((level+2)*3)
+            #     w.match.to_c(res,level+2)
+            #     res << "if (to_integer() == to_integer()) { \n"
+            #     w.statement.to_c(res,level+3)
+            #     res << " " * (level+2)*3
+            #     res << "}\n"
+            # end
+            # if self.default then
+            #     res << " " * (level+2)*3
+            #     res << "else {\n"
+            #     self.default.to_c(res,level+3)
+            #     res << " " * (level+2)*3
+            #     res << "}\n"
+            # end
+            res << " " * ((level+2)*3)
+            res << "int val=to_integer(), done=0;\n"
+            self.each_when.with_index do |w,i|
                 res << " " * ((level+2)*3)
-                res << "dup();\n"
+                res << "if (!done) {\n" unless i == 0
                 res << " " * ((level+2)*3)
                 w.match.to_c(res,level+2)
-                res << "if (to_integer() == to_integer()) {\n"
+                res << "if (val == to_integer()) {\n"
                 w.statement.to_c(res,level+3)
+                res << " " * (level+3)*3
+                res << "done = 1;\n"
                 res << " " * (level+2)*3
+                res << "}" unless i == 0
                 res << "}\n"
             end
             if self.default then
                 res << " " * (level+2)*3
-                res << "else {\n"
+                res << "if(!done) {\n"
                 self.default.to_c(res,level+3)
                 res << " " * (level+2)*3
                 res << "}\n"
             end
+
             # Close the case.
             res << " " * (level+1)*3
-            res << "pop();\n" # Remove the testing value.
+            # res << "pop();\n" # Remove the testing value.
             res << " " * (level+1)*3
             res << "}\n"
             res << " " * (level)*3
@@ -1827,7 +1887,7 @@ module HDLRuby::Low
         def to_c(res,level = 0)
             # The resulting string.
             res << " " * level*3
-            if (number < 0) then
+            if (self.number < 0) then
                 # Generate an infinite loop executing the block and waiting.
                 res << "for(;;) {\n"
             else
@@ -2053,8 +2113,6 @@ module HDLRuby::Low
         ## Generates the content of the h file.
         # def to_ch
         def to_ch(res)
-            # res = ""
-            # return "extern Value #{Low2C.make_name(self)}();"
             res << "extern Value " << Low2C.make_name(self) << "();"
             return res
         end
@@ -2067,74 +2125,131 @@ module HDLRuby::Low
         def to_c_make(res,level = 0)
             # Check is the value maker is already present.
             maker = Low2C.make_name(self);
-            # return "" if @@made_values.include?(maker)
             return res if @@made_values.include?(maker)
             @@made_values.add(maker)
 
-            # The resulting string.
-            # res = ""
-
             # The header of the value generation.
             res << " " * level*3
-            # res << "Value " << Low2C.make_name(self) << "() {\n"
             res << "Value " << maker << "() {\n"
 
+            # # Declares the data.
+            # # Create the bit string.
+            # # str = self.content.is_a?(BitString) ?
+            # #     self.content.to_s : self.content.to_s(2).rjust(32,"0")
+            # if self.content.is_a?(BitString) then
+            #     str = self.content.is_a?(BitString) ?
+            #         self.content.to_s : self.content.to_s(2).rjust(32,"0")
+            # else
+            #     # sign = self.content>=0 ? "0" : "1"
+            #     # str = self.content.abs.to_s(2).rjust(width,sign).upcase
+            #     if self.content >= 0 then
+            #         str = self.content.to_s(2).rjust(width,"0").upcase
+            #     else
+            #         # Compute the extension to the next multiple
+            #         # of int_width
+            #         ext_width = (((width-1) / Low2C.int_width)+1)*Low2C.int_width
+            #         # Convert the string.
+            #         str = (2**ext_width+self.content).to_s(2).upcase
+            #     end
+            #     # puts "content=#{self.content} str=#{str}"
+            # end
+            # # Is it a fully defined number?
+            # # NOTE: bignum values are not supported by the simulation engine
+            # #       yet, therefore numeric values are limited to 64 max.
+            # if str =~ /^[01]+$/ && str.length <= 64 then
+            #     # Yes, generate a numeral value.
+            #     res << " " * (level+1)*3
+            #     res << "static unsigned int data[] = { "
+            #     res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
+            #         sub.to_i(2).to_s # + "ULL"
+            #     end.join(",")
+            #     res << ", 0" if (str.length <= 32)
+            #     res << " };\n"
+            #     # Create the value.
+            #     res << " " * (level+1)*3
+            #     # puts "str=#{str} type width=#{self.type.width} signed? #{type.signed?}"
+            #     # res << "return make_set_value(#{self.type.to_c(level+1)},1," +
+            #     #        "data);\n" 
+            #     res << "return make_set_value("
+            #     self.type.to_c(res,level+1)
+            #     res << ",1,data);\n" 
+            # else
+            #     # No, generate a bit string value.
+            #     res << " " * (level+1)*3
+            #     # res << "static unsigned char data[] = \"#{str}\";\n"
+            #     res << "static unsigned char data[] = \"#{str.reverse}\";\n"
+            #     # Create the value.
+            #     res << " " * (level+1)*3
+            #     # res << "return make_set_value(#{self.type.to_c(level+1)},0," +
+            #     #        "data);\n" 
+            #     res << "return make_set_value("
+            #     self.type.to_c(res,level+1)
+            #     res << ",0,data);\n" 
+            # end
+
             # Declares the data.
-            # Create the bit string.
-            # str = self.content.is_a?(BitString) ?
-            #     self.content.to_s : self.content.to_s(2).rjust(32,"0")
-            if self.content.is_a?(BitString) then
-                str = self.content.is_a?(BitString) ?
-                    self.content.to_s : self.content.to_s(2).rjust(32,"0")
-            else
-                # sign = self.content>=0 ? "0" : "1"
-                # str = self.content.abs.to_s(2).rjust(width,sign).upcase
-                if self.content >= 0 then
-                    str = self.content.to_s(2).rjust(width,"0").upcase
+            if self.content.is_a?(::Integer) then
+                if self.type.width <= 64 then
+                    res << " " * (level+1)*3
+                    res << "Value value = make_value("
+                    self.type.to_c(res,level+1)
+                    res << ",1);\n"
+                    # res << " " * (level+1)*3
+                    # res << "value->numeric = 1;\n"
+                    res << " " * (level+1)*3
+                    res << "value->capacity = 0;\n"
+                    res << " " * (level+1)*3
+                    res << "value->data_str = NULL;\n"
+                    res << " " * (level+1)*3
+                    if self.content.bit_length <= 63 then
+                        res << "value->data_int = #{self.content}LLU;\n"
+                    else
+                        res << "value->data_int = "
+                        res << "#{self.content & 0xFFFFFFFFFFFF}LLU;\n"
+                    end
+                    # Close the value.
+                    res << " " * (level+1)*3
+                    res << "return value;\n"
+                    res << " " * level*3
+                    res << "}\n\n"
+                    # Return the result.
+                    return res
                 else
-                    # Compute the extension to the next multiple
-                    # of int_width
-                    ext_width = (((width-1) / Low2C.int_width)+1)*Low2C.int_width
-                    # Convert the string.
-                    str = (2**ext_width+self.content).to_s(2).upcase
+                    str = self.content.to_s(2)
+                    # if str[-1] == "-" then
+                    #     str[-1] = "1"
+                    # elsif str[-1] == "1" then
+                    #     str = "0" + str
+                    # end
+                    if self.content < 0 then
+                        str = (2**self.type.width + self.content).to_s(2)
+                        str = "1" * (self.type.width-str.length) + str
+                    else
+                        str = self.content.to_s(2)
+                        str = "0" * (self.type.width-str.length) + str
+                    end
+                    str.reverse!
                 end
-                # puts "content=#{self.content} str=#{str}"
-            end
-            # Is it a fully defined number?
-            # NOTE: bignum values are not supported by the simulation engine
-            #       yet, therefore numeric values are limited to 64 max.
-            if str =~ /^[01]+$/ && str.length <= 64 then
-                # Yes, generate a numeral value.
-                res << " " * (level+1)*3
-                res << "static unsigned int data[] = { "
-                res << str.scan(/.{1,#{Low2C.int_width}}/m).reverse.map do |sub|
-                    sub.to_i(2).to_s # + "ULL"
-                end.join(",")
-                res << ", 0" if (str.length <= 32)
-                res << " };\n"
-                # Create the value.
-                res << " " * (level+1)*3
-                # puts "str=#{str} type width=#{self.type.width} signed? #{type.signed?}"
-                # res << "return make_set_value(#{self.type.to_c(level+1)},1," +
-                #        "data);\n" 
-                res << "return make_set_value("
-                self.type.to_c(res,level+1)
-                res << ",1,data);\n" 
             else
-                # No, generate a bit string value.
-                res << " " * (level+1)*3
-                # res << "static unsigned char data[] = \"#{str}\";\n"
-                res << "static unsigned char data[] = \"#{str.reverse}\";\n"
-                # Create the value.
-                res << " " * (level+1)*3
-                # res << "return make_set_value(#{self.type.to_c(level+1)},0," +
-                #        "data);\n" 
-                res << "return make_set_value("
-                self.type.to_c(res,level+1)
-                res << ",0,data);\n" 
+                str = content.to_s.reverse
             end
+            str = str.ljust(self.type.width,str[-1])
+            res << " " * (level+1)*3
+            res << "Value value = make_value("
+            self.type.to_c(res,level+1)
+            res << ",1);\n"
+            res << " " * (level+1)*3
+            res << "value->numeric = 0;\n"
+            res << " " * (level+1)*3
+            res << "value->capacity = #{str.length+1};"
+            res << " " * (level+1)*3
+            res << "value->data_str = calloc(value->capacity,sizeof(char));\n"
+            res << " " * (level+1)*3
+            res << "strcpy(value->data_str,\"#{str}\");\n"
 
             # Close the value.
+            res << " " * (level+1)*3
+            res << "return value;\n"
             res << " " * level*3
             res << "}\n\n"
             # Return the result.
@@ -2142,6 +2257,7 @@ module HDLRuby::Low
         end
     end
 
+
     ## Extends the Cast class with generation of C text.
     class Cast