HDLRuby 2.10.5 → 2.11.0

data/lib/HDLRuby/hruby_high.rb

@@ -825,8 +825,20 @@ module HDLRuby::High
 
         include Hmux
 
+
+        # Merge the included systems interface in current system.
+        # NOTE: incompatible with further to_low transformation.
+        def merge_included!
+            # puts "merge_included! for system=#{self.name}"
+            # Recurse on the system instances.
+            self.scope.merge_included!
+            # Merge for current system.
+            self.scope.merge_included(self)
+        end
+
+
         # Fills the interface of a low level system.
-        def fill_interface(systemTlow)
+        def fill_interface_low(systemTlow)
             # Adds its input signals.
             self.each_input { |input|  systemTlow.add_input(input.to_low) }
             # Adds its output signals.
@@ -835,7 +847,7 @@ module HDLRuby::High
             self.each_inout { |inout|  systemTlow.add_inout(inout.to_low) }
             # Adds the interface of its included systems.
             self.scope.each_included do |included|
-                included.fill_interface(systemTlow)
+                included.fill_interface_low(systemTlow)
             end
         end
 
@@ -844,7 +856,7 @@ module HDLRuby::High
         # NOTE: name conflicts are treated in the current NameStack state.
         def fill_low(systemTlow)
             # Fills the interface
-            self.fill_interface(systemTlow)
+            self.fill_interface_low(systemTlow)
         end
 
         # Converts the system to HDLRuby::Low and set its +name+.
@@ -1380,6 +1392,72 @@ module HDLRuby::High
 
         include Hmux
 
+
+
+        # Merge the included systems interface in +systemT+
+        # NOTE: incompatible with further to_low transformation.
+        def merge_included(systemT)
+            # Recurse on the sub.
+            self.each_scope {|scope| scope.merge_included(systemT) }
+            # Include for current scope.
+            self.each_included do |included|
+                included.merge_included!
+                # Adds its interface signals.
+                included.each_input do |input|
+                    input.no_parent!
+                    systemT.add_input(input)
+                end
+                included.each_output do |output|  
+                    output.no_parent!
+                    systemT.add_output(output)
+                end
+                included.each_inout do |inout|  
+                    inout.no_parent!
+                    systemT.add_inout(inout)
+                end
+                # Adds its behaviors.
+                included.scope.each_behavior do |beh|
+                    beh.no_parent!
+                    systemT.scope.add_behavior(beh)
+                end
+                # Adds its connections.
+                included.scope.each_connection do |cx|
+                    cx.no_parent!
+                    systemT.scope.add_connection(cx)
+                end
+                # Adds its sytem instances.
+                included.scope.each_systemI do |sys|
+                    sys.no_parent!
+                    systemT.scope.add_systemI(sys)
+                end
+                # Adds its code.
+                included.scope.each_code do |code|
+                    code.no_parent!
+                    systemT.scope.add_code(code)
+                end
+                # Adds its subscopes.
+                included.scope.each_scope do |scope|
+                    scope.no_parent!
+                    systemT.scope.add_scope(scope)
+                end
+                # Add its inner signals.
+                included.scope.each_inner do |inner|
+                    inner.no_parent!
+                    systemT.scope.add_inner(inner)
+                end
+            end
+        end
+
+        # Merge the included systems interface in system instances.
+        # NOTE: incompatible with further to_low transformation.
+        def merge_included!
+            # Recurse on the sub.
+            self.each_scope {|scope| scope.merge_included! }
+            # Merge in the system instances.
+            self.each_systemI {|systemI| systemI.systemT.merge_included! }
+        end
+
+
         # Fills a low level scope with self's contents.
         #
         # NOTE: name conflicts are treated in the current NameStack state.
@@ -2194,8 +2272,6 @@ module HDLRuby::High
             else
                 # No, perform a connection is order of declaration
                 connects.each.with_index do |csig,i|
-                    csig = csig.to_expr
-                    # puts "csig=#{csig} i=#{i}"
                     # puts "systemT inputs=#{systemT.each_input.to_a.size}"
                     # Gets i-est signal to connect
                     ssig = self.systemT.get_interface_with_included(i)
@@ -2207,8 +2283,10 @@ module HDLRuby::High
                     # Make the connection.
                     if isout then
                         csig <= ssig
+                        # csig.to_ref <= ssig
                     else
                         ssig <= csig
+                        # ssig <= csig.to_expr
                     end
                 end
             end
@@ -2775,30 +2853,39 @@ module HDLRuby::High
             return self.ljust(self[-1])
         end
 
