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 Attribute Summary collapse

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.



715
716
717
718
719
720
721
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 715

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

Instance Attribute Details

#name ⇒ Object

Returns the value of attribute name.



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

def name
  @name
end

Instance Method Details

#[](rng) ⇒ Object

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



924
925
926
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 924

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

#base ⇒ Object

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



811
812
813
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 811

def base
  raise "No base type for type #{self} (#{self.name})"
end

#base? ⇒ Boolean

Tells if the type has a base.

Returns:

  • (Boolean) 


806
807
808
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 806

def base?
  return false
end

#binary(operator, expr0, expr1) ⇒ Object

Performs binary operation operator on expressions expr0 and expr1.



983
984
985
986
987
988
989
990
991
992
993
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 983

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.



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

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.



957
958
959
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 957

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

#define_operator(operator, &ruby_block) ⇒ Object

Redefinition of operator.



996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 996

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



1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1013

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.



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

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

#each_overload(&ruby_block) ⇒ Object

Interates over the overloaded operators.



1031
1032
1033
1034
1035
1036
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1031

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.



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

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) 


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

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) 


839
840
841
842
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 839

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) 


748
749
750
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 748

def fixed?
  return false
end

#float? ⇒ Boolean

Tells if the type is floating point.

Returns:

  • (Boolean) 


753
754
755
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 753

def float?
  return false
end

#hash ⇒ Object

Hash function.



733
734
735
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 733

def hash
  return [@name].hash
end

#hierarchical? ⇒ Boolean

Tells if the type is hierarchical.

Returns:

  • (Boolean) 


831
832
833
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 831

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

#htype? ⇒ Boolean

Tells htype has been included.

Returns:

  • (Boolean) 


860
861
862
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 860

def htype?
  return true
end

#inner(*names) ⇒ Object

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



951
952
953
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 951

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

#input(*names) ⇒ Object

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



931
932
933
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 931

def input(*names)
  RubyHDL::High.top_sblock.make_inputs(self,*names)
end

#leaf? ⇒ Boolean

Tells if the type is a leaf.

Returns:

  • (Boolean) 


758
759
760
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 758

def leaf?
  return false
end

#left ⇒ Object

Gets the type as left value.

NOTE: used for asymetric types like TypeSystemI.



897
898
899
900
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 897

def left
  # By default self.
  self
end

#max ⇒ Object

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



779
780
781
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 779

def max
  raise "No max value for type #{self} (#{self.name})"
end

#min ⇒ Object

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



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

def min
  raise "No min value for type #{self} (#{self.name})"
end

#output(*names) ⇒ Object

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



937
938
939
940
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 937

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

#range ⇒ Object

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



801
802
803
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 801

def range
  raise "No range for type #{self} (#{self.name})"
end

#range? ⇒ Boolean

Tells if the type has a range.

Returns:

  • (Boolean) 


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

def range?
  return false
end

#register(name) ⇒ Object

Register the name of the type.



888
889
890
891
892
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 888

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) 


821
822
823
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 821

def regular?
  return false
end

#right ⇒ Object

Gets the type as right value.

NOTE: used for asymetric types like TypeSystemI.



905
906
907
908
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 905

def right
  # By default self.
  self
end

#signed? ⇒ Boolean

Tells if the type signed.

Returns:

  • (Boolean) 


738
739
740
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 738

def signed?
  return false
end

#struct? ⇒ Boolean

Tells if the type has named sub types.

Returns:

  • (Boolean) 


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

def struct?
  return false
end

#to_c ⇒ Object

Convert to C code.



1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1039

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.



1057
1058
1059
1060
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1057

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.



866
867
868
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 866

def to_type
  return self
end

#to_vector ⇒ Object

Converts to a bit vector.



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

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.



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

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) 


816
817
818
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 816

def types?
  return false
end

#unary(operator, expr) ⇒ Object

Performs unary operation operator on expression expr.



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

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) 


743
744
745
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 743

def unsigned?
  return false
end

#vector? ⇒ Boolean

Tells if the type of of vector kind.

Returns:

  • (Boolean) 


763
764
765
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 763

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.



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

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