HDLRuby 2.6.16 → 2.6.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0defaa4d148c2fbdc008f29c75a6ab8a4b48726a932f3222e2dc19c7b229492c
-  data.tar.gz: 9e2d4268200af09e0c078306b5c8a81494b589468b5b8b0084d300d14f922387
+  metadata.gz: 2d8c97794e72e7b03ad7d6db03c24ff4fb77748c3340bc9b9857a64537118e8f
+  data.tar.gz: 8077bcb0c9ce65c3372943ffcdeb2fd756fcd6969e94e135bb32a53b3de1e650
 SHA512:
-  metadata.gz: ae9f4d696caa0c8f76caa7f0fd05bf1f6554da50c40871c86ad3b44f4c41f3dc184fe58141afd796d3c9448fcdfd04d6869fafc0246fe39236e5f3f48d6bd6a2
-  data.tar.gz: 9cc5165ad15458f4c2f514107f7e15118534c079d061dc2f97aecb0982097fe534b0e26683834b901de34ced55132fc0f3608c19087b87ee5a9137174f49a4d1
+  metadata.gz: 104fae34f93944ecc476026b0e8c97b548220e92b7e14727f66af0dc8e6e3655b9dee20b1057f177263ad8947fd2a289333b7aa4378e9baaf16dac57cb41b988
+  data.tar.gz: 47c8c77471d8aff9cc4e601f403d3f32f254658f81884075cdc25e9c4ea422cbd3ef645664fcc3524f2cfb632c2a7c3f11d1cff20451a81e17422e3fab0f4130

data/lib/HDLRuby/hdr_samples/with_reduce.rb

@@ -0,0 +1,38 @@
+
+
+# A benchmark for testing the enumarable properties of expression (reduce).
+system :with_reduce_bench do
+    [8].inner :val,:res
+    [64].inner :val64
+
+    timed do
+        val <= _01101010
+        res <= val.reduce(_00000000,:+)
+        !10.ns
+        val <= _01010010
+        res <= val.reduce(_00000000,:+)
+        !10.ns
+        val <= _01101111
+        res <= val.reduce(_00000000,:+)
+        !10.ns
+        val64 <= _0110101001101010011010100110101001101010011010100110101001101010
+        res <= val64.reduce(_00000000,:+)
+        !10.ns
+        res <= val64[7..0]
+        !10.ns
+        res <= res.reduce(_00000000,:+)
+        !10.ns
+        res <= val64[63..60]
+        !10.ns
+        res <= res.reduce(_00000000,:+)
+        !10.ns
+        val64 <= ~(val64 ^ val64)
+        res <= val64.reduce(_00000000,:+)
+        !10.ns
+        val64[0] <= _0
+        val64[3] <= _0
+        val64[63] <= _0
+        res <= val64.reduce(_00000000,:+)
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_str2value.rb

@@ -0,0 +1,14 @@
+
+
+# A benchmark for testing conversion of strings to values.
+system :with_str2value_bench do
+    [8].inner :val
+    [64].inner :val64
+
+    timed do
+        val <= "01010011".to_value
+        !10.ns
+        val64 <= ("01010011" * 8).to_value
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_to_a.rb

