Class: HDLRuby::Low::If

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_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 If class with functionality for moving the declarations to the upper namespace.

Direct Known Subclasses

High::If

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, #behavior, #block, #break_types!, #parent_system, #scope, #top_block, #top_scope, #with_boolean!

Methods included from Low2Symbol

#to_sym

Methods included from Hparent

#scope

Constructor Details

#initialize(condition, yes, no = nil) ⇒ If

Creates a new if statement with a +condition+ and a +yes+ and +no+ blocks.



2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790
2791
2792
2793
2794
2795
2796
2797
2798
2799
2800
2801
2802
2803
2804
2805
2806
 
# File 'lib/HDLRuby/hruby_low.rb', line 2780

def initialize(condition, yes, no = nil)
    # Check and set the condition.
    unless condition.is_a?(Expression)
        raise AnyError,
              "Invalid class for a condition: #{condition.class}"
    end
    @condition = condition
    # And set its parent.
    condition.parent = self
    # Check and set the yes statement.
    unless yes.is_a?(Statement)
        raise AnyError, "Invalid class for a statement: #{yes.class}"
    end
    @yes = yes
    # And set its parent.
    yes.parent = self
    # Check and set the yes statement.
    if no and !no.is_a?(Statement)
        raise AnyError, "Invalid class for a statement: #{no.class}"
    end
    @no = no
    # And set its parent.
    no.parent = self if no

    # Initialize the list of alternative if statements (elsif)
    @noifs = []
end

Instance Attribute Details

#condition ⇒ Object (readonly)

The condition



2773
2774
2775
 
# File 'lib/HDLRuby/hruby_low.rb', line 2773

def condition
  @condition
end

#no ⇒ Object

The yes and no statements



2776
2777
2778
 
# File 'lib/HDLRuby/hruby_low.rb', line 2776

def no
  @no
end

#yes ⇒ Object (readonly)

The yes and no statements



2776
2777
2778
 
# File 'lib/HDLRuby/hruby_low.rb', line 2776

def yes
  @yes
end

Instance Method Details

#add_noif(next_cond, next_yes) ⇒ Object

Adds an alternative if statement (elsif) testing +next_cond+ and executing +next_yes+ when the condition is met.



2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
 
# File 'lib/HDLRuby/hruby_low.rb', line 2841

def add_noif(next_cond, next_yes)
    # Check the condition.
    unless next_cond.is_a?(Expression)
        raise AnyError, 
              "Invalid class for a condition: #{next_cond.class}"
    end
    # And set its parent.
    next_cond.parent = self
    # Check yes statement.
    unless next_yes.is_a?(Statement)
        raise AnyError, 
              "Invalid class for a statement: #{next_yes.class}"
    end
    # And set its parent.
    next_yes.parent = self
    # Add the statement.
    @noifs << [next_cond,next_yes]
end

#blocks2seq! ⇒ Object

Converts the par sub blocks to seq.



102
103
104
105
106
107
108
109
110
111
112
113
 
# File 'lib/HDLRuby/hruby_low2seq.rb', line 102

def blocks2seq!
    # Convert each sub block.
    # If block.
    self.yes.blocks2seq!
    # Elsif blocks
    self.each_noif do |cond, stmnt|
        stmnt.blocks2seq!
    end
    # Else block if any.
    self.no.blocks2seq! if self.no
    return self
end

#boolean_in_assign2select! ⇒ Object

Converts booleans in assignments to select operators.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 70

def boolean_in_assign2select!
    # No need to apply on condition!
    # # Apply on the condition.
    # self.set_condition!(self.condition.boolean_in_assign2select)
    # Apply on the yes.
    self.yes.boolean_in_assign2select!
    # Apply on the noifs.
    @noifs.map! do |cond,stmnt|
        # No need to apply on condition!
        # [cond.boolean_in_assign2select,stmnt.boolean_in_assign2select!]
        [cond,stmnt.boolean_in_assign2select!]
    end
    # Apply on the no if any.
    self.no.boolean_in_assign2select! if self.no
    return self
end

