HDLRuby 2.11.11 → 3.0.0

data/lib/HDLRuby/hruby_low_without_parinseq.rb

@@ -13,9 +13,9 @@ module HDLRuby::Low
 ########################################################################
     
 
-    ## Extends the SystemT class with functionality for converting par blocks
-    #  within seq blocks to seq blocks.
     class SystemT
+        ## Extends the SystemT class with functionality for converting par blocks
+        #  within seq blocks to seq blocks.
 
         # Converts par blocks within seq blocks to seq blocks.
         def par_in_seq2seq!
@@ -23,9 +23,11 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Scope class with functionality for breaking assingments
-    #  to concats.
+
     class Scope
+        ## Extends the Scope class with functionality for converting par blocks
+        #  within seq blocks to seq blocks.
+
         # Converts par blocks within seq blocks to seq blocks.
         def par_in_seq2seq!
             # Recruse on the sub scopes.
@@ -38,9 +40,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Statement class with functionality for breaking assingments
-    #  to concats.
     class Statement
+        ## Extends the Statement class with functionality for converting par 
+        #  blocks within seq blocks to seq blocks.
+ 
         # Converts par blocks within seq blocks to seq blocks.
         def par_in_seq2seq!
             # By default nothing to do.
@@ -55,9 +58,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the If class with functionality for breaking assingments
-    #  to concats.
     class If
+        ## Extends the If class with functionality for converting par blocks
+        #  within seq blocks to seq blocks.
+
         # Converts par blocks within seq blocks to seq blocks.
         def par_in_seq2seq!
             self.yes.par_in_seq2seq!
@@ -78,9 +82,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Case class with functionality for breaking assingments
-    #  to concats.
     class Case
+        ## Extends the Case class with functionality for converting par blocks
+        #  within seq blocks to seq blocks.
+
         # Converts par blocks within seq blocks to seq blocks.
         def par_in_seq2seq!
             self.each_when do |w|
@@ -99,9 +104,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Block class with functionality for breaking assingments
-    #  to concats.
     class Block
+        ## Extends the Block class with functionality for converting par blocks
+        #  within seq blocks to seq blocks.
+
         # Converts par blocks within seq blocks to seq blocks.
         def par_in_seq2seq!
             # Recurse on the sub blocks.
@@ -122,6 +128,9 @@ module HDLRuby::Low
         def to_seq!
             if self.mode == :par then
                 # Need to convert.
+                # Get which module is it.
+                modul = self.is_a?(HDLRuby::High::Block) ? HDLRuby::High :
+                    HDLRuby::Low
                 # First recurse on the sub blocks.
                 self.each_statement(&:to_seq!)
                 # Now replace each left value by a new signal for
@@ -130,16 +139,23 @@ module HDLRuby::Low
                 self.each_statement do |statement|
                     left = statement.left
                     if statement.is_a?(Transmit) then
-                        sig = SignalI.new(HDLRuby.uniq_name,left.type)
-                        self.add_inner(sig)
-                        diff = RefName.new(left.type,RefThis.new,sig.name)
+                        if modul == HDLRuby::High then
+                            sig = modul::SignalI.new(HDLRuby.uniq_name,left.type,:inner)
+                            self.add_inner(sig)
+                            puts "sig.parent=#{sig.parent}"
+                            diff = modul::RefObject.new(modul::RefThis.new,sig)
+                        else
+                            sig = modul::SignalI.new(HDLRuby.uniq_name,left.type)
+                            self.add_inner(sig)
+                            diff = modul::RefName.new(left.type,modul::RefThis.new,sig.name)
+                        end
                         differeds << [left,diff]
                         statement.set_left!(diff)
                     end
                 end
                 # Adds the differed assignments.
                 differeds.each do |left,diff|
-                    self.add_statement(Transmit.new(left.clone,diff.clone))
+                    self.add_statement(modul::Transmit.new(left.clone,diff.clone))
                 end
                 # Change the mode.
                 self.set_mode!(:seq)

data/lib/HDLRuby/hruby_low_without_select.rb

@@ -52,9 +52,9 @@ module HDLRuby::Low
     end
     
 
-    ## Extends the SystemT class with functionality for converting select
-    #  expressions to case statements.
     class SystemT
+        ## Extends the SystemT class with functionality for converting select
+        #  expressions to case statements.
 
         # Converts the Select expressions to Case statements.
         def select2case!
@@ -63,9 +63,10 @@ module HDLRuby::Low
 
     end
 
+
+    class Scope
     ## Extends the Scope class with functionality for converting select
     #  expressions to case statements.
