class HDLRuby::Low::RefName
Describes a name reference.
Describes a name reference.
Extends the RefName
class with generation of C text.
Extends the RefName
class with generation of hdr text.
Add the conversion to high.
Extends the RefName
class with generation of HDLRuby::High
text.
Extends the RefName
class with functionality for converting booleans in assignments to select operators.
Extends the RefName
class with functionality for converting booleans in assignments to select operators.
Extends the RefName
class with fixing of types and constants.
Describes a name reference.
Extends RefName
with the capability of finding the object it refered to.
Used to display variable names. Enhance RefName
with generation of verilog code.
Attributes
The access name.
The accessed reference.
Public Class Methods
Create a new named reference with type
accessing ref
with name
. def initialize(ref,name)
# File lib/HDLRuby/hruby_low.rb, line 5574 def initialize(type,ref,name) super(type) # Check and set the accessed reference. unless ref.is_a?(Ref) then raise AnyError, "Invalid class for a reference: #{ref.class}." end @ref = ref # And set its parent. ref.parent = self # Check and set the symbol. @name = name.to_sym end
Public Instance Methods
# File lib/HDLRuby/hruby_verilog.rb, line 1383 def ancestor(my) if my.parent.parent.respond_to? (:mode) then return ancestor(my.parent) else return "#{my.parent.mode.to_s}#{my.mode.to_s}" end end
Converts booleans in assignments to select operators.
# File lib/HDLRuby/hruby_low_bool2select.rb, line 314 def boolean_in_assign2select # Recurse on the sub references. return RefName.new(self.type, self.ref.boolean_in_assign2select, self.name) end
Extracts the expressions from the casts.
# File lib/HDLRuby/hruby_low_casts_without_expression.rb, line 322 def casts_without_expression # Recurse on the sub references. return RefName.new(self.type, self.ref.casts_without_expression, self.name) end
Clones the name references (deeply)
# File lib/HDLRuby/hruby_low.rb, line 5665 def clone return RefName.new(@type, @ref.clone, @name) end
Iterates over each object deeply.
Returns an enumerator if no ruby block is given.
# File lib/HDLRuby/hruby_low.rb, line 5590 def each_deep(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_deep) unless ruby_block # A ruby block? First apply it to current. ruby_block.call(self) # Then apply on the type. self.type.each_deep(&ruby_block) # Then apply on the reference. self.ref.each_deep(&ruby_block) end
Iterates over the reference children if any.
# File lib/HDLRuby/hruby_low.rb, line 5637 def each_node(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_node) unless ruby_block # A ruby block? Apply it on the child. ruby_block.call(@ref) end
Iterates over the nodes deeply if any.
# File lib/HDLRuby/hruby_low.rb, line 5647 def each_node_deep(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_node_deep) unless ruby_block # A ruby block? First apply it to current. ruby_block.call(self) # And recurse on the child. @ref.each_node_deep(&ruby_block) end
Comparison for hash: structural comparison.
# File lib/HDLRuby/hruby_low.rb, line 5609 def eql?(obj) # General comparison. return false unless super(obj) # Specific comparison. return false unless obj.is_a?(RefName) return false unless @name.eql?(obj.name) return false unless @ref.eql?(obj.ref) return true end
Explicit the types conversions in the index ref where type
is the expected type of the condition if any.
# File lib/HDLRuby/hruby_low_fix_types.rb, line 428 def explicit_types(type = nil) # Is there a type to match, if not use current one. type = self.type unless type # Cast if required and return the new reference. if self.type.eql?(type) then # No need to cast. return RefName.new(type,self.ref.explicit_types,self.name) else # Need a cast. return Cast.new(type, RefName.new(self.type,self.ref.explicit_types,self.name)) end end
Tells if it is a reference to a systemI signal.
# File lib/HDLRuby/hruby_low_resolve.rb, line 145 def from_systemI? # 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) if found end parent = parent.parent end # Not found, look further in the reference hierarchy. return self.ref.from_systemI? end # Not from a systemI. # puts "Not from systemI for #{self.name}" return false end
Get the full name of the reference, i.e. including the sub ref names if any.
# File lib/HDLRuby/hruby_low.rb, line 5603 def full_name name = self.ref.respond_to?(:full_name) ? self.ref.full_name : :"" return :"#{name}::#{self.name}" end
Hash
function.
# File lib/HDLRuby/hruby_low.rb, line 5620 def hash return [super,@name,@ref].hash end
Maps on the children.
# File lib/HDLRuby/hruby_low_mutable.rb, line 1920 def map_nodes!(&ruby_block) @ref = ruby_block.call(@ref) @ref.parent = self unless @ref.parent end
Iterates over the names of the path indicated by the reference.
Returns an enumerator if no ruby block is given.
# File lib/HDLRuby/hruby_low.rb, line 5627 def path_each(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:path_each) unless ruby_block # Recurse on the base reference. ref.path_each(&ruby_block) # Applies the block on the current name. ruby_block.call(@name) end
Replaces sub expressions using node2rep
table indicating the node to replace and the corresponding replacement. Returns the actually replaced nodes and their corresponding replacement.
NOTE: the replacement is duplicated.
# File lib/HDLRuby/hruby_low_mutable.rb, line 1931 def replace_expressions!(node2rep) # First recurse on the ref. res = self.ref.replace_expressions!(node2rep) # Is there a replacement to on the ref? rep = node2rep[self.ref] if rep then # Yes, do it. rep = rep.clone node = self.ref # node.set_parent!(nil) self.set_ref!(rep) # And register the replacement. res[node] = rep end return res end
Resolves the name of the reference and return the corresponding object. NOTE: return nil if could not resolve.
# File lib/HDLRuby/hruby_low_resolve.rb, line 172 def resolve # puts "Resolve with #{self} and name=#{self.name}" # First resolve the sub reference if possible. if self.ref.is_a?(RefName) then # puts "ref name=#{self.ref.name}" obj = self.ref.resolve # Look into the object for the name. return obj.get_by_name(self.name) else # Look in the parent hierachy for the name. 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 end parent = parent.parent end # Not found. return nil end end
Sets the name.
# File lib/HDLRuby/hruby_low_mutable.rb, line 1914 def set_name!(name) # Check and set the symbol. @name = name.to_sym end
Sets the base reference.
# File lib/HDLRuby/hruby_low_mutable.rb, line 1903 def set_ref!(ref) # Check and set the accessed reference. unless ref.is_a?(Ref) then raise AnyError, "Invalid class for a reference: #{ref.class}." end @ref = ref # And set its parent. ref.parent = self end
Used for instantiation (emergency procedure).
# File lib/HDLRuby/hruby_verilog.rb, line 1379 def to_another_verilog return "_#{self.name.to_s}" end
Generates the C text of the equivalent HDLRuby
code. level
is the hierachical level of the object and left
tells if it is a left value or not.
# File lib/HDLRuby/hruby_low2c.rb, line 2014 def to_c(level = 0, left = false) # puts "RefName to_c for #{self.name}" return "#{self.resolve.to_c_signal(level+1)}->" + (left ? "f_value" : "c_value") end
Generates the C text for reference as left value to a signal. level
is the hierarchical level of the object.
# File lib/HDLRuby/hruby_low2c.rb, line 2022 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
Generates the text of the equivalent hdr text. level
is the hierachical level of the object.
# File lib/HDLRuby/hruby_low2hdr.rb, line 706 def to_hdr(level = 0) # The resulting string. res = "" # Generates the sub reference if any. res << self.ref.to_hdr(level) << "." unless self.ref.is_a?(RefThis) # Generates the current reference. res << Low2HDR.hdr_use_name(self.name) # Returns the resulting string. return res end
Creates a new high range reference.
# File lib/HDLRuby/hruby_low2high.rb, line 495 def to_high return HDLRuby::High::RefName.new(self.type.to_high, self.ref.to_high, self.name) end
Converts the system to Verilog
code using renamer
for producing Verilog-compatible names.
# File lib/HDLRuby/hruby_verilog.rb, line 1372 def to_verilog vname = name_to_verilog(self.name) self.properties[:verilog_name] = vname return "#{vname}" end
Generates the text of the equivalent HDLRuby::High
code. level
is the hierachical level of the object. std_logic
tells if std_logic computation is to be done.
# File lib/HDLRuby/hruby_low2vhd.rb, line 1495 def to_vhdl(level = 0, std_logic = false) # The resulting string. res = "" # Generate the sub refs if any (case of struct). unless self.ref.is_a?(RefThis) then res << self.ref.to_vhdl(level) << "." end # Generates the current reference. res << Low2VHDL.vhdl_name(self.name) res << "(0)" if std_logic # Force to std_logic if required # Returns the resulting string. return res end
Tell if the expression includes a signal whose name is one of names
.
# File lib/HDLRuby/hruby_low.rb, line 5657 def use_name?(*names) # Is the named used here? return true if names.include?(@name) # No, recurse the reference. return @ref.use_name?(*names) end