#clone ⇒ Object

Clones the If (deeply)



2951
2952
2953
2954
2955
2956
2957
2958
2959
 
# File 'lib/HDLRuby/hruby_low.rb', line 2951

def clone
    # Duplicate the if.
    res = If.new(@condition.clone, @yes.clone, @no ? @no.clone : nil)
    # Duplicate the alternate ifs
    @noifs.each do |next_cond,next_yes|
        res.add_noif(next_cond.clone,next_yes.clone)
    end
    return res
end

#delete_noif!(noif) ⇒ Object

Deletes an alternate if.



668
669
670
671
672
673
674
675
676
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 668

def delete_noif!(noif)
    if @noifs.include?(noif) then
        # The noif is present, delete it.
        @noifs.delete(noif)
        # And remove its parent.
        noif.parent = nil
    end
    noif
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.



737
738
739
740
741
742
743
744
745
746
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 737

def delete_related!(*names)
    # Delete the noifs if their condition uses one of names.
    @noifs.delete_if { |noif| noif[0].use_names?(names) }
    # Recurse on the yes.
    @yes.delete_related!(*names)
    # Recurse on the no.
    @no.delete_related!(*names)
    # Recruse one the no ifs statements.
    @noifs.each { |noif| noif[1].delete_related!(*names) }
end

#delete_unless!(keep) ⇒ Object

Removes the signals and corresponding assignments whose name is not in +keep+.



128
129
130
131
132
133
134
135
136
 
# File 'lib/HDLRuby/hruby_low_cleanup.rb', line 128

def delete_unless!(keep)
    # Recurse on the sub statements.
    # Yes.
    self.yes.delete_unless!(keep)
    # Noifs.
    self.each_noif { |cond,stmnt| stmnt.delete_unless!(keep) }
    # No if any.
    self.no.delete_unless!(keep) if self.no
end

#each_block(&ruby_block) ⇒ Object

Iterates over the sub blocks.



2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
 
# File 'lib/HDLRuby/hruby_low.rb', line 2903

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 the yes, the alternate ifs and the no blocks.
    ruby_block.call(@yes) if @yes.is_a?(Block)
    @noifs.each do |next_cond,next_yes|
        ruby_block.call(next_yes) if next_yes.is_a?(Block)
    end
    ruby_block.call(@no) if @no.is_a?(Block)
end

#each_block_deep(&ruby_block) ⇒ Object

Iterates over all the blocks contained in the current block.



2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
 
# File 'lib/HDLRuby/hruby_low.rb', line 2931

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 the yes, the alternate ifs and the no blocks.
    @yes.each_block_deep(&ruby_block)
    @noifs.each do |next_cond,next_yes|
        next_yes.each_block_deep(&ruby_block)
    end
    # @no.each_block_deep(&ruby_block) if @no.is_a?(Block)
    @no.each_block_deep(&ruby_block) if @no
end

#each_node(&ruby_block) ⇒ Object

Iterates over the children (including the condition).



2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
 
# File 'lib/HDLRuby/hruby_low.rb', line 2872

def each_node(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_node) unless ruby_block
    # A ruby block?
    # Appy it on the children.
    ruby_block.call(@condition)
    ruby_block.call(@yes)
    self.each_noif do |next_cond,next_yes|
        ruby_block.call(next_cond)
        ruby_block.call(next_yes)
    end
    ruby_block.call(@no) if @no
end

#each_node_deep(&ruby_block) ⇒ Object

Iterates over the nodes deeply if any.



2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
 
# File 'lib/HDLRuby/hruby_low.rb', line 2887

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
    @condition.each_node_deep(&ruby_block)
    @yes.each_node_deep(&ruby_block)
    self.each_noif do |next_cond,next_yes|
        next_cond.each_node_deep(&ruby_block)
        next_yes.each_node_deep(&ruby_block)
    end
    @no.each_node_deep(&ruby_block) if @no
end

#each_noif(&ruby_block) ⇒ Object

Iterates over the alternate if statements (elsif).



2861
2862
2863
2864
2865
2866
2867
2868
2869
 
