HDLRuby 2.6.18 → 2.6.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d49fb40d2d1233c59c0ae1f6d7afea51ab17e70aaac5f605295f4c44e478fa4
-  data.tar.gz: 0b14393197c0af246dae6c221d2beb94580fa9b4c30b234e82efdae4eebf5bca
+  metadata.gz: 935f56ddd3e2db8f8cd72ae2d8156af2dbf9c1961be139a1b2c4f27b2e0d483c
+  data.tar.gz: 5a6d8a611f8cf6e0e9ae859721a26b2940c569436479f74f01cced46b741d810
 SHA512:
-  metadata.gz: e2c55c6966faa1274aee2ae712b376aec22670e9a574b4d5312e73a8a8a1f85713b8312d6b923e4daef030398667c327245ee8aeb813c3d379d137dd63ec9af8
-  data.tar.gz: a28d25d1a5ff5893e64ede5229a4b53c7ad0c4ff6479807e3f76764c9f464fc5d0b6a41f8cce3ea8b49338895a3d95e8582760c64a0d8df21a5683fd0acba4d3
+  metadata.gz: c2df833c800000df44afdd2178414f6a282b4f597ec6d6b000a26e15ddff990f3ad0784e8d93d1dc75c4948f638824ea12a731340e896c8eb976ad83a61ff6eb
+  data.tar.gz: 84b29e842be879ed848aeb475f80cc34654a31d0ca0fbfa45093082374dca6a90ad8dce3b1774ae339d1c962fcf63a81e5821bddd924ea6be84f2a6f8b566e84

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/hruby_high.rb

@@ -2499,7 +2499,11 @@ module HDLRuby::High
 
         # Casts as +type+.
         def as(type)
-            return Cast.new(type.to_type,self.to_expr)
+            if (self.parent)
+                return Cast.new(type.to_type,self.to_expr)
+            else
+                return Cast.new(type.to_type,self)
+            end
         end
 
         # Casts to a bit vector type.

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_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.18"
+  VERSION = "2.6.24"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.6.18
+  version: 2.6.24
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-01 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