HDLRuby 2.11.11 → 2.11.12

data/lib/HDLRuby/hruby_high.rb

@@ -26,6 +26,14 @@ module HDLRuby::High
         return HDLRuby::Infinity
     end
 
+    # Reimplementation of the Proc's curry that transmit the context for
+    # execution.
+    def curry_with_context(*args,&ruby_block)
+        return proc do |cxt,*new_args|
+            cxt.instance_exec(*(args+new_args),&ruby_block)
+        end
+    end
+
 
 
     ##
@@ -38,7 +46,7 @@ module HDLRuby::High
             # puts "eigen_extend for #{self} class=#{self.class}"
             obj.singleton_methods.each do |name|
                 next if name == :yaml_tag # Do not know why we need to skip
-                puts "name=#{name}"
+                # puts "name=#{name}"
                 self.define_singleton_method(name, &obj.singleton_method(name))
             end
         end
@@ -403,6 +411,11 @@ module HDLRuby::High
             return @scope
         end
 
+        # Converts to a new reference.
+        def to_ref
+            return RefObject.new(this,self)
+        end
+
         # Creates and adds a set of inputs typed +type+ from a list of +names+.
         #
         # NOTE: a name can also be a signal, is which case it is duplicated. 
@@ -1397,6 +1410,7 @@ module HDLRuby::High
         # Merge the included systems interface in +systemT+
         # NOTE: incompatible with further to_low transformation.
         def merge_included(systemT)
+            # puts "merge_included for scope=#{self.name} with behaviors=#{self.each_behavior.count}" 
             # Recurse on the sub.
             self.each_scope {|scope| scope.merge_included(systemT) }
             # Include for current scope.
@@ -1437,6 +1451,8 @@ module HDLRuby::High
                 end
                 # Adds its subscopes.
                 included.scope.each_scope do |scope|
+                    # Do not override scopes with same name since it is prioritary!
+                    next if !scope.name.empty? && systemT.scope.each_scope.find {|sc| sc.name == scope.name}
                     scope.no_parent!
                     systemT.scope.add_scope(scope)
                 end
@@ -1709,10 +1725,27 @@ module HDLRuby::High
             # Set the new method for the operator.
             self.define_singleton_method(comp_operator(operator)) do |*args|
                 # puts "Top user=#{HDLRuby::High.top_user}"
-                HDLRuby::High.top_user.instance_exec do
-                   sub do
-                        HDLRuby::High.top_user.instance_exec(*args,&ruby_block)
-                   end
+                HDLRuby::High.top_user.sub(HDLRuby.uniq_name) do
+                    ruby_block.call(*args)
+                end
+            end
+        end
+
+        # Redefinition of +operator+ when requiring the context to be passed
+        # as argument (normally only used internally).
+        def define_operator_with_context(operator,&ruby_block)
+            # Ensure there is a block.
+            ruby_block = proc {} unless block_given?
+            # Register the operator as overloaded.
+            @overloads ||= {}
+            @overloads[operator] = ruby_block
+            # Set the new method for the operator.
+            self.define_singleton_method(comp_operator(operator)) do |*args|
+                # puts "Top user=#{HDLRuby::High.top_user}"
+                HDLRuby::High.top_user.sub(HDLRuby.uniq_name) do
+                    # It is assumed that the first argument of the ruby_block
+                    # is the context in which it must be executed.
+                    ruby_block.call(self,*args)
                 end
             end
         end
@@ -1945,7 +1978,8 @@ module HDLRuby::High
                                    gtype)
             # Adds the possible overloaded operators.
             self.each_overload do |op,ruby_block|
-                gtype.define_operator(op,&(ruby_block.curry[*args]))
+                # gtype.define_operator(op,&(ruby_block.curry[*args]))
+                gtype.define_operator_with_context(op,&(High.curry_with_context(*args,&ruby_block)))
             end
             # Returns the resulting type
             return gtype
@@ -2051,10 +2085,10 @@ module HDLRuby::High
 
         # Converts the type to HDLRuby::Low and set its +name+.
         def to_low(name = self.name)
