Class: RubyHDL::High::Type

Inherits:
Object
  • Object
show all
Includes:
HDLRuby::Tprocess
Defined in:
lib/HDLRuby/std/sequencer_sw.rb

Overview

Describes a high-level data type.

NOTE: by default a type is not specified.

Direct Known Subclasses

TypeDef, TypeGen, TypeStruct, TypeTuple, TypeVector

Instance Method Summary collapse

Methods included from HDLRuby::Tprocess

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

Constructor Details

#initialize(name = nil) ⇒ Type

Creates a new type named name.



645
646
647
648
649
650
651
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 645

def initialize(name = nil)
  if name then
    @name = name.to_sym 
    # Registers the name.
    self.register(name)
  end
end

Instance Method Details

#[](rng) ⇒ Object

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



854
855
856
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 854

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

#base ⇒ Object

Gets the base type, by default base type is not defined.

Raises:



741
742
743
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 741

def base
  raise AnyError, "No base type for type #{self}"
end

#base? ⇒ Boolean

Tells if the type has a base.

Returns:

  • (Boolean) 


736
737
738
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 736

def base?
  return false
end

#binary(operator, expr0, expr1) ⇒ Object

Performs binary operation operator on expressions expr0 and expr1.



913
914
915
916
917
918
919
920
921
922
923
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 913

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 computation.
    expr0.to_value.send(operator,expr1)
  end
end

#comp_operator(op) ⇒ Object

Gets the computation method for operator.



894
895
896
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 894

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.



887
888
889
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 887

def constant(hsh)
  RubyHDL::High.top_sblock.make_constants(self,hsh)
end

#define_operator(operator, &ruby_block) ⇒ Object

Redefinition of operator.



926
927
928
929
930
931
932
933
934
935
936
937
938
939
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 926

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}"
    RubyHDL::High.top_sblock.sub(RubyHDL.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).



943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 943

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}"
    RubyHDL::High.top_sblock.sub(RubyHDL.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

#direction ⇒ Object

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



720
721
722
723
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 720

def direction
  # By default, little endian.
  return :little
end

#each_overload(&ruby_block) ⇒ Object

Interates over the overloaded operators.



961
962
963
964
965
966
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 961

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

#each_type_deep(&ruby_block) ⇒ Object Also known as: each_deep

Iterates over the types deeply if any.



775
776
777
778
779
780
781
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 775

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 that's all by default.
end

#eql?(obj) ⇒ Boolean

Comparison for hash: structural comparison.

Returns:

  • (Boolean) 


656
657
658
659
660
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 656

def eql?(obj)
  return false unless obj.is_a?(Type)
  return false unless @name.eql?(obj.name)
  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) 


769
770
771
772
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 769

def equivalent?(type)
  # By default, types are equivalent iff they have the same name.
  return (type.is_a?(Type) and self.name == type.name)
end

#fixed? ⇒ Boolean

Tells if the type is fixed point.

Returns:

  • (Boolean) 


678
679
680
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 678

def fixed?
  return false
end

#float? ⇒ Boolean

Tells if the type is floating point.

Returns:

  • (Boolean) 


683
684
685
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 683

def float?
  return false
end

#hash ⇒ Object

Hash function.



663
664
665
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 663

def hash
  return [@name].hash
end

#hierarchical? ⇒ Boolean

Tells if the type is hierarchical.

Returns:

  • (Boolean) 


761
762
763
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 761

def hierarchical?
  return self.base? || self.types?
end

#htype? ⇒ Boolean

Tells htype has been included.

Returns:

  • (Boolean) 


790
791
792
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 790

def htype?
  return true
end

#inner(*names) ⇒ Object

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



881
882
883
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 881

def inner(*names)
  RubyHDL::High.top_sblock.make_inners(self,*names)
end

#leaf? ⇒ Boolean

Tells if the type is a leaf.

Returns:

  • (Boolean) 


688
689
690
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 688

def leaf?
  return false
end

#left ⇒ Object

Gets the type as left value.

NOTE: used for asymetric types like TypeSystemI.



827
828
829
830
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 827

def left
  # By default self.
  self
end

#max ⇒ Object

Gets the type max value if any. Default: not defined.

Raises:



709
710
711
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 709

def max
  raise AnyError, "No max value for type #{self}"
end

#min ⇒ Object

Gets the type min value if any. Default: not defined.

Raises:



715
716
717
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 715

def min
  raise AnyError, "No min value for type #{self}"
end

#name=(name) ⇒ Object

Sets the name.

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



803
804
805
806
807
808
809
810
811
812
813
814
815
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 803

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

#range ⇒ Object

Gets the range of the type, by default range is not defined.

Raises:



731
732
733
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 731

def range
  raise AnyError, "No range for type #{self}"
end

#range? ⇒ Boolean

Tells if the type has a range.

Returns:

  • (Boolean) 


726
727
728
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 726

def range?
  return false
end

#register(name) ⇒ Object

Register the name of the type.



818
819
820
821
822
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 818

def register(name)
  # Sets the hdl-like access to the type.
  obj = self # For using the right self within the proc
  RubyHDL::High.top_sblock.register(name) { obj }
end

#regular? ⇒ Boolean

Tells if the type is regular (applies for tuples).

Returns:

  • (Boolean) 


751
752
753
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 751

def regular?
  return false
end

#right ⇒ Object

Gets the type as right value.

NOTE: used for asymetric types like TypeSystemI.



835
836
837
838
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 835

def right
  # By default self.
  self
end

#signed? ⇒ Boolean

Tells if the type signed.

Returns:

  • (Boolean) 


668
669
670
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 668

def signed?
  return false
end

#struct? ⇒ Boolean

Tells if the type has named sub types.

Returns:

  • (Boolean) 


756
757
758
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 756

def struct?
  return false
end

#to_c ⇒ Object

Convert to C code.



969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 969

def to_c
  case @name
  when :void
    return "void"
  when :bit, :unsigned
    return "unsigned"
  when :signed
    return "signed"
  when :float
    return "double"
  when :string
    return "char*"
  else
    return @name.to_s
  end
end

#to_c_init ⇒ Object

Convert to C initialization code.



987
988
989
990
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 987

def to_c_init
  # By default: 0
  return "0"
end

#to_type ⇒ Object

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



796
797
798
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 796

def to_type
  return self
end

#to_vector ⇒ Object

Converts to a bit vector.



785
786
787
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 785

def to_vector
  return TypeVector.new(:"", Bit, self.width-1..0)
end

#typedef(name) ⇒ Object

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



843
844
845
846
847
848
849
850
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 843

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

#types? ⇒ Boolean

Tells if the type has sub types.

Returns:

  • (Boolean) 


746
747
748
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 746

def types?
  return false
end

#unary(operator, expr) ⇒ Object

Performs unary operation operator on expression expr.



899
900
901
902
903
904
905
906
907
908
909
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 899

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 computation.
    expr.to_value.send(operator)
  end
end

#unsigned? ⇒ Boolean

Tells if the type is unsigned.

Returns:

  • (Boolean) 


673
674
675
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 673

def unsigned?
  return false
end

#vector? ⇒ Boolean

Tells if the type of of vector kind.

Returns:

  • (Boolean) 


693
694
695
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 693

def vector?
  return false
end

#width ⇒ Object

Gets the bitwidth of the type, by default 0. Bit, signed, unsigned and Float base have a width of 1.



699
700
701
702
703
704
705
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 699

def width
  if [:bit, :signed, :unsigned, :float ].include?(@name) then
    return 1
  else
    return 0
  end
end