HDLRuby 3.9.1 → 3.9.3

data/lib/HDLRuby/hdr_samples/with_henumerable.rb

@@ -35,360 +35,383 @@ include HDLRuby::High::Std
 # - The thirtieth check is for suniq
 # - The thirty first check is for hzip
 #
-# - The remaing checks the enumerators apply on values directly.
+# - The remaining checks the enumerators apply on values directly.
+# - The second remaining checks the brak and next statements.
 #
- 
+
 system :henmerable_checks do
 
-    inner :clk,:rst
+  inner :clk,:rst
 
-    bit[8][-8].inner vals: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44 ]
-    rvals = 8.times.to_a.reverse
+  bit[8][-8].inner vals: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44 ]
+  rvals = 8.times.to_a.reverse
 
-    [16].inner :res0, :res1, :res2, :res3
+  [16].inner :res0, :res1, :res2, :res3
 
-    res0 <= vals.hall? { |val| val != _h11 }
-    res1 <= vals.hall? { |val| val != _h5C }
+  res0 <= vals.hall? { |val| val != _h11 }
+  res1 <= vals.hall? { |val| val != _h5C }
 
-    par(clk.posedge) do
-      # hprint("#0\n")
-      res2 <= rvals.hall? { |val| val.to_expr != 11 }
-      res3 <= rvals.hall? { |val| val.to_expr != 4 }
-      # hprint("#1 res0=",res0," res1=",res1," res2=",res2," res3=",res3,"\n")
-    end
+  par(clk.posedge) do
+    # hprint("#0\n")
+    res2 <= rvals.hall? { |val| val.to_expr != 11 }
+    res3 <= rvals.hall? { |val| val.to_expr != 4 }
+    # hprint("#1 res0=",res0," res1=",res1," res2=",res2," res3=",res3,"\n")
+  end
 
-    [16].inner :res4, :res5, :res6, :res7
+  [16].inner :res4, :res5, :res6, :res7
 
-    res4 <= vals.hany? { |val| val == _h11 }
-    res5 <= vals.hany? { |val| val == _h5C }
+  res4 <= vals.hany? { |val| val == _h11 }
+  res5 <= vals.hany? { |val| val == _h5C }
 
-    par(clk.posedge) do
-        # hprint("$0\n")
-        res6 <= rvals.hany? { |val| val == 11 }
-        res7 <= rvals.hany? { |val| val == 4 }
-        # hprint("#1 res4=",res4," res5=",res5," res6=",res6," res7=",res7,"\n")
-    end
+  par(clk.posedge) do
+    # hprint("$0\n")
+    res6 <= rvals.hany? { |val| val == 11 }
+    res7 <= rvals.hany? { |val| val == 4 }
+    # hprint("#1 res4=",res4," res5=",res5," res6=",res6," res7=",res7,"\n")
+  end
 
-    [16].inner :res8, :res9, :res10, :res11
+  [16].inner :res8, :res9, :res10, :res11
 
-    res8 <= vals.hchain(0..10).hany? { |val| val.as(bit[8]) == _h11 }
-    res9 <= vals.hchain(0..10).hany? { |val| val.as(bit[8]) == _h05 }
+  res8 <= vals.hchain(0..10).hany? { |val| val.as(bit[8]) == _h11 }
+  res9 <= vals.hchain(0..10).hany? { |val| val.as(bit[8]) == _h05 }
 
-    par(clk.posedge) do
-      # hprint("!0\n")
-      res10 <= rvals.hchain(vals).hany? { |val| val.as(bit[8]) == _h11 }
-      res11 <= rvals.hchain(vals).hany? { |val| val.as(bit[8]) == _h04 }
-    end
+  par(clk.posedge) do
+    # hprint("!0\n")
+    res10 <= rvals.hchain(vals).hany? { |val| val.as(bit[8]) == _h11 }
+    res11 <= rvals.hchain(vals).hany? { |val| val.as(bit[8]) == _h04 }
+  end
 
