C.7.3 The Package Task_Termination
Static Semantics
The following language-defined
library package exists:
with Ada.Task_Identification;
with Ada.Exceptions;
package Ada.Task_Termination
with Preelaborate, Nonblocking, Global =>
in out synchronized is
type Cause_Of_Termination
is (Normal, Abnormal, Unhandled_Exception);
type Termination_Handler
is access protected procedure
(Cause :
in Cause_Of_Termination;
T :
in Ada.Task_Identification.Task_Id;
X :
in Ada.Exceptions.Exception_Occurrence);
procedure Set_Dependents_Fallback_Handler
(Handler:
in Termination_Handler);
function Current_Task_Fallback_Handler
return Termination_Handler;
procedure Set_Specific_Handler
(T :
in Ada.Task_Identification.Task_Id;
Handler :
in Termination_Handler);
function Specific_Handler (T : Ada.Task_Identification.Task_Id)
return Termination_Handler;
end Ada.Task_Termination;
Dynamic Semantics
The type
Termination_Handler identifies a protected procedure to be executed by
the implementation when a task terminates. Such a protected procedure
is called a
handler. In all cases T identifies the task that is
terminating. If the task terminates due to completing the last statement
of its body, or as a result of waiting on a terminate alternative, and
the finalization of the task completes normally, then Cause is set to
Normal and X is set to Null_Occurrence. If the task terminates because
it is being aborted, then Cause is set to Abnormal; X is set to Null_Occurrence
if the finalization of the task completes normally. If the task terminates
because of an exception raised by the execution of its
task_body,
then Cause is set to Unhandled_Exception; X is set to the associated
exception occurrence if the finalization of the task completes normally.
Independent of how the task completes, if finalization of the task propagates
an exception, then Cause is either Unhandled_Exception or Abnormal, and
X is an exception occurrence that identifies the Program_Error exception.
Each
task has two termination handlers, a
fall-back handler and a
specific
handler. The specific handler applies only to the task itself, while
the fall-back handler applies only to the dependent tasks of the task.
A handler is said to be
set if it is associated with a nonnull
value of type Termination_Handler, and
cleared otherwise. When
a task is created, its specific handler and fall-back handler are cleared.
The procedure Set_Dependents_Fallback_Handler changes
the fall-back handler for the calling task: if Handler is null,
that fall-back handler is cleared; otherwise, it is set to be Handler.all.
If a fall-back handler had previously been set it is replaced.
The function Current_Task_Fallback_Handler returns
the fall-back handler that is currently set for the calling task, if
one is set; otherwise, it returns null.
The procedure Set_Specific_Handler changes the specific
handler for the task identified by T: if Handler is null, that
specific handler is cleared; otherwise, it is set to be Handler.all.
If a specific handler had previously been set it is replaced.
The function Specific_Handler returns the specific
handler that is currently set for the task identified by T, if one is
set; otherwise, it returns null.
As part of the finalization of a
task_body,
after performing the actions specified in
7.6
for finalization of a master, the specific handler for the task, if one
is set, is executed. If the specific handler is cleared, a search for
a fall-back handler proceeds by recursively following the master relationship
for the task. If a task is found whose fall-back handler is set, that
handler is executed; otherwise, no handler is executed.
For Set_Specific_Handler or Specific_Handler, Tasking_Error
is raised if the task identified by T has already terminated. Program_Error
is raised if the value of T is Ada.Task_Identification.Null_Task_Id.
An exception propagated from a handler that is invoked
as part of the termination of a task has no effect.
Erroneous Execution
For a call of Set_Specific_Handler or Specific_Handler,
if the task identified by T no longer exists, the execution of the program
is erroneous.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe