Class: HDLRuby::Low::TimeRepeat

Inherits:
Statement show all
Defined in:
lib/HDLRuby/hruby_low.rb,
lib/HDLRuby/hruby_viz.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, #get_signal_splits, #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).



4373
4374
4375
4376
4377
4378
4379
4380
4381
4382
4383
4384
4385
4386
4387
4388
4389
4390
4391
4392
4393
 
# File 'lib/HDLRuby/hruby_low.rb', line 4373

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.



4363
4364
4365
 
# File 'lib/HDLRuby/hruby_low.rb', line 4363

def number
  @number
end

#statement ⇒ Object (readonly)

The statement to execute.



4366
4367
4368
 
# File 'lib/HDLRuby/hruby_low.rb', line 4366

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)



4425
4426
4427
4428
 
# File 'lib/HDLRuby/hruby_low.rb', line 4425

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.



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

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.



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

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.



4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
 
# File 'lib/HDLRuby/hruby_low.rb', line 4398

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.



4431
4432
4433
4434
4435
4436
 
# File 'lib/HDLRuby/hruby_low.rb', line 4431

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.



4439
4440
4441
4442
4443
4444
4445
4446
 
# File 'lib/HDLRuby/hruby_low.rb', line 4439

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.



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

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) 


4410
4411
4412
4413
4414
4415
4416
 
# File 'lib/HDLRuby/hruby_low.rb', line 4410

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!



769
770
771
772
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 769

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).



782
783
784
785
786
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 782

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

#hash ⇒ Object

Hash function.



4419
4420
4421
4422
 
# File 'lib/HDLRuby/hruby_low.rb', line 4419

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.number.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.



775
776
777
778
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 775

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
476
 
# 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"
    res << "repeat " << self.number.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.



761
762
763
764
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 761

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

#to_viz_node(parent) ⇒ Object

Converts the transmit to a Viz flow node under +parent+.



5030
5031
5032
5033
5034
5035
5036
 
# File 'lib/HDLRuby/hruby_viz.rb', line 5030

def to_viz_node(parent)
  node = HDLRuby::Viz::Node.new(:repeat,parent)
  # And generate the children.
  self.number.to_expr.to_viz_node(node)
  self.statement.to_viz_node(node)
  return node
end