Class: RubyHDL::High::Siter

Inherits:
Object
  • Object
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+.



2153
2154
2155
2156
2157
2158
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2153

def initialize(sequencer,*commands, &ruby_block)
  @sequencer = sequencer
  puts "@sequencer=#{@sequencer}"
  @commands = commands
  @blk = Sblock.new(sequencer,&ruby_block)
end

Instance Method Details

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

Iterate on the commands.



2161
2162
2163
2164
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2161

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

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

Create an iterator for a given method +meth+.



2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2175

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
  return Iter.new(@sequencer,*self.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) 


2203
2204
2205
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2203

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) 


2209
2210
2211
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2209

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+



2214
2215
2216
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2214

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.



2220
2221
2222
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2220

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.



2226
2227
2228
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2226

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



2247
2248
2249
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2247

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

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

WH implementation of the Ruby count.



2253
2254
2255
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2253

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.



2258
2259
2260
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2258

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

#sdrop(n) ⇒ Object

HW implementation of the Ruby drop.



2270
2271
2272
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2270

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

#sdrop_while(&ruby_block) ⇒ Object

HW implementation of the Ruby drop_while.



2275
2276
2277
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2275

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



2280
2281
2282
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2280

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.



2286
2287
2288
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2286

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.


2501
2502
2503
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2501

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.


2197
2198
2199
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2197

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



2291
2292
2293
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2291

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

#seach_with_index(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby each_with_index.



2296
2297
2298
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2296

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.



2301
2302
2303
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2301

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.



2265
2266
2267
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2265

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.



2316
2317
2318
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2316

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.



2321
2322
2323
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2321

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



2241
2242
2243
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2241

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.



2327
2328
2329
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2327

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.



2333
2334
2335
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2333

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.



2339
2340
2341
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2339

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) 


2344
2345
2346
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2344

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

#sinject(*args, &ruby_block) ⇒ Object

HW implementation of the Ruby inject.



2349
2350
2351
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2349

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.



2361
2362
2363
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2361

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.



2234
2235
2236
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2234

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

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

HW implementation of the Ruby max.



2366
2367
2368
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2366

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.



2371
2372
2373
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2371

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.



2376
2377
2378
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2376

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.



2381
2382
2383
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2381

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.



2386
2387
2388
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2386

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

#sminmax_by(&ruby_block) ⇒ Object

HW implementation of the Ruby minmax_by.



2391
2392
2393
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2391

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) 


2397
2398
2399
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2397

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) 


2403
2404
2405
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2403

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.



2409
2410
2411
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2409

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

#sreduce ⇒ Object

HW implementation of the Ruby reduce.



2354
2355
2356
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2354

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

#sreject(&ruby_block) ⇒ Object

HW implementatiob of the Ruby reject.



2414
2415
2416
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2414

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.



2419
2420
2421
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2419

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.



2311
2312
2313
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2311

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.



2425
2426
2427
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2425

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.



2431
2432
2433
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2431

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.



2437
2438
2439
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2437

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

#ssort(&ruby_block) ⇒ Object

HW implementation of the Ruby sort.



2447
2448
2449
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2447

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

#ssort_by(&ruby_block) ⇒ Object

HW implementation of the Ruby sort.



2452
2453
2454
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2452

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.



2442
2443
2444
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2442

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.



2457
2458
2459
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2457

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.



2462
2463
2464
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2462

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

#stake_while(&ruby_block) ⇒ Object

The HW implementation of the Ruby take_while.



2467
2468
2469
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2467

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.



2473
2474
2475
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2473

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

#sto_a ⇒ Object

HW implementation of the Ruby to_a.



2306
2307
2308
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2306

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.



2479
2480
2481
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2479

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

#suniq(&ruby_block) ⇒ Object

HW implementation of the Ruby uniq.



2484
2485
2486
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2484

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.



2491
2492
2493
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2491

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

#to_ruby ⇒ Object

Convert to ruby code.



2168
2169
2170
2171
2172
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 2168

def to_ruby
  res = @sequencer.clk_up + "\n" + 
    @commands.map { |command| command.to_ruby }.join(".") 
  return res + " do\n#{@blk.to_ruby}\n#{@sequencer.clk_up}\nend"
end