Class: Range

Inherits:
Object
  • Object
show all
Includes:
SEnumerable
Defined in:
lib/HDLRuby/hruby_high.rb,
lib/HDLRuby/std/sequencer.rb

Overview

Extends the range class to support to_low

Instance Method Summary collapse

Instance Method Details

#heach(&ruby_block) ⇒ Object

Iterates over the range as hardware.

Returns an enumerator if no ruby block is given.



5289
5290
5291
5292
5293
5294
5295
5296
5297
 
# File 'lib/HDLRuby/hruby_high.rb', line 5289

def heach(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:heach) unless ruby_block
    # Order the bounds to be able to iterate.
    first,last = self.first, self.last
    first,last = first > last ? [last,first] : [first,last]
    # Iterate.
    (first..last).each(&ruby_block)
end

#seach(&ruby_block) ⇒ Object

HW iteration on each element.



2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
 
# File 'lib/HDLRuby/std/sequencer.rb', line 2194

def seach(&ruby_block)
    # Create the iteration type.
    # if self.first < 0 || self.last < 0 then
    #     fw = self.first.is_a?(Numeric) ? self.first.abs.width :
    #          self.first.width
    #     lw = self.last.is_a?(Numeric) ? self.last.abs.width :
    #          self.last.width
    #     typ = signed[[fw,lw].max]
    # else
    #     typ = bit[[self.first.width,self.last.width].max]
    # end
    # Create the iteration type: selection of the larger HDLRuby type
    # between first and last. If one of first and last is a Numeric,
    # priority to the non Numeric one.
    if (self.last.is_a?(Numeric)) then
        typ = self.first.to_expr.type
    elsif (self.first.is_a?(Numeric)) then
        typ = self.last.to_expr.type
    else
        typ = self.first.type.width > self.last.type.width ? 
            self.first.type : self.last.type
    end
    # Create the hardware iterator.
    this = self
    size = this.size ? this.size : this.last - this.first + 1
    # size = size.to_expr
    # if size.respond_to?(:cast) then
    #     size = size.cast(typ)
    # else
    #     size = size.as(typ)
    # end
    size = size.to_expr.as(typ)
    # hw_enum = SEnumeratorBase.new(signed[32],size) do |idx|
    hw_enum = SEnumeratorBase.new(typ,size) do |idx|
        # idx.as(typ) + this.first
        idx.as(typ) + this.first.to_expr.as(typ)
    end
    # Is there a ruby block?
    if(ruby_block) then
        # Yes, apply it.
        return hw_enum.seach(&ruby_block)
    else
        # No, return the resulting enumerator.
        return hw_enum
    end
end

#to_low ⇒ Object

Convert the first and last to HDLRuby::Low



5278
5279
5280
5281
5282
5283
5284
 
# File 'lib/HDLRuby/hruby_high.rb', line 5278

def to_low
    first = self.first
    first = first.respond_to?(:to_low) ? first.to_low : first
    last = self.last
    last = last.respond_to?(:to_low) ? last.to_low : last
    return (first..last)
end