5.1 Simple and Compound Statements - Sequences of Statements
Term entry: parallel construct
— executable construct that defines multiple activities of a single
task that can proceed in parallel, via the execution of multiple logical
threads of control
Syntax
Name Resolution Rules
Legality Rules
Static Semantics
The scope of a declaration starts at the place
of the declaration itself (see
8.2). In the
case of a label, loop, or block name, it follows from this rule that
the scope of the implicit declaration starts before the first explicit
occurrence of the corresponding name, since this occurrence is either
in a statement label, a
loop_statement,
a
block_statement,
or a
goto_statement.
An implicit declaration in a
block_statement
may hide a declaration given in an outer program unit or
block_statement
(according to the usual rules of hiding explained in
8.3).
We cannot consider
the
label
to be a defining occurrence. An example that can tell the difference
is this:
declare
-- Label Foo is implicitly declared here.
begin
for Foo in ... loop
...
<<Foo>> -- Illegal.
...
end loop;
end;
{
AI05-0299-1}
{
AI12-0449-1}
The label in this example is hidden from itself by the loop parameter
with the same name; the example is illegal. We considered creating a
new syntactic category name, separate from
direct_name
and
selector_name,
for use in the case of statement labels. However, that would confuse
the rules in
8.3, so we didn't do it.
Reason: The semantics of a
goto_statement
is defined in terms of the statement having (following) that label. Thus
we ensure that every label has a following statement, which might be
implicit.
Dynamic Semantics
{
AI95-00318-02}
A
transfer of control is the run-time action
of an
exit_statement,
return statement,
goto_statement,
or
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.]
Ramification: It could be completed by
reaching the end of it, or by a transfer of control.
{
AI12-0119-1}
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.
{
AI12-0119-1}
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) Errors
{
AI12-0119-1}
{
AI12-0442-1}
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.
NOTE A
statement_identifier
that appears immediately within the declarative region of a named
loop_statement
or an
accept_statement
is 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.
Discussion:
Each comment in the following example gives the expanded name associated
with an entity declared in the task body:
task body Compute is
Sum : Integer := 0; -- Compute.Sum
begin
Outer: -- Compute.Outer
for I in 1..10 loop -- Compute.Outer.I
Blk: -- Compute.Blk
declare
Sum : Integer := 0; -- Compute.Blk.Sum
begin
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
-- Compute.Blk.Inner.J
Sum := Sum + Compute.Blk.Inner.J * Compute.Ent.J;
end loop Inner;
end Ent;
Compute.Sum := Compute.Sum + Compute.Blk.Sum;
end Blk;
end loop Outer;
Record_Result(Sum);
end Compute;
Examples
Examples of labeled
statements:
<<Here>> <<Ici>> <<Aqui>> <<Hier>> null;
<<After>> X := 1;
Extensions to Ada 83
Wording Changes from Ada 83
We define the syntactic category
statement_identifier
to 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.
Completion includes completion caused by a transfer
of control, although RM83-5.1(6) did not take this view.
Extensions to Ada 95
Extensions to Ada 2005
Extensions to Ada 2012
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
