Class: RubyHDL::High::Siter

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

Overview

Describes a SW implementation of an iterator statement.

Instance Method Summary collapse

Constructor Details

#initialize(sequencer, *commands, &ruby_block) ⇒ Siter

Create a new iteration statement in sequencer +sequencer+ for chain of commands +commands+ to interate while executing +ruby_block+.



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

def initialize(sequencer,*commands, &ruby_block)
  @sequencer = sequencer
  @commands = commands
  if ruby_block then
    # The iterator is finalized.
    @blk = Sblock.new(sequencer,&ruby_block)
  end
  # puts "New iterator with blk=#{@blk} commands=#{@commands}"
end

Instance Method Details

#each_command(&ruby_block) ⇒ Object Also known as: each

Iterate on the commands.



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

def each_command(&ruby_block)
  return to_enum(:each_command) unless ruby_block
  @commands.each(&ruby_block)
end

#each_statement(&ruby_block) ⇒ Object

Iterate on the statements.



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

def each_statement(&ruby_block)
  return to_enum(:each_statement) unless ruby_block
  # Apply ruby_block on the block.
  @blk.each_statement(&ruby_block)
end

#each_statement_deep(&ruby_block) ⇒ Object

Iterate deeply on the statements.



3327
3328
3329
3330
3331
3332
3333
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3327

def each_statement_deep(&ruby_block)
  return to_enum(:each_statement_deep) unless ruby_block
  # Recurse on the yes block.
  @blk.each_statement_deep
  # And apply ruby_block on self.
  ruby_block.call(self)
end

#make_iterator(meth, *args, &ruby_block) ⇒ Object

Create an iterator for a given method +meth+.



3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3361

def make_iterator(meth,*args,&ruby_block)
  # if ruby_block then
  #   blk = Sblock.new(@sequencer,&ruby_block)
  #   command = RubyHDL::High::Ruby.new do
  #     "#{meth}(#{args.map{|arg| arg.to_ruby}.join(",")}) { #{blk.to_ruby} }"
  #   end
  # else
  #   command = RubyHDL::High::Ruby.new do
  #     "#{meth}(#{args.map{|arg| arg.to_ruby}.join(",")})"
  #   end
  # end
  command = "#{meth}"
  if args.any? then
    command += "(*#{RubyHDL::High::Ruby.new {
    "#{args.map{|arg| arg.to_ruby}.join(",")}"}})"
  end
  return Siter.new(@sequencer,*@commands,command,&ruby_block)
end

#sall?(arg = nil, &ruby_block) ⇒ Boolean

Tell if all the elements respect a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


3394
3395
3396
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3394

def sall?(arg = nil,&ruby_block)
  return self.make_iterator("all?",arg,&ruby_block)
end

#sany?(arg = nil, &ruby_block) ⇒ Boolean

Tell if any of the elements respects a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


3400
3401
3402
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3400

def sany?(arg = nil,&ruby_block)
  return self.make_iterator("any?",arg,&ruby_block)
end

#schain(arg) ⇒ Object

Returns an SEnumerator generated from current enumerable and +arg+



3405
3406
3407
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3405

def schain(arg)
  return self.make_iterator("chain",arg)
end

#schunk(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby chunk. NOTE: to do, or may be not.



3411
3412
3413
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3411

def schunk(*args,&ruby_block)
  raise "schunk is not supported yet."
end

#schunk_while(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby chunk_while. NOTE: to do, or may be not.



3417
3418
3419
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3417

def schunk_while(*args,&ruby_block)
  raise "schunk_while is not supported yet."
end

#scompact ⇒ Object

HW implementation of the Ruby compact, but remove 0 values instead on nil (since nil that does not have any meaning in HW).



3438
3439
3440
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3438

def scompact
  return self.make_iterator("compact",&ruby_block)
end

#scount(obj = nil, &ruby_block) ⇒ Object

WH implementation of the Ruby count.



3444
3445
3446
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3444

def scount(obj = nil, &ruby_block)
  return self.make_iterator("count",obj,&ruby_block)
end

#scycle(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby cycle.



3449
3450
3451
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3449

