C.3.2 The Package Interrupts
The following language-defined
Interrupt_ID is implementation-defined
access protected procedure
Is_Reserved (Interrupt : Interrupt_ID)
Is_Attached (Interrupt : Interrupt_ID)
Current_Handler (Interrupt : Interrupt_ID)
(New_Handler : in
Interrupt : in
(Old_Handler : out
New_Handler : in
Interrupt : in
(Interrupt : in
Reference(Interrupt : Interrupt_ID)
... -- not specified by the language
. . .
The Interrupt_ID type is an implementation-defined
discrete type used to identify interrupts.
The Is_Reserved function returns True if and only
if the specified interrupt is reserved.
The Is_Attached function returns True if and only
if a user-specified interrupt handler is attached to the interrupt.
The Current_Handler function returns a value that
represents the attached handler of the interrupt. If no user-defined
handler is attached to the interrupt, Current_Handler returns null.
The Attach_Handler procedure attaches the specified
handler to the interrupt, overriding any existing treatment (including
a user handler) in effect for that interrupt. If New_Handler is null
the default treatment is restored.
designates a protected procedure to which the pragma Interrupt_Handler
does not apply, Program_Error is raised. In this case, the operation
does not modify the existing interrupt treatment.
The Exchange_Handler procedure operates in the same
manner as Attach_Handler with the addition that the value returned in
Old_Handler designates the previous treatment for the specified interrupt.
If the previous treatment is not a user-defined handler, null
The Detach_Handler procedure restores the default
treatment for the specified interrupt.
For all operations defined in this package that take
a parameter of type Interrupt_ID, with the exception of Is_Reserved and
Reference, a check is made that the specified interrupt is not reserved.
Program_Error is raised if this check fails.
If, by using the Attach_Handler, Detach_Handler,
or Exchange_Handler procedures, an attempt is made to detach a handler
that was attached statically (using the pragma Attach_Handler), the handler
is not detached and Program_Error is raised.
The Reference function returns a value of type System.Address
that can be used to attach a task entry via an address clause (see J.7.1
to the interrupt specified by Interrupt. This function raises Program_Error
if attaching task entries to interrupts (or to this particular interrupt)
is not supported.
At no time during attachment or exchange of handlers
shall the current handler of the corresponding interrupt be undefined.
If the Ceiling_Locking policy (see D.3
is in effect, the implementation shall document the default ceiling priority
assigned to a protected object that contains either the Attach_Handler
or Interrupt_Handler pragmas, but not the Interrupt_Priority pragma.
This default need not be the same for all interrupts.
If implementation-defined forms of interrupt handler
procedures are supported, such as protected procedures with parameters,
then for each such form of a handler, a type analogous to Parameterless_Handler
should be specified in a child package of Interrupts, with the same operations
as in the predefined package Interrupts.
8 The package Interrupts.Names contains
implementation-defined names (and constant values) for the interrupts
that are supported by the implementation.
Example of interrupt
Device_Priority : constant
array (1..5) of System.Interrupt_Priority := ( ... );
protected type Device_Interface
(Int_ID : Ada.Interrupts.Interrupt_ID) is
pragma Attach_Handler(Handler, Int_ID);
Device_1_Driver : Device_Interface(1);
Device_5_Driver : Device_Interface(5);