HDLRuby 3.0.0 → 3.2.0

data/lib/HDLRuby/hruby_low_without_namespace.rb

@@ -122,10 +122,17 @@ module HDLRuby::Low
             # Extract the connections of the sub scopes.
             cnxs = self.each_scope.map(&:extract_connections!).flatten
             # Reinsert them to self.
-            cnxs.each { |beh| self.add_connection(beh) }
+            cnxs.each { |cnx| self.add_connection(cnx) }
+
+            # The fix the RefName using sub scopes since their target have
+            # been deplaced to current scope and renamed.
+            self_scopes = self.each_scope.to_a
+            self.each_behavior { |beh| beh.fix_scope_refnames!(self_scopes) }
+            self.each_connection { |cnx| cnx.fix_scope_refnames!(self_scopes) }
 
             # Now can delete the sub scopes since they are empty.
-            self.each_scope.to_a.each { |scope| self.delete_scope!(scope) }
+            # self.each_scope.to_a.each { |scope| self.delete_scope!(scope) }
+            self_scopes.each { |scope| self.delete_scope!(scope) }
         end
 
         # Extract the behaviors from the scope and returns them into an array.
@@ -219,9 +226,10 @@ module HDLRuby::Low
         # in the internals.
         def replace_names_subs!(former,nname)
             # puts "replace_names_subs! for #{self} with former=#{former} and nname=#{nname}"
-            self.each_type do |type|
-                type.replace_names!(former,nname)
-            end
+            # No need? 
+            # self.each_type do |type|
+            #     type.replace_names!(former,nname)
+            # end
             self.each_systemT do |systemT|
                 systemT.replace_names!(former,nname)
             end
@@ -460,6 +468,13 @@ module HDLRuby::Low
             # Recurse on the block.
             self.block.replace_names!(former,nname)
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+          self.block.fix_scope_refnames!(scopes)
+          return self
+        end
     end
 
 
@@ -498,6 +513,34 @@ module HDLRuby::Low
                 node.break_types!(types)
             end
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+          # By default, does nothing.
+          return self
+        end
+    end
+
+
+    class Transmit
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            self.set_left!(self.left.fix_scope_refnames!(scopes))
+            self.set_right!(self.right.fix_scope_refnames!(scopes))
+            return self
+        end
+    end
+
+    class Connection
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            self.set_left!(self.left.fix_scope_refnames!(scopes))
+            self.set_right!(self.right.fix_scope_refnames!(scopes))
+            return self
+        end
     end
 
 
@@ -527,6 +570,16 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # By default: recurse.
+            self.map_nodes! do |node|
+                node.fix_scope_refnames!(scopes)
+            end
+            return self
+        end
     end
 
     
@@ -578,6 +631,24 @@ module HDLRuby::Low
             # Recurse on the no if any.
             self.no.replace_names!(former,nname) if self.no
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Fix the condition.
+            self.set_condition!(self.condition.fix_scope_refnames!(scopes))
+            # Recurse on the yes.
+            self.yes.fix_scope_refnames!(scopes)
+            # Recurse on the alternate ifs.
+            self.map_noifs! do |cond,stmnt|
+                cond = cond.fix_scope_refnames!(scopes)
+                stmnt = stmnt.fix_scope_refnames!(scopes)
+                [cond,stmnt]
+            end
+            # Recruse on the no if any.
+            self.no.fix_scope_refnames!(scopes) if self.no
+            return self
+        end
     end
 
 
@@ -618,6 +689,16 @@ module HDLRuby::Low
                 end
             end
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Fix the match.
+            self.set_match!(self.match.fix_scope_refnames!(scopes))
+            # Recurse on the statement.
+            self.statement.fix_scope_refnames!(scopes)
+            return self
+        end
     end
 
 
@@ -655,6 +736,18 @@ module HDLRuby::Low
             # Recurse on the default.
             self.default.replace_names!(former,nname) if self.default
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Fix the value.
+            self.set_value!(self.value.fix_scope_refnames!(scopes))
+            # Recurse on the whens.
+            self.each_when {|w| w.fix_scope_refnames!(scopes) }
+            # Recurse on the default.
+            self.default.fix_scope_refnames!(scopes) if self.default
+            return self
+        end
     end
 
 
