Class: HDLRuby::Low::TypeTuple

Inherits:
Type
  • Object
show all
Includes:
Ltype
Defined in:
lib/HDLRuby/hruby_db.rb,
lib/HDLRuby/hruby_low.rb,
lib/HDLRuby/hruby_low2c.rb,
lib/HDLRuby/hruby_low2vhd.rb,
lib/HDLRuby/hruby_low2high.rb,
lib/HDLRuby/hruby_low_mutable.rb,
lib/HDLRuby/hruby_low_skeleton.rb,
lib/HDLRuby/hruby_low_without_namespace.rb

Overview

Extends the TypeTuple class with functionality for breaking hierarchical types.

Direct Known Subclasses

High::TypeTuple

Constant Summary

Constants included from Low2Symbol

Low2Symbol::Low2SymbolPrefix, Low2Symbol::Low2SymbolTable, Low2Symbol::Symbol2LowTable

Instance Attribute Summary

Attributes inherited from Type

#name

Attributes included from Hparent

#parent

Instance Method Summary collapse

Methods included from Ltype

included, #ltype?

Methods inherited from Type

#boolean?, #fixed?, #float?, #leaf?, #range?, #set_name!, #signed?, #struct?, #to_vector, #to_verilog, #unsigned?

Methods included from Low2Symbol

#to_sym

Methods included from Hparent

#scope

Constructor Details

#initialize(name, direction, *content) ⇒ TypeTuple

Creates a new tuple type named name width direction and whose sub types are given by content.



1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
 
# File 'lib/HDLRuby/hruby_low.rb', line 1656

def initialize(name,direction,*content)
    # Initialize the type.
    super(name)

    # Set the direction.
    @direction = direction.to_sym
    unless [:little, :big].include?(@direction)
        raise AnyError, "Invalid direction for a type: #{direction}"
    end

    # Check and set the content.
    content.each do |sub|
        unless sub.is_a?(Type) then
            raise AnyError, "Invalid class for a type: #{sub.class}"
        end
    end
    @types = content
end

Instance Method Details

#add_type(type) ⇒ Object

Adds a sub type.



1711
1712
1713
1714
1715
1716
1717
 
# File 'lib/HDLRuby/hruby_low.rb', line 1711

def add_type(type)
    unless type.is_a?(Type) then
        raise AnyError, 
              "Invalid class for a type: #{type.class} (#{type})"
    end
    @types << type
end

#base ⇒ Object

Gets the base type.

NOTE: only valid if the tuple is regular (i.e., all its sub types are identical)



1796
1797
1798
1799
1800
1801
1802
1803
 
# File 'lib/HDLRuby/hruby_low.rb', line 1796

def base
    if regular? then
        # Regular tuple, return the type of its first element.
        return @types[0]
    else
        raise AnyError, "No base type for type #{self}"
    end
end

#base? ⇒ Boolean

Tells if the type has a base.

NOTE: only if the tuple is regular (i.e., all its sub types are identical)

Returns:

  • (Boolean) 


1788
1789
1790
 
# File 'lib/HDLRuby/hruby_low.rb', line 1788

def base?
    return regular?
end

#break_types!(types) ⇒ Object

Breaks the hierarchical types into sequences of type definitions. Assumes to_upper_space! has been called before. types include the resulting types.



337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/HDLRuby/hruby_low_without_namespace.rb', line 337

def break_types!(types)
    self.map_types! do |sub|
        if sub.is_a?(TypeVector) || sub.is_a?(TypeTuple) ||
                sub.is_a?(TypeStruct) then
            # Need to break
            # First recurse on the sub.
            nsub = sub.break_types!(types)
            # Maybe such a type already exists.
            ndef = types[sub]
            if ndef then
                # Yes, use it.
                ndef.clone
            else
                # No change it to a type definition
                ndef = TypeDef.new(HDLRuby.uniq_name,nsub)
                # And add it to the types by structure.
                types[nsub] = ndef
                nsub
            end
        end
    end
    return self
end

#delete_type!(type) ⇒ Object

Deletes a type.



334
335
336
337
338
339
340
341
342
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 334

def delete_type!(type)
    if @types.include?(type) then
        # The type is present, delete it.
        @types.delete(type)
        # And remove its parent.
        type.parent = nil
    end
    type
end

#direction ⇒ Object

Get the direction of the type, little or big endian.



1767
1768
1769
 
# File 'lib/HDLRuby/hruby_low.rb', line 1767

def direction
    return @direction
end

#each(&ruby_block) ⇒ Object

Iterates over the sub name/type pair.

Returns an enumerator if no ruby block is given.



1722
1723
1724
1725
1726
1727
 
# File 'lib/HDLRuby/hruby_low.rb', line 1722

def each(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each) unless ruby_block
    # A ruby block? Apply it on each input signal instance.
    @types.each(&ruby_block)
end

#each_type(&ruby_block) ⇒ Object

Iterates over the sub types.

Returns an enumerator if no ruby block is given.



1732
1733
1734
1735
1736
1737
 
# File 'lib/HDLRuby/hruby_low.rb', line 1732

def each_type(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_type) unless ruby_block
    # A ruby block? Apply it on each input signal instance.
    @types.each(&ruby_block)
end

