HDLRuby 2.0.8

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -0,0 +1,165 @@
+require "HDLRuby/hruby_error"
+
+
+
+##
+# Adds methods for finding objects through names.
+#
+# NOTE: For now only resolve name reference.
+#
+########################################################################
+module HDLRuby::Low
+
+    ##
+    #  Extends SystemT with the capability of finding one of its inner object
+    #  by name.
+    class SystemT
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            # Ensure the name is a symbol.
+            name = name.to_sym
+            # Look in the interface.
+            found = self.get_signal(name)
+            return found if found
+            # Maybe it is the scope.
+            return self.scope if self.scope.name == name
+            # Look in the scope.
+            return self.scope.get_by_name(name)
+        end
+    end
+
+
+    ##
+    #  Extends Scope with the capability of finding one of its inner object
+    #  by name.
+    class Scope
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            # Ensure the name is a symbol.
+            name = name.to_sym
+            # Look in the signals.
+            found = self.get_inner(name)
+            return found if found
+            # Look in the instances.
+            found = self.each_systemI.find { |systemI| systemI.name == name }
+            return found if found
+            # Maybe it is a sub scope.
+            return self.each_scope.find { |scope| scope.name == name }
+        end
+    end
+
+
+    ##
+    #  Extends SystemI with the capability of finding one of its inner object
+    #  by name.
+    class SystemI
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            # Look into the eigen system.
+            return self.systemT.get_by_name(name)
+        end
+    end
+
+
+    ##
+    #  Extends Block with the capability of finding one of its inner object
+    #  by name.
+    class Block
+        
+        ## Find an inner object by +name+.
+        #  NOTE: return nil if not found.
+        def get_by_name(name)
+            # Ensure the name is a symbol.
+            name = name.to_sym
+            # Look in the signals.
+            return self.get_inner(name)
+        end
+    end
+
+
+    ##
+    #  Extends RefIndex with the capability of finding the object it
+    #  refered to.
+    class RefIndex
+
+        ## Tells if it is a reference to a systemI signal.
+        def from_systemI?
+            return self.ref.from_systemI
+        end
+    end
+
+
+    ##
+    #  Extends RefRange with the capability of finding the object it
+    #  refered to.
+    class RefRange
+
+        ## Tells if it is a reference to a systemI signal.
+        def from_systemI?
+            return self.ref.from_systemI
+        end
+    end
+
+    
+    ##
+    #  Extends RefName with the capability of finding the object it
+    #  refered to.
+    class RefName
+
+        ## Tells if it is a reference to a systemI signal.
+        def from_systemI?
+            # puts "from_systemI? for #{self.name}"
+            # Look for the owner from the name hierarchy.
+            if self.ref.is_a?(RefName) then
+                # Look in the parent hierachy for the sub reference name.
+                parent = self.parent
+                while parent
+                    if parent.respond_to?(:get_by_name) then
+                        found = parent.get_by_name(self.ref.name)
+                        # puts "found is a :#{found.class}"
+                        return found.is_a?(SystemI)
+                    end
+                    parent = parent.parent
+                end
+                # Not found, look further in the reference hierarchy.
+                return self.ref.from_systemI?
+            end
+            # Not from a systemI.
+            # puts "Not from systemI for #{self.name}"
+            return false
+        end
+
+
+        ## Resolves the name of the reference and return the
+        #  corresponding object.
+        #  NOTE: return nil if could not resolve.
+        def resolve
+            # puts "Resolve with #{self} and name=#{self.name}"
+            # First resolve the sub reference if possible.
+            if self.ref.is_a?(RefName) then
+                obj = self.ref.resolve
+                # Look into the object for the name.
+                return obj.get_by_name(self.name)
+            else
+                # Look in the parent hierachy for the name.
+                parent = self.parent
+                # puts "parent=#{parent}"
+                while parent
+                    if parent.respond_to?(:get_by_name) then
+                        found = parent.get_by_name(self.name)
+                        return found if found
+                    end
+                    parent = parent.parent
+                end
+                # Not found.
+                return nil
+            end
+        end
+    end
+end

data/lib/HDLRuby/hruby_low_skeleton.rb

