5.1 Simple and Compound Statements - Sequences of Statements
This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue
statement is either simple or compound. A
simple_statement encloses no other
compound_statement can enclose
simple_statements and other
compound_statements.] A parallel construct is a construct that introduces additional logical threads of control (see clause 9) without creating a new task. Parallel loops (see 5.5) and
parallel_block_statements (see 5.6.1) are parallel constructs.
direct_name of a
statement_identifier shall be an
identifier (not an
Name Resolution Rules11
direct_name of a
statement_identifier shall resolve to denote its corresponding implicit declaration (see below).
identifiers shall be used for all
statement_identifiers that appear in the same body, including inner
block_statements but excluding inner program units.
statement_identifier, there is an implicit declaration (with the specified
identifier) at the end of the
declarative_part of the innermost
block_statement or body that encloses the
statement_identifier. The implicit declarations occur in the same order as the
statement_identifiers occur in the source text. If a usage name denotes such an implicit declaration, the entity it denotes is the
block_statement with the given
statement_identifiers here rather than in terms of the corresponding statements, since a given
statementmay have multiple
block_statementthat has no explicit
declarative_parthas an implicit empty
declarative_part, so this rule can safely refer to the
block_statement, or a
goto_statement. An implicit declaration in a
block_statementmay hide a declaration given in an outer program unit or
block_statement(according to the usual rules of hiding explained in 8.3).
statement_identifierwhich is a
defining_identifier), because labels are implicitly declared. The same applies to loop and block names. In other words, the
labelitself is not the defining occurrence; the implicit declaration is.
labelto be a defining occurrence. An example that can tell the difference is this:
-- Label Foo is implicitly declared here.
for Foo in ... loop
<<Foo>> -- Illegal.
selector_name, for use in the case of statement labels. However, that would confuse the rules in Clause 8, so we didn't do it.
If one or more
labels end a
sequence_of_statements, an implicit
null_statement follows the
labels before any following constructs.
goto_statementis defined in terms of the statement having (following) that label. Thus we ensure that every label has a following statement, which might be implicit.
The execution of a
null_statement has no effect.
A transfer of control is the run-time action of an
exit_statement, return statement,
requeue_statement, selection of a
terminate_alternative, raising of an exception, or an abort, which causes the next action performed to be one other than what would normally be expected from the other rules of the language. [As explained in 7.6.1, a transfer of control can cause the execution of constructs to be completed and then left, which may trigger finalization.]
The execution of a
sequence_of_statements consists of the execution of the individual
statements in succession until the
sequence_ is completed.
Within a parallel construct, if a transfer of control out of the construct is initiated by one of the logical threads of control, an attempt is made to cancel all other logical threads of control initiated by the parallel construct. Once all other logical threads of control of the construct either complete or are canceled, the transfer of control occurs. If two or more logical threads of control of the same construct initiate such a transfer of control concurrently, one of them is chosen arbitrarily and the others are canceled.
When a logical thread of control is canceled, the cancellation causes it to complete as though it had performed a transfer of control to the point where it would have finished its execution. Such a cancellation is deferred while the logical thread of control is executing within an abort-deferred operation (see 9.8), and may be deferred further, but not past a point where the logical thread initiates a new nested parallel construct or reaches an exception handler that is outside such an abort-deferred operation.
Bounded (Run-Time) Errors19/5
During the execution of a parallel construct, it is a bounded error to invoke an operation that is potentially blocking (see 9.5). Program_Error is raised if the error is detected by the implementation; otherwise, the execution of the potentially blocking operation can either proceed normally, or it can result in the indefinite blocking of some or all of the logical threads of control making up the current task.
statement_identifierthat appears immediately within the declarative region of a named
accept_statementis nevertheless implicitly declared immediately within the declarative region of the innermost enclosing body or
block_statement; in other words, the expanded name for a named statement is not affected by whether the statement occurs inside or outside a named loop or an
accept_statement— only nesting within
block_statements is relevant to the form of its expanded name.
task body Compute is
Sum : Integer := 0; -- Compute.Sum
Outer: -- Compute.Outer
for I in 1..10 loop -- Compute.Outer.I
Blk: -- Compute.Blk
Sum : Integer := 0; -- Compute.Blk.Sum
accept Ent(I : out Integer; J : in Integer) do
-- Compute.Ent.I, Compute.Ent.J
Compute.Ent.I := Compute.Outer.I;
Inner: -- Compute.Blk.Inner
for J in 1..10 loop
Sum := Sum + Compute.Blk.Inner.J * Compute.Ent.J;
end loop Inner;
Compute.Sum := Compute.Sum + Compute.Blk.Sum;
end loop Outer;
Examples of labeled statements:
<<Here>> <<Ici>> <<Aqui>> <<Hier>> null; 23<<After>> X := 1;
Extensions to Ada 83
Wording Changes from Ada 83
statement_identifierto simplify the description. It is used for labels, loop names, and block names. We define the entity associated with the implicit declarations of statement names.
Extensions to Ada 95
extended_return_statementis new (
simple_return_statementis merely renamed).
Extensions to Ada 2005
labelcan end a
sequence_of_statements, eliminating the requirement for having an explicit null; statement after an ending label (a common use).
Extensions to Ada 2012