#each_type_deep(&ruby_block) ⇒ Object

Iterates over the types deeply if any.



1740
1741
1742
1743
1744
1745
1746
1747
 
# File 'lib/HDLRuby/hruby_low.rb', line 1740

def each_type_deep(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_type_deep) unless ruby_block
    # A ruby block? First apply it to current.
    ruby_block.call(self)
    # And recurse on the sub types.
    @types.each { |type| type.each_type_deep(&ruby_block) }
end

#eql?(obj) ⇒ Boolean

Comparison for hash: structural comparison.

Returns:

  • (Boolean) 


1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
 
# File 'lib/HDLRuby/hruby_low.rb', line 1677

def eql?(obj)
    # General type comparison.
    return false unless super(obj)
    # Specific comparison.
    idx = 0
    obj.each_type do |type|
        return false unless @types[idx].eql?(type)
        idx += 1
    end
    return false unless idx == @types.size
    return true
end

#equivalent?(type) ⇒ Boolean

Tell if type is equivalent to current type.

NOTE: type can be compatible while not being equivalent, please refer to hruby_types.rb for type compatibility.

Returns:

  • (Boolean) 


1809
1810
1811
1812
 
# File 'lib/HDLRuby/hruby_low.rb', line 1809

def equivalent?(type)
    return (type.is_a?(TypeTuple) and
            !@types.zip(type.types).index {|t0,t1| !t0.equivalent?(t1) })
end

#get_all_types ⇒ Object

Gets an array containing all the syb types.



1701
1702
1703
 
# File 'lib/HDLRuby/hruby_low.rb', line 1701

def get_all_types
    return @types.clone
end

#get_type(index) ⇒ Object

Gets a sub type by index.



1706
1707
1708
 
# File 'lib/HDLRuby/hruby_low.rb', line 1706

def get_type(index)
    return @types[index.to_i]
end

#hash ⇒ Object

Hash function.



1691
1692
1693
 
# File 'lib/HDLRuby/hruby_low.rb', line 1691

def hash
    return [super,@types].hash
end

#map_types!(&ruby_block) ⇒ Object

Maps on the sub types.



329
330
331
 
# File 'lib/HDLRuby/hruby_low_mutable.rb', line 329

def map_types!(&ruby_block)
    @types.map(&ruby_block)
end

#range ⇒ Object

Gets the range of the type.

NOTE: only valid if the tuple is regular (i.e., all its sub types are identical)



1775
1776
1777
1778
1779
1780
1781
1782
 
# File 'lib/HDLRuby/hruby_low.rb', line 1775

def range
    if regular? then
        # Regular tuple, return its range as if it was an array.
        return 0..@types.size-1
    else
        raise AnyError, "No range for type #{self}"
    end
end

#regular? ⇒ Boolean

Tell if the tuple is regular, i.e., all its sub types are equivalent.

NOTE: empty tuples are assumed not to be regular.

Returns:

  • (Boolean) 


1752
1753
1754
1755
1756
1757
1758
1759
 
# File 'lib/HDLRuby/hruby_low.rb', line 1752

def regular?
    return false if @types.empty?
    t0 = @types[0]
    @types[1..-1].each do |type|
        return false unless t0.equivalent?(type)
    end
    return true
end

#to_c(level = 0) ⇒ Object

Generates the text of the equivalent HDLRuby::High code. level is the hierachical level of the object.

NOTE: type tuples are converted to bit vector of their contents.



550
551
552
553
554
555
 
# File 'lib/HDLRuby/hruby_low2c.rb', line 550

def to_c(level = 0)
    # return "get_type_tuple(#{self.each.to_a.join(",") do |type|
    #    type.to_c(level+1)
    # end})"
    return self.to_vector.to_c(level)
end

#to_high(level = 0) ⇒ Object

Generates the text of the equivalent HDLRuby::High code. level is the hierachical level of the object.



213
214
215
216
217
218
219
220
221
222
 
# File 'lib/HDLRuby/hruby_low2high.rb', line 213

def to_high(level = 0)
    # The resulting string.
    res = "["
    # Generate each sub type.
    res << self.each_type.map { |type| type.to_high(level) }.join(", ")
    # Close the tuple.
    res << "]"
    # Return the result.
    return res
end

#to_vhdl(level = 0) ⇒ Object

Generates the text of the equivalent HDLRuby::High code. level is the hierachical level of the object.

NOTE: type tuples are converted to bit vector of their contents.



703
704
705
706
 
# File 'lib/HDLRuby/hruby_low2vhd.rb', line 703

def to_vhdl(level = 0)
    # raise AnyError, "Tuple types are not supported in VHDL, please convert them to Struct types using Low::tuple2struct from HDLRuby/hruby_low_witout_tuple."
    return self.to_vector.to_vhdl(level)
end

#types? ⇒ Boolean

Tells if the type has sub types.

Returns:

  • (Boolean) 


1696
1697
1698
 
# File 'lib/HDLRuby/hruby_low.rb', line 1696

def types?
    return true
end

#width ⇒ Object

Gets the bitwidth.



1762
1763
1764
 
# File 'lib/HDLRuby/hruby_low.rb', line 1762

def width
    return @types.reduce(0) { |sum,type| sum + type.width }
end