Contents Index Search Previous Next

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.

2

3

positional_array_aggregate
::=

(expression, expression {, expression})

| (expression {, expression},**others** => expression)

(expression, expression {, expression})

| (expression {, expression},

4

5

6

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).
For the multidimensional case (n >= 2) the array_aggregates
(or equivalent string_literals)
at the n-1 lower levels are called *subaggregate*s of the enclosing
n-dimensional array_aggregate. 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.

7

The expected type for an array_aggregate
(that is not a subaggregate) shall be a single nonlimited array type.
The component type of this array type is the expected
type for each array component expression of the array_aggregate.

8

The expected type for each
discrete_choice in any discrete_choice_list
of a named_array_aggregate is the
type of the *corresponding index*; 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.

9

An array_aggregate
of an n-dimensional array type shall be written as an n-dimensional array_aggregate.

10

An **others**
choice is allowed for an array_aggregate
only if an *applicable index constraint* applies to the array_aggregate.
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;

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;

15

- For a parenthesized expression, the applicable index constraint is that, if any, defined for the expression.

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.

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.

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.

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.

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.

21

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;

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.

24

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.

28

For an
array_aggregate, a check is made
that the index range defined by its bounds is compatible with the corresponding
index subtype.

29

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.

30

For a
multidimensional array_aggregate,
a check is made that all subaggregates that correspond to the same index
have the same bounds.

31

NOTES

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.

33

34

Table'(5, 8, 4, 1,

35

36

(1 .. N =>

37

Schedule'(Mon .. Fri => True,

Schedule'(Wed | Sun => False,

Vector'(1 => 2.5)

38

39

40

(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

42

B : Table := (2 | 4 | 10 => 1,

C :

43

E : Bit_Vector(M .. N) := (

F : String(1 .. 1) := (1 => 'F');