HDLRuby 2.0.8

data/lib/HDLRuby/hruby_low_bool2select.rb

@@ -0,0 +1,295 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+require 'HDLRuby/hruby_low_with_bool'
+
+
+module HDLRuby::Low
+
+
+##
+# Converts booleans in assignments to select operators.
+# Use for generating VHDL code without type compatibility troubles.
+#
+########################################################################
+    
+
+    ## Extends the SystemT class with functionality for converting booleans
+    #  in assignments to select operators.
+    class SystemT
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            self.scope.boolean_in_assign2select!
+            return self
+        end
+
+    end
+
+
+    ## Extends the Scope class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Scope
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Recurse on the sub scopes.
+            self.each_scope(&:boolean_in_assign2select!)
+
+            # Apply on the connections.
+            self.each_connection(&:boolean_in_assign2select!)
+
+            # Apply on the behaviors.
+            self.each_behavior do |behavior|
+                behavior.block.boolean_in_assign2select!
+            end
+            return self
+        end
+    end
+
+
+    ## Extends the Transmit class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Transmit
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Apply on the left value.
+            self.set_left!(self.left.boolean_in_assign2select)
+            # Apply on the right value.
+            self.set_right!(self.right.boolean_in_assign2select)
+            return self
+        end
+    end
+    
+    ## Extends the If class with functionality for converting booleans
+    #  in assignments to select operators.
+    class If
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # No need to apply on condition!
+            # # Apply on the condition.
+            # self.set_condition!(self.condition.boolean_in_assign2select)
+            # Apply on the yes.
+            self.yes.boolean_in_assign2select!
+            # Apply on the noifs.
+            @noifs.map! do |cond,stmnt|
+                # No need to apply on condition!
+                # [cond.boolean_in_assign2select,stmnt.boolean_in_assign2select!]
+                [cond,stmnt.boolean_in_assign2select!]
+            end
+            # Apply on the no if any.
+            self.no.boolean_in_assign2select! if self.no
+            return self
+        end
+    end
+
+    ## Extends the When class with functionality for converting booleans
+    #  in assignments to select operators.
+    class When
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # No need to apply on the match!
+            # # Apply on the match.
+            # self.set_match!(self.match.boolean_in_assign2select)
+            # Apply on the statement.
+            self.statement.boolean_in_assign2select!
+            return self
+        end
+    end
+
+
+    ## Extends the Case class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Case
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # No need to apply on the value!
+            # # Apply on the value.
+            # self.set_value!(self.value.boolean_in_assign2select)
+            # Apply on the whens.
+            self.each_when(&:boolean_in_assign2select!)
+            # Apply on the default if any.
+            self.default.boolean_in_assign2select! if self.default
+            return self
+        end
+    end
+
+
+    ## Extends the Block class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Block
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select!
+            # Apply on each statement.
+            self.each_statement(&:boolean_in_assign2select!)
+            return self
+        end
+    end
+
+
+    ## Extends the Value class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Value
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Simple clones.
+            return self.clone
+        end
+    end
+
+
+    ## Extends the Cast class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Cast
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the child.
+            return Cast.new(self.type,self.child.boolean_in_assign2select)
+        end
+    end
+
+    ## Extends the Unary class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Unary
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub node.
+            return Unary.new(self.type,self.operator,
+                             self.child.boolean_in_assign2select)
+            return self
+        end
+    end
+
+
+    ## Extends the Binary class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Binary
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub nodes.
+            nleft = self.left.boolean_in_assign2select
+            nright = self.right.boolean_in_assign2select
+            # Is it a comparison but the parent is not a boolean?
+            # or a transmit to a boolean.
+            if [:==,:>,:<,:>=,:<=].include?(self.operator) &&
+              ( (self.parent.is_a?(Expression) && !self.parent.type.boolean?) ||
+                (self.parent.is_a?(Transmit) && !self.parent.left.type.boolean?)) then
+                # Yes, create a select.
+                nself = Binary.new(self.type,self.operator,nleft,nright)
+                # return Select.new(self.type, "?", nself,
+                return Select.new(HDLRuby::Low::Bit, "?", nself,
+                        # Value.new(self.type,1), Value.new(self.type,0) )
+                        Value.new(HDLRuby::Low::Bit,0), 
+                        Value.new(HDLRuby::Low::Bit,1) )
+                        # Value.new(HDLRuby::Low::Boolean,0),
+                        # Value.new(HDLRuby::Low::Boolean,1) )
+            else
+                # No return it as is.
+                self.set_left!(nleft)
+                self.set_right!(nright)
+                return self
+            end
+        end
+    end
+
+
+    ## Extends the Select class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Select
+
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub node.
+            return Select.new(self.type,"?", 
+                              self.select.boolean_in_assign2select,
+                              *self.each_choice.map do |choice|
+                                  choice.boolean_in_assign2select
+                              end )
+            return self
+        end
+    end
+
+
+    ## Extends the Concat class with functionality for converting booleans
+    #  in assignments to select operators.
+    class Concat
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub expressions.
+            return Concat.new(self.type,self.each_expression.map do |expr|
+                expr.boolean_in_assign2select
+            end )
+        end
+    end
+
+
+    ## Extends the Ref class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefConcat
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub references.
+            return RefConcat.new(self.type,self.each_expression.map do |expr|
+                expr.boolean_in_assign2select
+            end )
+        end
+    end
+
+
+    ## Extends the RefIndex class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefIndex
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub references.
+            return RefIndex.new(self.type,
+                                self.ref.boolean_in_assign2select,
+                                self.index.boolean_in_assign2select)
+        end
+    end
+
+
+    ## Extends the RefRange class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefRange
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub references.
+            return RefRange.new(self.type,
+                                self.ref.boolean_in_assign2select,
+                                self.range.first.boolean_in_assign2select ..
+                                self.range.last.boolean_in_assign2select)
+        end
+    end
+
+
+    ## Extends the RefName class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefName
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Recurse on the sub references.
+            return RefName.new(self.type,
+                               self.ref.boolean_in_assign2select,
+                               self.name)
+        end
+    end
+
+
+    ## Extends the RefName class with functionality for converting booleans
+    #  in assignments to select operators.
+    class RefThis 
+        # Converts booleans in assignments to select operators.
+        def boolean_in_assign2select
+            # Simply clone.
+            return self.clone
+        end
+    end
+end

