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
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)
3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 |
# File 'lib/HDLRuby/hruby_low.rb', line 3432 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.
3427 3428 3429 |
# File 'lib/HDLRuby/hruby_low.rb', line 3427 def default @default end |
#value ⇒ Object (readonly)
The tested value
3424 3425 3426 |
# File 'lib/HDLRuby/hruby_low.rb', line 3424 def value @value end |
Instance Method Details
#add_when(w) ⇒ Object
Adds possible when case +w+.
3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 |
# File 'lib/HDLRuby/hruby_low.rb', line 3485 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.
123 124 125 126 127 128 129 130 131 132 |
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 123 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)
3602 3603 3604 3605 3606 3607 3608 3609 |
# File 'lib/HDLRuby/hruby_low.rb', line 3602 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.
3561 3562 3563 3564 3565 3566 3567 3568 3569 |
# File 'lib/HDLRuby/hruby_low.rb', line 3561 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.
3572 3573 3574 3575 3576 3577 3578 3579 3580 |
# File 'lib/HDLRuby/hruby_low.rb', line 3572 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.
3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 |
# File 'lib/HDLRuby/hruby_low.rb', line 3451 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.
3539 3540 3541 3542 3543 3544 3545 3546 |
# File 'lib/HDLRuby/hruby_low.rb', line 3539 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.
3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 |
# File 'lib/HDLRuby/hruby_low.rb', line 3549 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.
3516 3517 3518 3519 3520 3521 3522 3523 3524 |
# File 'lib/HDLRuby/hruby_low.rb', line 3516 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.
3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 |
# File 'lib/HDLRuby/hruby_low.rb', line 3583 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.
3529 3530 3531 3532 3533 3534 |
# File 'lib/HDLRuby/hruby_low.rb', line 3529 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.
3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 |
# File 'lib/HDLRuby/hruby_low.rb', line 3465 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.
143 144 145 146 147 148 149 150 |
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 143 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!
625 626 627 628 629 630 631 632 633 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 625 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.
214 215 216 217 218 219 220 221 |
# File 'lib/HDLRuby/hruby_low_without_select.rb', line 214 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.
3480 3481 3482 |
# File 'lib/HDLRuby/hruby_low.rb', line 3480 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.
636 637 638 639 640 641 642 643 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 636 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)
1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1608 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 # 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
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 |
# File 'lib/HDLRuby/hruby_low2c.rb', line 1649 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.
615 616 617 618 619 620 |
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 615 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.
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 |
# File 'lib/HDLRuby/hruby_verilog.rb', line 1584 def to_verilog(spc = 3) result = " " * spc # Indented based on space_count. 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 << " " * (spc+3) + "#{whens.match.to_verilog}: " if whens.statement.each_statement.count >= 1 then result << whens.statement.to_verilog(spc+3) else result << "\n" end end if self.default then if self.default.each_statement.count >= 1 then result << self.default.each_statement.map do |stmnt| stmnt.to_verilog(spc+3) end.join("\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.
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 |
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 987 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.
3597 3598 3599 |
# File 'lib/HDLRuby/hruby_low.rb', line 3597 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 |