-            # return HDLRuby::Low::TypeTuple.new(name,self.direction,
-            #                    *@types.map { |type| type.to_low } )
-            typeTupleL = HDLRuby::Low::TypeTuple.new(name,self.direction,
-                               *@types.map { |type| type.to_low } )
+            # typeTupleL = HDLRuby::Low::TypeTuple.new(name,self.direction,
+            #                    *@types.map do |typ| typ.to_low  )
+            typeTupleL = HDLRuby::Low::TypeTuple.new(name,self.direction)
+            @types.each { |typ| typeTupleL.add_type(typ.to_low) }
             # # For debugging: set the source high object 
             # typeTupleL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = typeTupleL
@@ -2116,6 +2150,7 @@ module HDLRuby::High
                     gtype = type.generate(*args)
                     # And add it as a local type of the system.
                     HDLRuby::High.top_user.add_type(gtype)
+                    gtype
                 end
             end
         else
@@ -3208,6 +3243,7 @@ module HDLRuby::High
             #         expr.to_low
             #     end
             # )
+            i = 0
             concatL = HDLRuby::Low::Concat.new(self.type.to_low,
                 self.each_expression.map do |expr|
                     expr.to_low
@@ -3292,7 +3328,8 @@ module HDLRuby::High
 
         # Converts to a new event.
         def to_event
-            return Event.new(:change,self.to_ref)
+            # return Event.new(:change,self.to_ref)
+            return Event.new(:anyedge,self.to_ref)
         end
 
         # Iterate over the elements.
@@ -3370,8 +3407,19 @@ module HDLRuby::High
         def to_low
             # puts "to_low with base=#{@base} @object=#{@object}"
             # puts "@object.name=#{@object.name}"
-            refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
+            if @base.is_a?(RefThis) && 
+                    (@object.parent != High.top_user) &&
+                    (@object.parent != High.cur_system) &&
+                    (!@object.parent.name.empty?) then
+                # Need to have a hierachical access.
+                # puts "Indirect access for #{self.object.name}: #{self.object.parent.name}(#{self.object.parent.class}) != #{High.cur_system.name}(#{High.top_user.class})"
+                refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
+                                                     @object.parent.to_ref.to_low,@object.name)
+            else
+                # Direct access is enough.
+                refNameL = HDLRuby::Low::RefName.new(self.type.to_low,
                                              @base.to_ref.to_low,@object.name)
+            end
             # # For debugging: set the source high object 
             # refNameL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = refNameL
@@ -3801,11 +3849,15 @@ module HDLRuby::High
 
             # Hierarchical type allows access to sub references, so generate
             # the corresponding methods.
+            # For that first get the real type.
+            type = type.def while type.is_a?(TypeDef)
+            # Now process it if it is a structured type.
             if type.struct? then
                 type.each_name do |name|
+                    sig = SignalI.new(name,type.get_type(name),dir)
+                    self.add_signal(sig)
                     self.define_singleton_method(name) do
-                        RefObject.new(self.to_ref,
-                                    SignalI.new(name,type.get_type(name),dir))
+                        RefObject.new(self.to_ref,sig)
                     end
                 end
             end
@@ -3838,17 +3890,41 @@ module HDLRuby::High
 
         # Creates a positive edge event from the signal.
         def posedge
-            return Event.new(:posedge,self.to_ref)
+            # return Event.new(:posedge,self.to_ref)
+            # Is there any sub signals?
+            if self.each_signal.any? then
+                # Yes, make events with them instead.
+                return self.each_signal.map { |sig| sig.posedge }
+            else
+                # No, create a single event.
+                return Event.new(:posedge,self.to_ref)
+            end
         end
 
         # Creates a negative edge event from the signal.
         def negedge
-            return Event.new(:negedge,self.to_ref)
+            # return Event.new(:negedge,self.to_ref)
+            # Is there any sub signals?
+            if self.each_signal.any? then
+                # Yes, make events with them instead.
+                return self.each_signal.map { |sig| sig.negedge }
+            else
+                # No, create a single event.
+                return Event.new(:negedge,self.to_ref)
+            end
         end
 
         # Creates an edge event from the signal.
