Module: HDLRuby::High::Htype

Includes:
Tprocess
Included in:
Type, TypeDef, TypeStruct, TypeTuple, TypeVector
Defined in:
lib/HDLRuby/hruby_high.rb,
lib/HDLRuby/std/sequencer_sync.rb

Overview

Enhance the Htype module for creating a shared signal.

Constant Summary collapse

High = 
HDLRuby::High

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Tprocess

#&, #*, #+, #+@, #-@, #/, #<<, #==, #abs, #lr, #make, #resolve, #slice, #~

Class Method Details

.included(base) ⇒ Object

Ensures initialize registers the type name



1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
 
# File 'lib/HDLRuby/hruby_high.rb', line 1598

def self.included(base) # built-in Ruby hook for modules
    base.class_eval do    
        original_method = instance_method(:initialize)
        define_method(:initialize) do |*args, &block|
            original_method.bind(self).call(*args, &block)
            # Registers the name (if not empty).
            self.register(name) unless name.empty?
        end
    end
end

Instance Method Details

#[](rng) ⇒ Object

Creates a new vector type of range +rng+ and with current type as base.



1679
1680
1681
 
# File 'lib/HDLRuby/hruby_high.rb', line 1679

def [](rng)
    return TypeVector.new(:"",self,rng)
end

#binary(operator, expr0, expr1) ⇒ Object

Performs binary operation +operator+ on expressions +expr0+ and +expr1+.



1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
 
# File 'lib/HDLRuby/hruby_high.rb', line 1738

def binary(operator, expr0, expr1)
    # Look for a specific computation method.
    comp = comp_operator(operator)
    if self.respond_to?(comp) then
        # Found, use it.
        self.send(comp,expr0,expr1)
    else
        # Not found, back to default generation of binary expression.
        return Binary.new(self.send(operator,expr1.type),operator,
                          expr0,expr1)
    end
end

#comp_operator(op) ⇒ Object

Gets the computation method for +operator+.



1719
1720
1721
 
# File 'lib/HDLRuby/hruby_high.rb', line 1719

def comp_operator(op)
    return (op.to_s + ":C").to_sym
end

#constant(hsh) ⇒ Object

Declares high-level untyped constant signals by name and value given by +hsh+ of the current type.



1712
1713
1714
 
# File 'lib/HDLRuby/hruby_high.rb', line 1712

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

#define_operator(operator, &ruby_block) ⇒ Object

Redefinition of +operator+.



1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
 
# File 'lib/HDLRuby/hruby_high.rb', line 1752

def define_operator(operator,&ruby_block)
    # Ensure there is a block.
    ruby_block = proc {} unless block_given?
    # Register the operator as overloaded.
    @overloads ||= {}
    @overloads[operator] = ruby_block
    # Set the new method for the operator.
    self.define_singleton_method(comp_operator(operator)) do |*args|
        # puts "Top user=#{HDLRuby::High.top_user}"
        HDLRuby::High.top_user.sub(HDLRuby.uniq_name) do
            ruby_block.call(*args)
        end
    end
end

#define_operator_with_context(operator, &ruby_block) ⇒ Object

Redefinition of +operator+ when requiring the context to be passed as argument (normally only used internally).



1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
 
# File 'lib/HDLRuby/hruby_high.rb', line 1769

def define_operator_with_context(operator,&ruby_block)
    # Ensure there is a block.
    ruby_block = proc {} unless block_given?
    # Register the operator as overloaded.
    @overloads ||= {}
    @overloads[operator] = ruby_block
    # Set the new method for the operator.
    self.define_singleton_method(comp_operator(operator)) do |*args|
        # puts "Top user=#{HDLRuby::High.top_user}"
        HDLRuby::High.top_user.sub(HDLRuby.uniq_name) do
            # It is assumed that the first argument of the ruby_block
            # is the context in which it must be executed.
            ruby_block.call(self,*args)
        end
    end
end

#each_overload(&ruby_block) ⇒ Object

Interates over the overloaded operators.



1787
1788
1789
1790
1791
1792
 
