HDLRuby 2.0.8

data/lib/HDLRuby/hruby_low_without_outread.rb

@@ -0,0 +1,107 @@
+require "HDLRuby/hruby_error"
+require "HDLRuby/hruby_low_mutable"
+
+
+##
+# Ensures that there is no read on output port by adding intermediate
+# inner signal.
+#
+#
+# NOTE: Used for instance for converting to old versions of VHDL that
+#
+########################################################################
+module HDLRuby::Low
+
+
+
+    ## Extends the SystemT class for remove read of output signal.
+    class SystemT
+        # Replace read of output signal to read of intermediate inner
+        # signal.
+        #
+        # NOTE: the result is the same systemT.
+        def outread2inner!
+            # puts "For system: #{self.name}"
+            # First gather the read on output signals.
+            outreads = {}
+            gather_outreads = proc do |node|
+                # puts "node=#{node.name}" if node.is_a?(RefName)
+                if node.is_a?(RefName) && !node.leftvalue? then
+                    name = node.name
+                    # puts "name=#{name}"
+                    sig = self.get_output(name)
+                    outreads[node.name] = node if sig
+                end
+            end
+            # Apply the procedure for gathering the read on outputs signals.
+            self.scope.each_scope_deep do |scope|
+                scope.each_connection do |connection|
+                    connection.each_node_deep(&gather_outreads)
+                end
+                scope.each_behavior do |behavior|
+                    behavior.each_event do |event|
+                        gather_outreads.(event.ref)
+                    end
+                    behavior.each_statement do |statement|
+                        # puts "statement=#{statement.class}"
+                        statement.each_node_deep(&gather_outreads)
+                    end
+                end
+            end
+            # puts "outreads=#{outreads.keys}"
+
+            # Generate one inner signal per read output.
+            out2inner = {}
+            outreads.each do |name,node|
+                # Generate the inner variable.
+                out2inner[name] = 
+                 self.scope.add_inner(SignalI.new(HDLRuby::uniq_name,node.type))
+                # puts "new inner=#{out2inner[name].name}"
+            end
+
+            # Replace the output by the corresponding inner in the
+            # expressions.
+            replace_name = proc do |node| # The replacement procedure.
+                # Only single name reference are to be replaced, the others
+                # cannot correspond to output signal.
+                if node.is_a?(RefName) && node.ref.is_a?(RefThis) &&
+                        !node.parent.is_a?(RefName) then
+                    inner = out2inner[node.name]
+                    # puts "node=#{node.name} inner=#{inner}"
+                    # puts "Replace name: #{node.name} by #{inner.name}" if inner
+                    node.set_name!(inner.name) if inner
+                end
+            end
+            # Apply the replacement procedure on the code
+            self.scope.each_scope_deep do |scope|
+                scope.each_connection do |connection|
+                    connection.each_node_deep do |node|
+                        replace_name.(node)
+                    end
+                end
+                scope.each_behavior do |behavior|
+                    behavior.each_event do |event|
+                        event.ref.each_node_deep do |node|
+                            replace_name.(node)
+                        end
+                    end
+                    behavior.each_statement do |statement|
+                        statement.each_node_deep do |node|
+                            replace_name.(node)
+                        end
+                    end
+                end
+            end
+
+            # Finally connect the inner to the output.
+            out2inner.each do |out,inner|
+                self.scope.add_connection(
+                 Connection.new(RefName.new(inner.type,RefThis.new,out),
+                                RefName.new(inner.type,RefThis.new,inner.name)))
+            end
+
+            return self
+        end
+    end
+
+end

data/lib/HDLRuby/hruby_low_without_select.rb