-        def edge
-            return Event.new(:edge,self.to_ref)
+        def anyedge
+            # return Event.new(:edge,self.to_ref)
+            # Is there any sub signals?
+            if self.each_signal.any? then
+                # Yes, make events with them instead.
+                return self.each_signal.map { |sig| sig.anyedge }
+            else
+                # No, create a single event.
+                return Event.new(:anyedge,self.to_ref)
+            end
         end
 
         # Converts to a new reference.
@@ -3871,6 +3947,10 @@ module HDLRuby::High
             # return HDLRuby::Low::SignalI.new(name,self.type.to_low)
             valueL = self.value ? self.value.to_low : nil
             signalIL = HDLRuby::Low::SignalI.new(name,self.type.to_low,valueL)
+            # Recurse on the sub signals if any.
+            self.each_signal do |sig|
+                signalIL.add_signal(sig.to_low)
+            end
             # # For debugging: set the source high object 
             # signalIL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = signalIL
@@ -3937,6 +4017,10 @@ module HDLRuby::High
             #                                  self.value.to_low)
             signalCL = HDLRuby::Low::SignalC.new(name,self.type.to_low,
                                              self.value.to_low)
+            # Recurse on the sub signals if any.
+            self.each_signal do |sig|
+                signalCL.add_signal(sig.to_low)
+            end
             # # For debugging: set the source high object 
             # signalCL.properties[:low2high] = self.hdr_id
             # self.properties[:high2low] = signalCL
@@ -4062,7 +4146,8 @@ module HDLRuby::High
         # +ruby_block+.
         #
         # NOTE: the else part is defined through the helse method.
-        def hif(condition, mode = nil, &ruby_block)
+        # def hif(condition, mode = nil, &ruby_block)
+        def hif(condition, mode = self.mode, &ruby_block)
             # Ensure there is a block.
             ruby_block = proc {} unless block_given?
             # Creates the if statement.
@@ -4327,8 +4412,8 @@ module HDLRuby::High
             # @location = caller_locations
             # Sets the current behavior
             @@cur_behavior = self
-            # Add the events.
-            events.each { |event| self.add_event(event) }
+            # Add the events (they may be hierarchical to flatten)
+            events.flatten.each { |event| self.add_event(event) }
             # Create and add the block.
             self.block = High.make_block(mode,&ruby_block)
             # Unset the current behavior
@@ -4982,19 +5067,21 @@ module HDLRuby::High
         def to_value
             str = self.to_s
             return nil if str[0] != "_" # Bit string are prefixed by "_"
-            # Remove the "_" not needed any longer.
-            str = str[1..-1]
             # Get and check the type
-            type = str[0]
-            if type == "0" or type == "1" or type == "z" or type == "Z" then
+            # type = str[0]
+            type = str[1]
+            if ["0", "1", "z", "Z", "o", "d", "h"].include?(type) then
                 # Default binary
                 type = "b"
             else
                 # Not a default type
-                str = str[1..-1]
+                # str = str[1..-1]
+                str = str[2..-1]
             end
-            return nil if str.empty?
             return nil unless ["b","u","s"].include?(type)
+            # Remove the "_"
+            str = str.delete("_")
+            return nil if str.empty?
             # Get the width if any.
             if str[0].match(/[0-9]/) then
                 width = str.scan(/[0-9]*/)[0]

data/lib/HDLRuby/hruby_low.rb

@@ -850,6 +850,7 @@ module HDLRuby::Low
         
         # Adds inner signal +signal+.
         def add_inner(signal)
+            # puts "adding inner signal: #{signal.name}(#{signal})"
             # Check and add the signal.
             unless signal.is_a?(SignalI)
                 raise AnyError,
@@ -1632,6 +1633,112 @@ module HDLRuby::Low
 
         alias_method :each_deep, :each_type_deep
 
