module HDLRuby::Tprocess

To include to classes for type processing support.

Public Instance Methods

!=(type)
Alias for: ==
%(type)

Modulo

Alias for: /
&(type) click to toggle source

And

# File lib/HDLRuby/hruby_types.rb, line 159
def &(type)
    # # puts "compute types with=#{self} and #{type}"
    # # Resolve the type class.
    # resolved = self.resolve(type)
    #
    # # Logical operation on non-vector types are kept as is.
    # return resolved unless resolved.is_a?(TypeVector)

    # # Otherwise the range is computed.
    # # New type range: largest range
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # # puts "bounds=#{bounds}"
    # res_lsb =  bounds.min
    # res_msb = bounds.max
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end
Also aliased as: |, ^, <, >, <=, >=, <=>
*(type) click to toggle source

Multiplication

# File lib/HDLRuby/hruby_types.rb, line 100
def *(type)
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # # New type range: largest range * 2
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max * 2
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end
+(type) click to toggle source

Addition.

# File lib/HDLRuby/hruby_types.rb, line 78
def +(type)
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # # New type range: largest range + 1
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max + 1
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end
Also aliased as: -
+@() click to toggle source

Positive

# File lib/HDLRuby/hruby_types.rb, line 141
def +@()
    return self
end
-(type)

Subtraction

Alias for: +
-@() click to toggle source

Negative

# File lib/HDLRuby/hruby_types.rb, line 146
def -@()
    return self
end
/(type) click to toggle source

Division

# File lib/HDLRuby/hruby_types.rb, line 119
def /(type)
    # # Resolve the type class.
    # resolved = self.resolve(type)
    # # New type range: largest range
    # bounds = [ self.range.first.to_i, type.range.first.to_i,
    #            self.range.last.to_i, type.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end
Also aliased as: %
<(type)

Inferior

Alias for: &
<<(type) click to toggle source

Shift left

# File lib/HDLRuby/hruby_types.rb, line 221
def <<(type)
    # # The result type is the type of left.
    # resolved = self
    # # New type range: 2**(type width) times self range
    # bounds = [ self.range.first.to_i, self.range.last.to_i ]
    # res_lsb =  bounds.min
    # res_msb = bounds.max +
    #     (2 ** ((type.range.last-type.range.first).abs))
    # # Create and return the new type: its endianess is the one of self
    # if self.range.first.to_i > self.range.last.to_i then
    #     return resolved.make(:"",resolved.base,res_msb..res_lsb)
    # else
    #     return resolved.make(:"",resolved.base,res_lsb..res_msb)
    # end
    # The result is the resolve result now!
    return self.resolve(type)
end
Also aliased as: ls, >>, rs
<=(type)

Inferior or equal

Alias for: &
<=>(type)

Comparison

Alias for: &
==(type) click to toggle source

Equals alias_method :==, :&

# File lib/HDLRuby/hruby_types.rb, line 197
def ==(type)
    return Bit
end
Also aliased as: !=
>(type)

Superior

Alias for: &
>=(type)

Superior or equal

Alias for: &
>>(type)

Shift right

Alias for: <<
^(type)

Xor

Alias for: &
abs() click to toggle source

Absolute value

# File lib/HDLRuby/hruby_types.rb, line 151
def abs()
    return self
end
lr(type) click to toggle source

Rotate left.

# File lib/HDLRuby/hruby_types.rb, line 246
def lr(type)
    return self
end
Also aliased as: rr
ls(type)
Alias for: <<
make(name,base,range) click to toggle source

Creates a new generic vector type named name from base type and with range. NOTE: used for type processing.

# File lib/HDLRuby/hruby_types.rb, line 15
def make(name,base,range)
    # Generate a vector or a scalar type depending on the range.
    # First for checking the rangem ensures the bounds are Ruby
    # values.
    first = range.first
    last = range.last
    first = first.content if first.is_a?(Value)
    last = last.content if last.is_a?(Value)
    # Necessarily a TypeVector, since [0..0] has actually a
    # different meaning from [0]!
    # # Now can compare at Ruby level (and not HDLRuby level).
    # if first == last then
    #     # Single-element, return the base.
    #     return base
    # else
    #     # Multiple elements, create a new type vector.
    #     return TypeVector.new(name,base,range)
    # end
    return TypeVector.new(name,base,range)
end
resolve(type) click to toggle source

Type resolution: decide which class to use for representing a computating result with type.

# File lib/HDLRuby/hruby_types.rb, line 38
def resolve(type)
    # puts "self=#{self} type=#{type}"
    if self.float? then
        return self
    elsif type.float? then
        return type
    elsif self.signed? then
        return self
    elsif type.signed? then
        return type
    elsif self.unsigned? then
        return self
    elsif type.unsigned? then
        return type
    elsif self.width >= type.width then
        return self
    else
        return type
    end
end
rr(type)

Rotate right.

Alias for: lr
rs(type)
Alias for: <<
slice(idx) click to toggle source

Range access with idx NOTE:

- +idx+ may be a range.
- Do not use the [] operator for this since it is used for
  defining vector types!
# File lib/HDLRuby/hruby_types.rb, line 64
def slice(idx)
    if idx.is_a?(Range) then
        # Make a resized vector.
        return make(:"",self.base,idx)
    else
        # Return the base type.
        return self.base
    end
end
|(type)

Or

Alias for: &
~() click to toggle source

Not

# File lib/HDLRuby/hruby_types.rb, line 191
def ~()
    return self
end