def scycle(n = nil,&ruby_block)
  return self.make_iterator("cycle",n,&ruby_block)
end

#sdrop(n) ⇒ Object

HW implementation of the Ruby drop.



3461
3462
3463
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3461

def sdrop(n)
  return self.make_iterator("drop",n)
end

#sdrop_while(&ruby_block) ⇒ Object

HW implementation of the Ruby drop_while.



3466
3467
3468
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3466

def sdrop_while(&ruby_block)
  return self.make_iterator("drop_while",&ruby_block)
end

#seach_cons(n, &ruby_block) ⇒ Object

HW implementation of the Ruby each_cons



3471
3472
3473
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3471

def seach_cons(n,&ruby_block)
  return self.make_iterator("each_cons",n,&ruby_block)
end

#seach_entry(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby each_entry. NOTE: to do, or may be not.



3477
3478
3479
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3477

def seach_entry(*args,&ruby_block)
  raise "seach_entry is not supported yet."
end

#seach_nexts(num, &ruby_block) ⇒ Object

Iterator on the +num+ next elements. NOTE:

  • Stop iteration when the end of the range is reached or when there are no elements left
  • This is not a method from Ruby but one specific for hardware where creating a array is very expensive.


3693
3694
3695
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3693

def seach_nexts(num,&ruby_block)
  return self.seach.snexts(num,&ruby_block)
end

#seach_range(rng, &ruby_block) ⇒ Object

Iterator on each of the elements in range +rng+. NOTE:

  • Stop iteration when the end of the range is reached or when there are no elements left
  • This is not a method from Ruby but one specific for hardware where creating a array is very expensive.


3388
3389
3390
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3388

def seach_range(rng,&ruby_block)
  return self.make_iterator("each_range",rng,&ruby_block)
end

#seach_slice(n, &ruby_block) ⇒ Object

HW implementation of the Ruby each_slice



3482
3483
3484
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3482

def seach_slice(n,&ruby_block)
  return self.make_iterator("each_slice",n,&ruby_block)
end

#seach_with_index(*args, &ruby_block) ⇒ Object Also known as: with_index

HW implementation of the Ruby each_with_index.



3487
3488
3489
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3487

def seach_with_index(*args,&ruby_block)
  return self.make_iterator("each_with_index",*args,&ruby_block)
end

#seach_with_object(obj, &ruby_block) ⇒ Object

HW implementation of the Ruby each_with_object.



3493
3494
3495
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3493

def seach_with_object(obj,&ruby_block)
  return self.make_iterator("each_with_object",obj,&ruby_block)
end

#sfind(if_none_proc, &ruby_block) ⇒ Object

HW implementation of the Ruby find. NOTE: contrary to Ruby, if_none_proc is mandatory since there is no nil in HW. Moreover, the argument can also be a value.



3456
3457
3458
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3456

def sfind(if_none_proc, &ruby_block)
  return self.make_iterator("find",if_none_proc,&ruby_block)
end

#sfind_index(obj = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby find_index.



3508
3509
3510
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3508

def sfind_index(obj = nil, &ruby_block)
  return self.make_iterator("find_index",obj,&ruby_block)
end

#sfirst(n = 1) ⇒ Object

HW implementation of the Ruby first.



3513
3514
3515
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3513

def sfirst(n=1)
  return self.make_iterator("first",n)
end

#sflat_map(&ruby_block) ⇒ Object

HW implementation of the Ruby flat_map. NOTE: actually due to the way HDLRuby handles vectors, should work like smap



3432
3433
3434
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3432

def sflat_map(&ruby_block)
  return self.make_iterator("flat_map",&ruby_block)
end

#sgrep(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby grep. NOTE: to do, or may be not.



3519
3520
3521
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3519

def sgrep(*args,&ruby_block)
  raise "sgrep is not supported yet."
end

#sgrep_v(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby grep_v. NOTE: to do, or may be not.



3525
3526
3527
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3525

def sgrep_v(*args,&ruby_block)
  raise "sgrep_v is not supported yet."
end

#sgroup_by(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby group_by. NOTE: to do, or may be not.



