HDLRuby 2.11.10 → 2.11.12

data/lib/HDLRuby/hdr_samples/with_leftright.rb

@@ -0,0 +1,21 @@
+# A benchmark for the cases where a left value is also a right value
+# in a block without sensitivity list.
+system :leftright_bench do
+    [8].inner :l,:r0,:r1,:lr
+
+    par do
+        lr <= r0*2
+        l <= [lr[7],lr[6..0]].to_expr + r1
+    end
+
+    timed do
+        !10.ns
+        r0 <= 1
+        !10.ns
+        r1 <= 2
+        !10.ns
+        r0 <= 3
+        r1 <= 4
+        !10.ns
+    end
+end

data/lib/HDLRuby/hdr_samples/with_reduce.rb

@@ -6,33 +6,33 @@ system :with_reduce_bench do
     [64].inner :val64
 
     timed do
-        val <= _01101010
-        res <= val.reduce(_00000000,:+)
+        val <= _b01101010
+        res <= val.reduce(_b00000000,:+)
         !10.ns
         val <= _01010010
-        res <= val.reduce(_00000000,:+)
+        res <= val.reduce(_b00000000,:+)
         !10.ns
         val <= _01101111
-        res <= val.reduce(_00000000,:+)
+        res <= val.reduce(_b00000000,:+)
         !10.ns
-        val64 <= _0110101001101010011010100110101001101010011010100110101001101010
-        res <= val64.reduce(_00000000,:+)
+        val64 <= _b0110101001101010011010100110101001101010011010100110101001101010
+        res <= val64.reduce(_b00000000,:+)
         !10.ns
         res <= val64[7..0]
         !10.ns
-        res <= res.reduce(_00000000,:+)
+        res <= res.reduce(_b00000000,:+)
         !10.ns
         res <= val64[63..60]
         !10.ns
-        res <= res.reduce(_00000000,:+)
+        res <= res.reduce(_b00000000,:+)
         !10.ns
         val64 <= ~(val64 ^ val64)
-        res <= val64.reduce(_00000000,:+)
+        res <= val64.reduce(_b00000000,:+)
         !10.ns
-        val64[0] <= _0
-        val64[3] <= _0
-        val64[63] <= _0
-        res <= val64.reduce(_00000000,:+)
+        val64[0] <= _b0
+        val64[3] <= _b0
+        val64[63] <= _b0
+        res <= val64.reduce(_b00000000,:+)
         !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_ref_array.rb

@@ -10,16 +10,16 @@ system :with_concat do
     val3[6..3] <= val1[7..4]
 
     timed do
-        val0 <= _00001111
-        val1 <= _11000011
+        val0 <= _b00001111
+        val1 <= _b11000011
         count <= 0
         !10.ns
-        val0 <= _11110000
-        val1 <= _00111100
+        val0 <= _b11110000
+        val1 <= _b00111100
         count <= 1
         !10.ns
-        val0 <= _10101010
-        val1 <= _01010101
+        val0 <= _b10101010
+        val1 <= _b01010101
         count <= 2
         !10.ns
     end

data/lib/HDLRuby/hdr_samples/with_subsums.rb

@@ -20,13 +20,13 @@ system :with_concat do
     val6 <= bs.reduce(:+)
 
     timed do
-        val0 <= _1111000011110000
+        val0 <= _b1111000011110000
         count <= 0
         !10.ns
-        val0 <= _0000111100001111
+        val0 <= _b0000111100001111
         count <= 1
         !10.ns
-        val0 <= _1010101010101010
+        val0 <= _b1010101010101010
         count <= 2
         !10.ns
     end

data/lib/HDLRuby/hdr_samples/with_terminate.rb

@@ -2,9 +2,9 @@
 # A benchmark for testing the terminate statement.
 system :with_terminate do
     [8].constant cst0: 127
-    constant cst1: _1
-    [8].inner sig0: _10000000
-    inner sig1: _1
+    constant cst1: _b1
+    [8].inner sig0: _b10000000
+    inner sig1: _b1
     [8].inner :sig2
     [8].inner count: 0
 

data/lib/HDLRuby/hdr_samples/with_to_a.rb

@@ -52,26 +52,26 @@ system :with_to_a_bench do
     four2sixfour(:my_four2sixfour).(four,*(sixfour.to_a.reverse))
 
     timed do
-        val <= _01101010
+        val <= _b01101010
         res <= vals.reverse
         !10.ns
-        val64 <= _0110101001101010011010100110101001101010011010100110101001101010
+        val64 <= _b0110101001101010011010100110101001101010011010100110101001101010
         res64 <= val64s.reverse
         !10.ns
-        val <= _00000000
-        val64 <= _0000000000000000000000000000000000000000000000000000000000000000
+        val <= _b00000000
+        val64 <= _b0000000000000000000000000000000000000000000000000000000000000000
         !10.ns
         vals.each.with_index do |v,i|
-            v <= (i/2) & _1
+            v <= (i/2) & _b1
         end
         res <= val
         !10.ns
         val64s.each.with_index do |v,i|
-            v <= (i/2) & _1
+            v <= (i/2) & _b1
         end
         res64 <= val64
         !10.ns
-        val <= _01010011
+        val <= _b01010011
         !10.ns
         8.times do |i|
             val64s[i] <= val[i]