-    bit[8][-8].inner :res12, :res13
+  bit[8][-8].inner :res12, :res13
 
-    res12 <= vals.hmap { |val| val + 1 }
+  res12 <= vals.hmap { |val| val + 1 }
 
-    par(clk.posedge) do
-      # hprint("%0\n");
-      res13 <= vals.hmap { |val| val + 1 }
-    end
+  par(clk.posedge) do
+    # hprint("%0\n");
+    res13 <= vals.hmap { |val| val + 1 }
+  end
 
-    bit[8][-8].inner :res14, :res15
+  bit[8][-8].inner :res14, :res15
 
-    res14 <= vals.hmap.hwith_index { |val,i| val + i }
+  res14 <= vals.hmap.hwith_index { |val,i| val + i }
 
-    par(clk.posedge) do
-      # hprint("&0\n");
-      res15 <= vals.hmap.hwith_index { |val,i| val + i }
-    end
+  par(clk.posedge) do
+    # hprint("&0\n");
+    res15 <= vals.hmap.hwith_index { |val,i| val + i }
+  end
 
-    bit[8][-8].inner vals2: [ _h00, _h10, _h00, _h0B, _hFE, _h00, _h5C, _h00 ]
-    # bit[8][-8].inner :res16, :res17
+  bit[8][-8].inner vals2: [ _h00, _h10, _h00, _h0B, _hFE, _h00, _h5C, _h00 ]
+  # bit[8][-8].inner :res16, :res17
 
-    # res16 <= vals2.hcompact
+  # res16 <= vals2.hcompact
 
-    # sequencer(clk.posedge,rst) do
-    #   # hprint("|0\n");
-    #   res17 <= vals2.hcompact
-    # end
+  # sequencer(clk.posedge,rst) do
+  #   # hprint("|0\n");
+  #   res17 <= vals2.hcompact
+  # end
 
-    [8].inner :res18, :res19, :res20
+  [8].inner :res18, :res19, :res20
 
-    res18 <= vals2.hcount
-    res19 <= vals2.hcount(_h00)
+  res18 <= vals2.hcount
+  res19 <= vals2.hcount(_h00)
 
-    par(clk.posedge) do
-      # hprint("(0\n");
-      res20 <= vals2.hcount {|elem| elem > _h10 }
-    end
+  par(clk.posedge) do
+    # hprint("(0\n");
+    res20 <= vals2.hcount {|elem| elem > _h10 }
+  end
 
-    # [8].inner :res21, :res22
+  # [8].inner :res21, :res22
 
-    # vals.hcycle(2) { |elem| res21 <= elem }
+  # vals.hcycle(2) { |elem| res21 <= elem }
 
-    # par(clk.posedge) do
-    #   # hprint(")0\n")
-    #   vals2.hcycle { |elem| res22 <= elem }
-    # end
+  # par(clk.posedge) do
+  #   # hprint(")0\n")
+  #   vals2.hcycle { |elem| res22 <= elem }
+  # end
 
-    [8].inner :res23, :res24
+  [8].inner :res23, :res24
 
-    res23 <= vals.hfind(proc {-1}) { |elem| elem > 0 }
+  res23 <= vals.hfind(proc {-1}) { |elem| elem > 0 }
 
-    par(clk.posedge) do
-      # hprint("=0\n")
-      res24 <= vals.hfind(proc {-1}) { |elem| elem == _hAA }
-    end
+  par(clk.posedge) do
+    # hprint("=0\n")
+    res24 <= vals.hfind(proc {-1}) { |elem| elem == _hAA }
+  end
 
-    bit[8][-8].inner :res25 #, :res26
-    
-    res25 <= vals.hdrop(3)
+  bit[8][-8].inner :res25 #, :res26
 
-    # par(clk.posedge) do
-    #   # hprint("+0\n")
-    #   res26 <= vals.hdrop_while { |elem| elem < _hAA }
-    # end
+  res25 <= vals.hdrop(3)
 