-        # Match the type with +typ+:
-        # - Recurse on the sub expr if hierachical type, raising an arror
-        #   if the expression is not hierarchical.
-        # - Directly cast otherwise.
+        # # Match the type with +typ+:
+        # # - Recurse on the sub expr if hierachical type, raising an error
+        # #   if the expression is not hierarchical.
+        # # - Directly cast otherwise.
+        # def match_type(typ)
+        #     # Has the type sub types?
+        #     if typ.types? then
+        #         unless self.is_a?(Concat) then
+        #             raise AnyError,
+        #                 "Invalid class for assignment to hierarchical: #{self.class}."
+        #         end
+        #         return Concat.new(typ,
+        #           self.each_expression.zip(typ.each_type).map do |e,t|
+        #             e.match_type(t)
+        #         end)
+        #     elsif typ.vector? && typ.base.hierarchical? then
+        #         unless self.is_a?(Concat) then
+        #             raise AnyError,
+        #                 "Invalid class for assignment to hierarchical: #{self.class}."
+        #         end
+        #         return Concat.new(typ,
+        #           self.each_expression.map do |e|
+        #             e.match_type(typ.base)
+        #         end)
+        #     else
+        #         return self.as(typ)
+        #     end
+        # end
+
+        # Match the type with +typ+: cast if different type.
         def match_type(typ)
-            # Has the type sub types?
-            if typ.types? then
-                unless self.is_a?(Concat) then
-                    raise AnyError,
-                        "Invalid class for assignment to hierarchical: #{self.class}."
-                end
-                return Concat.new(typ,
-                  self.each_expression.zip(typ.each_type).map do |e,t|
-                    e.match_type(t)
-                end)
-            elsif typ.vector? && typ.base.hierarchical? then
-                unless self.is_a?(Concat) then
-                    raise AnyError,
-                        "Invalid class for assignment to hierarchical: #{self.class}."
-                end
-                return Concat.new(typ,
-                  self.each_expression.map do |e|
-                    e.match_type(typ.base)
-                end)
+            if self.type.eql?(typ) then
+                return self
             else
                 return self.as(typ)
             end
@@ -2875,54 +2962,58 @@ module HDLRuby::High
              define_method(orig_operator(operator),&meth)
          end
 
-        # Creates an access to elements of range +rng+ of the signal.
-        #
-        # NOTE: +rng+ can be a single expression in which case it is an index.
-        def [](rng)
-            if rng.is_a?(::Range) then
-                first = rng.first
-                if (first.is_a?(::Integer)) then
-                    first = self.type.size+first if first < 0
-                end
-                last = rng.last
-                if (last.is_a?(::Integer)) then
-                    last = self.type.size+last if last < 0
-                end
-                rng = first..last
-            end
-            if rng.is_a?(::Integer) && rng < 0 then
-                rng = self.type.size+rng
-            end
-            if rng.respond_to?(:to_expr) then
-                # Number range: convert it to an expression.
-                rng = rng.to_expr
-            end 
-            if rng.is_a?(HDLRuby::Low::Expression) then
-                # Index case
-                return RefIndex.new(self.type.base,self.to_expr,rng)
-            else
-                # Range case, ensure it is made among expression.
-                first = rng.first.to_expr
-                last = rng.last.to_expr
-                # Abd create the reference.
-                return RefRange.new(self.type.slice(first..last),
-                                    self.to_expr,first..last)
-            end
-        end
 
