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

name[R]

The access name.

ref[R]

The accessed reference.

Public Class Methods

new(type,ref,name) click to toggle source

Create a new named reference with type accessing ref with name. def initialize(ref,name)

Calls superclass method
# 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

ancestor(my) click to toggle source
# 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
boolean_in_assign2select() click to toggle source

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
casts_without_expression() click to toggle source

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
clone() click to toggle source

Clones the name references (deeply)

# File lib/HDLRuby/hruby_low.rb, line 5665
def clone
    return RefName.new(@type, @ref.clone, @name)
end
each_deep(&ruby_block) click to toggle source

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
each_expression(&ruby_block)
Alias for: each_node
each_node(&ruby_block) click to toggle source

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
Also aliased as: each_expression
each_node_deep(&ruby_block) click to toggle source

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
eql?(obj) click to toggle source

Comparison for hash: structural comparison.

Calls superclass method
# 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_types(type = nil) click to toggle source

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
from_systemI?() click to toggle source

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
full_name() click to toggle source

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() click to toggle source

Hash function.

Calls superclass method
# File lib/HDLRuby/hruby_low.rb, line 5620
def hash
    return [super,@name,@ref].hash
end
map_nodes!(&ruby_block) click to toggle source

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
path_each(&ruby_block) click to toggle source

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
replace_expressions!(node2rep) click to toggle source

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
resolve() click to toggle source

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
set_name!(name) click to toggle source

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
set_ref!(ref) click to toggle source

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
to_another_verilog() click to toggle source

Used for instantiation (emergency procedure).

# File lib/HDLRuby/hruby_verilog.rb, line 1379
def to_another_verilog
    return "_#{self.name.to_s}"
end
to_c(level = 0, left = false) click to toggle source

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
to_c_signal(level = 0) click to toggle source

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
to_hdr(level = 0) click to toggle source

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
to_high() click to toggle source

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
to_verilog() click to toggle source

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
to_vhdl(level = 0, std_logic = false) click to toggle source

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
use_name?(*names) click to toggle source

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