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.



2504
2505
2506
 
# File 'lib/HDLRuby/hruby_high.rb', line 2504

def systemT
  @systemT
end

#type ⇒ Object

The type of the expression if any.



2506
2507
2508
 
# File 'lib/HDLRuby/hruby_high.rb', line 2506

def type
  @type
end

Class Method Details

.orig_operator(op) ⇒ Object

Gets the origin method for operation +op+.



2677
2678
2679
 
# File 'lib/HDLRuby/hruby_high.rb', line 2677

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.



2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
 
# File 'lib/HDLRuby/hruby_high.rb', line 2750

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+.



2604
2605
2606
2607
2608
2609
2610
 
# File 'lib/HDLRuby/hruby_high.rb', line 2604

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.



2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
 
# File 'lib/HDLRuby/hruby_high.rb', line 2720

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) 


2582
2583
2584
2585
2586
2587
2588
 
# File 'lib/HDLRuby/hruby_high.rb', line 2582

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.



2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
 
# File 'lib/HDLRuby/hruby_high.rb', line 2549

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.



2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
2526
 
# File 'lib/HDLRuby/hruby_high.rb', line 2509

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.



2628
2629
2630
 
# File 'lib/HDLRuby/hruby_high.rb', line 2628

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

#lr(n) ⇒ Object

Left rotate of +n+ bits.



2708
2709
2710
2711
 
# File 'lib/HDLRuby/hruby_high.rb', line 2708

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.



2698
2699
2700
 
# File 'lib/HDLRuby/hruby_high.rb', line 2698

def ls(n)
    return self << n
end

#match_type(typ) ⇒ Object

Match the type with +typ+:

  • Recurse on the sub expr if hierachical type, raising an arror if the expression is not hierarchical.
  • Directly cast otherwise.


2651
2652
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
 
# File 'lib/HDLRuby/hruby_high.rb', line 2651

def match_type(typ)
    # Has the type sub types?
    if typ.types? then
        unless self.is_a?(Concat) then
            raise AnyError,
                "Invalid class for assignment to hierarchical: #{self.class}."
        end
        return Concat.new(typ,
          self.each_expression.zip(typ.each_type).map do |e,t|
            e.match_type(t)
        end)
    elsif typ.vector? && typ.base.hierarchical? then
        unless self.is_a?(Concat) then
            raise AnyError,
                "Invalid class for assignment to hierarchical: #{self.class}."
        end
        return Concat.new(typ,
          self.each_expression.map do |e|
            e.match_type(typ.base)
        end)
    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.



2788
2789
2790
2791
2792
2793
2794
 
# File 'lib/HDLRuby/hruby_high.rb', line 2788

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 



2680
2681
2682
 
# File 'lib/HDLRuby/hruby_high.rb', line 2680

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

#output(name) ⇒ Object

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



2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
 
# File 'lib/HDLRuby/hruby_high.rb', line 2529

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.



2633
2634
2635
 
# File 'lib/HDLRuby/hruby_high.rb', line 2633

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

#rr(n) ⇒ Object

Right rotate of +n+ bits.



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

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.



2703
2704
2705
 
# File 'lib/HDLRuby/hruby_high.rb', line 2703

def rs(n)
    return self >> n
end

#sext(n) ⇒ Object

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



2643
2644
2645
 
# File 'lib/HDLRuby/hruby_high.rb', line 2643

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

#to_bit ⇒ Object

Casts to a bit vector type.



2613
2614
2615
 
# File 'lib/HDLRuby/hruby_high.rb', line 2613

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:



2594
2595
2596
 
# File 'lib/HDLRuby/hruby_high.rb', line 2594

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.



2618
2619
2620
 
# File 'lib/HDLRuby/hruby_high.rb', line 2618

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

#to_value ⇒ Object

Converts to a new value.

NOTE: to be redefined.

Raises:



2576
2577
2578
2579
 
# File 'lib/HDLRuby/hruby_high.rb', line 2576

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) 


2569
2570
2571
 
# File 'lib/HDLRuby/hruby_high.rb', line 2569

def to_value?
    return false
end

#zext(n) ⇒ Object

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



2638
2639
2640
 
# File 'lib/HDLRuby/hruby_high.rb', line 2638

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