Class: Array

Inherits:
Object
  • Object
show all
Includes:
HArrow, HEnumerable
Defined in:
lib/HDLRuby/hruby_high.rb,
lib/HDLRuby/std/hruby_enum.rb,
lib/HDLRuby/std/sequencer_sync.rb

Overview

Extends the Array class for conversion to a high-level expression.

Direct Known Subclasses

HDLRuby::High::Std::PipelineT::Stage

Instance Method Summary collapse

Instance Method Details

#constant(hsh) ⇒ Object

Declares high-level inner constants named from +hsh+ with names and corresponding values.



5455
5456
5457
 
# File 'lib/HDLRuby/hruby_high.rb', line 5455

def constant(hsh)
    High.top_user.make_constants(self.to_type,hsh)
end

#hcase(value, &ruby_block) ⇒ Object

Creates a hcase statement executing +ruby_block+ on the element of the array selected by +value+



5461
5462
5463
5464
5465
5466
5467
5468
 
# File 'lib/HDLRuby/hruby_high.rb', line 5461

def hcase(value,&ruby_block)
    # Ensure there is a block.
    ruby_block = proc {} unless block_given?
    High.cur_block.hcase(value)
    self.each.with_index do |elem,i|
        High.cur_block.hwhen(i) { ruby_block.call(elem) }
    end
end

#heach(&ruby_block) ⇒ Object

Enhance the Array class with extra arguments in interation.

include HEnumArg



1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
 
# File 'lib/HDLRuby/std/hruby_enum.rb', line 1113

def heach(&ruby_block)
  if !ruby_block then
    return HEnumeratorWrapper.new(self)
  end
  # self.each { |e| HDLRuby::High.top_user.sub { ruby_block.call(e) } }
  catch(:HDLRubyThrow) do
    caught = false
    self.each do |e|
      HDLRuby::High.top_user.sub do
        caught = true
        catch(:HDLRubyThrow) do
          # HDLRuby::High.top_user.instance_exec(e,&ruby_block)
          ruby_block.call(e)
          caught = false
        end
      end
      throw(:HDLRubyThrow) if caught
    end
  end
end

#inner(*names) ⇒ Object

Declares high-level inner signals named +names+ of the current type.



5449
5450
5451
 
# File 'lib/HDLRuby/hruby_high.rb', line 5449

def inner(*names)
    High.top_user.make_inners(self.to_type,*names)
end

#inout(*names) ⇒ Object

Declares high-level untyped inout signals named +names+ of the current type.



5443
5444
5445
 
# File 'lib/HDLRuby/hruby_high.rb', line 5443

def inout(*names)
    High.top_user.make_inouts(self.to_type,*names)
end

#input(*names) ⇒ Object

Declares high-level input signals named +names+ of the current type.



5431
5432
5433
 
# File 'lib/HDLRuby/hruby_high.rb', line 5431

def input(*names)
    High.top_user.make_inputs(self.to_type,*names)
end

#make(name, *args) ⇒ Object

Create an array of instances of system +name+, using +args+ as arguments.

NOTE: the array must have a single element that is an integer.



5497
5498
5499
5500
5501
5502
5503
5504
5505
5506
5507
5508
5509
5510
5511
5512
5513
5514
5515
5516
5517
5518
 
# File 'lib/HDLRuby/hruby_high.rb', line 5497

def make(name,*args)
    # Check the array and get the number of elements.
    size = self[0]
    unless self.size == 1 and size.is_a?(::Integer)
        raise AnyError,
              "Invalid array for declaring a list of instances."
    end
    # Get the system to instantiate.
    systemT = High.space_call(name)
    # Get the name of the instance from the arguments.
    nameI = args.shift.to_s
    # Create the instances.
    instances = size.times.map do |i| 
        systemT.instantiate((nameI + "[#{i}]").to_sym,*args)
    end
    nameI = nameI.to_sym
    # Add them to the top system
    High.space_top.user.add_groupI(nameI,*instances)
    # Register and return the result.
    High.space_reg(nameI) { High.space_top.user.get_groupI(nameI) }
    return High.space_top.user.get_groupI(nameI)
end

#output(*names) ⇒ Object

Declares high-level untyped output signals named +names+ of the current type.



5437
5438
5439
 
# File 'lib/HDLRuby/hruby_high.rb', line 5437

def output(*names)
    High.top_user.make_outputs(self.to_type,*names)
end

#shared(*names) ⇒ Object

Create new shared signals from +args+.



382
383
384
 
# File 'lib/HDLRuby/std/sequencer_sync.rb', line 382

def shared(*names)
    return self.to_type.shared(*names)
end

#to_expr ⇒ Object

Converts to a new high-level expression.



5393
5394
5395
5396
5397
5398
5399
5400
 
# File 'lib/HDLRuby/hruby_high.rb', line 5393

def to_expr
    elems = self.map {|elem| elem.to_expr }
    typ= TypeTuple.new(:"",:little)
    elems.each {|elem| typ.add_type(elem.type) }
    expr = Concat.new(typ)
    elems.each {|elem| expr.add_expression(elem) }
    expr
end

#to_ref ⇒ Object

Converts to a new high-level reference.



5403
5404
5405
5406
5407
5408
5409
 
# File 'lib/HDLRuby/hruby_high.rb', line 5403

def to_ref
    expr = RefConcat.new(TypeTuple.new(:"",:little,*self.map do |elem|
        elem.to_ref.type
    end))
    self.each {|elem| expr.add_ref(elem.to_ref) }
    expr
end

#to_type ⇒ Object

Converts to a new type.



5412
5413
5414
5415
5416
5417
5418
5419
5420
5421
 
# File 'lib/HDLRuby/hruby_high.rb', line 5412

def to_type
    if self.size == 1 and
       ( self[0].is_a?(Range) or self[0].respond_to?(:to_i) ) then
        # Vector type case
        return bit[*self]
    else
        # Tuple type case.
        return TypeTuple.new(:"",:little,*self)
    end
end

#typedef(name) ⇒ Object

Declares a new type definition with +name+ equivalent to current one.



5424
5425
5426
 
# File 'lib/HDLRuby/hruby_high.rb', line 5424

def typedef(name)
    return self.to_type.typedef(name)
end