@@ -681,6 +774,14 @@ module HDLRuby::Low
             # Recurse on the statement.
             self.statement.replace_names!(former,nname)
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            # Recurse on the statement.
+            self.statement.fix_scope_refnames!(scopes)
+            return self
+        end
     end
 
 
@@ -738,6 +839,33 @@ module HDLRuby::Low
             # Recurse on the sub scopes and behaviors.
             replace_names_subs!(former,nname)
         end
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            self.each_statement {|stmnt| stmnt.fix_scope_refnames!(scopes) }
+            return self
+        end
+    end
+
+
+    class RefName
+        include ForceName
+
+        # Fix the references names using scopes given in +scopes + list (they
+        # are marked to be deleted).
+        def fix_scope_refnames!(scopes)
+            return self unless self.ref.is_a?(RefName)
+            # puts "fix_scope_refnames! with self.name=#{name} and self.ref=#{self.ref}"
+            # Recurse on the ref.
+            self.set_ref!(self.ref.fix_scope_refnames!(scopes))
+            # Rename and curt the subref if referening to one of the scopes.
+            if scopes.find {|scope| scope.name == self.ref.name } then
+                self.ref.extend_name!(self)
+                self.set_ref!(RefThis.new)
+            end
+            return self
+        end
     end
 
 end

data/lib/HDLRuby/hruby_low_without_subsignals.rb

@@ -18,10 +18,24 @@ module HDLRuby::Low
         ## Extends the SystemT class with functionality for decomposing the
         #  hierachical signals in the statements.
 
+        # # Decompose the hierarchical signals in the statements.
+        # def signal2subs!
+        #     self.scope.signal2subs!
+        # end
+
         # Decompose the hierarchical signals in the statements.
-        def signal2subs!
+        # If +decompose_vec2d+ is true then also decompose 2 dimension vectors
+        # (e.g., for Verilog HDL that does not support handling such signals
+        #  as usual expressions).
+        def signal2subs!(decompose_vec2d = false)
+            @@decompose_vec2d = decompose_vec2d == true
             self.scope.signal2subs!
         end
+
+        ## Tell if 2d vector signals must be decomposed too.
+        def self.decompose_vec2d?
+            @@decompose_vec2d
+        end
     end
 
 
@@ -229,17 +243,41 @@ module HDLRuby::Low
         # Flatten a reference to a list of reference to leaf signals
         # from signal +sig+ and add to result to +subrefs+
         def flatten_to(sig,subrefs)
-            # puts "flatten_to with sig name=#{sig.name}"
-            # Work on the sub signals if any.
-            sig.each_signal do |sub|
-                # Create a reference for the sub.
-                subref = RefName.new(sub.type,self.clone,sub.name)
-                # Recruse on it.
-                subref.flatten_to(sub,subrefs)
-                # Was it a leaf?
-                unless sub.each_signal.any? then
-                    # Yes, add its new ref to the list of subs.
-                    subrefs << subref
+            # Shall we decompose 2d vectors, and is the current signal
+            # for one of them?
+            if SystemT.decompose_vec2d? and sig.type.is_a?(TypeVector) and
+                    sig.type.base.is_a?(TypeVector) then
+                # Is the reference used other than for a memory access?
+                unless self.parent.is_a?(RefIndex) then
+                    # Yes, do the decomposition.
+                    # Selects the direction.
+                    rng = sig.type.range
+                    if rng.first > rng.last then
+                        itr = (rng.last..rng.first).each
+                    else
+                        itr = rng.reverse_each
+                    end
+                    # Iterate on each element.
+                    itr.each do |i|
+                        # Create a reference fo the sub.
+                        subref = RefIndex.new(sig.type.base,self.clone,
+                                                  Value.new(TypeUnsigned.new(:""),i))
+                        # Add it.
+                        subrefs << subref
+                    end
+                end
+            else
+                # Work on the sub signals if any.
+                sig.each_signal do |sub|
+                    # Create a reference for the sub.
+                    subref = RefName.new(sub.type,self.clone,sub.name)
+                    # Recurse on it.
+                    subref.flatten_to(sub,subrefs)
+                    # Was it a leaf?
+                    unless sub.each_signal.any? then
+                        # Yes, add its new ref to the list of subs.
+                        subrefs << subref
+                    end
                 end
             end
         end
@@ -255,6 +293,7 @@ module HDLRuby::Low
         # Decompose the hierarchical signals in the statements.
         def signal2subs!
             # puts "signal2subs! for RefName: #{self.name}"
+            return self if self.type == void # Not a singal anyway.
             # Decompose it to a list of reference to each leaf sub signal.
             subrefs = []
             self.flatten_to(self.resolve,subrefs)

data/lib/HDLRuby/hruby_rcsim.rb

@@ -1000,7 +1000,30 @@ module HDLRuby::High
 
     class RefName
         ## Extends the RefName class for hybrid Ruby-C simulation.
-        # Should not be used with rcsim.
+        # Converted to RefRange.
+
+        # Generate the C description of the reference range (not ref name!).
+        def to_rcsim
+            # Convert the base to a bit vector.
+            type_base = Bit[self.ref.type.width]
+            # self.ref.parent = nil
+            # bit_base = Cast.new(type_base,self.ref)
+            bit_base = RCSim.rcsim_make_cast(type_base.to_rcsim,self.ref.to_rcsim)
+            # Compute range in bits of the field.
+            last = 0
+            self.ref.type.each.detect do |name,typ|
+                last += typ.width
+                name == self.name
+            end
+            first = last-self.type.width
+            last -= 1
+            # puts "name=#{self.name} first=#{first} last=#{last}"
+            type_int = Bit[type_base.width.width]
+            return RCSim.rcsim_make_refRange(self.type.to_rcsim,
+                                             Value.new(type_int,last).to_rcsim,
+                                             Value.new(type_int,first).to_rcsim,
+                                             bit_base)
+        end
     end
 
 

data/lib/HDLRuby/hruby_serializer.rb

@@ -23,7 +23,8 @@ module HDLRuby
                  Low::TypeSigned, Low::TypeUnsigned, Low::TypeFloat,
                  Low::TypeTuple, Low::TypeStruct,
                  Low::Behavior, Low::TimeBehavior, 
-                 Low::Event, Low::Block, Low::TimeBlock, Low::Code, 
+                 Low::Event, Low::Block, Low::TimeBlock, 
+                 Low::Program, Low::Code, 
                  Low::SignalI, Low::SignalC,
                  Low::SystemI, Low::Connection, 
                  Low::Transmit, Low::If, Low::Case, Low::When, Low::Cast,

data/lib/HDLRuby/hruby_types.rb

@@ -42,13 +42,13 @@ module HDLRuby
             elsif type.float? then
                 return type
             elsif self.signed? then
-                return self
+                if type.signed? then
+                    return self.width >= type.width ? self : type
+                else
+                    return self
+                end
             elsif type.signed? then
                 return type
-            elsif self.unsigned? then
-                return self
-            elsif type.unsigned? then
-                return type
             elsif self.width >= type.width then
                 return self
             else

data/lib/HDLRuby/hruby_values.rb

@@ -253,6 +253,7 @@ module HDLRuby
         # Cast to +type+.
         # NOTE: nodir tells if the direction is to be ignored.
         def cast(type,nodir = false)
+            # puts "cast with content=#{self.content} type.signed=#{type.signed?} type.width=#{type.width}"
             # Handle the direction.
             if !nodir && type.direction != self.type.direction then
                 if self.content.is_a?(Numeric) then
@@ -281,19 +282,18 @@ module HDLRuby
                     res_content.positive!
                 end
             end
-            if type.signed && res_content.is_a?(Numeric) && res_content >= (1 << (type.width-1)) then
+            if type.signed? && res_content.is_a?(Numeric) && res_content >= (1 << (type.width-1)) then
                 res_content = (-1 << type.width) + res_content
             end
-            # # truncs to the right size if necessary.
-            # if res_content.is_a?(BitString) then
-            #     res_content.trunc!(type.width)
-            # else 
-            #     res_content = self.trunc(res_content,type.width)
-            # end
             # Generate the resulting value.
+            # puts "res_content=#{res_content}"
             return self.class.new(type,res_content)
         end
 
+        def as(typ)
+            return self.cast(typ)
+        end
+
         # Concat the content of +vals+.
         def self.concat(*vals)
             # Compute the resulting type.