Class: HDLRuby::Low::Case
- 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_low2seq.rb,
lib/HDLRuby/hruby_low2vhd.rb,
lib/HDLRuby/hruby_verilog.rb,
lib/HDLRuby/hruby_low2high.rb,
lib/HDLRuby/hruby_low_cleanup.rb,
lib/HDLRuby/hruby_low_mutable.rb,
lib/HDLRuby/hruby_low_skeleton.rb,
lib/HDLRuby/hruby_low_with_var.rb,
lib/HDLRuby/hruby_low_fix_types.rb,
lib/HDLRuby/hruby_low_bool2select.rb,
lib/HDLRuby/hruby_low_without_select.rb,
lib/HDLRuby/hruby_low_without_parinseq.rb,
lib/HDLRuby/hruby_low_without_namespace.rb,
lib/HDLRuby/hruby_low_casts_without_expression.rb
Overview
Extends the Case class with functionality for extracting expressions from cast.
Direct Known Subclasses
Constant Summary
Constants included from Low2Symbol
Low2Symbol::Low2SymbolPrefix, Low2Symbol::Low2SymbolTable, Low2Symbol::Symbol2LowTable
Instance Attribute Summary collapse
-
#default ⇒ Object
The default block.
-
#value ⇒ Object
readonly
The tested value.
Attributes included from Hparent
Instance Method Summary collapse
-
#add_when(w) ⇒ Object
Adds possible when case +w+.
-
#blocks2seq! ⇒ Object
Converts the par sub blocks to seq.
-
#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 Case (deeply).
-
#delete_related!(*names) ⇒ Object
Deletes the elements related to one of +names+: either they have one of the names or they use an element with these names.
-
#delete_unless!(keep) ⇒ Object
Removes the signals and corresponding assignments whose name is not in +keep+.
-
#delete_when!(w) ⇒ Object
Delete a when.
-
#each_block(&ruby_block) ⇒ Object
Iterates over the sub blocks.
-
#each_block_deep(&ruby_block) ⇒ Object
Iterates over all the blocks contained in the current block.
-
#each_deep(&ruby_block) ⇒ Object
Iterates over each object deeply.
-
#each_node(&ruby_block) ⇒ Object
Iterates over the children (including the value).
-
#each_node_deep(&ruby_block) ⇒ Object
Iterates over the nodes deeply if any.
-
#each_statement(&ruby_block) ⇒ Object
Iterates over each sub statement if any.
-
#each_statement_deep(&ruby_block) ⇒ Object
Iterates over all the statements contained in the current statement.
-
#each_when(&ruby_block) ⇒ Object
Iterates over the match cases.
-
#eql?(obj) ⇒ Boolean
Comparison for hash: structural comparison.
-
#explicit_types! ⇒ Object
Explicit the types conversions in the case.
-
#extract_declares! ⇒ Object
Extract the declares from the scope and returns them into an array.
-
#extract_selects! ⇒ Object
Extract the Select expressions.
-
#hash ⇒ Object
Hash function.
-
#initialize(value, default = nil, whens = []) ⇒ Case
constructor
Creates a new case statement whose excution flow is decided from +value+ with a possible cases given in +whens+ and +default + (can be set later).
-
#map_nodes!(&ruby_block) ⇒ Object
Maps on the children (including the value).
-
#map_whens!(&ruby_block) ⇒ Object
Maps on the whens.
-
#mix?(mode = nil) ⇒ Boolean
Tell if there is a mix block.
-
#par_in_seq2seq! ⇒ Object
Converts par blocks within seq blocks to seq blocks.
-
#replace_expressions!(node2rep) ⇒ Object
Replaces sub expressions using +node2rep+ table indicating the node to replace and the corresponding replacement.
-
#replace_names!(former, nname) ⇒ Object
Replaces recursively +former+ name by +nname+ until it is redeclared.
-
#set_default!(default) ⇒ Object
Sets the default.
-
#set_value!(value) ⇒ Object
Sets the value.
-
#to_c(res, level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby code.
-
#to_ch(res) ⇒ Object
Generates the content of the h file.
-
#to_hdr(level = 0) ⇒ Object
Generates the text of the equivalent hdr text.
-
#to_high ⇒ Object
Creates a new high case statement.
-
#to_seq! ⇒ Object
Convert the block to seq.
-
#to_upper_space! ⇒ Object
Moves the declarations to the upper namespace.
-
#to_verilog(spc = 3) ⇒ Object
def to_verilog(mode = nil).
-
#to_vhdl(vars, level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code.
-
#use_name?(*names) ⇒ Boolean
Tell if the statement includes a signal whose name is one of +names+.
-
#with_var(upper = nil) ⇒ Object
Converts to a variable-compatible case where +upper+ is the upper block if any.
Methods inherited from Statement
#add_blocks_code, #add_make_block, #behavior, #block, #break_types!, #parent_system, #scope, #top_block, #top_scope, #with_boolean!
Methods included from Low2Symbol
Methods included from Hparent
#hierarchy, #no_parent!, #scope
Constructor Details
#initialize(value, default = nil, whens = []) ⇒ Case
Creates a new case statement whose excution flow is decided from +value+ with a possible cases given in +whens+ and +default
- (can be set later)
3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 |
# File 'lib/HDLRuby/hruby_low.rb', line 3508 def initialize(value, default = nil, whens = []) # Check and set the value. unless value.is_a?(Expression) raise AnyError, "Invalid class for a value: #{value.class}" end super() @value = value # And set its parent. value.parent = self # Checks and set the default case if any. self.default = default if default # Check and add the whens. @whens = [] whens.each { |w| self.add_when(w) } end |
Instance Attribute Details
#default ⇒ Object
The default block.
3503 3504 3505 |
# File 'lib/HDLRuby/hruby_low.rb', line 3503 def default @default end |
#value ⇒ Object (readonly)
The tested value
3500 3501 3502 |
# File 'lib/HDLRuby/hruby_low.rb', line 3500 def value @value end |
Instance Method Details
#add_when(w) ⇒ Object
Adds possible when case +w+.
3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 |
# File 'lib/HDLRuby/hruby_low.rb', line 3561 def add_when(w) # Check +w+. unless w.is_a?(When) raise AnyError, "Invalid class for a when: #{w.class}" end # Add it. @whens << w # And set the parent of +w+. w.parent = self end |
#blocks2seq! ⇒ Object
Converts the par sub blocks to seq.
154 155 156 157 158 159 160 |
# File 'lib/HDLRuby/hruby_low2seq.rb', line 154 def blocks2seq! # Recurse on the whens. self.each_when(&:blocks2seq!) # Converts the default if any. self.default.blocks2seq! if self.default return self end |
#boolean_in_assign2select! ⇒ Object
Converts booleans in assignments to select operators.
135 136 137 138 139 140 141 142 143 144 |
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 135 def boolean_in_assign2select! # No need to apply on the value! # # Apply on the value. # self.set_value!(self.value.boolean_in_assign2select) # Apply on the whens. self.each_when(&:boolean_in_assign2select!) # Apply on the default if any. self.default.boolean_in_assign2select! if self.default return self end |
#casts_without_expression! ⇒ Object
Extracts the expressions from the casts.
120 121 122 123 124 125 126 127 128 129 |
# File 'lib/HDLRuby/hruby_low_casts_without_expression.rb', line 120 def casts_without_expression! # No need to apply on the value! # Apply on the value. self.set_value!(self.value.casts_without_expression!) # Apply on the whens. self.each_when(&:casts_without_expression!) # Apply on the default if any. self.default.casts_without_expression! if self.default return self end |
#clone ⇒ Object
Clones the Case (deeply)
3678 3679 3680 3681 3682 3683 3684 3685 |
# File 'lib/HDLRuby/hruby_low.rb', line 3678 def clone # Clone the default if any. default = @default ? @default.clone : nil # Clone the case. return Case.new(@value.clone,default,(@whens.map do |w| w.clone end) ) end |
#delete_related!(*names) ⇒ Object
Deletes the elements related to one of +names+: either they have one of the names or they use an element with these names. NOTE: only delete actual instantiated elements, types or systemTs are left as is.
970 971 972 973 974 975 976 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 970 def (*names) # Delete the whens whose match contains a signal whoses name is # in names. @whens.delete_if { |w| w.match.use_name?(*names) } # Recurse on the whens. @whens.each { |w| w.(*names) } end |
#delete_unless!(keep) ⇒ Object
Removes the signals and corresponding assignments whose name is not in +keep+.
157 158 159 160 161 162 |
# File 'lib/HDLRuby/hruby_low_cleanup.rb', line 157 def delete_unless!(keep) # Recurse on the whens. self.each_when {|w| w.delete_unless!(keep) } # Recurse on the default if any. self.default.delete_unless!(keep) if self.default end |
#delete_when!(w) ⇒ Object
Delete a when.
924 925 926 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 924 def delete_when!(w) @whens.delete(w) end |
#each_block(&ruby_block) ⇒ Object
Iterates over the sub blocks.
3637 3638 3639 3640 3641 3642 3643 3644 3645 |
# File 'lib/HDLRuby/hruby_low.rb', line 3637 def each_block(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_block) unless ruby_block # A ruby block? # Apply it on each when's block. self.each_when { |w| w.each_block(&ruby_block) } # And apply it on the default if any. ruby_block.call(@default) if @default end |
#each_block_deep(&ruby_block) ⇒ Object
Iterates over all the blocks contained in the current block.
3648 3649 3650 3651 3652 3653 3654 3655 3656 |
# File 'lib/HDLRuby/hruby_low.rb', line 3648 def each_block_deep(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_block_deep) unless ruby_block # A ruby block? # Apply it on each when's block. self.each_when { |w| w.each_block_deep(&ruby_block) } # And apply it on the default if any. @default.each_block_deep(&ruby_block) if @default end |
#each_deep(&ruby_block) ⇒ Object
Iterates over each object deeply.
Returns an enumerator if no ruby block is given.
3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 |
# File 'lib/HDLRuby/hruby_low.rb', line 3527 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 value. self.value.each_deep(&ruby_block) # Then apply on the whens. self.each_when do |w| w.each_deep(&ruby_block) end end |
#each_node(&ruby_block) ⇒ Object
Iterates over the children (including the value).
Returns an enumerator if no ruby block is given.
3615 3616 3617 3618 3619 3620 3621 3622 |
# File 'lib/HDLRuby/hruby_low.rb', line 3615 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 each child. ruby_block.call(@value) @whens.each(&ruby_block) ruby_block.call(@default) if @default end |
#each_node_deep(&ruby_block) ⇒ Object
Iterates over the nodes deeply if any.
3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 |
# File 'lib/HDLRuby/hruby_low.rb', line 3625 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 children @value.each_node_deep(&ruby_block) @whens.each { |w| w.each_node_deep(&ruby_block) } @default.each_node_deep(&ruby_block) if @default end |
#each_statement(&ruby_block) ⇒ Object
Iterates over each sub statement if any.
Returns an enumerator if no ruby block is given.
3592 3593 3594 3595 3596 3597 3598 3599 3600 |
# File 'lib/HDLRuby/hruby_low.rb', line 3592 def each_statement(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_statement) unless ruby_block # A ruby block? # Apply on each when. @whens.each { |w| w.each_statement(&ruby_block) } # And on the default if any. ruby_block.call(@default) if @default end |
#each_statement_deep(&ruby_block) ⇒ Object
Iterates over all the statements contained in the current statement.
3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 |
# File 'lib/HDLRuby/hruby_low.rb', line 3659 def each_statement_deep(&ruby_block) # No ruby statement? Return an enumerator. return to_enum(:each_statement_deep) unless ruby_block # A ruby block? # Apply it on self. ruby_block.call(self) # And apply it on each when's statement. self.each_when { |w| w.each_statement_deep(&ruby_block) } # And apply it on the default if any. @default.each_statement_deep(&ruby_block) if @default end |
#each_when(&ruby_block) ⇒ Object
Iterates over the match cases.
Returns an enumerator if no ruby block is given.
3605 3606 3607 3608 3609 3610 |
# File 'lib/HDLRuby/hruby_low.rb', line 3605 def each_when(&ruby_block) # No ruby block? Return an enumerator. return to_enum(:each_when) unless ruby_block # A ruby block? Apply it on each when case. @whens.each(&ruby_block) end |
#eql?(obj) ⇒ Boolean
Comparison for hash: structural comparison.
3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 |
# File 'lib/HDLRuby/hruby_low.rb', line 3541 def eql?(obj) return false unless obj.is_a?(Case) return false unless @value.eql?(obj.value) return false unless @whens.eql?(obj.instance_variable_get(:@whens)) idx = 0 obj.each_when do |w| return false unless @whens[idx].eql?(w) idx += 1 end return false unless idx == @whens.size return false unless @default.eql?(obj.default) return true end |
#explicit_types! ⇒ Object
Explicit the types conversions in the case.
162 163 164 165 166 167 168 169 |
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 162 def explicit_types! # Recurse on the value. self.set_value!(self.value.explicit_types) # Recurse on the whens, the match of each when must be of the # type of the value. self.each_when { |w| w.explicit_types!(self.value.type) } return self end |
#extract_declares! ⇒ Object
Extract the declares from the scope and returns them into an array.
NOTE: do not recurse into the sub scopes or behaviors!
626 627 628 629 630 631 632 633 634 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 626 def extract_declares! # # Recurse on the whens. # return self.each_when.map(&:extract_declares!) # # Recurse on the default if any. # self.default.extract_declares! if self.default res = self.each_when.map(&:extract_declares!) res += self.default.extract_declares! if self.default return res end |
#extract_selects! ⇒ Object
Extract the Select expressions.
Note: the default is not treated.
224 225 226 227 228 229 230 231 |
# File 'lib/HDLRuby/hruby_low_without_select.rb', line 224 def extract_selects! selects = [] # Work on the value. self.set_value!(self.value.extract_selects_to!(selects)) # Work on the whens. selects += self.each_when.map(&:extract_selects!).reduce(:+) return selects end |
#hash ⇒ Object
Hash function.
3556 3557 3558 |
# File 'lib/HDLRuby/hruby_low.rb', line 3556 def hash return [@value,@whens,@default].hash end |
#map_nodes!(&ruby_block) ⇒ Object
Maps on the children (including the value).
929 930 931 932 933 934 935 936 937 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 929 def map_nodes!(&ruby_block) # A block? Apply it on each child. @value = ruby_block.call(@value) map_whens!(&ruby_block) if @default then @default = ruby_block.call(@default) @default.parent = self unless @default.parent end end |
#map_whens!(&ruby_block) ⇒ Object
Maps on the whens.
915 916 917 918 919 920 921 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 915 def map_whens!(&ruby_block) @whens.map! do |w| w = ruby_block.call(w) w.parent = self unless w.parent w end end |
#mix?(mode = nil) ⇒ Boolean
Tell if there is a mix block. +mode+ is the mode of the upper block.
164 165 166 167 168 169 |
# File 'lib/HDLRuby/hruby_low2seq.rb', line 164 def mix?(mode = nil) # Recuse on the whens. return true if self.each_when.any? { |w| w.mix?(mode) } # Check the default if any. return self.default.mix?(mode) end |
#par_in_seq2seq! ⇒ Object
Converts par blocks within seq blocks to seq blocks.
85 86 87 88 89 90 |
# File 'lib/HDLRuby/hruby_low_without_parinseq.rb', line 85 def par_in_seq2seq! self.each_when do |w| w.statement.par_in_seq2seq! end self.default.par_in_seq2seq! if self.default 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.
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 945 def replace_expressions!(node2rep) # First recurse on the children. res = {} self.each_node do |node| res.merge!(node.replace_expressions!(node2rep)) end # Is there a replacement to do on the value? rep = node2rep[self.value] if rep then # Yes, do it. rep = rep.clone node = self.value # node.set_parent!(nil) self.set_value!(rep) # And register the replacement. res[node] = rep end return res end |
#replace_names!(former, nname) ⇒ Object
Replaces recursively +former+ name by +nname+ until it is redeclared.
637 638 639 640 641 642 643 644 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 637 def replace_names!(former,nname) # Recurse on the value. self.value.replace_names!(former,nname) # Recurse on the whens. self.each_when {|w| w.replace_names!(former,nname) } # Recurse on the default. self.default.replace_names!(former,nname) if self.default end |
#set_default!(default) ⇒ Object
Sets the default.
909 910 911 912 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 909 def set_default!(default) # Checks and set the default case if any. self.default = default end |
#set_value!(value) ⇒ Object
Sets the value.
898 899 900 901 902 903 904 905 906 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 898 def set_value!(value) # Check and set the value. unless value.is_a?(Expression) raise AnyError, "Invalid class for a value: #{value.class}" end @value = value # And set its parent. value.parent = self end |
#to_c(res, level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby code.
+level+ is the hierachical level of the object.
def to_c(level = 0)
def to_c(res,level = 0) # res = "" # Compute the selection value. res << " res << " " * (level+1)*3 # res << "Value value = " << self.value.to_c(level+1) << ";\n" res << "Value value = " self.value.to_c(res,level+1) res << ";\n" # Ensure the selection value is testable. res << " " * (level+1)*3 res << "if (is_defined_value(value)) {\n" # The condition is testable. # Generate the case as a succession of if statements. first = true self.each_when do |w| res << " " * (level+2)*3 if first then first = false else res << "else " end res << "if (value2integer(value) == " # res << "value2integer(" << w.match.to_c(level+2) << ")) {\n" res << "value2integer(" w.match.to_c(res,level+2) res << ")) {\n" # res << w.statement.to_c(level+3) w.statement.to_c(res,level+3) res << " " * (level+2)*3 res << "\n" end if self.default then res << " " * (level+2)*3 res << "else # res << self.default.to_c(level+3) self.default.to_c(res,level+3) res << " " * (level+2)*3 res << "\n" end # Close the case. res << " " * (level+1)*3 res << "}\n" res << " " * (level)*3 res << "}\n" # Return the resulting string. return res end Generates the text of the equivalent HDLRuby code. +level+ is the hierachical level of the object. def to_c(level = 0)
1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1749 def to_c(res,level = 0) # Compute the selection value. res << "{\n" self.value.to_c(res,level+1) res << " " * ((level+1)*3) res << "dup();\n" # Ensure the selection value is testable. res << " " * ((level+1)*3) res << "if (is_defined()) {\n" # The condition is testable. # Generate the case as a succession of if statements. # self.each_when do |w| # res << " " * ((level+2)*3) # res << "dup();\n" # res << " " * ((level+2)*3) # w.match.to_c(res,level+2) # res << "if (to_integer() == to_integer()) { \n" # w.statement.to_c(res,level+3) # res << " " * (level+2)*3 # res << "}\n" # end # if self.default then # res << " " * (level+2)*3 # res << "else {\n" # self.default.to_c(res,level+3) # res << " " * (level+2)*3 # res << "}\n" # end res << " " * ((level+2)*3) res << "int val=to_integer(), done=0;\n" self.each_when.with_index do |w,i| res << " " * ((level+2)*3) res << "if (!done) {\n" unless i == 0 res << " " * ((level+2)*3) w.match.to_c(res,level+2) res << "if (val == to_integer()) {\n" w.statement.to_c(res,level+3) res << " " * (level+3)*3 res << "done = 1;\n" res << " " * (level+2)*3 res << "}" unless i == 0 res << "}\n" end if self.default then res << " " * (level+2)*3 res << "if(!done) {\n" self.default.to_c(res,level+3) res << " " * (level+2)*3 res << "}\n" end # Close the case. res << " " * (level+1)*3 # res << "pop();\n" # Remove the testing value. res << " " * (level+1)*3 res << "}\n" res << " " * (level)*3 res << "}\n" # Return the resulting string. return res end |
#to_ch(res) ⇒ Object
Generates the content of the h file. def to_ch
1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1813 def to_ch(res) # res = "" # Recurse on the whens. # self.each_when {|w| res << w.to_ch } self.each_when {|w| w.to_ch(res) } # Recurse on the default statement. # res << self.default.to_ch if self.default self.default.to_ch(res) if self.default return res end |
#to_hdr(level = 0) ⇒ Object
Generates the text of the equivalent hdr text. +level+ is the hierachical level of the object.
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 |
# File 'lib/HDLRuby/hruby_low2hdr.rb', line 400 def to_hdr(level = 0) # The result string. res = " " * (level*3) # Generate the test. res << "hcase " << self.value.to_hdr(level) << "\n" # Generate the whens. self.each_when do |w| res << w.to_hdr(level) end # Generatethe default. if self.default then res << " " * (level*3) res << "helse do\n" res << self.default.to_hdr(level+1) res << " " * (level*3) res << "end\n" end # Return the resulting string. return res end |
#to_high ⇒ Object
Creates a new high case statement.
285 286 287 288 289 290 291 292 293 |
# File 'lib/HDLRuby/hruby_low2high.rb', line 285 def to_high # Is there a default? if self.default then # Yes, create the new case statement with it. return HDLRuby::High::Case.new(self.value.to_high, self.default.to_high, self.each_when.map { |w| w.to_high }) end end |
#to_seq! ⇒ Object
Convert the block to seq.
93 94 95 96 97 98 |
# File 'lib/HDLRuby/hruby_low_without_parinseq.rb', line 93 def to_seq! self.each_when do |w| w.statement.to_seq! end self.default.to_seq! if self.default end |
#to_upper_space! ⇒ Object
Moves the declarations to the upper namespace.
616 617 618 619 620 621 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 616 def to_upper_space! # Recurse on the whens. self.each_when(&:to_upper_space!) # Recurse on the default if any. self.default.to_upper_space! if self.default end |
#to_verilog(spc = 3) ⇒ Object
def to_verilog(mode = nil)
Converts to Verilog code, checking if variables are register or wire adding 'spc' spaces at the begining of each line.
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 |
# File 'lib/HDLRuby/hruby_verilog.rb', line 1626 def to_verilog(spc = 3) result = " " * spc # Indented based on space_count. result << "case(#{self.value.to_verilog})\n" # n the case statement, each branch is partitioned by when. Process each time when. self.each_when do |whens| # Reads and stores the numbers and expressions stored in when. result << " " * (spc+3) + "#{whens.match.to_verilog}: " if whens.statement.each_statement.count >= 1 then result << whens.statement.to_verilog(spc+3) << "\n" else result << ";\n" end end if self.default then result << " " * (spc+3) + "default: " if self.default.each_statement.count >= 1 then result << self.default.each_statement.map do |stmnt| stmnt.to_verilog(spc+3) end.join("\n") << "\n" else result << ";\n" end end result << " " * spc + "endcase\n" # Conclusion. return result # Return case after translation. end |
#to_vhdl(vars, level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code. +vars+ is the list of the variables and +level+ is the hierachical level of the object.
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 |
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 999 def to_vhdl(vars,level = 0) # The result string. res = " " * (level*3) # Generate the test. res << "case " << self.value.to_vhdl(level) << " is\n" # Generate the whens. self.each_when do |w| res << w.to_vhdl(vars,self.value.type,level) end # Generate teh default if any. if self.default then res << " " * (level*3) res << "when others =>\n" res << self.default.to_vhdl(vars,level+1) else # NOTE: some VHDL parsers are very picky about others, # even though all the cases have been treated through # "when" statements. res << " " * (level*3) res << "when others =>\n" end # Close the case. res << " " * (level*3) res << "end case;\n" # Return the resulting string. return res end |
#use_name?(*names) ⇒ Boolean
Tell if the statement includes a signal whose name is one of +names+. NOTE: for the case check only the value.
3673 3674 3675 |
# File 'lib/HDLRuby/hruby_low.rb', line 3673 def use_name?(*names) return @value.use_name?(*name) end |
#with_var(upper = nil) ⇒ Object
Converts to a variable-compatible case where +upper+ is the upper block if any.
NOTE: the result is a new case.
311 312 313 314 315 |
# File 'lib/HDLRuby/hruby_low_with_var.rb', line 311 def with_var(upper = nil) ndefault = self.default ? self.default.clone : nil return Case.new(self.value.clone,ndefault, self.each_when.map {|w| w.with_var(upper) }) end |