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_without_subsignals.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.
-
#signal2subs! ⇒ Object
Decompose the hierarchical signals in the statements.
-
#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)
3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 |
# File 'lib/HDLRuby/hruby_low.rb', line 3672 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.
3667 3668 3669 |
# File 'lib/HDLRuby/hruby_low.rb', line 3667 def default @default end |
#value ⇒ Object (readonly)
The tested value
3664 3665 3666 |
# File 'lib/HDLRuby/hruby_low.rb', line 3664 def value @value end |
Instance Method Details
#add_when(w) ⇒ Object
Adds possible when case +w+.
3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 |
# File 'lib/HDLRuby/hruby_low.rb', line 3725 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)
3842 3843 3844 3845 3846 3847 3848 3849 |
# File 'lib/HDLRuby/hruby_low.rb', line 3842 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.
977 978 979 980 981 982 983 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 977 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.
931 932 933 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 931 def delete_when!(w) @whens.delete(w) end |
#each_block(&ruby_block) ⇒ Object
Iterates over the sub blocks.
3801 3802 3803 3804 3805 3806 3807 3808 3809 |
# File 'lib/HDLRuby/hruby_low.rb', line 3801 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.
3812 3813 3814 3815 3816 3817 3818 3819 3820 |
# File 'lib/HDLRuby/hruby_low.rb', line 3812 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.
3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 |
# File 'lib/HDLRuby/hruby_low.rb', line 3691 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.
3779 3780 3781 3782 3783 3784 3785 3786 |
# File 'lib/HDLRuby/hruby_low.rb', line 3779 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.
3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 |
# File 'lib/HDLRuby/hruby_low.rb', line 3789 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.
3756 3757 3758 3759 3760 3761 3762 3763 3764 |
# File 'lib/HDLRuby/hruby_low.rb', line 3756 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.
3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 |
# File 'lib/HDLRuby/hruby_low.rb', line 3823 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.
3769 3770 3771 3772 3773 3774 |
# File 'lib/HDLRuby/hruby_low.rb', line 3769 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.
3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 |
# File 'lib/HDLRuby/hruby_low.rb', line 3705 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.
3720 3721 3722 |
# File 'lib/HDLRuby/hruby_low.rb', line 3720 def hash return [@value,@whens,@default].hash end |
#map_nodes!(&ruby_block) ⇒ Object
Maps on the children (including the value).
936 937 938 939 940 941 942 943 944 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 936 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.
922 923 924 925 926 927 928 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 922 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.
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 952 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.
912 913 914 915 916 917 918 919 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 912 def set_default!(default) # Checks and set the default case if any. if self.default then # There is a default first detach it. @default = nil end self.default = default end |
#set_value!(value) ⇒ Object
Sets the value.
901 902 903 904 905 906 907 908 909 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 901 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 |
#signal2subs! ⇒ Object
Decompose the hierarchical signals in the statements.
198 199 200 201 202 203 204 205 206 |
# File 'lib/HDLRuby/hruby_low_without_subsignals.rb', line 198 def signal2subs! # Recurse on the case value. self.set_value!(self.value.signal2subs!) # Recurse on the whens. self.each_when(&:signal2subs!) # Recurse on the default. self.set_default!(self.default.signal2subs!) if self.default return 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)
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 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1781 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
1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1845 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.
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 1026 |
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 1000 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.
3837 3838 3839 |
# File 'lib/HDLRuby/hruby_low.rb', line 3837 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 |