@@ -0,0 +1,90 @@
+
+system :four2eight do
+    [4].input :four
+    output :o0, :o1, :o2, :o3, :o4, :o5, :o6, :o7
+
+    o0 <= four[0]; o1 <= four[1]; o2 <= four[2]; o3 <= four[3]
+    o4 <= four[0]; o5 <= four[1]; o6 <= four[2]; o7 <= four[3]
+end
+
+system :four2sixfour do
+    [4].input :four
+    output :o00, :o01, :o02, :o03, :o04, :o05, :o06, :o07,
+           :o08, :o09, :o0A, :o0B, :o0C, :o0D, :o0E, :o0F,
+           :o10, :o11, :o12, :o13, :o14, :o15, :o16, :o17,
+           :o18, :o19, :o1A, :o1B, :o1C, :o1D, :o1E, :o1F,
+           :o20, :o21, :o22, :o23, :o24, :o25, :o26, :o27,
+           :o28, :o29, :o2A, :o2B, :o2C, :o2D, :o2E, :o2F,
+           :o30, :o31, :o32, :o33, :o34, :o35, :o36, :o37,
+           :o38, :o39, :o3A, :o3B, :o3C, :o3D, :o3E, :o3F
+
+
+    o00 <= four[0]; o01 <= four[1]; o02 <= four[2]; o03 <= four[3]
+    o04 <= four[0]; o05 <= four[1]; o06 <= four[2]; o07 <= four[3]
+    o08 <= four[0]; o09 <= four[1]; o0A <= four[2]; o0B <= four[3]
+    o0C <= four[0]; o0D <= four[1]; o0E <= four[2]; o0F <= four[3]
+    o10 <= four[0]; o11 <= four[1]; o12 <= four[2]; o13 <= four[3]
+    o14 <= four[0]; o15 <= four[1]; o16 <= four[2]; o17 <= four[3]
+    o18 <= four[0]; o19 <= four[1]; o1A <= four[2]; o1B <= four[3]
+    o1C <= four[0]; o1D <= four[1]; o1E <= four[2]; o1F <= four[3]
+    o20 <= four[0]; o21 <= four[1]; o22 <= four[2]; o23 <= four[3]
+    o24 <= four[0]; o25 <= four[1]; o26 <= four[2]; o27 <= four[3]
+    o28 <= four[0]; o29 <= four[1]; o2A <= four[2]; o2B <= four[3]
+    o2C <= four[0]; o2D <= four[1]; o2E <= four[2]; o2F <= four[3]
+    o30 <= four[0]; o31 <= four[1]; o32 <= four[2]; o33 <= four[3]
+    o34 <= four[0]; o35 <= four[1]; o36 <= four[2]; o37 <= four[3]
+    o38 <= four[0]; o39 <= four[1]; o3A <= four[2]; o3B <= four[3]
+    o3C <= four[0]; o3D <= four[1]; o3E <= four[2]; o3F <= four[3]
+end
+
+
+
+# A benchmark for testing some enumarable properties of expression (to_a).
+system :with_to_a_bench do
+    [4].inner :four
+    [8].inner :val, :res, :eight
+    [64].inner :val64, :res64, :sixfour
+
+    vals = val.to_a
+    val64s = val64.to_a
+
+    four2eight(:my_four2eight).(four,*(eight.to_a.reverse))
+    four2sixfour(:my_four2sixfour).(four,*(sixfour.to_a.reverse))
+
+    timed do
+        val <= _01101010
+        res <= vals.reverse
+        !10.ns
+        val64 <= _0110101001101010011010100110101001101010011010100110101001101010
+        res64 <= val64s.reverse
+        !10.ns
+        val <= _00000000
+        val64 <= _0000000000000000000000000000000000000000000000000000000000000000
+        !10.ns
+        vals.each.with_index do |v,i|
+            v <= (i/2) & _1
+        end
+        res <= val
+        !10.ns
+        val64s.each.with_index do |v,i|
+            v <= (i/2) & _1
+        end
+        res64 <= val64
+        !10.ns
+        val <= _01010011
+        !10.ns
+        8.times do |i|
+            val64s[i] <= val[i]
+            val64s[i+32] <= val[i]
+            val64s[i+56] <= val[i]
+        end
+        res64 <= val64
+        !10.ns
+        four <= _0000
+        !10.ns
+        four <= _0001
+        !10.ns
+        four <= _1100
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdrcc.rb

@@ -110,7 +110,7 @@ module HDLRuby
                     else
                         # A standard file is found, skip it since it does not
                         # need to be read.
-                        # puts "Standard files: #{founds}"
+                        # show? "Standard files: #{founds}"
                         return false
                     end
                 end
@@ -134,7 +134,7 @@ module HDLRuby
                     file = @top_file_name
                 end
             end
-            # puts "read_all with file=#{file}"
+            # show? "read_all with file=#{file}"
             # Read the file
             # read(file)
             unless read(file) then
@@ -158,7 +158,7 @@ module HDLRuby
 
         # Displays the syntax tree of all the files.
         def show_all(outfile = $stdout)
-            # puts "@checks.size=#{@checks.size}"
+            # show? "@checks.size=#{@checks.size}"
             @checks.each { |check| check.show(outfile) }
         end
 
@@ -166,7 +166,7 @@ module HDLRuby
         def get_top
             # Get all the systems.
             systems = @checks.reduce([]) {|ar,check| ar + check.get_all_systems}
-            # puts "First systems=#{systems}"
+            # show? "First systems=#{systems}"
             # Remove the systems that are instantiated or included
             # (they cannot be tops)
             @checks.each do |check|
@@ -183,7 +183,7 @@ module HDLRuby
                     systems -= check.get_inherit_systems(inherit)
                 end
             end
