Class: HDLRuby::Low::TimeRepeat

Inherits:
Statement show all
Defined in:
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_mutable.rb,
lib/HDLRuby/hruby_low_skeleton.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,
lib/HDLRuby/hruby_low_without_subsignals.rb,
lib/HDLRuby/hruby_low_casts_without_expression.rb

Overview

Describes a timed loop statement: not synthesizable!

Direct Known Subclasses

High::TimeRepeat

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!, #delete_related!, #delete_unless!, #each_statement, #par_in_seq2seq!, #parent_system, #scope, #to_ch, #to_seq!, #top_block, #top_scope, #use_name?, #with_boolean!

Methods included from Low2Symbol

#to_sym

Methods included from Hparent

#absolute_ref, #hierarchy, #no_parent!, #scope

Constructor Details

#initialize(number, statement) ⇒ TimeRepeat

Creates a new timed loop statement execute in a loop statement until

delay has passed.

def initialize(statement,delay) Creates a new timed loop statement execute in a loop statement number times (negative means inifinity).



4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
 
# File 'lib/HDLRuby/hruby_low.rb', line 4390

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

    # # Check and set the delay.
    # unless delay.is_a?(Delay)
    #     raise AnyError, "Invalid class for a delay: #{delay.class}."
    # end
    # @delay = delay
    # Check and set the number.
    @number = number.to_i
    # # And set its parent.
    # delay.parent = self
end

Instance Attribute Details

#number ⇒ Object (readonly)

The delay until the loop is repeated

attr_reader :delay The number of interrations.



4380
4381
4382
 
# File 'lib/HDLRuby/hruby_low.rb', line 4380

def number
  @number
end

#statement ⇒ Object (readonly)

The statement to execute.



4383
4384
4385
 
# File 'lib/HDLRuby/hruby_low.rb', line 4383

def statement
  @statement
end

Instance Method Details

#blocks2seq! ⇒ Object

Converts the par sub blocks to seq.



185
186
187
188
189
 
# File 'lib/HDLRuby/hruby_low2seq.rb', line 185

def blocks2seq!
    # Converts the statement.
    self.statement.blocks2seq!
    return self
end

#boolean_in_assign2select! ⇒ Object

Converts booleans in assignments to select operators.



166
167
168
169
170
 
# File 'lib/HDLRuby/hruby_low_bool2select.rb', line 166

def boolean_in_assign2select!
    # Simply recurse on the stamtement.
    self.statement.boolean_in_assign2select!
    return self
end

#casts_without_expression! ⇒ Object

Extracts the expressions from the casts.



150
151
152
153
154
 
# File 'lib/HDLRuby/hruby_low_casts_without_expression.rb', line 150

def casts_without_expression!
    # Simply recurse on the stamtement.
    self.statement.casts_without_expression!
    return self
end

#clone ⇒ Object

Clones the TimeRepeat (deeply)



4442
4443
4444
4445
 
# File 'lib/HDLRuby/hruby_low.rb', line 4442

def clone
    # return TimeRepeat.new(@statement.clone,@delay.clone)
    return TimeRepeat.new(@statement.clone,@number)
end

#each_block(&ruby_block) ⇒ Object

Iterates over the sub blocks.



4466
4467
4468
4469
4470
4471
4472
 
# File 'lib/HDLRuby/hruby_low.rb', line 4466

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 statement if it is a block.
    ruby_block.call(@statement) if statement.is_a?(Block)
end

#each_block_deep(&ruby_block) ⇒ Object

Iterates over all the blocks contained in the current block.



4475
4476
4477
4478
4479
4480
4481
 
# File 'lib/HDLRuby/hruby_low.rb', line 4475

def each_block_deep(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_block_deep) unless ruby_block
    # A ruby block?
    # Recurse on the statement.
    @statement.each_block_deep(&ruby_block)
end

#each_deep(&ruby_block) ⇒ Object

Iterates over each object deeply.

Returns an enumerator if no ruby block is given.