# File 'lib/HDLRuby/hruby_high.rb', line 1787

def each_overload(&ruby_block)
    # No ruby block? Return an enumerator.
    return to_enum(:each_overload) unless ruby_block
    # A block? Apply it on each overload if any.
    @overloads.each(&ruby_block) if @overloads
end

#htype? ⇒ Boolean

Tells htype has been included.

Returns:

  • (Boolean) 


1610
1611
1612
 
# File 'lib/HDLRuby/hruby_high.rb', line 1610

def htype?
    return true
end

#inner(*names) ⇒ Object

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



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

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

#inout(*names) ⇒ Object

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



1699
1700
1701
1702
 
# File 'lib/HDLRuby/hruby_high.rb', line 1699

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

#input(*names) ⇒ Object

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



1686
1687
1688
 
# File 'lib/HDLRuby/hruby_high.rb', line 1686

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

#left ⇒ Object

Gets the type as left value.

NOTE: used for asymetric types like TypeSystemI.



1652
1653
1654
1655
 
# File 'lib/HDLRuby/hruby_high.rb', line 1652

def left
    # By default self.
    self
end

#name=(name) ⇒ Object

Sets the +name+.

NOTE: can only be done if the name is not already set.



1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
 
# File 'lib/HDLRuby/hruby_high.rb', line 1623

def name=(name)
    unless @name.empty? then
        raise AnyError, "Name of type already set to: #{@name}."
    end
    # Checks and sets the name.
    name = name.to_sym
    if name.empty? then
        raise AnyError, "Cannot set an empty name."
    end
    @name = name
    # Registers the name.
    self.register(name)
end

#output(*names) ⇒ Object

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



1692
1693
1694
1695
 
# File 'lib/HDLRuby/hruby_high.rb', line 1692

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

#register(name) ⇒ Object

Register the +name+ of the type.



1638
1639
1640
1641
1642
1643
1644
1645
1646
 
# File 'lib/HDLRuby/hruby_high.rb', line 1638

def register(name)
    if self.name.empty? then
        raise AnyError, "Cannot register with empty name."
    else
        # Sets the hdl-like access to the type.
        obj = self # For using the right self within the proc
        High.space_reg(name) { obj }
    end
end

#right ⇒ Object

Gets the type as right value.

NOTE: used for asymetric types like TypeSystemI.



1660
1661
1662
1663
 
# File 'lib/HDLRuby/hruby_high.rb', line 1660

def right
    # By default self.
    self
end

#shared(*args) ⇒ Object

Create new shared signals from +args+. +args+ can be a name of list of names or a hash associating names to default values.



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
# File 'lib/HDLRuby/std/sequencer_sync.rb', line 360

def shared(*args)
    # # Process the arguments.
    # Create the shared signal.
    sig = nil
    args.each do |arg|
        if arg.is_a?(Hash) then
            arg.each do |k,v|
                sig = SharedSignalI.new(self,k,v)
            end
        else
            sig = SharedSignalI.new(self,arg)
        end
    end
    return sig
end

#to_type ⇒ Object

Converts to a type. Returns self since it is already a type.



1616
1617
1618
 
# File 'lib/HDLRuby/hruby_high.rb', line 1616

def to_type
    return self
end

#typedef(name) ⇒ Object

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



1668
1669
1670
1671
1672
1673
1674
1675
 
# File 'lib/HDLRuby/hruby_high.rb', line 1668

def typedef(name)
    # Create the new type.
    typ = TypeDef.new(name,self)
    # Register it.
    High.space_reg(name) { typ }
    # Return it.
    return typ
end

#unary(operator, expr) ⇒ Object

Performs unary operation +operator+ on expression +expr+.



1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
 
# File 'lib/HDLRuby/hruby_high.rb', line 1724

def unary(operator,expr)
    # Look for a specific computation method.
    comp = comp_operator(operator)
    if self.respond_to?(comp) then
        # Found, use it.
        self.send(comp,expr)
    else
        # Not found, back to default generation of unary expression.
        return Unary.new(self.send(operator),operator,expr)
    end
end