1.1.5 Classification of Errors
The language definition
classifies errors into several different categories:
Errors that are required to be detected prior to
run time by every Ada implementation;
These errors correspond to any violation
of a rule given in this document, other than those listed below. In particular,
violation of any rule that uses the terms shall, allowed, permitted,
legal, or illegal belongs to this category. Any program that contains
such an error is not a legal Ada program; on the other hand, the fact
that a program is legal does not mean, per se, that the program
is free from other forms of error.
rules are further classified as either compile time rules, or post compilation
rules, depending on whether a violation has to be detected at the time
a compilation unit is submitted to the compiler, or may be postponed
until the time a compilation unit is incorporated into a partition of
Errors that are required to be detected at run
time by the execution of an Ada program;
corresponding error situations are associated with the names of the predefined
exceptions. Every Ada compiler is required to generate code that raises
the corresponding exception if such an error situation arises during
program execution. If such an error situation is certain to arise in
every execution of a construct, then an implementation is allowed (although
not required) to report this fact at compilation time.
The language rules define certain kinds
of errors that are not expected to be detected either prior to or during
run time, but if not detected, the range of possible effects shall be
The errors of this category are called bounded
. The possible effects of a given bounded error are specified
for each such error, but in any case one possible effect of a bounded
error is the raising of the exception Program_Error.
In addition to bounded
errors, the language rules define certain kinds of errors as leading
to erroneous execution
. Like bounded errors, the implementation
is not expected to detect such errors either prior to or during run time.
Unlike bounded errors, there is no language-specified bound on the possible
effect of erroneous execution; the effect is in general not predictable.
may provide nonstandard modes
of operation. Typically these modes
would be selected by a pragma
or by a command line switch when the compiler is invoked. When operating
in a nonstandard mode, the implementation may reject compilation_unit
that do not conform to additional requirements associated with the mode,
such as an excessive number of warnings or violation of coding style
guidelines. Similarly, in a nonstandard mode, the implementation may
apply special optimizations or alternative algorithms that are only meaningful
for programs that satisfy certain criteria specified by the implementation.
In any case, an implementation
shall support a standard
mode that conforms to the requirements
of this Reference Manual; in particular, in the standard mode, all legal
shall be accepted.
If an implementation detects a bounded error or erroneous
execution, it should raise Program_Error.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe