HDLRuby 2.2.13 → 2.3.0

data/lib/HDLRuby/hruby_low2c.rb

@@ -546,9 +546,10 @@ module HDLRuby::Low
         #
         # NOTE: type tuples are converted to bit vector of their contents.
         def to_c(level = 0)
-            return "get_type_tuple(#{self.each.join(",") do |type|
-               type.to_c(level+1)
-            end})"
+            # return "get_type_tuple(#{self.each.to_a.join(",") do |type|
+            #    type.to_c(level+1)
+            # end})"
+            return self.to_vector.to_c(level)
         end
     end
 
@@ -1872,7 +1873,8 @@ module HDLRuby::Low
             res << "idx = value2integer(#{self.index.to_c(level+2)});\n"
             # Make the access.
             res << (" " * ((level+1)*3))
-            res << "dst = read_range(ref,idx,idx,#{self.ref.type.base.to_c(level)},dst);\n"
+            # res << "dst = read_range(ref,idx,idx,#{self.ref.type.base.to_c(level)},dst);\n"
+            res << "dst = read_range(ref,idx,idx,#{self.type.to_c(level)},dst);\n"
             # Restore the state of the value pool.
             res << (" " * ((level+1)*3))
             res << "set_value_pos(pool_state);\n"
@@ -1930,7 +1932,9 @@ module HDLRuby::Low
             res << "last = value2integer(#{self.range.last.to_c(level+2)});\n"
             # Make the access.
             res << (" " * ((level+1)*3))
-            res << "dst = #{command}_range(ref,first,last,#{self.ref.type.base.to_c(level)},dst);\n"
+            # res << "dst = #{command}_range(ref,first,last,#{self.ref.type.base.to_c(level)},dst);\n"
+            # puts "will read_range for #{self.ref.name} with width=#{self.ref.type.width} with base width=#{self.ref.type.base.width} with range=#{self.ref.type.range} with range=#{self.range.first.content}..#{self.range.last.content}"
+            res << "dst = #{command}_range(ref,first,last,#{self.type.base.to_c(level)},dst);\n"
             # Restore the state of the value pool.
             res << (" " * ((level+1)*3))
             res << "set_value_pos(pool_state);\n"
@@ -1961,6 +1965,7 @@ module HDLRuby::Low
         # Generates the C text for reference as left value to a signal.
         # +level+ is the hierarchical level of the object.
         def to_c_signal(level = 0)
+            # puts "to_c_signal with self=#{self.name}, resolve=#{self.resolve}"
             return "#{self.resolve.to_c_signal(level+1)}"
         end
     end

data/lib/HDLRuby/hruby_low2high.rb

@@ -566,7 +566,7 @@ module HDLRuby::Low
         # +level+ is the hierachical level of the object.
         def to_high(level = 0)
             return self.child.to_high(level) + 
-                ".cast(" + self.type.to_high(level) + ")"
+                ".as(" + self.type.to_high(level) + ")"
         end
     end
 

data/lib/HDLRuby/hruby_low2vhd.rb

@@ -345,31 +345,34 @@ module HDLRuby::Low
             res << " " * (level*3)
             res << "entity #{Low2VHDL.entity_name(self.name)} is\n"
             # The ports
-            res << " " * ((level+1)*3)
-            res << "port (\n"
-            # Inputs
-            self.each_input do |input|
-                res << " " * ((level+2)*3)
-                res << Low2VHDL.vhdl_name(input.name) << ": in " 
-                res << input.type.to_vhdl << ";\n"
-            end
-            # Outputs
-            self.each_output do |output|
-                res << " " * ((level+2)*3)
-                res << Low2VHDL.vhdl_name(output.name) << ": out " 
-                res << output.type.to_vhdl << ";\n"
-            end
-            # Inouts
-            self.each_inout do |inout|
-                res << " " * ((level+2)*3)
-                res << Low2VHDL.vhdl_name(inout.name) << ": inout " 
-                res << inout.type.to_vhdl << ";\n"
+            if self.each_input.any? || self.each_output.any? ||
+                   self.each_inout.any? then
+                res << " " * ((level+1)*3)
+                res << "port (\n"
+                # Inputs
+                self.each_input do |input|
+                    res << " " * ((level+2)*3)
+                    res << Low2VHDL.vhdl_name(input.name) << ": in " 
+                    res << input.type.to_vhdl << ";\n"
+                end
+                # Outputs
+                self.each_output do |output|
+                    res << " " * ((level+2)*3)
+                    res << Low2VHDL.vhdl_name(output.name) << ": out " 
+                    res << output.type.to_vhdl << ";\n"
+                end
+                # Inouts
+                self.each_inout do |inout|
+                    res << " " * ((level+2)*3)
+                    res << Low2VHDL.vhdl_name(inout.name) << ": inout " 
+                    res << inout.type.to_vhdl << ";\n"
+                end
+                # Remove the last ";" for conforming with VHDL syntax.
+                res[-2..-1] = "\n" if res[-2] == ";"
+                res << " " * ((level+1)*3)
+                # Close the port declaration.
+                res << ");\n"
             end
-            # Remove the last ";" for conforming with VHDL syntax.
-            res[-2..-1] = "\n" if res[-2] == ";"
-            res << " " * ((level+1)*3)
-            # Close the port declaration.
-            res << ");\n"
             # Close the entity
             res << " " * (level*3)
             res << "end #{Low2VHDL.entity_name(self.name)};\n\n"
@@ -617,7 +620,17 @@ module HDLRuby::Low
             # # Simply generates the redefined type.
             # return self.def.to_vhdl(level)
             # Simply use the name of the type.
-            return Low2VHDL.vhdl_name(self.name)
+            # Is it a composite type?
+            if (self.def.is_a?(TypeStruct) ||
+              (self.def.is_a?(TypeVector) && 
+                    (self.def.base.is_a?(TypeVector) || 
+                     self.def.base.is_a?(TypeStruct))))
+                # Yes, generate a VHDL type definition.
+                return Low2VHDL.vhdl_name(self.name)
+            else
+                # No, generates the defined type.
+                return self.def.to_vhdl(level)
+            end
         end
     end
 
@@ -745,29 +758,31 @@ module HDLRuby::Low
                 res << Low2VHDL.vhdl_name(self.block.name) << ": "
             end
             res << "process "
-            # Generate the senitivity list.
-            if self.each_event.any? then
-                # If there is a clock.
-                res << "("
-                res << self.each_event.map do |event|
-                    event.ref.to_vhdl(level)
-                end.join(", ")
-                res << ")"
-            else
-                # If no clock, generate the sensitivity list from the right
-                # values.
-                list = self.block.each_node_deep.select do |node|
-                    node.is_a?(RefName) && !node.leftvalue? && 
-                        !node.parent.is_a?(RefName) &&
-                        # Also skip the variables
-                        !vars.find {|var| var.name == node.name }
-                end.to_a
-                # Keep only one ref per signal.
-                list.uniq! { |node| node.name }
-                # Generate the sensitivity list from it.
-                res << "("
-                res << list.map {|node| node.to_vhdl(level) }.join(", ")
-                res << ")"
+            # Generate the senitivity list if not a timed block.
+            unless self.block.is_a?(TimeBlock) then
+                if self.each_event.any? then
+                    # If there is a clock.
+                    res << "("
+                    res << self.each_event.map do |event|
+                        event.ref.to_vhdl(level)
+                    end.join(", ")
+                    res << ")"
+                else
+                    # If no clock, generate the sensitivity list from the right
+                    # values.
+                    list = self.block.each_node_deep.select do |node|
+                        node.is_a?(RefName) && !node.leftvalue? && 
+                            !node.parent.is_a?(RefName) &&
+                            # Also skip the variables
+                            !vars.find {|var| var.name == node.name }
+                    end.to_a
+                    # Keep only one ref per signal.
+                    list.uniq! { |node| node.name }
+                    # Generate the sensitivity list from it.
+                    res << "("
+                    res << list.map {|node| node.to_vhdl(level) }.join(", ")
+                    res << ")"
+                end
             end
             res << "\n"
             # Generate the variables.

data/lib/HDLRuby/hruby_low_fix_types.rb

@@ -302,14 +302,16 @@ module HDLRuby::Low
                     end)
                 else
                     # No, it should be a tuple.
-                    return Concat.new(type,self.expressions.map.with_index do
+                    return Concat.new(type,
+                                      self.each_expression.map.with_index do
                         |expr,i|
                         expr.explicit_types(type.get_type(i))
                     end)
                 end
             else
                 # No, recurse on the sub expressions.
-                return Concat.new(self.type,self.expressions.map do |expr|
+                return Concat.new(self.type,
+                                  self.each_expression.map do |expr|
                     expr.explicit_types
                 end)
             end

data/lib/HDLRuby/hruby_low_mutable.rb

@@ -1069,7 +1069,8 @@ module HDLRuby::Low
             node2rep = node2reassign.map {|n,r| [n,r[0]] }.to_h
 
             # First recurse on the sub blocks.
-            self.each_block { |block| block.reassign_expressions!(node2rep) }
+            # self.each_block { |block| block.reassign_expressions!(node2rep) }
+            self.each_block { |block| block.reassign_expressions!(node2reassign) }
 
             # Now work on the block.
             # Replace on the statements.

data/lib/HDLRuby/hruby_low_resolve.rb

@@ -39,6 +39,7 @@ module HDLRuby::Low
         ## Find an inner object by +name+.
         #  NOTE: return nil if not found.
         def get_by_name(name)
+            # puts "getbyname for name=#{name} with self=#{self}"
             # Ensure the name is a symbol.
             name = name.to_sym
             # Look in the signals.
@@ -90,7 +91,7 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            return self.ref.from_systemI
+            return self.ref.from_systemI?
         end
     end
 
@@ -102,7 +103,7 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            return self.ref.from_systemI
+            return self.ref.from_systemI?
         end
     end
 
@@ -114,16 +115,17 @@ module HDLRuby::Low
 
         ## Tells if it is a reference to a systemI signal.
         def from_systemI?
-            # puts "from_systemI? for #{self.name}"
             # Look for the owner from the name hierarchy.
             if self.ref.is_a?(RefName) then
                 # Look in the parent hierachy for the sub reference name.
                 parent = self.parent
+                # puts "self.ref.name=#{self.ref.name}"
                 while parent
+                    # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
                         found = parent.get_by_name(self.ref.name)
                         # puts "found is a :#{found.class}"
-                        return found.is_a?(SystemI)
+                        return found.is_a?(SystemI) if found
                     end
                     parent = parent.parent
                 end
@@ -151,6 +153,7 @@ module HDLRuby::Low
                 parent = self.parent
                 # puts "parent=#{parent}"
                 while parent
+                    # puts "parent=#{parent}"
                     if parent.respond_to?(:get_by_name) then
                         found = parent.get_by_name(self.name)
                         return found if found

data/lib/HDLRuby/hruby_low_without_concat.rb

@@ -187,11 +187,13 @@ module HDLRuby::Low
                             # Generate the assignment.
                             block.add_statement(
                                 Transmit.new(ref.clone,
-                                RefIndex.new(aux.type.base, aux.clone, idx)))
+                                # RefIndex.new(aux.type.base, aux.clone, idx)))
+                                RefIndex.new(bit, aux.clone, idx)))
                         else
                             # Multi-bits.
                             # Compute the type of the right value.
-                            rtype = TypeVector.new(:"",aux.type.base,range)
+                            # rtype = TypeVector.new(:"",aux.type.base,range)
+                            rtype = TypeVector.new(:"",bit,range)
                             # Generate the range.
                             range = Value.new(Integer,range.first) ..
                                     Value.new(Integer,range.last)
@@ -272,11 +274,13 @@ module HDLRuby::Low
                             # Generate the assignment.
                             block.add_statement(
                                 Transmit.new(ref.clone,
-                                RefIndex.new(aux.type.base, aux.clone, idx)))
+                                # RefIndex.new(aux.type.base, aux.clone, idx)))
+                                RefIndex.new(bit, aux.clone, idx)))
                         else
                             # Multi-bits.
                             # Compute the type of the right value.
-                            rtype = TypeVector.new(:"",aux.type.base,range)
+                            # rtype = TypeVector.new(:"",aux.type.base,range)
+                            rtype = TypeVector.new(:"",bit,range)
                             # Generate the range.
                             range = Value.new(Integer,range.first) ..
                                     Value.new(Integer,range.last)

data/lib/HDLRuby/hruby_types.rb

@@ -76,19 +76,21 @@ module HDLRuby
 
         # Addition.
         def +(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range + 1
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max + 1
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range + 1
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max + 1
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Subtraction
@@ -96,36 +98,40 @@ module HDLRuby
 
         # Multiplication
         def *(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range * 2
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max * 2
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range * 2
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max * 2
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Division
         def /(type)
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            # New type range: largest range 
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max 
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # # New type range: largest range 
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max 
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Modulo
@@ -151,26 +157,28 @@ module HDLRuby
 
         # And
         def &(type)
-            # puts "compute types with=#{self} and #{type}"
-            # Resolve the type class.
-            resolved = self.resolve(type)
-            
-            # Logical operation on non-vector types are kept as is.
-            return resolved unless resolved.is_a?(TypeVector)
-
-            # Otherwise the range is computed.
-            # New type range: largest range 
-            bounds = [ self.range.first.to_i, type.range.first.to_i,
-                       self.range.last.to_i, type.range.last.to_i ]
-            # puts "bounds=#{bounds}"
-            res_lsb =  bounds.min
-            res_msb = bounds.max 
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # puts "compute types with=#{self} and #{type}"
+            # # Resolve the type class.
+            # resolved = self.resolve(type)
+            # 
+            # # Logical operation on non-vector types are kept as is.
+            # return resolved unless resolved.is_a?(TypeVector)
+
+            # # Otherwise the range is computed.
+            # # New type range: largest range 
+            # bounds = [ self.range.first.to_i, type.range.first.to_i,
+            #            self.range.last.to_i, type.range.last.to_i ]
+            # # puts "bounds=#{bounds}"
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max 
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         # Or
@@ -211,19 +219,21 @@ module HDLRuby
 
         # Shift left
         def <<(type)
-            # The result type is the type of left.
-            resolved = self
-            # New type range: 2**(type width) times self range
-            bounds = [ self.range.first.to_i, self.range.last.to_i ]
-            res_lsb =  bounds.min
-            res_msb = bounds.max +
-                (2 ** ((type.range.last-type.range.first).abs))
-            # Create and return the new type: its endianess is the one of self
-            if self.range.first.to_i > self.range.last.to_i then
-                return resolved.make(:"",resolved.base,res_msb..res_lsb)
-            else
-                return resolved.make(:"",resolved.base,res_lsb..res_msb)
-            end
+            # # The result type is the type of left.
+            # resolved = self
+            # # New type range: 2**(type width) times self range
+            # bounds = [ self.range.first.to_i, self.range.last.to_i ]
+            # res_lsb =  bounds.min
+            # res_msb = bounds.max +
+            #     (2 ** ((type.range.last-type.range.first).abs))
+            # # Create and return the new type: its endianess is the one of self
+            # if self.range.first.to_i > self.range.last.to_i then
+            #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
+            # else
+            #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
+            # end
+            # The result is the resolve result now!
+            return self.resolve(type)
         end
 
         alias_method :ls, :<<