-            # puts "Now systems=#{systems}"
+            # show? "Now systems=#{systems}"
             # Return the first top of the list.
             return systems[-1]
         end
@@ -195,7 +195,7 @@ module HDLRuby
             if @top_system == "" then
                 # No, look for it.
                 @top_system = get_top
-                # puts "@top_system=#{@top_system}"
+                # show? "@top_system=#{@top_system}"
                 unless @top_system then
                     # Not found? Error.
                     # Maybe it is a parse error, look for it.
@@ -238,7 +238,7 @@ module HDLRuby
                 # Dump to a file.
                 if chunk.name != :sim then 
                     # The chunk is to be dumbed to a file.
-                    # puts "Outputing chunk:#{HDLRuby::Low::Low2C.obj_name(chunk)}"
+                    # show? "Outputing chunk:#{HDLRuby::Low::Low2C.obj_name(chunk)}"
                     outfile = File.open(path + "/" +
                                        HDLRuby::Low::Low2C.obj_name(chunk) + "." +
                                        chunk.name.to_s,"w")
@@ -351,6 +351,12 @@ $optparse = OptionParser.new do |opts|
     opts.on("-D", "--debug","Set the HDLRuby debug mode") do |d|
         $options[:debug] = d
     end
+    opts.on("--verbose","Set verbose mode.") do |d|
+        HDLRuby.verbosity = 2
+    end
+    opts.on("--volubile","Set extreme verbose mode.") do |d|
+        HDLRuby.verbosity = 3
+    end
     opts.on("-T","--test t0,t1,t2","Compile the unit tests named t0,t1,...") do |t|
         $options[:test] = t
     end
@@ -396,7 +402,7 @@ $optparse = OptionParser.new do |opts|
 end
 $optparse.parse!
 
-# puts "options=#{$options}"
+# show? "options=#{$options}"
 
 # Check the compatibility of the options
 if $options.count {|op| [:yaml,:hdr,:verilog,:vhdl].include?(op) } > 1 then
@@ -436,7 +442,7 @@ if ($options[:test] || $options[:testall]) then
     $test_file.write("require 'std/hruby_unit.rb'\nrequire_relative '#{$input}'\n\n" +
                      "HDLRuby::Unit.test(:\"#{$top}\"#{tests})\n")
     # $test_file.rewind
-    # puts $test_file.read
+    # show? $test_file.read
     # exit
     $test_file.rewind
     # It is the new input file.
@@ -491,11 +497,11 @@ end
 
 # Generate the result.
 # Get the top systemT.
-puts Time.now
+HDLRuby.show Time.now
 $top_system = $top_instance.to_low.systemT
 $top_intance = nil # Free as much memory as possible.
-puts "##### Top system built #####"
-puts Time.now
+HDLRuby.show "##### Top system built #####"
+HDLRuby.show Time.now
 
 
 # # Apply the pre drivers if any.
@@ -562,23 +568,23 @@ elsif $options[:clang] then
     # top_system = $top_system
     # Preprocess the HW description for valid C generation.
     $top_system.each_systemT_deep do |systemT|
-        puts "seq2seq step..."
+        HDLRuby.show "seq2seq step..."
         # Coverts the par blocks in seq blocks to seq blocks to match
         # the simulation engine.
         systemT.par_in_seq2seq!
-        puts Time.now
-        puts "connections_to_behaviors step..."
+        HDLRuby.show Time.now
+        HDLRuby.show "connections_to_behaviors step..."
         # Converts the connections to behaviors.
         systemT.connections_to_behaviors!
-        puts Time.now
+        HDLRuby.show Time.now
         # Break the RefConcat.
-        puts "concat_assigns step..."
+        HDLRuby.show "concat_assigns step..."
         systemT.break_concat_assigns! 
-        puts Time.now
+        HDLRuby.show Time.now
         # Explicits the types.
-        puts "explicit_types step..."
+        HDLRuby.show "explicit_types step..."
         systemT.explicit_types!
-        puts Time.now
+        HDLRuby.show Time.now
     end
     # Generate the C.
     if $options[:multiple] then
@@ -649,7 +655,7 @@ elsif $options[:clang] then
             name = $output + "/" +
                 HDLRuby::Low::Low2C.c_name(systemT.name) +
                 ".c"
-            # puts "for systemT=#{systemT.name} generating: #{name}"
+            # show? "for systemT=#{systemT.name} generating: #{name}"
             # Open the file for current systemT
             outfile = File.open(name,"w")
             # Generate the C code in to.
