|
|
|
|
|
A composite type whose values consist of named elements.
type record_type_name is record
element_name : element type;
element_name : element type;
. . .
end record record_type_name;
The record type allows declaring composite objects whose elements can be of different types. This is the main difference from arrays, which must have all elements of the same type. All elements are declared with individual names together with subtype indication. If two or more elements are of the same subtype they can be declared together (Example 1). The names of elements in each record must be distinct. The same element name, however, can be used in different records.
The value of an object of type record is a composite value, consisting of the values of its elements. The assignment of a value to an object of the type record can be realized either through an aggregate or through individual assignments to elements (selected names).
Aggregate-based assignment to a record, either positional or named association, can be used (Example 2). If the positional association is used, it is assumed that the elements are listed in the order defined in the record declaration. If the others choice is used, it must represent at least one element. If there are two or more elements assigned by the others choice, then all these elements have to be of the same type.
When individual assignment to elements are used then each element id referenced by the record object name followed by a dot and element's name (example 3).
Expression assigned to an element of a record must result in a value of the same type as the element.
Example 1
type RegName is
(AX, BX, CX, DX);
type Operation is record
Mnemonic : String (1 to 10);
OpCode : Bit_Vector(3 downto 0);
Op1, Op2, Res : RegName;
end record;
The record type defined above represents an information from an
instruction list of a processor. There are five elements here:
mnemonic code (a string), operation code (four bit), two operands and
the destination. Note that the last three elements are declared
together as they are of the same type.
Example 2
-- type declarations are given in Example 1
variable Instr1, Instr2: Operation;
. . .
Instr1:= ("ADD AX, BX", "0001", AX, BX, AX);
Instr2:= ("ADD AX, BX", "0010", others
=> BX);
Here, the two assignments to variables of the record type (Operation)
are performed with aggregates. Note the way the choice others was
used in the second example.
Example 3
-- type declarations are given in Example 1
variable Instr3 : Operation;
. . .
Instr3.Mnemonic := "MUL AX, BX";
Instr3.Op1 := AX;
In this case direct assignments to individual elements of a record
object are performed. Note the way an element is referenced: record
name, dot, and element name.
Linear records (i.e. record, where elements are of not of composite type) are generally synthesizable.
Files are not allowed as elements of records.
|
|
|
|
|