@@ -0,0 +1,206 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+
+
+module HDLRuby::Low
+
+
+##
+# Converts the select expression to case statements.
+# Makes handling by some synthesis tools easier.
+#
+########################################################################
+    
+
+    ## Module containing helping methods for converting Select expressions
+    #  to Case.
+    module LowWithoutSelect
+
+        # Generate a block with Cases from a list of Select objects.
+        def self.selects2block(selects) 
+            blk = Block.new(:seq)
+            selects.each do |select,sig|
+                # puts "for select=#{select.to_high} with sig=#{sig.name}(#{sig.type.name})"
+                # Create the case.
+                cas = Case.new(select.select.clone)
+                # Get the type for the matches.
+                type = select.select.type
+                # Create and add the whens.
+                size = select.each_choice.count
+                select.each_choice.with_index do |choice,i|
+                    # Create the transmission statements of the when.
+                    left = RefName.new(sig.type,RefThis.new,sig.name)
+                    trans = Transmit.new(left,choice.clone)
+                    # Put it into a block for the when.
+                    tb = Block.new(:par)
+                    tb.add_statement(trans)
+                    if i < size-1 then
+                        # Create and add the when.
+                        cas.add_when( When.new(Value.new(type,i), tb) )
+                    else
+                        # Last choice, add a default/
+                        cas.default = tb
+                    end
+                end
+                # puts "Resulting case: #{cas.to_high}"
+                # Adds the case to the block.
+                blk.add_statement(cas)
+            end
+            return blk
+        end
+    end
+    
+
+    ## Extends the SystemT class with functionality for converting select
+    #  expressions to case statements.
+    class SystemT
+
+        # Converts the Select expressions to Case statements.
+        def select2case!
+            self.scope.select2case!
+        end
+
+    end
+
+    ## Extends the Scope class with functionality for converting select
+    #  expressions to case statements.
+    class Scope
+
+        # Converts the Select expressions to Case statements.
+        def select2case!
+            # Recruse on the sub scopes.
+            self.each_scope(&:select2case!)
+
+            # Recurse on the blocks.
+            self.each_behavior do |behavior|
+                behavior.block.each_block_deep(&:select2case!)
+            end
+
+            # Work on the connections.
+            self.each_connection.to_a.each do |connection|
+                selects = connection.extract_selects!
+                if selects.any? then
+                    # Selects have been extract, replace the connection
+                    # be y behavior.
+                    # Generate the block with cases.
+                    blk = LowWithoutSelect.selects2block(selects)
+                    # Add a transmit replacing the connection.
+                    blk.add_statement(
+                        Transmit.new(self.left.clone,self.right.clone))
+                    # Remove the connection and add a behavior instead.
+                    self.remove_connection(connection)
+                    self.add_behavior(Behavior.new(blk))
+                end
+            end
+        end
+    end
+
+    ## Extends the Block class with functionality for converting select
+    #  expressions to case statements.
+    class Block
+
+        # Breaks the assignments to concats.
+        #
+        # NOTE: work on the direct sub statement only, not deeply.
+        def select2case!
+            # Check each statement.
+            self.map_statements! do |stmnt|
+                # Skip blocks that are treated through recursion.
+                next stmnt if stmnt.is_a?(Block)
+                # Work on the statement.
+                # Extract the Select expressions.
+                selects = stmnt.extract_selects!
+                if selects.any? then
+                    # Generate a sequential block containing the cases.
+                    blk = LowWithoutSelect.selects2block(selects)
+                    # Adds the statement to the block.
+                    blk.add_statement(stmnt.clone)
+                    stmnt = blk
+                end
+                stmnt 
+            end
+        end
+    end
+
+    ## Extends the Transmit class with functionality for converting select
+    #  expressions to case statements.
+    class Transmit
+        # Extract the Select expressions.
+        def extract_selects!
+            selects = []
+            self.set_left!(self.left.extract_selects_to!(selects))
+            self.set_right!(self.right.extract_selects_to!(selects))
+            return selects
+        end
+    end
+    
+    ## Extends the If class with functionality for converting select
+    #  expressions to case statements.
+    class If
+
+        # Extract the Select expressions.
+        #
+        # NOTE: work on the condition only.
+        def extract_selects!
+            selects = []
+            self.set_condition!(self.condition.extract_selects_to!(selects))
+            return selects
+        end
+    end
+
+    ## Extends the If class with functionality for converting select
+    #  expressions to case statements.
+    class When
+
+        # Extract the Select expressions.
+        #
+        # NOTE: work on the match only.
+        def extract_selects!
+            selects = []
+            self.set_match!(self.match.extract_selects_to!(selects))
+            return selects
+        end
+    end
+
+    ## Extends the If class with functionality for converting select
+    #  expressions to case statements.
+    class Case
+
+        # Extract the Select expressions.
+        #
+        # Note: the default is not treated.
+        def extract_selects!
+            selects = []
+            # Work on the value.
+            self.set_value!(self.value.extract_selects_to!(selects))
+            # Work on the whens.
+            selects += self.each_when.map(&:extract_selects!).reduce(:+)
+            return selects
+        end
+    end
+
+    ## Extends the Expression class with functionality for converting select
+    #  expressions to ase statements.
+    class Expression
+
+        # Extract the Select expressions and put them into +selects+
+        def extract_selects_to!(selects)
+            # Recurse on the sub expressions.
+            self.map_expressions! {|expr| expr.extract_selects_to!(selects) }
+            # Treat case of select.
+            if self.is_a?(Select) then
+                # Create the signal replacing self.
+                sig = SignalI.new(HDLRuby.uniq_name,self.type)
+                # Add the self with replacing sig to the extracted selects
+                selects << [self,sig]
+                # Create the signal replacing self.
+                blk = self.statement.block
+                blk.add_inner(sig)
+                # And return a reference to it.
+                return RefName.new(sig.type,RefThis.new,sig.name)
+            end
+            return self
+        end
+    end
+end