HDLRuby 2.0.8

data/lib/HDLRuby/hruby_low2seq.rb

@@ -0,0 +1,248 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+
+
+module HDLRuby::Low
+
+
+##
+# Converts par blocks to seq blocks.
+# Also provides detection of mixed par and seq blocks.
+#
+########################################################################
+    
+
+    ## Extends the SystemT class with functionality for converting par block
+    #  to seq.
+    class SystemT
+        
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Recurse on the scope.
+            self.scope.to_seq!
+            return self
+        end
+
+        # Converts the par sub blocks to seq if they are not full par.
+        def mixblocks2seq!
+            # Recurse on the scope.
+            self.scope.mixblocks2seq!
+        end
+
+    end
+
+    ## Extends the Scope class with functionality for converting par block
+    #  to seq.
+
+    class Scope
+        
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Recurse on the behaviors.
+            self.each_behavior { |beh| beh.blocks2seq! }
+            return self
+        end
+
+        # Converts the par sub blocks to seq if they are not full par.
+        def mixblocks2seq!
+            # Recurse on the behaviors.
+            self.each_behavior { |beh| beh.mixblocs2seq! }
+        end
+
+    end
+
+
+    ## Extends the Behavior class with functionality for converting par block
+    #  to seq.
+
+    class Behavior
+        
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Converts the block to seq.
+            self.block.to_seq!
+            return self
+        end
+
+        # Converts the par sub blocks to seq if they are not full par.
+        def mixblocks2seq!
+            # Is the block mix?
+            return unless block.mix?
+            # Mixed, do convert.
+            # Converts the block to seq.
+            self.block.to_seq!
+        end
+
+    end
+
+    ## Extends the Statement class with functionality for converting par block
+    #  to seq.
+    class Statement
+
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # By default, nothing to do.
+            return self
+        end
+
+        # Tell if there is a mix block.
+        # +mode+ is the mode of the upper block.
+        def mix?(mode = nil)
+            # By default, no mix block.
+            return false
+        end
+    end
+
+    ## Extends the If class with functionality for converting par block
+    #  to seq.
+    class If
+        
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Convert each sub block.
+            # If block.
+            self.yes.blocks2seq!
+            # Elsif blocks
+            self.each_noif do |cond, stmnt|
+                stmnt.blocks2seq!
+            end
+            # Else block if any.
+            self.no.blocks2seq! if self.no
+            return self
+        end
+
+        # Tell if there is a mix block.
+        # +mode+ is the mode of the upper block.
+        def mix?(mode = nil)
+            # Check each sub block.
+            # If block.
+            return true if self.yes.mix?(mode)
+            # Elsif blocks
+            self.each_noif do |cond, stmnt|
+                return true if stmnt.mix?(mode)
+            end
+            # Else block if any.
+            true if self.no && self.no.mix?(mode)
+        end
+
+    end
+
+    ## Extends the When class with functionality for converting par block
+    #  to seq.
+    class When
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Convert the statement.
+            self.statement.blocks2seq!
+            return self
+        end
+
+        # Tell if there is a mix block.
+        # +mode+ is the mode of the upper block.
+        def mix?(mode = nil)
+            # Check the statement.
+            return statement.mix?(mode)
+        end
+
+    end
+
+    ## Extends the When class with functionality for converting par block
+    #  to seq.
+    class Case
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Recurse on the whens.
+            self.each_when(&:blocks2seq!)
+            # Converts the default if any.
+            self.default.blocks2seq! if self.default
+            return self
+        end
+
+        # Tell if there is a mix block.
+        # +mode+ is the mode of the upper block.
+        def mix?(mode = nil)
+            # Recuse on the whens.
+            return true if self.each_when.any? { |w| w.mix?(mode) }
+            # Check the default if any.
+            return self.default.mix?(mode)
+        end
+
+    end
+
+    ## Extends the TimeRepeat class with functionality for converting par block
+    #  to seq.
+    class TimeRepeat
+
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # Converts the statement.
+            self.statement.blocks2seq!
+            return self
+        end
+
+        # Tell if there is a mix block.
+        # +mode+ is the mode of the upper block.
+        def mix?(mode = nil)
+            # Check the statement.
+            return self.statement.mix?(mode)
+        end
+
+    end
+
+    ## Extends the Block class with functionality for converting par block
+    #  to seq.
+    class Block
+
+        # Converts the par sub blocks to seq.
+        def blocks2seq!
+            # First recurse on each statement.
+            self.each_statement { |stmnt| stmnt.blocks2seq! }
+            # If the block is already seq, nothing more to do.
+            return self if self.mode == :seq
+            # IF the block contains one or less transmit statement,
+            # simply change its mode.
+            if self.each_statement.count { |stmnt| stmnt.is_a?(Transmit) } <= 1
+                self.set_mode!(:par)
+                return self
+            end
+            # Gather the left values of the assignments.
+            lvalues = self.each_statement.select do |stmnt|
+                stmnt.is_a?(Transmit)
+            end.map { |trans| trans.left }
+            # Gather the right values inside the whole block.
+            rvalues = self.each_node_deep.select do |node|
+                node.is_a?(Expression) and node.rightvalue?
+            end
+            # Keep the left value that are reused.
+            lvalues = lvalues & rvalues
+            # Create new inner variable for replacing them.
+            nvalues = []
+            lvalues.each do |lvalue|
+                # Create the replacing variable.
+                nvalues << nvalue = self.add_inner(
+                    SignalI.new(HDLRuby.uniq_name,lvalue.type))
+                # Replace it.
+                ref = RefName.new(lvalue.type, RefThis.new, nvalues[-1].name)
+                lvalue.parent.set_left!(ref)
+                # And reassign it at the end of the block.
+                lvalue.parent = nil
+                assign = Transmit.new(lvalue,ref.clone)
+                self.add_statement(assign)
+            end
+            return self
+        end
+
+        # Tell if there is a mix block.
+        # +mode+ is the mode of the upper block.
+        def mix?(mode = nil)
+            # Check if different from mode block if any.
+            return true if mode && self.type != mode
+            # No difference with the upper block, maybe there is one within.
+            # Check each statement.
+            self.each_statement.any? { |stmt| stmnt.mix?(mode) }
+        end
+
+    end
+
+end

