HDLRuby 2.4.21 → 2.4.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28c1956d124429de349aede3dce3644cca530400479dedb09bedc3326a1fdb76
-  data.tar.gz: cd76438901da8bff407b7db4abef07399192c19f0349af0c9e0e545a1a22cf1d
+  metadata.gz: ad6c03f726ed838a4d5456f41c4b0f295e4ca7d10ca8585ee8f8c011f7f2fd23
+  data.tar.gz: a59727e177be4d5ff3eb740d210fad37bd4ba9ea6296a8cfed84495a7122411d
 SHA512:
-  metadata.gz: 89ccd495fa050a3f552ea73e52f726a08f56f5a937691209622a4d008a62905134d3a4765265ee07ff4c8aca59bc097221d4f75fc9da445ba3115fe6aee293ea
-  data.tar.gz: 47150e816409de410e41f8aa5a22e7bcc514ac88d2798d0282cb1efa5f660ec0e20d35015f807c43e7823ef4ae406125aba45bcd28b2acaf740991528549c413
+  metadata.gz: dc19bcb5b44267c6506a9a1b3547d516b565a2a3ea997bf2ab5cada119caafb0fee09220c7da2e92321562ed2588dc5b6c58c6c697d3230daa8942c00fb731f6
+  data.tar.gz: c6849492302732600fe232d73f6984c4fe1a94e4d818349d5400fb15979eecc6b2b32d71a81b50f09713c5143236e13f330f763ea98beeda4a939d77b8d2fba9

data/lib/HDLRuby/hdr_samples/rom.rb

@@ -1,12 +1,14 @@
 
+signed[7..0].typedef(:typ)
+
 # Describes an 8-bit data 4-bit address ROM.
 system :rom4_8 do
     [2..0].input :addr
     [7..0].output :data0,:data1,:data2
 
     bit[7..0][0..7].constant content0: [0,1,2,3,4,5,6,7]
-    bit[7..0][-8].constant content1: [0,1,2,3,4,5,6,7]
-    bit[7..0][-8].constant content2: (8).times.to_a
+    signed[7..0][-8].constant content1: [0,1,2,3,4,5,6,7]
+    typ[-8].constant content2: (8).times.to_a
 
     data0 <= content0[addr]
     data1 <= content1[addr]

data/lib/HDLRuby/hdr_samples/seqpar_bench.rb

@@ -0,0 +1,59 @@
+# require "../hruby_low2c.rb"
+
+
+
+# A system for testing the execution of par block in seq block.
+system :seqpar_bench do
+
+    inner :rst, :clk
+    signed[8].inner :a, :b, :c, :d
+    signed[8].inner :out
+
+    seq(clk.posedge) do
+        hif(rst) do
+            a <= 0
+            b <= 0
+            c <= 0
+            d <= 0
+        end
+        helse do
+            a <= a + 1
+            b <= a + 2
+            par do
+                c <= b + 3
+                d <= c + 4
+            end
+            a <= d + 5
+        end
+    end
+
+    out <= a
+
+    timed do
+        clk <= 0
+        rst <= 0
+        !20.ns
+        clk <= 1
+        !20.ns
+        clk <= 0
+        rst <= 1
+        !20.ns
+        clk <= 1
+        !20.ns
+        clk <= 0
+        rst <= 0
+        !20.ns
+        clk <= 1
+        !20.ns
+        clk <= 0
+        !20.ns
+        clk <= 1
+        !20.ns
+        clk <= 0
+        !20.ns
+        clk <= 1
+        !20.ns
+        clk <= 0
+        !20.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_fixpoint.rb

@@ -61,5 +61,6 @@ system :fix_test do
         !10.ns
         c <= a * b
         !10.ns
+        c <= (a+b) * b
     end
 end

data/lib/HDLRuby/hdrcc.rb

@@ -19,6 +19,8 @@ require 'HDLRuby/hruby_low_with_port'
 require 'HDLRuby/hruby_low_with_var'
 require 'HDLRuby/hruby_low_without_concat'
 require 'HDLRuby/hruby_low_without_connection'
