Class: HDLRuby::Low::Case
- Defined in:
- lib/HDLRuby/hruby_db.rb,
lib/HDLRuby/hruby_low.rb,
lib/HDLRuby/hruby_low2c.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_namespace.rb
Overview
Extends the When class with functionality for moving the declarations to the upper namespace.
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.
-
#clone ⇒ Object
Clones the Case (deeply).
-
#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_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_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.
-
#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(level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code.
-
#to_high(level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code.
-
#to_upper_space! ⇒ Object
Moves the declarations to the upper namespace.
- #to_verilog(mode = nil) ⇒ Object
-
#to_vhdl(vars, level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code.
-
#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, #block, #break_types!, #top_block, #top_scope, #with_boolean!
Methods included from Low2Symbol
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)
2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 |
# File 'lib/HDLRuby/hruby_low.rb', line 2996 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 @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.
2991 2992 2993 |
# File 'lib/HDLRuby/hruby_low.rb', line 2991 def default @default end |
#value ⇒ Object (readonly)
The tested value
2988 2989 2990 |
# File 'lib/HDLRuby/hruby_low.rb', line 2988 def value @value end |
Instance Method Details
#add_when(w) ⇒ Object
Adds possible when case +w+.
3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 |
# File 'lib/HDLRuby/hruby_low.rb', line 3050 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.
109 110 111 112 113 114 115 116 117 118 |
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 109 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 |
#clone ⇒ Object
Clones the Case (deeply)
3148 3149 3150 3151 3152 |
# File 'lib/HDLRuby/hruby_low.rb', line 3148 def clone return Case.new(@value.clone,@default.clone,(@whens.map do |w| w.clone end) ) 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.
795 796 797 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 795 def delete_when!(w) @whens.delete(w) end |
#each_block(&ruby_block) ⇒ Object
Iterates over the sub blocks.
3113 3114 3115 3116 3117 3118 3119 3120 3121 |
# File 'lib/HDLRuby/hruby_low.rb', line 3113 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.
3124 3125 3126 3127 3128 3129 3130 3131 3132 |
# File 'lib/HDLRuby/hruby_low.rb', line 3124 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_node(&ruby_block) ⇒ Object
Iterates over the children (including the value).
Returns an enumerator if no ruby block is given.
3091 3092 3093 3094 3095 3096 3097 3098 |
# File 'lib/HDLRuby/hruby_low.rb', line 3091 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.
3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 |
# File 'lib/HDLRuby/hruby_low.rb', line 3101 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_deep(&ruby_block) ⇒ Object
Iterates over all the statements contained in the current statement.
3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 |
# File 'lib/HDLRuby/hruby_low.rb', line 3135 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.
3081 3082 3083 3084 3085 3086 |
# File 'lib/HDLRuby/hruby_low.rb', line 3081 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.
3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 |
# File 'lib/HDLRuby/hruby_low.rb', line 3012 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.
129 130 131 132 133 134 135 136 |
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 129 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!
619 620 621 622 623 624 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 619 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 end |
#extract_selects! ⇒ Object
Extract the Select expressions.
Note: the default is not treated.
173 174 175 176 177 178 179 180 |
# File 'lib/HDLRuby/hruby_low_without_select.rb', line 173 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.
3027 3028 3029 |
# File 'lib/HDLRuby/hruby_low.rb', line 3027 def hash return [@value,@whens,@default].hash end |
#map_nodes!(&ruby_block) ⇒ Object
Maps on the children (including the value).
800 801 802 803 804 805 806 807 808 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 800 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.
786 787 788 789 790 791 792 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 786 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 |
#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.
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 816 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.
627 628 629 630 631 632 633 634 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 627 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.
780 781 782 783 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 780 def set_default!(default) # Checks and set the default case if any. self.default = default end |
#set_value!(value) ⇒ Object
Sets the value.
769 770 771 772 773 774 775 776 777 |
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 769 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(level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code. +level+ is the hierachical level of the object.
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1172 def to_c(level = 0) res = "" # Compute the selection value. res << "{\n" res << " " * (level+1)*3 res << "Value value = " << self.value.to_c(level+1) << ";\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 << w.statement.to_c(level+3) res << " " * (level+2)*3 res << "}\n" end if self.default then res << " " * (level+2)*3 res << "else {\n" res << self.default.to_c(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 |
#to_high(level = 0) ⇒ Object
Generates the text of the equivalent HDLRuby::High code. +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_low2high.rb', line 400 def to_high(level = 0) # The result string. res = " " * (level*3) # Generate the test. res << "hcase " << self.value.to_high(level) << "\n" # Generate the whens. self.each_when do |w| res << w.to_high(level) end # Generatethe default. if self.default then res << " " * (level*3) res << "helse do\n" res << self.default.to_high(level+1) res << " " * (level*3) res << "end\n" end # Return the resulting string. return res end |
#to_upper_space! ⇒ Object
Moves the declarations to the upper namespace.
609 610 611 612 613 614 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 609 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(mode = nil) ⇒ Object
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 |
# File 'lib/HDLRuby/hruby_verilog.rb', line 1389 def to_verilog(mode = nil) if ($space_count == 0) then result = " " * ($space_count) # Indented based on space_count. else result = "" end $space_count += 1 # Add count to be used for indentation. result = "" 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 << " " + " " *$space_count + "#{whens.match.to_verilog}: " if whens.statement.each_statement.count > 1 then result << "begin\n" whens.statement.each_statement do |statement| result << " "+ " " *$space_count +"#{statement.to_verilog}" end result << " " + " " *$space_count + "end\n" elsif whens.statement.each_statement.count == 1 then whens.statement.each_statement do |statement| result << "#{statement.to_verilog}" end end end # The default part is stored in default instead of when. Reads and processes in the same way as when. if self.default.each_statement.count > 1 then result << " " + " " *$space_count + "default: begin\n" self.default.each_statement do |statement| result << " " + " " *$space_count + "#{statement.to_verilog}" end result << " end\n" elsif self.default.each_statement.count == 1 then result << " " + " " *$space_count + "default: " self.default.each_statement do |statement| result << "#{statement.to_verilog}" end end result << " " + " " *$space_count + "endcase\n" # Conclusion. $space_count -= 1 # Since the output ends, reduce the count. 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.
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 |
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 934 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 |
#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.
296 297 298 299 300 |
# File 'lib/HDLRuby/hruby_low_with_var.rb', line 296 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 |