HDLRuby 2.11.11 → 3.0.0

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
@@ -2010,7 +2044,7 @@ module HDLRuby::High
     end
 
     ##
-    # Describes a unsigned integer data type.
+    # Describes an unsigned integer data type.
     class TypeUnsigned < TypeVector
 
         # Creates a new vector type named +name+ from +base+ type and with
@@ -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
@@ -2820,17 +2855,17 @@ module HDLRuby::High
 
         # Casts to a bit vector type.
         def to_bit
-            return self.as(bit[self.width])
+            return self.as(HDLRuby::High.top_user.bit[self.type.width])
         end
 
         # Casts to an unsigned bit vector type.
         def to_unsigned
-            return self.as(unsigned[self.width])
+            return self.as(HDLRuby::High.top_user.unsigned[self.type.width])
         end
 
         # Casts to a signed bit vector type.
-        def to_unsigned
-            return self.as(signed[self.width])
+        def to_signed
+            return self.as(HDLRuby::High.top_user.signed[self.type.width])
         end
 
         # Extends on the left to +n+ bits filling with +v+ bit values.
@@ -2962,6 +2997,12 @@ module HDLRuby::High
              define_method(orig_operator(operator),&meth)
          end
 
+         # The <=> operator is also supported by is transformed into a sub
+         # with a signed result.
+         def <=>(expr)
+             return (self.as(self.type.base[self.type.width+1])-expr).to_signed
+         end
+
 
          # Creates an access to elements of range +rng+ of the signal.
          #
@@ -3153,7 +3194,7 @@ module HDLRuby::High
 
 
     ##
-    # 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 < Low::Select
@@ -3208,6 +3249,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 +3334,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.
@@ -3307,6 +3350,12 @@ module HDLRuby::High
             end
         end
 
+        # Get the refered objects.
+        def objects
+            return [ self.object] if self.is_a?(RefObject)
+            return self.each.map { |ref| ref.objects }.flatten
+        end
+
         # Reference can be used like enumerator
         include Enumerable
     end
@@ -3370,8 +3419,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 +3861,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 +3902,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 +3959,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 +4029,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 +4158,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.
@@ -4325,14 +4422,14 @@ module HDLRuby::High
             super(nil)
             # # Save the Location for debugging information
             # @location = caller_locations
-            # Sets the current behavior
-            @@cur_behavior = self
-            # Add the events.
-            events.each { |event| self.add_event(event) }
+            # # Sets the current behavior
+            # @@cur_behavior = self
+            # 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
-            @@cur_behavior = nil
+            # # Unset the current behavior
+            # @@cur_behavior = nil
         end
 
         # Sets an event to the behavior.
@@ -4499,12 +4596,21 @@ module HDLRuby::High
         end
     end
 
-    # The current behavior: by default none.
-    @@cur_behavior = nil
+    # # The current behavior: by default none.
+    # @@cur_behavior = nil
 
     # Gets the enclosing behavior if any.
     def self.cur_behavior
-        return @@cur_behavior
+        # return @@cur_behavior
+        if in_behavior? then
+            user = top_user
+            while(user && !user.is_a?(Behavior)) do
+                user = user.parent
+            end
+            return user
+        else
+            return nil
+        end
     end
 
     # Tell if we are in a behavior.
@@ -4680,13 +4786,10 @@ module HDLRuby::High
                 return Value.new(TypeSigned.new(:"",self.bit_length..0),self)
             end
         end
-    end
-    
-    # Extends the Float class for computing for conversion to expression.
-    class ::Float
-        # Converts to a new high-level expression.
-        def to_expr
-            return Value.new(Float,self)
+
+        # Gets the bit width
+        def width
+            return self.bit_length
         end
     end
 
@@ -4982,19 +5085,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_high_fullname.rb

@@ -5,10 +5,11 @@ require "HDLRuby/hruby_high"
 module HDLRuby::High
 
 ##
-# Library for describing adding the fullname method to HDLRuby::High objects.
+# Library for adding the fullname method to HDLRuby::High objects.
 #
 ########################################################################
 
+
     class SystemT
 
         ## Returns the name of the signal with its hierarchy.
@@ -32,6 +33,7 @@ module HDLRuby::High
 
     end
 
+
     class Scope
         include WithFullname
     end