Annex A
(normative)
Predefined Language Environment
[
This Annex contains the specifications of library
units that shall be provided by every implementation. There are three
root library units: Ada, Interfaces, and System; other library units
are children of these:]
Standard (...continued)
Ada (...continued)
Containers (...continued)
Indefinite_Holders — A.18.18
Indefinite_Multiway_Trees — A.18.17
Indefinite_Ordered_Maps — A.18.14
Indefinite_Ordered_Sets — A.18.16
Indefinite_Vectors — A.18.11Standard (...continued)
Ada (...continued)
Containers (...continued)
Multiway_Trees — A.18.10
Ordered_Maps — A.18.6
Ordered_Sets — A.18.9
Synchronized_Queue_Interfaces
— A.18.27
Unbounded_Priority_Queues
— A.18.30
Unbounded_Synchronized_Queues
— A.18.28
Vectors — A.18.2
Decimal — F.2
Direct_IO — A.8.4
Directories — A.16
Hierarchical_File_Names — A.16.1
Information — A.16
Dispatching — D.2.1
EDF — D.2.6
Non_Preemptive — D.2.4
Round_Robin — D.2.5
Dynamic_Priorities — D.5.1
Environment_Variables — A.17
Exceptions — 11.4.1
Execution_Time — D.14
Group_Budgets — D.14.2
Interrupts — D.14.3
Timers — D.14.1
Finalization — 7.6
Float_Text_IO — A.10.9
Float_Wide_Text_IO — A.11
Float_Wide_Wide_Text_IO — A.11
Standard (...continued)
Ada (...continued)
Integer_Text_IO — A.10.8
Integer_Wide_Text_IO — A.11
Integer_Wide_Wide_Text_IO — A.11
Interrupts — C.3.2
Names — C.3.2
IO_Exceptions — A.13
Iterator_Interfaces — 5.5.1
Locales — A.19Standard (...continued)
Ada (...continued)
Numerics — A.5
Big_Numbers — A.5.5
Big_Integers — A.5.6
Big_Reals — A.5.7
Complex_Arrays — G.3.2
Complex_Elementary_Functions — G.1.2
Complex_Types — G.1.1
Discrete_Random — A.5.2
Elementary_Functions — A.5.1
Float_Random — A.5.2
Generic_Complex_Arrays — G.3.2
Generic_Complex_Elementary_Functions
— G.1.2
Generic_Complex_Types — G.1.1
Generic_Elementary_Functions — A.5.1
Generic_Real_Arrays — G.3.1
Real_Arrays — G.3.1
Real_Time — D.8
Timing_Events — D.15
Sequential_IO — A.8.1
Storage_IO — A.9
Streams — 13.13.1
Storage_Streams — 13.13.1
Bounded_FIFO_Streams — 13.13.1
FIFO_Streams — 13.13.1
Stream_IO — A.12.1
Strings — A.4.1
Bounded — A.4.4
Equal_Case_Insensitive — A.4.10
Hash — A.4.9
Hash_Case_Insensitive — A.4.9
Less_Case_Insensitive — A.4.10
Equal_Case_Insensitive — A.4.10
Fixed — A.4.3
Equal_Case_Insensitive — A.4.10
Hash — A.4.9
Hash_Case_Insensitive — A.4.9
Less_Case_Insensitive — A.4.10
Standard (...continued)
Ada (...continued)
Strings (...continued)
Hash — A.4.9
Hash_Case_Insensitive — A.4.9
Less_Case_Insensitive — A.4.10
Maps — A.4.2
Constants — A.4.6
Text_Buffers — A.4.12
Bounded — A.4.12
Unbounded — A.4.12
Unbounded — A.4.5
Equal_Case_Insensitive — A.4.10
Hash — A.4.9
Hash_Case_Insensitive — A.4.9
Less_Case_Insensitive — A.4.10
UTF_Encoding — A.4.11
Conversions — A.4.11
Strings — A.4.11
Wide_Strings — A.4.11
Wide_Wide_Strings — A.4.11
Standard (...continued)
Ada (...continued)
Strings (...continued)
Wide_Bounded — A.4.7
Wide_Equal_Case_Insensitive
— A.4.7
Wide_Hash — A.4.7
Wide_Hash_Case_Insensitive — A.4.7
Wide_Equal_Case_Insensitive — A.4.7
Wide_Fixed — A.4.7
Wide_Equal_Case_Insensitive
— A.4.7
Wide_Hash — A.4.7
Wide_Hash_Case_Insensitive — A.4.7
Wide_Hash — A.4.7
Wide_Hash_Case_Insensitive — A.4.7
Wide_Maps — A.4.7
Wide_Constants — A.4.7
Wide_Unbounded — A.4.7
Wide_Equal_Case_Insensitive
— A.4.7
Wide_Hash — A.4.7
Wide_Hash_Case_Insensitive — A.4.7
Wide_Wide_Bounded — A.4.8
Wide_Wide_Equal_Case_Insensitive
— A.4.8
Wide_Wide_Hash — A.4.8
Wide_Wide_Hash_Case_Insensitive
— A.4.8
Standard (...continued)
Ada (...continued)
Strings (...continued)
Wide_Wide_Equal_Case_Insensitive
— A.4.8
Wide_Wide_Fixed — A.4.8
Wide_Wide_Equal_Case_Insensitive
— A.4.8
Wide_Wide_Hash — A.4.8
Wide_Wide_Hash_Case_Insensitive
— A.4.8
Wide_Wide_Hash — A.4.8
Wide_Wide_Hash_Case_Insensitive
— A.4.8
Wide_Wide_Maps — A.4.8
Wide_Wide_Constants — A.4.8
Wide_Wide_Unbounded — A.4.8
Wide_Wide_Equal_Case_Insensitive
— A.4.8
Wide_Wide_Hash — A.4.8
Wide_Wide_Hash_Case_Insensitive
— A.4.8
Synchronous_Barriers — D.10.1
Synchronous_Task_Control — D.10
EDF — D.10
Standard (...continued)
Ada (...continued)
Tags — 3.9
Generic_Dispatching_Constructor — 3.9
Task_Attributes — C.7.2
Task_Identification — C.7.1
Task_Termination — C.7.3
Text_IO — A.10.1
Bounded_IO — A.10.11
Complex_IO — G.1.3
Editing — F.3.3
Text_Streams — A.12.2
Unbounded_IO — A.10.12
Unchecked_Conversion — 13.9
Unchecked_Deallocate_Subpool — 13.11.5
Unchecked_Deallocation — 13.11.2
Wide_Characters — A.3.1
Handling — A.3.5
Wide_Command_Line — A.15.1
Wide_Directories — A.16.2
Wide_Environment_Variables — A.17.1
Standard (...continued)
Ada (...continued)
Wide_Text_IO — A.11
Complex_IO — G.1.4
Editing — F.3.4
Text_Streams — A.12.3
Wide_Bounded_IO — A.11
Wide_Unbounded_IO — A.11 Wide_Wide_Characters — A.3.1
Handling — A.3.6
Wide_Wide_Command_Line — A.15.1
Wide_Wide_Directories — A.16.2
Wide_Wide_Environment_Variables —
A.17.1
Wide_Wide_Text_IO — A.11
Complex_IO — G.1.5
Editing — F.3.5
Text_Streams — A.12.4
Wide_Wide_Bounded_IO — A.11
Wide_Wide_Unbounded_IO — A.11
Discussion: In running text, we generally
leave out the “Ada.” when referring to a child of Ada.
Reason: We had no strict rule for which
of Ada, Interfaces, or System should be the parent of a given library
unit. However, we have tried to place as many things as possible under
Ada, except that interfacing is a separate category, and we have tried
to place library units whose use is highly nonportable under System.
Implementation Requirements
{
AI95-00434-01}
{
AI12-0052-1}
{
AI12-0114-1}
{
AI12-0200-1}
{
AI12-0439-1}
The implementation shall ensure that
each language-defined
subprogram is reentrant in the sense that
concurrent calls on
any two (possibly the same) language-defined the
same subprograms subprogram
perform as specified, so long as all
pairs
of objects (one
from each call) that are either denoted by parameters that
can could be
passed by reference
, or
are designated
by parameters of an access type, are denote nonoverlapping
objects.
Ramification: {
AI12-0052-1}
{
AI12-0114-1}
So long as the parameters are disjoint, concurrent
calls on the same language-defined subprogram, and concurrent calls on
two different language-defined subprograms are required to work. But
concurrent calls operating on overlapping objects (be they of the same
or different language-defined subprograms) are not required to
work (being an erroneous use of shared variables) unless both subprograms
are required to pass the associated parameter by-copy.
For example, simultaneous calls to Text_IO.Put
will work properly, so long as they are going to two different files.
On the other hand, simultaneous output to the same file constitutes erroneous
use of shared variables.
To be honest: Here, “language defined
subprogram” means a language defined library subprogram, a subprogram
declared in the visible part of a language defined library package, an
instance of a language defined generic library subprogram, or a subprogram
declared in the visible part of an instance of a language defined generic
library package.
Ramification: {
AI12-0052-1}
This rule applies to all language-defined subprograms,
including those defined in packages that manage some global state (like
environment variables or the current directory). Unless specified above,
such subprograms need to work when the explicit parameters are not overlapping;
in particular, the existence of the global state is not considered.
{
AI12-0052-1}
The rule implies that any data local to the private part or body of the
package
(including global state as described above)
has to be somehow protected against simultaneous access.
{
AI12-0052-1}
{
AI12-0159-1}
For the purpose of determining whether concurrent
calls on text input-output subprograms are required to perform as specified
above, when calling a subprogram within Text_IO or its children that
implicitly operates on one of the default input-output files, the subprogram
is considered to have a parameter of Current_Input or Current_Output
(as appropriate). {
AI05-0048-1}
If a descendant of a language-defined tagged type is declared, the implementation
shall ensure that each inherited language-defined subprogram behaves
as described in this Reference Manual. In particular, overriding a language-defined
subprogram shall not alter the effect of any inherited language-defined
subprogram.
Reason: This means that internally the
implementation must not do redispatching unless it is required by the
Standard. So when we say that some subprogram Bar is equivalent to Foo,
overriding Foo for a derived type doesn't change the semantics of Bar,
and in particular it means that Bar may no longer be equivalent to Foo.
The word “equivalent” is always a bit of a lie anyway.
Implementation Permissions
The implementation may restrict the replacement of
language-defined compilation units. The implementation may restrict children
of language-defined library units (other than Standard).
Ramification: For example, the implementation
may say, “you cannot compile a library unit called System”
or “you cannot compile a child of package System” or “if
you compile a library unit called System, it has to be a package, and
it has to contain at least the following declarations: ...”.
Ramification: {
AI12-0112-1}
Implementations are of course allowed to make changes
to the specifications of language-defined units, so long as those changes
are semantically neutral (that is, no program could change legality or
effect because of the changes). In particular, an implementation can
with additional units (especially implementation-defined units)
so long as those units do not change the elaboration of the language-defined
unit.
Similarly, an implementation
can add postconditions to language-defined subprograms, so long as those
postconditions always evaluate to True. This is useful if the implementation
can use those postconditions for optimization.
Wording Changes from Ada 83
Many of Ada 83's language-defined library units
are now children of Ada or System. For upward compatibility, these are
renamed as root library units (see
J.1).
The order and lettering of the annexes has been
changed.
Wording Changes from Ada 95
Wording Changes from Ada 2005
{
AI05-0048-1}
Correction: Added wording to ban redispatching unless it is explicitly
required, in order to safeguard portability when overriding language-defined
routines.
{
AI05-0060-1}
{
AI05-0206-1}
Correction: Added a permission to omit pragma Remote_Types from
language-defined units if Annex E is not supported. This was later removed,
as a better method of supporting the reason is now available. Note that
this requires all implementations to provide minimal support for the
Remote_Types categorization even if Annex E is not supported; being unable
to compile language-defined units is not allowed.
Incompatibilities With Ada 2012
{
AI12-0005-1}
When a new entity E
is added to a package P that is used in client code, use
clause conflicts are possible. Specifically,
if P is referenced in a use_clause,
and an entity F with the same defining identifier as E
is defined in some other package that is also referenced in a use_clause,
the user-defined entity F may no longer be use-visible, resulting
in errors. This is an incompatibility when the new entity is added to
a language-defined package. Note that use clause conflicts are rare and
easily fixed by using an expanded name. Wording Changes from Ada 2012
{
AI12-0052-1}
{
AI12-0114-1}
{
AI12-0159-1}
Corrigendum: The rules requiring concurrent
access of language-defined subprograms were expanded to include implicit
Text_IO objects, overlapping objects designated by parameters of an access
type, and simultaneous calls on different language-defined subprograms.
While this might change behavior of some programs, it would do so by
eliminating erroneous execution, so we don't consider this an inconsistency.{
AI12-0200-1}
Correction: The rules requiring concurrent
access of language-defined subprograms were clarified further.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
