HDLRuby 2.6.19 → 2.6.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 752424361455f2bd949a8f90c9802337f3ce1d853ebff6bfa44bbe25ebeda369
-  data.tar.gz: f9c2dd84c0c875c423a94211948beaea44b54bfe234c01d6f35716b7df26053c
+  metadata.gz: a207f3222cab832d2b846f9658ea0cf9426e77afd14196c2db8cb6832bd4ebda
+  data.tar.gz: 490c8a6400d6faac77cec5ab1e49caa3abd94d4d0961521ec14d485cad640b72
 SHA512:
-  metadata.gz: cc71caee7a2435e579b533b4cbba22c6bc9ca9e8e75be4e57d4a629b7a467ac28a2a302f6d53cf7552a1c1f115e17f5ec7b7648eadc482ab62bc2fdff1319cc6
-  data.tar.gz: 4053a2050e82212db5901c7cb4756b21bca3465ec9ee4d08cd2875d8b57e5c53cd05df0405e2f5b249ec96b28271f514c8707fbb43b8e69db901ff9713a9b1f4
+  metadata.gz: '08196d385fb34444cc7387f6b4982063c38e98e10e51e3b58551b0a6b62dac6921fcbb9c7a89aaccabea055ecab0d2da0543667f688d52bd7ea6b875d9db5ebd'
+  data.tar.gz: c22296c840a2a7a52b8f4bd8bc34dc38c53f571feba0a01f1bb17a2f548c2965947916fcf47b95b33f2293f1481d8b91653d855c21708a746245cebffebc72f4

data/lib/HDLRuby/hdr_samples/case_bench.rb

@@ -0,0 +1,30 @@
+# Test the comparison operators.
+
+# A benchmark for the case statement.
+system :if_bench do
+    [8].inner :x, :y
+
+    par do
+        hcase(x)
+        hwhen(0) { y <= _10000000 }
+        hwhen(1) { y <= _10000001 }
+        hwhen(2) { y <= _10000010 }
+        hwhen(3) { y <= _10000011 }
+        helse    { y <= _00000000 }
+    end
+
+    timed do
+        x <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        x <= 2
+        !10.ns
+        x <= 3
+        !10.ns
+        x <= 4
+        !10.ns
+        x <= 5
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/constant_in_function.rb

@@ -2,7 +2,7 @@
 
 
 function :func do |addr|
-    bit[4][-4].constant tbl: [ _0000, _0001, _0010, _0011 ]
+    bit[4][-4].constant tbl: [ _1000, _1001, _1010, _1011 ]
     
     tbl[addr]
 end

data/lib/HDLRuby/hdr_samples/if_bench.rb

@@ -0,0 +1,24 @@
+# Test the comparison operators.
+
+# A benchmark for the if statement.
+system :if_bench do
+    [8].inner :x, :y, :z
+
+    par do
+        hif(x == y)   { z <= 1 }
+        helsif(x < y) { z <= 2 }
+        helse         { z <= 3 }
+    end
+
+    timed do
+        x <= 0
+        y <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        y <= 2
+        !10.ns
+        x <= 2
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/index_bench.rb

@@ -0,0 +1,37 @@
+# Test the comparison operators.
+
+# A benchmark for the index access..
+system :if_bench do
+    [8].inner :x
+    inner :b0,:b1,:b2,:b3,:b4,:b5,:b6,:b7
+
+    par do
+        b0 <= x[0]
+        b1 <= x[1]
+        b2 <= x[2]
+        b3 <= x[3]
+        b4 <= x[4]
+        b5 <= x[5]
+        b6 <= x[6]
+        b7 <= x[7]
+    end
+
+    timed do
+        x <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        x <= 2
+        !10.ns
+        x <= 3
+        !10.ns
+        x <= 4
+        !10.ns
+        x <= 5
+        !10.ns
+        x[7] <= 1
+        !10.ns
+        x[6] <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/range_bench.rb

