Class: HDLRuby::Low::RefName

Inherits:
Ref show all
Defined in:
lib/HDLRuby/hruby_db.rb,
lib/HDLRuby/hruby_low.rb,
lib/HDLRuby/hruby_low2c.rb,
lib/HDLRuby/hruby_low2vhd.rb,
lib/HDLRuby/hruby_verilog.rb,
lib/HDLRuby/hruby_low2high.rb,
lib/HDLRuby/hruby_low_mutable.rb,
lib/HDLRuby/hruby_low_resolve.rb,
lib/HDLRuby/hruby_low_skeleton.rb,
lib/HDLRuby/hruby_low_fix_types.rb,
lib/HDLRuby/hruby_low_bool2select.rb

Overview

Extends the RefName class with functionality for converting booleans in assignments to select operators.

Direct Known Subclasses

High::RefName

Constant Summary

Constants included from Low2Symbol

Low2Symbol::Low2SymbolPrefix, Low2Symbol::Low2SymbolTable, Low2Symbol::Symbol2LowTable

Instance Attribute Summary collapse

Attributes inherited from Expression

#type

Attributes included from Hparent

#parent

Instance Method Summary collapse

Methods inherited from Expression

#boolean?, #break_types!, #each_ref_deep, #extract_selects_to!, #leftvalue?, #replace_names!, #rightvalue?, #set_type!, #statement

Methods included from Low2Symbol

#to_sym

Methods included from Hparent

#scope

Constructor Details

#initialize(type, ref, name) ⇒ RefName

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



4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
 
# File 'lib/HDLRuby/hruby_low.rb', line 4823

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

Instance Attribute Details

#name ⇒ Object (readonly)

The access name.



4819
4820
4821
 
# File 'lib/HDLRuby/hruby_low.rb', line 4819

def name
  @name
end

#ref ⇒ Object (readonly)

The accessed reference.



4816
4817
4818
 
# File 'lib/HDLRuby/hruby_low.rb', line 4816

def ref
  @ref
end

Instance Method Details

#ancestor(my) ⇒ Object 



1328
1329
1330
1331
1332
1333
1334
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1328

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 ⇒ Object

Converts booleans in assignments to select operators.



300
301
302
303
304
305
 
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 300

def boolean_in_assign2select
    # Recurse on the sub references.
    return RefName.new(self.type,
                       self.ref.boolean_in_assign2select,
                       self.name)
end

#clone ⇒ Object

Clones the name references (deeply)



4900
4901
4902
 
# File 'lib/HDLRuby/hruby_low.rb', line 4900

def clone
    return RefName.new(@type, @ref.clone, @name)
end

#each_node(&ruby_block) ⇒ Object Also known as: each_expression

Iterates over the reference children if any.



4872
4873
4874
4875
4876
4877
 
# File 'lib/HDLRuby/hruby_low.rb', line 4872

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

#each_node_deep(&ruby_block) ⇒ Object

Iterates over the nodes deeply if any.



4882
4883
4884
4885
4886
4887
4888
4889
 
# File 'lib/HDLRuby/hruby_low.rb', line 4882

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) ⇒ Boolean

Comparison for hash: structural comparison.

Returns:

  • (Boolean) 


4844
4845
4846
4847
4848
4849
4850
4851
4852
 
# File 'lib/HDLRuby/hruby_low.rb', line 4844

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) ⇒ Object

Explicit the types conversions in the index ref where type is the expected type of the condition if any.



414
415
416
417
418
419
420
421
422
423
424
425
426
 
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 414

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? ⇒ Boolean

Tells if it is a reference to a systemI signal.

Returns:

  • (Boolean) 


117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 117

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 ⇒ Object

Get the full name of the reference, i.e. including the sub ref names if any.



4838
4839
4840
4841
 
# File 'lib/HDLRuby/hruby_low.rb', line 4838

def full_name
    name = self.ref.respond_to?(:full_name) ? self.ref.full_name : :""
    return :"#{name}::#{self.name}"
end

#hash ⇒ Object

Hash function.



4855
4856
4857
 
# File 'lib/HDLRuby/hruby_low.rb', line 4855

def hash
    return [super,@name,@ref].hash
end

#map_nodes!(&ruby_block) ⇒ Object

Maps on the children.



1850
1851
1852
1853
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1850

def map_nodes!(&ruby_block)
    @ref = ruby_block.call(@ref)
    @ref.parent = self unless @ref.parent
end

#path_each(&ruby_block) ⇒ Object

Iterates over the names of the path indicated by the reference.

Returns an enumerator if no ruby block is given.



4862
4863
4864
4865
4866
4867
4868
4869
 
# File 'lib/HDLRuby/hruby_low.rb', line 4862

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) ⇒ Object

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.



1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1861

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 ⇒ Object

Resolves the name of the reference and return the corresponding object. NOTE: return nil if could not resolve.



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 144

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) ⇒ Object

Sets the name.



1844
1845
1846
1847
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1844

def set_name!(name)
    # Check and set the symbol.
    @name = name.to_sym
end

#set_ref!(ref) ⇒ Object

Sets the base reference.



1833
1834
1835
1836
1837
1838
1839
1840
1841
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1833

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 ⇒ Object

Used for instantiation (emergency procedure).



1324
1325
1326
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1324

def to_another_verilog
    return "_#{self.name.to_s}"
end

#to_c(level = 0, left = false) ⇒ Object

Generates the C text of the equivalent HDLRuby::High code. level is the hierachical level of the object and left tells if it is a left value or not.



1983
1984
1985
1986
1987
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1983

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) ⇒ Object

Generates the C text for reference as left value to a signal. level is the hierarchical level of the object.



1991
1992
1993
1994
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1991

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_high(level = 0) ⇒ Object

Generates the text of the equivalent HDLRuby::High code. level is the hierachical level of the object.



706
707
708
709
710
711
712
713
714
715
 
# File 'lib/HDLRuby/hruby_low2high.rb', line 706

def to_high(level = 0)
    # The resulting string.
    res = ""
    # Generates the sub reference if any.
    res << self.ref.to_high(level) << "." unless self.ref.is_a?(RefThis)
    # Generates the current reference.
    res << Low2High.high_use_name(self.name)
    # Returns the resulting string.
    return res
end

#to_verilog ⇒ Object

Converts the system to Verilog code using renamer for producing Verilog-compatible names.



1318
1319
1320
1321
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1318

def to_verilog
    # return "#{self.name.to_s}"
    return "#{name_to_verilog(self.name)}"
end

#to_vhdl(level = 0, std_logic = false) ⇒ Object

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.



1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
 
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 1470

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) ⇒ Boolean

Tell if the expression includes a signal whose name is one of names.

Returns:

  • (Boolean) 


4892
4893
4894
4895
4896
4897
 
# File 'lib/HDLRuby/hruby_low.rb', line 4892

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