@@ -703,26 +709,26 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
-        puts "casts_without_expression! step..."
+        HDLRuby.show "casts_without_expression! step..."
         systemT.casts_without_expression!
-        puts Time.now
-        puts "to_upper_space! step..."
+        HDLRuby.show Time.now
+        HDLRuby.show "to_upper_space! step..."
         systemT.to_upper_space!
-        puts Time.now
-        puts "to_global_space! step..."
+        HDLRuby.show Time.now
+        HDLRuby.show "to_global_space! step..."
         systemT.to_global_systemTs!
-        puts Time.now
+        HDLRuby.show Time.now
         # systemT.break_types!
         # systemT.expand_types!
-        puts "par_in_seq2seq! step..."
+        HDLRuby.show "par_in_seq2seq! step..."
         systemT.par_in_seq2seq!
-        puts Time.now
-        puts "initial_concat_to_timed! step..."
+        HDLRuby.show Time.now
+        HDLRuby.show "initial_concat_to_timed! step..."
         systemT.initial_concat_to_timed!
-        puts Time.now
-        puts "with_port! step..."
+        HDLRuby.show Time.now
+        HDLRuby.show "with_port! step..."
         systemT.with_port!
-        puts Time.now
+        HDLRuby.show Time.now
     end
     # # Verilog generation
     # $output << top_system.to_verilog

data/lib/HDLRuby/hruby_low2c.rb

@@ -1575,9 +1575,10 @@ module HDLRuby::Low
             if str =~ /^[01]+$/ && str.length <= 64 then
                 # Yes, generate a numeral value.
                 res << " " * (level+1)*3