+require 'HDLRuby/hruby_low_casts_without_expression'
+require 'hruby_low_without_parinseq'
 require 'HDLRuby/hruby_low_cleanup'
 
 require 'HDLRuby/hruby_verilog.rb'
@@ -577,10 +579,12 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
+        systemT.casts_without_expression!
         systemT.to_upper_space!
         systemT.to_global_systemTs!
         # systemT.break_types!
         # systemT.expand_types!
+        systemT.par_in_seq2seq!
         systemT.initial_concat_to_timed!
         systemT.with_port!
     end

data/lib/HDLRuby/hruby_low.rb

@@ -1183,6 +1183,11 @@ module HDLRuby::Low
             return false
         end
 
+        # Tells if the type of of vector kind.
+        def vector?
+            return false
+        end
+
         # Gets the bitwidth of the type, by default 0.
         # Bit, signed, unsigned and Float base have a width of 1.
         def width
@@ -1410,7 +1415,7 @@ module HDLRuby::Low
 
             # Sets the delegations
             self.extend Forwardable
-            [ :signed?, :unsigned?, :fixed?, :float?, :leaf?,
+            [ :signed?, :unsigned?, :fixed?, :float?, :leaf?, :vector?,
               :width, :range?, :range, :base?, :base, :types?,
               :get_all_types, :get_type, :each, :each_type, 
               :regular?,
@@ -1466,6 +1471,11 @@ module HDLRuby::Low
         # The base type of the vector
         attr_reader :base
 
+        # Tells if the type of of vector kind.
+        def vector?
+            return true
+        end
+
         # Tells if the type has a base.
         def base?
             return true

data/lib/HDLRuby/hruby_low_casts_without_expression.rb

@@ -0,0 +1,326 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+require 'HDLRuby/hruby_low_with_bool'
+
+
+module HDLRuby::Low
+
+
+##
+# Replace expressions in cast operators with variables.
+# Use for generating Verilog code generation since bit extension cannot
+# be performed on expression but only on signals. 
+#
+########################################################################
+    
+
+    ## Extends the SystemT class with functionality for extracting 
+    #  expressions from cast.
+    class SystemT
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            self.scope.casts_without_expression!
+            return self
+        end
+
+    end
+
+
+    ## Extends the Scope class with functionality for extracting 
+    #  expressions from cast.
+    class Scope
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Recurse on the sub scopes.
+            self.each_scope(&:casts_without_expression!)
+
+            # Apply on the connections.
+            self.each_connection(&:casts_without_expression!)
+
+            # Apply on the behaviors.
+            self.each_behavior do |behavior|
+                behavior.block.casts_without_expression!
+            end
+            return self
+        end
+    end
+
+
+    ## Extends the Transmit class with functionality for extracting 
+    #  expressions from cast.
+    class Transmit
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Apply on the left value.
+            self.set_left!(self.left.casts_without_expression)
+            # Apply on the right value.
+            self.set_right!(self.right.casts_without_expression)
+            return self
+        end
+    end
+    
+    ## Extends the If class with functionality for extracting 
+    #  expressions from cast.
+    class If
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Apply on the condition.
+            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!]
+            end
+            # Apply on the no if any.
+            self.no.casts_without_expression! if self.no
+            return self
+        end
+    end
+
+    ## Extends the When class with functionality for extracting 
+    #  expressions from cast.
+    class When
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Apply on the match.
+            self.set_match!(self.match.casts_without_expression)
+            # Apply on the statement.
+            self.statement.casts_without_expression!
+            return self
+        end
+    end
+
+
+    ## Extends the Case class with functionality for extracting 
+    #  expressions from cast.
+    class Case
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # No need to apply on the value!
+            # Apply on the value.
+            self.set_value!(self.value.casts_without_expression)
+            # Apply on the whens.
+            self.each_when(&:casts_without_expression!)
+            # Apply on the default if any.
+            self.default.casts_without_expression! if self.default
+            return self
+        end
+    end
+
+
+    ## Extends the TimeWait class with functionality for extracting 
+    #  expressions from cast.
+    class TimeWait
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Nothing to do.
+            return self
+        end
+    end
+
+    ## Extends the TimeRepeat class with functionality for extracting 
+    #  expressions from cast.
+    class TimeRepeat
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Simply recurse on the stamtement.
+            self.statement.casts_without_expression!
+            return self
+        end
+    end
+
+
+    ## Extends the Block class with functionality for extracting 
+    #  expressions from cast.
+    class Block
+
+        # Extracts the expressions from the casts.
+        def casts_without_expression!
+            # Apply on each statement.
+            self.each_statement(&:casts_without_expression!)
+            return self
+        end
+    end
+
+
+    ## Extends the Value class with functionality for extracting 
+    #  expressions from cast.
+    class Value
+        # Extracts the expressions from the casts.
+        def casts_without_expression
+            # Simple clones.
+            return self.clone
+        end
+    end
+
+
+    ## Extends the Cast class with functionality for extracting 
+    #  expressions from cast.
+    class Cast
+        # Extracts the expressions from the casts.
+        def casts_without_expression
+            # Recurse on the child.
+            nchild = self.child.casts_without_expression
+            # Process the cast.
+            unless (nchild.is_a?(Ref)) then
+                # Need to extract the child.
+                # Create signal holding the child.
+                stmnt = self.statement
+                if (stmnt.is_a?(Connection)) then
+                    # Specific case of connections: need to build
+                    # a new block.
+                    scop = stmnt.parent
+                    scop.delete_connection!(stmnt)
+                    stmnt = Transmit.new(stmnt.left.clone, stmnt.right.clone)
+                    blk = Block.new(:seq)
+                    scop.add_behavior(Behavior.new(blk))
+                    blk.add_statement(stmnt)
+                else
+                    blk = stmnt.block
+                end
+                name = HDLRuby.uniq_name
+                typ = nchild.type
+                sig = blk.add_inner(SignalI.new(name,typ))
+                # Add a statement assigning the child to the new signal.
+                nref = RefName.new(typ,RefThis.new,name)
+                nstmnt = Transmit.new(nref,nchild)
+                idx = blk.each_statement.find_index(stmnt)
+                blk.insert_statement!(idx,nstmnt)
+                # Replace the child by a reference to the created
+                # signal.
+                nchild = nref.clone
+            end
+            return Cast.new(self.type,nchild)
+        end
+    end
+
+    ## Extends the Unary class with functionality for extracting 
+    #  expressions from cast.
+    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)
+            return self
+        end
+    end
+
+
+    ## Extends the Binary class with functionality for extracting 
+    #  expressions from cast.
+    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)
+        end
+    end
+
+    
+
+    ## Extends the Select class with functionality for extracting 
+    #  expressions from cast.
+    class Select
+
+        # Extracts the expressions from the casts.
+        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 self
+        end
+    end
+
+
+    ## Extends the Concat class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Concat
+        # Extracts the expressions from the casts.
+        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 )
+        end
+    end
+
+
+    ## Extends the RefConcat class with functionality for converting booleans
+    #  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 )
+        end
+    end
+
+
+    ## Extends the RefIndex class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefIndex
+        # Extracts the expressions from the casts.
+        def casts_without_expression
+            # Recurse on the sub references.
+            return RefIndex.new(self.type,
+                                self.ref.casts_without_expression,
+                                self.index.casts_without_expression)
+        end
+    end
+
+
+    ## Extends the RefRange class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefRange
+        # Extracts the expressions from the casts.
+        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)
+        end
+    end
+
+
+    ## Extends the RefName class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefName
+        # Extracts the expressions from the casts.
+        def casts_without_expression
+            # Recurse on the sub references.
+            return RefName.new(self.type,
+                               self.ref.casts_without_expression,
+                               self.name)
+        end
+    end
+
+
+    ## Extends the RefThis class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefThis 
+        # Extracts the expressions from the casts.
+        def casts_without_expression
+            # Simply clone.
+            return self.clone
+        end
+    end
+end