HDLRuby 2.6.22 → 2.6.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1568bd314caee471d78b83b882b7c89ad778642a4a026de691209318bf3f5a00
-  data.tar.gz: 6d1829e1f8d04fb8592d68faf1b12affccf487a94a86275f932bef8676c542a6
+  metadata.gz: 2d8c97794e72e7b03ad7d6db03c24ff4fb77748c3340bc9b9857a64537118e8f
+  data.tar.gz: 8077bcb0c9ce65c3372943ffcdeb2fd756fcd6969e94e135bb32a53b3de1e650
 SHA512:
-  metadata.gz: ded7ab60f18f80344d244274c354e85eda76150804bdb31598d801d803c33e0d63cc4786becdff7a3bff63a93b98d3837256638fe76ed993384998f56484846c
-  data.tar.gz: 52c1fabe48cacabad8692f7eacd00c3ced295e2963ec29c3f5235cf27ff99a8826b12e2d525bc2d4b86703967dcbe2fe10bdb47c20127f84c04ea8875ae39277
+  metadata.gz: 104fae34f93944ecc476026b0e8c97b548220e92b7e14727f66af0dc8e6e3655b9dee20b1057f177263ad8947fd2a289333b7aa4378e9baaf16dac57cb41b988
+  data.tar.gz: 47c8c77471d8aff9cc4e601f403d3f32f254658f81884075cdc25e9c4ea422cbd3ef645664fcc3524f2cfb632c2a7c3f11d1cff20451a81e17422e3fab0f4130

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_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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: HDLRuby
 version: !ruby/object:Gem::Version
-  version: 2.6.22
+  version: 2.6.23
 platform: ruby
 authors:
 - Lovic Gauthier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-24 00:00:00.000000000 Z
+date: 2021-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -151,6 +151,8 @@ files:
 - 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