Contents Index Previous Next
3.6 Array Types
1
An
array
object is a composite object consisting of components which all have
the same subtype. The name for a component of an array uses one or more
index values belonging to specified discrete types. The value of an array
object is a composite value consisting of the values of the components.
Syntax
2
array_type_definition
::=
unconstrained_array_definition |
constrained_array_definition
3
unconstrained_array_definition
::=
array(
index_subtype_definition {,
index_subtype_definition})
of component_definition
4
index_subtype_definition
::= subtype_mark range <>
5
constrained_array_definition
::=
array (
discrete_subtype_definition {,
discrete_subtype_definition})
of component_definition
6
discrete_subtype_definition
::= discrete_subtype_indication |
range
7
component_definition
::= [
aliased]
subtype_indication
Name Resolution Rules
8
For a
discrete_subtype_definition
that is a
range, the
range
shall resolve to be of some specific discrete type[; which discrete type
shall be determined without using any context other than the bounds of
the
range itself (plus the preference
for
root_integer -- see
8.6).]
Legality Rules
9
Each
index_subtype_definition
or
discrete_subtype_definition in
an
array_type_definition defines
an
index subtype;
its type (the
index type)
shall be discrete.
9.a
Discussion: An
index is a discrete quantity used to select along a given dimension
of an array. A component is selected by specifying corresponding values
for each of the indices.
10
The subtype defined by the
subtype_indication of a
component_definition
(the
component subtype) shall be a definite subtype.
10.a
Ramification: This applies
to all uses of component_definition,
including in record_type_definitions
and protected_definitions.
11
Within the definition of a nonlimited composite
type (or a limited composite type that later in its immediate scope becomes
nonlimited -- see
7.3.1 and
7.5),
if a
component_definition contains
the reserved word
aliased and the type of the component is discriminated,
then the nominal subtype of the component shall be constrained.
11.a
Reason: If we allowed the
subtype to be unconstrained, then the discriminants might change because
of an assignment to the containing (nonlimited) object, thus causing
a potential violation of an access subtype constraint of an access value
designating the aliased component.
11.b
Note that the rule elsewhere defining
all aliased discriminated objects to be constrained does not help --
that rule prevents assignments to the component itself from doing any
harm, but not assignments to the containing object.
11.c
We
allow this for components within limited types since assignment to the
enclosing object is not a problem. Furthermore, it is important to be
able to use a default expression for a discriminant in arrays of limited
components, since that is the only way to give the components different
values for their discriminants. For example:
11.d
protected type Counter_Type(Initial_Value : Integer := 1) is
procedure Get_Next(Next_Value : out Integer);
-- Returns the next value on each call, bumping Count
-- before returning.
private
Count : Integer := Initial_Value;
end Counter_Type;
protected body Counter_Type is ...
11.e
function Next_Id(Counter : access Counter_Type) return Integer is
Result : Integer;
begin
Counter.Get_Next(Result);
return Result;
end Next_Id;
11.f
C : aliased Counter_Type;
task type T(Who_Am_I : Integer := Next_Id(C'Access));
task body T is ...
11.g
Task_Array : array(1..100) of aliased T;
-- Array of task elements, each with its own unique ID.
-- We specify "aliased" so we can use Task_Array(I)'Access.
-- This is safe because Task_Array is of a limited type,
-- so there is no way an assignment to it could change
-- the discriminants of one of its components.
11.h
Ramification: Note that
this rule applies to array components and record components, but not
to protected type components (since they are always limited).
Static Semantics
12
An
array is characterized by the number of indices (the
dimensionality
of the array), the type and position of each index, the lower and upper
bounds for each index, and the subtype of the components. The order of
the indices is significant.
13
A one-dimensional array has a distinct component
for each possible index value. A multidimensional array has a distinct
component for each possible sequence of index values that can be formed
by selecting one value for each index position (in the given order).
The possible values for a given index are all the values between the
lower and upper bounds, inclusive;
this range of
values is called the
index range.
The
bounds
of an array are the bounds of its index ranges.
The
length of a dimension of an array is the number of values of the
index range of the dimension (zero for a null range).
The
length of a one-dimensional array is the length of its only dimension.
14
An
array_type_definition
defines an array type and its first subtype. For each object of this
array type, the number of indices, the type and position of each index,
and the subtype of the components are as in the type definition[; the
values of the lower and upper bounds for each index belong to the corresponding
index subtype of its type, except for null arrays (see
3.6.1)].
15
An
unconstrained_array_definition
defines an array type with an unconstrained first subtype. Each
index_subtype_definition
defines the corresponding index subtype to be the subtype denoted by
the
subtype_mark. [
The compound delimiter <> (called a
box) of an
index_subtype_definition
stands for an undefined range (different objects of the type need not
have the same bounds).]
16
A
constrained_array_definition
defines an array type with a constrained first subtype. Each
discrete_subtype_definition
defines the corresponding index subtype, as well as the corresponding
index range for the constrained first subtype.
The
constraint of the first subtype consists of the bounds of the
index ranges.
16.a
Discussion: Although there
is no namable unconstrained array subtype in this case, the predefined
slicing and concatenation operations can operate on and yield values
that do not necessarily belong to the first array subtype. This is also
true for Ada 83.
17
The discrete subtype
defined by a discrete_subtype_definition
is either that defined by the subtype_indication,
or a subtype determined by the range
as follows:
18
- If the type of the range
resolves to root_integer, then the discrete_subtype_definition
defines a subtype of the predefined type Integer with bounds given by
a conversion to Integer of the bounds of the range;
18.a
Reason: This ensures that
indexing over the discrete subtype can be performed with regular Integers,
rather than only universal_integers.
18.b
Discussion: We considered
doing this by simply creating a ``preference'' for Integer when resolving
the range. However,
this can introduce Beaujolais effects when the simple_expressions
involve calls on functions visible due to use clauses.
19
- Otherwise, the discrete_subtype_definition
defines a subtype of the type of the range,
with the bounds given by the range.
20
The
component_definition
of an
array_type_definition defines
the nominal subtype of the components. If the reserved word
aliased
appears in the
component_definition,
then each component of the array is aliased (see
3.10).
20.a
Ramification: In this case,
the nominal subtype cannot be an unconstrained discriminated subtype.
See 3.8.
Dynamic Semantics
21
The elaboration of an
array_type_definition
creates the array type and its first subtype, and consists of the elaboration
of any
discrete_subtype_definitions
and the
component_definition.
22/1
{
8652/0002}
The elaboration of a
discrete_subtype_definition
that does not contain any per-object expressions creates the discrete
subtype, and consists of the elaboration of the
subtype_indication
or the evaluation of the
range.
The elaboration of a discrete_subtype_definition
that contains one or more per-object expressions is defined in 3.8.
The elaboration of a
component_definition
in an
array_type_definition consists
of the elaboration of the
subtype_indication.
The elaboration of any
discrete_subtype_definitions
and the elaboration of the
component_definition
are performed in an arbitrary order.
23
41 All components of an array
have the same subtype. In particular, for an array of components that
are one-dimensional arrays, this means that all components have the same
bounds and hence the same length.
24
42 Each elaboration of an
array_type_definition creates a
distinct array type. A consequence of this is that each object whose
object_declaration contains an array_type_definition
is of its own unique type.
Examples
25
Examples of
type declarations with unconstrained array definitions:
26
type Vector is array(Integer range <>) of Real;
type Matrix is array(Integer range <>, Integer range <>) of Real;
type Bit_Vector is array(Integer range <>) of Boolean;
type Roman is array(Positive range <>) of Roman_Digit; -- see 3.5.2
27
Examples of type
declarations with constrained array definitions:
28
type Table is array(1 .. 10) of Integer;
type Schedule is array(Day) of Boolean;
type Line is array(1 .. Max_Line_Size) of Character;
29
Examples of object
declarations with array type definitions:
30
Grid : array(1 .. 80, 1 .. 100) of Boolean;
Mix : array(Color range Red .. Green) of Boolean;
Page : array(Positive range <>) of Line := -- an array of arrays
(1 | 50 => Line'(1 | Line'Last => '+', others => '-'), -- see 4.3.3
2 .. 49 => Line'(1 | Line'Last => '|', others => ' '));
-- Page is constrained by its initial value to (1..50)
Extensions to Ada 83
30.a
The syntax
rule for component_definition is
modified to allow the reserved word aliased.
30.b
The syntax rules for unconstrained_array_definition
and constrained_array_definition
are modified to use component_definition
(instead of component_subtype_indication).
The effect of this change is to allow the reserved word aliased
before the component subtype_indication.
30.c
A range
in a discrete_subtype_definition
may use arbitrary universal expressions for each bound (e.g. -1 .. 3+5),
rather than strictly "implicitly convertible" operands. The
subtype defined will still be a subtype of Integer.
Wording Changes from Ada 83
30.d
We introduce a new syntactic category,
discrete_subtype_definition, as
distinct from discrete_range. These
two constructs have the same syntax, but their semantics are quite different
(one defines a subtype, with a preference for Integer subtypes, while
the other just selects a subrange of an existing subtype). We use this
new syntactic category in for loops and entry families.
30.e
The syntax for index_constraint
and discrete_range have been moved
to their own subclause, since they are no longer used here.
30.f
The syntax rule for component_definition
(formerly component_subtype_definition)
is moved here from RM83-3.7.
Contents Index Previous Next Legal