HDLRuby 2.11.11 → 3.0.0

data/lib/HDLRuby/hdr_samples/with_sequencer_enumerator.rb

@@ -0,0 +1,89 @@
+require 'std/sequencer.rb'
+
+include HDLRuby::High::Std
+
+# Checking the creation of sequencers enumerators.
+# - The first sequencer checks enumerators on signals.
+# - The second sequencer checks enumerators on ranges.
+# - The third sequencer checks enumerators on arrays.
+# - The fourth sequencer checks custom enumerators.
+system :my_seqencer do
+
+    inner :clk,:rst
+
+    bit[8][-8].inner vals: [ _h01, _h02, _h03, _h04, _h10, _h20, _h30, _h40 ]
+
+    [8].inner :res0, :res1
+
+    sequencer(clk.posedge,rst) do
+        hprint("#0\n")
+        res0 <= 0
+        res1 <= 0
+        res0 <= vals.ssum
+        res1 <= res0.ssum(_h00)
+        hprint("#1 res0=",res0," res1=",res1,"\n")
+    end
+
+    [8].inner :res2, :res3
+
+    sequencer(clk.posedge,rst) do
+        hprint("$0\n")
+        res2 <= 0
+        res3 <= 0
+        res2 <= (1..5).sum
+        res3 <= (res3..res2).ssum
+        hprint("$1 res2=",res2," res3=",res3,"\n")
+    end
+
+    [8].inner :res4, :res5
+
+    sequencer(clk.posedge,rst) do
+        hprint("!0\n")
+        res4 <= 0
+        res5 <= 0
+        res4 <= [_h01,_h02,_h03,_h04].ssum
+        res5 <= [1,2,3,4,5].ssum
+        hprint("!1 res4=",res4," res5=",res5,"\n")
+    end
+
+    bit[8][-8].inner mem: [ _h01, _h02, _h03, _h04, _h30, _h30, _h30, _h30 ]
+
+    [8].inner :res6, :addr, :data
+
+    data <= mem[addr]
+
+    mem_enum = senumerator(bit[8],8) do |i|
+        addr <= i
+        step
+        data
+    end
+
+    sequencer(clk.posedge,rst) do
+        hprint("~0\n")
+        res6 <= 0
+        res6 <= mem_enum.ssum
+        hprint("~1 res6=",res6,"\n")
+    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(100) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_sequencer_sync.rb

@@ -0,0 +1,120 @@
+require 'std/sequencer_sync.rb'
+
+include HDLRuby::High::Std
+
+# Checking the usage of sequencers with synchronizarion.
+system :my_seqencer do
+
+    inner :clk,:rst
+
+    [8].inner :res0, :res1
+    [8].shared(x0: _hFF,x1: _hFF)
+
+    arbiter(:arbiter0).(x1)
+
+    par(clk.posedge) do
+        x0.select <= x0.select + 1
+    end
+
+    sequencer(clk.posedge,rst) do
+        sloop do
+            res0 <= x0 * 2
+            res1 <= x1 * 2
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        10.stimes do |i|
+            x0 <= i
+            x1 <= i
+            arbiter0 <= 1
+        end
+        arbiter0 <= 0
+    end
+
+    sequencer(clk.posedge,rst) do
+        10.stimes do |i|
+            x0 <= 10-i
+            x1 <= 10-i
+            arbiter0 <= 1
+            step
+        end
+        arbiter0 <= 0
+    end
+
+    sequencer(clk.posedge,rst) do
+        10.stimes do |i|
+            step
+            arbiter0 <= 1
+            x0 <= 128+i
+            x1 <= 128+i
+            step
+            arbiter0 <= 0
+        end
+    end
+
+
+
+    [8].inner :res2, :res20, :res21, :res22
+    [8].shared x2: _hFF 
+
+    monitor(:monitor0).(x2)
+
+    sequencer(clk.posedge,rst) do
+        sloop do
+            res2 <= x2 * 2
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        x2 <= 0
+        monitor0.lock
+        4.stimes do |i|
+            res20 <= res2
+            x2 <= i + 1
+        end
+        res20 <= res2
+        monitor0.unlock
+    end
+
+    sequencer(clk.posedge,rst) do
+        5.stimes do |i|
+            x2 <= 16 + i
+            monitor0.lock
+            res21 <= res2
+            monitor0.unlock
+        end
+    end
+
+    sequencer(clk.posedge,rst) do
+        5.stimes do |i|
+            x2 <= 32 + i
+            monitor0.lock
+            res22 <= res2
+            step
+            monitor0.unlock
+        end
+    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(100) do
+            !10.ns
+            clk <= ~clk
+        end
+    end
+end

data/lib/HDLRuby/hdr_samples/with_subsums.rb

@@ -20,13 +20,13 @@ system :with_concat do
     val6 <= bs.reduce(:+)
 
     timed do
-        val0 <= _1111000011110000
+        val0 <= _b1111000011110000
         count <= 0
         !10.ns