-        # Converts to a select operator using current expression as
-        # condition for one of the +choices+.
-        #
-        # NOTE: +choices+ can either be a list of arguments or an array.
-        # If +choices+ has only two entries
-        # (and it is not a hash), +value+ will be converted to a boolean.
-        def mux(*choices)
-            # Process the choices.
-            choices = choices.flatten(1) if choices.size == 1
-            choices.map! { |choice| choice.to_expr }
-            # Generate the select expression.
-            return Select.new(choices[0].type,"?",self.to_expr,*choices)
-        end
+         # Creates an access to elements of range +rng+ of the signal.
+         #
+         # NOTE: +rng+ can be a single expression in which case it is an index.
+         def [](rng)
+             if rng.is_a?(::Range) then
+                 first = rng.first
+                 if (first.is_a?(::Integer)) then
+                     first = self.type.size+first if first < 0
+                 end
+                 last = rng.last
+                 if (last.is_a?(::Integer)) then
+                     last = self.type.size+last if last < 0
+                 end
+                 rng = first..last
+             end
+             if rng.is_a?(::Integer) && rng < 0 then
+                 rng = self.type.size+rng
+             end
+             if rng.respond_to?(:to_expr) then
+                 # Number range: convert it to an expression.
+                 rng = rng.to_expr
+             end 
+             if rng.is_a?(HDLRuby::Low::Expression) then
+                 # Index case
+                 return RefIndex.new(self.type.base,self.to_expr,rng)
+             else
+                 # Range case, ensure it is made among expression.
+                 first = rng.first.to_expr
+                 last = rng.last.to_expr
+                 # Abd create the reference.
+                 return RefRange.new(self.type.slice(first..last),
+                                     self.to_expr,first..last)
+             end
+         end
+
+         # And save it so that it can still be accessed if overidden.
+         alias_method orig_operator(:[]), :[]
+
+         # Converts to a select operator using current expression as
+         # condition for one of the +choices+.
+         #
+         # NOTE: +choices+ can either be a list of arguments or an array.
+         # If +choices+ has only two entries
+         # (and it is not a hash), +value+ will be converted to a boolean.
+         def mux(*choices)
+             # Process the choices.
+             choices = choices.flatten(1) if choices.size == 1
+             choices.map! { |choice| choice.to_expr }
+             # Generate the select expression.
+             return Select.new(choices[0].type,"?",self.to_expr,*choices)
+         end
 
 
 
@@ -2966,19 +3057,25 @@ module HDLRuby::High
         #
         # NOTE: it is converted afterward to an expression if required.
         def <=(expr)
+            # Generate a ref from self for the left of the transmit.
+            left = self.to_ref
             # Cast expr to self if required.
-            expr = expr.to_expr.match_type(self.type)
+            expr = expr.to_expr.match_type(left.type)
+            # Ensure expr is an expression.
+            expr = expr.to_expr
+            # Cast it to left if necessary.
+            expr = expr.as(left.type) unless expr.type.eql?(left.type)
             # Generate the transmit.
             if High.top_user.is_a?(HDLRuby::Low::Block) then
                 # We are in a block, so generate and add a Transmit.
                 High.top_user.
-                    # add_statement(Transmit.new(self.to_ref,expr.to_expr))
-                    add_statement(Transmit.new(self.to_ref,expr))
+                    # add_statement(Transmit.new(self.to_ref,expr))
+                    add_statement(Transmit.new(left,expr))
             else
                 # We are in a system type, so generate and add a Connection.
                 High.top_user.
-                    # add_connection(Connection.new(self.to_ref,expr.to_expr))
-                    add_connection(Connection.new(self.to_ref,expr))
+                    # add_connection(Connection.new(self.to_ref,expr))
+                    add_connection(Connection.new(left,expr))
             end
         end
     end
@@ -3229,7 +3326,7 @@ module HDLRuby::High
 
         # Creates a new reference from a +base+ reference and named +object+.
         def initialize(base,object)
-            # puts "New RefObjet with base=#{base}, object=#{object.name}"
+            # puts "New RefObjet with base=#{base}, object=#{object}"
             if object.respond_to?(:type) then
                 # Typed object, so typed reference.
                 super(object.type)
@@ -3246,6 +3343,11 @@ module HDLRuby::High
             @object = object
         end
 
+        # Clones.
+        def clone
+            return RefObject.new(self.base.clone,self.object)
+        end
+
         # Tell if the expression is constant.
         def constant?
             return self.base.constant?
@@ -3395,6 +3497,11 @@ module HDLRuby::High
         High = HDLRuby::High
         include HRef
 
+        # Clones.
+        def clone
+            return RefThis.new
+        end
+
         # Converts to a new reference.
         def to_ref
             return RefThis.new
@@ -4597,13 +4704,19 @@ module HDLRuby::High
         #     # Use it to create the new value.
         #     return Value.new(Bit[bstr.width],self)
         # end
+        
+        # Tell if the expression can be converted to a value.
+        def to_value?
+            return true
+        end
 
         # Converts to a new high-level value.
         def to_value
             # Convert the string to a bit string.
             bstr = BitString.new(self)
             # Use it to create the new value.
-            return Value.new(Bit[bstr.width],self)
+            # return Value.new(Bit[bstr.width],bstr)
+            return Value.new(Bit[self.length],bstr)
         end
         
         # Convert to a new high-level string expression
@@ -4717,9 +4830,6 @@ module HDLRuby::High
 
         # Converts to a new high-level expression.
         def to_expr
