An operation used to create
anonymous, variable objects accessible by means of access values.
Each time an allocator is
evaluated, a new object is created and the object is designated
(pointed) by an access value (pointer). The type of the object
created by an allocator is defined either by a subtype indication
(example 1 and 2) or a qualified expression (example 3 and 4).
In case of allocators with a subtype indication, the initial value of
the created object is the same as the default initial value of a
directly declared variable of the same subtype (example 1 and 2).
When qualified expression is used, the initial value is defined by
the expression itself (example 3 and 4).
If an allocator creates an object of the array type, then the array
must be constrained. This can be achieved through using a constrained
subtype or specified in the subtype indication with an explicit index
constraint (example 2).
Copying a value of a variable with allocated object to other variable
does not create new object. Instead, both variables point to the same
object (example 5).
See also access type.
type Table is
array (1 to 8) of Natural;
type TableAccess is access Table;
variable y : TableAccess;
y := new Table; -- will be
-- (0, 0, 0, 0, 0, 0, 0, 0)
The allocator (note that the allocator is of the access type) creates
a new object of the Table type, which is initialized to a default
value, equal in this case to (0, 0, 0, 0, 0, 0, 0, 0).
z:= new BIT_VECTOR(1 to 3);
This allocator creates a new object of the BIT_VECTOR type,
consisting of three elements. The default initial value of this
object is equal to ('0','0','0'). Note that the subtype indication is
constrained as the BIT_VECTOR type is unconstrained.
type test_record is record
: Bit_Vector (0 to 3);
end record test_record;
type AccTR is
variable x,z : AccTR;
x := new test_record'(30 ns,
B"1100"); -- record allocation with aggregate
z := new test_record;
z.test_time := 30 ns;
z.test_value := B"1100";
Initial values can be assigned to an object (in this case a record)
created by an allocator both using a qualified expression (in this
case with an aggregate - allocator for x) or using a subtype
indication and later on direct assignments (allocator for z). In both
cases above the objects created will be identical (although it will
not be the same object).
type AccBV is access
Bit_Vector(7 downto 0);
variable Ptr1, Ptr2 : AccBV;
Ptr1 := new Bit_Vector(7 downto 0);
Ptr2 := Ptr1;
There is no allocator assigned to Ptr2, thus no new object will be
created for it. Instead it will point to the same object, which was
created for Ptr1.
For each access type an implicitly declared procedure Deallocate is
defined. The procedure reverses the evaluation of an allocator, i.e.
releases the storage occupied by an object created by an allocator.
Allocators (and access types) are not synthesizable.
A subtype indication in allocator must not include a resolution function.
An object created by an allocator has not its own name (indicator).
Instead, it is referred to through the name, which it was allocated to.
The concept of access types and allocators is very much the same as
the concept of pointers in software programming languages.