-        val0 <= _0000111100001111
+        val0 <= _b0000111100001111
         count <= 1
         !10.ns
-        val0 <= _1010101010101010
+        val0 <= _b1010101010101010
         count <= 2
         !10.ns
     end

data/lib/HDLRuby/hdr_samples/with_terminate.rb

@@ -2,9 +2,9 @@
 # A benchmark for testing the terminate statement.
 system :with_terminate do
     [8].constant cst0: 127
-    constant cst1: _1
-    [8].inner sig0: _10000000
-    inner sig1: _1
+    constant cst1: _b1
+    [8].inner sig0: _b10000000
+    inner sig1: _b1
     [8].inner :sig2
     [8].inner count: 0
 

data/lib/HDLRuby/hdr_samples/with_to_a.rb

@@ -52,26 +52,26 @@ system :with_to_a_bench do
     four2sixfour(:my_four2sixfour).(four,*(sixfour.to_a.reverse))
 
     timed do
-        val <= _01101010
+        val <= _b01101010
         res <= vals.reverse
         !10.ns
-        val64 <= _0110101001101010011010100110101001101010011010100110101001101010
+        val64 <= _b0110101001101010011010100110101001101010011010100110101001101010
         res64 <= val64s.reverse
         !10.ns
-        val <= _00000000
-        val64 <= _0000000000000000000000000000000000000000000000000000000000000000
+        val <= _b00000000
+        val64 <= _b0000000000000000000000000000000000000000000000000000000000000000
         !10.ns
         vals.each.with_index do |v,i|
-            v <= (i/2) & _1
+            v <= (i/2) & _b1
         end
         res <= val
         !10.ns
         val64s.each.with_index do |v,i|
-            v <= (i/2) & _1
+            v <= (i/2) & _b1
         end
         res64 <= val64
         !10.ns
-        val <= _01010011
+        val <= _b01010011
         !10.ns
         8.times do |i|
             val64s[i] <= val[i]
@@ -80,11 +80,11 @@ system :with_to_a_bench do
         end
         res64 <= val64
         !10.ns
-        four <= _0000
+        four <= _b0000
         !10.ns
-        four <= _0001
+        four <= _b0001
         !10.ns
-        four <= _1100
+        four <= _b1100
         !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_values.rb

@@ -11,7 +11,7 @@ system :with_values do
 
 
     timed do
-        v1  <= 0
+        v1  <= _b0
         v8  <= 0
         v16 <= 0
         v32 <= 0
@@ -19,7 +19,7 @@ system :with_values do
         v64 <= 0
         v96 <= 0
         !10.ns
-        v1  <= 1
+        v1  <= _b1
         v8  <= 1
         v16 <= 1
         v32 <= 1
@@ -27,7 +27,7 @@ system :with_values do
         v64 <= 1
         v96 <= 1
         !10.ns
-        v1  <= _1010[2]
+        v1  <= _b1010[2]
         v8  <= _uhFF00[12..4]
         !10.ns
         v8  <= 128

data/lib/HDLRuby/hdrcc.rb

@@ -60,6 +60,7 @@ require 'HDLRuby/hruby_check.rb'
 require 'HDLRuby/hruby_low2hdr'
 require 'HDLRuby/hruby_low2c'
 require 'HDLRuby/hruby_low2vhd'
+require 'HDLRuby/hruby_low_without_subsignals'
 require 'HDLRuby/hruby_low_fix_types'
 # require 'HDLRuby/hruby_low_expand_types' # For now dormant
 require 'HDLRuby/hruby_low_without_outread'
@@ -262,6 +263,9 @@ module HDLRuby
             # Initialize the environment for processing the hdr file.
             bind = TOPLEVEL_BINDING.clone
             eval("require 'HDLRuby'\n\nconfigure_high\n\n",bind)
+            if $options[:std] then
+                eval("require 'std/std.rb'\n\ninclude HDLRuby::High::Std\n\n",bind)
+            end
             # Process it.
             eval(@texts[0],bind,@top_file_name,1)
             # Get the resulting instance
@@ -279,8 +283,8 @@ module HDLRuby
     end
 
 
-    # Extend the Code class with generation of file for the content.
     class HDLRuby::Low::Code
+        ## Extends the Code class with generation of file for the content.
 
         ## Creates a file in +path+ containing the content of the code.
         def to_file(path = "")
@@ -336,6 +340,9 @@ end
 require 'optparse'
 # Process the command line options
 $options = {}
+# By default the std libraries are loaded.
+$options[:std] = true
+# Parse the options
 $optparse = OptionParser.new do |opts|
     opts.banner = "Usage: hdrcc.rb [options] <input file> [<output directory or file>]"
 
@@ -434,6 +441,9 @@ $optparse = OptionParser.new do |opts|
     opts.on("--testall","Compile all the available unit tests.") do |t|
         $options[:testall] = t
     end
+    opts.on("--no-std", "Compile without the standard library.") do |t|
+        $options[:std] = false
+    end
     opts.on("-t", "--top system", "Specify the top system to process") do|t|
         $options[:top] = t
     end
