Class: RubyHDL::High::Sblock

Inherits:
SblockTop show all
Defined in:
lib/HDLRuby/std/sequencer_sw.rb

Overview

Describes a SW implementation of a block.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from SblockTop

#callable, #callable?, #each_signal, #make_inners, #register

Constructor Details

#initialize(sequencer, &ruby_block) ⇒ Sblock

Create a new block for sequencer +sequencer+ and fill it by executing +ruby_block+



3168
3169
3170
3171
3172
3173
3174
3175
3176
3177
3178
3179
3180
3181
3182
3183
3184
3185
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3168

def initialize(sequencer,&ruby_block)
  super()
  # Sets the sequencer.
  @sequencer = sequencer
  # Initialize the statements.
  @statements = []
  # Push the new sblock on top of the stack.
  RubyHDL::High.push_sblock(self)
  # Make signals from the arguments of the ruby block.
  @args = []
  ruby_block.parameters.each do |typ,arg|
    @args << SignalI.new(Void,arg)
  end
  # Fill it.
  self.instance_exec(*@args,&ruby_block)
  # Pop the new sblock.
  RubyHDL::High.pop_sblock
end

Instance Attribute Details

#sequencer ⇒ Object (readonly)

Returns the value of attribute sequencer.



3164
3165
3166
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3164

def sequencer
  @sequencer
end

Instance Method Details

#add(statement) ⇒ Object Also known as: <<

Add a new statement to the block.



3188
3189
3190
3191
3192
3193
3194
3195
3196
3197
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3188

def add(statement)
  # Add the statement.
  @statements.push(statement)
  # # If the statement is a transmit, schedule the corresponding
  # # signal for final update.
  # if statement.is_a?(Transmit) then
  #   @sequencer.to_update(statement.left)
  # end
  statement
end

#delete(statement) ⇒ Object

Delete a statement.



3201
3202
3203
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3201

def delete(statement)
  @statements.delete(statement)
end

#last_statement ⇒ Object

Get the last statement.



3211
3212
3213
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3211

def last_statement
  return @statements[-1]
end

#ruby(str = nil, &ruby_block) ⇒ Object

Some arbirary Ruby code as a string +str+ or as a proc +ruby_block+.



3321
3322
3323
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3321

def ruby(str = nil, &ruby_block)
  self << RubyHDL::High::Ruby.new(str,&ruby_block)
end

#sbreak ⇒ Object

Breaks current iteration.



3257
3258
3259
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3257

def sbreak
  self << RubyHDL::High::Sbreak.new(@sequencer)
end

#scontinue ⇒ Object

Continues current iteration.



3262
3263
3264
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3262

def scontinue
  self << RubyHDL::High::Scontinue.new(@sequencer)
end

#selse(&ruby_block) ⇒ Object

Create a sequential else statement.



3282
3283
3284
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3282

def selse(&ruby_block)
  self.last_statement.selse(&ruby_block)
end

#selsif(cond, &ruby_block) ⇒ Object

Create a sequential elsif statement on +cond+.



3277
3278
3279
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3277

def selsif(cond, &ruby_block)
  self.last_statement.selsif(&ruby_block)
end

#sfor(expr, &ruby_block) ⇒ Object

Create a sequential for statement iterating over the elements of +expr+.



3303
3304
3305
3306
3307
3308
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3303

def sfor(expr,&ruby_block)
  # Ensures there is a ruby block to avoid returning an enumerator
  # (returning an enumerator would be confusing for a for statement).
  ruby_block = proc {} unless ruby_block
  self << expr.seach.with_index(&ruby_block)
end

#sif(cond, &ruby_block) ⇒ Object

Create a sequential if statement on +cond+.



3272
3273
3274
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3272

def sif(cond, &ruby_block)
  self << RubyHDL::High::Sif.new(@sequencer,cond,&ruby_block)
end

#sloop(&ruby_block) ⇒ Object

Create a sequential infinite loop statement.



3297
3298
3299
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3297

def sloop(&ruby_block)
  self << RubyHDL::High::Sloop.new(@sequencer,&ruby_block)
end

#step ⇒ Object

Mark a step.



3247
3248
3249
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3247

def step
  self << RubyHDL::High::Step.new(@sequencer)
end

#steps(num) ⇒ Object

Mark several steps.



3252
3253
3254
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3252

def steps(num)
  num.times { self.step }
end

#sterminate ⇒ Object

Terminates the sequencer.



3267
3268
3269
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3267

def sterminate
  self << RubyHDL::High::Sterminate.new(@sequencer)
end

#swait(cond) ⇒ Object

Wait a given condition.



3287
3288
3289
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3287

def swait(cond)
  self.swhile(~cond)
end

#swhile(cond, &ruby_block) ⇒ Object

Create a sequential while statement on +cond+.



3292
3293
3294
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3292

def swhile(cond,&ruby_block)
  self << RubyHDL::High::Swhile.new(@sequencer,cond,&ruby_block)
end

#sync ⇒ Object

Mark a synchronisation. For software only: stop the current sequencer for allowing sharing of variables with other ones.



3315
3316
3317
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3315

def sync
  self << RubyHDL::High::Sync.new
end

#to_c ⇒ Object

Convert to C code.



3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3231

def to_c
  res = ""
  # Generate the arguments if any.
  if @args.any? then
    res = "(#{@args.map(&:to_c).join(",")})\n"
  end
  # Generate the statements.
  res += "{" + @statements.map do |stmnt|
    stmnt.to_ruby + "\n"
  end.join + "}"
  return res
end

#to_ruby ⇒ Object

Convert to Ruby code.



3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3217

def to_ruby
  res = ""
  # Generate the arguments if any.
  if @args.any? then
    res = "|#{@args.map(&:to_ruby).join(",")}|\n"
  end
  # Generate the statements.
  res += @statements.map do |stmnt|
    stmnt.to_ruby + "\n"
  end.join
  return res
end

#unshift(statement) ⇒ Object

Unshift a new statement.



3206
3207
3208
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3206

def unshift(statement)
  @statements.unshift(statement)
end