@@ -0,0 +1,47 @@
+# Test the comparison operators.
+
+# A benchmark for the index access..
+system :if_bench do
+    [8].inner :x
+    [2].inner :r0,:r1,:r2,:r3
+
+    par do
+        r0 <= x[1..0]
+        r1 <= x[3..2]
+        r2 <= x[5..4]
+        r3 <= x[7..6]
+    end
+
+    timed do
+        x <= 0
+        !10.ns
+        x <= 1
+        !10.ns
+        x <= 2
+        !10.ns
+        x <= 3
+        !10.ns
+        x <= 4
+        !10.ns
+        x <= 5
+        !10.ns
+        x <= 6
+        !10.ns
+        x <= 7
+        !10.ns
+        x <= 8
+        !10.ns
+        x <= 81
+        !10.ns
+        x <= 123
+        !10.ns
+        x <= 0
+        !10.ns
+        x[7..6] <= 3
+        !10.ns
+        x[5..4] <= 2
+        !10.ns
+        x[3..2] <= 1
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_casts.rb

@@ -0,0 +1,30 @@
+
+# A benchmark for testing the casts.
+system :with_cast do
+    [8].inner :count
+    [8].inner :val0,:val1
+    [9].inner :val2,:val3
+
+    timed do
+        val0 <= _11111111
+        val1 <= _00000010
+        val3 <= _000000000
+        count <= 0
+        !10.ns
+        count <= 1
+        val2 <= val0 + val1
+        val3 <= val3 + 1
+        !10.ns
+        count <= 2
+        val2 <= val0.as(bit[9]) + val1
+        val3 <= val3.as(bit[10]) + 1
+        !10.ns
+        count <= 3
+        val2 <= (val0 + val1).as(bit[9])
+        val3 <= (val3 + 1).as(bit[10])
+        !10.ns
+        count <= 4
+        val2 <= (val0 + val1).as(bit[8])
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_concat.rb

@@ -0,0 +1,26 @@
+
+# A benchmark for testing the concat.
+system :with_concat do
+    [8].inner :count
+    [4].inner :val0,:val1
+    [8].inner :val2
+    [12].inner :val3
+
+    val2 <= [val0,val1]
+    val3 <= [val2,val0]
+
+    timed do
+        val0 <= _1111
+        val1 <= _0000
+        count <= 0
+        !10.ns
+        val0 <= _1001
+        val1 <= _0110
+        count <= 1
+        !10.ns
+        val0 <= _1010
+        val1 <= _0101
+        count <= 2
+        !10.ns
+    end
+end

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

@@ -486,6 +486,8 @@ if $options[:syntax] then
     $output << $loader.show_all
     exit
 end
+HDLRuby.show Time.now
+HDLRuby.show "##### Starting parser #####"
 
 if $options[:debug] then
     # Debug mode, no error management.
@@ -608,26 +610,29 @@ elsif $options[:clang] then
         $outfile = File.open($hname,"w")
         # Adds the generated globals
         $top_system.each_systemT_deep do |systemT|
-            # For the h file.
-            # hname = $output + "/" +
-            #     HDLRuby::Low::Low2C.c_name(systemT.name) +
-            #     ".h"
-            # hnames << File.basename(hname)
-            # # Open the file for current systemT
-            # output = File.open(hname,"w")
+            # # For the h file.
+            # # hname = $output + "/" +
+            # #     HDLRuby::Low::Low2C.c_name(systemT.name) +
+            # #     ".h"
+            # # hnames << File.basename(hname)
+            # # # Open the file for current systemT
+            # # output = File.open(hname,"w")
             # Generate the H code in to.
-            $outfile << systemT.to_ch
-            # # Close the file.
-            # output.close
-            # # Clears the name.
-            # hname = nil
+            # $outfile << systemT.to_ch
+            systemT.to_ch($outfile)
+            # # # Close the file.
+            # # output.close
+            # # # Clears the name.
+            # # hname = nil
         end
         # Adds the globals from the non-HDLRuby code
         $non_hdlruby.each do |code|
             code.each_chunk do |chunk|
                 if chunk.name == :sim then