-    class Scope
 
         # Converts the Select expressions to Case statements.
         def select2case!
@@ -82,7 +83,7 @@ module HDLRuby::Low
                 selects = connection.extract_selects!
                 if selects.any? then
                     # Selects have been extract, replace the connection
-                    # be y behavior.
+                    # by a behavior.
                     # Generate the block with cases.
                     blk = LowWithoutSelect.selects2block(selects)
                     # Add a transmit replacing the connection.
@@ -98,9 +99,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the TimeWait class with functionality for converting booleans
-    #  in assignments to select operators.
     class TimeWait
+        ## Extends the TimeWait class with functionality for converting booleans
+        #  in assignments to select operators.
+
         # Extract the Select expressions.
         def extract_selects!
             # Nothing to extract.
@@ -109,9 +111,10 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the TimeRepeat class with functionality for converting booleans
-    #  in assignments to select operators.
     class TimeRepeat
+        ## Extends the TimeRepeat class with functionality for converting
+        #  booleans in assignments to select operators.
+
         # Extract the Select expressions.
         def extract_selects!
             # Simply recruse on the statement.
@@ -124,9 +127,9 @@ module HDLRuby::Low
     end
 
 
-    ## Extends the Block class with functionality for converting select
-    #  expressions to case statements.
     class Block
+        ## Extends the Block class with functionality for converting select
+        #  expressions to case statements.
 
         # Breaks the assignments to concats.
         #
@@ -151,9 +154,11 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Transmit class with functionality for converting select
-    #  expressions to case statements.
+
     class Transmit
+        ## Extends the Transmit class with functionality for converting select
+        #  expressions to case statements.
+
         # Extract the Select expressions.
         def extract_selects!
             selects = []
@@ -163,9 +168,11 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Print class with functionality for converting select
-    #  expressions to case statements.
+
     class Print
+        ## Extends the Print class with functionality for converting select
+        #  expressions to case statements.
+
         # Extract the Select expressions.
         def extract_selects!
             selects = []
@@ -176,19 +183,22 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the TimeTerminate class with functionality for converting select
-    #  expressions to case statements.
+
     class TimeTerminate
+        ## Extends the TimeTerminate class with functionality for converting
+        #  select expressions to case statements.
+
         # Extract the Select expressions.
         def extract_selects!
             # Nothing to extract.
             return []
         end
     end
+
     
-    ## Extends the If class with functionality for converting select
-    #  expressions to case statements.
     class If
+        ## Extends the If class with functionality for converting select
+        #  expressions to case statements.
 
         # Extract the Select expressions.
         #
@@ -200,9 +210,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the If class with functionality for converting select
-    #  expressions to case statements.
+
     class When
+        ## Extends the If class with functionality for converting select
+        #  expressions to case statements.
 
         # Extract the Select expressions.
         #
@@ -214,9 +225,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the If class with functionality for converting select
-    #  expressions to case statements.
+
     class Case
+        ## Extends the Case class with functionality for converting select
+        #  expressions to case statements.
 
         # Extract the Select expressions.
         #
@@ -231,9 +243,10 @@ module HDLRuby::Low
         end
     end
 
-    ## Extends the Expression class with functionality for converting select
-    #  expressions to ase statements.
+
     class Expression
+        ## Extends the Expression class with functionality for converting select
+        #  expressions to ase statements.
 
         # Extract the Select expressions and put them into +selects+
         def extract_selects_to!(selects)

data/lib/HDLRuby/hruby_low_without_subsignals.rb