data/lib/HDLRuby/hruby_low2sym.rb

@@ -0,0 +1,126 @@
+require 'HDLRuby'
+
+
+module HDLRuby
+
+    # The new field symbol_equiv is not to be dumped.
+    FIELDS_TO_EXCLUDE.default << :@_symbol_equiv
+end
+
+module HDLRuby::Low
+
+
+##
+# Converts a HDLRuby::Low description to a uniq symbol and vice versa.
+#
+########################################################################
+
+    ##
+    #  Module adding the conversion to symbol feature to HDLRuby objects.
+    module Low2Symbol
+
+        # The correspondance tables between HDLRuby objects and symbols.
+        Low2SymbolTable = {}
+        Symbol2LowTable = {}
+
+        # The prefix used when building symbols.
+        Low2SymbolPrefix = "`"
+
+        # Converts to a symbol.
+        def to_sym
+            # Get the associated symbol if any.
+            @_symbol_equiv ||= Low2SymbolTable[self]
+            unless @_symbol_equiv then
+                # No symbol yet, create it.
+                @_symbol_equiv =
+                    (Low2SymbolPrefix + Symbol2LowTable.size.to_s).to_sym
+                # And regiter it.
+                Symbol2LowTable[@_symbol_equiv] = self
+                Low2SymbolTable[self] = @_symbol_equiv
+            end
+            # Now there is a symbol, return it.
+            return @_symbol_equiv
+        end
+    end
+
+    ## Extends the Symbol class with of equivalent HDLRuby object.
+    class ::Symbol
+        # Convert to the equivalent HDLRuby object if any, returns nil if not.
+        def to_hdr
+            return Low2Symbol::Symbol2LowTable[self]
+        end
+    end
+    
+
+    ## Extends the SystemT class with conversion to symbol.
+    class SystemT
+        include Low2Symbol
+    end
+
+
+    ## Extends the Scope class with conversion to symbol.
+    class Scope
+        include Low2Symbol
+    end
+
+    
+    ## Extends the Type class with conversion to symbol.
+    class Type
+        include Low2Symbol
+    end
+
+
+    ## Extends the Behavior class with conversion to symbol.
+    class Behavior
+        include Low2Symbol
+    end
+
+
+    ## Extends the Event class with conversion to symbol.
+    class Event
+        include Low2Symbol
+    end
+
+
+    ## Extends the SignalI class with conversion to symbol.
+    class SignalI
+        include Low2Symbol
+    end
+
+
+    ## Extends the SystemI class with conversion to symbol.
+    class SystemI
+        include Low2Symbol
+    end
+
+
+    ## Extends the Statement class with conversion to symbol.
+    class Statement
+        include Low2Symbol
+    end
+
+
+    ## Extends the When class with conversion to symbol.
+    class When
+        include Low2Symbol
+    end
+
+
+    ## Extends the Delay class with conversion to symbol.
+    class Delay
+        include Low2Symbol
+    end
+
+
+    ## Extends the Code class with conversion to symbol.
+    class Code
+        include Low2Symbol
+    end
+
+
+    ## Extends the Expression class with conversion to symbol.
+    class Expression
+        include Low2Symbol
+    end
+
+end