-                    $outfile << "extern " + 
-                        HDLRuby::Low::Low2C.prototype(chunk.to_c)
+                    # $outfile << "extern " + 
+                    #     HDLRuby::Low::Low2C.prototype(chunk.to_c)
+                    $outfile << "extern "
+                    $outfile << HDLRuby::Low::Low2C.prototype(chunk.to_c(""))
                 end
             end
         end
@@ -659,7 +664,8 @@ elsif $options[:clang] then
             # Open the file for current systemT
             outfile = File.open(name,"w")
             # Generate the C code in to.
-            outfile << systemT.to_c(0,*$hnames)
+            # outfile << systemT.to_c(0,*$hnames)
+            systemT.to_c(outfile,0,*$hnames)
             # Close the file.
             outfile.close
             # Clears the name.
@@ -668,8 +674,10 @@ elsif $options[:clang] then
     else
         # Single file generation mode.
         $top_system.each_systemT_deep.reverse_each do |systemT|
-            $output << systemT.to_ch
-            $output << systemT.to_c
+            # $output << systemT.to_ch
+            systemT.to_ch($output)
+            # $output << systemT.to_c
+            systemT.to_c($output)
         end
         # Adds the main code.
         $output << HDLRuby::Low::Low2C.main(top_system,
@@ -709,17 +717,19 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
-        HDLRuby.show "casts_without_expression! step..."
-        systemT.casts_without_expression!
-        HDLRuby.show Time.now
+        # HDLRuby.show "casts_without_expression! step..."
+        # systemT.casts_without_expression!
+        # HDLRuby.show Time.now
         HDLRuby.show "to_upper_space! step..."
         systemT.to_upper_space!
         HDLRuby.show Time.now
-        HDLRuby.show "to_global_space! step..."
-        systemT.to_global_systemTs!
-        HDLRuby.show Time.now
-        # systemT.break_types!
-        # systemT.expand_types!
+    end
+    HDLRuby.show "to_global_space! step (global)..."
+    $top_system.to_global_systemTs!
+    HDLRuby.show Time.now
+    $top_system.each_systemT_deep do |systemT|
+        ## systemT.break_types!
+        ## systemT.expand_types!
         HDLRuby.show "par_in_seq2seq! step..."
         systemT.par_in_seq2seq!
         HDLRuby.show Time.now
@@ -818,6 +828,9 @@ elsif $options[:vhdl] then
     end
 end
 
+HDLRuby.show "##### Code generated #####"
+HDLRuby.show Time.now
+
 # # Apply the post drivers if any.
 # Hdecorator.each_with_property(:post_driver) do |obj, value|
 #     # Load the driver.

data/lib/HDLRuby/hruby_high.rb

@@ -1960,6 +1960,9 @@ module HDLRuby::High
                                                          &ruby_block)
                     # ruby_block.call(*args)
                 end
+                # sub do
+                #     ruby_block.call(*args,*other_block)
+                # end
             end
         else
             define_method(name.to_sym) do |*args,&other_block|
@@ -1968,6 +1971,9 @@ module HDLRuby::High
                     HDLRuby::High.top_user.instance_exec(*args,*other_block,
                                                          &ruby_block)
                 end
+                # sub do
+                #     ruby_block.call(*args,*other_block)
+                # end
             end
         end
     end
@@ -2499,7 +2505,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_low.rb

@@ -63,6 +63,17 @@ module HDLRuby::Low
             cur = cur.parent until cur.is_a?(Scope)
             return cur
         end
+
+        # Get the full parents hierachy.
+        def hierarchy
+            res = []
+            cur = self
+            while(cur) do
+                res << cur
+                cur = cur.parent
+            end
+            return res
+        end
     end