-    bit[8][-8].inner :res27
+  # par(clk.posedge) do
+  #   # hprint("+0\n")
+  #   res26 <= vals.hdrop_while { |elem| elem < _hAA }
+  # end
 
-    par(clk.posedge) do
-      # hprint("*0\n")
-      vals.heach_cons(3).hwith_index { |(a,b,c),i| res27[i] <= a+b+c }
-    end
+  bit[8][-8].inner :res27
+
+  par(clk.posedge) do
+    # hprint("*0\n")
+    vals.heach_cons(3).hwith_index { |(a,b,c),i| res27[i] <= a+b+c }
+  end
 
-    bit[8][-8].inner :res28
-    
-    par(clk.posedge) do
-      # hprint("/0\n")
-      vals.heach_slice(3).hwith_index do |(a,b,c),i| 
-        if c then
-          res28[i] <= a+b+c
-        elsif b then
-          res28[i] <= a+b
-        else
-          res28[i] <= a
-        end
+  bit[8][-8].inner :res28
+
+  par(clk.posedge) do
+    # hprint("/0\n")
+    vals.heach_slice(3).hwith_index do |(a,b,c),i| 
+      if c then
+        res28[i] <= a+b+c
+      elsif b then
+        res28[i] <= a+b
+      else
+        res28[i] <= a
       end
     end
+  end
 
-    bit[32][-4].inner :res29
-    
-    par(clk.posedge) do
-      # hprint("~0\n")
-      res29 <= (_h00000001.._h00000004).heach.hto_a
-    end
+  bit[32][-4].inner :res29
 
-    [8].inner :res30, :res31, :res31x
+  par(clk.posedge) do
+    # hprint("~0\n")
+    res29 <= (_h00000001.._h00000004).heach.hto_a
+  end
 
-    res30 <= vals.hfind_index(_h0B)
-    
-    par(clk.posedge) do
-      # hprint(">0\n")
-      res31 <= vals.hfind_index { |elem| elem < _hAA }
-      res31x <= vals.hfind_index { |elem| elem == _hAA }
-    end
+  [8].inner :res30, :res31, :res31x
 
-    bit[8][-4].inner :res32
-    
-    par(clk.posedge) do
-      # hprint("<0\n")
-      res32 <= vals.hfirst(4)
-    end
+  res30 <= vals.hfind_index(_h0B)
 
-    inner :res33, :res34
+  par(clk.posedge) do
+    # hprint(">0\n")
+    res31 <= vals.hfind_index { |elem| elem < _hAA }
+    res31x <= vals.hfind_index { |elem| elem == _hAA }
+  end
 
-    res33 <= vals.hinclude?(_h0B)
-    
-    par(clk.posedge) do
-      # hprint("!0\n")
-      res34 <= vals.hinclude?(_hAA)
-    end
+  bit[8][-4].inner :res32
 
-    [8].inner :res35, :res36
-    [7].inner :res35X, :res36X
+  par(clk.posedge) do
+    # hprint("<0\n")
+    res32 <= vals.hfirst(4)
+  end
 
-    res35 <= vals.hinject(_h01) { |a,b| a+b }
+  inner :res33, :res34
 
-    res35X <= vals.hinject(bit[4]) { |a,b| a+b }
+  res33 <= vals.hinclude?(_h0B)
 
-    par(clk.posedge) do
-      # hprint(":0\n")
-      res36 <= vals.(:+)
-      res36X <= vals.(bit[4],:+)
-    end
+  par(clk.posedge) do
+    # hprint("!0\n")
+    res34 <= vals.hinclude?(_hAA)
+  end
 
-    [8].inner :res37
-    bit[8][-3].inner :res38
+  [8].inner :res35, :res36
+  [7].inner :res35X, :res36X
 
-    res37 <= vals.hmax
+  res35 <= vals.hinject(_h01) { |a,b| a+b }
 
-    par(clk.posedge) do
-      # hprint(";0\n")
-      # res38 <= vals.hmax(3)
-      res38 <= vals.hmax(1)
-    end
+  res35X <= vals.hinject(bit[4]) { |a,b| a+b }
 