-            # expr = Concat.new(TypeTuple.new(:"",:little,*self.map do |elem|
-            #     elem.to_expr.type
-            # end))
             elems = self.map {|elem| elem.to_expr }
             typ= TypeTuple.new(:"",:little)
             elems.each {|elem| typ.add_type(elem.type) }
@@ -4730,7 +4840,6 @@ module HDLRuby::High
 
         # Converts to a new high-level reference.
         def to_ref
-            # expr = RefConcat.new
             expr = RefConcat.new(TypeTuple.new(:"",:little,*self.map do |elem|
                 elem.to_ref.type
             end))
@@ -4797,10 +4906,11 @@ module HDLRuby::High
             end
         end
 
-        # Add support of the left arrow operator.
-        def <=(expr)
-            self.to_expr <= expr
-        end
+        # Moved to HArrow.
+        # # Add support of the left arrow operator.
+        # def <=(expr)
+        #     self.to_expr <= expr
+        # end
 
         # Array construction shortcuts
 

data/lib/HDLRuby/hruby_high_fullname.rb

@@ -0,0 +1,82 @@
+require "HDLRuby/hruby_high"
+
+
+
+module HDLRuby::High
+
+##
+# Library for describing adding the fullname method to HDLRuby::High objects.
+#
+########################################################################
+
+    class SystemT
+
+        ## Returns the name of the signal with its hierarchy.
+        def fullname
+            @fullname ||= (self.parent ? self.parent.fullname + ":" : "") + 
+                self.name.to_s
+            return @fullname
+        end
+    end
+
+
+    ##
+    # Module for extending named classes with fullname (other than SystemT).
+    module WithFullname
+
+        ## Returns the name of the signal with its hierarchy.
+        def fullname
+            @fullname ||= self.parent.fullname + ":" + self.name.to_s
+            return @fullname
+        end
+
+    end
+
+    class Scope
+        include WithFullname
+    end
+
+
+    class Behavior
+
+        ## Returns the name of the signal with its hierarchy.
+        def fullname
+            return self.parent.fullname
+        end
+    end
+
+
+    class TimeBehavior
+
+        ## Returns the name of the signal with its hierarchy.
+        def fullname
+            return self.parent.fullname
+        end
+    end
+
+
+    class SignalI
+        include WithFullname
+    end
+
+    class SignalC
+        include WithFullname
+    end
+
+    class SystemI
+        include WithFullname
+    end
+
+    class Code
+        # TODO
+    end
+
+    class Block
+        include WithFullname
+    end
+
+    class TimeBlock
+        include WithFullname
+    end
+
+end

data/lib/HDLRuby/hruby_low.rb

@@ -57,6 +57,11 @@ module HDLRuby::Low
             end
         end
 
+        # Clears the parent.
+        def no_parent!
+            @parent = nil
+        end
+
         # Get the parent scope.
         def scope
             cur = self.parent
@@ -1456,6 +1461,10 @@ module HDLRuby::Low
     # The bit type leaf.
     class << ( Bit = Type.new(:bit) )
         include LLeaf
+        # Tells if the type is unsigned.
+        def unsigned?
+            return true
+        end
         # Tells if the type fixed point.
         def fixed?
             return true
@@ -1597,10 +1606,11 @@ module HDLRuby::Low
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
-            # General type comparison.
-            return false unless super(obj)
+            # # General type comparison.
+            # return false unless super(obj)
             # Specific comparison.
             return false unless obj.is_a?(TypeDef)
+            return false unless @name.eql?(obj.name)
             return false unless @def.eql?(obj.def)
             return true
         end
@@ -1675,8 +1685,8 @@ module HDLRuby::Low
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
-            # General type comparison.
-            return false unless super(obj)
+            # # General type comparison.
+            # return false unless super(obj)
             # Specific comparison.
             return false unless obj.is_a?(TypeVector)
             return false unless @base.eql?(obj.base)
@@ -1867,8 +1877,9 @@ module HDLRuby::Low
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
-            # General type comparison.
-            return false unless super(obj)
+            # # General type comparison.
+            # return false unless super(obj)
+            return false unless obj.is_a?(TypeTuple)
             # Specific comparison.
             idx = 0
             obj.each_type do |type|
@@ -2523,18 +2534,18 @@ module HDLRuby::Low
             self.value.each_deep(&ruby_block) if self.value
         end
 