@@ -0,0 +1,129 @@
+require 'HDLRuby'
+
+
+module HDLRuby::Low
+
+
+##
+# Skeleton of the HRuby::Low class structure.
+#
+# Can be used as basis for extending HDLRuby::Low
+#
+########################################################################
+
+
+    class SystemT
+    end
+
+    class Scope
+    end
+
+    class Type
+    end
+
+    class TypeDef
+    end
+
+    class TypeVector
+    end
+
+    class TypeTuple
+    end
+
+    class TypeStruct
+    end
+
+    class Behavior
+    end
+
+    class TimeBehavior
+    end
+
+    class Event
+    end
+
+    class SignalI
+    end
+
+    class SystemI
+    end
+
+    class Statement
+    end
+
+    class Transmit
+    end
+    
+    class If
+    end
+
+    class When
+    end
+
+    class Case
+    end
+
+    class Delay
+    end
+
+    class TimeWait
+    end
+
+    class TimeRepeat
+    end
+
+    class Block
+    end
+
+    class TimeBlock
+    end
+
+    class Code
+    end
+
+    class Connection
+    end
+
+    class Expression
+    end
+
+    class Value
+    end
+
+    class Cast
+    end
+
+    class Operation
+    end
+
+    class Unary
+    end
+
+    class Binary
+    end
+
+    class Select
+    end
+
+    class Concat
+    end
+
+    class Ref
+    end
+
+    class RefConcat
+    end
+
+    class RefIndex
+    end
+
+    class RefRange
+    end
+
+    class RefName
+    end
+
+    class RefThis 
+    end
+
+end

data/lib/HDLRuby/hruby_low_with_bool.rb

@@ -0,0 +1,141 @@
+require "HDLRuby/hruby_error"
+require "HDLRuby/hruby_low_mutable"
+
+
+##
+# Provides a new boolean type and converts the comparison and operations
+# on it to this new type.
+#
+# NOTE: * this transformation is a prerequired for supporting target
+#         language like VHDL that do not consider boolean to be identical
+#         to bit.
+#       * Boolean is weak in type promotion, e.g.: boolean & bit = bit
+#
+########################################################################
+module HDLRuby::Low
+
+    # Extend Type with check telling if it is a boolean type.
+    class Type
+        # Tells if it is a boolean type.
+        def boolean?
+            return false
+        end
+    end
+    
+    
+    ##
+    # The boolean type leaf.
+    class << ( Boolean = Type.new(:boolean) )
+        include LLeaf
+        # Tells if the type fixed point.
+        def fixed?
+            return true
+        end
+        # Gets the bitwidth of the type, nil for undefined.
+        def width
+            1
+        end
+        # Gets the range of the type.
+        def range
+            0..0
+        end
+        # Tells if it is a boolean type.
+        def boolean?
+            return true
+        end
+        # # Get the base type, actually self for leaf types.
+        # def base
+        #     self
+        # end
+    end
+
+
+    ## Extends the SystemT class for converting types of comparison and
+    #  operations on it to boolean type.
+    class SystemT
+        # Converts to a variable-compatible system.
+        #
+        # NOTE: the result is the same systemT.
+        def with_boolean!
+            self.scope.each_scope_deep do |scope|
+                scope.each_connection { |connection| connection.with_boolean! }
+                scope.each_behavior   { |behavior|   behavior.with_boolean! }
+            end
+            return self
+        end
+    end
+
+    ## Extends the Behaviour class for converting types of comparison and
+    #  operations on it to boolean type.
+    class Behavior
+        # Converts to a variable-compatible system.
+        #
+        # NOTE: the result is the same Behaviour.
+        def with_boolean!
+            self.each_statement  { |statement| statement.with_boolean! }
+        end
+    end
+
+    ## Extends the Statement class for converting types of comparison and
+    #  operations on it to boolean type.
+    class Statement
+        # Converts to a variable-compatible system.
+        #
+        # NOTE: the result is the same Behaviour.
+        def with_boolean!
+            self.each_node do |node| 
+                if node.is_a?(Expression) && node.boolean? then
+                    node.set_type!(HDLRuby::Low::Boolean)
+                end
+            end
+        end
+    end
+
+    ## Extends the Expression class for checking if it a boolean expression
+    #  or not.
+    class Expression
+        # Tells if the expression is boolean.
+        def boolean?
+            return false
+        end
+    end
+
+    ## Extends the Unary class for checking if it is a boolean expression
+    #  or not.
+    class Unary
+        # Tells if the expression is boolean.
+        def boolean?
+            return self.child.boolean?
+        end
+    end
+
+    ## Extends the Binary class for checking if it is a boolean expression
+    #  or not.
+    class Binary
+        # Tells if the expression is boolean.
+        def boolean?
+            case(self.operator)
+            when :==,:!=,:>,:<,:>=,:<= then
+                # Comparison, it is a boolean.
+                return true
+            when :&,:|,:^ then
+                # AND, OR or XOR, boolean if both subs are boolean.
+                return self.left.boolean? && self.right.boolean?
+            else
+                # Other cases: not boolean.
+                return false
+            end
+        end
+    end
+
+    ## Extends the Select class for checking if it a boolean epression
+    #  or not.
+    class Select
+        # Tells if the expression is boolean.
+        def boolean?
+            # Boolean if all the choices are boolean.
+            return !self.each_choice.any? {|c| !c.boolean? }
+        end
+    end
+
+end

data/lib/HDLRuby/hruby_low_with_port.rb