-    [8].inner :res39
-    # bit[8][-3].inner :res40
-    [8].inner :res40
+  par(clk.posedge) do
+    # hprint(":0\n")
+    res36 <= vals.(:+)
+    res36X <= vals.(bit[4],:+)
+  end
 
-    res39 <= vals.hmax_by {|e| e.to_signed }
+  [8].inner :res37
+  bit[8][-3].inner :res38
 
-    par(clk.posedge) do
-      # hprint(",0\n")
-      # res40 <= vals.hmax_by(3) {|e| e.to_signed }
-      res40 <= vals.hmax_by(1) {|e| e.to_signed }
-    end
+  res37 <= vals.hmax
 
-    [8].inner :res41
-    bit[8][-3].inner :res42
+  par(clk.posedge) do
+    # hprint(";0\n")
+    # res38 <= vals.hmax(3)
+    res38 <= vals.hmax(1)
+  end
 
-    res41 <= vals.hmin
+  [8].inner :res39
+  # bit[8][-3].inner :res40
+  [8].inner :res40
 
-    par(clk.posedge) do
-      # hprint(".0\n")
-      # res42 <= vals.hmin(3)
-      res42 <= vals.hmin(1)
-    end
+  res39 <= vals.hmax_by {|e| e.to_signed }
 
-    [8].inner :res43
-    bit[8][-3].inner :res44
+  par(clk.posedge) do
+    # hprint(",0\n")
+    # res40 <= vals.hmax_by(3) {|e| e.to_signed }
+    res40 <= vals.hmax_by(1) {|e| e.to_signed }
+  end
 
-    res43 <= vals.hmin_by {|e| e.to_signed }
+  [8].inner :res41
+  bit[8][-3].inner :res42
 
-    par(clk.posedge) do
-      # hprint(":0\n")
-      # res44 <= vals.hmin_by(3) {|e| e.to_signed }
-      res44 <= vals.hmin_by(1) {|e| e.to_signed }
-    end
+  res41 <= vals.hmin
 
-    [16].inner :res45, :res46
+  par(clk.posedge) do
+    # hprint(".0\n")
+    # res42 <= vals.hmin(3)
+    res42 <= vals.hmin(1)
+  end
 
-    res45 <= vals.hminmax
+  [8].inner :res43
+  bit[8][-3].inner :res44
 
-    par(clk.posedge) do
-      # hprint("]0\n")
-      res46 <= vals.hminmax_by {|e| e.to_signed }
-    end
+  res43 <= vals.hmin_by {|e| e.to_signed }
 
-    [8].inner :res47, :res48
+  par(clk.posedge) do
+    # hprint(":0\n")
+    # res44 <= vals.hmin_by(3) {|e| e.to_signed }
+    res44 <= vals.hmin_by(1) {|e| e.to_signed }
+  end
 
-    res47 <= vals.hnone? { |val| val == _h11 }
+  [16].inner :res45, :res46
 
-    par(clk.posedge) do
-      # hprint("[0\n")
-      res48 <= vals.hnone?(_h5C)
-    end
+  res45 <= vals.hminmax
 
-    [8].inner :res49, :res50, :res51
+  par(clk.posedge) do
+    # hprint("]0\n")
+    res46 <= vals.hminmax_by {|e| e.to_signed }
+  end
 
-    res49 <= vals.hone?(_h5C)
+  [8].inner :res47, :res48
 
-    par(clk.posedge) do
-      # hprint("[0\n")
-      res50 <= vals.hone? { |val| val == _h11 }
-      res51 <= vals2.hone? { |val| val == _h00 }
-    end
+  res47 <= vals.hnone? { |val| val == _h11 }
 
-    bit[8][-6].inner :res52
+  par(clk.posedge) do
+    # hprint("[0\n")
+    res48 <= vals.hnone?(_h5C)
+  end
 
-    par(clk.posedge) do
-        # hprint("_0\n")
-      (5..10).hreverse_each.hwith_index { |val,i| res52[i] <= val }
-    end
+  [8].inner :res49, :res50, :res51
 
