Annotated Ada Reference Manual — Legal Information

5.5 Loop Statements

[A loop_statement includes a sequence_of_statements that is to be executed repeatedly, zero or more times.]

Syntax

loop_statement ::=
   [loop_statement_identifier:]
      [iteration_scheme] loop
         sequence_of_statements
       end loop [loop_identifier];

3/3

{AI05-0139-2} iteration_scheme ::= while condition
| for loop_parameter_specification
| for iterator_specification

loop_parameter_specification ::=
defining_identifier in [reverse] discrete_subtype_definition

If a loop_statement has a loop_statement_identifier, then the identifier shall be repeated after the end loop; otherwise, there shall not be an identifier after the end loop.

Static Semantics

A loop_parameter_specification declares a loop parameter, which is an object whose subtype is that defined by the discrete_subtype_definition.

Dynamic Semantics

For the execution of a loop_statement, the sequence_of_statements is executed repeatedly, zero or more times, until the loop_statement is complete. The loop_statement is complete when a transfer of control occurs that transfers control out of the loop, or, in the case of an iteration_scheme, as specified below.

For the execution of a loop_statement with a while iteration_scheme, the condition is evaluated before each execution of the sequence_of_statements; if the value of the condition is True, the sequence_of_statements is executed; if False, the execution of the loop_statement is complete.

9/4

{AI05-0139-2} {AI05-0262-1} {AI12-0071-1} For the execution of a loop_statement with the iteration_scheme being for loop_parameter_specification, the loop_parameter_specification is first elaborated. This elaboration creates the loop parameter and elaborates the discrete_subtype_definition. If the discrete_subtype_definition defines a subtype with a null range, the execution of the loop_statement is complete. Otherwise, the sequence_of_statements is executed once for each value of the discrete subtype defined by the discrete_subtype_definition that satisfies the predicates of the subtype (or until the loop is left as a consequence of a transfer of control). Prior to each such iteration, the corresponding value of the discrete subtype is assigned to the loop parameter. These values are assigned in increasing order unless the reserved word reverse is present, in which case the values are assigned in decreasing order.

9.a

Ramification: The order of creating the loop parameter and evaluating the discrete_subtype_definition doesn't matter, since the creation of the loop parameter has no side effects (other than possibly raising Storage_Error, but anything can do that).

9.b/3

{AI05-0262-1} The predicate (if any) necessarily has to be a static predicate as a dynamic predicate is explicitly disallowed — see 3.2.4.

9.c/3

Reason: {AI05-0262-1} If there is a predicate, the loop still visits the values in the order of the underlying base type; the order of the values in the predicate is irrelevant. This is the case so that the following loops have the same sequence of calls and parameters on procedure Call for any subtype S:

9.d

for I in S loop
Call (I);
end loop;

9.e

for I in S'Base loop
   if I in S then
      Call (I);
   end if;
end loop;

9.1/3

{AI05-0262-1} [For details about the execution of a loop_statement with the iteration_scheme being for iterator_specification, see 5.5.2.]

NOTES

5 A loop parameter is a constant; it cannot be updated within the sequence_of_statements of the loop (see 3.3).

6 An object_declaration should not be given for a loop parameter, since the loop parameter is automatically declared by the loop_parameter_specification. The scope of a loop parameter extends from the loop_parameter_specification to the end of the loop_statement, and the visibility rules are such that a loop parameter is only visible within the sequence_of_statements of the loop.

11.a

Implementation Note: An implementation could give a warning if a variable is hidden by a loop_parameter_specification.

7 The discrete_subtype_definition of a for loop is elaborated just once. Use of the reserved word reverse does not alter the discrete subtype defined, so that the following iteration_schemes are not equivalent; the first has a null range.

for J in reverse 1 .. 0
for J in 0 .. 1

13.a

Ramification: If a loop_parameter_specification has a static discrete range, the subtype of the loop parameter is static.

Examples

Example of a loop statement without an iteration scheme:

loop
Get(Current_Character);
exit when Current_Character = '*';
end loop;

Example of a loop statement with a while iteration scheme:

while Bid(N).Price < Cut_Off.Price loop
Record_Bid(Bid(N).Price);
N := N + 1;
end loop;

Example of a loop statement with a for iteration scheme:

for J in Buffer'Range loop     --  works even with a null range
   if Buffer(J) /= Space then
      Put(Buffer(J));
   end if;
end loop;

Example of a loop statement with a name:

Summation:
   while Next /= Head loop       -- see 3.10.1
      Sum  := Sum + Next.Value;
      Next := Next.Succ;
   end loop Summation;

Wording Changes from Ada 83

21.a

The constant-ness of loop parameters is specified in 3.3, “Objects and Named Numbers”.

Wording Changes from Ada 2005

21.b/3

{AI05-0139-2} {AI05-0262-1} {AI05-0299-1} Generalized iterator_specifications are allowed in for loops; these are documented as an extension in the appropriate subclause.

Wording Changes from Ada 2012

21.c/4

{AI12-0071-1} Corrigendum: Updated wording of loop execution to use the new term "satisfies the predicates" (see 3.2.4).

Ada 2005 and 2012 Editions sponsored in part by Ada-Europe