data/lib/HDLRuby/hruby_low_cleanup.rb

@@ -0,0 +1,193 @@
+require 'HDLRuby'
+require 'HDLRuby/hruby_tools'
+require 'HDLRuby/hruby_low_mutable'
+
+
+module HDLRuby::Low
+
+
+##
+# Cleans up the HDLRuby::Low description.
+#
+# NOTE: Assume each name is uniq.
+#
+########################################################################
+    
+
+    ## Extends the SystemT class with functionality for cleaning up the
+    #  structure.
+    class SystemT
+
+        # Cleans up.
+        def cleanup!
+            # Gather the output and inout signals' names, they are used to
+            # identify the signals that can be removed.
+            keep = self.each_output.map {|sig| sig.name } +
+                   self.each_inout.map {|sig| sig.name }
+            self.scope.cleanup!(keep)
+        end
+
+    end
+
+    ## Extends the Scope class with functionality for cleaning up the
+    #  structure.
+    class Scope
+
+        # Cleans up.
+        # +keep+ includes the list of names to be kept.
+        def cleanup!(keep)
+            # Complete the list of signals to keep with the signals parts
+            # of the right values of connections and statements or
+            # instance interface.
+            self.each_scope_deep do |scope|
+                # Connections.
+                scope.each_connection do |connection|
+                    connection.right.each_node_deep do |node|
+                        # Leaf right value references are to keep.
+                        # They are either signal of current system or
+                        # system instance names.
+                        if node.is_a?(RefName) && !node.ref.is_a?(RefName) then
+                            keep << node.name 
+                        end
+                    end
+                end
+                # System instances.
+                scope.each_systemI do |systemI|
+                    keep << systemI.name
+                end
+                # Behaviors.
+                scope.each_behavior do |behavior|
+                    behavior.block.each_node_deep do |node|
+                        # Skip left values.
+                        next if node.respond_to?(:leftvalue?) && node.leftvalue?
+                        # Leaf right value references are to keep.
+                        # They are either signal of current system or
+                        # system instance names.
+                        if node.is_a?(RefName) && !node.ref.is_a?(RefName) then
+                            keep << node.name 
+                        end
+                    end
+                end
+            end
+            
+            # Remove the signals and correspondong assignments that are not 
+            # to keep.
+            self.delete_unless!(keep)
+        end
+
+        # Removes the signals and corresponding assignments whose name is not
+        # in +keep+.
+        def delete_unless!(keep)
+            # Recurse on the sub scopes.
+            self.each_scope { |scope| scope.delete_unless!(keep) }
+
+            # Remove the unessary  inner signals.
+            self.each_inner.to_a.each do |inner|
+                unless keep.include?(inner.name) then
+                    self.delete_inner!(inner)
+                end
+            end
+
+            # Remove the unessary connections.
+            self.each_connection.to_a.each do |connection|
+                # puts "connection with left=#{connection.left.name}"
+                unless connection.left.each_node_deep.any? { |node|
+                    node.is_a?(RefName) && keep.include?(node.name) 
+                }
+                self.delete_connection!(connection)
+                end
+            end
+
+            # Recurse on the blocks.
+            self.each_behavior do |behavior|
+                behavior.block.delete_unless!(keep)
+            end
+        end
+            
+    end
+
+
+    ## Extends the Statement class with functionality for breaking assingments
+    #  to concats.
+    class Statement
+
+        # Removes the signals and corresponding assignments whose name is not
+        # in +keep+.
+        def delete_unless!(keep)
+            # By default nothing to do.
+        end
+    end
+
+
+    ## Extends the If class with functionality for breaking assingments
+    #  to concats.
+    class If
+
+        # Removes the signals and corresponding assignments whose name is not
+        # in +keep+.
+        def delete_unless!(keep)
+            # Recurse on the sub statements.
+            # Yes.
+            self.yes.delete_unless!(keep)
+            # Noifs.
+            self.each_noif { |cond,stmnt| stmnt.delete_unless!(keep) }
+            # No if any.
+            self.no.delete_unless!(keep) if self.no
+        end
+    end
+
+    ## Extends the When class with functionality for breaking assingments
+    #  to concats.
+    class When
+
+        # Removes the signals and corresponding assignments whose name is not
+        # in +keep+.
+        def delete_unless!(keep)
+            # Recurse on the statement.
+            self.statement.delete_unless!(keep)
+        end
+    end
+
+
+    ## Extends the Case class with functionality for breaking assingments
+    #  to concats.
+    class Case
+        # Removes the signals and corresponding assignments whose name is not
+        # in +keep+.
+        def delete_unless!(keep)
+            # Recurse on the whens.
+            self.each_when {|w| w.delete_unless!(keep) }
+            # Recurse on the default if any.
+            self.default.delete_unless!(keep) if self.default
+        end
+    end
+
+
+    ## Extends the Block class with functionality for breaking assingments
+    #  to concats.
+    class Block
+
+        # Removes the signals and corresponding assignments whose name is not
+        # in +keep+.
+        def delete_unless!(keep)
+            # Delete the unecessary inner signals.
+            self.each_inner.to_a.each do |inner|
+                self.delete_inner!(inner) unless keep.include?(inner.name)
+            end
+
+            # Recurse on the sub statements.
+            self.each_statement {|stmnt| stmnt.delete_unless!(keep) }
+
+            # Delete the unecessary assignments.
+            self.each_statement.to_a.each do |stmnt|
+                if stmnt.is_a?(Transmit) &&
+                     !stmnt.left.each_node_deep.any? { |node| 
+                    node.is_a?(RefName) && keep.include?(node.name) } then
+                    self.delete_statement!(stmnt)
+                end
+            end
+        end
+    end
+
+
+end