Module: HDLRuby::High::HExpression

Included in:
Binary, Cast, Concat, Select, Std::PipelineT::PipeSignal, StringE, Unary, Value
Defined in:
lib/HDLRuby/hruby_high.rb

Overview

Module giving high-level expression properties

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#systemT ⇒ Object (readonly)

The system type the expression has been resolved in, if any.



2713
2714
2715
 
# File 'lib/HDLRuby/hruby_high.rb', line 2713

def systemT
  @systemT
end

#type ⇒ Object

The type of the expression if any.



2715
2716
2717
 
# File 'lib/HDLRuby/hruby_high.rb', line 2715

def type
  @type
end

Class Method Details

.orig_operator(op) ⇒ Object

Gets the origin method for operation +op+.



2895
2896
2897
 
# File 'lib/HDLRuby/hruby_high.rb', line 2895

def self.orig_operator(op)
    return (op.to_s + "_orig").to_sym
end

Instance Method Details

#[](rng) ⇒ Object

Creates an access to elements of range +rng+ of the signal.

NOTE: +rng+ can be a single expression in which case it is an index.



2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
 
# File 'lib/HDLRuby/hruby_high.rb', line 2969

def [](rng)
    if rng.is_a?(::Range) then
        first = rng.first
        if (first.is_a?(::Integer)) then
            first = self.type.size+first if first < 0
        end
        last = rng.last
        if (last.is_a?(::Integer)) then
            last = self.type.size+last if last < 0
        end
        rng = first..last
    end
    if rng.is_a?(::Integer) && rng < 0 then
        rng = self.type.size+rng
    end
    if rng.respond_to?(:to_expr) then
        # Number range: convert it to an expression.
        rng = rng.to_expr
    end 
    if rng.is_a?(HDLRuby::Low::Expression) then
        # Index case
        return RefIndex.new(self.type.base,self.to_expr,rng)
    else
        # Range case, ensure it is made among expression.
        first = rng.first.to_expr
        last = rng.last.to_expr
        # Abd create the reference.
        return RefRange.new(self.type.slice(first..last),
                            self.to_expr,first..last)
    end
end

#as(type) ⇒ Object

Casts as +type+.



2813
2814
2815
2816
2817
2818
2819
 
# File 'lib/HDLRuby/hruby_high.rb', line 2813

def as(type)
    if (self.parent)
        return Cast.new(type.to_type,self.to_expr)
    else
        return Cast.new(type.to_type,self)
    end
end

#coerce(obj) ⇒ Object

Coerce by forcing convertion of obj to expression.



2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
 
# File 'lib/HDLRuby/hruby_high.rb', line 2938

def coerce(obj)
    if obj.is_a?(HDLRuby::Low::Expression) then
        # Already an expression, nothing to do.
        return [obj,self]
    elsif obj.respond_to?(:to_expr) then
        # Can be converted to an expression, do it.
        return [obj.to_expr, self]
    else
        return [obj,self]
    end
end

#constant? ⇒ Boolean

Tell if the expression is constant.

Returns:

  • (Boolean) 


2791
2792
2793
2794
2795
2796
2797
 
# File 'lib/HDLRuby/hruby_high.rb', line 2791

def constant?
    # By default not constant.
    return false unless self.each_node.any?
    # If any sub node, check if all of them are constants.
    self.each_node { |node| return false unless node.constant? }
    return true
end

#inout(name) ⇒ Object

Creates inout port +name+ and connect it to the expression.



2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
 
# File 'lib/HDLRuby/hruby_high.rb', line 2758

def inout(name)
    # Ensures the name is a symbol.
    name = name.to_sym
    # Get access to the current expression
    obj = self
    # Create the inout.
    port = nil
    HDLRuby::High.cur_system.open do
        port = obj.type.inout(name)
    end
    # Make the connection when the instance is ready.
    HDLRuby::High.cur_system.on_instance do |inst|
        obj.scope.open do
            RefObject.new(inst,port.to_ref) <= obj
        end
    end
    return port
end

#input(name) ⇒ Object

Creates input port +name+ and connect it to the expression.



2718
2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
 
# File 'lib/HDLRuby/hruby_high.rb', line 2718

def input(name)
    # Ensures the name is a symbol.
    name = name.to_sym
    # Get access to the current expression
    obj = self
    # Create the input.
    port = nil
    HDLRuby::High.cur_system.open do
        port = obj.type.input(name)
    end
    # Make the connection when the instance is ready.
    HDLRuby::High.cur_system.on_instance do |inst|
        obj.scope.open do
            RefObject.new(inst,port.to_ref) <= obj
        end
    end
    return port
end

#ljust(n, v) ⇒ Object

Extends on the left to +n+ bits filling with +v+ bit values.



2837
2838
2839
 
# File 'lib/HDLRuby/hruby_high.rb', line 2837

def ljust(n,v)
    return [(v.to_s * (n-self.width)).to_expr, self]
