- A conforming implementation shall:
- Translate and correctly execute legal programs written in Ada,
provided that they are not so large as to exceed the capacity of
- Identify all programs or program units that are so large as to
exceed the capacity of the implementation (or raise an
appropriate exception at run time);
- Identify all programs or program units that contain errors whose
detection is required by this International Standard;
- Supply all language-defined library units required by this
- Contain no variations except those explicitly permitted by this
International Standard, or those that are impossible or
impractical to avoid given the implementation's execution
- Specify all such variations in the manner prescribed by this
- The external effect of the execution of an Ada program is defined in
terms of its interactions with its external environment. The following are
defined as external interactions:
- Any interaction with an external file (see A.7);
- The execution of certain code_statements (see 13.8);
which code_statements cause external interactions is implementation defined.
- Any call on an imported subprogram (see Annex B),
including any parameters passed to it;
- Any result returned or exception propagated from a main subprogram (see
10.2) or an exported subprogram (see Annex B)
to an external caller;
- Any read or update of an atomic or volatile object (see
- The values of imported and exported objects (see Annex
B) at the time of any other interaction with the external environment.
- A conforming implementation of this International Standard shall produce
for the execution of a given Ada program a set of interactions with the
external environment whose order and timing are consistent with the
definitions and requirements of this International Standard for the semantics
of the given program.
- An implementation that conforms to this Standard shall support each
capability required by the core language as specified. In addition, an
implementation that conforms to this Standard may conform to one or more
Specialized Needs Annexes (or to none). Conformance to a Specialized Needs
Annex means that each capability required by the Annex is provided as
- An implementation conforming to this International Standard may provide
additional attributes, library units, and pragmas. However, it shall not
provide any attribute, library unit, or pragma having the same name as an
attribute, library unit, or pragma (respectively) specified in a Specialized
Needs Annex unless the provided construct is either as specified in the
Specialized Needs Annex or is more limited in capability than that required
by the Annex. A program that attempts to use an unsupported capability of an
Annex shall either be identified by the implementation before run time or
shall raise an exception at run time.
- Certain aspects of the semantics are defined to be either implementation
defined or unspecified. In such cases, the set of possible effects is specified,
and the implementation may choose any effect in the set. Implementations shall
document their behavior in implementation-defined situations, but documentation
is not required for unspecified situations. The implementation-defined characteristics
are summarized in Annex M.
- The implementation may choose to document implementation-defined
behavior either by documenting what happens in general, or by providing some
mechanism for the user to determine what happens in a particular case.
- If an implementation detects the use of an unsupported Specialized Needs
Annex feature at run time, it should raise Program_Error if feasible.
- If an implementation wishes to provide implementation-defined extensions
to the functionality of a language-defined library unit, it should normally
do so by adding children to the library unit.
(2) The above requirements imply that an implementation conforming to
this Standard may support some of the capabilities required by a
Specialized Needs Annex without supporting all required capabilities.
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe -- Magnus.Kempe@di.epfl.ch
Page last generated: 95-03-12