@@ -80,11 +80,11 @@ system :with_to_a_bench do
         end
         res64 <= val64
         !10.ns
-        four <= _0000
+        four <= _b0000
         !10.ns
-        four <= _0001
+        four <= _b0001
         !10.ns
-        four <= _1100
+        four <= _b1100
         !10.ns
     end
 end

data/lib/HDLRuby/hdr_samples/with_values.rb

@@ -11,7 +11,7 @@ system :with_values do
 
 
     timed do
-        v1  <= 0
+        v1  <= _b0
         v8  <= 0
         v16 <= 0
         v32 <= 0
@@ -19,7 +19,7 @@ system :with_values do
         v64 <= 0
         v96 <= 0
         !10.ns
-        v1  <= 1
+        v1  <= _b1
         v8  <= 1
         v16 <= 1
         v32 <= 1
@@ -27,7 +27,7 @@ system :with_values do
         v64 <= 1
         v96 <= 1
         !10.ns
-        v1  <= _1010[2]
+        v1  <= _b1010[2]
         v8  <= _uhFF00[12..4]
         !10.ns
         v8  <= 128

data/lib/HDLRuby/hdrcc.rb

@@ -60,6 +60,7 @@ require 'HDLRuby/hruby_check.rb'
 require 'HDLRuby/hruby_low2hdr'
 require 'HDLRuby/hruby_low2c'
 require 'HDLRuby/hruby_low2vhd'
+require 'HDLRuby/hruby_low_without_subsignals'
 require 'HDLRuby/hruby_low_fix_types'
 # require 'HDLRuby/hruby_low_expand_types' # For now dormant
 require 'HDLRuby/hruby_low_without_outread'
@@ -641,8 +642,12 @@ elsif $options[:clang] then
     # top_system = $top_system
     # Preprocess the HW description for valid C generation.
     $top_system.each_systemT_deep do |systemT|
+        HDLRuby.show? "signal2subs step..."
+        # Ensure there is not implicit assign to sub signals.
+        systemT.signal2subs!
+        HDLRuby.show? "#{Time.now}#{show_mem}"
         HDLRuby.show? "seq2seq step..."
-        # Coverts the par blocks in seq blocks to seq blocks to match
+        # Converts the par blocks in seq blocks to seq blocks to match
         # the simulation engine.
         systemT.par_in_seq2seq!
         HDLRuby.show? "#{Time.now}#{show_mem}"
@@ -801,6 +806,9 @@ elsif $options[:verilog] then
     # top_system = $top_system
     # Make description compatible with verilog generation.
     $top_system.each_systemT_deep do |systemT|
+        HDLRuby.show? "signal2subs step..."
+        # Ensure there is not implicit assign to sub signals.
+        systemT.signal2subs!
         # HDLRuby.show "casts_without_expression! step..."
         # systemT.casts_without_expression!
         # HDLRuby.show Time.now
@@ -889,6 +897,8 @@ elsif $options[:rcsim] then
     require 'HDLRuby/hruby_rcsim.rb'
     # Merge the included from the top system.
     $top_system.merge_included!
+    # Process par in seq.
+    $top_system.par_in_seq2seq!
     # Generate the C data structures.
     $top_system.to_rcsim
     HDLRuby.show "Executing the hybrid C-Ruby-level simulator..."
@@ -902,6 +912,9 @@ elsif $options[:vhdl] then
     # top_system = $top_system
     # Make description compatible with vhdl generation.
     $top_system.each_systemT_deep do |systemT|
+        HDLRuby.show? "signal2subs step..."
+        # Ensure there is not implicit assign to sub signals.
+        systemT.signal2subs!
         systemT.outread2inner!            unless $options[:vhdl08] || $options[:alliance]
         systemT.with_boolean!
         systemT.boolean_in_assign2select! unless $options[:alliance]

data/lib/HDLRuby/hruby_bstr.rb

@@ -225,6 +225,7 @@ module HDLRuby
         #       * when index is larger than the bit width, the bit string is
         #         X extended accordingly.
         def []=(index,value)
+            # puts "first @content=#{@content}"
             # Change inside the bit string, it is not know any longer if it
             # is specified or not
             @specified = nil
@@ -250,8 +251,8 @@ module HDLRuby
                     sign = @content[-1]
                     @content.concat([sign] * (right-@content.size+1))
                 end
+                # puts "left=#{left} right=#{right} sign=#{sign} @content=#{@content}"
                 if right >= left then
-                    # puts "left=#{left} right=#{right} value=#{value} (#{value.class})"
                     # Sets the value to a copy of the bit string.
                     @content[left..right] = value.is_a?(BitString) ?
                         value.raw_content[0..right-left] : 
@@ -412,10 +413,14 @@ module HDLRuby
             return @specified
         end
 
-        # # Coerces.
-        # def coerce(other)
-        #     return [BitString.new(other),self]
-        # end
+        # Coerces.
+        def coerce(other)
+            if other.is_a?(Numeric) && self.specified? then
+                return [other,self.to_i]
+            else
+                return [BitString.new(other),self]
+            end
+        end
 
         # String conversion table.
         B2S_T = [ "0", "1", "z", "x" ]

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]