4415
4416
4417
4418
4419
4420
4421
4422
4423
4424
 
# File 'lib/HDLRuby/hruby_low.rb', line 4415

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 statement.
    self.statement.each_deep(&ruby_block)
    # # Then apply on the delay.
    # self.delay.each_deep(&ruby_block)
end

#each_node(&ruby_block) ⇒ Object

Iterates over the expression children if any.



4448
4449
4450
4451
4452
4453
 
# File 'lib/HDLRuby/hruby_low.rb', line 4448

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 the child.
    ruby_block.call(@statement)
end

#each_node_deep(&ruby_block) ⇒ Object

Iterates over the nodes deeply if any.



4456
4457
4458
4459
4460
4461
4462
4463
 
# File 'lib/HDLRuby/hruby_low.rb', line 4456

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 child
    @statement.each_node_deep(&ruby_block)
end

#each_statement_deep(&ruby_block) ⇒ Object

Iterates over all the statements contained in the current block.



4484
4485
4486
4487
4488
4489
4490
4491
4492
 
# File 'lib/HDLRuby/hruby_low.rb', line 4484

def each_statement_deep(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_statement_deep) unless ruby_block
    # A ruby block?
    # Apply it on self.
    ruby_block.call(self)
    # Recurse on the statement.
    @statement.each_statement_deep(&ruby_block)
end

#eql?(obj) ⇒ Boolean

Comparison for hash: structural comparison.

Returns:

  • (Boolean) 


4427
4428
4429
4430
4431
4432
4433
 
# File 'lib/HDLRuby/hruby_low.rb', line 4427

def eql?(obj)
    return false unless obj.is_a?(TimeRepeat)
    # return false unless @delay.eql?(obj.delay)
    return false unless @number.eql?(obj.number)
    return false unless @statement.eql?(obj.statement)
    return true
end

#explicit_types! ⇒ Object

Explicit the types conversions in the time repeat.



200
201
202
203
204
 
# File 'lib/HDLRuby/hruby_low_fix_types.rb', line 200

def explicit_types!
    # Recurse on the statement.
    self.statement.explicit_types!
    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!



767
768
769
770
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 767

def extract_declares!
    # Recurse on the statement.
    return self.statement.extract_declares!
end

#extract_selects! ⇒ Object

Extract the Select expressions.



119
120
121
122
123
124
125
126
 
# File 'lib/HDLRuby/hruby_low_without_select.rb', line 119

def extract_selects!
    # Simply recruse on the statement.
    if self.statement.is_a?(Block) then
        return []
    else
        return self.statement.extract_selects!
    end
end

#fix_scope_refnames!(scopes) ⇒ Object

Fix the references names using scopes given in +scopes + list (they are marked to be deleted).



780
781
782
783
784
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 780

def fix_scope_refnames!(scopes)
    # Recurse on the statement.
    self.statement.fix_scope_refnames!(scopes)
    return self
end

#hash ⇒ Object

Hash function.



4436
4437
4438
4439
 
# File 'lib/HDLRuby/hruby_low.rb', line 4436

def hash
    # return [@delay,@statement].hash
    return [@number,@statement].hash
end

#map_nodes!(&ruby_block) ⇒ Object

Maps on the child.



1052
1053
1054
1055
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1052

def map_nodes!(&ruby_block)
    @statement = ruby_block.call(@statement)
    @statement.parent = self unless @statement.parent
end

#mix?(mode = nil) ⇒ Boolean

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

Returns:

  • (Boolean) 


193
194
195
196
 
# File 'lib/HDLRuby/hruby_low2seq.rb', line 193

def mix?(mode = nil)
    # Check the statement.
    return self.statement.mix?(mode)
end

#process_to_vhdl(vars, level = 0) ⇒ Object

Generates the text of the equivalent HDLRuby::High code as a new process. vars is the list of the variables and level is the hierachical level of the object.



1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
 
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 1088