-        # Comparison for hash: structural comparison.
-        def eql?(obj)
-            return false unless obj.is_a?(SignalI)
-            return false unless @name.eql?(obj.name)
-            return false unless @type.eql?(obj.type)
-            return true
-        end
+        # # Comparison for hash: structural comparison.
+        # def eql?(obj)
+        #     return false unless obj.is_a?(SignalI)
+        #     return false unless @name.eql?(obj.name)
+        #     return false unless @type.eql?(obj.type)
+        #     return true
+        # end
 
-        # Hash function.
-        def hash
-            return [@name,@type].hash
-        end
+        # # Hash function.
+        # def hash
+        #     return [@name,@type].hash
+        # end
 
         # Gets the bit width.
         def width
@@ -4594,7 +4605,8 @@ module HDLRuby::Low
                 # Yes so it is also a left value if it is a sub ref.
                 if parent.respond_to?(:ref) then
                     # It might nor be a sub ref.
-                    return parent.ref == self
+                    # return parent.ref == self
+                    return parent.ref.eql?(self)
                 else
                     # It is necessarily a sub ref (case of RefConcat for now).
                     return true
@@ -4602,7 +4614,8 @@ module HDLRuby::Low
             end
             # No, therefore maybe it is directly a left value.
             return (parent.is_a?(Transmit) || parent.is_a?(Connection)) &&
-                    parent.left == self
+                    # parent.left == self
+                parent.left.eql?(self)
         end
 
         # Tells if the expression is a right value.
@@ -4676,12 +4689,16 @@ module HDLRuby::Low
         # Creates a new value typed +type+ and containing +content+.
         def initialize(type,content)
             super(type)
-            unless content then
+            if content.nil? then
                 # Handle the nil content case.
                 unless type.eql?(Void) then
                     raise AnyError, "A value with nil content must have the Void type."
                 end
                 @content = content
+            elsif content.is_a?(FalseClass) then
+                @content = 0
+            elsif content.is_a?(TrueClass) then
+                @content = 1
             else
                 # Checks and set the content: Ruby Numeric and HDLRuby
                 # BitString are supported. Strings or equivalent are
@@ -4718,8 +4735,8 @@ module HDLRuby::Low
 
         # Comparison for hash: structural comparison.
         def eql?(obj)
-            # General comparison.
-            return false unless super(obj)
+            # # General comparison.
+            # return false unless super(obj)
             # Specific comparison.
             return false unless obj.is_a?(Value)
             return false unless @content.eql?(obj.content)
@@ -5118,7 +5135,7 @@ module HDLRuby::Low
 
 
     ##
-    # Describes a section operation (generalization of the ternary operator).
+    # Describes a selection operation (generalization of the ternary operator).
     #
     # NOTE: choice is using the value of +select+ as an index.
     class Select < Operation
@@ -5284,6 +5301,7 @@ module HDLRuby::Low
         # def initialize(expressions = [])
         def initialize(type,expressions = [])
             super(type)
+            # puts "Building concat=#{self} with direction=#{type.direction}\n"
             # Initialize the array of expressions that are concatenated.
             @expressions = []
             # Check and add the expressions.

data/lib/HDLRuby/hruby_low2c.rb

@@ -709,6 +709,10 @@ module HDLRuby::Low
             # Tells if the behavior is timed or not.
             res << " " * (level+1)*3
             res << "behavior->timed = #{time ? 1 : 0};\n"
+            
+            # Set the active time to 0.
+            res << " " * (level+1)*3
+            res << "behavior->active_time = 0;\n"
 
             # Is it a clocked behavior?
             events = self.each_event.to_a
@@ -858,6 +862,7 @@ module HDLRuby::Low
         #  +level+ is the hierachical level of the object.
         # def to_c(level = 0)
         def to_c(res,level = 0)
+
             # puts "Signal.to_c with name: #{Low2C.obj_name(self)}"
             # Declare the global variable holding the signal.
             res << "SignalI "
@@ -2546,6 +2551,7 @@ module HDLRuby::Low
         # Generates the C text for the equivalent HDLRuby code.
         # +level+ is the hierachical level of the object.
         def to_c(res,level = 0)
+            # puts "to_c fo concat=#{self} with type=#{self.type} and direction=#{self.type.direction}"
             # Save the value pool state.
             res << (" " * (level*3)) << "PV;\n"
             # Gather the content to concat.
@@ -2556,6 +2562,7 @@ module HDLRuby::Low
             end
             # Compute the resulting concatenation.
             res << (" " * ((level+1)*3))
+            # puts "self.type.direction=#{self.type.direction}\n"
             res << "sconcat(#{expressions.size},"
             res << (self.type.direction == :little ? "1" : "0")
             res << ");\n"