end

#lr(n) ⇒ Object

Left rotate of +n+ bits.



2926
2927
2928
2929
 
# File 'lib/HDLRuby/hruby_high.rb', line 2926

def lr(n)
    w = self.type.width
    return [self[w-(n+1)..0], self[w-1..w-(n)]]
end

#ls(n) ⇒ Object

Left shift of +n+ bits.



2916
2917
2918
 
# File 'lib/HDLRuby/hruby_high.rb', line 2916

def ls(n)
    return self << n
end

#match_type(typ) ⇒ Object

Match the type with +typ+: cast if different type.



2886
2887
2888
2889
2890
2891
2892
 
# File 'lib/HDLRuby/hruby_high.rb', line 2886

def match_type(typ)
    if self.type.eql?(typ) then
        return self
    else
        return self.as(typ)
    end
end

#mux(*choices) ⇒ Object

Converts to a select operator using current expression as condition for one of the +choices+.

NOTE: +choices+ can either be a list of arguments or an array. If +choices+ has only two entries (and it is not a hash), +value+ will be converted to a boolean.



3010
3011
3012
3013
3014
3015
3016
 
# File 'lib/HDLRuby/hruby_high.rb', line 3010

def mux(*choices)
    # Process the choices.
    choices = choices.flatten(1) if choices.size == 1
    choices.map! { |choice| choice.to_expr }
    # Generate the select expression.
    return Select.new(choices[0].type,"?",self.to_expr,*choices)
end

#orig_operator(op) ⇒ Object 



2898
2899
2900
 
# File 'lib/HDLRuby/hruby_high.rb', line 2898

def orig_operator(op)
    HExpression.orig_operator(op)
end

#output(name) ⇒ Object

Creates output port +name+ and connect it to the expression.



2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
 
# File 'lib/HDLRuby/hruby_high.rb', line 2738

def output(name)
    # Ensures the name is a symbol.
    name = name.to_sym
    # Get access to the current expression
    obj = self
    # Create the output.
    port = nil
    HDLRuby::High.cur_system.open do
        port = obj.type.output(name)
    end
    # Make the connection when the instance is ready.
    HDLRuby::High.cur_system.on_instance do |inst|
        obj.scope.open do
            obj <= RefObject.new(inst,port.to_ref)
        end
    end
    return port
end

#rjust(n, v) ⇒ Object

Extends on the right to +n+ bits filling with +v+ bit values.



2842
2843
2844
 
# File 'lib/HDLRuby/hruby_high.rb', line 2842

def rjust(n,v)
    return [self, (v.to_s * (n-self.width)).to_expr]
end

#rr(n) ⇒ Object

Right rotate of +n+ bits.



2932
2933
2934
2935
 
# File 'lib/HDLRuby/hruby_high.rb', line 2932

def rr(n)
    w = self.type.width
    return [self[(n-1)..0], self[w-1..n]]
end

#rs(n) ⇒ Object

Right shift of +n+ bits.



2921
2922
2923
 
# File 'lib/HDLRuby/hruby_high.rb', line 2921

def rs(n)
    return self >> n
end

#sext(n) ⇒ Object

Extends on the left to +n+ bits preserving the signe.



2852
2853
2854
 
# File 'lib/HDLRuby/hruby_high.rb', line 2852

def sext(n)
    return self.ljust(self[-1])
end

#to_bit ⇒ Object

Casts to a bit vector type.



2822
2823
2824
 
# File 'lib/HDLRuby/hruby_high.rb', line 2822

def to_bit
    return self.as(bit[self.width])
end

#to_expr ⇒ Object

Converts to a new expression.

NOTE: to be redefined in case of non-expression class.

Raises:



2803
2804
2805
 
# File 'lib/HDLRuby/hruby_high.rb', line 2803

def to_expr
    raise AnyError, "Internal error: to_expr not defined yet for class: #{self.class}"
end

#to_unsigned ⇒ Object

Casts to a signed bit vector type.



2827
2828
2829
 
# File 'lib/HDLRuby/hruby_high.rb', line 2827

def to_unsigned
    return self.as(unsigned[self.width])
end

#to_value ⇒ Object

Converts to a new value.

NOTE: to be redefined.

Raises:



2785
2786
2787
2788
 
# File 'lib/HDLRuby/hruby_high.rb', line 2785

def to_value
    raise AnyError,
          "Expression cannot be converted to a value: #{self.class}"
end

#to_value? ⇒ Boolean

Tell if the expression can be converted to a value.

Returns:

  • (Boolean) 


2778
2779
2780
 
# File 'lib/HDLRuby/hruby_high.rb', line 2778

def to_value?
    return false
end

#zext(n) ⇒ Object

Extends on the left to +n+ bits filling with 0.



2847
2848
2849
 
# File 'lib/HDLRuby/hruby_high.rb', line 2847

def zext(n)
    return self.ljust(n,0)
end