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)



5793
5794
5795
5796
5797
5798
5799
5800
5801
5802
5803
5804
 
# File 'lib/HDLRuby/hruby_low.rb', line 5793

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.



5789
5790
5791
 
# File 'lib/HDLRuby/hruby_low.rb', line 5789

def name
  @name
end

#ref ⇒ Object (readonly)

The accessed reference.



5786
5787
5788
 
# File 'lib/HDLRuby/hruby_low.rb', line 5786

def ref
  @ref
end

Instance Method Details

#ancestor(my) ⇒ Object 



1448
1449
1450
1451
1452
1453
1454
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1448

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.



326
327
328
329
330
331
 
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 326

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)



5884
5885
5886
 
# File 'lib/HDLRuby/hruby_low.rb', line 5884

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.



5809
5810
5811
5812
5813
5814
5815
5816
5817
5818
 
# File 'lib/HDLRuby/hruby_low.rb', line 5809

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.



5856
5857
5858
5859
5860
5861
 
# File 'lib/HDLRuby/hruby_low.rb', line 5856

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.



5866
5867
5868
5869
5870
5871
5872
5873
 
# File 'lib/HDLRuby/hruby_low.rb', line 5866

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) 


5828
5829
5830
5831
5832
5833
5834
5835
5836
 
# File 'lib/HDLRuby/hruby_low.rb', line 5828

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.



447
448
449
450
451
452
453
454
455
456
457
458
459
 
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 447

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.



5822
5823
5824
5825
 
# File 'lib/HDLRuby/hruby_low.rb', line 5822

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.



5839
5840
5841
 
# File 'lib/HDLRuby/hruby_low.rb', line 5839

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.



5846
5847
5848
5849
5850
5851
5852
5853
 
# File 'lib/HDLRuby/hruby_low.rb', line 5846

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



1444
1445
1446
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1444

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)



2907
2908
2909
2910
2911
2912
2913
2914
2915
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 2907

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)



2920
2921
2922
2923
2924
2925
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 2920

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.



1437
1438
1439
1440
1441
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1437

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.



1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
 
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 1507

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) 


5876
5877
5878
5879
5880
5881
 
# File 'lib/HDLRuby/hruby_low.rb', line 5876

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