AARM95 - Exception Handlers
Author: JTC1/SC22/WG9/ARG, by Randall Brukardt, ARG Editor

Contents Index Previous Next

# 11.2 Exception Handlers

1
[The response to one or more exceptions is specified by an exception_handler.]

#### Syntax

2
handled_sequence_of_statements ::=
sequence_of_statements
[exception
exception_handler
{exception_handler}]
3
exception_handler ::=
when [choice_parameter_specification:] exception_choice {| exception_choice} =>
sequence_of_statements
4
choice_parameter_specification ::= defining_identifier
5
exception_choice ::= exception_name | others
5.a
To be honest: ``Handler'' is an abbreviation for ``exception_handler.''
5.b
Within this section, we sometimes abbreviate ``exception_choice'' to ``choice.''

#### Legality Rules

6
A choice with an exception_name covers the named exception. A choice with others covers all exceptions not named by previous choices of the same handled_sequence_of_statements. Two choices in different exception_handlers of the same handled_sequence_of_statements shall not cover the same exception.
6.a
Ramification: Two choices of the same exception_handler may cover the same exception. For example, given two renaming declarations in separate packages for the same exception, one may nevertheless write, for example, ``when Ada.Text_IO.Data_Error | My_Seq_IO.Data_Error =>''.
6.b
An others choice even covers exceptions that are not visible at the place of the handler. Since exception raising is a dynamic activity, it is entirely possible for an others handler to handle an exception that it could not have named.
7
A choice with others is allowed only for the last handler of a handled_sequence_of_statements and as the only choice of that handler.
8
An exception_name of a choice shall not denote an exception declared in a generic formal package.
8.a
Reason: This is because the compiler doesn't know the identity of such an exception, and thus can't enforce the coverage rules.

#### Static Semantics

9
A choice_parameter_specification declares a choice parameter, which is a constant object of type Exception_Occurrence (see 11.4.1). During the handling of an exception occurrence, the choice parameter, if any, of the handler represents the exception occurrence that is being handled.

#### Dynamic Semantics

10
The execution of a handled_sequence_of_statements consists of the execution of the sequence_of_statements. [The optional handlers are used to handle any exceptions that are propagated by the sequence_of_statements.]

#### Examples

11
Example of an exception handler:
12
`begin
Open(File, In_File, "input.txt"); -- see A.8.2
exception
when E : Name_Error =>
Put("Cannot open input file : ");
Put_Line(Exception_Message(E)); -- see 11.4.1
raise;
end;`

#### Extensions to Ada 83

12.a
The syntax rule for exception_handler is modified to allow a choice_parameter_specification.
12.b
Different choices of the same exception_handler may cover the same exception. This allows for ``when Numeric_Error | Constraint_Error =>'' even though Numeric_Error is a rename of Constraint_Error. This also allows one to ``with'' two different I/O packages, and then write, for example, ``when Ada.Text_IO.Data_Error | My_Seq_IO.Data_Error =>'' even though these might both be renames of the same exception.

#### Wording Changes from Ada 83

12.c
The syntax rule for handled_sequence_of_statements is new. These are now used in all the places where handlers are allowed. This obviates the need to explain (in Sections 5, 6, 7, and 9) what portions of the program are handled by the handlers. Note that there are more such cases in Ada 95.
12.d
The syntax rule for choice_parameter_specification is new.

Contents Index Previous Next Legal