-    bit[8][-10].inner :res53X, :res54X
-    bit[8][-8].inner :res53, :res54
-    bit[8][-10].inner valsX: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44, _h01, _h82 ]
+  res49 <= vals.hone?(_h5C)
 
-    res53  <= vals.hsort
-    res54  <= vals.hsort_by { |val| val.to_signed }
+  par(clk.posedge) do
+    # hprint("[0\n")
+    res50 <= vals.hone? { |val| val == _h11 }
+    res51 <= vals2.hone? { |val| val == _h00 }
+  end
 
-    seq(clk.posedge) do
-      # hprint("@0\n")
-      res53X <= valsX.hsort
-      res54X <= valsX.hsort_by(_h7F) { |val| val.to_signed }
-    end
+  bit[8][-6].inner :res52
 
-    [8].inner :res55, :res56
+  par(clk.posedge) do
+    # hprint("_0\n")
+    (5..10).hreverse_each.hwith_index { |val,i| res52[i] <= val }
+  end
 
-    res55 <= vals.hsum
+  bit[8][-10].inner :res53X, :res54X
+  bit[8][-8].inner :res53, :res54
+  bit[8][-10].inner valsX: [ _h00, _h10, _hA5, _h0B, _hFE, _h34, _h5C, _h44, _h01, _h82 ]
 
-    par(clk.posedge) do
-      # hprint("`0\n")
-      res56 <= vals.hsum { |val| val & _h0F }
-    end
+  res53  <= vals.hsort
+  res54  <= vals.hsort_by { |val| val.to_signed }
 
-    bit[8][-3].inner :res57
-    # bit[8][-8].inner :res58
+  seq(clk.posedge) do
+    # hprint("@0\n")
+    res53X <= valsX.hsort
+    res54X <= valsX.hsort_by(_h7F) { |val| val.to_signed }
+  end
 
-    res57 <= vals.htake(3)
+  [8].inner :res55, :res56
 
-    # par(clk.posedge) do
-    #   # hprint("`0\n")
-    #   res58 <= vals.htake_while { |val| val < _hAA }
-    # end
+  res55 <= vals.hsum
 
-    bit[8][-8].inner vals3: [ _hFE, _h10, _hA5, _h10, _hFE, _h34, _h5C, _h10 ]
+  par(clk.posedge) do
+    # hprint("`0\n")
+    res56 <= vals.hsum { |val| val & _h0F }
+  end
 
-    # bit[8][-8].inner :res59,:res60
+  bit[8][-3].inner :res57
+  # bit[8][-8].inner :res58
 
-    # res59 <= vals3.huniq
+  res57 <= vals.htake(3)
 
-    # # par(clk.posedge) do
-    # #   # hprint("~0\n")
-    # #   res60 <= vals.huniq { |val| val & _h0F }
-    # # end
+  # par(clk.posedge) do
+  #   # hprint("`0\n")
+  #   res58 <= vals.htake_while { |val| val < _hAA }
+  # end
 
-    bit[8][-8].inner :res61
-    bit[8][-8].inner :res62
+  bit[8][-8].inner vals3: [ _hFE, _h10, _hA5, _h10, _hFE, _h34, _h5C, _h10 ]
 
-    res61 <= vals.hzip((1..6).to_a.map {|i| i.to_expr.as(bit[8]) })
+  # bit[8][-8].inner :res59,:res60
 
-    par(clk.posedge) do
-      # hprint("}0\n")
-      vals.hzip([_h12]*8).each_with_index { |(a,b),i| res62[i] <= a+b }
-    end
+  # res59 <= vals3.huniq
 
-    # Test enumerators of values.
-    inner :res63, :res64, :res65
+  # # par(clk.posedge) do
+  # #   # hprint("~0\n")
+  # #   res60 <= vals.huniq { |val| val & _h0F }
+  # # end
 
