Class: HDLRuby::Low::Case

Inherits:
Statement
  • Object
show all
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

High::Case

Constant Summary

Constants included from Low2Symbol

Low2Symbol::Low2SymbolPrefix, Low2Symbol::Low2SymbolTable, Low2Symbol::Symbol2LowTable

Instance Attribute Summary collapse

Attributes included from Hparent

#parent

Instance Method Summary collapse

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

#to_sym

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 delete_related!(*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.delete_related!(*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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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)



1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1712

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



1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1753

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.



1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1599

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.



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.

Returns:

  • (Boolean) 


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