@@ -0,0 +1,167 @@
+require "HDLRuby/hruby_error"
+require "HDLRuby/hruby_low_mutable"
+require "HDLRuby/hruby_low2sym"
+
+
+
+module HDLRuby::Low
+
+
+##
+# Generates port wires for each instance instead of standard signals in
+# HDLRuby::Low description.
+#
+# Port wires can be directly converted to instance connection in VHDL and
+# Verilog.
+#
+########################################################################
+
+    
+
+    ## Extends SystemT with generation of port wires.
+    class SystemT
+
+        # Converts to a port-compatible system.
+        #
+        # NOTE: the result is the same systemT.
+        def with_port!
+            self.scope.with_port!
+            return self
+        end
+    end
+
+
+    ## Extends the Scope class with retrival conversion to symbol.
+    class Scope
+
+        # Converts a port wire to a reference to it.
+        def portw2ref(portw)
+            return RefName.new(portw.type,RefThis.new,portw.name)
+        end
+
+        # Converts symbol +sym+ representing an HDLRuby reference to a 
+        # instance port to a port wire.
+        def sym2portw_name(sym)
+            return ("^" + sym.to_s).to_sym
+        end
+
+        # Converts a port wire +name+ to the symbol giving the corresponding
+        # HDLRuby reference.
+        def portw_name2sym(name)
+            return name[1..-1].to_sym
+        end
+
+        # Generates a port wire from a reference.
+        def make_portw(ref)
+            # First generates the name of the port.
+            name = sym2portw_name(ref.to_sym)
+            # Then generate the port wire.
+            return SignalI.new(name,ref.type)
+        end
+
+        # Tells if a +node+ is a reference to an instance's port.
+        def instance_port?(node)
+            # First the node must be a name reference.
+            return false unless node.is_a?(RefName)
+            # Then its sub ref must be a RefName of an instance.
+            sub = node.ref
+            return false unless sub.is_a?(RefName)
+            # puts "@systemIs.keys=#{@systemIs.keys}"
+            # System instance in current scope?
+            return true if @systemIs.key?(sub.name)
+            # if self.parent.is_a?(Scope) then
+            #     # Recurse the search in the parent.
+            #     return parent.instance_port?(node)
+            # else
+            #     # No parent, failure.
+            #     return false
+            # end
+            return false
+        end
+
+
+        # Converts to a port-compatible system.
+        #
+        # NOTE: the result is the same scope.
+        def with_port!
+            # # Recurse on the sub scope.
+            # self.each_scope(&:with_port!)
+            # Gather the references to instance ports.
+            # Also remember if the references were left values or not.
+            refs = []
+            ref_sym2leftvalue = {}
+            self.each_block_deep do |block|
+                block.each_node_deep do |node|
+                    if instance_port?(node) then
+                        # puts "port for node: #{node.ref.name}.#{node.name}"
+                        refs << node 
+                        ref_sym2leftvalue[node.to_sym] = node.leftvalue?
+                    end
+                end
+            end
+            self.each_connection do |connection|
+                connection.each_node_deep do |node|
+                    if instance_port?(node) then
+                        refs << node 
+                        ref_sym2leftvalue[node.to_sym] = node.leftvalue?
+                    end
+                end
+            end
+            # Generate the port wire from the refs.
+            ref_sym2portw = {}
+            refs.each { |ref| ref_sym2portw[ref.to_sym] = make_portw(ref) }
+            # Declare the port wires.
+            ref_sym2portw.each_value { |portw| self.add_inner(portw.clone) }
+            # Replace the references by their corresponding port wires.
+            self.each_block_deep do |block|
+                block.each_node_deep do |node|
+                    node.map_nodes! do |expr|
+                        portw = ref_sym2portw[expr.to_sym]
+                        portw ? portw2ref(portw) : expr
+                    end
+                end
+            end
+            self.each_connection do |connection|
+                connection.each_node_deep do |node|
+                    node.map_nodes! do |expr|
+                        portw = ref_sym2portw[expr.to_sym]
+                        portw ? portw2ref(portw) : expr
+                    end
+                end
+            end
+
+            # Finally adds the connections with the port wires.
+            ref_sym2portw.each do |sym,portw|
+                ref = sym.to_hdr
+                if ref_sym2leftvalue[sym] then
+                    # The reference was a left value, assign the port wire
+                    # to the ref.
+                    self.add_connection(
+                        Connection.new(ref.clone,portw2ref(portw)) )
+                else
+                    # The reference was a right value, assign it to the
+                    # port wire.
+                    self.add_connection(
+                        Connection.new(portw2ref(portw),ref.clone) )
+                end
+            end
+            
+
+            return self
+        end
+    end
+
+
+
+    ## Extends SystemT with generation of port wires.
+    class SystemI
+
+        def with_port!
+            self.systemT.with_port!
+            return self
+        end
+    end
+
+
+
+end