3531
3532
3533
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3531

def sgroup_by(*args,&ruby_block)
  raise "sgroup_by is not supported yet."
end

#sinclude?(obj) ⇒ Boolean

HW implementation of the Ruby include?

Returns:

  • (Boolean) 


3536
3537
3538
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3536

def sinclude?(obj)
  return self.make_iterator("include?",obj)
end

#sinject(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby inject.



3541
3542
3543
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3541

def sinject(*args,&ruby_block)
  return self.make_iterator("inject",*args,&ruby_block)
end

#slazy(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby lazy. NOTE: to do, or may be not.



3553
3554
3555
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3553

def slazy(*args,&ruby_block)
  raise "slazy is not supported yet."
end

#smap(&ruby_block) ⇒ Object

Returns a vector containing the execution result of the given block on each element. If no block is given, return an SEnumerator. NOTE: be carful that the resulting vector can become huge if there are many element.



3425
3426
3427
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3425

def smap(&ruby_block)
  return self.make_iterator("map",&ruby_block)
end

#smax(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby max.



3558
3559
3560
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3558

def smax(n = nil, &ruby_block)
  return self.make_iterator("max",n,&ruby_block)
end

#smax_by(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby max_by.



3563
3564
3565
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3563

def smax_by(n = nil, &ruby_block)
  return self.make_iterator("max_by",n,&ruby_block)
end

#smin(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby min.



3568
3569
3570
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3568

def smin(n = nil, &ruby_block)
  return self.make_iterator("min",n,&ruby_block)
end

#smin_by(n = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby min_by.



3573
3574
3575
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3573

def smin_by(n = nil, &ruby_block)
  return self.make_iterator("min_by",n,&ruby_block)
end

#sminmax(&ruby_block) ⇒ Object

HW implementation of the Ruby minmax.



3578
3579
3580
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3578

def sminmax(&ruby_block)
  return self.make_iterator("minmax",&ruby_block)
end

#sminmax_by(&ruby_block) ⇒ Object

HW implementation of the Ruby minmax_by.



3583
3584
3585
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3583

def sminmax_by(&ruby_block)
  return self.make_iterator("minmax_by",&ruby_block)
end

#snone?(arg = nil, &ruby_block) ⇒ Boolean

Tell if none of the elements respects a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


3589
3590
3591
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3589

def snone?(arg = nil,&ruby_block)
  return self.make_iterator("none?",arg,&ruby_block)
end

#sone?(arg = nil, &ruby_block) ⇒ Boolean

Tell if one and only one of the elements respects a given criterion given either as +arg+ or as block.

Returns:

  • (Boolean) 


3595
3596
3597
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3595

def sone?(arg = nil,&ruby_block)
  return self.make_iterator("one?",arg,&ruby_block)
end

#spartition(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby partition. NOTE: to do, or may be not.



3601
3602
3603
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3601

def spartition(*args,&ruby_block)
  raise "spartition is not supported yet."
end

#sreduce ⇒ Object

HW implementation of the Ruby reduce.



3546
3547
3548
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3546

def sreduce
  return self.make_iterator("reduce",*args,&ruby_block)
end

#sreject(&ruby_block) ⇒ Object

HW implementatiob of the Ruby reject.



3606
3607
3608
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3606

def sreject(&ruby_block)
  return self.make_iterator("reject",&ruby_block)
end

#sreverse_each(*args, &ruby_block) ⇒ Object

HW implementatiob of the Ruby reverse_each.



3611
3612
3613
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3611

def sreverse_each(*args,&ruby_block)
  return self.make_iterator("reverse_each",*args,&ruby_block)
end

#sselect(&ruby_block) ⇒ Object

HW implementation of the Ruby select.



3503
3504
3505
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3503

def sselect(&ruby_block)
  return self.make_iterator("select",&ruby_block)
end

#sslice_after(pattern = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby slice_after. NOTE: to do, or may be not.



3617
3618
3619
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3617

def sslice_after(pattern = nil,&ruby_block)
  raise "sslice_after is not supported yet."
end

#sslice_before(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby slice_before. NOTE: to do, or may be not.