# File 'lib/HDLRuby/hruby_low.rb', line 2861

def each_noif(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_noif) unless ruby_block
    # A ruby block?
    # Appy it on the alternate if statements.
    @noifs.each do |next_cond,next_yes|
        yield(next_cond,next_yes)
    end
end

#each_statement_deep(&ruby_block) ⇒ Object

Iterates over all the stamements of the block and its sub blocks.



2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
 
# File 'lib/HDLRuby/hruby_low.rb', line 2916

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 recurse on the alternate ifs and the no statements.
    @yes.each_statement_deep(&ruby_block)
    @noifs.each do |next_cond,next_yes|
        next_yes.each_statement_deep(&ruby_block)
    end
    @no.each_statement_deep(&ruby_block) if @no.is_a?(Block)
end

#eql?(obj) ⇒ Boolean

Comparison for hash: structural comparison.



2809
2810
2811
2812
2813
2814
2815
 
# File 'lib/HDLRuby/hruby_low.rb', line 2809

def eql?(obj)
    return false unless obj.is_a?(If)
    return false unless @condition.eql?(obj.condition)
    return false unless @yes.eql?(obj.yes)
    return false unless @no.eql?(obj.no)
    return true
end

#explicit_types! ⇒ Object

Explicit the types conversions in the if.



96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 96

def explicit_types!
    # Recurse on the condition: it must be a Bit.
    self.set_condition!(self.condition.explicit_types(Bit))
    # Recurse on the yes block.
    self.yes.explicit_types!
    # Recruse on the alternative ifs, the conditions must be Bit.
    self.map_noifs! do |cond,block|
        [ cond.explicit_types(Bit), block.explicit_types! ]
    end
    # Recurse on the no block.
    self.no.explicit_types! if self.no
    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!



533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 533

def extract_declares!
    # The extracted declares.
    decls = []
    # Recurse on the sub blocks.
    # Yes.
    decls << self.yes.extract_declares!
    # Noifs.
    decls << self.each_noif.map do |cond,stmnt|
        stmnt.extract_declares!
    end
    # No if any.
    decls << self.no.extract_declares! if self.no
    # Returns the extracted declares.
    return decls
end

#extract_selects! ⇒ Object

Extract the Select expressions.

NOTE: work on the condition only.



173
174
175
176
177
 
# File 'lib/HDLRuby/hruby_low_without_select.rb', line 173

def extract_selects!
    selects = []
    self.set_condition!(self.condition.extract_selects_to!(selects))
    return selects
end

#hash ⇒ Object

Hash function.



2818
2819
2820
 
# File 'lib/HDLRuby/hruby_low.rb', line 2818

def hash
    return [@condition,@yes,@no].hash
end

#map_nodes!(&ruby_block) ⇒ Object

Maps on the children (including the condition).



690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 690

def map_nodes!(&ruby_block)
    @condition = ruby_block.call(@condition)
    @yes = ruby_block.call(@yes)
    self.map_noifs! do |cond,stmnt|
        [ruby_block.call(cond), ruby_block.call(stmnt)]
    end
    # @noifs.map! do |cond,stmnt|
    #     cond  = ruby_block.call(cond)
    #     stmnt = ruby_block.call(stmnt)
    #     cond.parent  = self unless cond.parent
    #     stmnt.parent = self unless stmnt.parent
    #     [cond,stmnt]
    # end
    @no = ruby_block.call(@no) if @no
end

#map_noifs!(&ruby_block) ⇒ Object

Maps on the noifs.



679
680
681
682
683
684
685
686
687
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 679

def map_noifs!(&ruby_block)
    @noifs.map! do |cond,stmnt|
        cond,stmnt  = ruby_block.call(cond,stmnt)
        # cond, stmnt  = ruby_block.call(cond), ruby_block.call(stmnt)
        cond.parent  = self unless cond.parent
        stmnt.parent = self unless stmnt.parent
        [cond,stmnt]
    end
end

#mix?(mode = nil) ⇒ Boolean

Tell if there is a mix block. +mode+ is the mode of the upper block.