+        # Tells if the type signed.
+        def signed?
+            return @def.signed?
+        end
+
+        # Tells if the type is unsigned.
+        def unsigned?
+            return @def.unsigned?
+        end
+
+        # Tells if the type is fixed point.
+        def fixed?
+            return @def.fixed?
+        end
+
+        # Tells if the type is floating point.
+        def float?
+            return @def.float?
+        end
+
+        # Tells if the type is a leaf.
+        def leaf?
+            return @def.leaf?
+        end
+
+        # Tells if the type of of vector kind.
+        def vector?
+            return @def.vector?
+        end
+
+        # Gets the bitwidth of the type, by default 0.
+        # Bit, signed, unsigned and Float base have a width of 1.
+        def width
+            return @def.width
+        end
+
+        # Gets the type max value if any.
+        # Default: not defined.
+        def max
+            return @def.max
+        end
+
+        # Gets the type min value if any.
+        # Default: not defined.
+        def min
+            return @def.min
+        end
+
+        # Get the direction of the type, little or big endian.
+        def direction
+            return @def.direction
+        end
+
+        # Tells if the type has a range.
+        def range?
+            return @def.range?
+        end
+
+        # Gets the range of the type, by default range is not defined.
+        def range
+            return @def.range
+        end
+
+        # Tells if the type has a base.
+        def base?
+            return @def.base?
+        end
+
+        # Gets the base type, by default base type is not defined.
+        def base
+            return @def.base
+        end
+
+        # Tells if the type has sub types.
+        def types?
+            return @def.types?
+        end
+
+        # Tells if the type is regular (applies for tuples).
+        def regular?
+            return @def.regular?
+        end
+
+        # Tells if the type has named sub types.
+        def struct?
+            return @def.struct?
+        end
+
+        # Tells if the type is hierarchical.
+        def hierarchical?
+            return @def.hierarchical?
+        end
+
+        # Tell if +type+ is equivalent to current type.
+        #
+        # NOTE: type can be compatible while not being equivalent, please
+        #       refer to `hruby_types.rb` for type compatibility.
+        def equivalent?(type)
+            return @def.equivalent?(type)
+        end
+
+        # Converts to a bit vector.
+        def to_vector
+            return @def.to_vector
+        end
+
     end
 
 
@@ -1925,7 +2032,7 @@ module HDLRuby::Low
         def each(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each) unless ruby_block
-            # A ruby block? Apply it on each input signal instance.
+            # A ruby block? Apply it on each sub name/type pair.
             @types.each(&ruby_block)
         end
 
@@ -1935,7 +2042,7 @@ module HDLRuby::Low
         def each_type(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each_type) unless ruby_block
-            # A ruby block? Apply it on each input signal instance.
+            # A ruby block? Apply it on each sub type.
             @types.each(&ruby_block)
         end
 
@@ -2021,16 +2128,18 @@ module HDLRuby::Low
     ##
     # Describes a structure type.
     class TypeStruct < Type
-        # Creates a new structure type named +name+ with +direction+ and 
+        attr_reader :direction
+
+        # Creates a new structure type named +name+ with direction +dir+ and 
         # whose hierachy is given by +content+.
-        def initialize(name,direction,content)
+        def initialize(name,dir,content)
             # Initialize the type.
             super(name)
 
             # Set the direction.
-            @direction = direction.to_sym
+            @direction = dir.to_sym
             unless [:little, :big].include?(@direction)
-                raise AnyError, "Invalid direction for a type: #{direction}"
+                raise AnyError, "Invalid direction for a type: #{dir}"
             end
 
             # Check and set the content.
@@ -2046,7 +2155,8 @@ module HDLRuby::Low
         # Comparison for hash: structural comparison.
         def eql?(obj)
             # General type comparison.
-            return false unless super(obj)
+            # return false unless super(obj)
+            return false unless obj.is_a?(TypeStruct)
             # Specific comparison.
             idx = 0
             obj.each_key do |name|
@@ -2078,8 +2188,13 @@ module HDLRuby::Low
         end
 
         # Gets a sub type by +name+.
+        # NOTE: +name+ can also be an index.
         def get_type(name)