3623
3624
3625
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3623

def sslice_before(*args,&ruby_block)
  raise "sslice_before is not supported yet."
end

#sslice_when(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby slice_when. NOTE: to do, or may be not.



3629
3630
3631
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3629

def sslice_when(*args,&ruby_block)
  raise "sslice_before is not supported yet."
end

#ssort(&ruby_block) ⇒ Object

HW implementation of the Ruby sort.



3639
3640
3641
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3639

def ssort(&ruby_block)
  return self.make_iterator("sort",&ruby_block)
end

#ssort_by(&ruby_block) ⇒ Object

HW implementation of the Ruby sort.



3644
3645
3646
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3644

def ssort_by(&ruby_block)
  return self.make_iterator("sort_by",&ruby_block)
end

#ssort_merge(arI, arO, first, middle, last, &ruby_block) ⇒ Object

Merge two arrays in order, for ssort only.



3634
3635
3636
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3634

def ssort_merge(arI, arO, first, middle, last, &ruby_block)
  return self.make_iterator("sort_merge",arI,arO,first,middle,last,&ruby_block)
end

#ssum(initial_value = nil, &ruby_block) ⇒ Object

HW implementation of the Ruby sum.



3649
3650
3651
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3649

def ssum(initial_value = nil,&ruby_block)
  return self.make_iterator("sum",initial_value,&ruby_block)
end

#stake(n) ⇒ Object

The HW implementation of the Ruby take.



3654
3655
3656
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3654

def stake(n)
  return self.make_iterator("take",n)
end

#stake_while(&ruby_block) ⇒ Object

The HW implementation of the Ruby take_while.



3659
3660
3661
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3659

def stake_while(&ruby_block)
  return self.make_iterator("take_while",&ruby_block)
end

#stally(h = nil) ⇒ Object

HW implementation of the Ruby tally. NOTE: to do, or may be not.



3665
3666
3667
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3665

def stally(h = nil)
  raise "stally is not supported yet."
end

#sto_a ⇒ Object

HW implementation of the Ruby to_a.



3498
3499
3500
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3498

def sto_a
  return self.make_iterator("to_a")
end

#sto_h(h = nil) ⇒ Object

HW implementation of the Ruby to_h. NOTE: to do, or may be not.



3671
3672
3673
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3671

def sto_h(h = nil)
  raise "sto_h is not supported yet."
end

#suniq(&ruby_block) ⇒ Object

HW implementation of the Ruby uniq.



3676
3677
3678
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3676

def suniq(&ruby_block)
  return self.make_iterator("uniq",&ruby_block)
end

#szip(obj, &ruby_block) ⇒ Object

HW implementation of the Ruby zip. NOTE: for now szip is deactivated untile tuples are properly handled by HDLRuby.



3683
3684
3685
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3683

def szip(obj,&ruby_block)
  return self.make_iterator("zip",obj,&ruby_block)
end

#to_c ⇒ Object

Convert to C code.



3347
3348
3349
3350
3351
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3347

def to_c
  res = @sequencer.clk_up_c + "\n" +
    @commands.map { |command| command.to_c }.join("_")
  return res + "(#{@blk.to_c})"
end

#to_python(l = "") ⇒ Object

Convert to Python code.



3354
3355
3356
3357
3358
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3354

def to_python(l = "")
  res = @sequencer.clk_up_python(l) + "\n" +
    @commands.map { |command| command.to_python }.join("_")
  return res + "(#{@blk.to_python})"
end

#to_ruby ⇒ Object

Convert to Ruby code.



3336
3337
3338
3339
3340
3341
3342
3343
3344
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 3336

def to_ruby
  # puts "to_ruby with blk=#{@blk} commands=#{@commands}"
  res = @sequencer.clk_up + "\n" + 
    @commands.map { |command| command.to_ruby }.join(".") 
  return res + " do" + 
    (@blk.each_arg.any? ? 
     "|#{@blk.each_arg.map(&:to_ruby).join(",")}|" : "") + 
    "\n#{@blk.to_ruby}\n#{@sequencer.clk_up}\nend"
end