@@ -444,7 +454,11 @@ $optparse = OptionParser.new do |opts|
         $options[:dump] = v
         $options[:multiple] = v
     end
-    opts.on("--version", "Shows the version of HDLRuby.") do |v|
+    opts.on("--get-samples", "Copy the sample directory (hdr_samples) to current one, the exit") do
+        FileUtils.copy_entry(File.dirname(__FILE__) + "/hdr_samples","./hdr_samples")
+        exit
+    end
+    opts.on("--version", "Show the version of HDLRuby, then exit") do |v|
         puts VERSION
         exit
     end
@@ -641,8 +655,12 @@ elsif $options[:clang] then
     # top_system = $top_system
     # Preprocess the HW description for valid C generation.
     $top_system.each_systemT_deep do |systemT|
+        HDLRuby.show? "signal2subs step..."
+        # Ensure there is not implicit assign to sub signals.
+        systemT.signal2subs!
+        HDLRuby.show? "#{Time.now}#{show_mem}"
         HDLRuby.show? "seq2seq step..."
-        # Coverts the par blocks in seq blocks to seq blocks to match
+        # Converts the par blocks in seq blocks to seq blocks to match
         # the simulation engine.
         systemT.par_in_seq2seq!
         HDLRuby.show? "#{Time.now}#{show_mem}"
@@ -801,6 +819,9 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
+        HDLRuby.show? "signal2subs step..."
+        # Ensure there is not implicit assign to sub signals.
+        systemT.signal2subs!
         # HDLRuby.show "casts_without_expression! step..."
         # systemT.casts_without_expression!
         # HDLRuby.show Time.now
@@ -889,6 +910,8 @@ elsif $options[:rcsim] then
     require 'HDLRuby/hruby_rcsim.rb'
     # Merge the included from the top system.
     $top_system.merge_included!
+    # Process par in seq.
+    $top_system.par_in_seq2seq!
     # Generate the C data structures.
     $top_system.to_rcsim
     HDLRuby.show "Executing the hybrid C-Ruby-level simulator..."
@@ -902,6 +925,9 @@ elsif $options[:vhdl] then
     # top_system = $top_system
     # Make description compatible with vhdl generation.
     $top_system.each_systemT_deep do |systemT|
+        HDLRuby.show? "signal2subs step..."
+        # Ensure there is not implicit assign to sub signals.
+        systemT.signal2subs!
         systemT.outread2inner!            unless $options[:vhdl08] || $options[:alliance]
         systemT.with_boolean!
         systemT.boolean_in_assign2select! unless $options[:alliance]

data/lib/HDLRuby/hdrlib.rb

@@ -226,8 +226,8 @@ module HDLRuby
     end
 
 
-    # Extend the Code class with generation of file for the content.
     class HDLRuby::Low::Code
+        ## Extends the Code class with generation of file for the content.
 
         ## Creates a file in +path+ containing the content of the code.
         def to_file(path = "")

data/lib/HDLRuby/hruby_bstr.rb

@@ -225,6 +225,7 @@ module HDLRuby
         #       * when index is larger than the bit width, the bit string is
         #         X extended accordingly.
         def []=(index,value)
+            # puts "first @content=#{@content}"
             # Change inside the bit string, it is not know any longer if it
             # is specified or not
             @specified = nil
@@ -250,8 +251,8 @@ module HDLRuby
                     sign = @content[-1]
                     @content.concat([sign] * (right-@content.size+1))
                 end
+                # puts "left=#{left} right=#{right} sign=#{sign} @content=#{@content}"
                 if right >= left then
-                    # puts "left=#{left} right=#{right} value=#{value} (#{value.class})"
                     # Sets the value to a copy of the bit string.
                     @content[left..right] = value.is_a?(BitString) ?
                         value.raw_content[0..right-left] : 
@@ -412,10 +413,14 @@ module HDLRuby
             return @specified
         end
 
-        # # Coerces.
-        # def coerce(other)
-        #     return [BitString.new(other),self]
-        # end
+        # Coerces.
+        def coerce(other)
+            if other.is_a?(Numeric) && self.specified? then
+                return [other,self.to_i]
+            else
+                return [BitString.new(other),self]
+            end
+        end
 
         # String conversion table.
         B2S_T = [ "0", "1", "z", "x" ]

data/lib/HDLRuby/hruby_db.rb

@@ -9,7 +9,7 @@ warn "hruby_db.rb (former hruby_low.rb) is deprecated."
 ##
 # Low-level libraries for describing digital hardware.        
 #######################################################
-module HDLRuby::Low
+module HDLRuby::LowDB
 
     Base = HDLRuby::Base
 
@@ -151,7 +151,7 @@ module HDLRuby::Low
     end
 
     ##
-    # Describes a unsigned integer data type.
+    # Describes an unsigned integer data type.
     class TypeUnsigned < Base::TypeUnsigned
         include Ltype
     end