C.3.2 The Package Interrupts
Static Semantics
The following language-defined
packages exist:
with System;
package Ada.Interrupts
is
type Interrupt_ID
is implementation-defined;
type Parameterless_Handler
is
access protected procedure;
This paragraph
was deleted.
function Is_Reserved (Interrupt : Interrupt_ID)
return Boolean;
function Is_Attached (Interrupt : Interrupt_ID)
return Boolean;
function Current_Handler (Interrupt : Interrupt_ID)
return Parameterless_Handler;
procedure Attach_Handler
(New_Handler :
in Parameterless_Handler;
Interrupt :
in Interrupt_ID);
procedure Exchange_Handler
(Old_Handler :
out Parameterless_Handler;
New_Handler :
in Parameterless_Handler;
Interrupt :
in Interrupt_ID);
procedure Detach_Handler
(Interrupt :
in Interrupt_ID);
function Reference(Interrupt : Interrupt_ID)
return System.Address;
private
... -- not specified by the language
end Ada.Interrupts;
package Ada.Interrupts.Names
is
implementation-defined :
constant Interrupt_ID :=
implementation-defined;
. . .
implementation-defined :
constant Interrupt_ID :=
implementation-defined;
end Ada.Interrupts.Names;
Dynamic Semantics
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.
If New_Handler
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
is returned.
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.
Implementation Requirements
At no time during attachment or exchange of handlers
shall the current handler of the corresponding interrupt be undefined.
Documentation Requirements
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.
Implementation Advice
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.
Examples
Example of interrupt
handlers:
Device_Priority : constant
array (1..5) of System.Interrupt_Priority := ( ... );
protected type Device_Interface
(Int_ID : Ada.Interrupts.Interrupt_ID) is
procedure Handler;
pragma Attach_Handler(Handler, Int_ID);
...
pragma Interrupt_Priority(Device_Priority(Int_ID));
end Device_Interface;
...
Device_1_Driver : Device_Interface(1);
...
Device_5_Driver : Device_Interface(5);
...
Sponsored by Ada-Europe