-    res63 <= _b0101011.(:|)
-    res64 <= _b0101011.(:^)
-    res65 <= _b0101011.(:&)
+  bit[8][-8].inner :res61
+  bit[8][-8].inner :res62
 
-    [8].inner :res66
+  res61 <= vals.hzip((1..6).to_a.map {|i| i.to_expr.as(bit[8]) })
 
-    res66 <= [_h01, _h02, _h03, _h04].(:+)
+  par(clk.posedge) do
+    # hprint("}0\n")
+    vals.hzip([_h12]*8).each_with_index { |(a,b),i| res62[i] <= a+b }
+  end
 
+  # Test enumerators of values.
+  inner :res63, :res64, :res65
 
-    # Test signal declarations within iterator block.
-    vals.heach do |v,i|
-      inner :sig
-      sig <= v[0]
-    end
+  res63 <= _b0101011.(:|)
+  res64 <= _b0101011.(:^)
+  res65 <= _b0101011.(:&)
 
-    [_h0001, _h0002, _h0003].heach.hwith_index do |v,i|
-      [16].inner :sig
-      sig <= v + i
-    end
+  [8].inner :res66
+
+  res66 <= [_h01, _h02, _h03, _h04].(:+)
 
 
+  # Test signal declarations within iterator block.
+  vals.heach do |v,i|
+    inner :sig
+    sig <= v[0]
+  end
+
+  [_h0001, _h0002, _h0003].heach.hwith_index do |v,i|
+    [16].inner :sig
+    sig <= v + i
+  end
 
-    timed do
-        clk <= 0
-        rst <= 0
-        !10.ns
-        clk <= 1
-        !10.ns
-        clk <= 0
-        rst <= 1
-        !10.ns
-        clk <= 1
-        !10.ns
-        clk <= 0
-        rst <= 0
-        !10.ns
-        clk <= 1
-        repeat(500) do
-            !10.ns
-            clk <= ~clk
-        end
+  [8].inner :bcount
+
+  # looping = true
+  # vals.heach_with_index do |v,i|
+  #   if looping then
+  #     looping = false
+  #     catch(:HDLRubyThrow) do
+  #       bcount <= i
+  #       # hif(v > 10) { hbreak }
+  #       # hif(i > 2) { throw(:HDLRubyThrow) }
+  #       hif(i > 2) { hbreak }
+  #       looping = true
+  #     end
+  #   end
+  # end
+
+  vals.heach_with_index do |v,i|
+    bcount <= i
+    # hif(v > 10) { hbreak }
+    # hif(i > 2) { throw(:HDLRubyThrow) }
+    hif(i > 2) { hbreak }
+  end
+
+
+  timed do
+    clk <= 0
+    rst <= 0
+    !10.ns
+    clk <= 1
+    !10.ns
+    clk <= 0
+    rst <= 1
+    !10.ns
+    clk <= 1
+    !10.ns
+    clk <= 0
+    rst <= 0
+    !10.ns
+    clk <= 1
+    repeat(500) do
+      !10.ns
+      clk <= ~clk
     end
+  end
 end

data/lib/HDLRuby/hdr_samples/with_to_svg.rb

@@ -0,0 +1,37 @@
+# Sample for testing SVG generation.
+
+system :somemodule do
+  [8].input :x, :y
+  [8].output :z
+  [8].inner :tmp
+
+  tmp <= x + y
+
+  z <= tmp * 2
+end
+
+
+system :show_components do
+  input :clk
+  [8].input :x0, :y0, :x1, :y1, :x2, :y2, :x3, :y3
+  [8].output :z0, :z1, :z2
+
+  [8].inner :sig
+  bit[8][-8].inner :mem
+
+
+  somemodule(:instance).(x0,y0,z0)
+
+  sig[6..0] <= x3[6..0] & y3[6..0]
+  sig[7] <= x3[7] & y3[7]
+
+  seq do
+    z1 <= x1 | y1 | mem[sig]
+  end
+
+  par(clk.posedge) do
+    z2 <= x2 - y2
+  end
+
+end
+