117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/HDLRuby/hruby_low2seq.rb', line 117

def mix?(mode = nil)
    # Check each sub block.
    # If block.
    return true if self.yes.mix?(mode)
    # Elsif blocks
    self.each_noif do |cond, stmnt|
        return true if stmnt.mix?(mode)
    end
    # Else block if any.
    true if self.no && self.no.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.



712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 712

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 condition?
    rep = node2rep[self.condition]
    if rep then
        # Yes, do it.
        rep = rep.clone
        node = self.condition
        # node.set_parent!(nil)
        self.set_condition!(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.



550
551
552
553
554
555
556
557
558
559
560
561
562
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 550

def replace_names!(former,nname)
    # Recurse on the condition.
    self.condition.replace_names!(former,nname)
    # Recurse on the yes.
    self.yes.replace_names!(former,nname)
    # Recurse on the alternate ifs.
    self.each_noif do |cond,stmnt| 
        cond.replace_names!(former,nname)
        stmnt.replace_names!(former,nname)
    end
    # Recurse on the no if any.
    self.no.replace_names!(former,nname) if self.no
end

#set_condition!(condition) ⇒ Object

Sets the condition.



634
635
636
637
638
639
640
641
642
643
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 634

def set_condition!(condition)
    # Check and set the condition.
    unless condition.is_a?(Expression)
        raise AnyError,
              "Invalid class for a condition: #{condition.class}"
    end
    @condition = condition
    # And set its parent.
    condition.parent = self
end

#set_no!(no) ⇒ Object

Sets the no block.



657
658
659
660
661
662
663
664
665
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 657

def set_no!(no)
    # Check and set the yes statement.
    if no and !no.is_a?(Statement)
        raise AnyError, "Invalid class for a statement: #{no.class}"
    end
    @no = no
    # And set its parent.
    no.parent = self if no
end

#set_yes!(yes) ⇒ Object

Sets the yes block.



646
647
648
649
650
651
652
653
654
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 646

def set_yes!(yes)
    # Check and set the yes statement.
    unless yes.is_a?(Statement)
        raise AnyError, "Invalid class for a statement: #{yes.class}"
    end
    @yes = yes
    # And set its parent.
    yes.parent = self
end

#to_c(level = 0) ⇒ Object

Generates the C text of the equivalent HDLRuby::High code. +level+ is the hierachical level of the object.



1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1106

def to_c(level = 0)
    # The result string.
    res = " " * level*3
    # Compute the condition.
    res << "{\n"
    res << " " * (level+1)*3
    res << "Value cond = " << self.condition.to_c(level+1) << ";\n"
    # Ensure the condition is testable.
    res << " " * (level+1)*3
    res << "if (is_defined_value(cond)) {\n"
    # The condition is testable.
    res << " " * (level+2)*3
    res << "if (value2integer(cond)) {\n"
    # Generate the yes part.
    res << self.yes.to_c(level+3)
    res << " " * level*3
    res << "}\n"
    # Generate the alternate if parts.
    self.each_noif do |cond,stmnt|
        res << " " * level*3
        res << "else if (value2integer(" << cond.to_c(level+1) << ")) {\n"
        res << stmnt.to_c(level+1)
        res << " " * level*3
        res << "}\n"
    end
    # Generate the no part if any.
    if self.no then
        res << " " * level*3
        res << "else {\n" << self.no.to_c(level+1)
        res << " " * level*3
        res << "}\n"
    end
    # Close the if.
    res << " " * (level+1)*3
    res << "}\n"
    res << " " * (level)*3
    res << "}\n"
    # Return the result.
    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.



350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/HDLRuby/hruby_low2high.rb', line 350

def to_high(level = 0)
    # The result string.
    res = " " * (level*3)
    # Generate the test.
    res << "hif " << self.condition.to_high(level) << " do\n"
    # Generate the yes part.
    res << self.yes.to_high(level+1)
    res << " " * (level*3) << "end\n"
    # Generate the alternate if parts.
    self.each_noif do |cond,stmnt|
        res << " " * (level*3)
        res << "helsif " << cond.to_high(level) << " do\n"
        res << stmnt.to_high(level+1)
        res << " " * (level*3) << "end\n"
    end
    # Generate the no part if any.
    if self.no then
        res << " " * (level*3)
        res << "helse do\n" << self.no.to_high(level+1)
        res << " " * (level*3) << "end\n"
    end
    # Return the result.
    return res
end

#to_upper_space! ⇒ Object

Moves the declarations to the upper namespace.



520
521
522
523
524
525
526
527
528
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 520

def to_upper_space!
    # Recurse on the sub blocks.
    # Yes.
    self.yes.to_upper_space!
    # Noifs.
    self.each_noif {|cond,stmnt| stmnt.to_upper_space! }
    # No if any.
    self.no.to_upper_space! if self.no
end

#to_verilog(mode = nil) ⇒ Object

Converts the system to Verilog code.



1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1430

def to_verilog(mode = nil)

    $blocking = false

    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 << "if (#{self.condition.to_verilog}) begin\n"


    # Check if there is yes (if) and output yes or less.
    if self.respond_to? (:yes)
        self.yes.each_statement do |statement|
            result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
        end
        result << "#{"   " * $space_count}   end\n"
    end

    # If noif (else if) exists, it outputs it.
    # Since noif is directly under, respond_to is unnecessary.
    self.each_noif do |condition, block|
        result << "#{"   " * $space_count}   else if (#{condition.to_verilog}) begin\n"
        block.each_statement do |statement|
            result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
        end
        result << "#{"   "* $space_count}   end\n"
    end

    # Check if there is no (else) and output no or less.
    if self.no.respond_to? (:mode)
        result << "#{"   " * $space_count}   else begin\n"
        self.no.each_statement do |statement|
            result << "#{"   " * $space_count}      #{statement.to_verilog(mode)}"
        end
        result << "#{"   " * $space_count}   end\n"
    end

    $space_count -= 1 # Since the output ends, reduce the count.
    return result
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.



911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
 
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 911

def to_vhdl(vars,level = 0)
    # The result string.
    res = " " * (level*3)
    # Generate the test.
    res << "if (" << Low2VHDL.to_boolean(self.condition) << ") then\n"
    # Generate the yes part.
    res << self.yes.to_vhdl(vars,level+1)
    # Generate the alternate if parts.
    self.each_noif do |cond,stmnt|
        res << " " * (level*3)
        # res << "elsif (" << cond.to_vhdl(level) << ") then\n"
        res << "elsif (" << Low2VHDL.to_boolean(cond) << ") then\n"
        res << stmnt.to_vhdl(vars,level+1)
    end
    # Generate the no part if any.
    if self.no then
        res << " " * (level*3)
        res << "else\n" << self.no.to_vhdl(vars,level+1)
    end
    # Close the if.
    res << " " * (level*3)
    res << "end if;\n"
    # Return the result.
    return res
end

#use_name?(*names) ⇒ Boolean

Tell if the statement includes a signal whose name is one of +names+. NOTE: for the if check only the condition.



2946
2947
2948
 
# File 'lib/HDLRuby/hruby_low.rb', line 2946

def use_name?(*names)
    return @condition.use_name?(*name)
end

#with_var(upper = nil) ⇒ Object

Converts to a variable-compatible if where +upper+ is the upper block if any.

NOTE: the result is a new if.



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/HDLRuby/hruby_low_with_var.rb', line 271

def with_var(upper = nil)
    # Treat the sub nodes.
    # Condition.
    ncond = self.condition.clone
    # Yes.
    nyes =self.yes.with_var(upper)
    # Noifs.
    noifs = self.each_noif.map do |cond,stmnt|
        [cond.clone,stmnt.with_var(upper)]
    end
    # No.
    nno = self.no ? self.no.with_var(upper) : nil
    # Create the resulting If.
    res= If.new(ncond,nyes, nno)
    noifs.each do |cond,stmnt|
        res.add_noif(cond,stmnt)
    end
    return res
end