-            return @types[name.to_sym]
+            if name.respond_to?(:to_sym) then
+                return @types[name.to_sym]
+            else
+                return @types.values[name.to_i]
+            end
         end
 
         # Iterates over the sub name/type pair.
@@ -2088,7 +2203,7 @@ module HDLRuby::Low
         def each(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each) unless ruby_block
-            # A ruby block? Apply it on each input signal instance.
+            # A ruby block? Apply it on each sub name/type pair.
             @types.each(&ruby_block)
         end
 
@@ -2098,17 +2213,27 @@ module HDLRuby::Low
         def each_type(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each_type) unless ruby_block
-            # A ruby block? Apply it on each input signal instance.
+            # A ruby block? Apply it on each sub type.
             @types.each_value(&ruby_block)
         end
 
+        # Iterates over the keys.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_key(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_key) unless ruby_block
+            # A ruby block? Apply it on each key.
+            @types.each_key(&ruby_block)
+        end
+
         # Iterates over the sub type names.
         #
         # Returns an enumerator if no ruby block is given.
         def each_name(&ruby_block)
             # No ruby block? Return an enumerator.
             return to_enum(:each_name) unless ruby_block
-            # A ruby block? Apply it on each input signal instance.
+            # A ruby block? Apply it on each name.
             @types.each_key(&ruby_block)
         end
 
@@ -2128,7 +2253,11 @@ module HDLRuby::Low
         #
         # NOTE: must be redefined for specific types.
         def width
-            return @types.reduce(0) {|sum,type| sum + type.width }
+            if @types.is_a?(Array) then
+                return @types.reduce(0) {|sum,type| sum + type.width }
+            else
+                return @types.each_value.reduce(0) {|sum,type| sum + type.width }
+            end
         end
 
         # # Checks the compatibility with +type+
@@ -2506,8 +2635,9 @@ module HDLRuby::Low
                 end
                 @value = val
                 val.parent = self
-            else
-                @value = nil
+            # For memory optimization: no  initialization if not used.
+            # else
+            #     @value = nil
             end
         end
 
@@ -2517,6 +2647,40 @@ module HDLRuby::Low
             false
         end
 
+        # Adds sub signal +sig+
+        def add_signal(sig)
+            # puts "add sub=#{sig.name} in signal=#{self}"
+            # Sets the hash of sub signals if none.
+            @signals = HashName.new unless @signals
+            # Check and add the signal.
+            unless sig.is_a?(SignalI)
+                raise AnyError,
+                      "Invalid class for a signal instance: #{sig.class}"
+            end
+            # if @signals.include?(sig) then
+            #     raise AnyError, "SignalI #{sig.name} already present."
+            # end
+            # Set its parent.
+            sig.parent = self
+            # And add it
+            @signals.add(sig)
+        end
+
+        # Gets a sub signal by name.
+        def get_signal(name)
+            return @signals ? @signals[name] : nil
+        end
+
+        # Iterates over the sub signals.
+        #
+        # Returns an enumerator if no ruby block is given.
+        def each_signal(&ruby_block)
+            # No ruby block? Return an enumerator.
+            return to_enum(:each_signal) unless ruby_block
+            # A ruby block? Apply it on each sub signal instance if any.
+            @signals.each(&ruby_block) if @signals
+        end
+
         # # Add decorator capability (modifies intialize to put after).
         # include Hdecorator
 
@@ -4717,8 +4881,15 @@ module HDLRuby::Low
                         content.is_a?(HDLRuby::BitString)
                     # content = HDLRuby::BitString.new(content.to_s)
                     content = content.to_s
-                    if self.type.unsigned? && content[0] != 0 then
-                        content = "0" + content.rjust(self.type.width,content[0])
+                    if self.type.unsigned? && content[0] != "0" then
+                        # content = "0" + content.rjust(self.type.width,content[0])
+                        if content[0] == "1" then
+                            # Do not extend the 1, but 0 instead.
+                            content = "0" + content.rjust(self.type.width,"0")
+                        else
+                            # But extend the other.
+                            content = "0" + content.rjust(self.type.width,content[0])
+                        end
                     end
                     content = HDLRuby::BitString.new(content)
                 end