@@ -0,0 +1,280 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+require 'HDLRuby/hruby_low_resolve'
+
+
+module HDLRuby::Low
+
+
+##
+# Replace hierachical signals by the list of their sub signals.
+# Makes handling by some synthesis tools easier.
+#
+########################################################################
+ 
+
+    class SystemT
+        ## Extends the SystemT class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            self.scope.signal2subs!
+        end
+    end
+
+
+    class Scope
+        ## Extends the Scope class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recruse on the sub scopes.
+            self.each_scope(&:signal2subs!)
+
+            # Recurse on the blocks.
+            self.each_behavior do |behavior|
+                # behavior.block.each_block_deep(&:signal2subs!)
+                behavior.signal2subs!
+            end
+
+            # Work on the connections.
+            self.each_connection.to_a.each do |connection|
+                # Recurse on the left and right.
+                connection.set_left!(connection.left.signal2subs!)
+                connection.set_right!(connection.right.signal2subs!)
+            end
+        end
+    end
+
+
+    class Behavior
+        ## Extends the Behavior class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Process the events.
+            self.each_event.to_a.each do |ev|
+                subrefs = ev.ref.flatten
+                if subrefs.any? then
+                    # The refence have been flattend, remove the event.
+                    self.delete_event!(ev)
+                    # And add instead new events for the sub references.
+                    subrefs.each do |subref|
+                        nev = Event.new(ev.type,subref)
+                        self.add_event(nev)
+                    end
+                end
+            end
+            # Recurse on the blocks.
+            self.block.each_block_deep(&:signal2subs!)
+        end
+    end
+
+
+    class Block
+        ## Extends the Block class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the statments.
+            self.map_statements! do |stmnt|
+                stmnt.signal2subs!
+            end
+            return self
+        end
+    end
+
+
+    class TimeWait
+        ## Extends the TimeWait class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Nothing to do.
+            return self
+        end
+    end
+
+
+    class TimeRepeat
+        ## Extends the TimeRepeat class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the statement.
+            self.set_statement!(self.statement.signal2subs!)
+            return self
+        end
+    end
+
+
+    class Transmit
+        ## Extends the Transmit class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the left and right.
+            self.set_left!(self.left.signal2subs!)
+            self.set_right!(self.right.signal2subs!)
+            return self
+        end
+    end
+
+
+    class Print
+        ## Extends the Print class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the arguments.
+            self.map_args! { |arg| arg.signal2subs! }
+            return self
+        end
+    end
+
+
+    class TimeTerminate
+        ## Extends the Print class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Nothing to do.
+            return self
+        end
+    end
+    
+
+    class If
+        ## Extends the If class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the condition.
+            self.set_condition!(self.condition.signal2subs!)
+            # Recurse on the yes block.
+            self.yes.signal2subs!
+            # Recurse on the no block if any.
+            self.no.signal2subs! if self.no
+            # Recurse on the alternate ifs.
+            self.map_noifs! do |cond,stmnt|
+                [cond.signal2subs!,stmnt.signal2subs!]
+            end
+            return self
+        end
+    end
+
+
+    class When
+        ## Extends the When class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the match.
+            self.set_match!(self.match.signal2subs!)
+            # Recurse on the statement.
+            self.set_statement!(self.statement.signal2subs!)
+            return self
+        end
+
+    end
+
+
+    class Case
+        ## Extends the Case class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # Recurse on the case value.
+            self.set_value!(self.value.signal2subs!)
+            # Recurse on the whens.
+            self.each_when(&:signal2subs!)
+            # Recurse on the default.
+            self.set_default!(self.default.signal2subs!) if self.default
+            return self
+        end
+    end
+
+
+    class Expression
+        ## Extends the Expression class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # puts "signal2subs! for expr=#{self}"
+            # Recurse on the subexpressions.
+            self.map_expressions!(&:signal2subs!)
+            return self
+        end
+    end
+
+
+    class RefName
+        ## Extends the RefName class with functionality for decomposing the
+        #  hierachical signals in the statements.
+
+        # Flatten a reference to a list of reference to leaf signals
+        # from signal +sig+ and add to result to +subrefs+
+        def flatten_to(sig,subrefs)
+            # puts "flatten_to with sig name=#{sig.name}"
+            # Work on the sub signals if any.
+            sig.each_signal do |sub|
+                # Create a reference for the sub.
+                subref = RefName.new(sub.type,self.clone,sub.name)
+                # Recruse on it.
+                subref.flatten_to(sub,subrefs)
+                # Was it a leaf?
+                unless sub.each_signal.any? then
+                    # Yes, add its new ref to the list of subs.
+                    subrefs << subref
+                end
+            end
+        end
+
+        # Flatten the current ref to a list of references.
+        # If the reference is not heirachical, returns an empty list.
+        def flatten
+            subrefs = []
+            self.flatten_to(self.resolve,subrefs)
+            return subrefs
+        end
+
+        # Decompose the hierarchical signals in the statements.
+        def signal2subs!
+            # puts "signal2subs! for RefName: #{self.name}"
+            # Decompose it to a list of reference to each leaf sub signal.
+            subrefs = []
+            self.flatten_to(self.resolve,subrefs)
+            # puts "subrefs=#{subrefs.map{|subref| subref.name}}"
+            # Has it sub signals?
+            if (subrefs.any?) then
+                # Yes, convert it to a Concat.
+                if self.leftvalue? then
+                    return RefConcat.new(self.type,subrefs)
+                else
+                    return Concat.new(self.type,subrefs)
+                end
+            else
+                # Nothing to do.
+                return self
+            end
+        end
+    end
+
+
+
+
+end