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.



1133
1134
1135
1136
1137
1138
1139
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1133

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.



1128
1129
1130
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1128

def name
  @name
end

Instance Method Details

#[](rng) ⇒ Object

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



1342
1343
1344
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1342

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

#base ⇒ Object

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



1229
1230
1231
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1229

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

#base? ⇒ Boolean

Tells if the type has a base.

Returns:

  • (Boolean) 


1224
1225
1226
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1224

def base?
  return false
end

#binary(operator, expr0, expr1) ⇒ Object

Performs binary operation operator on expressions expr0 and expr1.



1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1401

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.



1382
1383
1384
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1382

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.



1375
1376
1377
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1375

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

#define_operator(operator, &ruby_block) ⇒ Object

Redefinition of operator.



1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1414

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



1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1431

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.



1208
1209
1210
1211
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1208

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

#each_overload(&ruby_block) ⇒ Object

Interates over the overloaded operators.



1449
1450
1451
1452
1453
1454
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1449

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.



1263
1264
1265
1266
1267
1268
1269
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1263

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) 


1144
1145
1146
1147
1148
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1144

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) 


1257
1258
1259
1260
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1257

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) 


1166
1167
1168
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1166

def fixed?
  return false
end

#float? ⇒ Boolean

Tells if the type is floating point.

Returns:

  • (Boolean) 


1171
1172
1173
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1171

def float?
  return false
end

#hash ⇒ Object

Hash function.



1151
1152
1153
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1151

def hash
  return [@name].hash
end

#hierarchical? ⇒ Boolean

Tells if the type is hierarchical.

Returns:

  • (Boolean) 


1249
1250
1251
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1249

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

#htype? ⇒ Boolean

Tells htype has been included.

Returns:

  • (Boolean) 


1278
1279
1280
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1278

def htype?
  return true
end

#inner(*names) ⇒ Object

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



1369
1370
1371
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1369

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.



1349
1350
1351
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1349

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

#leaf? ⇒ Boolean

Tells if the type is a leaf.

Returns:

  • (Boolean) 


1176
1177
1178
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1176

def leaf?
  return false
end

#left ⇒ Object

Gets the type as left value.

NOTE: used for asymetric types like TypeSystemI.



1315
1316
1317
1318
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1315

def left
  # By default self.
  self
end

#max ⇒ Object

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



1197
1198
1199
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1197

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

#min ⇒ Object

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



1203
1204
1205
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1203

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.



1355
1356
1357
1358
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1355

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.



1219
1220
1221
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1219

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

#range? ⇒ Boolean

Tells if the type has a range.

Returns:

  • (Boolean) 


1214
1215
1216
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1214

def range?
  return false
end

#register(name) ⇒ Object

Register the name of the type.



1306
1307
1308
1309
1310
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1306

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) 


1239
1240
1241
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1239

def regular?
  return false
end

#right ⇒ Object

Gets the type as right value.

NOTE: used for asymetric types like TypeSystemI.



1323
1324
1325
1326
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1323

def right
  # By default self.
  self
end

#signed? ⇒ Boolean

Tells if the type signed.

Returns:

  • (Boolean) 


1156
1157
1158
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1156

def signed?
  return false
end

#struct? ⇒ Boolean

Tells if the type has named sub types.

Returns:

  • (Boolean) 


1244
1245
1246
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1244

def struct?
  return false
end

#to_c ⇒ Object

Convert to C code.



1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1457

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.



1475
1476
1477
1478
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1475

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

#to_python_init ⇒ Object

Convert to Python initialization code.



1481
1482
1483
1484
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1481

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

#to_tf_init ⇒ Object

Convert to tensorflow initialization code.



1487
1488
1489
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1487

def to_tf_init
  return "tf.constant(0)"
end

#to_type ⇒ Object

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



1284
1285
1286
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1284

def to_type
  return self
end

#to_vector ⇒ Object

Converts to a bit vector.



1273
1274
1275
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1273

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.



1331
1332
1333
1334
1335
1336
1337
1338
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1331

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) 


1234
1235
1236
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1234

def types?
  return false
end

#unary(operator, expr) ⇒ Object

Performs unary operation operator on expression expr.



1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1387

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) 


1161
1162
1163
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1161

def unsigned?
  return false
end

#vector? ⇒ Boolean

Tells if the type of of vector kind.

Returns:

  • (Boolean) 


1181
1182
1183
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1181

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.



1187
1188
1189
1190
1191
1192
1193
 
# File 'lib/HDLRuby/std/sequencer_sw.rb', line 1187

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