Class: HDLRuby::Low::RefName
- Inherits:
-
Ref
- Object
- Base::Expression
- Expression
- Ref
- HDLRuby::Low::RefName
- 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
Constant Summary
Constants included from Low2Symbol
Low2Symbol::Low2SymbolPrefix, Low2Symbol::Low2SymbolTable, Low2Symbol::Symbol2LowTable
Instance Attribute Summary collapse
-
#name ⇒ Object
readonly
The access name.
-
#ref ⇒ Object
readonly
The accessed reference.
Attributes inherited from Expression
Attributes included from Hparent
Instance Method Summary collapse
- #ancestor(my) ⇒ Object
-
#boolean_in_assign2select ⇒ Object
Converts booleans in assignments to select operators.
-
#casts_without_expression! ⇒ Object
Extracts the expressions from the casts.
-
#clone ⇒ Object
Clones the name references (deeply).
-
#each_deep(&ruby_block) ⇒ Object
Iterates over each object deeply.
-
#each_node(&ruby_block) ⇒ Object
(also: #each_expression)
Iterates over the reference children if any.
-
#each_node_deep(&ruby_block) ⇒ Object
Iterates over the nodes deeply if any.
-
#eql?(obj) ⇒ Boolean
Comparison for hash: structural comparison.
-
#explicit_types(type = nil) ⇒ Object
Explicit the types conversions in the index ref where +type+ is the expected type of the condition if any.
-
#from_systemI? ⇒ Boolean
Tells if it is a reference to a systemI signal.
-
#full_name ⇒ Object
Get the full name of the reference, i.e.
-
#get_systemI ⇒ Object
Gets the systemI the reference comes from if any.
-
#hash ⇒ Object
Hash function.
-
#initialize(type, ref, name) ⇒ RefName
constructor
Create a new named reference with +type+ accessing +ref+ with +name+.
-
#map_nodes!(&ruby_block) ⇒ Object
Maps on the children.
-
#path_each(&ruby_block) ⇒ Object
Iterates over the names of the path indicated by the reference.
-
#replace_expressions!(node2rep) ⇒ Object
Replaces sub expressions using +node2rep+ table indicating the node to replace and the corresponding replacement.
-
#resolve ⇒ Object
Resolves the name of the reference and return the corresponding object.
-
#set_name!(name) ⇒ Object
Sets the name.
-
#set_ref!(ref) ⇒ Object
Sets the base reference.
-
#to_another_verilog ⇒ Object
Used for instantiation (emergency procedure).
-
#to_c(res, level = 0, left = false) ⇒ Object
Generates the C text of the equivalent HDLRuby code.
-
#to_c_signal(res, level = 0) ⇒ Object
Generates the C text for reference as left value to a signal.
-
#to_hdr(level = 0) ⇒ Object
Generates the text of the equivalent hdr text.
-
#to_high ⇒ Object
Creates a new high range reference.
-
#to_verilog ⇒ Object
Converts the system to Verilog code using +renamer+ for producing Verilog-compatible names.
-
#to_vhdl(level = 0, std_logic = false) ⇒ Object
Generates the text of the equivalent HDLRuby::High code.
-
#use_name?(*names) ⇒ Boolean
Tell if the expression includes a signal whose name is one of +names+.
Methods inherited from Expression
#boolean?, #break_types!, #each_ref_deep, #extract_selects_to!, #immutable?, #leftvalue?, #replace_names!, #rightvalue?, #set_type!, #statement
Methods included from Low2Symbol
Methods included from Hparent
Constructor Details
#initialize(type, ref, name) ⇒ RefName
Create a new named reference with +type+ accessing +ref+ with +name+. def initialize(ref,name)
5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 |
# File 'lib/HDLRuby/hruby_low.rb', line 5586 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.
5582 5583 5584 |
# File 'lib/HDLRuby/hruby_low.rb', line 5582 def name @name end |
#ref ⇒ Object (readonly)
The accessed reference.
5579 5580 5581 |
# File 'lib/HDLRuby/hruby_low.rb', line 5579 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)
5677 5678 5679 |
# File 'lib/HDLRuby/hruby_low.rb', line 5677 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.
5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 |
# File 'lib/HDLRuby/hruby_low.rb', line 5602 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.
5649 5650 5651 5652 5653 5654 |
# File 'lib/HDLRuby/hruby_low.rb', line 5649 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.
5659 5660 5661 5662 5663 5664 5665 5666 |
# File 'lib/HDLRuby/hruby_low.rb', line 5659 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.
5621 5622 5623 5624 5625 5626 5627 5628 5629 |
# File 'lib/HDLRuby/hruby_low.rb', line 5621 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.
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
# 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 ⇒ Object
Get the full name of the reference, i.e. including the sub ref names if any.
5615 5616 5617 5618 |
# File 'lib/HDLRuby/hruby_low.rb', line 5615 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.
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 |
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 169 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.
5632 5633 5634 |
# File 'lib/HDLRuby/hruby_low.rb', line 5632 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.
5639 5640 5641 5642 5643 5644 5645 5646 |
# File 'lib/HDLRuby/hruby_low.rb', line 5639 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.
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 |
# File 'lib/HDLRuby/hruby_low_resolve.rb', line 196 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.
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)
2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 2780 def to_c(res,level = 0, left = false) # # puts "RefName to_c for #{self.name}" # self.resolve.to_c_signal(res,level+1) # res << "->" << (left ? "f_value" : "c_value") # return res # puts "RefName to_c for #{self.name}" res << (" " * (level*3)) # res << "d=" res << "push(" self.resolve.to_c_signal(res,level+1) res << "->" << (left ? "f_value" : "c_value") # res << ";\n" 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)
2799 2800 2801 2802 2803 2804 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 2799 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+.
5669 5670 5671 5672 5673 5674 |
# File 'lib/HDLRuby/hruby_low.rb', line 5669 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 |