def process_to_vhdl(vars,level = 0)
    # Generate a separate process for the repeated statement with
    # a wait.
    # The resulting string.
    res = " " * (level*3)
    # Generate the header.
    unless  self.block.name.empty? then
        res << Low2VHDL.vhdl_name(self.block.name) << ": "
    end
    res << "process \n"
    # Generate the content.
    res << " " * (level*3)
    res << "begin\n"
    # Adds the wait.
    res << " " * ((level+1)*3)
    res << "wait for " << self.delay.to_vhdl(level) << ";\n" 
    # Generate the remaining of the body.
    res << self.statement.to_vhdl(vars,level+1)
    # Close the process.
    res << " " * (level*3)
    res << "end process;\n\n"
    # Return the result.
    return res
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.



1063
1064
1065
1066
1067
1068
1069
1070
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1063

def replace_expressions!(node2rep)
    res = {}
    # Recurse on the children.
    self.each_node do |node|
        res.merge!(node.replace_expressions!(node2rep))
    end
    return res
end

#replace_names!(former, nname) ⇒ Object

Replaces recursively former name by nname until it is redeclared.



773
774
775
776
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 773

def replace_names!(former,nname)
    # Recurse on the statement.
    self.statement.replace_names!(former,nname)
end

#set_delay!(delay) ⇒ Object

Sets the delay.



1041
1042
1043
1044
1045
1046
1047
1048
1049
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1041

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

#set_statement!(statement) ⇒ Object

Sets the statement.



1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 1029

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

#signal2subs! ⇒ Object

Decompose the hierarchical signals in the statements.



124
125
126
127
128
 
# File 'lib/HDLRuby/hruby_low_without_subsignals.rb', line 124

def signal2subs!
    # Recurse on the statement.
    self.set_statement!(self.statement.signal2subs!)
    return self
end

#to_c(res, level = 0) ⇒ Object

Generates the C text of the equivalent HDLRuby code. level is the hierachical level of the object. def to_c(level = 0)



1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 1928

def to_c(res,level = 0)
    # The resulting string.
    res << " " * level*3
    if (self.number < 0) then
        # Generate an infinite loop executing the block and waiting.
        res << "for(;;) {\n"
    else
        # Generate a finite loop.
        res << "for(long long i = 0; i<#{self.number}; ++i) {\n"
    end
    self.statement.to_c(res,level+1)
    res << " " * level*3 << "}\n"
    # Return the resulting string.
    return res
end

#to_hdr(level = 0) ⇒ Object

Generates the text of the equivalent hdr text. level is the hierachical level of the object.



464
465
466
467
468
469
470
471
472
473
474
475
 
# File 'lib/HDLRuby/hruby_low2hdr.rb', line 464

def to_hdr(level = 0)
    # The resulting string.
    res = " " * (level*3)
    # Generate the header.
    res << "repeat " << self.delay.to_hdr(level) << " do\n"
    # Generate the statement to repeat.
    res << self.statement.to_hdr(level+1)
    # Close the repeat.
    res << " " * (level*3) << "end\n"
    # Return the resulting string.
    return res
end

#to_high ⇒ Object

Creates a new high repreat statement.



354
355
356
357
 
# File 'lib/HDLRuby/hruby_low2high.rb', line 354

def to_high
    return HDLRuby::High::TimeReapeat.new(self.delay.to_high,
                                          self.statement.to_high)
end

#to_upper_space! ⇒ Object

Moves the declarations to the upper namespace.



759
760
761
762
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 759

def to_upper_space!
    # Recurse on the statement.
    self.statement.to_upper_space!
end

#to_verilog(spc = 3) ⇒ Object

Enhances TimeRepeat with generation of verilog code.



1989
1990
1991
1992
 
# File 'lib/HDLRuby/hruby_verilog.rb', line 1989

def to_verilog(spc = 3)
    result = (" " * spc) + "repeat(#{self.number})" + "\n"
    result << self.statement.to_verilog(spc+3)
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.



1079
1080
1081
1082
 
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 1079

def to_vhdl(vars,level = 0)
    # Nothing to do, see process_to_vhdl
    return ""
end