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