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.

Notes

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);
    ...

Contents | Index | Previous | Next Legal