Contents Index Search Previous Next
4.3.3 Array Aggregates
1
[In an array_aggregate,
a value is specified for each component of an array, either positionally
or by its index.] For a positional_array_aggregate,
the components are given in increasing-index order, with a final others,
if any, representing any remaining components. For a named_array_aggregate,
the components are identified by the values covered by the discrete_choices.
Language Design Principles
1.a/1
The rules in this subclause
are based on terms and rules for discrete_choice_lists
defined in 3.8.1, ``Variant
Parts and Discrete Choices''. For example, the requirements that
others come last and stand alone are found there.
Syntax
2
array_aggregate
::=
positional_array_aggregate |
named_array_aggregate
3
positional_array_aggregate
::=
(
expression,
expression {,
expression})
| (
expression {,
expression},
others =>
expression)
4
named_array_aggregate
::=
(
array_component_association {,
array_component_association})
5
array_component_association
::=
discrete_choice_list =>
expression
6
{n-dimensional array_aggregate}
An
n-dimensional array_aggregate
is one that is written as n levels of nested
array_aggregates
(or at the bottom level, equivalent
string_literals).
{subaggregate (of an array_aggregate)}
For the multidimensional case (n >= 2) the
array_aggregates
(or equivalent
string_literals)
at the n-1 lower levels are called
subaggregates of the enclosing
n-dimensional
array_aggregate.
{array
component expression} The
expressions
of the bottom level subaggregates (or of the
array_aggregate
itself if one-dimensional) are called the
array component expressions
of the enclosing n-dimensional
array_aggregate.
6.a
Ramification: Subaggregates
do not have a type. They correspond to part of an array. For example,
with a matrix, a subaggregate would correspond to a single row of the
matrix. The definition of "n-dimensional" array_aggregate
applies to subaggregates as well as aggregates
that have a type.
6.b
To be honest: {others
choice} An others choice is the
reserved word others as it appears in a positional_array_aggregate
or as the discrete_choice of the
discrete_choice_list in an array_component_association.
Name Resolution Rules
7
{expected type (array_aggregate)
[partial]} The expected type for an
array_aggregate
(that is not a subaggregate) shall be a single nonlimited array type.
{expected type (array_aggregate component expression)
[partial]} The component type of this array
type is the expected type for each array component expression of the
array_aggregate.
7.a
Ramification: We already
require a single array or record type or record extension for an aggregate.
The above rule requiring a single nonlimited array type (and similar
ones for record and extension aggregates) resolves which kind of aggregate
you have.
8
{expected type (array_aggregate
discrete_choice) [partial]} The expected
type for each
discrete_choice in
any
discrete_choice_list of a
named_array_aggregate
is the type of the
corresponding index;
{corresponding
index (for an array_aggregate)} the corresponding
index for an
array_aggregate that
is not a subaggregate is the first index of its type; for an (n-m)-dimensional
subaggregate within an
array_aggregate
of an n-dimensional type, the corresponding index is the index in position
m+1.
Legality Rules
9
An array_aggregate
of an n-dimensional array type shall be written as an n-dimensional array_aggregate.
9.a
Ramification: In an m-dimensional
array_aggregate [(including a subaggregate)],
where m >= 2, each of the expressions
has to be an (m-1)-dimensional subaggregate.
10
An
others
choice is allowed for an
array_aggregate
only if an
applicable index constraint applies to the
array_aggregate.
{applicable index constraint} [An
applicable index constraint is a constraint provided by certain contexts
where an
array_aggregate is permitted
that can be used to determine the bounds of the array value specified
by the aggregate.] Each of the following contexts (and none other) defines
an applicable index constraint:
11
- For an explicit_actual_parameter,
an explicit_generic_actual_parameter,
the expression of a return_statement,
the initialization expression in an object_declaration,
or a default_expression [(for a
parameter or a component)], when the nominal subtype of the corresponding
formal parameter, generic formal parameter, function result, object,
or component is a constrained array subtype, the applicable index constraint
is the constraint of the subtype;
12
- For the expression
of an assignment_statement where
the name denotes an array variable,
the applicable index constraint is the constraint of the array variable;
12.a
Reason: This case is
broken out because the constraint comes from the actual subtype of the
variable (which is always constrained) rather than its nominal subtype
(which might be unconstrained).
13
- For the operand of a qualified_expression
whose subtype_mark denotes a constrained
array subtype, the applicable index constraint is the constraint of the
subtype;
14
- For a component expression
in an aggregate, if the component's
nominal subtype is a constrained array subtype, the applicable index
constraint is the constraint of the subtype;
14.a
Discussion: Here, the
array_aggregate with others
is being used within a larger aggregate.
15
- For a parenthesized expression,
the applicable index constraint is that, if any, defined for the expression.
15.a
Discussion: RM83 omitted
this case, presumably as an oversight. We want to minimize situations
where an expression becomes illegal
if parenthesized.
16
The applicable index constraint applies
to an array_aggregate that appears
in such a context, as well as to any subaggregates thereof. In the case
of an explicit_actual_parameter
(or default_expression) for a call
on a generic formal subprogram, no applicable index constraint is defined.
16.a
Reason: This avoids generic
contract model problems, because only mode conformance is required when
matching actual subprograms with generic formal subprograms.
17
The discrete_choice_list
of an array_component_association
is allowed to have a discrete_choice
that is a nonstatic expression or
that is a discrete_range that defines
a nonstatic or null range, only if it is the single discrete_choice
of its discrete_choice_list, and
there is only one array_component_association
in the array_aggregate.
17.a
Discussion: We now allow
a nonstatic others choice even if there are other array component
expressions as well.
18
In a
named_array_aggregate
with more than one
discrete_choice,
no two
discrete_choices are allowed
to cover the same value (see
3.8.1); if there
is no
others choice, the
discrete_choices
taken together shall exactly cover a contiguous sequence of values of
the corresponding index type.
18.a
Ramification: This implies
that each component must be specified exactly once. See AI83-309.
19
A bottom level subaggregate of a multidimensional
array_aggregate of a given array
type is allowed to be a string_literal
only if the component type of the array type is a character type; each
character of such a string_literal
shall correspond to a defining_character_literal
of the component type.
Static Semantics
20
A subaggregate that is a string_literal
is equivalent to one that is a positional_array_aggregate
of the same length, with each expression
being the character_literal for
the corresponding character of the string_literal.
Dynamic Semantics
21
{evaluation
(array_aggregate) [partial]} The evaluation
of an
array_aggregate of a given
array type proceeds in two steps:
22
- 1.
-
Any discrete_choices of this aggregate
and of its subaggregates are evaluated in an arbitrary order, and converted
to the corresponding index type; {implicit subtype
conversion (choices of aggregate) [partial]}
23
- 2.
-
The array component expressions of the aggregate are evaluated in an
arbitrary order and their values are converted to the component subtype
of the array type; an array component expression is evaluated once for
each associated component. {implicit subtype conversion
(expressions of aggregate) [partial]}
23.a
Ramification: Subaggregates
are not separately evaluated. The conversion of the value of the component
expressions to the component subtype might raise Constraint_Error.
24
{bounds
(of the index range of an array_aggregate)} The
bounds of the index range of an
array_aggregate
[(including a subaggregate)] are determined as follows:
25
- For an array_aggregate
with an others choice, the bounds are those of the corresponding
index range from the applicable index constraint;
26
- For a positional_array_aggregate
[(or equivalent string_literal)]
without an others choice, the lower bound is that of the corresponding
index range in the applicable index constraint, if defined, or that of
the corresponding index subtype, if not; in either case, the upper bound
is determined from the lower bound and the number of expressions
[(or the length of the string_literal)];
27
- For a named_array_aggregate
without an others choice, the bounds are determined by the smallest
and largest index values covered by any discrete_choice_list.
27.a
Reason: We don't need
to say that each index value has to be covered exactly once, since that
is a ramification of the general rule on aggregates
that each component's value has to be specified exactly once.
28
{Range_Check [partial]}
{check, language-defined (Range_Check)}
For an
array_aggregate,
a check is made that the index range defined by its bounds is compatible
with the corresponding index subtype.
28.a
Discussion: In RM83,
this was phrased more explicitly, but once we define "compatibility"
between a range and a subtype, it seems to make sense to take advantage
of that definition.
28.b
Ramification: The definition
of compatibility handles the special case of a null range, which is always
compatible with a subtype. See AI83-00313.
29
{Index_Check [partial]}
{check, language-defined (Index_Check)}
For an
array_aggregate
with an
others choice, a check is made that no
expression
is specified for an index value outside the bounds determined by the
applicable index constraint.
29.a
Discussion: RM83 omitted
this case, apparently through an oversight. AI83-00309 defines this as
a dynamic check, even though other Ada 83 rules ensured that this check
could be performed statically. We now allow an others choice to
be dynamic, even if it is not the only choice, so this check now needs
to be dynamic, in some cases. Also, within a generic unit, this would
be a nonstatic check in some cases.
30
{Index_Check [partial]}
{check, language-defined (Index_Check)}
For a multidimensional
array_aggregate,
a check is made that all subaggregates that correspond to the same index
have the same bounds.
30.a
Ramification: No array
bounds ``sliding'' is performed on subaggregates.
30.b
Reason: If sliding were
performed, it would not be obvious which subaggregate would determine
the bounds of the corresponding index.
31
{Constraint_Error (raised
by failure of run-time check)} The exception
Constraint_Error is raised if any of the above checks fail.
32
10 In an array_aggregate,
positional notation may only be used with two or more expressions;
a single expression in parentheses
is interpreted as a parenthesized_expression.
A named_array_aggregate, such as
(1 => X), may be used to specify an array with a single component.
Examples
33
Examples of
array aggregates with positional associations:
34
(7, 9, 5, 1, 3, 2, 4, 8, 6, 0)
Table'(5, 8, 4, 1, others => 0) -- see 3.6
35
Examples of array
aggregates with named associations:
36
(1 .. 5 => (1 .. 8 => 0.0)) -- two-dimensional
(1 .. N => new Cell) -- N new cells, in particular for N = 0
37
Table'(2 | 4 | 10 => 1, others => 0)
Schedule'(Mon .. Fri => True, others => False) -- see 3.6
Schedule'(Wed | Sun => False, others => True)
Vector'(1 => 2.5) -- single-component vector
38
Examples of two-dimensional
array aggregates:
39
-- Three aggregates for the same value of subtype Matrix(1..2,1..3) (see 3.6):
40
((1.1, 1.2, 1.3), (2.1, 2.2, 2.3))
(1 => (1.1, 1.2, 1.3), 2 => (2.1, 2.2, 2.3))
(1 => (1 => 1.1, 2 => 1.2, 3 => 1.3), 2 => (1 => 2.1, 2 => 2.2, 3 => 2.3))
41
Examples of aggregates
as initial values:
42
A : Table := (7, 9, 5, 1, 3, 2, 4, 8, 6, 0); -- A(1)=7, A(10)=0
B : Table := (2 | 4 | 10 => 1, others => 0); -- B(1)=0, B(10)=1
C : constant Matrix := (1 .. 5 => (1 .. 8 => 0.0)); -- C'Last(1)=5, C'Last(2)=8
43
D : Bit_Vector(M .. N) := (M .. N => True); -- see 3.6
E : Bit_Vector(M .. N) := (others => True);
F : String(1 .. 1) := (1 => 'F'); -- a one component aggregate: same as "F"
Incompatibilities With Ada 83
43.a.1/1
{incompatibilities with
Ada 83} In Ada 95, no applicable index constraint
is defined for a parameter in a call to a generic formal subprogram;
thus, some aggregates that are legal in Ada 83 are illegal in Ada 95.
For example:
43.a.2/1
subtype S3 is String (1 .. 3);
...
generic
with function F (The_S3 : in S3) return Integer;
package Gp is
I : constant Integer := F ((1 => '!', others => '?'));
-- The aggregate is legal in Ada 83, illegal in Ada 95.
end Gp;
43.a.3/1
This change eliminates generic
contract model problems.
Extensions to Ada 83
43.a
{extensions to Ada 83}
We now allow "named with others" aggregates
in all contexts where there is an applicable index constraint, effectively
eliminating what was RM83-4.3.2(6). Sliding never occurs on an aggregate
with others, because its bounds come from the applicable index constraint,
and therefore already match the bounds of the target.
43.b
The legality of an others
choice is no longer affected by the staticness of the applicable index
constraint. This substantially simplifies several rules, while being
slightly more flexible for the user. It obviates the rulings of AI83-00244
and AI83-00310, while taking advantage of the dynamic nature of the "extra
values" check required by AI83-00309.
43.c
Named array aggregates are permitted
even if the index type is descended from a formal scalar type. See 4.9
and AI83-00190.
Wording Changes from Ada 83
43.d
We now separate named and positional
array aggregate syntax, since, unlike other aggregates, named and positional
associations cannot be mixed in array aggregates (except that an others
choice is allowed in a positional array aggregate).
43.e
We have also reorganized the
presentation to handle multidimensional and one-dimensional aggregates
more uniformly, and to incorporate the rulings of AI83-00019, AI83-00309,
etc.
Contents Index Search Previous Next Legal