-                res << "static unsigned long long data[] = { "
+                # res << "static unsigned long long data[] = { "
+                res << "static unsigned int data[] = { "
                 res << str.scan(/.{1,#{Low2C.int_width}}/m).map do |sub|
-                    sub.to_i(2).to_s + "ULL"
+                    sub.to_i(2).to_s # + "ULL"
                 end.join(",")
                 res << " };\n"
                 # Create the value.
@@ -1930,11 +1931,10 @@ module HDLRuby::Low
             res << "ref = #{self.ref.to_c(level+2)};\n"
             # Compute the index.
             res << (" " * ((level+1)*3))
-            # res << "idx = read64(#{self.index.to_c(level+2)});\n"
             res << "idx = value2integer(#{self.index.to_c(level+2)});\n"
             # Make the access.
             res << (" " * ((level+1)*3))
-            # res << "dst = read_range(ref,idx,idx,#{self.ref.type.base.to_c(level)},dst);\n"
+            # puts "self.type.width=#{self.type.width}"
             res << "dst = read_range(ref,idx,idx,#{self.type.to_c(level)},dst);\n"
             # Restore the state of the value pool.
             res << (" " * ((level+1)*3))
@@ -1947,7 +1947,9 @@ module HDLRuby::Low
         # Generates the C text for reference as left value to a signal.
         # +level+ is the hierarchical level of the object.
         def to_c_signal(level = 0)
+            # puts "to_c_signal for RefIndex"
             return "make_ref_rangeS(#{self.ref.to_c_signal(level)}," +
+                "#{self.type.to_c(level)}," + 
                 "value2integer(#{self.index.to_c(level)}),value2integer(#{self.index.to_c(level)}))"
         end
     end
@@ -1985,7 +1987,7 @@ module HDLRuby::Low
             # Make the access.
             res << (" " * ((level+1)*3))
             # res << "dst = #{command}_range(ref,first,last,#{self.ref.type.base.to_c(level)},dst);\n"
-            # puts "will read_range for #{self.ref.name} with width=#{self.ref.type.width} with base width=#{self.ref.type.base.width} with range=#{self.ref.type.range} with range=#{self.range.first.content}..#{self.range.last.content}"
+            # puts "#{command}_range with first=#{self.range.first} and last=#{self.range.last}"
             res << "dst = #{command}_range(ref,first,last,#{self.type.base.to_c(level)},dst);\n"
             # Restore the state of the value pool.
             res << (" " * ((level+1)*3))

data/lib/HDLRuby/hruby_low_casts_without_expression.rb

@@ -56,9 +56,9 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the left value.
-            self.set_left!(self.left.casts_without_expression)
+            self.set_left!(self.left.casts_without_expression!)
             # Apply on the right value.
-            self.set_right!(self.right.casts_without_expression)
+            self.set_right!(self.right.casts_without_expression!)
             return self
         end
     end
@@ -71,7 +71,7 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the arguments.
-            self.map_args!(&:casts_without_expression)
+            self.map_args!(&:casts_without_expression!)
             return self
         end
     end
@@ -84,12 +84,12 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the condition.
-            self.set_condition!(self.condition.casts_without_expression)
+            self.set_condition!(self.condition.casts_without_expression!)
             # Apply on the yes.
             self.yes.casts_without_expression!
             # Apply on the noifs.
             @noifs.map! do |cond,stmnt|
-                [cond.casts_without_expression,stmnt.casts_without_expression!]
+                [cond.casts_without_expression!,stmnt.casts_without_expression!]
             end
             # Apply on the no if any.
             self.no.casts_without_expression! if self.no
@@ -104,7 +104,7 @@ module HDLRuby::Low
         # Extracts the expressions from the casts.
         def casts_without_expression!
             # Apply on the match.
-            self.set_match!(self.match.casts_without_expression)
+            self.set_match!(self.match.casts_without_expression!)
             # Apply on the statement.
             self.statement.casts_without_expression!
             return self
@@ -120,7 +120,7 @@ module HDLRuby::Low
         def casts_without_expression!
             # No need to apply on the value!
             # Apply on the value.
-            self.set_value!(self.value.casts_without_expression)
+            self.set_value!(self.value.casts_without_expression!)
             # Apply on the whens.
             self.each_when(&:casts_without_expression!)
             # Apply on the default if any.
@@ -169,9 +169,10 @@ module HDLRuby::Low
     #  expressions from cast.
     class Value
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Simple clones.
-            return self.clone
+        def casts_without_expression!
+            # # Simple clones.
+            # return self.clone
+            return self
         end
     end
 
@@ -180,9 +181,10 @@ module HDLRuby::Low
     #  expressions from cast.
     class Cast
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the child.
-            nchild = self.child.casts_without_expression
+            nchild = self.child.casts_without_expression!
+            nchild.parent = nil
             # Process the cast.
             unless (nchild.is_a?(Ref)) then
                 # Need to extract the child.
@@ -221,10 +223,11 @@ module HDLRuby::Low
     class Unary
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Recurse on the sub node.
-            return Unary.new(self.type,self.operator,
-                             self.child.casts_without_expression)
+        def casts_without_expression!
+            # # Recurse on the sub node.
+            # return Unary.new(self.type,self.operator,
+            #                  self.child.casts_without_expression)
+            self.set_child!(self.child.casts_without_expression!)
             return self
         end
     end
@@ -235,11 +238,14 @@ module HDLRuby::Low
     class Binary
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Recurse on the sub nodes.
-            return Binary.new(self.type,self.operator,
-                              self.left.casts_without_expression,
-                              self.right.casts_without_expression)
+        def casts_without_expression!
+            # # Recurse on the sub nodes.
+            # return Binary.new(self.type,self.operator,
+            #                   self.left.casts_without_expression,
+            #                   self.right.casts_without_expression)
+            self.set_left!(self.left.casts_without_expression!)
+            self.set_right!(self.right.casts_without_expression!)
+            return self
         end
     end
 
@@ -250,13 +256,15 @@ module HDLRuby::Low
     class Select
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub node.
-            return Select.new(self.type,"?", 
-                              self.select.casts_without_expression,
-                              *self.each_choice.map do |choice|
-                                  choice.casts_without_expression
-                              end )
+            # return Select.new(self.type,"?", 
+            #                   self.select.casts_without_expression,
+            #                   *self.each_choice.map do |choice|
+            #                       choice.casts_without_expression
+            #                   end )
+            self.set_select!(self.select.casts_without_expression!)
+            sef.map_choices! { |choice| choice.casts_without_expression! }
             return self
         end
     end
@@ -266,11 +274,13 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class Concat
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub expressions.
-            return Concat.new(self.type,self.each_expression.map do |expr|
-                expr.casts_without_expression
-            end )
+            # return Concat.new(self.type,self.each_expression.map do |expr|
+            #     expr.casts_without_expression
+            # end )
+            self.map_expressions! {|expr| expr.casts_without_expression! }
+            return self
         end
     end
 
@@ -279,11 +289,13 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefConcat
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Recurse on the sub references.
-            return RefConcat.new(self.type,self.each_expression.map do |expr|
-                expr.casts_without_expression
-            end )
+        def casts_without_expression!
+            # # Recurse on the sub references.
+            # return RefConcat.new(self.type,self.each_expression.map do |expr|
+            #     expr.casts_without_expression
+            # end )
+            self.map_expressions! {|expr| expr.casts_without_expression! }
+            return self
         end
     end
 
@@ -292,11 +304,14 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefIndex
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub references.
-            return RefIndex.new(self.type,
-                                self.ref.casts_without_expression,
-                                self.index.casts_without_expression)
+            # return RefIndex.new(self.type,
+            #                     self.ref.casts_without_expression,
+            #                     self.index.casts_without_expression)
+            self.set_ref!(self.ref.casts_without_expression!)
+            self.set_index!(self.index.casts_without_expression!)
+            return self
         end
     end
 
@@ -305,12 +320,16 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefRange
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub references.
-            return RefRange.new(self.type,
-                                self.ref.casts_without_expression,
-                                self.range.first.casts_without_expression ..
-                                self.range.last.casts_without_expression)
+            # return RefRange.new(self.type,
+            #                     self.ref.casts_without_expression,
+            #                     self.range.first.casts_without_expression ..
+            #                     self.range.last.casts_without_expression)
+            self.set_ref!(self.ref.casts_without_expression!)
+            self.set_range!(self.range.first.casts_without_expression! ..
+                            self.range.last.casts_without_expression!)
+            return self
         end
     end
 
@@ -319,11 +338,13 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefName
         # Extracts the expressions from the casts.
-        def casts_without_expression
+        def casts_without_expression!
             # Recurse on the sub references.
-            return RefName.new(self.type,
-                               self.ref.casts_without_expression,
-                               self.name)
+            # return RefName.new(self.type,
+            #                    self.ref.casts_without_expression,
+            #                    self.name)
+            self.set_ref!(self.ref.casts_without_expression!)
+            return self
         end
     end
 
@@ -332,9 +353,10 @@ module HDLRuby::Low
     #  in assignments to select operators.
     class RefThis 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            # Simply clone.
-            return self.clone
+        def casts_without_expression!
+            # # Simply clone.
+            # return self.clone
+            return self
         end
     end
 
@@ -344,9 +366,10 @@ module HDLRuby::Low
     class StringE
 
         # Extracts the expressions from the casts.
-        def casts_without_expression
-            return StringE.new(self.content,
-                               *self.each_arg.map(&:cast_without_expression))
+        def casts_without_expression!
+            # return StringE.new(self.content,
+            #                    *self.each_arg.map(&:casts_without_expression))
+            self.map_args! {|arg| arg.casts_without_expression! }
             return self
         end
     end

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -1959,4 +1959,25 @@ module HDLRuby::Low
             # Nothing to do.
         end
     end
+
+    ##
+    # Describes a string.
+    #
+    # NOTE: This is not synthesizable!
+    class StringE
+        
+        # Maps on the arguments.
+        def map_args!(&ruby_block)
+            @args.map! do |arg|
+                arg = ruby_block.call(arg)
+                arg.parent = self unless arg.parent
+                arg
+            end
+        end
+
+        # Maps on the children.
+        def map_nodes!(&ruby_block)
+            self.map_args!(&ruby_block)
+        end
+    end
 end

data/lib/HDLRuby/hruby_low_without_namespace.rb

@@ -44,8 +44,10 @@ module HDLRuby::Low
         def to_global_systemTs!
             # Force a name if not.
             self.force_name!
+            # puts "to_global_systemTs! for #{self.name}"
             # For each local systemT
             self.scope.each_systemT.to_a.each do |systemT|
+                # puts "Processing system: #{systemT}"
                 # Rename it for globalization.
                 former = systemT.name
                 self.extend_name!(systemT)
@@ -211,6 +213,7 @@ module HDLRuby::Low
         # Replaces recursively +former+ name by +nname+ until it is redeclared
         # in the internals.
         def replace_names_subs!(former,nname)
+            # puts "replace_names_subs! for #{self} with former=#{former} and nname=#{nname}"
             self.each_type do |type|
                 type.replace_names!(former,nname)
             end
@@ -416,8 +419,9 @@ module HDLRuby::Low
             if self.name == former then
                 self.set_name!(nname)
             end
-            # Recurse on the system type.
-            self.systemT.replace_names!(former,nname)
+            # Not needed since treated through scope and systemT.
+            # # Recurse on the system type.
+            # self.systemT.replace_names!(former,nname)
         end
     end
 

data/lib/HDLRuby/hruby_tools.rb

@@ -50,4 +50,28 @@ module HDLRuby
 
     end
 
+
+    # Display some messages depending on the verbosity mode.
+    @@verbosity = 1 # The verbosity level: default 1, only critical messages.
+
+    # Sets the verbosity.
+    def self.verbosity=(val)
+        @@verbosity = val.to_i
+    end
+    
+    # Display a critical message.
+    def self.show!(*args)
+        puts(*args) if @@verbosity > 0
+    end
+
+    # Display a common message.
+    def self.show(*args)
+        puts(*args) if @@verbosity > 1
+    end
+
+    # Display a minor message.
+    def self.show?(*args)
+        puts(*args) if @@verbosity > 2
+    end
+
 end

data/lib/HDLRuby/hruby_verilog_name.rb

@@ -6,63 +6,35 @@ module HDLRuby::Verilog
   # This is sample.
   # n = "abc_ABC_いろは"
   # puts n            
-  # name = n.split("") 
+  # name = n.split("")
+
+  @@hdr2verilog = {}
 
   # Since it is possible to use $ and numbers other than the beginning of the character string, it is divided.
   def name_to_verilog(name)
-    # ref = ""         # For storing the converted character.
-    # name = name.to_s # Ensure name is a string
-    # 
-    # if (name[0] =~ /[a-zA-Z]/) then
-    #   ref << name[0]
-    #   # _ To convert it to __.
-    # elsif (name[0] == "_") then
-    #   ref << "__"
-    # # If it does not satisfy the above, it is another character.
-    # # In that case, convert it to UTF-8 and convert it to a usable character string.
-    # else
-    #   l = name[0].bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
-   
-    #   ref << "_" + l.rjust(6,"0")      # Add an underscore indicating conversion.
-    #                                    # The remainder of 6 digits is filled with 0.
-    # end
-    # 
-    # name[1..-1].each_char do |c|
-    #   # Confirmation of characters in array.
-    #   # If it is a-zA-Z 0 - 9, it is added to ref as it is.
-    #   if (c =~ /[a-zA-Z0-9]|\$/) then
-    #     ref << c
-    #   # _ To convert it to __.
-    #   elsif (c == "_") then
-    #     ref << "__"
-    #   # If it does not satisfy the above, it is another character.
-    #   # In that case, convert it to UTF-8 and convert it to a usable character string.
-    #   else
-    #     l = c.bytes.map{|v| v.to_s(16)}.join # Conversion to UTF-8 hexadecimal number.
-    #  
-    #     ref << "_" + l.rjust(6,"0")      # Add an underscore indicating conversion.
-    #                                      # The remainder of 6 digits is filled with 0.
-    #   end
-    # end
-    # return ref
-
-    
+      # name = name.to_s
+      # # Convert special characters.
+      # name = name.each_char.map do |c|
+      #     if c=~ /[a-z0-9]/ then
+      #         c
+      #     elsif c == "_" then
+      #         "__"
+      #     else
+      #         "_" + c.ord.to_s
+      #     end
+      # end.join
+      # # First character: only letter is possible.
+      # unless name[0] =~ /[a-z_]/ then
+      #     name = "_" + name
+      # end
+      # return name
       name = name.to_s
-      # Convert special characters.
-      name = name.each_char.map do |c|
-          if c=~ /[a-z0-9]/ then
-              c
-          elsif c == "_" then
-              "__"
-          else
-              "_" + c.ord.to_s
-          end
-      end.join
-      # First character: only letter is possible.
-      unless name[0] =~ /[a-z_]/ then
-          name = "_" + name
+      vname = @@hdr2verilog[name]
+      unless vname then
+          vname = "_v#{@@hdr2verilog.size}_#{name.split(/[^a-zA-Z_0-9]/)[-1]}"
+            @@hdr2verilog[name] = vname
       end
-      return name
+      return vname
   end
 
   #puts ref

data/lib/HDLRuby/sim/hruby_sim.h

@@ -101,6 +101,7 @@ typedef struct ValueS_ {
 /* The tructure of a reference to a range in a value. */
 typedef struct RefRangeS_ {
     SignalI signal;           /* The refered signal. */
+    Type type;                /* The tyep of the elements. */
     unsigned long long first; /* The first index in the range. */
     unsigned long long last;  /* The last index in the range. */
 } RefRangeS;
@@ -308,11 +309,12 @@ extern int same_content_value_range(Value value0, unsigned long long first,
 
 /** Creates a reference to a range inside a signal.
  *  @param signal the signal to refer
+ *  @param typ the type of the elements.
  *  @param first the start index of the range
  *  @param last the end index of the range
  *  @return the resulting reference */
-extern RefRangeS make_ref_rangeS(SignalI signal, unsigned long long first,
-        unsigned long long last);
+extern RefRangeS make_ref_rangeS(SignalI signal, Type typ, 
+        unsigned long long first, unsigned long long last);
 
 
 /* The interface for the lists. */

data/lib/HDLRuby/sim/hruby_sim_calc.c

@@ -2171,7 +2171,8 @@ Value read_range_numeric(Value value, long long first, long long last,
     /* Compute the read mask. */
     // unsigned long long mask = ((-1LL) << first) & (~((-1LL) << (last+1)));
     /* NOTE: once again, << 64 does not work like expected. */
-    unsigned long long mask = mask+bw < 64 ? (~((-1LL) << (last+bw))) : -1LL;
+    unsigned long long mask = last+bw < 64 ? (~((-1LL) << (last+bw))) : -1LL;
+    // printf("mask=%llx\n",mask);
     /* Performs the read. */
     unsigned long long data = (value->data_int & mask) >> first;
     /* Write it to the destination. */
@@ -2216,7 +2217,9 @@ Value write_range_numeric(Value src, long long first, long long last,
     /* Copy from the source. */
     unsigned long long src_data = src->data_int & ~((-1LL) << (last-first+1));
     /* Cleans the destination where to place the data. */
-    unsigned long long mask = ~(((-1LL) << first) & ~((-1LL) << (last+1)));
+    unsigned long long mask;
+    if (last<63) mask = ~(((-1LL) << first) & ~((-1LL) << (last+1)));
+    else         mask = ~((-1LL)<<first);
     unsigned long long dst_data = dst->data_int & mask;
     // printf("src_data=%llx  mask=%llx dst_data=%llx\n",src_data,mask,dst_data);
     /* Write the data. */
@@ -2947,12 +2950,13 @@ int same_content_value_range(Value value0,
 
 /** Creates a reference to a range inside a signal.
  *  @param signal the signal to refer
+ *  @param typ the type of the elements
  *  @param first the start index of the range
  *  @param last the end index of the range
  *  @return the resulting reference */
-RefRangeS make_ref_rangeS(SignalI signal, unsigned long long first,
+RefRangeS make_ref_rangeS(SignalI signal, Type typ, unsigned long long first,
         unsigned long long last) {
-    RefRangeS result = { signal, first, last };
+    RefRangeS result = { signal, typ, first, last };
     return result;
 }
 

data/lib/HDLRuby/sim/hruby_sim_core.c

@@ -586,12 +586,14 @@ void transmit_to_signal_range_seq(Value value, RefRangeS ref) {
     SignalI signal = ref.signal;
     unsigned long long first = ref.first;
     unsigned long long last = ref.last;
-    // printf("Tansmit to signal range: %s(%p)\n",signal->name,signal);
+    // printf("Tansmit to signal range: %s(%p) [%llu,%llu]\n",signal->name,signal,first,last);
     /* Can transmit, copy the content. */
     if (signal->fading)
-        write_range(value,first,last,signal->f_value->type,signal->f_value);
+        // write_range(value,first,last,signal->f_value->type,signal->f_value);
+        write_range(value,first,last,ref.type,signal->f_value);
     else
-        write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
+        // write_range_no_z(value,first,last,signal->f_value->type,signal->f_value);
+        write_range_no_z(value,first,last,ref.type,signal->f_value);
     /* And touch the signal. */
     touch_signal_seq(signal);
 }

data/lib/HDLRuby/version.rb

@@ -1,3 +1,3 @@
 module HDLRuby
-  VERSION = "2.6.16"
+  VERSION = "2.6.23"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.6.16
+  version: 2.6.23
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-20 00:00:00.000000000 Z
+date: 2021-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,6 +150,9 @@ files:
 - lib/HDLRuby/hdr_samples/with_memory_rom.rb
 - lib/HDLRuby/hdr_samples/with_multi_channels.rb
 - lib/HDLRuby/hdr_samples/with_reconf.rb
+- lib/HDLRuby/hdr_samples/with_reduce.rb
+- lib/HDLRuby/hdr_samples/with_str2value.rb
+- lib/HDLRuby/hdr_samples/with_to_a.rb
 - lib/HDLRuby/hdr_samples/with_to_array.rb
 - lib/HDLRuby/hdrcc.rb
 - lib/HDLRuby/high_samples/_adder_fault.rb