1.1.3 Conformity of an Implementation with the Standard

1. A conforming implementation shall:
   1. Translate and correctly execute legal programs written in Ada, provided that they are not so large as to exceed the capacity of the implementation;
   2. 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);
   3. Identify all programs or program units that contain errors whose detection is required by this International Standard;
   4. Supply all language-defined library units required by this International Standard;
   5. 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 environment;
   6. Specify all such variations in the manner prescribed by this International Standard.

1. 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:
   1. Any interaction with an external file, See section A.7 External Files and File Objects,
   2. The execution of certain code_statements, See section 13.8 Machine Code Insertions, which code_statements cause external interactions is implementation defined.
   3. Any call on an imported subprogram, See section B Interface to Other Languages (normative), including any parameters passed to it;
   4. Any result returned or exception propagated from a main subprogram, See section 10.2 Program Execution, or an exported subprogram, See section B Interface to Other Languages (normative), to an external caller;
   5. Any read or update of an atomic or volatile object, See section C.6 Shared Variable Control,
   6. The values of imported and exported objects, See section B Interface to Other Languages (normative), at the time of any other interaction with the external environment.

1. 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.
2. 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 specified.
3. 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.
   Documentation Requirements
   
4. 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.
5. 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.
   Implementation Advice
   
6. If an implementation detects the use of an unsupported Specialized Needs Annex feature at run time, it should raise Program_Error if feasible.
7. 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.
   

   NOTES
   

8. (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.

Go to the first, previous, next, last section, table of contents.