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

#as(typ) ⇒ Object

Casts to typ.



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

def as(typ)
  return self.to_expr.as(typ)
end

#constant(hsh) ⇒ Object

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



5539
5540
5541
 
# File 'lib/HDLRuby/hruby_high.rb', line 5539

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



5545
5546
5547
5548
5549
5550
5551
5552
 
# File 'lib/HDLRuby/hruby_high.rb', line 5545

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

#hcasez(value, &ruby_block) ⇒ Object

Creates a hcase statement taking z as wildcard executing ruby_block on the element of the array selected by value



5556
5557
5558
5559
5560
5561
5562
5563
 
# File 'lib/HDLRuby/hruby_high.rb', line 5556

def hcasez(value,&ruby_block)
    # Ensure there is a block.
    ruby_block = proc {} unless block_given?
    High.cur_block.hcasez(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.



5533
5534
5535
 
# File 'lib/HDLRuby/hruby_high.rb', line 5533

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.



5527
5528
5529
 
# File 'lib/HDLRuby/hruby_high.rb', line 5527

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.



5515
5516
5517
 
# File 'lib/HDLRuby/hruby_high.rb', line 5515

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.



5592
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605
5606
5607
5608
5609
5610
5611
5612
5613
 
# File 'lib/HDLRuby/hruby_high.rb', line 5592

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.



5521
5522
5523
 
# File 'lib/HDLRuby/hruby_high.rb', line 5521

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

#sext(n) ⇒ Object

Extends on the left to n bits preserving the signe.



5480
5481
5482
 
# File 'lib/HDLRuby/hruby_high.rb', line 5480

def sext(n)
  return self.to_bit.sext(n)
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_bit ⇒ Object

Converts to a bit vector.



5460
5461
5462
 
# File 'lib/HDLRuby/hruby_high.rb', line 5460

def to_bit
  return self.to_expr.to_bit
end

#to_expr ⇒ Object

Converts to a new high-level expression.



5445
5446
5447
5448
5449
5450
5451
5452
 
# File 'lib/HDLRuby/hruby_high.rb', line 5445

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.



5487
5488
5489
5490
5491
5492
5493
 
# File 'lib/HDLRuby/hruby_high.rb', line 5487

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_signed ⇒ Object

Casts to a signed bit vector type.



5470
5471
5472
 
# File 'lib/HDLRuby/hruby_high.rb', line 5470

def to_signed
    return self.to_bit_to_signed
end

#to_type ⇒ Object

Converts to a new type.



5496
5497
5498
5499
5500
5501
5502
5503
5504
5505
 
# File 'lib/HDLRuby/hruby_high.rb', line 5496

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

#to_unsigned ⇒ Object

Casts to an unsigned bit vector type.



5465
5466
5467
 
# File 'lib/HDLRuby/hruby_high.rb', line 5465

def to_unsigned
  return self.to_bit.to_unsigned
end

#typedef(name) ⇒ Object

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



5508
5509
5510
 
# File 'lib/HDLRuby/hruby_high.rb', line 5508

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

#zext(n) ⇒ Object

Extends on the left to n bits filling with 0.



5475
5476
5477
 
# File 'lib/HDLRuby/hruby_high.rb', line 5475

def zext(n)
  return self.to_bit.zext(n)
end