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_low2hdr.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,
lib/HDLRuby/hruby_low_casts_without_expression.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!, #immutable?, #leftvalue?, #replace_names!, #rightvalue?, #set_type!, #statement, #to_c_expr

Methods included from Low2Symbol

#to_sym

Methods included from Hparent

#hierarchy, #scope

Constructor Details

#initialize(type, ref, name) ⇒ RefName

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



5588
5589
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599
 
# File 'lib/HDLRuby/hruby_low.rb', line 5588

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.



5584
5585
5586
 
# File 'lib/HDLRuby/hruby_low.rb', line 5584

def name
  @name
end

#ref ⇒ Object (readonly)

The accessed reference.



5581
5582
5583
 
# File 'lib/HDLRuby/hruby_low.rb', line 5581

def ref
  @ref
end

Instance Method Details

#ancestor(my) ⇒ Object 



1440
1441
1442
1443
1444
1445
1446
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1440

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.



314
315
316
317
318
319
 
# 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! ⇒ Object

Extracts the expressions from the casts.



341
342
343
344
345
346
347
348
 
# File 'lib/HDLRuby/hruby_low_casts_without_expression.rb', line 341

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

#clone ⇒ Object

Clones the name references (deeply)



5679
5680
5681
 
# File 'lib/HDLRuby/hruby_low.rb', line 5679

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

#each_deep(&ruby_block) ⇒ Object

Iterates over each object deeply.

Returns an enumerator if no ruby block is given.



5604
5605
5606
5607
5608
5609
5610
5611
5612
5613
 
# File 'lib/HDLRuby/hruby_low.rb', line 5604

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_node(&ruby_block) ⇒ Object Also known as: each_expression

Iterates over the reference children if any.



5651
5652
5653
5654
5655
5656
 
# File 'lib/HDLRuby/hruby_low.rb', line 5651

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.



5661
5662
5663
5664
5665
5666
5667
5668
 
# File 'lib/HDLRuby/hruby_low.rb', line 5661

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) 


5623
5624
5625
5626
5627
5628
5629
5630
5631
 
# File 'lib/HDLRuby/hruby_low.rb', line 5623

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.



428
429
430
431
432
433
434
435
436
437
438
439
440
 
# 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? ⇒ Boolean

Tells if it is a reference to a systemI signal.

Returns:

  • (Boolean) 


170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 170

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.



5617
5618
5619
5620
 
# File 'lib/HDLRuby/hruby_low.rb', line 5617

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

#get_systemI ⇒ Object

Gets the systemI the reference comes from if any.



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 194

def get_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 if found.is_a?(SystemI)
            end
            parent = parent.parent
        end
        # Not found, look further in the reference hierarchy.
        return self.ref.get_systemI
    end
    # Not from a systemI.
    # puts "Not from systemI for #{self.name}"
    return nil
end

#hash ⇒ Object

Hash function.



5634
5635
5636
 
# File 'lib/HDLRuby/hruby_low.rb', line 5634

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

#map_nodes!(&ruby_block) ⇒ Object

Maps on the children.



1932
1933
1934
1935
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1932

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.



5641
5642
5643
5644
5645
5646
5647
5648
 
# File 'lib/HDLRuby/hruby_low.rb', line 5641

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.



1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1943

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.



221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 221

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
        # puts "obj=#{obj}"
        # 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
                # puts "get_by_name"
                found = parent.get_by_name(self.name)
                # puts "found" if found
                return found if found
            end
            parent = parent.parent
        end
        # Not found.
        # puts "Not found!"
        return nil
    end
end

#set_name!(name) ⇒ Object

Sets the name.



1926
1927
1928
1929
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1926

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

#set_ref!(ref) ⇒ Object

Sets the base reference.



1915
1916
1917
1918
1919
1920
1921
1922
1923
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1915

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).



1436
1437
1438
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1436

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

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

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. def to_c(level = 0, left = false)



2818
2819
2820
2821
2822
2823
2824
2825
2826
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 2818

def to_c(res,level = 0, left = false)
    # puts "RefName to_c for #{self.name}"
    res << (" " * (level*3))
    res << "push("
    self.resolve.to_c_signal(res,level+1)
    res << "->" << (left ? "f_value" : "c_value")
    res << ");\n"
    return res
end

#to_c_signal(res, level = 0) ⇒ Object

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)



2831
2832
2833
2834
2835
2836
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 2831

def to_c_signal(res,level = 0)
    # puts "to_c_signal with self=#{self.name}, resolve=#{self.resolve}"
    # return "#{self.resolve.to_c_signal(level+1)}"
    self.resolve.to_c_signal(res,level+1)
    return res
end

#to_hdr(level = 0) ⇒ Object

Generates the text of the equivalent hdr text. +level+ is the hierachical level of the object.



706
707
708
709
710
711
712
713
714
715
 
# 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 ⇒ Object

Creates a new high range reference.



495
496
497
498
499
 
# 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 ⇒ Object

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



1429
1430
1431
1432
1433
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1429

def to_verilog
    vname = name_to_verilog(self.name)
    # self.properties[:verilog_name] = vname
    return "#{vname}"
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.



1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
 
# 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) ⇒ Boolean

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

Returns:

  • (Boolean) 


5671
5672
5673
5674
5675
5676
 
# File 'lib/HDLRuby/hruby_low.rb', line 5671

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