| | where Clock is the value of Clock at time t, and E is a real time
t
time duration not less than 24 hours. The value of E used for this
metric shall be reported. @end format
An upper bound on the execution time of a call to the Clock function, in
processor clock cycles.
Upper bounds on the execution times of the operators of the types Time
and Time_Span, in processor clock cycles.
Implementation Permissions
-
Implementations targeted to machines with word size smaller than 32 bits
need not support the full range and granularity of the Time and
Time_Span types.
Implementation Advice
-
When appropriate, implementations should provide configuration
mechanisms to change the value of Tick.
-
It is recommended that Calendar.Clock and Real_Time.Clock be implemented
as transformations of the same time base.
-
It is recommended that the ``best'' time base which exists in the
underlying system be available to the application through Clock.
``Best'' may mean highest accuracy or largest range.
NOTES
-
(30) The rules in this clause do not imply that the implementation can
protect the user from operator or installation errors which could result
in the clock being set incorrectly.
-
(31) Time_Unit is the granularity of the Time type. In contrast, Tick
represents the granularity of Real_Time.Clock. There is no requirement
that these be the same.
D.9 Delay Accuracy
-
This clause specifies performance requirements for the delay_statement.
The rules apply both to delay_relative_statement and to
delay_until_statement. Similarly, they apply equally to a simple
delay_statement and to one which appears in a delay_alternative.
Dynamic Semantics
-
The effect of the delay_statement for Real_Time.Time is defined in terms
of Real_Time.Clock:
-
| | If C is a value of Clock read before a task executes a
1
delay_relative_statement with duration D, and C is a value of Clock
2
read after the task resumes execution following that delay_statement,
then C - C >= D.
2 1
|
-
If C is a value of Clock read after a task resumes execution following a
delay_until_statement with Real_Time.Time value T, then C >= T.
-
A simple delay_statement with a negative or zero value for the
expiration time does not cause the calling task to be blocked; it is
nevertheless a potentially blocking operation, see 10.5.1 Protected Subprograms and Protected Actions.
-
When a delay_statement appears in a delay_alternative of a
timed_entry_call the selection of the entry call is attempted,
regardless of the specified expiration time. When a delay_statement
appears in a selective_accept_alternative, and a call is queued on one
of the open entries, the selection of that entry call proceeds,
regardless of the value of the delay expression.
Documentation Requirements
-
The implementation shall document the minimum value of the delay
expression of a delay_relative_statement that causes the task to
actually be blocked.
-
The implementation shall document the minimum difference between the
value of the delay expression of a delay_until_statement and the value
of Real_Time.Clock, that causes the task to actually be blocked.
Metrics
-
The implementation shall document the following metrics:
-
An upper bound on the execution time, in processor clock cycles, of a
delay_relative_statement whose requested value of the delay expression
is less than or equal to zero.
-
An upper bound on the execution time, in processor clock cycles, of a
delay_until_statement whose requested value of the delay expression is
less than or equal to the value of Real_Time.Clock at the time of
executing the statement. Similarly, for Calendar.Clock.
-
An upper bound on the lateness of a delay_relative_statement, for a
positive value of the delay expression, in a situation where the task
has sufficient priority to preempt the processor as soon as it becomes
ready, and does not need to wait for any other execution resources. The
upper bound is expressed as a function of the value of the delay
expression. The lateness is obtained by subtracting the value of the
delay expression from the actual duration. The actual duration is
measured from a point immediately before a task executes the
delay_statement to a point immediately after the task resumes execution
following this statement.
-
An upper bound on the lateness of a delay_until_statement, in a
situation where the value of the requested expiration time is after the
time the task begins executing the statement, the task has sufficient
priority to preempt the processor as soon as it becomes ready, and it
does not need to wait for any other execution resources. The upper bound
is expressed as a function of the difference between the requested
expiration time and the clock value at the time the statement begins
execution. The lateness of a delay_until_statement is obtained by
subtracting the requested expiration time from the real time that the
task resumes execution following this statement.
NOTES
-
(32) The execution time of a delay_statement that does not cause the
task to be blocked (e.g. "delay 0.0;" ) is of interest in situations
where delays are used to achieve voluntary round-robin task dispatching
among equal-priority tasks.
D.10 Synchronous Task Control
-
This clause describes a language-defined private semaphore (suspension
object), which can be used for two-stage suspend operations and as a
simple building block for implementing higher-level queues.
Static Semantics
-
The following language-defined package exists:
-
| | package Ada.Synchronous_Task_Control is
|
-
| | type Suspension_Object is limited private;
procedure Set_True(S : in out Suspension_Object);
procedure Set_False(S : in out Suspension_Object);
function Current_State(S : Suspension_Object) return Boolean;
procedure Suspend_Until_True(S : in out Suspension_Object);
private
... -- not specified by the language
end Ada.Synchronous_Task_Control;
|
-
The type Suspension_Object is a by-reference type.
Dynamic Semantics
-
An object of the type Suspension_Object has two visible states: true and
false. Upon initialization, its value is set to false.
-
The operations Set_True and Set_False are atomic with respect to each
other and with respect to Suspend_Until_True; they set the state to true
and false respectively.
-
Current_State returns the current state of the object.
-
The procedure Suspend_Until_True blocks the calling task until the state
of the object S is true; at that point the task becomes ready and the
state of the object becomes false.
-
Program_Error is raised upon calling Suspend_Until_True if another task
is already waiting on that suspension object. Suspend_Until_True is a
potentially blocking operation, see 10.5.1 Protected Subprograms and Protected Actions.
Implementation Requirements
-
The implementation is required to allow the calling of Set_False and
Set_True during any protected action, even one that has its ceiling
priority in the Interrupt_Priority range.
D.11 Asynchronous Task Control
-
This clause introduces a language-defined package to do asynchronous
suspend/resume on tasks. It uses a conceptual held priority value to
represent the task's held state.
Static Semantics
-
The following language-defined library package exists:
-
| | with Ada.Task_Identification;
package Ada.Asynchronous_Task_Control is
procedure Hold(T : in Ada.Task_Identification.Task_ID);
procedure Continue(T : in Ada.Task_Identification.Task_ID);
function Is_Held(T : Ada.Task_Identification.Task_ID)
return Boolean;
end Ada.Asynchronous_Task_Control;
|
Dynamic Semantics
-
After the Hold operation has been applied to a task, the task becomes
held. For each processor there is a conceptual idle task, which is
always ready. The base priority of the idle task is below
System.Any_Priority'First. The held priority is a constant of the type
integer whose value is below the base priority of the idle task.
-
The Hold operation sets the state of T to held. For a held task: the
task's own base priority does not constitute an inheritance source
(see section D.1 Task Priorities) and the value of the held priority is defined to be such a
source instead.
-
The Continue operation resets the state of T to not-held; T's active
priority is then reevaluated as described in D.1. This time, T's base
priority is taken into account.
-
The Is_Held function returns True if and only if T is in the held state.
-
As part of these operations, a check is made that the task identified by
T is not terminated. Tasking_Error is raised if the check fails.
Program_Error is raised if the value of T is Null_Task_ID.
Erroneous Execution
-
If any operation in this package is called with a parameter T that
specifies a task object that no longer exists, the execution of the
program is erroneous.
Implementation Permissions
-
An implementation need not support Asynchronous_Task_Control if it is
infeasible to support it in the target environment.
NOTES
-
(33) It is a consequence of the priority rules that held tasks cannot be
dispatched on any processor in a partition (unless they are inheriting
priorities) since their priorities are defined to be below the priority
of any idle task.
-
(34) The effect of calling Get_Priority and Set_Priority on a Held task
is the same as on any other task.
-
(35) Calling Hold on a held task or Continue on a non-held task has no
effect.
-
(36) The rules affecting queuing are derived from the above rules, in
addition to the normal priority rules:
-
When a held task is on the ready queue, its priority is so low as to
never reach the top of the queue as long as there are other tasks on
that queue.
-
If a task is executing in a protected action, inside a rendezvous, or is
inheriting priorities from other sources (e.g. when activated), it
continues to execute until it is no longer executing the corresponding
construct.
-
If a task becomes held while waiting (as a caller) for a rendezvous to
complete, the active priority of the accepting task is not affected.
-
If a task becomes held while waiting in a selective_accept, and a entry
call is issued to one of the open entries, the corresponding accept body
executes. When the rendezvous completes, the active priority of the
accepting task is lowered to the held priority (unless it is still
inheriting from other sources), and the task does not execute until
another Continue.
-
The same holds if the held task is the only task on a protected entry
queue whose barrier becomes open. The corresponding entry body executes.
D.12 Other Optimizations and Determinism Rules
-
This clause describes various requirements for improving the response
and determinism in a real-time system.
Implementation Requirements
-
If the implementation blocks interrupts, see C.3 Interrupt Support, not as a result of
direct user action (e.g. an execution of a protected action) there shall
be an upper bound on the duration of this blocking.
-
The implementation shall recognize entry-less protected types. The
overhead of acquiring the execution resource of an object of such a
type, see 10.5.1 Protected Subprograms and Protected Actions, shall be minimized. In particular, there should not
be any overhead due to evaluating entry_barrier conditions.
-
Unchecked_Deallocation shall be supported for terminated tasks that are
designated by access types, and shall have the effect of releasing all
the storage associated with the task. This includes any run-time system
or heap storage that has been implicitly allocated for the task by the
implementation.
Documentation Requirements
-
The implementation shall document the upper bound on the duration of
interrupt blocking caused by the implementation. If this is different
for different interrupts or interrupt priority levels, it should be
documented for each case.
Metrics
-
The implementation shall document the following metric:
-
The overhead associated with obtaining a mutual-exclusive access to an
entry-less protected object. This shall be measured in the following
way:
-
For a protected object of the form:
-
| | protected Lock is
procedure Set;
function Read return Boolean;
private
Flag : Boolean := False;
end Lock;
|
-
| | protected body Lock is
procedure Set is
begin
Flag := True;
end Set;
function Read return Boolean
Begin
return Flag;
end Read;
end Lock;
|
-
The execution time, in processor clock cycles, of a call to Set. This
shall be measured between the point just before issuing the call, and
the point just after the call completes. The function Read shall be
called later to verify that Set was indeed called (and not optimized
away). The calling task shall have sufficiently high priority as to not
be preempted during the measurement period. The protected object shall
have sufficiently high ceiling priority to allow the task to call Set.
-
For a multiprocessor, if supported, the metric shall be reported for the
case where no contention (on the execution resource) exists from tasks
executing on other processors.
E. Distributed Systems (normative)
-
This Annex defines facilities for supporting the implementation of
distributed systems using multiple partitions working cooperatively as
part of a single Ada program.
Post-Compilation Rules
-
A distributed system is an interconnection of one or more processing
nodes (a system resource that has both computational and storage
capabilities), and zero or more storage nodes (a system resource that
has only storage capabilities, with the storage addressable by one or
more processing nodes).
-
A distributed program comprises one or more partitions that execute
independently (except when they communicate) in a distributed system.
-
The process of mapping the partitions of a program to the nodes in a
distributed system is called configuring the partitions of the program.
Implementation Requirements
-
The implementation shall provide means for explicitly assigning library
units to a partition and for the configuring and execution of a program
consisting of multiple partitions on a distributed system; the means are
implementation defined.
Implementation Permissions
-
An implementation may require that the set of processing nodes of a
distributed system be homogeneous.
NOTES
-
(1) The partitions comprising a program may be executed on differently
configured distributed systems or on a non-distributed system without
requiring recompilation. A distributed program may be partitioned
differently from the same set of library units without recompilation.
The resulting execution is semantically equivalent.
-
(2) A distributed program retains the same type safety as the equivalent
single partition program.
--- The Detailed Node Listing ---
E.1 Partitions
-
The partitions of a distributed program are classified as either active
or passive.
Post-Compilation Rules
-
An active partition is a partition as defined in 11.2 Program Execution. A passive
partition is a partition that has no thread of control of its own, whose
library units are all preelaborated, and whose data and subprograms are
accessible to one or more active partitions.
-
A passive partition shall include only library_items that either are
declared pure or are shared passive, see 11.2.1 Elaboration Control, and E.2.1 Shared Passive Library Units.
-
An active partition shall be configured on a processing node. A passive
partition shall be configured either on a storage node or on a
processing node.
-
The configuration of the partitions of a program onto a distributed
system shall be consistent with the possibility for data references or
calls between the partitions implied by their semantic dependences. Any
reference to data or call of a subprogram across partitions is called a
remote access.
Dynamic Semantics
-
A library_item is elaborated as part of the elaboration of each
partition that includes it. If a normal library unit, see E.2 Categorization of Library Units, has
state, then a separate copy of the state exists in each active partition
that elaborates it. The state evolves independently in each such
partition.
-
An active partition terminates when its environment task terminates. A
partition becomes inaccessible if it terminates or if it is aborted. An
active partition is aborted when its environment task is aborted. In
addition, if a partition fails during its elaboration, it becomes
inaccessible to other partitions. Other implementation-defined events
can also result in a partition becoming inaccessible.
-
For a prefix D that denotes a library-level declaration, excepting a
declaration of or within a declared-pure library unit, the following
attribute is defined:
-
D'Partition_ID
| | Denotes a value of the type universal_integer that
identifies the partition in which D was elaborated. If D
denotes the declaration of a remote call interface
library unit, see E.2.3 Remote Call Interface Library Units, the given partition is the
one where the body of D was elaborated.
|
Bounded (Run-Time) Errors
-
It is a bounded error for there to be cyclic elaboration dependences
between the active partitions of a single distributed program. The
possible effects are deadlock during elaboration, or the raising of
Program_Error in one or all of the active partitions involved.
Implementation Permissions
-
An implementation may allow multiple active or passive partitions to be
configured on a single processing node, and multiple passive partitions
to be configured on a single storage node. In these cases, the
scheduling policies, treatment of priorities, and management of shared
resources between these partitions are implementation defined.
-
An implementation may allow separate copies of an active partition to be
configured on different processing nodes, and to provide appropriate
interactions between the copies to present a consistent state of the
partition to other active partitions.
-
In an implementation, the partitions of a distributed program need not
be loaded and elaborated all at the same time; they may be loaded and
elaborated one at a time over an extended period of time. An
implementation may provide facilities to abort and reload a partition
during the execution of a distributed program.
-
An implementation may allow the state of some of the partitions of a
distributed program to persist while other partitions of the program
terminate and are later reinvoked.
NOTES
-
(3) Library units are grouped into partitions after compile time, but
before run time. At compile time, only the relevant library unit
properties are identified using categorization pragmas.
-
(4) The value returned by the Partition_ID attribute can be used as a
parameter to implementation-provided subprograms in order to query
information about the partition.
E.2 Categorization of Library Units
-
Library units can be categorized according to the role they play in a
distributed program. Certain restrictions are associated with each
category to ensure that the semantics of a distributed program remain
close to the semantics for a nondistributed program.
-
A categorization pragma is a library unit pragma, see 11.1.5 Pragmas and Program Units, that
restricts the declarations, child units, or semantic dependences of the
library unit to which it applies. A categorized library unit is a
library unit to which a categorization pragma applies.
-
The pragmas Shared_Passive, Remote_Types, and Remote_Call_Interface are
categorization pragmas. In addition, for the purposes of this Annex, the
pragma Pure, see 11.2.1 Elaboration Control is considered a categorization pragma.
-
A library package or generic library package is called a shared passive
library unit if a Shared_Passive pragma applies to it. A library package
or generic library package is called a remote types library unit if a
Remote_Types pragma applies to it. A library package or generic library
package is called a remote call interface if a Remote_Call_Interface
pragma applies to it. A normal library unit is one to which no
categorization pragma applies.
-
The various categories of library units and the associated restrictions
are described in this clause and its subclauses. The categories are
related hierarchically in that the library units of one category can
depend semantically only on library units of that category or an earlier
one, except that the body of a remote types or remote call interface
library unit is unrestricted.
-
The overall hierarchy (including declared pure) is as follows:
-
Declared Pure
| | Can depend only on other declared pure library units;
|
-
Shared Passive
| | Can depend only on other shared passive or declared pure
library units;
|
-
Remote Types
| | The declaration of the library unit can depend only on other
remote types library units, or one of the above; the body of
the library unit is unrestricted;
|
-
Remote Call Interface
| | The declaration of the library unit can depend only on other
remote call interfaces, or one of the above; the body of the
library unit is unrestricted;
|
-
Normal
-
Declared pure and shared passive library units are preelaborated. The
declaration of a remote types or remote call interface library unit is
required to be preelaborable.
Implementation Requirements
-
For a given library-level type declared in a preelaborated library unit
or in the declaration of a remote types or remote call interface library
unit, the implementation shall choose the same representation for the
type upon each elaboration of the type's declaration for different
partitions of the same program.
Implementation Permissions
-
Implementations are allowed to define other categorization pragmas.
E.2.1 Shared Passive Library Units
-
A shared passive library unit is used for managing global data shared
between active partitions. The restrictions on shared passive library
units prevent the data or tasks of one active partition from being
accessible to another active partition through references implicit in
objects declared in the shared passive library unit.
Syntax
-
The form of a pragma Shared_Passive is as follows:
-
| | pragma Shared_Passive[(library_unit_name)];
|
Legality Rules
-
A shared passive library unit is a library unit to which a
Shared_Passive pragma applies. The following restrictions apply to such
a library unit:
-
it shall be preelaborable, see 11.2.1 Elaboration Control,
-
it shall depend semantically only upon declared pure or shared passive
library units;
-
it shall not contain a library-level declaration of an access type that
designates a class-wide type, task type, or protected type with
entry_declarations; if the shared passive library unit is generic, it
shall not contain a declaration for such an access type unless the
declaration is nested within a body other than a package_body.
-
Notwithstanding the definition of accessibility given in 4.10.2 Operations of Access Types,
the declaration of a library unit P1 is not accessible from within the
declarative region of a shared passive library unit P2, unless the
shared passive library unit P2 depends semantically on P1.
Static Semantics
-
A shared passive library unit is preelaborated.
Compilation Rules
-
A shared passive library unit shall be assigned to at most one partition
within a given program.
-
Notwithstanding the rule given in 11.2 Program Execution, a compilation unit in a
given partition does not need (in the sense of 11.2 Program Execution.) the shared
passive library units on which it depends semantically to be included in
that same partition; they will typically reside in separate passive
partitions.
E.2.2 Remote Types Library Units
-
A remote types library unit supports the definition of types intended
for use in communication between active partitions.
Syntax
-
The form of a pragma Remote_Types is as follows:
-
| | pragma Remote_Types[(library_unit_name)];
|
Legality Rules
-
A remote types library unit is a library unit to which the pragma
Remote_Types applies. The following restrictions apply to the
declaration of such a library unit:
-
it shall be preelaborable;
-
it shall depend semantically only on declared pure, shared passive, or
other remote types library units;
-
it shall not contain the declaration of any variable within the visible
part of the library unit;
-
if the full view of a type declared in the visible part of the library
unit has a part that is of a non-remote access type, then that access
type, or the type of some part that includes the access type
subcomponent, shall have user-specified Read and Write attributes.
-
An access type declared in the visible part of a remote types or remote
call interface library unit is called a remote access type. Such a type
shall be either an access-to-subprogram type or a general access type
that designates a class-wide limited private type.
-
The following restrictions apply to the use of a remote
access-to-subprogram type:
-
A value of a remote access-to-subprogram type shall be converted only to
another (subtype-conformant) remote access-to-subprogram type;
-
The prefix of an Access attribute_reference that yields a value of a
remote access-to-subprogram type shall statically denote a
(subtype-conformant) remote subprogram.
-
The following restrictions apply to the use of a remote
access-to-class-wide type:
-
The primitive subprograms of the corresponding specific limited private
type shall only have access parameters if they are controlling formal
parameters; the types of all the non-controlling formal parameters shall
have Read and Write attributes.
-
A value of a remote access-to-class-wide type shall be explicitly
converted only to another remote access-to-class-wide type;
-
A value of a remote access-to-class-wide type shall be dereferenced (or
implicitly converted to an anonymous access type) only as part of a
dispatching call where the value designates a controlling operand of the
call, see "Remote Subprogram Calls",
-
The Storage_Pool and Storage_Size attributes are not defined for remote
access-to-class-wide types; the expected type for an allocator shall not
be a remote access-to-class-wide type; a remote access-to-class-wide
type shall not be an actual parameter for a generic formal access type;
NOTES
-
(5) A remote types library unit need not be pure, and the types it
defines may include levels of indirection implemented by using access
types. User-specified Read and Write attributes, see 14.13.2 Stream-Oriented Attributes provide
for sending values of such a type between active partitions, with Write
marshalling the representation, and Read unmarshalling any levels of
indirection.
E.2.3 Remote Call Interface Library Units
-
A remote call interface library unit can be used as an interface for
remote procedure calls (RPCs) (or remote function calls) between active
partitions.
Syntax
-
The form of a pragma Remote_Call_Interface is as follows:
-
| | pragma Remote_Call_Interface[(library_unit_name)];
|
-
The form of a pragma All_Calls_Remote is as follows:
-
| | pragma All_Calls_Remote[(library_unit_name)];
|
-
A pragma All_Calls_Remote is a library unit pragma.
Legality Rules
-
A remote call interface (RCI) is a library unit to which the pragma
Remote_Call_Interface applies. A subprogram declared in the visible part
of such a library unit is called a remote subprogram.
-
The declaration of an RCI library unit shall be preelaborable
(see section 11.2.1 Elaboration Control) and shall depend semantically only upon declared pure,
shared passive, remote types, or other remote call interface library
units.
-
In addition, the following restrictions apply to the visible part of an
RCI library unit:
-
it shall not contain the declaration of a variable;
-
it shall not contain the declaration of a limited type;
-
it shall not contain a nested generic_declaration;
-
it shall not contain the declaration of a subprogram to which a pragma
Inline applies;
-
it shall not contain a subprogram (or access-to-subprogram) declaration
whose profile has an access parameter, or a formal parameter of a
limited type unless that limited type has user-specified Read and Write
attributes;
-
any public child of the library unit shall be a remote call interface
library unit.
-
If a pragma All_Calls_Remote applies to a library unit, the library unit
shall be a remote call interface.
Post-Compilation Rules
-
A remote call interface library unit shall be assigned to at most one
partition of a given program. A remote call interface library unit whose
parent is also an RCI library unit shall be assigned only to the same
partition as its parent.
-
Notwithstanding the rule given in 11.2 Program Execution, a compilation unit in a
given partition that semantically depends on the declaration of an RCI
library unit, needs (in the sense of 11.2 Program Execution.) only the declaration
of the RCI library unit, not the body, to be included in that same
partition. Therefore, the body of an RCI library unit is included only
in the partition to which the RCI library unit is explicitly assigned.
Implementation Requirements
-
If a pragma All_Calls_Remote applies to a given RCI library package,
then the implementation shall route any call to a subprogram of the RCI
package from outside the declarative region of the package through the
Partition Communication Subsystem (PCS); see E.5 Partition Communication Subsystem. Calls to such
subprograms from within the declarative region of the package are
defined to be local and shall not go through the PCS.
Implementation Permissions
-
An implementation need not support the Remote_Call_Interface pragma nor
the All_Calls_Remote pragma. Explicit message-based communication
between active partitions can be supported as an alternative to RPC.
E.3 Consistency of a Distributed System
-
This clause defines attributes and rules associated with verifying the
consistency of a distributed program.
Static Semantics
-
For a prefix P that statically denotes a program unit, the following
attributes are defined:
-
P'Version
| | Yields a value of the predefined type String that identifies
the version of the compilation unit that contains the
declaration of the program unit.
|
-
P'Body_Version
| | Yields a value of the predefined type String that identifies
the version of the compilation unit that contains the body
(but not any subunits) of the program unit.
|
-
The version of a compilation unit changes whenever the version changes
for any compilation unit on which it depends semantically. The version
also changes whenever the compilation unit itself changes in a
semantically significant way. It is implementation defined whether there
are other events (such as recompilation) that result in the version of a
compilation unit changing.
Bounded (Run-Time) Errors
-
In a distributed program, a library unit is consistent if the same
version of its declaration is used throughout. It is a bounded error to
elaborate a partition of a distributed program that contains a
compilation unit that depends on a different version of the declaration
of a shared passive or RCI library unit than that included in the
partition to which the shared passive or RCI library unit was assigned.
As a result of this error, Program_Error can be raised in one or both
partitions during elaboration; in any case, the partitions become
inaccessible to one another.
E.4 Remote Subprogram Calls
-
A remote subprogram call is a subprogram call that invokes the execution
of a subprogram in another partition. The partition that originates the
remote subprogram call is the calling partition, and the partition that
executes the corresponding subprogram body is the called partition. Some
remote procedure calls are allowed to return prior to the completion of
subprogram execution. These are called asynchronous remote procedure
calls.
-
There are three different ways of performing a remote subprogram call:
-
As a direct call on a (remote) subprogram explicitly declared in a
remote call interface;
-
As an indirect call through a value of a remote access-to-subprogram
type;
-
As a dispatching call with a controlling operand designated by a value
of a remote access-to-class-wide type.
-
The first way of calling corresponds to a static binding between the
calling and the called partition. The latter two ways correspond to a
dynamic binding between the calling and the called partition.
-
A remote call interface library unit, see E.2.3 Remote Call Interface Library Units, defines the remote
subprograms or remote access types used for remote subprogram calls.
Legality Rules
-
In a dispatching call with two or more controlling operands, if one
controlling operand is designated by a value of a remote
access-to-class-wide type, then all shall be.
Dynamic Semantics
-
For the execution of a remote subprogram call, subprogram parameters
(and later the results, if any) are passed using a stream-oriented
representation, see 14.13.1 The Package Streams, which is suitable for transmission
between partitions. This action is called marshalling. Unmarshalling is
the reverse action of reconstructing the parameters or results from the
stream-oriented representation. Marshalling is performed initially as
part of the remote subprogram call in the calling partition;
unmarshalling is done in the called partition. After the remote
subprogram completes, marshalling is performed in the called partition,
and finally unmarshalling is done in the calling partition.
-
A calling stub is the sequence of code that replaces the subprogram body
of a remotely called subprogram in the calling partition. A receiving
stub is the sequence of code (the "wrapper") that receives a remote
subprogram call on the called partition and invokes the appropriate
subprogram body.
-
Remote subprogram calls are executed at most once, that is, if the
subprogram call returns normally, then the called subprogram's body was
executed exactly once.
-
The task executing a remote subprogram call blocks until the subprogram
in the called partition returns, unless the call is asynchronous. For an
asynchronous remote procedure call, the calling task can become ready
before the procedure in the called partition returns.
-
If a construct containing a remote call is aborted, the remote
subprogram call is cancelled. Whether the execution of the remote
subprogram is immediately aborted as a result of the cancellation is
implementation defined.
-
If a remote subprogram call is received by a called partition before the
partition has completed its elaboration, the call is kept pending until
the called partition completes its elaboration (unless the call is
cancelled by the calling partition prior to that).
-
If an exception is propagated by a remotely called subprogram, and the
call is not an asynchronous call, the corresponding exception is
reraised at the point of the remote subprogram call. For an asynchronous
call, if the remote procedure call returns prior to the completion of
the remotely called subprogram, any exception is lost.
-
The exception Communication_Error, see E.5 Partition Communication Subsystem is raised if a remote call
cannot be completed due to difficulties in communicating with the called
partition.
-
All forms of remote subprogram calls are potentially blocking
operations, see 10.5.1 Protected Subprograms and Protected Actions.
-
In a remote subprogram call with a formal parameter of a class-wide
type, a check is made that the tag of the actual parameter identifies a
tagged type declared in a declared-pure or shared passive library unit,
or in the visible part of a remote types or remote call interface
library unit. Program_Error is raised if this check fails.
-
In a dispatching call with two or more controlling operands that are
designated by values of a remote access-to-class-wide type, a check is
made (in addition to the normal Tag_Check -- see 12.5 Suppressing Checks.) that all the
remote access-to-class-wide values originated from Access
attribute_references that were evaluated by tasks of the same active
partition. Constraint_Error is raised if this check fails.
Implementation Requirements
-
The implementation of remote subprogram calls shall conform to the PCS
interface as defined by the specification of the language-defined
package System.RPC, see E.5 Partition Communication Subsystem. The calling stub shall use the Do_RPC
procedure unless the remote procedure call is asynchronous in which case
Do_APC shall be used. On the receiving side, the corresponding receiving
stub shall be invoked by the RPC-receiver.
NOTES
-
(6) A given active partition can both make and receive remote subprogram
calls. Thus, an active partition can act as both a client and a server.
-
(7) If a given exception is propagated by a remote subprogram call, but
the exception does not exist in the calling partition, the exception can
be handled by an others choice or be propagated to and handled by a
third partition.
E.4.1 Pragma Asynchronous
-
This subclause introduces the pragma Asynchronous which allows a remote
subprogram call to return prior to completion of the execution of the
corresponding remote subprogram body.
Syntax
-
The form of a pragma Asynchronous is as follows:
-
| | pragma Asynchronous(local_name);
|
Legality Rules
-
The local_name of a pragma Asynchronous shall denote either:
-
One or more remote procedures; the formal parameters of the procedure(s)
shall all be of mode in;
-
The first subtype of a remote access-to-procedure type; the formal
parameters of the designated profile of the type shall all be of mode
in;
-
The first subtype of a remote access-to-class-wide type.
Static Semantics
-
A pragma Asynchronous is a representation pragma. When applied to a
type, it specifies the type-related asynchronous aspect of the type.
Dynamic Semantics
-
A remote call is asynchronous if it is a call to a procedure, or a call
through a value of an access-to-procedure type, to which a pragma
Asynchronous applies. In addition, if a pragma Asynchronous applies to a
remote access-to-class-wide type, then a dispatching call on a procedure
with a controlling operand designated by a value of the type is
asynchronous if the formal parameters of the procedure are all of mode
in.
Implementation Requirements
-
Asynchronous remote procedure calls shall be implemented such that the
corresponding body executes at most once as a result of the call.
E.4.2 Example of Use of a Remote Access-to-Class-Wide Type
Examples
-
Example of using a remote access-to-class-wide type to achieve dynamic
binding across active partitions:
-
| | package Tapes is
pragma Pure(Tapes);
type Tape is abstract tagged limited private;
-- Primitive dispatching operations where
-- Tape is controlling operand
procedure Copy (From, To : access Tape;
Num_Recs : in Natural) is abstract;
procedure Rewind (T : access Tape) is abstract;
-- More operations
private
type Tape is ...
end Tapes;
|
-
| | with Tapes;
package Name_Server is
pragma Remote_Call_Interface;
-- Dynamic binding to remote operations is achieved
-- using the access-to-limited-class-wide type Tape_Ptr
type Tape_Ptr is access all Tapes.Tape'Class;
-- The following statically bound remote operations
-- allow for a name-server capability in this example
function Find (Name : String) return Tape_Ptr;
procedure Register (Name : in String; T : in Tape_Ptr);
procedure Remove (T : in Tape_Ptr);
-- More operations
end Name_Server;
|
-
| | package Tape_Driver is
-- Declarations are not shown, they are irrelevant here
end Tape_Driver;
|
-
| | with Tapes, Name_Server;
package body Tape_Driver is
type New_Tape is new Tapes.Tape with ...
procedure Copy
(From, To : access New_Tape; Num_Recs: in Natural) is
begin
. . .
end Copy;
procedure Rewind (T : access New_Tape) is
begin
. . .
end Rewind;
-- Objects remotely accessible through use
-- of Name_Server operations
Tape1, Tape2 : aliased New_Tape;
begin
Name_Server.Register ("NINE-TRACK", Tape1'Access);
Name_Server.Register ("SEVEN-TRACK", Tape2'Access);
end Tape_Driver;
|
-
| | with Tapes, Name_Server;
-- Tape_Driver is not needed
-- and thus not mentioned in the with_clause
procedure Tape_Client is
T1, T2 : Name_Server.Tape_Ptr;
begin
T1 := Name_Server.Find ("NINE-TRACK");
T2 := Name_Server.Find ("SEVEN-TRACK");
Tapes.Rewind (T1);
Tapes.Rewind (T2);
Tapes.Copy (T1, T2, 3);
end Tape_Client;
|
-
Notes on the example:
-
The package Tapes provides the necessary declarations of the type and
its primitive operations.
-
Name_Server is a remote call interface package and is elaborated in a
separate active partition to provide the necessary naming services (such
as Register and Find) to the entire distributed program through remote
subprogram calls.
-
Tape_Driver is a normal package that is elaborated in a partition
configured on the processing node that is connected to the tape
device(s). The abstract operations are overridden to support the locally
declared tape devices (Tape1, Tape2). The package is not visible to its
clients, but it exports the tape devices (as remote objects) through the
services of the Name_Server. This allows for tape devices to be
dynamically added, removed or replaced without requiring the
modification of the clients' code.
-
The Tape_Client procedure references only declarations in the Tapes and
Name_Server packages. Before using a tape for the first time, it needs
to query the Name_Server for a system-wide identity for that tape. From
then on, it can use that identity to access the tape device.
-
Values of remote access type Tape_Ptr include the necessary information
to complete the remote dispatching operations that result from
dereferencing the controlling operands T1 and T2.
E.5 Partition Communication Subsystem
-
The Partition Communication Subsystem (PCS) provides facilities for
supporting communication between the active partitions of a distributed
program. The package System.RPC is a language-defined interface to the
PCS. An implementation conforming to this Annex shall use the RPC
interface to implement remote subprogram calls.
Static Semantics
-
The following language-defined library package exists:
-
-
| | type Partition_ID is range 0 .. implementation-defined;
|
-
| | Communication_Error : exception;
|
-
| | type Params_Stream_Type(
Initial_Size : Ada.Streams.Stream_Element_Count) is new
Ada.Streams.Root_Stream_Type with private;
|
-
| | procedure Read(
Stream : in out Params_Stream_Type;
Item : out Ada.Streams.Stream_Element_Array;
Last : out Ada.Streams.Stream_Element_Offset);
|
-
| | procedure Write(
Stream : in out Params_Stream_Type;
Item : in Ada.Streams.Stream_Element_Array);
|
-
| | -- Synchronous call
procedure Do_RPC(
Partition : in Partition_ID;
Params : access Params_Stream_Type;
Result : access Params_Stream_Type);
|
-
| | -- Asynchronous call
procedure Do_APC(
Partition : in Partition_ID;
Params : access Params_Stream_Type);
|
-
| | -- The handler for incoming RPCs
type RPC_Receiver is access procedure(
Params : access Params_Stream_Type;
Result : access Params_Stream_Type);
|
-
| | procedure Establish_RPC_Receiver(
Partition : in Partition_ID;
Receiver : in RPC_Receiver);
|
-
| | private
... -- not specified by the language
end System.RPC;
|
-
A value of the type Partition_ID is used to identify a partition.
-
An object of the type Params_Stream_Type is used for identifying the
particular remote subprogram that is being called, as well as
marshalling and unmarshalling the parameters or result of a remote
subprogram call, as part of sending them between partitions.
-
The Read and Write procedures override the corresponding abstract
operations for the type Params_Stream_Type.
Dynamic Semantics
-
The Do_RPC and Do_APC procedures send a message to the active partition
identified by the Partition parameter.
-
After sending the message, Do_RPC blocks the calling task until a reply
message comes back from the called partition or some error is detected
by the underlying communication system in which case Communication_Error
is raised at the point of the call to Do_RPC.
-
Do_APC operates in the same way as Do_RPC except that it is allowed to
return immediately after sending the message.
-
Upon normal return, the stream designated by the Result parameter of
Do_RPC contains the reply message.
-
The procedure System.RPC.Establish_RPC_Receiver is called once,
immediately after elaborating the library units of an active partition
(that is, right after the elaboration of the partition) if the partition
includes an RCI library unit, but prior to invoking the main subprogram,
if any. The Partition parameter is the Partition_ID of the active
partition being elaborated. The Receiver parameter designates an
implementation-provided procedure called the RPC-receiver which will
handle all RPCs received by the partition from the PCS.
Establish_RPC_Receiver saves a reference to the RPC-receiver; when a
message is received at the called partition, the RPC-receiver is called
with the Params stream containing the message. When the RPC-receiver
returns, the contents of the stream designated by Result is placed in a
message and sent back to the calling partition.
-
If a call on Do_RPC is aborted, a cancellation message is sent to the
called partition, to request that the execution of the remotely called
subprogram be aborted.
-
The subprograms declared in System.RPC are potentially blocking
operations.
Implementation Requirements
-
The implementation of the RPC-receiver shall be reentrant, thereby
allowing concurrent calls on it from the PCS to service concurrent
remote subprogram calls into the partition.
Documentation Requirements
-
The implementation of the PCS shall document whether the RPC-receiver is
invoked from concurrent tasks. If there is an upper limit on the number
of such tasks, this limit shall be documented as well, together with the
mechanisms to configure it (if this is supported).
Implementation Permissions
-
The PCS is allowed to contain implementation-defined interfaces for
explicit message passing, broadcasting, etc. Similarly, it is allowed to
provide additional interfaces to query the state of some remote
partition (given its partition ID) or of the PCS itself, to set timeouts
and retry parameters, to get more detailed error status, etc. These
additional interfaces should be provided in child packages of
System.RPC.
-
A body for the package System.RPC need not be supplied by the
implementation.
Implementation Advice
-
Whenever possible, the PCS on the called partition should allow for
multiple tasks to call the RPC-receiver with different messages and
should allow them to block until the corresponding subprogram body
returns.
-
The Write operation on a stream of type Params_Stream_Type should raise
Storage_Error if it runs out of space trying to write the Item into the
stream.
NOTES
-
(8) The package System.RPC is not designed for direct calls by user
programs. It is instead designed for use in the implementation of remote
subprograms calls, being called by the calling stubs generated for a
remote call interface library unit to initiate a remote call, and in
turn calling back to an RPC-receiver that dispatches to the receiving
stubs generated for the body of a remote call interface, to handle a
remote call received from elsewhere.
F. Information Systems (normative)
-
This Annex provides a set of facilities relevant to Information Systems
programming. These fall into several categories:
-
an attribute definition clause specifying Machine_Radix for a decimal
subtype;
-
the package Decimal, which declares a set of constants defining the
implementation's capacity for decimal types, and a generic procedure for
decimal division; and
-
the child packages Text_IO.Editing and Wide_Text_IO.Editing, which
support formatted and localized output of decimal data, based on
"picture String" values.
-
See also: "Fixed Point Types", "Operations of Fixed Point Types", "Type Conversions",
See section "Representation Attributes", "Input-Output for Real Types", "Interfacing with COBOL", "Interfacing with C", and "Numerics".
-
The character and string handling packages in "Predefined Language Environment", are also relevant for Information Systems.
Implementation Advice
-
If COBOL (respectively, C) is widely supported in the target
environment, implementations supporting the Information Systems Annex
should provide the child package Interfaces.COBOL (respectively,
Interfaces.C) specified in Annex B and should support a
convention_identifier of COBOL (respectively, C) in the interfacing
pragmas, see B. Interface to Other Languages (normative), thus allowing Ada programs to interface with programs
written in that language.
--- The Detailed Node Listing ---
F.1 Machine_Radix Attribute Definition Clause
Static Semantics
-
Machine_Radix may be specified for a decimal first subtype
(see section 4.5.9 Fixed Point Types) via an attribute_definition_clause; the expression of such
a clause shall be static, and its value shall be 2 or 10. A value of 2
implies a binary base range; a value of 10 implies a decimal base range.
Implementation Advice
-
Packed decimal should be used as the internal representation for objects
of subtype S when S'Machine_Radix = 10.
Examples
-
Example of Machine_Radix attribute definition clause:
-
| | type Money is delta 0.01 digits 15;
for Money'Machine_Radix use 10;
|
F.2 The Package Decimal
Static Semantics
-
The library package Decimal has the following declaration:
-
| | package Ada.Decimal is
pragma Pure(Decimal);
|
-
| | Max_Scale : constant := implementation-defined;
Min_Scale : constant := implementation-defined;
|
-
| | Min_Delta : constant := 10.0**(-Max_Scale);
Max_Delta : constant := 10.0**(-Min_Scale);
|
-
| | Max_Decimal_Digits : constant := implementation-defined;
|
-
| | generic
type Dividend_Type is delta <> digits <>;
type Divisor_Type is delta <> digits <>;
type Quotient_Type is delta <> digits <>;
type Remainder_Type is delta <> digits <>;
procedure Divide (Dividend : in Dividend_Type;
Divisor : in Divisor_Type;
Quotient : out Quotient_Type;
Remainder : out Remainder_Type);
pragma Convention(Intrinsic, Divide);
|
-
-
Max_Scale is the largest N such that 10.0**(-N) is allowed as a decimal
type's delta. Its type is universal_integer.
-
Min_Scale is the smallest N such that 10.0**(-N) is allowed as a decimal
type's delta. Its type is universal_integer.
-
Min_Delta is the smallest value allowed for delta in a
decimal_fixed_point_definition. Its type is universal_real.
-
Max_Delta is the largest value allowed for delta in a
decimal_fixed_point_definition. Its type is universal_real.
-
Max_Decimal_Digits is the largest value allowed for digits in a
decimal_fixed_point_definition. Its type is universal_integer.
Static Semantics
-
The effect of Divide is as follows. The value of Quotient is
Quotient_Type(Dividend/Divisor). The value of Remainder is
Remainder_Type(Intermediate), where Intermediate is the difference
between Dividend and the product of Divisor and Quotient; this result is
computed exactly.
Implementation Requirements
-
Decimal.Max_Decimal_Digits shall be at least 18.
-
Decimal.Max_Scale shall be at least 18.
-
Decimal.Min_Scale shall be at most 0.
NOTES
-
(1) The effect of division yielding a quotient with control over
rounding versus truncation is obtained by applying either the function
attribute Quotient_Type'Round or the conversion Quotient_Type to the
expression Dividend/Divisor.
F.3 Edited Output for Decimal Types
-
The child packages Text_IO.Editing and Wide_Text_IO.Editing provide
localizable formatted text output, known as edited output , for decimal
types. An edited output string is a function of a numeric value,
program-specifiable locale elements, and a format control value. The
numeric value is of some decimal type. The locale elements are:
-
the currency string;
-
the digits group separator character;
-
the radix mark character; and
-
the fill character that replaces leading zeros of the numeric value.
-
For Text_IO.Editing the edited output and currency strings are of type
String, and the locale characters are of type Character. For
Wide_Text_IO.Editing their types are Wide_String and Wide_Character,
respectively.
-
Each of the locale elements has a default value that can be replaced or
explicitly overridden.
-
A format-control value is of the private type Picture; it determines the
composition of the edited output string and controls the form and
placement of the sign, the position of the locale elements and the
decimal digits, the presence or absence of a radix mark, suppression of
leading zeros, and insertion of particular character values.
-
A Picture object is composed from a String value, known as a picture
String, that serves as a template for the edited output string, and a
Boolean value that controls whether a string of all space characters is
produced when the number's value is zero. A picture String comprises a
sequence of one- or two-Character symbols, each serving as a placeholder
for a character or string at a corresponding position in the edited
output string. The picture String symbols fall into several categories
based on their effect on the edited output string:
-
| | Decimal Digit: '9'
Radix Control: '.' 'V'
Sign Control: '+' '-' '<' '>' "CR" "DB"
Currency Control: '$' '#'
Zero Suppression: 'Z' '*'
Simple Insertion: '_' 'B' '0' '/'
|
-
The entries are not case-sensitive. Mixed- or lower-case forms for "CR"
and "DB", and lower-case forms for 'V', 'Z', and 'B', have the same
effect as the upper-case symbols shown.
-
An occurrence of a '9' Character in the picture String represents a
decimal digit position in the edited output string.
-
A radix control Character in the picture String indicates the position
of the radix mark in the edited output string: an actual character
position for '.', or an assumed position for 'V'.
-
A sign control Character in the picture String affects the form of the
sign in the edited output string. The '<' and '>' Character values
indicate parentheses for negative values. A Character '+', '-', or '<'
appears either singly, signifying a fixed-position sign in the edited
output, or repeated, signifying a floating-position sign that is
preceded by zero or more space characters and that replaces a leading 0.
-
A currency control Character in the picture String indicates an
occurrence of the currency string in the edited output string. The '$'
Character represents the complete currency string; the '#' Character
represents one character of the currency string. A '$' Character appears
either singly, indicating a fixed-position currency string in the edited
output, or repeated, indicating a floating-position currency string that
occurs in place of a leading 0. A sequence of '#' Character values
indicates either a fixed- or floating-position currency string,
depending on context.
-
A zero suppression Character in the picture String allows a leading zero
to be replaced by either the space character (for 'Z') or the fill
character (for '*').
-
A simple insertion Character in the picture String represents, in
general, either itself (if '/' or '0'), the space character (if 'B'), or
the digits group separator character (if '_'). In some contexts it is
treated as part of a floating sign, floating currency, or zero
suppression string.
-
An example of a picture String is "<###Z_ZZ9.99>". If the currency
string is "FF", the separator character is ',', and the radix mark is
'.' then the edited output string values for the decimal values 32.10
and -5432.10 are "bbFFbbb32.10b" and "(bFF5,432.10)", respectively,
where 'b' indicates the space character.
-
The generic packages Text_IO.Decimal_IO and Wide_Text_IO.Decimal_IO
(see section "Input-Output for Real Types") provide text input and
non-edited text output for decimal types.
NOTES
-
(2) A picture String is of type Standard.String, both for
Text_IO.Editing and Wide_Text_IO.Editing.
F.3.1 Picture String Formation
-
A well-formed picture String, or simply picture String, is a String
value that conforms to the syntactic rules, composition constraints, and
character replication conventions specified in this clause.
Dynamic Semantics
-
| | picture_string ::=
fixed_$_picture_string
| fixed_#_picture_string
| floating_currency_picture_string
| non_currency_picture_string
|
-
| | fixed_$_picture_string ::=
[fixed_LHS_sign] fixed_$_char {direct_insertion}
[zero_suppression] number [RHS_sign]
| [fixed_LHS_sign {direct_insertion}] [zero_suppression]
number fixed_$_char {direct_insertion} [RHS_sign]
| floating_LHS_sign number fixed_$_char {direct_insertion}
[RHS_sign]
| [fixed_LHS_sign] fixed_$_char {direct_insertion}
all_zero_suppression_number {direct_insertion} [RHS_sign]
| [fixed_LHS_sign {direct_insertion}] all_zero_suppression_number
{direct_insertion} fixed_$_char {direct_insertion}
[RHS_sign]
| all_sign_number {direct_insertion} fixed_$_char
{direct_insertion} [RHS_sign]
|
-
| | fixed_#_picture_string ::=
[fixed_LHS_sign] single_#_currency {direct_insertion}
[zero_suppression] number [RHS_sign]
| [fixed_LHS_sign] multiple_#_currency {direct_insertion}
zero_suppression number [RHS_sign]
| [fixed_LHS_sign {direct_insertion}] [zero_suppression]
number fixed_#_currency {direct_insertion} [RHS_sign]
| floating_LHS_sign number fixed_#_currency {direct_insertion}
[RHS_sign]
| [fixed_LHS_sign] single_#_currency {direct_insertion}
all_zero_suppression_number {direct_insertion} [RHS_sign]
| [fixed_LHS_sign] multiple_#_currency {direct_insertion}
all_zero_suppression_number {direct_insertion} [RHS_sign]
| [fixed_LHS_sign {direct_insertion}] all_zero_suppression_number
{direct_insertion} fixed_#_currency {direct_insertion}
[RHS_sign]
| all_sign_number {direct_insertion} fixed_#_currency
{direct_insertion} [RHS_sign]
|
-
| | floating_currency_picture_string ::=
[fixed_LHS_sign] {direct_insertion} floating_$_currency
number [RHS_sign]
| [fixed_LHS_sign] {direct_insertion} floating_#_currency
number [RHS_sign]
| [fixed_LHS_sign] {direct_insertion} all_currency_number
{direct_insertion} [RHS_sign]
|
-
| | non_currency_picture_string ::=
[fixed_LHS_sign {direct_insertion}] zero_suppression
number [RHS_sign]
| [floating_LHS_sign]
number [RHS_sign]
| [fixed_LHS_sign {direct_insertion}]
all_zero_suppression_number {direct_insertion} [RHS_sign]
| all_sign_number {direct_insertion}
| fixed_LHS_sign direct_insertion {direct_insertion}
number [RHS_sign]
|
-
| | fixed_LHS_sign ::= LHS_Sign
|
-
-
-
| | direct_insertion ::= simple_insertion
|
-
| | simple_insertion ::= _ | B | 0 | /
|
-
| | zero_suppression ::= Z {Z
| context_sensitive_insertion}
| fill_string
|
-
| | context_sensitive_insertion ::= simple_insertion
|
-
| | fill_string ::= * {* | context_sensitive_insertion}
|
-
| | number ::=
fore_digits [radix [aft_digits] {direct_insertion}]
| radix aft_digits {direct_insertion}
|
-
| | fore_digits ::= 9 {9 | direct_insertion}
|
-
| | aft_digits ::= {9 | direct_insertion} 9
|
-
-
| | RHS_sign ::= + | - | > | CR | DB
|
-
| | floating_LHS_sign ::=
LHS_Sign {context_sensitive_insertion} LHS_Sign
{LHS_Sign | context_sensitive_insertion}
|
-
-
| | multiple_#_currency ::= ## {#}
|
-
| | fixed_#_currency ::= single_#_currency | multiple_#_currency
|
-
| | floating_$_currency ::=
$ {context_sensitive_insertion} $ {$
| context_sensitive_insertion}
|
-
| | floating_#_currency ::=
# {context_sensitive_insertion} # {#
| context_sensitive_insertion}
|
-
| | all_sign_number ::= all_sign_fore [radix [all_sign_aft]] [>]
|
-
| | all_sign_fore ::=
sign_char {context_sensitive_insertion} sign_char {sign_char
| context_sensitive_insertion}
|
-
| | all_sign_aft ::= {all_sign_aft_char} sign_char
all_sign_aft_char ::= sign_char | context_sensitive_insertion
|
-
-
| | all_currency_number ::= all_currency_fore
[radix [all_currency_aft]]
|
-
| | all_currency_fore ::=
currency_char {context_sensitive_insertion}
currency_char {currency_char | context_sensitive_insertion}
|
-
| | all_currency_aft ::= {all_currency_aft_char} currency_char
all_currency_aft_char ::= currency_char
| context_sensitive_insertion
|
-
-
| | all_zero_suppression_number ::= all_zero_suppression_fore
[ radix [all_zero_suppression_aft]]
|
-
| | all_zero_suppression_fore ::=
zero_suppression_char {zero_suppression_char
| context_sensitive_insertion}
|
-
| | all_zero_suppression_aft ::= {all_zero_suppression_aft_char}
zero_suppression_char
all_zero_suppression_aft_char ::= zero_suppression_char
| context_sensitive_insertion
|
-
| | zero_suppression_char ::= Z | *
|
-
The following composition constraints apply to a picture String:
-
A floating_LHS_sign does not have occurrences of different LHS_Sign
Character values.
-
If a picture String has '<' as fixed_LHS_sign, then it has '>' as
RHS_sign.
-
If a picture String has '<' in a floating_LHS_sign or in an
all_sign_number, then it has an occurrence of '>'.
-
If a picture String has '+' or '-' as fixed_LHS_sign, in a
floating_LHS_sign, or in an all_sign_number, then it has no RHS_sign.
-
An instance of all_sign_number does not have occurrences of different
sign_char Character values.
-
An instance of all_currency_number does not have occurrences of
different currency_char Character values.
-
An instance of all_zero_suppression_number does not have occurrences of
different zero_suppression_char Character values, except for possible
case differences between 'Z' and 'z'.
-
A replicable Character is a Character that, by the above rules, can
occur in two consecutive positions in a picture String.
-
A Character replication is a String
-
| | char & '(' & spaces & count_string & ')'
|
-
where char is a replicable Character, spaces is a String (possibly
empty) comprising only space Character values, and count_string is a
String of one or more decimal digit Character values. A Character
replication in a picture String has the same effect as (and is said to
be equivalent to) a String comprising n consecutive occurrences of char,
where n=Integer'Value(count_string).
-
An expanded picture String is a picture String containing no Character
replications.
NOTES
-
(3) Although a sign to the left of the number can float, a sign to the
right of the number is in a fixed position.
F.3.2 Edited Output Generation
Dynamic Semantics
-
The contents of an edited output string are based on:
-
A value, Item, of some decimal type Num,
-
An expanded picture String Pic_String,
-
A Boolean value, Blank_When_Zero,
-
A Currency string,
-
A Fill character,
-
A Separator character, and
-
A Radix_Mark character.
-
The combination of a True value for Blank_When_Zero and a '*' character
in Pic_String is inconsistent; no edited output string is defined.
-
A layout error is identified in the rules below if leading non-zero
digits of Item, character values of the Currency string, or a negative
sign would be truncated; in such cases no edited output string is
defined.
-
The edited output string has lower bound 1 and upper bound N where N =
Pic_String'Length + Currency_Length_Adjustment - Radix_Adjustment, and
-
Currency_Length_Adjustment = Currency'Length - 1 if there is some
occurrence of '$' in Pic_String, and 0 otherwise.
-
Radix_Adjustment = 1 if there is an occurrence of 'V' or 'v' in Pic_Str,
and 0 otherwise.
-
| | Let the magnitude of Item be expressed as a base-10 number
I ***I .F ***F , called the displayed magnitude of Item, where:
p 1 1 q
|
-
q = Min(Max(Num'Scale, 0), n) where n is 0 if Pic_String has no radix
and is otherwise the number of digit positions following radix in
Pic_String, where a digit position corresponds to an occurrence of '9',
a zero_suppression_char (for an all_zero_suppression_number), a
currency_char (for an all_currency_number), or a sign_char (for an
all_sign_number).
-
-
If n < Num'Scale, then the above number is the result of rounding (away
from 0 if exactly midway between values).
-
If Blank_When_Zero = True and the displayed magnitude of Item is zero,
then the edited output string comprises all space character values.
Otherwise, the picture String is treated as a sequence of instances of
syntactic categories based on the rules in F.3.1 Picture String Formation, and the edited
output string is the concatenation of string values derived from these
categories according to the following mapping rules.
-
Table F-1 shows the mapping from a sign control symbol to a
corresponding character or string in the edited output. In the columns
showing the edited output, a lower-case 'b' represents the space
character. If there is no sign control symbol but the value of Item is
negative, a layout error occurs and no edited output string is produced.
| | +---------------------------------------------------+
| |
| Table F-1: Edited Output for Sign Control Symbols |
| |
+----------------+------------------+---------------+
| | | |
| Sign Control | Edited Output | Edited Output |
| Symbol | for Non-Negative | for Negative |
| | Number | Number |
| | | |
+----------------+------------------+---------------+
| | | |
| '+' | '+' | '-' |
| | | |
| '-' | 'b' | '-' |
| | | |
| '<' | 'b' | '(' |
| | | |
| '>' | 'b' | ')' |
| | | |
| "CR" | "bb" | "CR" |
| | | |
| "DB" | "bb" | "DB" |
| | | |
+----------------+------------------+---------------+
|
-
An instance of fixed_LHS_sign maps to a character as shown in Table F-1.
-
An instance of fixed_$_char maps to Currency.
-
An instance of direct_insertion maps to Separator if direct_insertion =
'_', and to the direct_insertion Character otherwise.
-
An instance of number maps to a string integer_part & radix_part &
fraction_part where:
-
The string for integer_part is obtained as follows:
-
| | Occurrences of '9' in fore_digits of number are replaced
from right to left with the decimal digit character values
for I , ..., I , respectively.
1 p
|
-
Each occurrence of '9' in fore_digits to the left of the leftmost '9'
replaced according to rule 1 is replaced with '0'.
-
If p exceeds the number of occurrences of '9' in fore_digits of number,
then the excess leftmost digits are eligible for use in the mapping of
an instance of zero_suppression, floating_LHS_sign, floating_$_currency,
or floating_#_currency to the left of number; if there is no such
instance, then a layout error occurs and no edited output string is
produced.
-
The radix_part is:
-
"" if number does not include a radix, if radix = 'V', or if radix = 'v'
-
Radix_Mark if number includes '.' as radix
-
The string for fraction_part is obtained as follows:
-
| | Occurrences of '9' in aft_digits of number are replaced
from left to right with the decimal digit character values
for F , ... F .
1 q
|
-
Each occurrence of '9' in aft_digits to the right of the rightmost '9'
replaced according to rule 1 is replaced by '0'.
-
An instance of zero_suppression maps to the string obtained as follows:
-
The rightmost 'Z', 'z', or '*' Character values are replaced with the
excess digits (if any) from the integer_part of the mapping of the
number to the right of the zero_suppression instance,
-
A context_sensitive_insertion Character is replaced as though it were a
direct_insertion Character, if it occurs to the right of some 'Z', 'z',
or '*' in zero_suppression that has been mapped to an excess digit,
-
Each Character to the left of the leftmost Character replaced according
to rule 1 above is replaced by:
-
the space character if the zero suppression Character is 'Z' or 'z', or
-
the Fill character if the zero suppression Character is '*'.
-
A layout error occurs if some excess digits remain after all 'Z', 'z',
and '*' Character values in zero_suppression have been replaced via rule
1; no edited output string is produced.
-
An instance of RHS_sign maps to a character or string as shown in Table
F-1.
-
An instance of floating_LHS_sign maps to the string obtained as follows.
-
Up to all but one of the rightmost LHS_Sign Character values are
replaced by the excess digits (if any) from the integer_part of the
mapping of the number to the right of the floating_LHS_sign instance.
-
The next Character to the left is replaced with the character given by
the entry in Table F-1 corresponding to the LHS_Sign Character.
-
A context_sensitive_insertion Character is replaced as though it were a
direct_insertion Character, if it occurs to the right of the leftmost
LHS_Sign character replaced according to rule 1.
-
Any other Character is replaced by the space character..
-
A layout error occurs if some excess digits remain after replacement via
rule 1; no edited output string is produced.
-
An instance of fixed_#_currency maps to the Currency string with n space
character values concatenated on the left (if the instance does not
follow a radix) or on the right (if the instance does follow a radix),
where n is the difference between the length of the fixed_#_currency
instance and Currency'Length. A layout error occurs if Currency'Length
exceeds the length of the fixed_#_currency instance; no edited output
string is produced.
-
An instance of floating_$_currency maps to the string obtained as
follows:
-
Up to all but one of the rightmost '$' Character values are replaced
with the excess digits (if any) from the integer_part of the mapping of
the number to the right of the floating_$_currency instance.
-
The next Character to the left is replaced by the Currency string.
-
A context_sensitive_insertion Character is replaced as though it were a
direct_insertion Character, if it occurs to the right of the leftmost
'$' Character replaced via rule 1.
-
Each other Character is replaced by the space character.
-
A layout error occurs if some excess digits remain after replacement by
rule 1; no edited output string is produced.
-
An instance of floating_#_currency maps to the string obtained as
follows:
-
Up to all but one of the rightmost '#' Character values are replaced
with the excess digits (if any) from the integer_part of the mapping of
the number to the right of the floating_#_currency instance.
-
The substring whose last Character occurs at the position immediately
preceding the leftmost Character replaced via rule 1, and whose length
is Currency'Length, is replaced by the Currency string.
-
A context_sensitive_insertion Character is replaced as though it were a
direct_insertion Character, if it occurs to the right of the leftmost
'#' replaced via rule 1.
-
Any other Character is replaced by the space character.
-
A layout error occurs if some excess digits remain after replacement
rule 1, or if there is no substring with the required length for
replacement rule 2; no edited output string is produced.
-
An instance of all_zero_suppression_number maps to:
-
a string of all spaces if the displayed magnitude of Item is zero, the
zero_suppression_char is 'Z' or 'z', and the instance of
all_zero_suppression_number does not have a radix at its last character
position;
-
a string containing the Fill character in each position except for the
character (if any) corresponding to radix, if zero_suppression_char =
'*' and the displayed magnitude of Item is zero;
-
otherwise, the same result as if each zero_suppression_char in
all_zero_suppression_aft were '9', interpreting the instance of
all_zero_suppression_number as either zero_suppression number (if a
radix and all_zero_suppression_aft are present), or as zero_suppression
otherwise.
-
An instance of all_sign_number maps to:
-
a string of all spaces if the displayed magnitude of Item is zero and
the instance of all_sign_number does not have a radix at its last
character position;
-
otherwise, the same result as if each sign_char in all_sign_number_aft
were '9', interpreting the instance of all_sign_number as either
floating_LHS_sign number (if a radix and all_sign_number_aft are
present), or as floating_LHS_sign otherwise.
-
An instance of all_currency_number maps to:
-
a string of all spaces if the displayed magnitude of Item is zero and
the instance of all_currency_number does not have a radix at its last
character position;
-
otherwise, the same result as if each currency_char in
all_currency_number_aft were '9', interpreting the instance of
all_currency_number as floating_$_currency number or floating_#_currency
number (if a radix and all_currency_number_aft are present), or as
floating_$_currency or floating_#_currency otherwise.
Examples
-
In the result string values shown below, 'b' represents the space
character.
-
| | Item: Picture and Result Strings:
|
-
| | 123456.78 Picture: "-###**_***_**9.99"
"bbb$***123,456.78"
"bbFF***123.456,78" (currency = "FF",
separator = '.',
radix mark = ',')
|
-
| | 123456.78 Picture: "-$$$**_***_**9.99"
Result: "bbb$***123,456.78"
"bbbFF***123.456,78" (currency = "FF",
separator = '.',
radix mark = ',')
|
-
| | 0.0 Picture: "-$$$$$$.$$"
Result: "bbbbbbbbbb"
|
-
| | 0.20 Picture: "-$$$$$$.$$"
Result: "bbbbbb$.20"
|
-
| | -1234.565 Picture: "<<<<_<<<.<<###>"
Result: "bb(1,234.57DMb)" (currency = "DM")
|
-
| | 12345.67 Picture: "###_###_##9.99"
Result: "bbCHF12,345.67" (currency = "CHF")
|
F.3.3 The Package Text_IO.Editing
-
The package Text_IO.Editing provides a private type Picture with
associated operations, and a generic package Decimal_Output. An object
of type Picture is composed from a well-formed picture String
(see section F.3.1 Picture String Formation) and a Boolean item indicating whether a zero numeric value
will result in an edited output string of all space characters. The
package Decimal_Output contains edited output subprograms implementing
the effects defined in F.3.2 Edited Output Generation.
Static Semantics
-
The library package Text_IO.Editing has the following declaration:
-
| | package Ada.Text_IO.Editing is
|
-
-
| | function Valid (Pic_String : in String;
Blank_When_Zero : in Boolean := False)
return Boolean;
|
-
| | function To_Picture (Pic_String : in String;
Blank_When_Zero : in Boolean := False)
return Picture;
|
-
| | function Pic_String (Pic : in Picture) return String;
function Blank_When_Zero (Pic : in Picture) return Boolean;
|
-
| | Max_Picture_Length : constant := implementation_defined;
|
-
| | Picture_Error : exception;
|
-
| | Default_Currency : constant String := "$";
Default_Fill : constant Character := '*';
Default_Separator : constant Character := ',';
Default_Radix_Mark : constant Character := '.';
|
-
| | generic
type Num is delta <> digits <>;
Default_Currency : in String
:= Text_IO.Editing.Default_Currency;
Default_Fill : in Character
:= Text_IO.Editing.Default_Fill;
Default_Separator : in Character
:= Text_IO.Editing.Default_Separator;
Default_Radix_Mark : in Character
:= Text_IO.Editing.Default_Radix_Mark;
package Decimal_Output is
function Length (Pic : in Picture;
Currency : in String := Default_Currency)
return Natural;
|
-
| | function Valid (Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency)
return Boolean;
|
-
| | function Image
(Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark)
return String;
|
-
| | procedure Put
(File : in File_Type;
Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark);
|
-
| | procedure Put
(Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark);
|
-
| | procedure Put
(To : out String;
Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark);
end Decimal_Output;
private
... -- not specified by the language
end Ada.Text_IO.Editing;
|
-
The exception Constraint_Error is raised if the Image function or any of
the Put procedures is invoked with a null string for Currency.
-
| | function Valid (Pic_String : in String;
Blank_When_Zero : in Boolean := False)
return Boolean;
|
-
Valid returns True if Pic_String is a well-formed picture String
(see section F.3.1 Picture String Formation) the length of whose expansion does not exceed
Max_Picture_Length, and if either Blank_When_Zero is False or Pic_String
contains no '*'.
-
| | function To_Picture (Pic_String : in String;
Blank_When_Zero : in Boolean := False)
return Picture;
|
-
To_Picture returns a result Picture such that the application of the
function Pic_String to this result yields an expanded picture String
equivalent to Pic_String, and such that Blank_When_Zero applied to the
result Picture is the same value as the parameter Blank_When_Zero.
Picture_Error is raised if not Valid(Pic_String, Blank_When_Zero).
-
| | function Pic_String (Pic : in Picture) return String;
function Blank_When_Zero (Pic : in Picture) return Boolean;
|
-
If Pic is To_Picture(String_Item, Boolean_Item) for some String_Item and
Boolean_Item, then:
-
Pic_String(Pic) returns an expanded picture String equivalent to
String_Item and with any lower-case letter replaced with its
corresponding upper-case form, and
-
Blank_When_Zero(Pic) returns Boolean_Item.
-
If Pic_1 and Pic_2 are objects of type Picture, then "="(Pic_1, Pic_2)
is True when
-
Pic_String(Pic_1) = Pic_String(Pic_2), and
-
Blank_When_Zero(Pic_1) = Blank_When_Zero(Pic_2).
-
| | function Length (Pic : in Picture;
Currency : in String := Default_Currency)
return Natural;
|
-
Length returns Pic_String(Pic)'Length + Currency_Length_Adjustment -
Radix_Adjustment where
-
Currency_Length_Adjustment =
-
Currency'Length - 1 if there is some occurrence of '$' in
Pic_String(Pic), and
-
0 otherwise.
-
Radix_Adjustment =
-
1 if there is an occurrence of 'V' or 'v' in Pic_Str(Pic), and
-
0 otherwise.
-
| | function Valid (Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency)
return Boolean;
|
-
Valid returns True if Image(Item, Pic, Currency) does not raise
Layout_Error, and returns False otherwise.
-
| | function Image (Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark)
return String;
|
-
Image returns the edited output String as defined in F.3.2 Edited Output Generation, for
Item, Pic_String(Pic), Blank_When_Zero(Pic), Currency, Fill, Separator,
and Radix_Mark. If these rules identify a layout error, then Image
raises the exception Layout_Error.
-
| | procedure Put (File : in File_Type;
Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark);
procedure Put (Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark);
|
-
Each of these Put procedures outputs Image(Item, Pic, Currency, Fill,
Separator, Radix_Mark) consistent with the conventions for Put for other
real types in case of bounded line length, see "Get and Put Procedures".
-
| | procedure Put (To : out String;
Item : in Num;
Pic : in Picture;
Currency : in String := Default_Currency;
Fill : in Character := Default_Fill;
Separator : in Character := Default_Separator;
Radix_Mark : in Character := Default_Radix_Mark);
|
-
Put copies Image(Item, Pic, Currency, Fill, Separator, Radix_Mark) to
the given string, right justified. Otherwise unassigned Character values
in To are assigned the space character. If To'Length is less than the
length of the string resulting from Image, then Layout_Error is raised.
Implementation Requirements
-
Max_Picture_Length shall be at least 30. The implementation shall
support currency strings of length up to at least 10, both for
Default_Currency in an instantiation of Decimal_Output, and for Currency
in an invocation of Image or any of the Put procedures.
NOTES
-
(4) The rules for edited output are based on COBOL (ANSI X3.23:1985,
endorsed by ISO as ISO 1989-1985), with the following differences:
-
The COBOL provisions for picture string localization and for 'P' format
are absent from Ada.
-
The following Ada facilities are not in COBOL:
-
currency symbol placement after the number,
-
localization of edited output string for multi-character currency string
values, including support for both length-preserving and
length-expanding currency symbols in picture strings
-
localization of the radix mark, digits separator, and
fill character, and
-
parenthesization of negative values.
The value of 30 for Max_Picture_Length is the same limit as in COBOL.
F.3.4 The Package Wide_Text_IO.Editing
Static Semantics
-
The child package Wide_Text_IO.Editing has the same contents as
Text_IO.Editing, except that:
-
each occurrence of Character is replaced by Wide_Character,
-
each occurrence of Text_IO is replaced by Wide_Text_IO,
-
the subtype of Default_Currency is Wide_String rather than String, and
-
each occurrence of String in the generic package Decimal_Output is
replaced by Wide_String.
NOTES
-
(5) Each of the functions Wide_Text_IO.Editing.Valid, To_Picture, and
Pic_String has String (versus Wide_String) as its parameter or result
subtype, since a picture String is not localizable.
G. Numerics (normative)
-
The Numerics Annex specifies
-
features for complex arithmetic, including complex I/O;
-
a mode ("strict mode"), in which the predefined arithmetic operations
of floating point and fixed point types and the functions and operations
of various predefined packages have to provide guaranteed accuracy or
conform to other numeric performance requirements, which the Numerics
Annex also specifies;
-
a mode ("relaxed mode"), in which no accuracy or other numeric
performance requirements need be satisfied, as for implementations not
conforming to the Numerics Annex;
-
models of floating point and fixed point arithmetic on which the
accuracy requirements of strict mode are based; and
-
the definitions of the model-oriented attributes of floating point types
that apply in the strict mode.
Implementation Advice
-
If Fortran (respectively, C) is widely supported in the target
environment, implementations supporting the Numerics Annex should
provide the child package Interfaces.Fortran (respectively,
Interfaces.C) specified in Annex B and should support a
convention_identifier of Fortran (respectively, C) in the interfacing
pragmas, see "Annex B", thus allowing Ada programs to interface
with programs written in that language.
--- The Detailed Node Listing ---
G.1 Complex Arithmetic
-
Types and arithmetic operations for complex arithmetic are provided in
Generic_Complex_Types, which is defined in G.1.1 Complex Types.
Implementation-defined approximations to the complex analogs of the
mathematical functions known as the "elementary functions" are
provided by the subprograms in Generic_Complex_Elementary_Functions,
which is defined in G.1.2 Complex Elementary Functions. Both of these library units are
generic children of the predefined package Numerics, see A.5 The Numerics Packages.
Nongeneric equivalents of these generic packages for each of the
predefined floating point types are also provided as children of
Numerics.
G.1.1 Complex Types
Static Semantics
-
The generic library package Numerics.Generic_Complex_Types has the
following declaration:
-
| | generic
type Real is digits <>;
package Ada.Numerics.Generic_Complex_Types is
pragma Pure(Generic_Complex_Types);
|
-
| | type Complex is
record
Re, Im : Real'Base;
end record;
|
-
| | type Imaginary is private;
|
-
| | i : constant Imaginary;
j : constant Imaginary;
|
-
| | function Re (X : Complex) return Real'Base;
function Im (X : Complex) return Real'Base;
function Im (X : Imaginary) return Real'Base;
|
-
| | procedure Set_Re (X : in out Complex;
Re : in Real'Base);
procedure Set_Im (X : in out Complex;
Im : in Real'Base);
procedure Set_Im (X : out Imaginary;
Im : in Real'Base);
|
-
| | function Compose_From_Cartesian (Re, Im : Real'Base)
return Complex;
function Compose_From_Cartesian (Re : Real'Base)
return Complex;
function Compose_From_Cartesian (Im : Imaginary)
return Complex;
|
-
| | function Modulus (X : Complex) return Real'Base;
function "abs" (Right : Complex) return Real'Base
renames Modulus;
|
-
| | function Argument (X : Complex) return Real'Base;
function Argument (X : Complex;
Cycle : Real'Base) return Real'Base;
|
-
| | function Compose_From_Polar
(Modulus, Argument : Real'Base)
return Complex;
function Compose_From_Polar
(Modulus, Argument, Cycle : Real'Base)
return Complex;
|
-
| | function "+" (Right : Complex) return Complex;
function "-" (Right : Complex) return Complex;
function Conjugate (X : Complex) return Complex;
|
-
| | function "+" (Left, Right : Complex) return Complex;
function "-" (Left, Right : Complex) return Complex;
function "*" (Left, Right : Complex) return Complex;
function "/" (Left, Right : Complex) return Complex;
|
-
| | function "**" (Left : Complex; Right : Integer) return Complex;
|
-
| | function "+" (Right : Imaginary) return Imaginary;
function "-" (Right : Imaginary) return Imaginary;
function Conjugate (X : Imaginary) return Imaginary
renames "-";
function "abs" (Right : Imaginary) return Real'Base;
|
-
| | function "+" (Left, Right : Imaginary) return Imaginary;
function "-" (Left, Right : Imaginary) return Imaginary;
function "*" (Left, Right : Imaginary) return Real'Base;
function "/" (Left, Right : Imaginary) return Real'Base;
|
-
| | function "**" (Left : Imaginary; Right : Integer) return Complex;
|
-
| | function "<" (Left, Right : Imaginary) return Boolean;
function "<=" (Left, Right : Imaginary) return Boolean;
function ">" (Left, Right : Imaginary) return Boolean;
function ">=" (Left, Right : Imaginary) return Boolean;
|
-
| | function "+" (Left : Complex;
Right : Real'Base) return Complex;
function "+" (Left : Real'Base;
Right : Complex) return Complex;
function "-" (Left : Complex;
Right : Real'Base) return Complex;
function "-" (Left : Real'Base;
Right : Complex) return Complex;
function "*" (Left : Complex;
Right : Real'Base) return Complex;
function "*" (Left : Real'Base;
Right : Complex) return Complex;
function "/" (Left : Complex;
Right : Real'Base) return Complex;
function "/" (Left : Real'Base;
Right : Complex) return Complex;
|
-
| | function "+" (Left : Complex;
Right : Imaginary) return Complex;
function "+" (Left : Imaginary;
Right : Complex) return Complex;
function "-" (Left : Complex;
Right : Imaginary) return Complex;
function "-" (Left : Imaginary;
Right : Complex) return Complex;
function "*" (Left : Complex;
Right : Imaginary) return Complex;
function "*" (Left : Imaginary;
Right : Complex) return Complex;
function "/" (Left : Complex;
Right : Imaginary) return Complex;
function "/" (Left : Imaginary;
Right : Complex) return Complex;
|
-
| | function "+" (Left : Imaginary;
Right : Real'Base) return Complex;
function "+" (Left : Real'Base;
Right : Imaginary) return Complex;
function "-" (Left : Imaginary;
Right : Real'Base) return Complex;
function "-" (Left : Real'Base;
Right : Imaginary) return Complex;
function "*" (Left : Imaginary;
Right : Real'Base) return Imaginary;
function "*" (Left : Real'Base;
Right : Imaginary) return Imaginary;
function "/" (Left : Imaginary;
Right : Real'Base) return Imaginary;
function "/" (Left : Real'Base;
Right : Imaginary) return Imaginary;
|
-
-
| | type Imaginary is new Real'Base;
i : constant Imaginary := 1.0;
j : constant Imaginary := 1.0;
|
-
| | end Ada.Numerics.Generic_Complex_Types;
|
-
The library package Numerics.Complex_Types defines the same types,
constants, and subprograms as Numerics.Generic_Complex_Types, except
that the predefined type Float is systematically substituted for
Real'Base throughout. Nongeneric equivalents of
Numerics.Generic_Complex_Types for each of the other predefined floating
point types are defined similarly, with the names
Numerics.Short_Complex_Types, Numerics.Long_Complex_Types, etc.
-
Complex is a visible type with cartesian components.
-
Imaginary is a private type; its full type is derived from Real'Base.
-
The arithmetic operations and the Re, Im, Modulus, Argument, and
Conjugate functions have their usual mathematical meanings. When applied
to a parameter of pure-imaginary type, the "imaginary-part" function
Im yields the value of its parameter, as the corresponding real value.
The remaining subprograms have the following meanings:
-
The Set_Re and Set_Im procedures replace the designated component of a
complex parameter with the given real value; applied to a parameter of
pure-imaginary type, the Set_Im procedure replaces the value of that
parameter with the imaginary value corresponding to the given real
value.
-
The Compose_From_Cartesian function constructs a complex value from the
given real and imaginary components. If only one component is given, the
other component is implicitly zero.
-
The Compose_From_Polar function constructs a complex value from the
given modulus (radius) and argument (angle). When the value of the
parameter Modulus is positive (resp., negative), the result is the
complex value represented by the point in the complex plane lying at a
distance from the origin given by the absolute value of Modulus and
forming an angle measured counterclockwise from the positive (resp.,
negative) real axis given by the value of the parameter Argument.
-
When the Cycle parameter is specified, the result of the Argument
function and the parameter Argument of the Compose_From_Polar function
are measured in units such that a full cycle of revolution has the given
value; otherwise, they are measured in radians.
-
The computed results of the mathematically multivalued functions are
rendered single-valued by the following conventions, which are meant to
imply the principal branch:
-
The result of the Modulus function is nonnegative.
-
The result of the Argument function is in the quadrant containing the
point in the complex plane represented by the parameter X. This may be
any quadrant (I through IV); thus, the range of the Argument function is
approximately -Pi to Pi (-Cycle/2.0 to Cycle/2.0, if the parameter Cycle
is specified). When the point represented by the parameter X lies on the
negative real axis, the result approximates
-
Pi (resp., -Pi) when the sign of the imaginary component of X is
positive (resp., negative), if Real'Signed_Zeros is True;
-
Pi, if Real'Signed_Zeros is False.
-
Because a result lying on or near one of the axes may not be exactly
representable, the approximation inherent in computing the result may
place it in an adjacent quadrant, close to but on the wrong side of the
axis.
Dynamic Semantics
-
The exception Numerics.Argument_Error is raised by the Argument and
Compose_From_Polar functions with specified cycle, signaling a parameter
value outside the domain of the corresponding mathematical function,
when the value of the parameter Cycle is zero or negative.
-
The exception Constraint_Error is raised by the division operator when
the value of the right operand is zero, and by the exponentiation
operator when the value of the left operand is zero and the value of the
exponent is negative, provided that Real'Machine_Overflows is True; when
Real'Machine_Overflows is False, the result is unspecified.
Constraint_Error can also be raised when a finite result overflows
(see section G.2.6 Accuracy Requirements for Complex Arithmetic).
Implementation Requirements
-
In the implementation of Numerics.Generic_Complex_Types, the range of
intermediate values allowed during the calculation of a final result
shall not be affected by any range constraint of the subtype Real.
-
In the following cases, evaluation of a complex arithmetic operation
shall yield the prescribed result, provided that the preceding rules do
not call for an exception to be raised:
-
The results of the Re, Im, and Compose_From_Cartesian functions are
exact.
-
The real (resp., imaginary) component of the result of a binary addition
operator that yields a result of complex type is exact when either of
its operands is of pure-imaginary (resp., real) type.
-
The real (resp., imaginary) component of the result of a binary
subtraction operator that yields a result of complex type is exact when
its right operand is of pure-imaginary (resp., real) type.
-
The real component of the result of the Conjugate function for the
complex type is exact.
-
When the point in the complex plane represented by the parameter X lies
on the nonnegative real axis, the Argument function yields a result of
zero.
-
When the value of the parameter Modulus is zero, the Compose_From_Polar
function yields a result of zero.
-
When the value of the parameter Argument is equal to a multiple of the
quarter cycle, the result of the Compose_From_Polar function with
specified cycle lies on one of the axes. In this case, one of its
components is zero, and the other has the magnitude of the parameter
Modulus.
-
Exponentiation by a zero exponent yields the value one. Exponentiation
by a unit exponent yields the value of the left operand. Exponentiation
of the value one yields the value one. Exponentiation of the value zero
yields the value zero, provided that the exponent is nonzero. When the
left operand is of pure-imaginary type, one component of the result of
the exponentiation operator is zero.
-
When the result, or a result component, of any operator of
Numerics.Generic_Complex_Types has a mathematical definition in terms of
a single arithmetic or relational operation, that result or result
component exhibits the accuracy of the corresponding operation of the
type Real.
-
Other accuracy requirements for the Modulus, Argument, and
Compose_From_Polar functions, and accuracy requirements for the
multiplication of a pair of complex operands or for division by a
complex operand, all of which apply only in the strict mode, are given
in G.2.6 Accuracy Requirements for Complex Arithmetic.
-
The sign of a zero result or zero result component yielded by a complex
arithmetic operation or function is implementation defined when
Real'Signed_Zeros is True.
Implementation Permissions
-
The nongeneric equivalent packages may, but need not, be actual
instantiations of the generic package for the appropriate predefined
type.
-
Implementations may obtain the result of exponentiation of a complex or
pure-imaginary operand by repeated complex multiplication, with
arbitrary association of the factors and with a possible final complex
reciprocation (when the exponent is negative). Implementations are also
permitted to obtain the result of exponentiation of a complex operand,
but not of a pure-imaginary operand, by converting the left operand to a
polar representation; exponentiating the modulus by the given exponent;
multiplying the argument by the given exponent, when the exponent is
positive, or dividing the argument by the absolute value of the given
exponent, when the exponent is negative; and reconverting to a cartesian
representation. Because of this implementation freedom, no accuracy
requirement is imposed on complex exponentiation (except for the
prescribed results given above, which apply regardless of the
implementation method chosen).
Implementation Advice
-
Because the usual mathematical meaning of multiplication of a complex
operand and a real operand is that of the scaling of both components of
the former by the latter, an implementation should not perform this
operation by first promoting the real operand to complex type and then
performing a full complex multiplication. In systems that, in the
future, support an Ada binding to IEC 559:1989, the latter technique
will not generate the required result when one of the components of the
complex operand is infinite. (Explicit multiplication of the infinite
component by the zero component obtained during promotion yields a NaN
that propagates into the final result.) Analogous advice applies in the
case of multiplication of a complex operand and a pure-imaginary
operand, and in the case of division of a complex operand by a real or
pure-imaginary operand.
-
Likewise, because the usual mathematical meaning of addition of a
complex operand and a real operand is that the imaginary operand remains
unchanged, an implementation should not perform this operation by first
promoting the real operand to complex type and then performing a full
complex addition. In implementations in which the Signed_Zeros attribute
of the component type is True (and which therefore conform to IEC
559:1989 in regard to the handling of the sign of zero in predefined
arithmetic operations), the latter technique will not generate the
required result when the imaginary component of the complex operand is a
negatively signed zero. (Explicit addition of the negative zero to the
zero obtained during promotion yields a positive zero.) Analogous
advice applies in the case of addition of a complex operand and a
pure-imaginary operand, and in the case of subtraction of a complex
operand and a real or pure-imaginary operand.
-
Implementations in which Real'Signed_Zeros is True should attempt to
provide a rational treatment of the signs of zero results and result
components. As one example, the result of the Argument function should
have the sign of the imaginary component of the parameter X when the
point represented by that parameter lies on the positive real axis; as
another, the sign of the imaginary component of the Compose_From_Polar
function should be the same as (resp., the opposite of) that of the
Argument parameter when that parameter has a value of zero and the
Modulus parameter has a nonnegative (resp., negative) value.
G.1.2 Complex Elementary Functions
Static Semantics
-
The generic library package
Numerics.Generic_Complex_Elementary_Functions has the following
declaration:
-
| | with Ada.Numerics.Generic_Complex_Types;
generic
with package Complex_Types is new
Ada.Numerics.Generic_Complex_Types (<>);
use Complex_Types;
package Ada.Numerics.Generic_Complex_Elementary_Functions is
pragma Pure(Generic_Complex_Elementary_Functions);
|
-
| | function Sqrt (X : Complex) return Complex;
function Log (X : Complex) return Complex;
function Exp (X : Complex) return Complex;
function Exp (X : Imaginary) return Complex;
function "**" (Left : Complex;
Right : Complex) return Complex;
function "**" (Left : Complex;
Right : Real'Base) return Complex;
function "**" (Left : Real'Base;
Right : Complex) return Complex;
|
-
| | function Sin (X : Complex) return Complex;
function Cos (X : Complex) return Complex;
function Tan (X : Complex) return Complex;
function Cot (X : Complex) return Complex;
|
-
| | function Arcsin (X : Complex) return Complex;
function Arccos (X : Complex) return Complex;
function Arctan (X : Complex) return Complex;
function Arccot (X : Complex) return Complex;
|
-
| | function Sinh (X : Complex) return Complex;
function Cosh (X : Complex) return Complex;
function Tanh (X : Complex) return Complex;
function Coth (X : Complex) return Complex;
|
-
| | function Arcsinh (X : Complex) return Complex;
function Arccosh (X : Complex) return Complex;
function Arctanh (X : Complex) return Complex;
function Arccoth (X : Complex) return Complex;
|
-
| | end Ada.Numerics.Generic_Complex_Elementary_Functions;
|
-
The library package Numerics.Complex_Elementary_Functions defines the
same subprograms as Numerics.Generic_Complex_Elementary_Functions,
except that the predefined type Float is systematically substituted for
Real'Base, and the Complex and Imaginary types exported by
Numerics.Complex_Types are systematically substituted for Complex and
Imaginary, throughout. Nongeneric equivalents of
Numerics.Generic_Complex_Elementary_Functions corresponding to each of
the other predefined floating point types are defined similarly, with
the names Numerics.Short_Complex_Elementary_Functions,
Numerics.Long_Complex_Elementary_Functions, etc.
-
The overloading of the Exp function for the pure-imaginary type is
provided to give the user an alternate way to compose a complex value
from a given modulus and argument. In addition to
Compose_From_Polar(Rho, Theta), see G.1.1 Complex Types, the programmer may write
Rho * Exp(i * Theta).
-
The imaginary (resp., real) component of the parameter X of the forward
hyperbolic (resp., trigonometric) functions and of the Exp function (and
the parameter X, itself, in the case of the overloading of the Exp
function for the pure-imaginary type) represents an angle measured in
radians, as does the imaginary (resp., real) component of the result of
the Log and inverse hyperbolic (resp., trigonometric) functions.
-
The functions have their usual mathematical meanings. However, the
arbitrariness inherent in the placement of branch cuts, across which
some of the complex elementary functions exhibit discontinuities, is
eliminated by the following conventions:
-
The imaginary component of the result of the Sqrt and Log functions is
discontinuous as the parameter X crosses the negative real axis.
-
The result of the exponentiation operator when the left operand is of
complex type is discontinuous as that operand crosses the negative real
axis.
-
The real (resp., imaginary) component of the result of the Arcsin and
Arccos (resp., Arctanh) functions is discontinuous as the parameter X
crosses the real axis to the left of -1.0 or the right of 1.0.
-
The real (resp., imaginary) component of the result of the Arctan
(resp., Arcsinh) function is discontinuous as the parameter X crosses
the imaginary axis below -i or above i.
-
The real component of the result of the Arccot function is discontinuous
as the parameter X crosses the imaginary axis between -i and i.
-
The imaginary component of the Arccosh function is discontinuous as the
parameter X crosses the real axis to the left of 1.0.
-
The imaginary component of the result of the Arccoth function is
discontinuous as the parameter X crosses the real axis between -1.0 and
1.0.
-
The computed results of the mathematically multivalued functions are
rendered single-valued by the following conventions, which are meant to
imply the principal branch:
-
The real component of the result of the Sqrt and Arccosh functions is
nonnegative.
-
The same convention applies to the imaginary component of the result of
the Log function as applies to the result of the natural-cycle version
of the Argument function of Numerics.Generic_Complex_Types
(see section G.1.1 Complex Types).
-
The range of the real (resp., imaginary) component of the result of the
Arcsin and Arctan (resp., Arcsinh and Arctanh) functions is
approximately -Pi/2.0 to Pi/2.0.
-
The real (resp., imaginary) component of the result of the Arccos and
Arccot (resp., Arccoth) functions ranges from 0.0 to approximately Pi.
-
The range of the imaginary component of the result of the Arccosh
function is approximately -Pi to Pi.
-
In addition, the exponentiation operator inherits the single-valuedness
of the Log function.
Dynamic Semantics
-
The exception Numerics.Argument_Error is raised by the exponentiation
operator, signaling a parameter value outside the domain of the
corresponding mathematical function, when the value of the left operand
is zero and the real component of the exponent (or the exponent itself,
when it is of real type) is zero.
-
The exception Constraint_Error is raised, signaling a pole of the
mathematical function (analogous to dividing by zero), in the following
cases, provided that Complex_Types.Real'Machine_Overflows is True:
-
by the Log, Cot, and Coth functions, when the value of the parameter X
is zero;
-
by the exponentiation operator, when the value of the left operand is
zero and the real component of the exponent (or the exponent itself,
when it is of real type) is negative;
-
by the Arctan and Arccot functions, when the value of the parameter X is
+/-i;
-
by the Arctanh and Arccoth functions, when the value of the parameter X
is +/-1.0.
-
Constraint_Error can also be raised when a finite result overflows
(see section G.2.6 Accuracy Requirements for Complex Arithmetic) this may occur for parameter values sufficiently near
poles, and, in the case of some of the functions, for parameter values
having components of sufficiently large magnitude. When
Complex_Types.Real'Machine_Overflows is False, the result at poles is
unspecified.
Implementation Requirements
-
In the implementation of Numerics.Generic_Complex_Elementary_Functions,
the range of intermediate values allowed during the calculation of a
final result shall not be affected by any range constraint of the
subtype Complex_Types.Real.
-
In the following cases, evaluation of a complex elementary function
shall yield the prescribed result (or a result having the prescribed
component), provided that the preceding rules do not call for an
exception to be raised:
-
When the parameter X has the value zero, the Sqrt, Sin, Arcsin, Tan,
Arctan, Sinh, Arcsinh, Tanh, and Arctanh functions yield a result of
zero; the Exp, Cos, and Cosh functions yield a result of one; the Arccos
and Arccot functions yield a real result; and the Arccoth function
yields an imaginary result.
-
When the parameter X has the value one, the Sqrt function yields a
result of one; the Log, Arccos, and Arccosh functions yield a result of
zero; and the Arcsin function yields a real result.
-
When the parameter X has the value -1.0, the Sqrt function yields the
result
-
i (resp., -i), when the sign of the imaginary component of X is positive
(resp., negative), if Complex_Types.Real'Signed_Zeros is True;
-
i, if Complex_Types.Real'Signed_Zeros is False;
-
the Log function yields an imaginary result; and the Arcsin and Arccos
functions yield a real result.
-
When the parameter X has the value +/-i, the Log function yields an
imaginary result.
-
Exponentiation by a zero exponent yields the value one. Exponentiation
by a unit exponent yields the value of the left operand (as a complex
value). Exponentiation of the value one yields the value one.
Exponentiation of the value zero yields the value zero.
-
Other accuracy requirements for the complex elementary functions, which
apply only in the strict mode, are given in G.2.6 Accuracy Requirements for Complex Arithmetic.
-
The sign of a zero result or zero result component yielded by a complex
elementary function is implementation defined when
Complex_Types.Real'Signed_Zeros is True.
Implementation Permissions
-
The nongeneric equivalent packages may, but need not, be actual
instantiations of the generic package with the appropriate predefined
nongeneric equivalent of Numerics.Generic_Complex_Types; if they are,
then the latter shall have been obtained by actual instantiation of
Numerics.Generic_Complex_Types.
-
The exponentiation operator may be implemented in terms of the Exp and
Log functions. Because this implementation yields poor accuracy in some
parts of the domain, no accuracy requirement is imposed on complex
exponentiation.
-
The implementation of the Exp function of a complex parameter X is
allowed to raise the exception Constraint_Error, signaling overflow,
when the real component of X exceeds an unspecified threshold that is
approximately log (Complex_Types.Real'Safe_Last). This permission
recognizes the impracticality of avoiding overflow in the marginal case
that the exponential of the real component of X exceeds the safe range
of Complex_Types.Real but both components of the final result do not.
Similarly, the Sin and Cos (resp., Sinh and Cosh) functions are allowed
to raise the exception Constraint_Error, signaling overflow, when the
absolute value of the imaginary (resp., real) component of the parameter
X exceeds an unspecified threshold that is approximately log
(Complex_Types.Real'Safe_Last)+log (2.0). This permission recognizes the
impracticality of avoiding overflow in the marginal case that the
hyperbolic sine or cosine of the imaginary (resp., real) component of X
exceeds the safe range of Complex_Types.Real but both components of the
final result do not.
Implementation Advice
-
Implementations in which Complex_Types.Real'Signed_Zeros is True should
attempt to provide a rational treatment of the signs of zero results and
result components. For example, many of the complex elementary functions
have components that are odd functions of one of the parameter
components; in these cases, the result component should have the sign of
the parameter component at the origin. Other complex elementary
functions have zero components whose sign is opposite that of a
parameter component at the origin, or is always positive or always
negative.
G.1.3 Complex Input-Output
-
The generic package Text_IO.Complex_IO defines procedures for the
formatted input and output of complex values. The generic actual
parameter in an instantiation of Text_IO.Complex_IO is an instance of
Numerics.Generic_Complex_Types for some floating point subtype.
Exceptional conditions are reported by raising the appropriate exception
defined in Text_IO.
Static Semantics
-
The generic library package Text_IO.Complex_IO has the following
declaration:
-
| | with Ada.Numerics.Generic_Complex_Types;
generic
with package Complex_Types is new
Ada.Numerics.Generic_Complex_Types (<>);
package Ada.Text_IO.Complex_IO is
|
-
-
| | Default_Fore : Field := 2;
Default_Aft : Field := Real'Digits - 1;
Default_Exp : Field := 3;
|
-
| | procedure Get (File : in File_Type;
Item : out Complex;
Width : in Field := 0);
procedure Get (Item : out Complex;
Width : in Field := 0);
|
-
| | procedure Put (File : in File_Type;
Item : in Complex;
Fore : in Field := Default_Fore;
Aft : in Field := Default_Aft;
Exp : in Field := Default_Exp);
procedure Put (Item : in Complex;
Fore : in Field := Default_Fore;
Aft : in Field := Default_Aft;
Exp : in Field := Default_Exp);
|
-
| | procedure Get (From : in String;
Item : out Complex;
Last : out Positive);
procedure Put (To : out String;
Item : in Complex;
Aft : in Field := Default_Aft;
Exp : in Field := Default_Exp);
|
-
| | end Ada.Text_IO.Complex_IO;
|
-
The semantics of the Get and Put procedures are as follows:
-
| | procedure Get (File : in File_Type;
Item : out Complex;
Width : in Field := 0);
procedure Get (Item : out Complex;
Width : in Field := 0);
|
-
The input sequence is a pair of optionally signed real literals
representing the real and imaginary components of a complex value;
optionally, the pair of components may be separated by a comma and/or
surrounded by a pair of parentheses. Blanks are freely allowed before
each of the components and before the parentheses and comma, if either
is used. If the value of the parameter Width is zero, then
-
line and page terminators are also allowed in these places;
-
the components shall be separated by at least one blank or line
terminator if the comma is omitted; and
-
reading stops when the right parenthesis has been read, if the input
sequence includes a left parenthesis, or when the imaginary component
has been read, otherwise.
If a nonzero value of Width is supplied, then
-
the components shall be separated by at least one blank if the comma is
omitted; and
-
exactly Width characters are read, or the characters (possibly none) up
to a line terminator, whichever comes first (blanks are included in the
count).
-
Returns, in the parameter Item, the value of type Complex that
corresponds to the input sequence.
-
The exception Text_IO.Data_Error is raised if the input sequence does
not have the required syntax or if the components of the complex value
obtained are not of the base subtype of Complex_Types.Real.
-
| | procedure Put (File : in File_Type;
Item : in Complex;
Fore : in Field := Default_Fore;
Aft : in Field := Default_Aft;
Exp : in Field := Default_Exp);
procedure Put (Item : in Complex;
Fore : in Field := Default_Fore;
Aft : in Field := Default_Aft;
Exp : in Field := Default_Exp);
|
-
Outputs the value of the parameter Item as a pair of decimal literals
representing the real and imaginary components of the complex value,
using the syntax of an aggregate. More specifically,
-
outputs a left parenthesis;
-
outputs the value of the real component of the parameter Item with the
format defined by the corresponding Put procedure of an instance of
Text_IO.Float_IO for the base subtype of Complex_Types.Real, using the
given values of Fore, Aft, and Exp;
-
outputs a comma;
-
outputs the value of the imaginary component of the parameter Item with
the format defined by the corresponding Put procedure of an instance of
Text_IO.Float_IO for the base subtype of Complex_Types.Real, using the
given values of Fore, Aft, and Exp;
-
outputs a right parenthesis.
-
| | procedure Get (From : in String;
Item : out Complex;
Last : out Positive);
|
-
Reads a complex value from the beginning of the given string, following
the same rule as the Get procedure that reads a complex value from a
file, but treating the end of the string as a line terminator. Returns,
in the parameter Item, the value of type Complex that corresponds to the
input sequence. Returns in Last the index value such that From(Last) is
the last character read.
-
The exception Text_IO.Data_Error is raised if the input sequence does
not have the required syntax or if the components of the complex value
obtained are not of the base subtype of Complex_Types.Real.
-
| | procedure Put (To : out String;
Item : in Complex;
Aft : in Field := Default_Aft;
Exp : in Field := Default_Exp);
|
-
Outputs the value of the parameter Item to the given string as a pair of
decimal literals representing the real and imaginary components of the
complex value, using the syntax of an aggregate. More specifically,
-
a left parenthesis, the real component, and a comma are left justified
in the given string, with the real component having the format defined
by the Put procedure (for output to a file) of an instance of
Text_IO.Float_IO for the base subtype of Complex_Types.Real, using a
value of zero for Fore and the given values of Aft and Exp;
-
the imaginary component and a right parenthesis are right justified in
the given string, with the imaginary component having the format defined
by the Put procedure (for output to a file) of an instance of
Text_IO.Float_IO for the base subtype of Complex_Types.Real, using a
value for Fore that completely fills the remainder of the string,
together with the given values of Aft and Exp.
-
The exception Text_IO.Layout_Error is raised if the given string is too
short to hold the formatted output.
Implementation Permissions
-
Other exceptions declared (by renaming) in Text_IO may be raised by the
preceding procedures in the appropriate circumstances, as for the
corresponding procedures of Text_IO.Float_IO.
G.1.4 The Package Wide_Text_IO.Complex_IO
Static Semantics
-
Implementations shall also provide the generic library package
Wide_Text_IO.Complex_IO. Its declaration is obtained from that of
Text_IO.Complex_IO by systematically replacing Text_IO by Wide_Text_IO
and String by Wide_String; the description of its behavior is obtained
by additionally replacing references to particular characters (commas,
parentheses, etc.) by those for the corresponding wide characters.
G.2 Numeric Performance Requirements
Implementation Requirements
-
Implementations shall provide a user-selectable mode in which the
accuracy and other numeric performance requirements detailed in the
following subclauses are observed. This mode, referred to as the strict
mode, may or may not be the default mode; it directly affects the
results of the predefined arithmetic operations of real types and the
results of the subprograms in children of the Numerics package, and
indirectly affects the operations in other language defined packages.
Implementations shall also provide the opposing mode, which is known as
the relaxed mode.
Implementation Permissions
-
Either mode may be the default mode.
-
The two modes need not actually be different.
G.2.1 Model of Floating Point Arithmetic
-
In the strict mode, the predefined operations of a floating point type
shall satisfy the accuracy requirements specified here and shall avoid
or signal overflow in the situations described. This behavior is
presented in terms of a model of floating point arithmetic that builds
on the concept of the canonical form, see A.5.3 Attributes of Floating Point Types.
Static Semantics
-
Associated with each floating point type is an infinite set of model
numbers. The model numbers of a type are used to define the accuracy
requirements that have to be satisfied by certain predefined operations
of the type; through certain attributes of the model numbers, they are
also used to explain the meaning of a user-declared floating point type
declaration. The model numbers of a derived type are those of the parent
type; the model numbers of a subtype are those of its type.
-
The model numbers of a floating point type T are zero and all the values
expressible in the canonical form (for the type T), in which mantissa
has T'Model_Mantissa digits and exponent has a value greater than or
equal to T'Model_Emin. (These attributes are defined in G.2.2 Model-Oriented Attributes of Floating Point Types.)
-
A model interval of a floating point type is any interval whose bounds
are model numbers of the type. The model interval of a type T associated
with a value v is the smallest model interval of T that includes v. (The
model interval associated with a model number of a type consists of that
number only.)
Implementation Requirements
-
The accuracy requirements for the evaluation of certain predefined
operations of floating point types are as follows.
-
An operand interval is the model interval, of the type specified for the
operand of an operation, associated with the value of the operand.
-
For any predefined arithmetic operation that yields a result of a
floating point type T, the required bounds on the result are given by a
model interval of T (called the result interval) defined in terms of the
operand values as follows:
-
The result interval is the smallest model interval of T that includes
the minimum and the maximum of all the values obtained by applying the
(exact) mathematical operation to values arbitrarily selected from the
respective operand intervals.
-
The result interval of an exponentiation is obtained by applying the
above rule to the sequence of multiplications defined by the exponent,
assuming arbitrary association of the factors, and to the final division
in the case of a negative exponent.
-
The result interval of a conversion of a numeric value to a floating
point type T is the model interval of T associated with the operand
value, except when the source expression is of a fixed point type with a
small that is not a power of T'Machine_Radix or is a fixed point
multiplication or division either of whose operands has a small that is
not a power of T'Machine_Radix; in these cases, the result interval is
implementation defined.
-
For any of the foregoing operations, the implementation shall deliver a
value that belongs to the result interval when both bounds of the result
interval are in the safe range of the result type T, as determined by
the values of T'Safe_First and T'Safe_Last; otherwise,
-
if T'Machine_Overflows is True, the implementation shall either deliver
a value that belongs to the result interval or raise Constraint_Error;
-
if T'Machine_Overflows is False, the result is implementation defined.
-
For any predefined relation on operands of a floating point type T, the
implementation may deliver any value (i.e., either True or False)
obtained by applying the (exact) mathematical comparison to values
arbitrarily chosen from the respective operand intervals.
-
The result of a membership test is defined in terms of comparisons of
the operand value with the lower and upper bounds of the given range or
type mark (the usual rules apply to these comparisons).
Implementation Permissions
-
If the underlying floating point hardware implements division as
multiplication by a reciprocal, the result interval for division (and
exponentiation by a negative exponent) is implementation defined.
G.2.2 Model-Oriented Attributes of Floating Point Types
-
In implementations that support the Numerics Annex, the model-oriented
attributes of floating point types shall yield the values defined here,
in both the strict and the relaxed modes. These definitions add
conditions to those in A.5.3 Attributes of Floating Point Types.
Static Semantics
-
For every subtype S of a floating point type T:
-
S'Model_Mantissa
| | Yields the number of digits in the mantissa of the
canonical form of the model numbers of T, see A.5.3 Attributes of Floating Point Types.
The value of this attribute shall be greater than or
equal to Ceiling(d*log (10)/log (T'Machine_Radix))+1,
where d is the requested decimal precision of T. In
addition, it shall be less than or equal to the value of
T'Machine_Mantissa. This attribute yields a value of the
type universal_integer.
|
-
S'Model_Emin
| | Yields the minimum exponent of the canonical form of the model
numbers of T, see A.5.3 Attributes of Floating Point Types. The value of this attribute shall
be greater than or equal to the value of T'Machine_Emin. This
attribute yields a value of the type universal_integer.
|
-
S'Safe_First
| | Yields the lower bound of the safe range of T. The value of
this attribute shall be a model number of T and greater than
or equal to the lower bound of the base range of T. In
addition, if T is declared by a floating_point_definition or
is derived from such a type, and the
floating_point_definition includes a real_range_specification
specifying a lower bound of lb, then the value of this
attribute shall be less than or equal to lb; otherwise, it
shall be less than or equal to -10.0 ** (4*d), where d is the
requested decimal precision of T. This attribute yields a
value of the type universal_real.
|
-
S'Safe_Last
| | Yields the upper bound of the safe range of T. The value of
this attribute shall be a model number of T and less than or
equal to the upper bound of the base range of T. In
addition, if T is declared by a floating_point_definition or
is derived from such a type, and the floating_point_definition
includes a real_range_specification specifying an
upper bound of ub, then the value of this attribute shall be
greater than or equal to ub; otherwise, it shall be greater
than or equal to 10.0 ** (4*d), where d is the requested
decimal precision of T. This attribute yields a value of the
type universal_real.
|
-
S'Model
| | Denotes a function (of a parameter X) whose specification is
given in A.5.3 Attributes of Floating Point Types. If X is a model number of T, the
function yields X; otherwise, it yields the value obtained by
rounding or truncating X to either one of the adjacent model
numbers of T. Constraint_Error is raised if the resulting model
number is outside the safe range of S. A zero result has the
sign of X when S'Signed_Zeros is True.
|
-
Subject to the constraints given above, the values of S'Model_Mantissa
and S'Safe_Last are to be maximized, and the values of S'Model_Emin and
S'Safe_First minimized, by the implementation as follows:
-
First, S'Model_Mantissa is set to the largest value for which values of
S'Model_Emin, S'Safe_First, and S'Safe_Last can be chosen so that the
implementation satisfies the strict-mode requirements of G.2.1 Model of Floating Point Arithmetic,
in terms of the model numbers and safe range induced by these
attributes.
-
Next, S'Model_Emin is set to the smallest value for which values of
S'Safe_First and S'Safe_Last can be chosen so that the implementation
satisfies the strict-mode requirements of G.2.1 Model of Floating Point Arithmetic, in terms of the
model numbers and safe range induced by these attributes and the
previously determined value of S'Model_Mantissa.
-
Finally, S'Safe_First and S'Safe_last are set (in either order) to the
smallest and largest values, respectively, for which the implementation
satisfies the strict-mode requirements of G.2.1 Model of Floating Point Arithmetic, in terms of the
model numbers and safe range induced by these attributes and the
previously determined values of S'Model_Mantissa and S'Model_Emin.
G.2.3 Model of Fixed Point Arithmetic
-
In the strict mode, the predefined arithmetic operations of a fixed
point type shall satisfy the accuracy requirements specified here and
shall avoid or signal overflow in the situations described.
Implementation Requirements
-
The accuracy requirements for the predefined fixed point arithmetic
operations and conversions, and the results of relations on fixed point
operands, are given below.
-
The operands of the fixed point adding operators, absolute value, and
comparisons have the same type. These operations are required to yield
exact results, unless they overflow.
-
Multiplications and divisions are allowed between operands of any two
fixed point types; the result has to be (implicitly or explicitly)
converted to some other numeric type. For purposes of defining the
accuracy rules, the multiplication or division and the conversion are
treated as a single operation whose accuracy depends on three types
(those of the operands and the result). For decimal fixed point types,
the attribute T'Round may be used to imply explicit conversion with
rounding, see 4.5.10 Operations of Fixed Point Types.
-
When the result type is a floating point type, the accuracy is as given
in G.2.1 Model of Floating Point Arithmetic. For some combinations of the operand and result types
in the remaining cases, the result is required to belong to a small set
of values called the perfect result set; for other combinations, it is
required merely to belong to a generally larger and
implementation-defined set of values called the close result set. When
the result type is a decimal fixed point type, the perfect result set
contains a single value; thus, operations on decimal types are always
fully specified.
-
When one operand of a fixed-fixed multiplication or division is of type
universal_real, that operand is not implicitly converted in the usual
sense, since the context does not determine a unique target type, but
the accuracy of the result of the multiplication or division (i.e.,
whether the result has to belong to the perfect result set or merely the
close result set) depends on the value of the operand of type
universal_real and on the types of the other operand and of the result.
-
For a fixed point multiplication or division whose (exact) mathematical
result is v, and for the conversion of a value v to a fixed point type,
the perfect result set and close result set are defined as follows:
-
If the result type is an ordinary fixed point type with a small of s,
-
if v is an integer multiple of s, then the perfect result set contains
only the value v;
-
otherwise, it contains the integer multiple of s just below v and the
integer multiple of s just above v.
-
The close result set is an implementation-defined set of consecutive
integer multiples of s containing the perfect result set as a subset.
-
If the result type is a decimal type with a small of s,
-
if v is an integer multiple of s, then the perfect result set contains
only the value v;
-
otherwise, if truncation applies then it contains only the integer
multiple of s in the direction toward zero, whereas if rounding applies
then it contains only the nearest integer multiple of s (with ties
broken by rounding away from zero).
-
The close result set is an implementation-defined set of consecutive
integer multiples of s containing the perfect result set as a subset.
-
If the result type is an integer type,
-
if v is an integer, then the perfect result set contains only the value
v;
-
otherwise, it contains the integer nearest to the value v (if v lies
equally distant from two consecutive integers, the perfect result set
contains the one that is further from zero).
-
The close result set is an implementation-defined set of consecutive
integers containing the perfect result set as a subset.
-
The result of a fixed point multiplication or division shall belong
either to the perfect result set or to the close result set, as
described below, if overflow does not occur. In the following cases, if
the result type is a fixed point type, let s be its small; otherwise,
i.e. when the result type is an integer type, let s be 1.0.
-
For a multiplication or division neither of whose operands is of type
universal_real, let l and r be the smalls of the left and right
operands. For a multiplication, if (l*r)/s is an integer or the
reciprocal of an integer (the smalls are said to be "compatible" in
this case), the result shall belong to the perfect result set;
otherwise, it belongs to the close result set. For a division, if
l/(r*s) is an integer or the reciprocal of an integer (i.e., the smalls
are compatible), the result shall belong to the perfect result set;
otherwise, it belongs to the close result set.
-
For a multiplication or division having one universal_real operand with
a value of v, note that it is always possible to factor v as an integer
multiple of a "compatible" small, but the integer multiple may be
"too big." If there exists a factorization in which that multiple is
less than some implementation-defined limit, the result shall belong to
the perfect result set; otherwise, it belongs to the close result set.
-
A multiplication P * Q of an operand of a fixed point type F by an
operand of an integer type I, or vice-versa, and a division P / Q of an
operand of a fixed point type F by an operand of an integer type I, are
also allowed. In these cases, the result has a type of F; explicit
conversion of the result is never required. The accuracy required in
these cases is the same as that required for a multiplication F(P * Q)
or a division F(P / Q) obtained by interpreting the operand of the
integer type to have a fixed point type with a small of 1.0.
-
The accuracy of the result of a conversion from an integer or fixed
point type to a fixed point type, or from a fixed point type to an
integer type, is the same as that of a fixed point multiplication of the
source value by a fixed point operand having a small of 1.0 and a value
of 1.0, as given by the foregoing rules. The result of a conversion from
a floating point type to a fixed point type shall belong to the close
result set. The result of a conversion of a universal_real operand to a
fixed point type shall belong to the perfect result set.
-
The possibility of overflow in the result of a predefined arithmetic
operation or conversion yielding a result of a fixed point type T is
analogous to that for floating point types, except for being related to
the base range instead of the safe range. If all of the permitted
results belong to the base range of T, then the implementation shall
deliver one of the permitted results; otherwise,
-
if T'Machine_Overflows is True, the implementation shall either deliver
one of the permitted results or raise Constraint_Error;
-
if T'Machine_Overflows is False, the result is implementation defined.
G.2.4 Accuracy Requirements for the Elementary Functions
-
In the strict mode, the performance of
Numerics.Generic_Elementary_Functions shall be as specified here.
Implementation Requirements
-
When an exception is not raised, the result of evaluating a function in
an instance EF of Numerics.Generic_Elementary_Functions belongs to a
result interval, defined as the smallest model interval of EF.Float_Type
that contains all the values of the form f*(1.0+d), where f is the exact
value of the corresponding mathematical function at the given parameter
values, d is a real number, and |d| is less than or equal to the
function's maximum relative error. The function delivers a value that
belongs to the result interval when both of its bounds belong to the
safe range of EF.Float_Type; otherwise,
-
if EF.Float_Type'Machine_Overflows is True, the function either delivers
a value that belongs to the result interval or raises Constraint_Error,
signaling overflow;
-
if EF.Float_Type'Machine_Overflows is False, the result is
implementation defined.
-
The maximum relative error exhibited by each function is as follows:
-
2.0*EF.Float_Type'Model_Epsilon, in the case of the Sqrt, Sin, and Cos
functions;
-
4.0*EF.Float_Type'Model_Epsilon, in the case of the Log, Exp, Tan, Cot,
and inverse trigonometric functions; and
-
8.0*EF.Float_Type'Model_Epsilon, in the case of the forward and inverse
hyperbolic functions.
-
The maximum relative error exhibited by the exponentiation operator,
which depends on the values of the operands, is (4.0+|Right*log
(Left)|/32.0)*EF.Float_Type'Model_Epsilon.
-
The maximum relative error given above applies throughout the domain of
the forward trigonometric functions when the Cycle parameter is
specified. When the Cycle parameter is omitted, the maximum relative
error given above applies only when the absolute value of the angle
parameter X is less than or equal to some implementation-defined angle
threshold, which shall be at least EF.Float_Type'Machine_Radix **
Floor(EF.Float_Type'Machine_Mantissa/2). Beyond the angle threshold, the
accuracy of the forward trigonometric functions is implementation
defined.
-
The prescribed results specified in A.5.1 Elementary Functions, for certain functions
at particular parameter values take precedence over the maximum relative
error bounds; effectively, they narrow to a single value the result
interval allowed by the maximum relative error bounds. Additional rules
with a similar effect are given by the table below for the inverse
trigonometric functions, at particular parameter values for which the
mathematical result is possibly not a model number of EF.Float_Type (or
is, indeed, even transcendental). In each table entry, the values of the
parameters are such that the result lies on the axis between two
quadrants; the corresponding accuracy rule, which takes precedence over
the maximum relative error bounds, is that the result interval is the
model interval of EF.Float_Type associated with the exact mathematical
result given in the table.
-
| | +--------------------------------------------------------------+
| |
| Tightly Approximated Elementary Function Results |
| |
+-----------------+----------+----------+------------+-------- +
| | | | | |
| | | | Exact | Exact |
| | | | Result | Result |
| | Value of | Value of | when Cycle | when |
| Function | X | Y | Specified | Cycle |
| | | | | Omitted |
| | | | | |
+-----------------+----------+----------+------------+---------+
| | | | | |
| Arcsin | 1.0 | n.a. | Cycle/4.0 | Pi/2.0 |
| | | | | |
| Arcsin | -1.0 | n.a. | -Cycle/4.0 | -Pi/2.0 |
| | | | | |
| Arccos | 0.0 | n.a. | Cycle/4.0 | Pi/2.0 |
| | | | | |
| Arccos | -1.0 | n.a. | Cycle/2.0 | Pi |
| | | | | |
| Arctan & Arccot | 0.0 | positive | Cycle/4.0 | Pi/2.0 |
| | | | | |
| Arctan & Arccot | 0.0 | negative | -Cycle/4.0 | -Pi/2.0 |
| | | | | |
| Arctan & Arccot | negative | +0.0 | Cycle/2.0 | Pi |
| | | | | |
| Arctan & Arccot | negative | -0.0 | -Cycle/2.0 | -Pi |
| | | | | |
| Arctan & Arccot | negative | 0.0 | Cycle/2.0 | Pi |
| | | | | |
+-----------------+----------+----------+------------+---------+
|
-
The last line of the table is meant to apply when EF.Float_Type'Signed_
Zeros is False; the two lines just above it, when
EF.Float_Type'Signed_Zeros is True and the parameter Y has a zero value
with the indicated sign.
-
The amount by which the result of an inverse trigonometric function is
allowed to spill over into a quadrant adjacent to the one corresponding
to the principal branch, as given in A.5.1 Elementary Functions, is limited. The rule
is that the result belongs to the smallest model interval of
EF.Float_Type that contains both boundaries of the quadrant
corresponding to the principal branch. This rule also takes precedence
over the maximum relative error bounds, effectively narrowing the result
interval allowed by them.
-
Finally, the following specifications also take precedence over the
maximum relative error bounds:
-
The absolute value of the result of the Sin, Cos, and Tanh functions
never exceeds one.
-
The absolute value of the result of the Coth function is never less than
one.
-
The result of the Cosh function is never less than one.
Implementation Advice
-
The versions of the forward trigonometric functions without a Cycle
parameter should not be implemented by calling the corresponding version
with a Cycle parameter of 2.0*Numerics.Pi, since this will not provide
the required accuracy in some portions of the domain. For the same
reason, the version of Log without a Base parameter should not be
implemented by calling the corresponding version with a Base parameter
of Numerics.e.
G.2.5 Performance Requirements for Random Number Generation
-
In the strict mode, the performance of Numerics.Float_Random and
Numerics.Discrete_Random shall be as specified here.
Implementation Requirements
-
Two different calls to the time-dependent Reset procedure shall reset
the generator to different states, provided that the calls are separated
in time by at least one second and not more than fifty years.
-
The implementation's representations of generator states and its
algorithms for generating random numbers shall yield a period of at
least 2**31-2; much longer periods are desirable but not required.
-
The implementations of Numerics.Float_Random.Random and
Numerics.Discrete_Random.Random shall pass at least 85% of the
individual trials in a suite of statistical tests. For
Numerics.Float_Random, the tests are applied directly to the floating
point values generated (i.e., they are not converted to integers first),
while for Numerics.Discrete_Random they are applied to the generated
values of various discrete types. Each test suite performs 6 different
tests, with each test repeated 10 times, yielding a total of 60
individual trials. An individual trial is deemed to pass if the
chi-square value (or other statistic) calculated for the observed counts
or distribution falls within the range of values corresponding to the
2.5 and 97.5 percentage points for the relevant degrees of freedom
(i.e., it shall be neither too high nor too low). For the purpose of
determining the degrees of freedom, measurement categories are combined
whenever the expected counts are fewer than 5.
G.2.6 Accuracy Requirements for Complex Arithmetic
-
In the strict mode, the performance of Numerics.Generic_Complex_Types
and Numerics.Generic_Complex_Elementary_Functions shall be as specified
here.
Implementation Requirements
-
When an exception is not raised, the result of evaluating a real
function of an instance CT of Numerics.Generic_Complex_Types (i.e., a
function that yields a value of subtype CT.Real'Base or CT.Imaginary)
belongs to a result interval defined as for a real elementary function
(see section G.2.4 Accuracy Requirements for the Elementary Functions).
- When an exception is not raised, each component of the result of
evaluating a complex function of such an instance, or of an instance of
Numerics.Generic_Complex_Elementary_Functions obtained by instantiating
the latter with CT (i.e., a function that yields a value of subtype
CT.Complex), also belongs to a result interval. The result intervals for
the components of the result are either defined by a maximum relative
error bound or by a maximum box error bound. When the result interval
for the real (resp., imaginary) component is defined by maximum relative
error, it is defined as for that of a real function, relative to the
exact value of the real (resp., imaginary) part of the result of the
corresponding mathematical function. When defined by maximum box error,
the result interval for a component of the result is the smallest model
interval of CT.Real that contains all the values of the corresponding
part of f*(1.0+d), where f is the exact complex value of the
corresponding mathematical function at the given parameter values, d is
complex, and |d| is less than or equal to the given maximum box error.
The function delivers a value that belongs to the result interval (or a
value both of whose components belong to their respective result
intervals) when both bounds of the result interval(s) belong to the safe
range of CT.Real; otherwise,
-
if CT.Real'Machine_Overflows is True, the function either delivers a
value that belongs to the result interval (or a value both of whose
components belong to their respective result intervals) or raises
Constraint_Error, signaling overflow;
-
if CT.Real'Machine_Overflows is False, the result is implementation
defined.
-
The error bounds for particular complex functions are tabulated below.
In the table, the error bound is given as the coefficient of
CT.Real'Model_Epsilon.
-
| | +-----------------------------------------------------------------+
| |
| Error Bounds for Particular Complex Functions |
| |
+-----------------------------+---------+-----------------+-------+
| | | | |
| | Nature | Nature of | Error |
| Function or Operator | of | Bound | Bound |
| | Result | | |
| | | | |
+-----------------------------+---------+-----------------+-------+
| | | | |
| Modulus | real | max. rel. error | 3.0 |
| | | | |
| Argument | real | max. rel. error | 4.0 |
| | | | |
| Compose_From_Polar | complex | max. rel. error | 3.0 |
| | | | |
| "*" (both operands complex) | complex | max. box error | 5.0 |
| | | | |
| "/" (right operand complex) | complex | max. box error | 13.0 |
| | | | |
| Sqrt | complex | max. rel. error | 6.0 |
| | | | |
| Log | complex | max. box error | 13.0 |
| | | | |
| Exp (complex parameter) | complex | max. rel. error | 7.0 |
| | | | |
| Exp (imaginary parameter) | complex | max. rel. error | 2.0 |
| | | | |
| Sin, Cos, Sinh, and Cosh | complex | max. rel. error | 11.0 |
| | | | |
| Tan, Cot, Tanh, and Coth | complex | max. rel. error | 35.0 |
| | | | |
| inverse trigonometric | complex | max. rel. error | 14.0 |
| | | | |
| inverse hyperbolic | complex | max. rel. error | 14.0 |
| | | | |
+-----------------------------+---------+-----------------+-------+
|
-
The maximum relative error given above applies throughout the domain of
the Compose_From_Polar function when the Cycle parameter is specified.
When the Cycle parameter is omitted, the maximum relative error applies
only when the absolute value of the parameter Argument is less than or
equal to the angle threshold, see G.2.4 Accuracy Requirements for the Elementary Functions. For the Exp function, and
for the forward hyperbolic (resp., trigonometric) functions, the maximum
relative error given above likewise applies only when the absolute value
of the imaginary (resp., real) component of the parameter X (or the
absolute value of the parameter itself, in the case of the Exp function
with a parameter of pure-imaginary type) is less than or equal to the
angle threshold. For larger angles, the accuracy is implementation
defined.
-
The prescribed results specified in G.1.2 Complex Elementary Functions, for certain functions
at particular parameter values take precedence over the error bounds;
effectively, they narrow to a single value the result interval allowed
by the error bounds for a component of the result. Additional rules with
a similar effect are given below for certain inverse trigonometric and
inverse hyperbolic functions, at particular parameter values for which a
component of the mathematical result is transcendental. In each case,
the accuracy rule, which takes precedence over the error bounds, is that
the result interval for the stated result component is the model
interval of CT.Real associated with the component's exact mathematical
value. The cases in question are as follows:
-
When the parameter X has the value zero, the real (resp., imaginary)
component of the result of the Arccot (resp., Arccoth) function is in
the model interval of CT.Real associated with the value Pi/2.0.
-
When the parameter X has the value one, the real component of the result
of the Arcsin function is in the model interval of CT.Real associated
with the value Pi/2.0.
-
When the parameter X has the value -1.0, the real component of the
result of the Arcsin (resp., Arccos) function is in the model interval
of CT.Real associated with the value -Pi/2.0 (resp., Pi).
-
The amount by which a component of the result of an inverse
trigonometric or inverse hyperbolic function is allowed to spill over
into a quadrant adjacent to the one corresponding to the principal
branch, as given in G.1.2 Complex Elementary Functions, is limited. The rule is that the
result belongs to the smallest model interval of CT.Real that contains
both boundaries of the quadrant corresponding to the principal branch.
This rule also takes precedence to the maximum error bounds, effectively
narrowing the result interval allowed by them.
-
Finally, the results allowed by the error bounds are narrowed by one
further rule: The absolute value of each component of the result of the
Exp function, for a pure-imaginary parameter, never exceeds one.
Implementation Advice
-
The version of the Compose_From_Polar function without a Cycle parameter
should not be implemented by calling the corresponding version with a
Cycle parameter of 2.0*Numerics.Pi, since this will not provide the
required accuracy in some portions of the domain.
H. Safety and Security (normative)
-
This Annex addresses requirements for systems that are safety critical
or have security constraints. It provides facilities and specifies
documentation requirements that relate to several needs:
-
Understanding program execution;
-
Reviewing object code;
-
Restricting language constructs whose usage might complicate the
demonstration of program correctness
Execution understandability is supported by pragma Normalize_Scalars,
and also by requirements for the implementation to document the effect
of a program in the presence of a bounded error or where the language
rules leave the effect unspecified.
-
The pragmas Reviewable and Restrictions relate to the other requirements
addressed by this Annex.
NOTES
-
(1) The Valid attribute, see 14.9.2 The Valid Attribute, is also useful in addressing
these needs, to avoid problems that could otherwise arise from scalars
that have values outside their declared range constraints.
--- The Detailed Node Listing ---
H.1 Pragma Normalize_Scalars
-
This pragma ensures that an otherwise uninitialized scalar object is set
to a predictable value, but out of range if possible.
Syntax
-
The form of a pragma Normalize_Scalars is as follows:
-
| | pragma Normalize_Scalars;
|
Post-Compilation Rules
-
Pragma Normalize_Scalars is a configuration pragma. It applies to all
compilation_units included in a partition.
Documentation Requirements
-
If a pragma Normalize_Scalars applies, the implementation shall document
the implicit initial value for scalar subtypes, and shall identify each
case in which such a value is used and is not an invalid representation.
Implementation Advice
-
Whenever possible, the implicit initial value for a scalar subtype
should be an invalid representation, see 14.9.1 Data Validity.
NOTES
-
(2) The initialization requirement applies to uninitialized scalar
objects that are subcomponents of composite objects, to allocated
objects, and to stand-alone objects. It also applies to scalar out
parameters. Scalar subcomponents of composite out parameters are
initialized to the corresponding part of the actual, by virtue of
7.4.1 Parameter Associations.
-
(3) The initialization requirement does not apply to a scalar for which
pragma Import has been specified, since initialization of an imported
object is performed solely by the foreign language environment
(see section B.1 Interfacing Pragmas).
-
(4) The use of pragma Normalize_Scalars in conjunction with Pragma
Restrictions(No_Exceptions) may result in erroneous execution
(see section H.4 Safety and Security Restrictions).
H.2 Documentation of Implementation Decisions
Documentation Requirements
-
The implementation shall document the range of effects for each
situation that the language rules identify as either a bounded error or
as having an unspecified effect. If the implementation can constrain the
effects of erroneous execution for a given construct, then it shall
document such constraints. The documentation might be provided either
independently of any compilation unit or partition, or as part of an
annotated listing for a given unit or partition. See also 2.1.3 Conformity of an Implementation with the Standard,
and 2.1.2 Structure.
NOTES
-
(5) Among the situations to be documented are the conventions chosen for
parameter passing, the methods used for the management of run-time
storage, and the method used to evaluate numeric expressions if this
involves extended range or extra precision.
H.3 Reviewable Object Code
-
Object code review and validation are supported by pragmas Reviewable
and Inspection_Point.
H.3.1 Pragma Reviewable
-
This pragma directs the implementation to provide information to
facilitate analysis and review of a program's object code, in particular
to allow determination of execution time and storage usage and to
identify the correspondence between the source and object programs.
Syntax
-
The form of a pragma Reviewable is as follows:
-
Post-Compilation Rules
-
Pragma Reviewable is a configuration pragma. It applies to all
compilation_units included in a partition.
Implementation Requirements
-
The implementation shall provide the following information for any
compilation unit to which such a pragma applies:
-
Where compiler-generated run-time checks remain;
-
An identification of any construct with a language-defined check that is
recognized prior to run time as certain to fail if executed (even if the
generation of run-time checks has been suppressed);
-
For each reference to a scalar object, an identification of the
reference as either "known to be initialized," or "possibly
uninitialized," independent of whether pragma Normalize_Scalars
applies;
-
Where run-time support routines are implicitly invoked;
-
An object code listing, including:
-
Machine instructions, with relative offsets;
-
Where each data object is stored during its lifetime;
-
Correspondence with the source program, including an identification of
the code produced per declaration and per statement.
-
An identification of each construct for which the implementation detects
the possibility of erroneous execution;
-
For each subprogram, block, task, or other construct implemented by
reserving and subsequently freeing an area on a run-time stack, an
identification of the length of the fixed-size portion of the area and
an indication of whether the non-fixed size portion is reserved on the
stack or in a dynamically-managed storage region.
-
The implementation shall provide the following information for any
partition to which the pragma applies:
-
An object code listing of the entire partition, including initialization
and finalization code as well as run-time system components, and with an
identification of those instructions and data that will be relocated at
load time;
-
A description of the run-time model relevant to the partition.
The implementation shall provide control- and data-flow information, both
within each compilation unit and across the compilation units of the
partition.
Implementation Advice
-
The implementation should provide the above information in both a
human-readable and machine-readable form, and should document the latter
so as to ease further processing by automated tools.
-
Object code listings should be provided both in a symbolic format and
also in an appropriate numeric format (such as hexadecimal or octal).
NOTES
-
(6) The order of elaboration of library units will be documented even in
the absence of pragma Reviewable, see 11.2 Program Execution.
H.3.2 Pragma Inspection_Point
-
An occurrence of a pragma Inspection_Point identifies a set of objects
each of whose values is to be available at the point(s) during program
execution corresponding to the position of the pragma in the compilation
unit. The purpose of such a pragma is to facilitate code validation.
Syntax
-
The form of a pragma Inspection_Point is as follows:
-
| | pragma Inspection_Point[(object_name {, object_name})];
|
Legality Rules
-
A pragma Inspection_Point is allowed wherever a declarative_item or
statement is allowed. Each object_name shall statically denote the
declaration of an object.
Static Semantics
-
An inspection point is a point in the object code corresponding to the
occurrence of a pragma Inspection_Point in the compilation unit. An
object is inspectable at an inspection point if the corresponding pragma
Inspection_Point either has an argument denoting that object, or has no
arguments.
Dynamic Semantics
-
Execution of a pragma Inspection_Point has no effect.
Implementation Requirements
-
Reaching an inspection point is an external interaction with respect to
the values of the inspectable objects at that point, see 2.1.3 Conformity of an Implementation with the Standard.
Documentation Requirements
-
For each inspection point, the implementation shall identify a mapping
between each inspectable object and the machine resources (such as
memory locations or registers) from which the object's value can be
obtained.
NOTES
-
(7) The implementation is not allowed to perform "dead store
elimination" on the last assignment to a variable prior to a point
where the variable is inspectable. Thus an inspection point has the
effect of an implicit reference to each of its inspectable objects.
-
(8) Inspection points are useful in maintaining a correspondence between
the state of the program in source code terms, and the machine state
during the program's execution. Assertions about the values of program
objects can be tested in machine terms at inspection points. Object code
between inspection points can be processed by automated tools to verify
programs mechanically.
-
(9) The identification of the mapping from source program objects to
machine resources is allowed to be in the form of an annotated object
listing, in human-readable or tool-processable form.
H.4 Safety and Security Restrictions
-
This clause defines restrictions that can be used with pragma
Restrictions, see 14.12 Pragma Restrictions, these facilitate the demonstration of
program correctness by allowing tailored versions of the run-time
system.
Static Semantics
-
The following restrictions, the same as in D.7 Tasking Restrictions, apply in this
Annex: No_Task_Hierarchy, No_Abort_Statement,
No_Implicit_Heap_Allocation, Max_Task_Entries is 0,
Max_Asynchronous_Select_Nesting is 0, and Max_Tasks is 0. The last three
restrictions are checked prior to program execution.
-
The following additional restrictions apply in this Annex.
-
Tasking-related restriction:
-
No_Protected_Types
| | There are no declarations of protected types or protected
objects.
|
-
Memory-management related restrictions:
-
No_Allocators
| | There are no occurrences of an allocator.
|
-
No_Local_Allocators
| | Allocators are prohibited in subprograms, generic sub-programs,
tasks, and entry bodies; instantiations of generic
packages are also prohibited in these contexts.
|
-
No_Unchecked_Deallocation
| | Semantic dependence on Unchecked_Deallocation is not allowed.
|
-
Immediate_Reclamation
| | Except for storage occupied by objects created by allocators
and not deallocated via unchecked deallocation, any storage
reserved at run time for an object is immediately reclaimed
when the object no longer exists.
|
-
Exception-related restriction:
-
No_Exceptions
| | Raise_statements and exception_handlers are not allowed. No
language-defined run-time checks are generated; however, a
run-time check performed automatically by the hardware is
permitted.
|
-
Other restrictions:
-
No_Floating_Point
| | Uses of predefined floating point types and operations, and
declarations of new floating point types, are not allowed.
|
-
No_Fixed_Point
| | Uses of predefined fixed point types and operations, and
declarations of new fixed point types, are not allowed.
|
-
No_Unchecked_Conversion
| | Semantic dependence on the predefined generic
Unchecked_Conversion is not allowed.
|
-
No_Access_Subprograms
| | The declaration of access-to-subprogram types is not allowed.
|
-
No_Unchecked_Access
| | The Unchecked_Access attribute is not allowed.
|
-
No_Dispatch
| | Occurrences of T'Class are not allowed, for any (tagged)
subtype T.
|
-
No_IO
| | Semantic dependence on any of the library units
Sequential_IO, Direct_IO, Text_IO, Wide_Text_IO, or Stream_IO
is not allowed.
|
-
No_Delay
| | Delay_Statements and semantic dependence on package Calendar
are not allowed.
|
-
No_Recursion
| | As part of the execution of a subprogram, the same subprogram
is not invoked.
|
-
No_Reentrancy
| | During the execution of a subprogram by a task, no other task
invokes the same subprogram.
|
Implementation Requirements
-
If an implementation supports pragma Restrictions for a particular
argument, then except for the restrictions No_Unchecked_Deallocation,
No_Unchecked_Conversion, No_Access_Subprograms, and No_Unchecked_Access,
the associated restriction applies to the run-time system.
Documentation Requirements
-
If a pragma Restrictions(No_Exceptions) is specified, the implementation
shall document the effects of all constructs where language-defined
checks are still performed automatically (for example, an overflow check
performed by the processor).
Erroneous Execution
-
Program execution is erroneous if pragma Restrictions(No_Exceptions) has
been specified and the conditions arise under which a generated
language-defined run-time check would fail.
-
Program execution is erroneous if pragma Restrictions(No_Recursion) has
been specified and a subprogram is invoked as part of its own execution,
or if pragma Restrictions(No_Reentrancy) has been specified and during
the execution of a subprogram by a task, another task invokes the same
subprogram.
I. Obsolescent Features (normative)
-
This Annex contains descriptions of features of the language whose
functionality is largely redundant with other features defined by this
International Standard. Use of these features is not recommended in
newly written programs.
--- The Detailed Node Listing ---
I.1 Renamings of Ada 83 Library Units
Static Semantics
-
The following library_unit_renaming_declarations exist:
-
| | with Ada.Unchecked_Conversion;
generic function Unchecked_Conversion
renames Ada.Unchecked_Conversion;
|
-
| | with Ada.Unchecked_Deallocation;
generic procedure Unchecked_Deallocation
renames Ada.Unchecked_Deallocation;
|
-
| | with Ada.Sequential_IO;
generic package Sequential_IO renames Ada.Sequential_IO;
|
-
| | with Ada.Direct_IO;
generic package Direct_IO renames Ada.Direct_IO;
|
-
| | with Ada.Text_IO;
package Text_IO renames Ada.Text_IO;
|
-
| | with Ada.IO_Exceptions;
package IO_Exceptions renames Ada.IO_Exceptions;
|
-
| | with Ada.Calendar;
package Calendar renames Ada.Calendar;
|
-
| | with System.Machine_Code;
package Machine_Code renames System.Machine_Code; -- If supported.
|
Implementation Requirements
-
The implementation shall allow the user to replace these renamings.
I.2 Allowed Replacements of Characters
Syntax
-
The following replacements are allowed for the vertical line, number
sign, and quotation mark characters:
-
A vertical line character (|) can be replaced by an exclamation mark (!)
where used as a delimiter.
-
The number sign characters (#) of a based_literal can be replaced by
colons (:) provided that the replacement is done for both occurrences.
-
The quotation marks (") used as string brackets at both ends of a string
literal can be replaced by percent signs (%) provided that the enclosed
sequence of characters contains no quotation mark, and provided that
both string brackets are replaced. Any percent sign within the sequence
of characters shall then be doubled and each such doubled percent sign
is interpreted as a single percent sign character value.
-
These replacements do not change the meaning of the program.
I.3 Reduced Accuracy Subtypes
-
A digits_constraint may be used to define a floating point subtype with
a new value for its requested decimal precision, as reflected by its
Digits attribute. Similarly, a delta_constraint may be used to define an
ordinary fixed point subtype with a new value for its delta, as
reflected by its Delta attribute.
Syntax
-
| | delta_constraint ::= delta static_expression [range_constraint]
|
Name Resolution Rules
-
The expression of a delta_constraint is expected to be of any real type.
Legality Rules
-
The expression of a delta_constraint shall be static.
-
For a subtype_indication with a delta_constraint, the subtype_mark shall
denote an ordinary fixed point subtype.
-
For a subtype_indication with a digits_constraint, the subtype_mark
shall denote either a decimal fixed point subtype or a floating point
subtype (notwithstanding the rule given in 4.5.9 Fixed Point Types, that only
allows a decimal fixed point subtype).
Static Semantics
-
A subtype_indication with a subtype_mark that denotes an ordinary fixed
point subtype and a delta_constraint defines an ordinary fixed point
subtype with a delta given by the value of the expression of the
delta_constraint. If the delta_constraint includes a range_constraint,
then the ordinary fixed point subtype is constrained by the
range_constraint.
-
A subtype_indication with a subtype_mark that denotes a floating point
subtype and a digits_constraint defines a floating point subtype with a
requested decimal precision (as reflected by its Digits attribute) given
by the value of the expression of the digits_constraint. If the
digits_constraint includes a range_constraint, then the floating point
subtype is constrained by the range_constraint.
Dynamic Semantics
-
A delta_constraint is compatible with an ordinary fixed point subtype if
the value of the expression is no less than the delta of the subtype,
and the range_constraint, if any, is compatible with the subtype.
-
A digits_constraint is compatible with a floating point subtype if the
value of the expression is no greater than the requested decimal
precision of the subtype, and the range_constraint, if any, is
compatible with the subtype.
-
The elaboration of a delta_constraint consists of the elaboration of the
range_constraint, if any.
I.4 The Constrained Attribute
Static Semantics
-
For every private subtype S, the following attribute is defined:
-
S'Constrained
| | Yields the value False if S denotes an unconstrained
nonformal private subtype with discriminants; also yields the
value False if S denotes a generic formal private subtype,
and the associated actual subtype is either an unconstrained
subtype with discriminants or an unconstrained array subtype;
yields the value True otherwise. The value of this attribute
is of the predefined subtype Boolean.
|
I.5 ASCII
Static Semantics
-
The following declaration exists in the declaration of package Standard:
-
-
-
| | NUL : constant Character := nul;
SOH : constant Character := soh;
STX : constant Character := stx;
ETX : constant Character := etx;
EOT : constant Character := eot;
ENQ : constant Character := enq;
ACK : constant Character := ack;
BEL : constant Character := bel;
BS : constant Character := bs;
HT : constant Character := ht;
LF : constant Character := lf;
VT : constant Character := vt;
FF : constant Character := ff;
CR : constant Character := cr;
SO : constant Character := so;
SI : constant Character := si;
DLE : constant Character := dle;
DC1 : constant Character := dc1;
DC2 : constant Character := dc2;
DC3 : constant Character := dc3;
DC4 : constant Character := dc4;
NAK : constant Character := nak;
SYN : constant Character := syn;
ETB : constant Character := etb;
CAN : constant Character := can;
EM : constant Character := em;
SUB : constant Character := sub;
ESC : constant Character := esc;
FS : constant Character := fs;
GS : constant Character := gs;
RS : constant Character := rs;
US : constant Character := us;
DEL : constant Character := del;
|
-
-
| | Exclam : constant Character:= '!';
Quotation : constant Character:= '"';
Sharp : constant Character:= '#';
Dollar : constant Character:= '$';
Percent : constant Character:= '%';
Ampersand : constant Character:= '&';
Colon : constant Character:= ':';
Semicolon : constant Character:= ';';
Query : constant Character:= '?';
At_Sign : constant Character:= '';
L_Bracket : constant Character:= '[';
Back_Slash: constant Character:= '\';
R_Bracket : constant Character:= ']';
Circumflex: constant Character:= '^';
Underline : constant Character:= '_';
Grave : constant Character:= '`';
L_Brace : constant Character:= '{';
Bar : constant Character:= '|';
R_Brace : constant Character:= '}';
Tilde : constant Character:= '~';
|
-
-
| | LC_A: constant Character:= 'a';
...
LC_Z: constant Character:= 'z';
|
-
I.6 Numeric_Error
Static Semantics
-
The following declaration exists in the declaration of package Standard:
-
| | Numeric_Error : exception renames Constraint_Error;
|
I.7 At Clauses
Syntax
-
| | at_clause ::= for direct_name use at expression;
|
Static Semantics
-
An at_clause of the form "for x use at y;" is equivalent to an
attribute_definition_clause of the form "for x'Address use y;".
I.7.1 Interrupt Entries
-
Implementations are permitted to allow the attachment of task entries to
interrupts via the address clause. Such an entry is referred to as an
interrupt entry.
-
The address of the task entry corresponds to a hardware interrupt in an
implementation-defined manner. (See Ada.Interrupts.Reference in
C.3.2 The Package Interrupts.)
Static Semantics
-
The following attribute is defined:
-
For any task entry X:
-
X'Address
| | For a task entry whose address is specified (an interrupt
entry), the value refers to the corresponding hardware
interrupt. For such an entry, as for any other task entry,
the meaning of this value is implementation defined. The
value of this attribute is of the type of the subtype
System.Address.
|
-
Address may be specified for single entries via an
attribute_definition_clause.
Dynamic Semantics
-
As part of the initialization of a task object, the address clause for
an interrupt entry is elaborated, which evaluates the expression of the
address clause. A check is made that the address specified is associated
with some interrupt to which a task entry may be attached. If this check
fails, Program_Error is raised. Otherwise, the interrupt entry is
attached to the interrupt associated with the specified address.
-
Upon finalization of the task object, the interrupt entry, if any, is
detached from the corresponding interrupt and the default treatment is
restored.
-
While an interrupt entry is attached to an interrupt, the interrupt is
reserved, see C.3 Interrupt Support.
-
An interrupt delivered to a task entry acts as a call to the entry
issued by a hardware task whose priority is in the
System.Interrupt_Priority range. It is implementation defined whether
the call is performed as an ordinary entry call, a timed entry call, or
a conditional entry call; which kind of call is performed can depend on
the specific interrupt.
Bounded (Run-Time) Errors
-
It is a bounded error to evaluate E'Caller, see C.7.1 The Package Task_Identification, in an
accept_statement for an interrupt entry. The possible effects are the
same as for calling Current_Task from an entry body.
Documentation Requirements
-
The implementation shall document to which interrupts a task entry may
be attached.
-
The implementation shall document whether the invocation of an interrupt
entry has the effect of an ordinary entry call, conditional call, or a
timed call, and whether the effect varies in the presence of pending
interrupts.
Implementation Permissions
-
The support for this subclause is optional.
-
Interrupts to which the implementation allows a task entry to be
attached may be designated as reserved for the entire duration of
program execution; that is, not just when they have an interrupt entry
attached to them.
-
Interrupt entry calls may be implemented by having the hardware execute
directly the appropriate accept body. Alternatively, the implementation
is allowed to provide an internal interrupt handler to simulate the
effect of a normal task calling the entry.
-
The implementation is allowed to impose restrictions on the
specifications and bodies of tasks that have interrupt entries.
-
It is implementation defined whether direct calls (from the program) to
interrupt entries are allowed.
-
If a select_statement contains both a terminate_alternative and an
accept_alternative for an interrupt entry, then an implementation is
allowed to impose further requirements for the selection of the
terminate_alternative in addition to those given in, see 10.3 Task Dependence - Termination of Tasks.
NOTES
-
(1) Queued interrupts correspond to ordinary entry calls. Interrupts
that are lost if not immediately processed correspond to conditional
entry calls. It is a consequence of the priority rules that an accept
body executed in response to an interrupt can be executed with the
active priority at which the hardware generates the interrupt, taking
precedence over lower priority tasks, without a scheduling action.
-
(2) Control information that is supplied upon an interrupt can be passed
to an associated interrupt entry as one or more parameters of mode in.
Examples
-
Example of an interrupt entry:
-
| | task Interrupt_Handler is
entry Done;
for Done'Address use
Ada.Interrupts.Reference (Ada.Interrupts.Names.Device_Done);
end Interrupt_Handler;
|
I.8 Mod Clauses
Syntax
-
| | mod_clause ::= at mod static_expression;
|
Static Semantics
-
A record_representation_clause of the form:
-
| | for r use
record at mod a
...
end record;
|
-
is equivalent to:
-
| | for r'Alignment use a;
for r use
record
...
end record;
|
I.9 The Storage_Size Attribute
Static Semantics
-
For any task subtype T, the following attribute is defined:
-
T'Storage_Size
| | Denotes an implementation-defined value of type
universal_integer representing the number of storage
elements reserved for a task of the subtype T.
|
-
Storage_Size may be specified for a task first subtype via an
attribute_definition_clause.
J. Language-Defined Attributes (informative)
-
This annex summarizes the definitions given elsewhere of the
language-defined attributes.
-
P'Access
For a prefix P that denotes a subprogram:
-
P'Access yields an access value that designates the subprogram denoted
by P. The type of P'Access is an access-to-subprogram type (S), as
determined by the expected type (see section 4.10.2 Operations of Access Types).
-
X'Access
For a prefix X that denotes an aliased view of an object:
-
X'Access yields an access value that designates the object denoted by X.
The type of X'Access is an access-to-object type, as determined by the
expected type. The expected type shall be a general access type
(see section 4.10.2 Operations of Access Types).
-
X'Address
For a prefix X that denotes an object, program unit, or
label:
-
Denotes the address of the first of the storage elements allocated to X.
For a program unit or label, this value refers to the machine code
associated with the corresponding body or statement. The value of this
attribute is of type System.Address (see section 14.3 Representation Attributes).
-
S'Adjacent
For every subtype S of a floating point type T:
-
S'Adjacent denotes a function with the following specification:
-
| | function S'Adjacent (X, Towards : T) return T
|
-
If Towards=X, the function yields X; otherwise, it yields the machine
number of the type T adjacent to X in the direction of Towards, if that
machine number exists. If the result would be outside the base range of
S, Constraint_Error is raised. When T'Signed_Zeros is True, a zero
result has the sign of X. When Towards is zero, its sign has no bearing
on the result (see section A.5.3 Attributes of Floating Point Types).
-
S'Aft
For every fixed point subtype S:
-
S'Aft yields the number of decimal digits needed after the decimal point
to accommodate the delta of the subtype S, unless the delta of the
subtype S is greater than 0.1, in which case the attribute yields the
value one. (S'Aft is the smallest positive integer N for which
(10**N)*S'Delta is greater than or equal to one.) The value of this
attribute is of the type universal_integer (see section 4.5.10 Operations of Fixed Point Types).
-
X'Alignment
For a prefix X that denotes a subtype or object:
-
The Address of an object that is allocated under control of the
implementation is an integral multiple of the Alignment of the object
(that is, the Address modulo the Alignment is zero). The offset of a
record component is a multiple of the Alignment of the component. For an
object that is not allocated under control of the implementation (that
is, one that is imported, that is allocated by a user-defined allocator,
whose Address has been specified, or is designated by an access value
returned by an instance of Unchecked_Conversion), the implementation may
assume that the Address is an integral multiple of its Alignment. The
implementation shall not assume a stricter alignment.
-
The value of this attribute is of type universal_integer, and
nonnegative; zero means that the object is not necessarily aligned on a
storage element boundary (see section 14.3 Representation Attributes).
-
S'Base
For every scalar subtype S:
-
S'Base denotes an unconstrained subtype of the type of S. This
unconstrained subtype is called the base subtype of the type
(see section 4.5 Scalar Types).
-
S'Bit_Order
For every specific record subtype S:
-
Denotes the bit ordering for the type of S. The value of this attribute
is of type System.Bit_Order (see section 14.5.3 Bit Ordering).
-
P'Body_Version
For a prefix P that statically denotes a program unit:
-
Yields a value of the predefined type String that identifies the version
of the compilation unit that contains the body (but not any subunits) of
the program unit (see section E.3 Consistency of a Distributed System).
-
T'Callable
For a prefix T that is of a task type (after any implicit dereference):
-
Yields the value True when the task denoted by T is callable, and False
otherwise (see section 10.9 Task and Entry Attributes).
-
E'Caller
For a prefix E that denotes an entry_declaration:
-
Yields a value of the type Task_ID that identifies the task whose call
is now being serviced. Use of this attribute is allowed only inside an
entry_body or accept_statement corresponding to the entry_declaration
denoted by E (see section C.7.1 The Package Task_Identification).
-
S'Ceiling
For every subtype S of a floating point type T:
-
S'Ceiling denotes a function with the following specification:
-
| | function S'Ceiling (X : T) return T
|
-
The function yields the value Ceiling(X), i.e., the smallest (most
negative) integral value greater than or equal to X. When X is zero, the
result has the sign of X; a zero result otherwise has a negative sign
when S'Signed_Zeros is True (see section A.5.3 Attributes of Floating Point Types).
-
S'Class
For every subtype S of a tagged type T (specific or class-wide):
-
S'Class denotes a subtype of the class-wide type (called T'Class in this
International Standard) for the class rooted at T (or if S already
denotes a class-wide subtype, then S'Class is the same as S).
-
S'Class is unconstrained. However, if S is constrained, then the values
of S'Class are only those that when converted to the type T belong to S
(see section 4.9 Tagged Types and Type Extensions).
-
S'Class
For every subtype S of an untagged private type whose full view is
tagged:
-
Denotes the class-wide subtype corresponding to the full view of S. This
attribute is allowed only from the beginning of the private part in
which the full view is declared, until the declaration of the full view.
After the full view, the Class attribute of the full view can be used
(see section 8.3.1 Private Operations).
-
X'Component_Size
For a prefix X that denotes an array subtype or array object (after any
implicit dereference):
-
Denotes the size in bits of components of the type of X. The value of
this attribute is of type universal_integer (see section 14.3 Representation Attributes).
-
S'Compose
For every subtype S of a floating point type T:
-
S'Compose denotes a function with the following specification:
-
| | function S'Compose
(Fraction : T;
Exponent : universal_integer) return T
|
-
Let v be the value (Fraction*T'Machine_Radix) ** (Exponent-k), where k
is the normalized exponent of Fraction. If v is a machine number of the
type T, or if |v|>=T'Model_Small, the function yields v; otherwise, it
yields either one of the machine numbers of the type T adjacent to v.
Constraint_Error is optionally raised if v is outside the base range of
S. A zero result has the sign of Fraction when S'Signed_Zeros is True
(see section A.5.3 Attributes of Floating Point Types).
-
A'Constrained
For a prefix A that is of a discriminated type (after any implicit
dereference):
-
Yields the value True if A denotes a constant, a value, or a constrained
variable, and False otherwise (see section 4.7.2 Operations of Discriminated Types).
-
S'Copy_Sign
For every subtype S of a floating point type T:
-
S'Copy_Sign denotes a function with the following specification:
-
| | function S'Copy_Sign (Value, Sign : T) return T
|
-
If the value of Value is nonzero, the function yields a result whose
magnitude is that of Value and whose sign is that of Sign; otherwise, it
yields the value zero. Constraint_Error is optionally raised if the
result is outside the base range of S. A zero result has the sign of
Sign when S'Signed_Zeros is True (see section A.5.3 Attributes of Floating Point Types).
-
E'Count
For a prefix E that denotes an entry of a task or protected unit:
-
Yields the number of calls presently queued on the entry E of the
current instance of the unit. The value of this attribute is of the type
universal_integer (see section 10.9 Task and Entry Attributes).
-
S'Definite
For a prefix S that denotes a formal indefinite subtype:
-
S'Definite yields True if the actual subtype corresponding to S is
definite; otherwise it yields False. The value of this attribute is of
the predefined type Boolean (see section 13.5.1 Formal Private and Derived Types).
-
S'Delta
For every fixed point subtype S:
-
S'Delta denotes the delta of the fixed point subtype S. The value of
this attribute is of the type universal_real (see section 4.5.10 Operations of Fixed Point Types).
-
S'Denorm
For every subtype S of a floating point type T:
-
Yields the value True if every value expressible in the form
| | T'Machine_Emin
+/-mantissa*T'Machine_Radix
|
where mantissa is a nonzero T'Machine_Mantissa-digit fraction in the
number base T'Machine_Radix, the first digit of which is zero, is a
machine number, see 4.5.7 Floating Point Types, of the type T; yields the value False
otherwise. The value of this attribute is of the predefined type
Boolean (see section A.5.3 Attributes of Floating Point Types).
-
S'Digits
For every decimal fixed point subtype S:
-
S'Digits denotes the digits of the decimal fixed point subtype S, which
corresponds to the number of decimal digits that are representable in
objects of the subtype. The value of this attribute is of the type
universal_integer (see section 4.5.10 Operations of Fixed Point Types).
-
S'Digits
For every floating point subtype S:
-
S'Digits denotes the requested decimal precision for the subtype S. The
value of this attribute is of the type universal_integer (see section 4.5.8 Operations of Floating Point Types).
-
S'Exponent
For every subtype S of a floating point type T:
-
S'Exponent denotes a function with the following specification:
-
| | function S'Exponent (X : T) return universal_integer
|
-
The function yields the normalized exponent of X (see section A.5.3 Attributes of Floating Point Types).
-
S'External_Tag
For every subtype S of a tagged type T (specific or class-wide):
-
S'External_Tag denotes an external string representation for S'Tag; it
is of the predefined type String. External_Tag may be specified for a
specific tagged type via an attribute_definition_clause; the expression
of such a clause shall be static. The default external tag
representation is implementation defined (see 4.9.2 Dispatching Operations of Tagged Types and
14.13.2 Stream-Oriented Attributes). See section 14.3 Representation Attributes.
-
A'First(N)
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'First(N) denotes the lower bound of the N-th index range; its type is
the corresponding index type (see section 4.6.2 Operations of Array Types).
-
A'First
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'First denotes the lower bound of the first index range; its type is
the corresponding index type (see section 4.6.2 Operations of Array Types).
-
S'First
For every scalar subtype S:
-
S'First denotes the lower bound of the range of S. The value of this
attribute is of the type of S. See section 4.5 Scalar Types.
-
R.C'First_Bit
For a component C of a composite, non-array object R:
-
Denotes the offset, from the start of the first of the storage elements
occupied by C, of the first bit occupied by C. This offset is measured
in bits. The first bit of a storage element is numbered zero. The value
of this attribute is of the type universal_integer. See section 14.5.2 Storage Place Attributes.
-
S'Floor
For every subtype S of a floating point type T:
-
S'Floor denotes a function with the following specification:
-
| | function S'Floor (X : T) return T
|
-
The function yields the value Floor(X), i.e., the largest (most
positive) integral value less than or equal to X. When X is zero, the
result has the sign of X; a zero result otherwise has a positive sign.
See section A.5.3 Attributes of Floating Point Types.
-
S'Fore
For every fixed point subtype S:
-
S'Fore yields the minimum number of characters needed before the decimal
point for the decimal representation of any value of the subtype S,
assuming that the representation does not include an exponent, but
includes a one-character prefix that is either a minus sign or a space.
(This minimum number does not include superfluous zeros or underlines,
and is at least 2.) The value of this attribute is of the type
universal_integer. See section 4.5.10 Operations of Fixed Point Types.
-
S'Fraction
For every subtype S of a floating point type T:
-
S'Fraction denotes a function with the following specification:
-
| | function S'Fraction (X : T) return T
|
-
The function yields the value (X*T'Machine_Radix) ** -k, where k is the
normalized exponent of X. A zero result, which can only occur when X is
zero, has the sign of X. See section A.5.3 Attributes of Floating Point Types.
-
E'Identity
For a prefix E that denotes an exception:
-
E'Identity returns the unique identity of the exception. The type of
this attribute is Exception_Id. See section 12.4.1 The Package Exceptions.
-
T'Identity
For a prefix T that is of a task type (after any implicit dereference):
-
Yields a value of the type Task_ID that identifies the task denoted by
T. See section C.7.1 The Package Task_Identification.
-
S'Image
For every scalar subtype S:
-
S'Image denotes a function with the following specification:
-
| | function S'Image(Arg : S'Base) return String
|
-
The function returns an image of the value of Arg as a String.
See section 4.5 Scalar Types.
-
S'Class'Input
For every subtype S'Class of a class-wide type T'Class:
-
S'Class'Input denotes a function with the following specification:
-
| | function S'Class'Input
(Stream : access Ada.Streams.Root_Stream_Type'Class)
return T'Class
|
-
First reads the external tag from Stream and determines the
corresponding internal tag (by calling
Tags.Internal_Tag(String'Input(Stream)) -- see 4.9 Tagged Types and Type Extensions.) and then
dispatches to the subprogram denoted by the Input attribute of the
specific type identified by the internal tag; returns that result.
See section 14.13.2 Stream-Oriented Attributes.
-
S'Input
For every subtype S of a specific type T:
-
S'Input denotes a function with the following specification:
-
| | function S'Input
(Stream : access Ada.Streams.Root_Stream_Type'Class)
return T
|
-
S'Input reads and returns one value from Stream, using any bounds or
discriminants written by a corresponding S'Output to determine how much
to read. See section 14.13.2 Stream-Oriented Attributes.
-
A'Last(N)
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'Last(N) denotes the upper bound of the N-th index range; its type is
the corresponding index type. See section 4.6.2 Operations of Array Types.
-
A'Last
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'Last denotes the upper bound of the first index range; its type is the
corresponding index type. See section 4.6.2 Operations of Array Types.
-
S'Last
For every scalar subtype S:
-
S'Last denotes the upper bound of the range of S. The value of this
attribute is of the type of S. See section 4.5 Scalar Types.
-
R.C'Last_Bit
For a component C of a composite, non-array object R:
-
Denotes the offset, from the start of the first of the storage elements
occupied by C, of the last bit occupied by C. This offset is measured in
bits. The value of this attribute is of the type universal_integer.
See section 14.5.2 Storage Place Attributes.
-
S'Leading_Part
For every subtype S of a floating point type T:
-
S'Leading_Part denotes a function with the following specification:
-
| | function S'Leading_Part
(X : T;
Radix_Digits : universal_integer) return T
|
-
Let v be the value T'Machine_Radix ** (k-Radix_Digits), where k is the
normalized exponent of X. The function yields the value
-
Floor(X/v)*v, when X is nonnegative and Radix_Digits is positive;
-
Ceiling(X/v)*v, when X is negative and Radix_Digits is positive.
-
Constraint_Error is raised when Radix_Digits is zero or negative. A zero
result, which can only occur when X is zero, has the sign of X.
See section A.5.3 Attributes of Floating Point Types.
-
A'Length(N)
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'Length(N) denotes the number of values of the N-th index range (zero
for a null range); its type is universal_integer. See section 4.6.2 Operations of Array Types.
-
A'Length
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'Length denotes the number of values of the first index range (zero for
a null range); its type is universal_integer. See section 4.6.2 Operations of Array Types.
-
S'Machine
For every subtype S of a floating point type T:
-
S'Machine denotes a function with the following specification:
-
| | function S'Machine (X : T) return T
|
-
If X is a machine number of the type T, the function yields X;
otherwise, it yields the value obtained by rounding or truncating X to
either one of the adjacent machine numbers of the type T.
Constraint_Error is raised if rounding or truncating X to the precision
of the machine numbers results in a value outside the base range of S. A
zero result has the sign of X when S'Signed_Zeros is True. See section A.5.3 Attributes of Floating Point Types.
-
S'Machine_Emax
For every subtype S of a floating point type T:
-
Yields the largest (most positive) value of exponent such that every
value expressible in the canonical form (for the type T), having a
mantissa of T'Machine_Mantissa digits, is a machine number
(see section 4.5.7 Floating Point Types) of the type T. This attribute yields a value of the type
universal_integer. See section A.5.3 Attributes of Floating Point Types.
-
S'Machine_Emin
For every subtype S of a floating point type T:
-
Yields the smallest (most negative) value of exponent such that every
value expressible in the canonical form (for the type T), having a
mantissa of T'Machine_Mantissa digits, is a machine number
(see section 4.5.7 Floating Point Types) of the type T. This attribute yields a value of the type
universal_integer. See section A.5.3 Attributes of Floating Point Types.
-
S'Machine_Mantissa
For every subtype S of a floating point type T:
-
Yields the largest value of p such that every value expressible in the
canonical form (for the type T), having a p-digit mantissa and an
exponent between T'Machine_Emin and T'Machine_Emax, is a machine number
(see 4.5.7 Floating Point Types) of the type T. This attribute yields a value of the type
universal_integer. See section A.5.3 Attributes of Floating Point Types.
-
S'Machine_Overflows
For every subtype S of a fixed point type T:
-
Yields the value True if overflow and divide-by-zero are detected and
reported by raising Constraint_Error for every predefined operation that
yields a result of the type T; yields the value False otherwise. The
value of this attribute is of the predefined type Boolean. See section A.5.4 Attributes of Fixed Point Types.
-
S'Machine_Overflows
For every subtype S of a floating point type T:
-
Yields the value True if overflow and divide-by-zero are detected and
reported by raising Constraint_Error for every predefined operation that
yields a result of the type T; yields the value False otherwise. The
value of this attribute is of the predefined type Boolean. See section A.5.3 Attributes of Floating Point Types.
-
S'Machine_Radix
For every subtype S of a fixed point type T:
-
Yields the radix of the hardware representation of the type T. The value
of this attribute is of the type universal_integer. See section A.5.4 Attributes of Fixed Point Types.
-
S'Machine_Radix
For every subtype S of a floating point type T:
-
Yields the radix of the hardware representation of the type T. The value
of this attribute is of the type universal_integer. See section A.5.3 Attributes of Floating Point Types.
-
S'Machine_Rounds
For every subtype S of a fixed point type T:
-
Yields the value True if rounding is performed on inexact results of
every predefined operation that yields a result of the type T; yields
the value False otherwise. The value of this attribute is of the
predefined type Boolean. See section A.5.4 Attributes of Fixed Point Types.
-
S'Machine_Rounds
For every subtype S of a floating point type T:
-
Yields the value True if rounding is performed on inexact results of
every predefined operation that yields a result of the type T; yields
the value False otherwise. The value of this attribute is of the
predefined type Boolean. See section A.5.3 Attributes of Floating Point Types.
-
S'Max
For every scalar subtype S:
-
S'Max denotes a function with the following specification:
-
| | function S'Max(Left, Right : S'Base) return S'Base
|
-
The function returns the greater of the values of the two parameters.
See section 4.5 Scalar Types.
-
S'Max_Size_In_Storage_Elements
For every subtype S:
-
Denotes the maximum value for Size_In_Storage_Elements that will be
requested via Allocate for an access type whose designated subtype is S.
The value of this attribute is of type universal_integer.
See section 14.11.1 The Max_Size_In_Storage_Elements Attribute.
-
S'Min
For every scalar subtype S:
-
S'Min denotes a function with the following specification:
-
| | function S'Min(Left, Right : S'Base) return S'Base
|
-
The function returns the lesser of the values of the two parameters.
See section 4.5 Scalar Types.
-
S'Model
For every subtype S of a floating point type T:
-
S'Model denotes a function with the following specification:
-
| | function S'Model (X : T) return T
|
-
If the Numerics Annex is not supported, the meaning of this attribute is
implementation defined; see G.2.2 Model-Oriented Attributes of Floating Point Types for the definition that applies to
implementations supporting the Numerics Annex. See section A.5.3 Attributes of Floating Point Types.
-
S'Model_Emin
For every subtype S of a floating point type T:
-
If the Numerics Annex is not supported, this attribute yields an
implementation defined value that is greater than or equal to the value
of T'Machine_Emin. See section G.2.2 Model-Oriented Attributes of Floating Point Types for further requirements that apply to
implementations supporting the Numerics Annex. The value of this
attribute is of the type universal_integer. See section A.5.3 Attributes of Floating Point Types.
-
S'Model_Epsilon
For every subtype S of a floating point type T:
-
Yields the value T'Machine_Radix ** (1-T'Model_Mantissa). The value of
this attribute is of the type universal_real. See section A.5.3 Attributes of Floating Point Types.
-
S'Model_Mantissa
For every subtype S of a floating point type T:
-
If the Numerics Annex is not supported, this attribute yields an
implementation defined value that is greater than or equal to
Ceiling(d*log (10)/log (T'Machine_Radix))+1, where d is the requested
decimal precision of T, and less than or equal to the value of
T'Machine_Mantissa. See section G.2.2 Model-Oriented Attributes of Floating Point Types for further requirements that apply to
implementations supporting the Numerics Annex. The value of this
attribute is of the type universal_integer. See section A.5.3 Attributes of Floating Point Types.
-
S'Model_Small
For every subtype S of a floating point type T:
-
Yields the value T'Machine_Radix ** (T'Model_Emin-1). The value of this
attribute is of the type universal_real. See section A.5.3 Attributes of Floating Point Types.
-
S'Modulus
For every modular subtype S:
-
S'Modulus yields the modulus of the type of S, as a value of the type
universal_integer. See section 4.5.4 Integer Types.
-
S'Class'Output
For every subtype S'Class of a class-wide type T'Class:
-
S'Class'Output denotes a procedure with the following specification:
-
| | procedure S'Class'Output
(Stream : access Ada.Streams.Root_Stream_Type'Class;
Item : in T'Class)
|
-
First writes the external tag of Item to Stream (by calling
String'Output(Tags.External_Tag(Item'Tag) -- see 4.9 Tagged Types and Type Extensions.) and then
dispatches to the subprogram denoted by the Output attribute of the
specific type identified by the tag. See section 14.13.2 Stream-Oriented Attributes.
-
S'Output
For every subtype S of a specific type T:
-
S'Output denotes a procedure with the following specification:
-
| | procedure S'Output
(Stream : access Ada.Streams.Root_Stream_Type'Class;
Item : in T)
|
-
S'Output writes the value of Item to Stream, including any bounds or
discriminants. See section 14.13.2 Stream-Oriented Attributes.
-
D'Partition_ID
For a prefix D that denotes a library-level declaration, excepting a
declaration of or within a declared-pure library unit:
-
Denotes a value of the type universal_integer that identifies the
partition in which D was elaborated. If D denotes the declaration of a
remote call interface library unit, see E.2.3 Remote Call Interface Library Units, the given partition is
the one where the body of D was elaborated. See section E.1 Partitions.
-
S'Pos
For every discrete subtype S:
-
S'Pos denotes a function with the following specification:
-
| | function S'Pos(Arg : S'Base) return universal_integer
|
-
This function returns the position number of the value of Arg, as a
value of type universal_integer. See section 4.5.5 Operations of Discrete Types.
-
R.C'Position
For a component C of a composite, non-array object R:
-
Denotes the same value as R.C'Address - R'Address. The value of this
attribute is of the type universal_integer. See section 14.5.2 Storage Place Attributes.
-
S'Pred
For every scalar subtype S:
-
S'Pred denotes a function with the following specification:
-
| | function S'Pred(Arg : S'Base) return S'Base
|
-
For an enumeration type, the function returns the value whose position
number is one less than that of the value of Arg; Constraint_Error is
raised if there is no such value of the type. For an integer type, the
function returns the result of subtracting one from the value of Arg.
For a fixed point type, the function returns the result of subtracting
small from the value of Arg. For a floating point type, the function
returns the machine number (as defined in 4.5.7 Floating Point Types.) immediately
below the value of Arg; Constraint_Error is raised if there is no such
machine number. See section 4.5 Scalar Types.
-
A'Range(N)
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'Range(N) is equivalent to the range A'First(N) .. A'Last(N), except
that the prefix A is only evaluated once. See section 4.6.2 Operations of Array Types.
-
A'Range
For a prefix A that is of an array type (after any implicit
dereference), or denotes a constrained array subtype:
-
A'Range is equivalent to the range A'First .. A'Last, except that the
prefix A is only evaluated once. See section 4.6.2 Operations of Array Types.
-
S'Range
For every scalar subtype S:
-
S'Range is equivalent to the range S'First .. S'Last. See section 4.5 Scalar Types.
-
S'Class'Read
For every subtype S'Class of a class-wide type T'Class:
-
S'Class'Read denotes a procedure with the following specification:
-
| | procedure S'Class'Read
(Stream : access Ada.Streams.Root_Stream_Type'Class;
Item : out T'Class)
|
-
Dispatches to the subprogram denoted by the Read attribute of the
specific type identified by the tag of Item. See section 14.13.2 Stream-Oriented Attributes.
-
S'Read
For every subtype S of a specific type T:
-
S'Read denotes a procedure with the following specification:
-
| | procedure S'Read
(Stream : access Ada.Streams.Root_Stream_Type'Class;
Item : out T)
|
-
S'Read reads the value of Item from Stream. See section 14.13.2 Stream-Oriented Attributes.
-
S'Remainder
For every subtype S of a floating point type T:
-
S'Remainder denotes a function with the following specification:
-
| | function S'Remainder (X, Y : T) return T
|
-
For nonzero Y, let v be the value X-n*Y, where n is the integer nearest
to the exact value of X/Y; if |n-X/Y|=1/2, then n is chosen to be even.
If v is a machine number of the type T, the function yields v;
otherwise, it yields zero. Constraint_Error is raised if Y is zero. A
zero result has the sign of X when S'Signed_Zeros is True. See section A.5.3 Attributes of Floating Point Types.
-
S'Round
For every decimal fixed point subtype S:
-
S'Round denotes a function with the following specification:
-
| | function S'Round(X : universal_real) return S'Base
|
-
The function returns the value obtained by rounding X (away from 0, if X
is midway between two values of the type of S). See section 4.5.10 Operations of Fixed Point Types.
-
S'Rounding
For every subtype S of a floating point type T:
-
S'Rounding denotes a function with the following specification:
-
| | function S'Rounding (X : T) return T
|
-
The function yields the integral value nearest to X, rounding away from
zero if X lies exactly halfway between two integers. A zero result has
the sign of X when S'Signed_Zeros is True. See section A.5.3 Attributes of Floating Point Types.
-
S'Safe_First
For every subtype S of a floating point type T:
-
Yields the lower bound of the safe range, see 4.5.7 Floating Point Types, of the type T.
If the Numerics Annex is not supported, the value of this attribute is
implementation defined; See section G.2.2 Model-Oriented Attributes of Floating Point Types for the definition that applies to
implementations supporting the Numerics Annex. The value of this
attribute is of the type universal_real. See section A.5.3 Attributes of Floating Point Types.
-
S'Safe_Last
For every subtype S of a floating point type T:
-
Yields the upper bound of the safe range, see 4.5.7 Floating Point Types of the type T. If
the Numerics Annex is not supported, the value of this attribute is
implementation defined; See section G.2.2 Model-Oriented Attributes of Floating Point Types for the definition that applies to
implementations supporting the Numerics Annex. The value of this
attribute is of the type universal_real. See section A.5.3 Attributes of Floating Point Types.
-
S'Scale
For every decimal fixed point subtype S:
-
S'Scale denotes the scale of the subtype S, defined as the value N such
that S'Delta = 10.0**(-N). The scale indicates the position of the point
relative to the rightmost significant digits of values of subtype S. The
value of this attribute is of the type universal_integer. See section 4.5.10 Operations of Fixed Point Types.
-
S'Scaling
For every subtype S of a floating point type T:
-
S'Scaling denotes a function with the following specification:
-
| | function S'Scaling
(X : T;
Adjustment : universal_integer) return T
|
-
Let v be the value X*T'Machine_Radix ** Adjustment. If v is a machine
number of the type T, or if |v|>=T'Model_Small, the function yields v;
otherwise, it yields either one of the machine numbers of the type T
adjacent to v. Constraint_Error is optionally raised if v is outside the
base range of S. A zero result has the sign of X when S'Signed_Zeros is
True. See section A.5.3 Attributes of Floating Point Types.
-
S'Signed_Zeros
For every subtype S of a floating point type T:
-
Yields the value True if the hardware representation for the type T has
the capability of representing both positively and negatively signed
zeros, these being generated and used by the predefined operations of
the type T as specified in IEC 559:1989; yields the value False
otherwise. The value of this attribute is of the predefined type
Boolean. See section A.5.3 Attributes of Floating Point Types.
-
S'Size
For every subtype S:
-
If S is definite, denotes the size (in bits) that the implementation
would choose for the following objects of subtype S:
-
A record component of subtype S when the record type is packed.
-
The formal parameter of an instance of Unchecked_Conversion that
converts from subtype S to some other subtype.
-
If S is indefinite, the meaning is implementation defined. The value of
this attribute is of the type universal_integer. See section 14.3 Representation Attributes.
-
X'Size
For a prefix X that denotes an object:
-
Denotes the size in bits of the representation of the object. The value
of this attribute is of the type universal_integer. See section 14.3 Representation Attributes.
-
S'Small
For every fixed point subtype S:
-
S'Small denotes the small of the type of S. The value of this attribute
is of the type universal_real. See section 4.5.10 Operations of Fixed Point Types.
-
S'Storage_Pool
For every access subtype S:
-
Denotes the storage pool of the type of S. The type of this attribute is
Root_Storage_Pool'Class. See section 14.11 Storage Management.
-
S'Storage_Size
For every access subtype S:
-
Yields the result of calling Storage_Size(S'Storage_Pool), which is
intended to be a measure of the number of storage elements reserved for
the pool. The type of this attribute is universal_integer. See section 14.11 Storage Management.
-
T'Storage_Size
For a prefix T that denotes a task object (after any implicit
dereference):
-
Denotes the number of storage elements reserved for the task. The value
of this attribute is of the type universal_integer. The Storage_Size
includes the size of the task's stack, if any. The language does not
specify whether or not it includes other storage associated with the
task (such as the "task control block" used by some implementations.)
See section 14.3 Representation Attributes.
-
S'Succ
For every scalar subtype S:
-
S'Succ denotes a function with the following specification:
-
| | function S'Succ(Arg : S'Base) return S'Base
|
-
For an enumeration type, the function returns the value whose position
number is one more than that of the value of Arg; Constraint_Error is
raised if there is no such value of the type. For an integer type, the
function returns the result of adding one to the value of Arg. For a
fixed point type, the function returns the result of adding small to the
value of Arg. For a floating point type, the function returns the
machine number (as defined in 4.5.7 Floating Point Types.) immediately above the value
of Arg; Constraint_Error is raised if there is no such machine number.
See section 4.5 Scalar Types.
-
S'Tag
For every subtype S of a tagged type T (specific or class-wide):
-
S'Tag denotes the tag of the type T (or if T is class-wide, the tag of
the root type of the corresponding class). The value of this attribute
is of type Tag. See section 4.9 Tagged Types and Type Extensions.
-
X'Tag
For a prefix X that is of a class-wide tagged type (after any implicit
dereference):
-
X'Tag denotes the tag of X. The value of this attribute is of type Tag.
See section 4.9 Tagged Types and Type Extensions.
-
T'Terminated
For a prefix T that is of a task type (after any implicit dereference):
-
Yields the value True if the task denoted by T is terminated, and False
otherwise. The value of this attribute is of the predefined type
Boolean. See section 10.9 Task and Entry Attributes.
-
S'Truncation
For every subtype S of a floating point type T:
-
S'Truncation denotes a function with the following specification:
-
| | function S'Truncation (X : T) return T
|
-
The function yields the value Ceiling(X) when X is negative, and
Floor(X) otherwise. A zero result has the sign of X when S'Signed_Zeros
is True. See section A.5.3 Attributes of Floating Point Types.
-
S'Unbiased_Rounding
For every subtype S of a floating point type T:
-
S'Unbiased_Rounding denotes a function with the following specification:
-
| | function S'Unbiased_Rounding (X : T) return T
|
-
The function yields the integral value nearest to X, rounding toward the
even integer if X lies exactly halfway between two integers. A zero
result has the sign of X when S'Signed_Zeros is True. See section A.5.3 Attributes of Floating Point Types.
-
X'Unchecked_Access
For a prefix X that denotes an aliased view of an object:
-
All rules and semantics that apply to X'Access, see 4.10.2 Operations of Access Types, apply
also to X'Unchecked_Access, except that, for the purposes of
accessibility rules and checks, it is as if X were declared immediately
within a library package. See section 14.10 Unchecked Access Value Creation.
-
S'Val
For every discrete subtype S:
-
S'Val denotes a function with the following specification:
-
| | function S'Val(Arg : universal_integer) return S'Base
|
-
This function returns a value of the type of S whose position number
equals the value of Arg. See section 4.5.5 Operations of Discrete Types.
-
262 X'Valid
For a prefix X that denotes a scalar object (after any implicit
dereference):
-
Yields True if and only if the object denoted by X is normal and has a
valid representation. The value of this attribute is of the predefined
type Boolean. See section 14.9.2 The Valid Attribute.
-
S'Value
For every scalar subtype S:
-
S'Value denotes a function with the following specification:
-
| | function S'Value(Arg : String) return S'Base
|
-
This function returns a value given an image of the value as a String,
ignoring any leading or trailing spaces. See section 4.5 Scalar Types.
-
P'Version
For a prefix P that statically denotes a program unit:
-
Yields a value of the predefined type String that identifies the version
of the compilation unit that contains the declaration of the program
unit. See section E.3 Consistency of a Distributed System.
-
S'Wide_Image
For every scalar subtype S:
-
S'Wide_Image denotes a function with the following specification:
-
| | function S'Wide_Image(Arg : S'Base) return Wide_String
|
-
The function returns an image of the value of Arg, that is, a sequence
of characters representing the value in display form. See section 4.5 Scalar Types.
-
S'Wide_Value
For every scalar subtype S:
-
S'Wide_Value denotes a function with the following specification:
-
| | function S'Wide_Value(Arg : Wide_String) return S'Base
|
-
This function returns a value given an image of the value as a
Wide_String, ignoring any leading or trailing spaces. See section 4.5 Scalar Types.
-
S'Wide_Width
For every scalar subtype S:
-
S'Wide_Width denotes the maximum length of a Wide_String returned by
S'Wide_Image over all values of the subtype S. It denotes zero for a
subtype that has a null range. Its type is universal_integer.
See section 4.5 Scalar Types.
-
S'Width
For every scalar subtype S:
-
S'Width denotes the maximum length of a String returned by S'Image over
all values of the subtype S. It denotes zero for a subtype that has a
null range. Its type is universal_integer. See section 4.5 Scalar Types.
-
S'Class'Write
For every subtype S'Class of a class-wide type T'Class:
-
S'Class'Write denotes a procedure with the following specification:
-
| | procedure S'Class'Write
(Stream : access Ada.Streams.Root_Stream_Type'Class;
Item : in T'Class)
|
-
Dispatches to the subprogram denoted by the Write attribute of the
specific type identified by the tag of Item. See section 14.13.2 Stream-Oriented Attributes.
-
S'Write
For every subtype S of a specific type T:
-
S'Write denotes a procedure with the following specification:
-
| | procedure S'Write
(Stream : access Ada.Streams.Root_Stream_Type'Class;
Item : in T)
|
-
S'Write writes the value of Item to Stream. See section 14.13.2 Stream-Oriented Attributes.
K. Language-Defined Pragmas (informative)
-
This Annex summarizes the definitions given elsewhere of the
language-defined pragmas.
-
-
-
-
-
-
-
-
-
-
-
-
| | pragma Export( [Convention =>] convention_identifier,
[Entity =>] local_name [, [External_Name =>] string_expression]
[, [Link_Name =>] string_expression]);
-- see B.1 Interfacing Pragmas.
|
-
| | pragma Import( [Convention =>] convention_identifier,
[Entity =>] local_name [, [External_Name =>] string_expression]
[, [Link_Name =>] string_expression]);
-- see B.1 Interfacing Pragmas.
|
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
L. Implementation-Defined Characteristics (informative)
-
The Ada language allows for certain machine dependences in a controlled
manner. Each Ada implementation must document all implementation-defined
characteristics:
-
Whether or not each recommendation given in Implementation Advice is
followed. See section 1.1.2(37).
-
Capacity limitations of the implementation. See section 1.1.3(3).
-
Variations from the standard that are impractical to avoid given the
implementation's execution environment. See section 1.1.3(6).
-
Which code_statements cause external interactions. See section 1.1.3(10).
-
The coded representation for the text of an Ada program. See section 3.1 Character Set,
(4).
-
The control functions allowed in comments. See section 2.1(14).
-
The representation for an end of line. See section 2.2(2).
-
Maximum supported line length and lexical element length. See section 3.2 Lexical Elements, Separators, and Delimiters,
(15).
-
Implementation-defined pragmas. See section 2.8(14).
-
Effect of pragma Optimize. See section 2.8(27).
-
The sequence of characters of the value returned by S'Image when some of
the graphic characters of S'Wide_Image are not defined in Character.
See section 3.5(37).
-
The predefined integer types declared in Standard. See section 3.5.4(25).
-
Any nonstandard integer types and the operators defined for them.
See section 3.5.4(26).
-
Any nonstandard real types and the operators defined for them.
See section 3.5.6(8).
-
What combinations of requested decimal precision and range are supported
for floating point types. See section 3.5.7(7).
-
The predefined floating point types declared in Standard. See section 4.5.7 Floating Point Types,
(16).
-
The small of an ordinary fixed point type. See section 3.5.9(8).
-
What combinations of small, range, and digits are supported for fixed
point types. See section 3.5.9(10).
-
The result of Tags.Expanded_Name for types declared within an unnamed
block_statement. See section 3.9(10).
-
Implementation-defined attributes. See section 4.1.4(12).
-
Any implementation-defined time types. See section 9.6(6).
-
The time base associated with relative delays. See section 9.6(20).
-
The time base of the type Calendar.Time. See section 9.6(23).
-
The timezone used for package Calendar operations. See section 9.6(24).
-
Any limit on delay_until_statements of select_statements. See section 10.6 Delay Statements, Duration, and Time,
(29).
-
Whether or not two nonoverlapping parts of a composite object are
independently addressable, in the case where packing, record layout, or
Component_Size is specified for the object. See section 9.10(1).
-
The representation for a compilation. See section 10.1(2).
-
Any restrictions on compilations that contain multiple
compilation_units. See section 10.1(4).
-
The mechanisms for creating an environment and for adding and replacing
compilation units. See section 10.1.4(3).
-
The manner of explicitly assigning library units to a partition.
See section 10.2(2).
-
The implementation-defined means, if any, of specifying which
compilation units are needed by a given compilation unit. See section 11.2 Program Execution,
(2).
-
The manner of designating the main subprogram of a partition.
See section 10.2(7).
-
The order of elaboration of library_items. See section 10.2(18).
-
Parameter passing and function return for the main subprogram.
See section 10.2(21).
-
The mechanisms for building and running partitions. See section 10.2(24).
-
The details of program execution, including program termination.
See section 10.2(25).
-
The semantics of any nonactive partitions supported by the
implementation. See section 10.2(28).
-
The information returned by Exception_Message. See section 11.4.1(10).
-
The result of Exceptions.Exception_Name for types declared within an
unnamed block_statement. See section 11.4.1(12).
-
The information returned by Exception_Information. See section 11.4.1(13).
-
Implementation-defined check names. See section 11.5(27).
-
The interpretation of each aspect of representation. See section 13.1(20).
-
Any restrictions placed upon representation items. See section 13.1(20).
-
The meaning of Size for indefinite subtypes. See section 13.3(48).
-
The default external representation for a type tag. See section 13.3(75).
-
What determines whether a compilation unit is the same in two different
partitions. See section 13.3(76).
-
Implementation-defined components. See section 13.5.1(15).
-
If Word_Size = Storage_Unit, the default bit ordering. See section 14.5.3 Bit Ordering,
(5).
-
The contents of the visible part of package System and its
language-defined children. See section 13.7(2).
-
The contents of the visible part of package System.Machine_Code, and the
meaning of code_statements. See section 13.8(7).
-
The effect of unchecked conversion. See section 13.9(11).
-
The manner of choosing a storage pool for an access type when
Storage_Pool is not specified for the type. See section 13.11(17).
-
Whether or not the implementation provides user-accessible names for the
standard pool type(s). See section 13.11(17).
-
The meaning of Storage_Size. See section 13.11(18).
-
Implementation-defined aspects of storage pools. See section 13.11(22).
-
The set of restrictions allowed in a pragma Restrictions. See section 14.12 Pragma Restrictions,
(7).
-
The consequences of violating limitations on Restrictions pragmas.
See section 13.12(9).
-
The representation used by the Read and Write attributes of elementary
types in terms of stream elements. See section 13.13.2(9).
-
The names and characteristics of the numeric subtypes declared in the
visible part of package Standard. See section A.1(3).
-
The accuracy actually achieved by the elementary functions.
See section A.5.1(1).
-
The sign of a zero result from some of the operators or functions in
Numerics.Generic_Elementary_Functions, when Float_Type'Signed_Zeros is
True. See section A.5.1(46).
-
The value of Numerics.Float_Random.Max_Image_Width. See section A.5.2(27).
-
The value of Numerics.Discrete_Random.Max_Image_Width. See section A.5.2 Random Number Generation,
(27).
-
The algorithms for random number generation. See See section 2(32).
-
The string representation of a random number generator's state.
See section A.5.2(38).
-
The minimum time interval between calls to the time-dependent Reset
procedure that are guaranteed to initiate different random number
sequences. See section A.5.2(45).
-
The values of the Model_Mantissa, Model_Emin, Model_Epsilon, Model,
Safe_First, and Safe_Last attributes, if the Numerics Annex is not
supported. See section A.5.3(72).
-
Any implementation-defined characteristics of the input-output packages.
See section A.7(14).
-
The value of Buffer_Size in Storage_IO. See section A.9(10).
-
external files for standard input, standard output, and standard error.
See section A.10(5).
-
The accuracy of the value produced by Put. See section A.10.9(36).
-
The meaning of Argument_Count, Argument, and Command_Name. See section A.15 The Package Command_Line,
(1).
-
Implementation-defined convention names. See section B.1(11).
-
The meaning of link names. See section B.1(36).
-
The manner of choosing link names when neither the link name nor the
address of an imported or exported entity is specified. See section B.1 Interfacing Pragmas,
(36).
-
The effect of pragma Linker_Options. See section B.1(37).
-
The contents of the visible part of package Interfaces and its
language-defined descendants. See section B.2(1).
-
Implementation-defined children of package Interfaces. The contents of
the visible part of package Interfaces. See section 12. Exceptions.
-
The types Floating, Long_Floating, Binary, Long_Binary, Decimal_Element,
and COBOL_Character; and the initializations of the variables
Ada_To_COBOL and COBOL_To_Ada, in Interfaces.COBOL See section B.4(50).
-
Support for access to machine instructions. See section C.1(1).
-
Implementation-defined aspects of access to machine operations.
See section C.1(9).
-
Implementation-defined aspects of interrupts. See section C.3(2).
-
Implementation-defined aspects of preelaboration. See section C.4(13).
-
The semantics of pragma Discard_Names. See section C.5(7).
-
The result of the Task_Identification.Image attribute. See section C.7.1 The Package Task_Identification,
(7).
-
The value of Current_Task when in a protected entry or interrupt
handler. See section C.7.1(17).
-
The effect of calling Current_Task from an entry body or interrupt
handler. See section C.7.1(19).
-
Implementation-defined aspects of Task_Attributes. See section C.7.2(19).
-
Values of all Metrics. See section D(2).
-
The declarations of Any_Priority and Priority. See section D.1(11).
-
Implementation-defined execution resources. See section D.1(15).
-
Whether, on a multiprocessor, a task that is waiting for access to a
protected object keeps its processor busy. See section D.2.1(3).
-
The affect of implementation defined execution resources on task
dispatching. See section D.2.1(9).
-
Implementation-defined policy_identifiers allowed in a pragma
Task_Dispatching_Policy. See section D.2.2(3).
-
Implementation-defined aspects of priority inversion. See section D.2.2 The Standard Task Dispatching Policy,
(16).
-
Implementation defined task dispatching. See section D.2.2(18).
-
Implementation-defined policy_identifiers allowed in a pragma
Locking_Policy. See section D.3(4).
-
Default ceiling priorities. See section D.3(10).
-
The ceiling of any protected object used internally by the
implementation. See section D.3(16).
-
Implementation-defined queuing policies. See section D.4(1).
-
On a multiprocessor, any conditions that cause the completion of an
aborted construct to be delayed later than what is specified for a
single processor. See section D.6(3).
-
Any operations that implicitly require heap storage allocation.
See section D.7(8).
-
Implementation-defined aspects of pragma Restrictions. See section D.7(20).
-
Implementation-defined aspects of package Real_Time. See section D.8(17).
-
Implementation-defined aspects of delay_statements. See section D.9(8).
-
The upper bound on the duration of interrupt blocking caused by the
implementation. See section D.12(5).
-
The means for creating and executing distributed programs. See section E. Distributed Systems (normative),
(5).
-
Any events that can result in a partition becoming inaccessible.
See section E.1(7).
-
The scheduling policies, treatment of priorities, and management of
shared resources between partitions in certain cases. See section E.1(11).
-
Events that cause the version of a compilation unit to change.
See section E.3(5).
-
Whether the execution of the remote subprogram is immediately aborted as
a result of cancellation. See section E.4(13).
-
Implementation-defined aspects of the PCS. See section E.5(25).
-
Implementation-defined interfaces in the PCS. See section E.5(26).
-
The values of named numbers in the package Decimal. See section F.2(7).
-
The value of Max_Picture_Length in the package Text_IO.Editing
See section F.3.3(16).
-
The value of Max_Picture_Length in the package Wide_Text_IO.Editing
See section F.3.4(5).
-
The accuracy actually achieved by the complex elementary functions and
by other complex arithmetic operations. See section G.1(1).
-
The sign of a zero result (or a component thereof) from any operator or
function in Numerics.Generic_Complex_Types, when Real'Signed_Zeros is
True. See section G.1.1(53).
-
The sign of a zero result (or a component thereof) from any operator or
function in Numerics.Generic_Complex_Elementary_Functions, when
Complex_Types.Real'Signed_Zeros is True. See section G.1.2(45).
-
Whether the strict mode or the relaxed mode is the default. See section G.2 Numeric Performance Requirements,
(2).
-
The result interval in certain cases of fixed-to-float conversion.
See section G.2.1(10).
-
The result of a floating point arithmetic operation in overflow
situations, when the Machine_Overflows attribute of the result type is
False. See section G.2.1(13).
-
The result interval for division (or exponentiation by a negative
exponent), when the floating point hardware implements division as
multiplication by a reciprocal. See section G.2.1(16).
-
The definition of close result set, which determines the accuracy of
certain fixed point multiplications and divisions. See section G.2.3(5).
-
Conditions on a universal_real operand of a fixed point multiplication
or division for which the result shall be in the perfect result set.
See section G.2.3(22).
-
The result of a fixed point arithmetic operation in overflow situations,
when the Machine_Overflows attribute of the result type is False.
See section G.2.3(27).
-
The result of an elementary function reference in overflow situations,
when the Machine_Overflows attribute of the result type is False.
See section G.2.4(4).
-
The value of the angle threshold, within which certain elementary
functions, complex arithmetic operations, and complex elementary
functions yield results conforming to a maximum relative error bound.
See section G.2.4(10).
-
The accuracy of certain elementary functions for parameters beyond the
angle threshold. See section G.2.4(10).
-
The result of a complex arithmetic operation or complex elementary
function reference in overflow situations, when the Machine_Overflows
attribute of the corresponding real type is False. See section G.2.6(5).
-
The accuracy of certain complex arithmetic operations and certain
complex elementary functions for parameters (or components thereof)
beyond the angle threshold. See section G.2.6(8).
-
Information regarding bounded errors and erroneous execution.
See section H.2(1).
-
Implementation-defined aspects of pragma Inspection_Point. See section H.3.2 Pragma Inspection_Point,
(8).
-
Implementation-defined aspects of pragma Restrictions. See section H.4(25).
-
Any restrictions on pragma Restrictions. See section H.4(27).
M. Glossary (informative)
-
This Annex contains informal descriptions of some terms used in this
International Standard. To find more formal definitions, look the term
up in the index.
-
Access type. An access type has values that designate aliased
objects. Access types correspond to "pointer types" or "reference
types" in some other languages.
-
Aliased. An aliased view of an object is one that can be
designated by an access value. Objects allocated by allocators are
aliased. Objects can also be explicitly declared as aliased with the
reserved word aliased. The Access attribute can be used to create an
access value designating an aliased object.
-
Array type. An array type is a composite type whose components
are all of the same type. Components are selected by indexing.
-
Character type. A character type is an enumeration type whose
values include characters.
-
Class. A class is a set of types that is closed under
derivation, which means that if a given type is in the class, then all
types derived from that type are also in the class. The set of types of
a class share common properties, such as their primitive operations.
-
Compilation unit. The text of a program can be submitted to the
compiler in one or more compilations. Each compilation is a succession
of compilation_units. A compilation_unit contains either the
declaration, the body, or a renaming of a program unit.
-
Composite type. A composite type has components.
-
Construct. A construct is a piece of text (explicit or
implicit) that is an instance of a syntactic category defined under
"Syntax."
-
Controlled type. A controlled type supports user-defined
assignment and finalization. Objects are always finalized before being
destroyed.
Declaration. A declaration is a language construct that
associates a name with (a view of) an entity. A declaration may appear
explicitly in the program text (an explicit declaration), or may be
supposed to occur at a given place in the text as a consequence of the
semantics of another construct (an implicit declaration).
-
Definition. All declarations contain a definition for a view of
an entity. A view consists of an identification of the entity (the
entity of the view), plus view-specific characteristics that affect the
use of the entity through that view (such as mode of access to an
object, formal parameter names and defaults for a subprogram, or
visibility to components of a type). In most cases, a declaration also
contains the definition for the entity itself (a renaming_declaration is
an example of a declaration that does not define a new entity, but
instead defines a view of an existing entity, see 9.5 Renaming Declarations.
-
Derived type. A derived type is a type defined in terms of
another type, which is the parent type of the derived type. Each class
containing the parent type also contains the derived type. The derived
type inherits properties such as components and primitive operations
from the parent. A type together with the types derived from it
(directly or indirectly) form a derivation class.
-
Discrete type. A discrete type is either an integer type or an
enumeration type. Discrete types may be used, for example, in
case_statements and as array indices.
-
Discriminant. A discriminant is a parameter of a composite
type. It can control, for example, the bounds of a component of the type
if that type is an array type. A discriminant of a task type can be used
to pass data to a task of the type upon creation.
-
Elementary type. An elementary type does not have components.
-
Enumeration type. An enumeration type is defined by an
enumeration of its values, which may be named by identifiers or
character literals.
-
Exception. An exception represents a kind of exceptional
situation; an occurrence of such a situation (at run time) is called an
exception occurrence. To raise an exception is to abandon normal program
execution so as to draw attention to the fact that the corresponding
situation has arisen. Performing some actions in response to the arising
of an exception is called handling the exception.
-
Execution. The process by which a construct achieves its
run-time effect is called execution. Execution of a declaration is also
called elaboration. Execution of an expression is also called
evaluation.
-
Generic unit. A generic unit is a template for a (nongeneric)
program unit; the template can be parameterized by objects, types,
subprograms, and packages. An instance of a generic unit is created by a
generic_instantiation. The rules of the language are enforced when a
generic unit is compiled, using a generic contract model; additional
checks are performed upon instantiation to verify the contract is met.
That is, the declaration of a generic unit represents a contract between
the body of the generic and instances of the generic. Generic units can
be used to perform the role that macros sometimed play in other
languages.
-
Integer type. Integer types comprise the signed integer types
and the modular types. A signed integer type has a base range that
includes both positive and negative numbers, and has operations that may
raise an exception when the result is outside the base range. A modular
type has a base range whose lower bound is zero, and has operations with
"wraparound" semantics. Modular types subsume what are called
"unsigned types" in some other languages.
-
Library unit. A library unit is a separately compiled program
unit, and is always a package, subprogram, or generic unit. Library
units may have other (logically nested) library units as children, and
may have other program units physically nested within them. A root
library unit, together with its children and grandchildren and so on,
form a subsystem.
-
Limited type. A limited type is (a view of) a type for which
the assignment operation is not allowed. A nonlimited type is a (view of
a) type for which the assignment operation is allowed.
-
Object. An object is either a constant or a variable. An object
contains a value. An object is created by an object_declaration or by an
allocator. A formal parameter is (a view of) an object. A subcomponent
of an object is an object.
-
Package. Packages are program units that allow the
specification of groups of logically related entities. Typically, a
package contains the declaration of a type (often a private type or
private extension) along with the declarations of primitive subprograms
of the type, which can be called from outside the package, while their
inner workings remain hidden from outside users.
-
Partition. A partition is a part of a program. Each partition
consists of a set of library units. Each partition may run in a separate
address space, possibly on a separate computer. A program may contain
just one partition. A distributed program typically contains multiple
partitions, which can execute concurrently.
-
Pragma. A pragma is a compiler directive. There are
language-defined pragmas that give instructions for optimization,
listing control, etc. An implementation may support additional
(implementation-defined) pragmas.
-
Primitive operations. The primitive operations of a type are
the operations (such as subprograms) declared together with the type
declaration. They are inherited by other types in the same class of
types. For a tagged type, the primitive subprograms are dispatching
subprograms, providing run-time polymorphism. A dispatching subprogram
may be called with statically tagged operands, in which case the
subprogram body invoked is determined at compile time. Alternatively, a
dispatching subprogram may be called using a dispatching call, in which
case the subprogram body invoked is determined at run time.
-
Private extension. A private extension is like a record
extension, except that the components of the extension part are hidden
from its clients.
-
Private type. A private type is a partial view of a type whose
full view is hidden from its clients.
-
Program unit. A program unit is either a package, a task unit,
a protected unit, a protected entry, a generic unit, or an explicitly
declared subprogram other than an enumeration literal. Certain kinds of
program units can be separately compiled. Alternatively, they can appear
physically nested within other program units.
-
Program. A program is a set of partitions, each of which may
execute in a separate address space, possibly on a separate computer. A
partition consists of a set of library units.
-
Protected type. A protected type is a composite type whose
components are protected from concurrent access by multiple tasks.
-
Real type. A real type has values that are approximations of
the real numbers. Floating point and fixed point types are real types.
-
Record extension. A record extension is a type that extends
another type by adding additional components.
-
Record type. A record type is a composite type consisting of
zero or more named components, possibly of different types.
-
Scalar type. A scalar type is either a discrete type or a real
type.
-
Subtype. A subtype is a type together with a constraint, which
constrains the values of the subtype to satisfy a certain condition. The
values of a subtype are a subset of the values of its type.
-
Tagged type. The objects of a tagged type have a run-time type
tag, which indicates the specific type with which the object was
originally created. An operand of a class-wide tagged type can be used
in a dispatching call; the tag indicates which subprogram body to
invoke. Nondispatching calls, in which the subprogram body to invoke is
determined at compile time, are also allowed. Tagged types may be
extended with additional components.
-
Task type. A task type is a composite type whose values are
tasks, which are active entities that may execute concurrently with
other tasks. The top-level task of a partition is called the environment
task.
-
Type. Each object has a type. A type has an associated set of
values, and a set of primitive operations which implement the
fundamental aspects of its semantics. Types are grouped into classes.
The types of a given class share a set of primitive operations. Classes
are closed under derivation; that is, if a type is in a class, then all
of its derivatives are in that class.
-
View. (See Definition.)
N. Syntax Summary (informative)
-
This Annex summarizes the complete syntax of the language. 2.1.4 Method of Description and Syntax Notation,
for a description of the notation used.
| | 3.1 Character Set
character ::=
graphic_character
| format_effector
| other_control_function
3.1 Character Set
graphic_character ::=
identifier_letter
| digit
| space_character
| special_character
3.3 Identifiers
identifier ::= identifier_letter {[underline] letter_or_digit}
3.3 Identifiers
letter_or_digit ::= identifier_letter | digit
3.4 Numeric Literals
numeric_literal ::= decimal_literal | based_literal
3.4.1 Decimal Literals
decimal_literal ::= numeral [.numeral] [exponent]
3.4.1 Decimal Literals
numeral ::= digit {[underline] digit}
3.4.1 Decimal Literals
exponent ::= E [+] numeral | E - numeral
3.4.2 Based Literals
based_literal ::= base # based_numeral [.based_numeral] # [exponent]
3.4.2 Based Literals
base ::= numeral
3.4.2 Based Literals
based_numeral ::= extended_digit {[underline] extended_digit}
3.4.2 Based Literals
extended_digit ::= digit | A | B | C | D | E | F
3.5 Character Literals
character_literal ::= 'graphic_character'
3.6 String Literals
string_literal ::= "{string_element}"
3.6 String Literals
string_element ::= "" | non_quotation_mark_graphic_character
A string_element is either a pair of quotation marks (""), or a
single graphic_character other than a quotation mark.
3.7 Comments
comment ::= --{non_end_of_line_character}
3.8 Pragmas
pragma ::=
pragma identifier [(pragma_argument_association
{, pragma_argument_association})];
3.8 Pragmas
pragma_argument_association ::=
[pragma_argument_identifier =>] name
| [pragma_argument_identifier =>] expression
4.1 Declarations
basic_declaration ::=
type_declaration | subtype_declaration
| object_declaration | number_declaration
| subprogram_declaration | abstract_subprogram_declaration
| package_declaration | renaming_declaration
| exception_declaration | generic_declaration
| generic_instantiation
4.1 Declarations
defining_identifier ::= identifier
4.2.1 Type Declarations
type_declaration ::=
full_type_declaration
| incomplete_type_declaration
| private_type_declaration
| private_extension_declaration
4.2.1 Type Declarations
full_type_declaration ::=
type defining_identifier [known_discriminant_part]
is type_definition;
| task_type_declaration
| protected_type_declaration
4.2.1 Type Declarations
type_definition ::=
enumeration_type_definition | integer_type_definition
| real_type_definition | array_type_definition
| record_type_definition | access_type_definition
| derived_type_definition
4.2.2 Subtype Declarations
subtype_declaration ::=
subtype defining_identifier is subtype_indication;
4.2.2 Subtype Declarations
subtype_indication ::= subtype_mark [constraint]
4.2.2 Subtype Declarations
subtype_mark ::= subtype_name
4.2.2 Subtype Declarations
constraint ::= scalar_constraint | composite_constraint
4.2.2 Subtype Declarations
scalar_constraint ::=
range_constraint | digits_constraint | delta_constraint
4.2.2 Subtype Declarations
composite_constraint ::=
index_constraint | discriminant_constraint
4.3.1 Object Declarations
object_declaration ::=
defining_identifier_list : [aliased] [constant]
subtype_indication [:= expression];
| defining_identifier_list : [aliased] [constant]
array_type_definition [:= expression];
| single_task_declaration
| single_protected_declaration
4.3.1 Object Declarations
defining_identifier_list ::=
defining_identifier {, defining_identifier}
4.3.2 Number Declarations
number_declaration ::=
defining_identifier_list : constant := static_expression;
4.4 Derived Types and Classes
derived_type_definition ::= [abstract] new
parent_subtype_indication [record_extension_part]
4.5 Scalar Types
range_constraint ::= range range
4.5 Scalar Types
range ::=
range_attribute_reference
| simple_expression .. simple_expression
4.5.1 Enumeration Types
enumeration_type_definition ::=
(enumeration_literal_specification
{, enumeration_literal_specification})
4.5.1 Enumeration Types
enumeration_literal_specification ::=
defining_identifier | defining_character_literal
4.5.1 Enumeration Types
defining_character_literal ::= character_literal
4.5.4 Integer Types
integer_type_definition ::=
signed_integer_type_definition | modular_type_definition
4.5.4 Integer Types
signed_integer_type_definition ::=
range static_simple_expression .. static_simple_expression
4.5.4 Integer Types
modular_type_definition ::= mod static_expression
4.5.6 Real Types
real_type_definition ::=
floating_point_definition | fixed_point_definition
4.5.7 Floating Point Types
floating_point_definition ::=
digits static_expression [real_range_specification]
4.5.7 Floating Point Types
real_range_specification ::=
range static_simple_expression .. static_simple_expression
4.5.9 Fixed Point Types
fixed_point_definition ::=
ordinary_fixed_point_definition | decimal_fixed_point_definition
4.5.9 Fixed Point Types
ordinary_fixed_point_definition ::=
delta static_expression real_range_specification
4.5.9 Fixed Point Types
decimal_fixed_point_definition ::=
delta static_expression digits static_expression
[real_range_specification]
4.5.9 Fixed Point Types
digits_constraint ::=
digits static_expression [range_constraint]
4.6 Array Types
array_type_definition ::=
unconstrained_array_definition | constrained_array_definition
4.6 Array Types
unconstrained_array_definition ::=
array(index_subtype_definition {, index_subtype_definition})
of component_definition
4.6 Array Types
index_subtype_definition ::= subtype_mark range <>
4.6 Array Types
constrained_array_definition ::=
array (discrete_subtype_definition
{, discrete_subtype_definition}) of component_definition
4.6 Array Types
discrete_subtype_definition ::= discrete_subtype_indication | range
4.6 Array Types
component_definition ::= [aliased] subtype_indication
4.6.1 Index Constraints and Discrete Ranges
index_constraint ::= (discrete_range {, discrete_range})
4.6.1 Index Constraints and Discrete Ranges
discrete_range ::= discrete_subtype_indication | range
4.7 Discriminants
discriminant_part ::=
unknown_discriminant_part | known_discriminant_part
4.7 Discriminants
unknown_discriminant_part ::= (<>)
4.7 Discriminants
known_discriminant_part ::=
(discriminant_specification {; discriminant_specification})
4.7 Discriminants
discriminant_specification ::=
defining_identifier_list : subtype_mark
[:= default_expression]
| defining_identifier_list : access_definition
[:= default_expression]
4.7 Discriminants
default_expression ::= expression
4.7.1 Discriminant Constraints
discriminant_constraint ::=
(discriminant_association {, discriminant_association})
4.7.1 Discriminant Constraints
discriminant_association ::=
[discriminant_selector_name
{| discriminant_selector_name} =>] expression
4.8 Record Types
record_type_definition ::=
[[abstract] tagged] [limited] record_definition
4.8 Record Types
record_definition ::=
record
component_list
end record
| null record
4.8 Record Types
component_list ::=
component_item {component_item}
| {component_item} variant_part
| null;
4.8 Record Types
component_item ::= component_declaration | representation_clause
4.8 Record Types
component_declaration ::=
defining_identifier_list : component_definition
[:= default_expression];
4.8.1 Variant Parts and Discrete Choices
variant_part ::=
case discriminant_direct_name is
variant
{variant}
end case;
4.8.1 Variant Parts and Discrete Choices
variant ::=
when discrete_choice_list =>
component_list
4.8.1 Variant Parts and Discrete Choices
discrete_choice_list ::= discrete_choice {| discrete_choice}
4.8.1 Variant Parts and Discrete Choices
discrete_choice ::= expression | discrete_range | others
4.9.1 Type Extensions
record_extension_part ::= with record_definition
4.10 Access Types
access_type_definition ::=
access_to_object_definition
| access_to_subprogram_definition
4.10 Access Types
access_to_object_definition ::=
access [general_access_modifier] subtype_indication
4.10 Access Types
general_access_modifier ::= all | constant
4.10 Access Types
access_to_subprogram_definition ::=
access [protected] procedure parameter_profile
| access [protected] function parameter_and_result_profile
4.10 Access Types
access_definition ::= access subtype_mark
4.10.1 Incomplete Type Declarations
incomplete_type_declaration ::=
type defining_identifier [discriminant_part];
4.11 Declarative Parts
declarative_part ::= {declarative_item}
4.11 Declarative Parts
declarative_item ::= basic_declarative_item | body
4.11 Declarative Parts
basic_declarative_item ::=
basic_declaration | representation_clause | use_clause
4.11 Declarative Parts
body ::= proper_body | body_stub
4.11 Declarative Parts
proper_body ::=
subprogram_body | package_body | task_body | protected_body
5.1 Names
name ::=
direct_name | explicit_dereference
| indexed_component | slice
| selected_component | attribute_reference
| type_conversion | function_call
| character_literal
5.1 Names
direct_name ::= identifier | operator_symbol
5.1 Names
prefix ::= name | implicit_dereference
5.1 Names
explicit_dereference ::= name.all
5.1 Names
implicit_dereference ::= name
5.1.1 Indexed Components
indexed_component ::= prefix(expression {, expression})
5.1.2 Slices
slice ::= prefix(discrete_range)
5.1.3 Selected Components
selected_component ::= prefix . selector_name
5.1.3 Selected Components
selector_name ::= identifier | character_literal | operator_symbol
5.1.4 Attributes
attribute_reference ::= prefix'attribute_designator
5.1.4 Attributes
attribute_designator ::=
identifier[(static_expression)]
| Access | Delta | Digits
5.1.4 Attributes
range_attribute_reference ::= prefix'range_attribute_designator
5.1.4 Attributes
range_attribute_designator ::= Range[(static_expression)]
5.3 Aggregates
aggregate ::=
record_aggregate | extension_aggregate | array_aggregate
5.3.1 Record Aggregates
record_aggregate ::= (record_component_association_list)
5.3.1 Record Aggregates
record_component_association_list ::=
record_component_association {, record_component_association}
| null record
5.3.1 Record Aggregates
record_component_association ::=
[ component_choice_list => ] expression
5.3.1 Record Aggregates
component_choice_list ::=
component_selector_name {| component_selector_name}
| others
5.3.2 Extension Aggregates
extension_aggregate ::=
(ancestor_part with record_component_association_list)
5.3.2 Extension Aggregates
ancestor_part ::= expression | subtype_mark
5.3.3 Array Aggregates
array_aggregate ::=
positional_array_aggregate | named_array_aggregate
5.3.3 Array Aggregates
positional_array_aggregate ::=
(expression, expression {, expression})
| (expression {, expression}, others => expression)
5.3.3 Array Aggregates
named_array_aggregate ::=
(array_component_association {, array_component_association})
5.3.3 Array Aggregates
array_component_association ::=
discrete_choice_list => expression
5.4 Expressions
expression ::=
relation {and relation} | relation {and then relation}
| relation {or relation} | relation {or else relation}
| relation {xor relation}
5.4 Expressions
relation ::=
simple_expression [relational_operator simple_expression]
| simple_expression [not] in range
| simple_expression [not] in subtype_mark
5.4 Expressions
simple_expression ::=
[unary_adding_operator] term {binary_adding_operator term}
5.4 Expressions
term ::= factor {multiplying_operator factor}
5.4 Expressions
factor ::= primary [** primary] | abs primary | not primary
5.4 Expressions
primary ::=
numeric_literal | null
| string_literal | aggregate
| name | qualified_expression
| allocator | (expression)
5.5 Operators and Expression Evaluation
logical_operator ::= and | or | xor
5.5 Operators and Expression Evaluation
relational_operator ::= = | /= | < | <= | > | >=
5.5 Operators and Expression Evaluation
binary_adding_operator ::= + | - | &
5.5 Operators and Expression Evaluation
unary_adding_operator ::= + | -
5.5 Operators and Expression Evaluation
multiplying_operator ::= * | / | mod | rem
5.5 Operators and Expression Evaluation
highest_precedence_operator ::= ** | abs | not
5.6 Type Conversions
type_conversion ::=
subtype_mark(expression)
| subtype_mark(name)
5.7 Qualified Expressions
qualified_expression ::=
subtype_mark'(expression) | subtype_mark'aggregate
5.8 Allocators
allocator ::=
new subtype_indication | new qualified_expression
6.1 Simple and Compound Statements - Sequences of Statements
sequence_of_statements ::= statement {statement}
6.1 Simple and Compound Statements - Sequences of Statements
statement ::=
{label} simple_statement | {label} compound_statement
6.1 Simple and Compound Statements - Sequences of Statements
simple_statement ::= null_statement
| assignment_statement | exit_statement
| goto_statement | procedure_call_statement
| return_statement | entry_call_statement
| requeue_statement | delay_statement
| abort_statement | raise_statement
| code_statement
6.1 Simple and Compound Statements - Sequences of Statements
compound_statement ::=
if_statement | case_statement
| loop_statement | block_statement
| accept_statement | select_statement
6.1 Simple and Compound Statements - Sequences of Statements
null_statement ::= null;
6.1 Simple and Compound Statements - Sequences of Statements
label ::= <<label_statement_identifier>>
6.1 Simple and Compound Statements - Sequences of Statements
statement_identifier ::= direct_name
6.2 Assignment Statements
assignment_statement ::= variable_name := expression;
6.3 If Statements
if_statement ::=
if condition then
sequence_of_statements
{elsif condition then
sequence_of_statements}
[else
sequence_of_statements]
end if;
6.3 If Statements
condition ::= boolean_expression
6.4 Case Statements
case_statement ::=
case expression is
case_statement_alternative
{case_statement_alternative}
end case;
6.4 Case Statements
case_statement_alternative ::=
when discrete_choice_list =>
sequence_of_statements
6.5 Loop Statements
loop_statement ::=
[loop_statement_identifier:]
[iteration_scheme] loop
sequence_of_statements
end loop [loop_identifier];
6.5 Loop Statements
iteration_scheme ::= while condition
| for loop_parameter_specification
6.5 Loop Statements
loop_parameter_specification ::=
defining_identifier in [reverse] discrete_subtype_definition
6.6 Block Statements
block_statement ::=
[block_statement_identifier:]
[declare
declarative_part]
begin
handled_sequence_of_statements
end [block_identifier];
6.7 Exit Statements
exit_statement ::= exit [loop_name] [when condition];
6.8 Goto Statements
goto_statement ::= goto label_name;
7.1 Subprogram Declarations
subprogram_declaration ::= subprogram_specification;
7.1 Subprogram Declarations
abstract_subprogram_declaration ::= subprogram_specification is abstract;
7.1 Subprogram Declarations
subprogram_specification ::=
procedure defining_program_unit_name parameter_profile
| function defining_designator parameter_and_result_profile
7.1 Subprogram Declarations
designator ::= [parent_unit_name . ]identifier | operator_symbol
7.1 Subprogram Declarations
defining_designator ::=
defining_program_unit_name | defining_operator_symbol
7.1 Subprogram Declarations
defining_program_unit_name ::=
[parent_unit_name . ]defining_identifier
7.1 Subprogram Declarations
operator_symbol ::= string_literal
7.1 Subprogram Declarations
defining_operator_symbol ::= operator_symbol
7.1 Subprogram Declarations
parameter_profile ::= [formal_part]
7.1 Subprogram Declarations
parameter_and_result_profile ::= [formal_part] return subtype_mark
7.1 Subprogram Declarations
formal_part ::=
(parameter_specification {; parameter_specification})
7.1 Subprogram Declarations
parameter_specification ::=
defining_identifier_list : mode subtype_mark
[:= default_expression]
| defining_identifier_list : access_definition
[:= default_expression]
7.1 Subprogram Declarations
mode ::= [in] | in out | out
7.3 Subprogram Bodies
subprogram_body ::=
subprogram_specification is
declarative_part
begin
handled_sequence_of_statements
end [designator];
7.4 Subprogram Calls
procedure_call_statement ::=
procedure_name;
| procedure_prefix actual_parameter_part;
7.4 Subprogram Calls
function_call ::=
function_name
| function_prefix actual_parameter_part
7.4 Subprogram Calls
actual_parameter_part ::=
(parameter_association {, parameter_association})
7.4 Subprogram Calls
parameter_association ::=
[formal_parameter_selector_name =>] explicit_actual_parameter
7.4 Subprogram Calls
explicit_actual_parameter ::= expression | variable_name
7.5 Return Statements
return_statement ::= return [expression];
8.1 Package Specifications and Declarations
package_declaration ::= package_specification;
8.1 Package Specifications and Declarations
package_specification ::=
package defining_program_unit_name is
{basic_declarative_item}
[private
{basic_declarative_item}]
end [[parent_unit_name.]identifier]
8.2 Package Bodies
package_body ::=
package body defining_program_unit_name is
declarative_part
[begin
handled_sequence_of_statements]
end [[parent_unit_name.]identifier];
8.3 Private Types and Private Extensions
private_type_declaration ::=
type defining_identifier [discriminant_part] is
[[abstract] tagged] [limited] private;
8.3 Private Types and Private Extensions
private_extension_declaration ::=
type defining_identifier [discriminant_part] is
[abstract] new ancestor_subtype_indication with private;
9.4 Use Clauses
use_clause ::= use_package_clause | use_type_clause
9.4 Use Clauses
use_package_clause ::= use package_name {, package_name};
9.4 Use Clauses
use_type_clause ::= use type subtype_mark {, subtype_mark};
9.5 Renaming Declarations
renaming_declaration ::=
object_renaming_declaration
| exception_renaming_declaration
| package_renaming_declaration
| subprogram_renaming_declaration
| generic_renaming_declaration
9.5.1 Object Renaming Declarations
object_renaming_declaration ::=
defining_identifier : subtype_mark renames object_name;
9.5.2 Exception Renaming Declarations
exception_renaming_declaration ::=
defining_identifier : exception renames exception_name;
9.5.3 Package Renaming Declarations
package_renaming_declaration ::=
package defining_program_unit_name renames package_name;
9.5.4 Subprogram Renaming Declarations
subprogram_renaming_declaration ::=
subprogram_specification renames callable_entity_name;
9.5.5 Generic Renaming Declarations
generic_renaming_declaration ::=
generic package defining_program_unit_name renames
generic_package_name;
| generic procedure defining_program_unit_name renames
generic_procedure_name;
| generic function defining_program_unit_name renames
generic_function_name;
10.1 Task Units and Task Objects
task_type_declaration ::=
task type defining_identifier [known_discriminant_part]
[is task_definition];
10.1 Task Units and Task Objects
single_task_declaration ::=
task defining_identifier [is task_definition];
10.1 Task Units and Task Objects
task_definition ::=
{task_item}
[ private
{task_item}]
end [task_identifier]
10.1 Task Units and Task Objects
task_item ::= entry_declaration | representation_clause
10.1 Task Units and Task Objects
task_body ::=
task body defining_identifier is
declarative_part
begin
handled_sequence_of_statements
end [task_identifier];
10.4 Protected Units and Protected Objects
protected_type_declaration ::=
protected type defining_identifier [known_discriminant_part] is
protected_definition;
10.4 Protected Units and Protected Objects
single_protected_declaration ::=
protected defining_identifier is protected_definition;
10.4 Protected Units and Protected Objects
protected_definition ::=
{ protected_operation_declaration }
[ private
{ protected_element_declaration } ]
end [protected_identifier]
10.4 Protected Units and Protected Objects
protected_operation_declaration ::=
subprogram_declaration
| entry_declaration
| representation_clause
10.4 Protected Units and Protected Objects
protected_element_declaration ::=
protected_operation_declaration | component_declaration
10.4 Protected Units and Protected Objects
protected_body ::=
protected body defining_identifier is
{ protected_operation_item }
end [protected_identifier];
10.4 Protected Units and Protected Objects
protected_operation_item ::=
subprogram_declaration
| subprogram_body
| entry_body
| representation_clause
10.5.2 Entries and Accept Statements
entry_declaration ::=
entry defining_identifier [(discrete_subtype_definition)]
parameter_profile;
10.5.2 Entries and Accept Statements
accept_statement ::=
accept entry_direct_name [(entry_index)] parameter_profile [do
handled_sequence_of_statements
end [entry_identifier]];
10.5.2 Entries and Accept Statements
entry_index ::= expression
10.5.2 Entries and Accept Statements
entry_body ::=
entry defining_identifier entry_body_formal_part entry_barrier is
declarative_part
begin
handled_sequence_of_statements
end [entry_identifier];
10.5.2 Entries and Accept Statements
entry_body_formal_part ::=
[(entry_index_specification)] parameter_profile
10.5.2 Entries and Accept Statements
entry_barrier ::= when condition
10.5.2 Entries and Accept Statements
entry_index_specification ::=
for defining_identifier in discrete_subtype_definition
10.5.3 Entry Calls
entry_call_statement ::= entry_name [actual_parameter_part];
10.5.4 Requeue Statements
requeue_statement ::= requeue entry_name [with abort];
10.6 Delay Statements, Duration, and Time
delay_statement ::= delay_until_statement | delay_relative_statement
10.6 Delay Statements, Duration, and Time
delay_until_statement ::= delay until delay_expression;
10.6 Delay Statements, Duration, and Time
delay_relative_statement ::= delay delay_expression;
10.7 Select Statements
select_statement ::=
selective_accept
| timed_entry_call
| conditional_entry_call
| asynchronous_select
10.7.1 Selective Accept
selective_accept ::=
select
[guard]
select_alternative
{ or
[guard]
select_alternative }
[ else
sequence_of_statements ]
end select;
10.7.1 Selective Accept
guard ::= when condition =>
10.7.1 Selective Accept
select_alternative ::=
accept_alternative
| delay_alternative
| terminate_alternative
10.7.1 Selective Accept
accept_alternative ::=
accept_statement [sequence_of_statements]
10.7.1 Selective Accept
delay_alternative ::=
delay_statement [sequence_of_statements]
10.7.1 Selective Accept
terminate_alternative ::= terminate;
10.7.2 Timed Entry Calls
timed_entry_call ::=
select
entry_call_alternative
or
delay_alternative
end select;
10.7.2 Timed Entry Calls
entry_call_alternative ::=
entry_call_statement [sequence_of_statements]
10.7.3 Conditional Entry Calls
conditional_entry_call ::=
select
entry_call_alternative
else
sequence_of_statements
end select;
10.7.4 Asynchronous Transfer of Control
asynchronous_select ::=
select
triggering_alternative
then abort
abortable_part
end select;
10.7.4 Asynchronous Transfer of Control
triggering_alternative ::=
triggering_statement [sequence_of_statements]
10.7.4 Asynchronous Transfer of Control
triggering_statement ::= entry_call_statement | delay_statement
10.7.4 Asynchronous Transfer of Control
abortable_part ::= sequence_of_statements
10.8 Abort of a Task - Abort of a Sequence of Statements
abort_statement ::= abort task_name {, task_name};
11.1.1 Compilation Units - Library Units
compilation ::= {compilation_unit}
11.1.1 Compilation Units - Library Units
compilation_unit ::=
context_clause library_item
| context_clause subunit
11.1.1 Compilation Units - Library Units
library_item ::= [private] library_unit_declaration
| library_unit_body
| [private] library_unit_renaming_declaration
11.1.1 Compilation Units - Library Units
library_unit_declaration ::=
subprogram_declaration | package_declaration
| generic_declaration | generic_instantiation
11.1.1 Compilation Units - Library Units
library_unit_renaming_declaration ::=
package_renaming_declaration
| generic_renaming_declaration
| subprogram_renaming_declaration
11.1.1 Compilation Units - Library Units
library_unit_body ::= subprogram_body | package_body
11.1.1 Compilation Units - Library Units
parent_unit_name ::= name
11.1.2 Context Clauses - With Clauses
context_clause ::= {context_item}
11.1.2 Context Clauses - With Clauses
context_item ::= with_clause | use_clause
11.1.2 Context Clauses - With Clauses
with_clause ::= with library_unit_name {, library_unit_name};
11.1.3 Subunits of Compilation Units
body_stub ::=
subprogram_body_stub
| package_body_stub
| task_body_stub
| protected_body_stub
11.1.3 Subunits of Compilation Units
subprogram_body_stub ::= subprogram_specification is separate;
11.1.3 Subunits of Compilation Units
package_body_stub ::= package body defining_identifier is separate;
11.1.3 Subunits of Compilation Units
task_body_stub ::= task body defining_identifier is separate;
11.1.3 Subunits of Compilation Units
protected_body_stub ::=
protected body defining_identifier is separate;
11.1.3 Subunits of Compilation Units
subunit ::= separate (parent_unit_name) proper_body
12.1 Exception Declarations
exception_declaration ::= defining_identifier_list : exception;
12.2 Exception Handlers
handled_sequence_of_statements ::=
sequence_of_statements
[exception
exception_handler
{exception_handler}]
12.2 Exception Handlers
exception_handler ::=
when [choice_parameter_specification:] exception_choice
{| exception_choice} =>
sequence_of_statements
12.2 Exception Handlers
choice_parameter_specification ::= defining_identifier
12.2 Exception Handlers
exception_choice ::= exception_name | others
12.3 Raise Statements
raise_statement ::= raise [exception_name];
13.1 Generic Declarations
generic_declaration ::=
generic_subprogram_declaration | generic_package_declaration
13.1 Generic Declarations
generic_subprogram_declaration ::=
generic_formal_part subprogram_specification;
13.1 Generic Declarations
generic_package_declaration ::=
generic_formal_part package_specification;
13.1 Generic Declarations
generic_formal_part ::=
generic {generic_formal_parameter_declaration | use_clause}
13.1 Generic Declarations
generic_formal_parameter_declaration ::=
formal_object_declaration
| formal_type_declaration
| formal_subprogram_declaration
| formal_package_declaration
13.3 Generic Instantiation
generic_instantiation ::=
package defining_program_unit_name is
new generic_package_name [generic_actual_part];
| procedure defining_program_unit_name is
new generic_procedure_name [generic_actual_part];
| function defining_designator is
new generic_function_name [generic_actual_part];
13.3 Generic Instantiation
generic_actual_part ::=
(generic_association {, generic_association})
13.3 Generic Instantiation
generic_association ::=
[generic_formal_parameter_selector_name =>]
explicit_generic_actual_parameter
13.3 Generic Instantiation
explicit_generic_actual_parameter ::= expression | variable_name
| subprogram_name | entry_name | subtype_mark
| package_instance_name
13.4 Formal Objects
formal_object_declaration ::=
defining_identifier_list : mode subtype_mark
[:= default_expression];
13.5 Formal Types
formal_type_declaration ::=
type defining_identifier[discriminant_part] is
formal_type_definition;
13.5 Formal Types
formal_type_definition ::=
formal_private_type_definition
| formal_derived_type_definition
| formal_discrete_type_definition
| formal_signed_integer_type_definition
| formal_modular_type_definition
| formal_floating_point_definition
| formal_ordinary_fixed_point_definition
| formal_decimal_fixed_point_definition
| formal_array_type_definition
| formal_access_type_definition
13.5.1 Formal Private and Derived Types
formal_private_type_definition ::=
[[abstract] tagged] [limited] private
13.5.1 Formal Private and Derived Types
formal_derived_type_definition ::=
[abstract] new subtype_mark [with private]
13.5.2 Formal Scalar Types
formal_discrete_type_definition ::= (<>)
13.5.2 Formal Scalar Types
formal_signed_integer_type_definition ::= range <>
13.5.2 Formal Scalar Types
formal_modular_type_definition ::= mod <>
13.5.2 Formal Scalar Types
formal_floating_point_definition ::= digits <>
13.5.2 Formal Scalar Types
formal_ordinary_fixed_point_definition ::= delta <>
13.5.2 Formal Scalar Types
formal_decimal_fixed_point_definition ::= delta <> digits <>
13.5.3 Formal Array Types
formal_array_type_definition ::= array_type_definition
13.5.4 Formal Access Types
formal_access_type_definition ::= access_type_definition
13.6 Formal Subprograms
formal_subprogram_declaration ::=
with subprogram_specification [is subprogram_default];
13.6 Formal Subprograms
subprogram_default ::= default_name | <>
13.6 Formal Subprograms
default_name ::= name
13.7 Formal Packages
formal_package_declaration ::=
with package defining_identifier is new
generic_package_name formal_package_actual_part;
13.7 Formal Packages
formal_package_actual_part ::= (<>) | [generic_actual_part]
14.1 Representation Items
representation_clause ::=
attribute_definition_clause
| enumeration_representation_clause
| record_representation_clause
| at_clause
14.1 Representation Items
local_name ::=
direct_name
| direct_name'attribute_designator
| library_unit_name
14.3 Representation Attributes
attribute_definition_clause ::=
for local_name'attribute_designator use expression;
| for local_name'attribute_designator use name;
14.4 Enumeration Representation Clauses
enumeration_representation_clause ::=
for first_subtype_local_name use enumeration_aggregate;
14.4 Enumeration Representation Clauses
enumeration_aggregate ::= array_aggregate
14.5.1 Record Representation Clauses
record_representation_clause ::=
for first_subtype_local_name use
record [mod_clause]
{component_clause}
end record;
14.5.1 Record Representation Clauses
component_clause ::=
component_local_name at position range first_bit .. last_bit;
14.5.1 Record Representation Clauses
position ::= static_expression
14.5.1 Record Representation Clauses
first_bit ::= static_simple_expression
14.5.1 Record Representation Clauses
last_bit ::= static_simple_expression
14.8 Machine Code Insertions
code_statement ::= qualified_expression;
14.12 Pragma Restrictions
restriction ::= restriction_identifier
| restriction_parameter_identifier => expression
I.3 Reduced Accuracy Subtypes
delta_constraint ::= delta static_expression [range_constraint]
I.7 At Clauses
at_clause ::= for direct_name use at expression;
I.8 Mod Clauses
mod_clause ::= at mod static_expression;
|
SYNTAX CROSS REFERENCE
-
N.1 Index
| | Index entries are given by paragraph number. A list of all
language-defined library units may be found under Language-Defined
Library Units. A list of all language-defined types may be found under
Language-Defined Types.
|
N.2 Operator index
| | & operator 5.4 Expressions(1), 5.5.3 Binary Adding Operators(1), 5.5.3 Binary Adding Operators(3)
* operator 5.4 Expressions(1), 5.5.5 Multiplying Operators(1), 5.5.5 Multiplying Operators(1)
** operator 5.4 Expressions(1), 5.5.6 Highest Precedence Operators(1), 5.5.6 Highest Precedence Operators(7)
+ operator 5.4 Expressions(1), 5.5.3 Binary Adding Operators(1), 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1)
= operator 5.4 Expressions(1), 5.5.2 Relational Operators and Membership Tests(1), 5.5.2 Relational Operators and Membership Tests(1)
- operator 5.4 Expressions(1), 5.5.3 Binary Adding Operators(1), 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1)
/ operator 5.4 Expressions(1), 5.5.5 Multiplying Operators(1), 5.5.5 Multiplying Operators(1)
/= operator 5.4 Expressions(1), 5.5.2 Relational Operators and Membership Tests(1), 5.5.2 Relational Operators and Membership Tests(1)
< operator 5.4 Expressions(1), 5.5.2 Relational Operators and Membership Tests(1), 5.5.2 Relational Operators and Membership Tests(1)
<= operator 5.4 Expressions(1), 5.5.2 Relational Operators and Membership Tests(1), 5.5.2 Relational Operators and Membership Tests(1)
> operator 5.4 Expressions(1), 5.5.2 Relational Operators and Membership Tests(1), 5.5.2 Relational Operators and Membership Tests(1)
>= operator 5.4 Expressions(1), 5.5.2 Relational Operators and Membership Tests(1), 5.5.2 Relational Operators and Membership Tests(1)
|
N.3 Digits index
| | 10646-1:1993, ISO/IEC standard 1.2(8).
1539:1991, ISO/IEC standard 1.2(3).
1989:1985, ISO standard 1.2(4).
6429:1992, ISO/IEC standard 1.2(5).
646:1991, ISO/IEC standard 1.2(2).
8859-1:1987, ISO/IEC standard 1.2(6).
9899:1990, ISO/IEC standard 1.2(7).
|
O. index
| | A_Form 5.6 Type Conversions.
abnormal completion 8.6.1 Completion and Finalization.
abnormal state of an object 14.9.1 Data Validity.
[partial] 10.8 Abort of a Task - Abort of a Sequence of Statements(21), see 12.6 Exceptions and Optimization(6), see A.13 Exceptions in Input-Output(21), see 12.6 Exceptions and Optimization(6), see A.13(17).
abnormal task 10.8 Abort of a Task - Abort of a Sequence of Statements.
abort
of a partition E.1 Partitions.
of a task 10.8 Abort of a Task - Abort of a Sequence of Statements.
of the execution of a construct 10.8 Abort of a Task - Abort of a Sequence of Statements.
abort completion point 10.8 Abort of a Task - Abort of a Sequence of Statements.
abort-deferred operation 10.8 Abort of a Task - Abort of a Sequence of Statements.
abort_statement 10.8 Abort of a Task - Abort of a Sequence of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
Abort_Task C.7.1 The Package Task_Identification.
abortable_part 10.7.4 Asynchronous Transfer of Control.
used 10.7.4 Asynchronous Transfer of Control(2), see N. Syntax Summary (informative)(2), see P(1).
abs operator 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(1).
absolute value 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(1).
abstract data type (ADT)
See also abstract type 4.9.3 Abstract Types and Subprograms.
See private types and private extensions 8.3 Private Types and Private Extensions.
abstract subprogram 4.9.3 Abstract Types and Subprograms(1), see 4.9.3 Abstract Types and Subprograms(1), see 3.9.3(3).
abstract type 4.9.3 Abstract Types and Subprograms(1), see 4.9.3 Abstract Types and Subprograms(1), see 3.9.3(2).
abstract_subprogram_declaration 7.1 Subprogram Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
Acc 14.11 Storage Management.
accept_alternative 10.7.1 Selective Accept.
used 10.7.1 Selective Accept(4), see N. Syntax Summary (informative)(4), see P(1).
accept_statement 10.5.2 Entries and Accept Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(5), see 10.7.1 Selective Accept(5), see N. Syntax Summary (informative)(5), see 10.7.1 Selective Accept(5), see P(1).
acceptable interpretation 9.6 The Context of Overload Resolution.
Access attribute 4.10.2 Operations of Access Types(24), see 4.10.2 Operations of Access Types(24), see 3.10.2(32),
J. Language-Defined Attributes (informative)(2), J. Language-Defined Attributes (informative)(2), K(4).
See also Unchecked_Access attribute 14.10 Unchecked Access Value Creation.
access discriminant 4.7 Discriminants.
access parameter 7.1 Subprogram Declarations.
access paths
distinct 7.2 Formal Parameter Modes.
access type 4.10 Access Types(1), see M. Glossary (informative)(1), see N(2).
access types
input-output unspecified A.7 External Files and File Objects.
access value 4.10 Access Types.
access-to-constant type 4.10 Access Types.
access-to-object type 4.10 Access Types.
access-to-subprogram type 4.10 Access Types(7), see 4.10 Access Types(7), see 3.10(11).
access-to-variable type 4.10 Access Types.
Access_Check 12.5 Suppressing Checks.
[partial] 5.1 Names(13), see 5.6 Type Conversions(13), see 4.6(49).
access_definition 4.10 Access Types.
used 4.7 Discriminants(5), see 7.1 Subprogram Declarations(15), see N. Syntax Summary (informative)(5), see 7.1 Subprogram Declarations(15), see P(1).
access_type_definition 4.10 Access Types.
used 4.2.1 Type Declarations(4), see 13.5.4 Formal Access Types(2), see N. Syntax Summary (informative)(4), see 13.5.4 Formal Access Types(2), see P(1).
access_to_object_definition 4.10 Access Types.
used 4.10 Access Types(2), see N. Syntax Summary (informative)(2), see P(1).
access_to_subprogram_definition 4.10 Access Types.
used 4.10 Access Types(2), see N. Syntax Summary (informative)(2), see P(1).
accessibility
from shared passive library units E.2.1 Shared Passive Library Units.
accessibility level 4.10.2 Operations of Access Types.
accessibility rule
Access attribute 4.10.2 Operations of Access Types(28), see 4.10.2 Operations of Access Types(28), see 3.10.2(32).
record extension 4.9.1 Type Extensions.
requeue statement 10.5.4 Requeue Statements.
type conversion 5.6 Type Conversions(17), see 5.6 Type Conversions(17), see 4.6(20).
Accessibility_Check 12.5 Suppressing Checks.
[partial] 4.10.2 Operations of Access Types(29), see 5.6 Type Conversions(48), see 7.5 Return Statements(29), see 5.6 Type Conversions(48), see 6.5(17),
E.4 Remote Subprogram Calls.
accessible partition E.1 Partitions.
accuracy 5.6 Type Conversions(32), see G.2 Numeric Performance Requirements(32), see G.2(1).
ACK A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
acquire
execution resource associated with protected object
10.5.1 Protected Subprograms and Protected Actions.
Activate 7.4 Subprogram Calls.
activation
of a task 10.2 Task Execution - Task Activation.
activation failure 10.2 Task Execution - Task Activation.
activator
of a task 10.2 Task Execution - Task Activation.
active partition 11.2 Program Execution(28), see E.1 Partitions(28), see E.1(2).
active priority D.1 Task Priorities.
actual 13.3 Generic Instantiation.
actual duration D.9 Delay Accuracy.
actual parameter
for a formal parameter 7.4.1 Parameter Associations.
actual subtype 4.3 Objects and Named Numbers(23), see 13.5 Formal Types(23), see 12.5(4).
of an object 4.3.1 Object Declarations.
actual type 13.5 Formal Types.
actual_parameter_part 7.4 Subprogram Calls.
used 7.4 Subprogram Calls(2), see 7.4 Subprogram Calls(3), see 10.5.3 Entry Calls(2), see N. Syntax Summary (informative)(2), see 7.4 Subprogram Calls(3), see 10.5.3 Entry Calls(2), see P(1).
Acute A.3.3 The Package Characters.Latin_1.
Ada A.2 The Package Ada.
Ada calling convention 7.3.1 Conformance Rules.
Ada.Asynchronous_Task_Control D.11 Asynchronous Task Control.
Ada.Calendar 10.6 Delay Statements, Duration, and Time.
Ada.Characters A.3.1 The Package Characters.
Ada.Characters.Handling A.3.2 The Package Characters.Handling.
Ada.Characters.Latin_1 A.3.3 The Package Characters.Latin_1.
Ada.Command_Line A.15 The Package Command_Line.
Ada.Decimal F.2 The Package Decimal.
Ada.Direct_IO A.8.4 The Generic Package Direct_IO.
Ada.Dynamic_Priorities D.5 Dynamic Priorities.
Ada.Exceptions 12.4.1 The Package Exceptions.
Ada.Finalization 8.6 User-Defined Assignment and Finalization.
Ada.Float_Text_IO A.10.9 Input-Output for Real Types.
Ada.Float_Wide_Text_IO A.11 Wide Text Input-Output.
Ada.Integer_Text_IO A.10.8 Input-Output for Integer Types.
Ada.Integer_Wide_Text_IO A.11 Wide Text Input-Output.
Ada.Interrupts C.3.2 The Package Interrupts.
Ada.Interrupts.Names C.3.2 The Package Interrupts.
Ada.Numerics A.5 The Numerics Packages.
Ada.Numerics.Complex_Elementary_Functions G.1.2 Complex Elementary Functions.
Ada.Numerics.Complex_Types G.1.1 Complex Types.
Ada.Numerics.Discrete_Random A.5.2 Random Number Generation.
Ada.Numerics.Elementary_Functions A.5.1 Elementary Functions.
Ada.Numerics.Float_Random A.5.2 Random Number Generation.
Ada.Numerics.Generic_Complex_Elementary_Functions G.1.2 Complex Elementary Functions.
Ada.Numerics.Generic_Complex_Types G.1.1 Complex Types.
Ada.Numerics.Generic_Elementary_Functions A.5.1 Elementary Functions.
Ada.Real_Time D.8 Monotonic Time.
Ada.Sequential_IO A.8.1 The Generic Package Sequential_IO.
Ada.Storage_IO A.9 The Generic Package Storage_IO.
Ada.Streams 14.13.1 The Package Streams.
Ada.Streams.Stream_IO A.12.1 The Package Streams.Stream_IO.
Ada.Strings A.4.1 The Package Strings.
Ada.Strings.Bounded A.4.4 Bounded-Length String Handling.
Ada.Strings.Fixed A.4.3 Fixed-Length String Handling.
Ada.Strings.Maps A.4.2 The Package Strings.Maps.
Ada.Strings.Maps.Constants A.4.6 String-Handling Sets and Mappings.
Ada.Strings.Unbounded A.4.5 Unbounded-Length String Handling.
Ada.Strings.Wide_Bounded A.4.7 Wide_String Handling.
Ada.Strings.Wide_Fixed A.4.7 Wide_String Handling.
Ada.Strings.Wide_Maps A.4.7 Wide_String Handling.
Ada.Strings.Wide_Maps.Wide_Constants A.4.7 Wide_String Handling.
Ada.Strings.Wide_Unbounded A.4.7 Wide_String Handling.
Ada.Synchronous_Task_Control D.10 Synchronous Task Control.
Ada.Tags 4.9 Tagged Types and Type Extensions.
Ada.Task_Attributes C.7.2 The Package Task_Attributes.
Ada.Task_Identification C.7.1 The Package Task_Identification.
Ada.Text_IO A.10.1 The Package Text_IO.
Ada.Text_IO.Complex_IO G.1.3 Complex Input-Output.
Ada.Text_IO.Editing F.3.3 The Package Text_IO.Editing.
Ada.Text_IO.Text_Streams A.12.2 The Package Text_IO.Text_Streams.
Ada.Unchecked_Conversion 14.9 Unchecked Type Conversions.
Ada.Unchecked_Deallocation 14.11.2 Unchecked Storage Deallocation.
Ada.Wide_Text_IO A.11 Wide Text Input-Output.
Ada.Wide_Text_IO.Complex_IO G.1.4 The Package Wide_Text_IO.Complex_IO.
Ada.Wide_Text_IO.Editing F.3.4 The Package Wide_Text_IO.Editing.
Ada.Wide_Text_IO.Text_Streams A.12.3 The Package Wide_Text_IO.Text_Streams.
Ada.IO_Exceptions A.13 Exceptions in Input-Output.
Ada_Application B.5 Interfacing with Fortran.
Ada_Employee_Record_Type B.4 Interfacing with COBOL.
Addition 4.9.1 Type Extensions.
Address 14.7 The Package System.
arithmetic 14.7.1 The Package System.Storage_Elements.
comparison 14.7 The Package System.
null 14.7 The Package System.
Address attribute 14.3 Representation Attributes(11), see I.7.1 Interrupt Entries(5), see J. Language-Defined Attributes (informative)(11), see I.7.1 Interrupt Entries(5), see K(6).
Address clause 14.3 Representation Attributes(7), see 14.3 Representation Attributes(7), see 13.3(12).
Address_To_Access_Conversions
child of System 14.7.2 The Package System.Address_To_Access_Conversions.
Adjacent attribute A.5.3 Attributes of Floating Point Types(48), see J. Language-Defined Attributes (informative)(48), see K(8).
Adjust 8.6 User-Defined Assignment and Finalization(2), see 8.6 User-Defined Assignment and Finalization(2), see 7.6(6).
adjusting the value of an object 8.6 User-Defined Assignment and Finalization(15), see 8.6 User-Defined Assignment and Finalization(15), see 7.6(16).
adjustment 8.6 User-Defined Assignment and Finalization(15), see 8.6 User-Defined Assignment and Finalization(15), see 7.6(16).
as part of assignment 6.2 Assignment Statements.
Adjustments_Conversions B.4 Interfacing with COBOL.
Adjustments_Type B.4 Interfacing with COBOL.
ADT (abstract data type)
See also abstract type 4.9.3 Abstract Types and Subprograms.
See private types and private extensions 8.3 Private Types and Private Extensions.
advice 2.1.2 Structure.
Aft attribute 4.5.10 Operations of Fixed Point Types(5), see J. Language-Defined Attributes (informative)(5), see K(12).
aggregate 5.3 Aggregates(1), see 5.3 Aggregates(1), see 4.3(2).
used 5.4 Expressions(7), see 5.7 Qualified Expressions(2), see N. Syntax Summary (informative)(7), see 5.7 Qualified Expressions(2), see P(1).
See also composite type 4.2 Types and Subtypes.
aliased 4.10 Access Types(9), see M. Glossary (informative)(9), see N(3).
aliasing
See distinct access paths 7.2 Formal Parameter Modes.
Alignment A.4.1 The Package Strings.
Alignment attribute 14.3 Representation Attributes(23), see J. Language-Defined Attributes (informative)(23), see K(14).
Alignment clause 14.3 Representation Attributes(7), see 14.3 Representation Attributes(7), see 13.3(25).
All_Calls_Remote pragma E.2.3 Remote Call Interface Library Units(5), see K. Language-Defined Pragmas (informative)(5), see L(2).
All_Checks 12.5 Suppressing Checks.
Allocate 14.11 Storage Management.
allocator 5.8 Allocators.
used 5.4 Expressions(7), see N. Syntax Summary (informative)(7), see P(1).
Alphanumeric B.4 Interfacing with COBOL.
alphanumeric character
a category of Character A.3.2 The Package Characters.Handling.
Alphanumeric_Set A.4.6 String-Handling Sets and Mappings.
ambiguous 9.6 The Context of Overload Resolution.
ampersand 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(8)
ampersand operator 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 4.5.3(3).
ancestor
of a library unit 11.1.1 Compilation Units - Library Units.
of a type 4.4.1 Derivation Classes.
ultimate 4.4.1 Derivation Classes.
ancestor subtype
of a private_extension_declaration 8.3 Private Types and Private Extensions.
of a formal derived type 13.5.1 Formal Private and Derived Types.
ancestor_part 5.3.2 Extension Aggregates.
used 5.3.2 Extension Aggregates(2), see N. Syntax Summary (informative)(2), see P(1).
and operator 5.4 Expressions(1), see 5.5.1 Logical Operators and Short-circuit Control Forms(1), see 4.5.1(2).
and then (short-circuit control form) 5.4 Expressions,
5.5.1 Logical Operators and Short-circuit Control Forms.
Angle 13.5 Formal Types.
angle threshold G.2.4 Accuracy Requirements for the Elementary Functions.
Annex
informative 2.1.2 Structure.
normative 2.1.2 Structure.
Specialized Needs 2.1.2 Structure.
anonymous access type 4.10 Access Types.
anonymous array type 4.3.1 Object Declarations.
anonymous protected type 4.3.1 Object Declarations.
anonymous task type 4.3.1 Object Declarations.
anonymous type 4.2.1 Type Declarations.
Any_Priority 14.7 The Package System(16), see D.1 Task Priorities(16), see D.1(10).
APC A.3.3 The Package Characters.Latin_1.
apostrophe 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(15), see A.3.3(8).
Append A.4.4 Bounded-Length String Handling(13), see A.4.4 Bounded-Length String Handling(14), see A.4.4 Bounded-Length String Handling(13), see A.4.4 Bounded-Length String Handling(14), see A.4.4(15),
A.4.4 Bounded-Length String Handling(16), see A.4.4 Bounded-Length String Handling(17), see A.4.4 Bounded-Length String Handling(16), see A.4.4 Bounded-Length String Handling(17), see A.4.4(18),
A.4.4 Bounded-Length String Handling(19), see A.4.4 Bounded-Length String Handling(20), see A.4.5 Unbounded-Length String Handling(19), see A.4.4 Bounded-Length String Handling(20), see A.4.5(12),
A.4.5 Unbounded-Length String Handling(13), see A.4.5 Unbounded-Length String Handling(13), see A.4.5(14).
applicable index constraint 5.3.3 Array Aggregates.
application areas 2.1.2 Structure.
apply
to a loop_statement by an exit_statement 6.7 Exit Statements.
to a callable construct by a return_statement 7.5 Return Statements.
to a program unit by a program unit pragma 11.1.5 Pragmas and Program Units.
arbitrary order 2.1.4 Method of Description and Syntax Notation.
Arccos A.5.1 Elementary Functions(6), see G.1.2 Complex Elementary Functions(6), see G.1.2(5).
Arccosh A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(7).
Arccot A.5.1 Elementary Functions(6), see G.1.2 Complex Elementary Functions(6), see G.1.2(5).
Arccoth A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(7).
Arcsin A.5.1 Elementary Functions(6), see G.1.2 Complex Elementary Functions(5)
Arcsinh A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(7).
Arctan A.5.1 Elementary Functions(6), see G.1.2 Complex Elementary Functions(6), see G.1.2(5).
Arctanh A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(7).
Argument A.15 The Package Command_Line(5), see G.1.1 Complex Types(5), see G.1.1(10).
argument of a pragma 3.8 Pragmas.
Argument_Count A.15 The Package Command_Line.
Argument_Error A.5 The Numerics Packages.
array 4.6 Array Types.
array component expression 5.3.3 Array Aggregates.
array indexing
See indexed_component 5.1.1 Indexed Components.
array slice 5.1.2 Slices.
array type 4.6 Array Types(1), see M. Glossary (informative)(1), see N(4).
array_aggregate 5.3.3 Array Aggregates.
used 5.3 Aggregates(2), see 14.4 Enumeration Representation Clauses(3), see N. Syntax Summary (informative)(2), see 14.4 Enumeration Representation Clauses(3), see P(1).
array_component_association 5.3.3 Array Aggregates.
used 5.3.3 Array Aggregates(4), see N. Syntax Summary (informative)(4), see P(1).
array_type_definition 4.6 Array Types.
used 4.2.1 Type Declarations(4), see 4.3.1 Object Declarations(2), see 13.5.3 Formal Array Types(4), see 4.3.1 Object Declarations(2), see 12.5.3(2),
N. Syntax Summary (informative).
ASCII A.1 The Package Standard(36), see I.5 ASCII(36), see J.5(2).
package physically nested within the declaration of Standard
A.1 The Package Standard.
aspect of representation 14.1 Representation Items.
coding 14.4 Enumeration Representation Clauses.
controlled 14.11.3 Pragma Controlled.
convention, calling convention B.1 Interfacing Pragmas.
exported B.1 Interfacing Pragmas.
imported B.1 Interfacing Pragmas.
layout 14.5 Record Layout.
packing 14.2 Pragma Pack.
record layout 14.5 Record Layout.
specifiable attributes 14.3 Representation Attributes.
storage place 14.5 Record Layout.
assembly language C.1 Access to Machine Operations.
assign
See assignment operation 6.2 Assignment Statements.
assigning back of parameters 7.4.1 Parameter Associations.
assignment
user-defined 8.6 User-Defined Assignment and Finalization.
assignment operation 6.2 Assignment Statements(3), see 6.2 Assignment Statements(12), see 8.6 User-Defined Assignment and Finalization(3), see 6.2 Assignment Statements(12), see 7.6(13).
during elaboration of an object_declaration 4.3.1 Object Declarations.
during evaluation of a generic_association for a formal object
of mode in 13.4 Formal Objects(11)
during evaluation of a parameter_association 7.4.1 Parameter Associations.
during evaluation of an aggregate 5.3 Aggregates.
during evaluation of an initialized allocator 5.8 Allocators.
during evaluation of an uninitialized allocator 5.8 Allocators,
5.8 Allocators.
during evaluation of concatenation 5.5.3 Binary Adding Operators.
during execution of a for loop 6.5 Loop Statements.
during execution of a return_statement 7.5 Return Statements.
during execution of an assignment_statement 6.2 Assignment Statements.
during parameter copy back 7.4.1 Parameter Associations.
assignment_statement 6.2 Assignment Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
associated components
of a record_component_association 5.3.1 Record Aggregates.
associated discriminants
of a named discriminant_association 4.7.1 Discriminant Constraints.
of a positional discriminant_association 4.7.1 Discriminant Constraints.
associated object
of a value of a by-reference type 7.2 Formal Parameter Modes.
asterisk 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(15), see A.3.3(8).
asynchronous
remote procedure call E.4.1 Pragma Asynchronous.
Asynchronous pragma E.4.1 Pragma Asynchronous(3), see K. Language-Defined Pragmas (informative)(3), see L(3).
asynchronous remote procedure call E.4 Remote Subprogram Calls.
asynchronous_select 10.7.4 Asynchronous Transfer of Control.
used 10.7 Select Statements(2), see N. Syntax Summary (informative)(2), see P(1).
Asynchronous_Task_Control
child of Ada D.11 Asynchronous Task Control.
at-most-once execution E.4 Remote Subprogram Calls.
at_clause I.7 At Clauses.
used 14.1 Representation Items(2), see N. Syntax Summary (informative)(2), see P(1).
atomic C.6 Shared Variable Control.
Atomic pragma C.6 Shared Variable Control(3), see K. Language-Defined Pragmas (informative)(3), see L(4).
Atomic_Components pragma C.6 Shared Variable Control(5), see K. Language-Defined Pragmas (informative)(5), see L(5).
Attach_Handler C.3.2 The Package Interrupts.
Attach_Handler pragma C.3.1 Protected Procedure Handlers, L(6)
attaching
to an interrupt C.3 Interrupt Support.
attribute 5.1.4 Attributes(1), see C.7.2 The Package Task_Attributes(2), see J. Language-Defined Attributes (informative)(1), see C.7.2 The Package Task_Attributes(2), see K(1).
representation 14.3 Representation Attributes.
specifiable 14.3 Representation Attributes.
specifying 14.3 Representation Attributes.
attribute_definition_clause 14.3 Representation Attributes.
used 14.1 Representation Items(2), see N. Syntax Summary (informative)(2), see P(1).
attribute_designator 5.1.4 Attributes.
used 5.1.4 Attributes(2), see 14.1 Representation Items(3), see 14.3 Representation Attributes(2), see 14.1 Representation Items(3), see 13.3(2),
N. Syntax Summary (informative).
Attribute_Handle C.7.2 The Package Task_Attributes.
attribute_reference 5.1.4 Attributes.
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
attributes
Access 4.10.2 Operations of Access Types(24), see 4.10.2 Operations of Access Types(32), see J. Language-Defined Attributes (informative)(24), see 4.10.2 Operations of Access Types(32), see K(2),
J. Language-Defined Attributes (informative).
Address 14.3 Representation Attributes(11), see I.7.1 Interrupt Entries(5), see J. Language-Defined Attributes (informative)(11), see I.7.1 Interrupt Entries(5), see K(6).
Adjacent A.5.3 Attributes of Floating Point Types(48), see J. Language-Defined Attributes (informative)(48), see K(8).
Aft 4.5.10 Operations of Fixed Point Types(5), see J. Language-Defined Attributes (informative)(5), see K(12).
Alignment 14.3 Representation Attributes(23), see J. Language-Defined Attributes (informative)(23), see K(14).
Base 4.5 Scalar Types(15), see J. Language-Defined Attributes (informative)(15), see K(17).
Bit_Order 14.5.3 Bit Ordering(4), see J. Language-Defined Attributes (informative)(4), see K(19).
Body_Version E.3 Consistency of a Distributed System(4), see J. Language-Defined Attributes (informative)(4), see K(21).
Callable 10.9 Task and Entry Attributes(2), see J. Language-Defined Attributes (informative)(2), see K(23).
Caller C.7.1 The Package Task_Identification(14), see J. Language-Defined Attributes (informative)(14), see K(25).
Ceiling A.5.3 Attributes of Floating Point Types(33), see J. Language-Defined Attributes (informative)(33), see K(27).
Class 4.9 Tagged Types and Type Extensions(14), see 8.3.1 Private Operations(9), see J. Language-Defined Attributes (informative)(14), see 8.3.1 Private Operations(9), see K(31),
J. Language-Defined Attributes (informative).
Component_Size 14.3 Representation Attributes(69), see J. Language-Defined Attributes (informative)(69), see K(36).
Compose A.5.3 Attributes of Floating Point Types(24), see J. Language-Defined Attributes (informative)(24), see K(38).
Constrained 4.7.2 Operations of Discriminated Types(3), see I.4 The Constrained Attribute(2), see J. Language-Defined Attributes (informative)(3), see I.4 The Constrained Attribute(2), see K(42).
Copy_Sign A.5.3 Attributes of Floating Point Types(51), see J. Language-Defined Attributes (informative)(51), see K(44).
Count 10.9 Task and Entry Attributes(5), see J. Language-Defined Attributes (informative)(5), see K(48).
Definite 13.5.1 Formal Private and Derived Types(23), see J. Language-Defined Attributes (informative)(23), see K(50).
Delta 4.5.10 Operations of Fixed Point Types(3), see J. Language-Defined Attributes (informative)(3), see K(52).
Denorm A.5.3 Attributes of Floating Point Types(9), see J. Language-Defined Attributes (informative)(9), see K(54).
Digits 4.5.8 Operations of Floating Point Types(2), see 4.5.10 Operations of Fixed Point Types(7), see J. Language-Defined Attributes (informative)(2), see 4.5.10 Operations of Fixed Point Types(7), see K(56),
J. Language-Defined Attributes (informative).
Exponent A.5.3 Attributes of Floating Point Types(18), see J. Language-Defined Attributes (informative)(18), see K(60).
External_Tag 14.3 Representation Attributes(75), see J. Language-Defined Attributes (informative)(75), see K(64).
First 4.5 Scalar Types(12), see 4.6.2 Operations of Array Types(3), see J. Language-Defined Attributes (informative)(12), see 4.6.2 Operations of Array Types(3), see K(68),
J. Language-Defined Attributes (informative).
First(N) 4.6.2 Operations of Array Types(4), see J. Language-Defined Attributes (informative)(4), see K(66).
First_Bit 14.5.2 Storage Place Attributes(3), see J. Language-Defined Attributes (informative)(3), see K(72).
Floor A.5.3 Attributes of Floating Point Types(30), see J. Language-Defined Attributes (informative)(30), see K(74).
Fore 4.5.10 Operations of Fixed Point Types(4), see J. Language-Defined Attributes (informative)(4), see K(78).
Fraction A.5.3 Attributes of Floating Point Types(21), see J. Language-Defined Attributes (informative)(21), see K(80).
Identity 12.4.1 The Package Exceptions(9), see C.7.1 The Package Task_Identification(12), see J. Language-Defined Attributes (informative)(9), see C.7.1 The Package Task_Identification(12), see K(84),
J. Language-Defined Attributes (informative).
Image 4.5 Scalar Types(35), see J. Language-Defined Attributes (informative)(35), see K(88).
Input 14.13.2 Stream-Oriented Attributes(22), see 14.13.2 Stream-Oriented Attributes(32), see J. Language-Defined Attributes (informative)(22), see 14.13.2 Stream-Oriented Attributes(32), see K(92),
J. Language-Defined Attributes (informative).
Last 4.5 Scalar Types(13), see 4.6.2 Operations of Array Types(5), see J. Language-Defined Attributes (informative)(13), see 4.6.2 Operations of Array Types(5), see K(102),
J. Language-Defined Attributes (informative).
Last(N) 4.6.2 Operations of Array Types(6), see J. Language-Defined Attributes (informative)(6), see K(100).
Last_Bit 14.5.2 Storage Place Attributes(4), see J. Language-Defined Attributes (informative)(4), see K(106).
Leading_Part A.5.3 Attributes of Floating Point Types(54), see J. Language-Defined Attributes (informative)(54), see K(108).
Length 4.6.2 Operations of Array Types(9), see J. Language-Defined Attributes (informative)(9), see K(117).
Length(N) 4.6.2 Operations of Array Types(10), see J. Language-Defined Attributes (informative)(10), see K(115).
Machine A.5.3 Attributes of Floating Point Types(60), see J. Language-Defined Attributes (informative)(60), see K(119).
Machine_Emax A.5.3 Attributes of Floating Point Types(8), see J. Language-Defined Attributes (informative)(8), see K(123).
Machine_Emin A.5.3 Attributes of Floating Point Types(7), see J. Language-Defined Attributes (informative)(125)
Machine_Mantissa A.5.3 Attributes of Floating Point Types(6), see J. Language-Defined Attributes (informative)(6), see K(127).
Machine_Overflows A.5.3 Attributes of Floating Point Types(12), see A.5.4 Attributes of Fixed Point Types(12), see A.5.4(4),
J. Language-Defined Attributes (informative)(129), J. Language-Defined Attributes (informative)(129), K(131).
Machine_Radix A.5.3 Attributes of Floating Point Types(2), see A.5.4 Attributes of Fixed Point Types(2), see J. Language-Defined Attributes (informative)(2), see A.5.4 Attributes of Fixed Point Types(2), see K(133),
J. Language-Defined Attributes (informative).
Machine_Rounds A.5.3 Attributes of Floating Point Types(11), see A.5.4 Attributes of Fixed Point Types(11), see A.5.4(3),
J. Language-Defined Attributes (informative)(137), J. Language-Defined Attributes (informative)(137), K(139).
Max 4.5 Scalar Types(19), see J. Language-Defined Attributes (informative)(19), see K(141).
Max_Size_In_Storage_Elements 14.11.1 The Max_Size_In_Storage_Elements Attribute(3), see J. Language-Defined Attributes (informative)(3), see K(145).
Min 4.5 Scalar Types(16), see J. Language-Defined Attributes (informative)(147)
Model A.5.3 Attributes of Floating Point Types(68), see G.2.2 Model-Oriented Attributes of Floating Point Types(7), see J. Language-Defined Attributes (informative)(68), see G.2.2 Model-Oriented Attributes of Floating Point Types(7), see K(151).
Model_Emin A.5.3 Attributes of Floating Point Types(65), see G.2.2 Model-Oriented Attributes of Floating Point Types(4), see J. Language-Defined Attributes (informative)(155)
Model_Epsilon A.5.3 Attributes of Floating Point Types(66), see J. Language-Defined Attributes (informative)(66), see K(157).
Model_Mantissa A.5.3 Attributes of Floating Point Types(64), see G.2.2 Model-Oriented Attributes of Floating Point Types(3), see J. Language-Defined Attributes (informative)(64), see G.2.2 Model-Oriented Attributes of Floating Point Types(3), see K(159).
Model_Small A.5.3 Attributes of Floating Point Types(67), see J. Language-Defined Attributes (informative)(67), see K(161).
Modulus 4.5.4 Integer Types(17), see J. Language-Defined Attributes (informative)(17), see K(163).
Output 14.13.2 Stream-Oriented Attributes(19), see 14.13.2 Stream-Oriented Attributes(29), see J. Language-Defined Attributes (informative)(19), see 14.13.2 Stream-Oriented Attributes(29), see K(165),
J. Language-Defined Attributes (informative).
Partition_ID E.1 Partitions(9), see J. Language-Defined Attributes (informative)(9), see K(173).
Pos 4.5.5 Operations of Discrete Types(2), see J. Language-Defined Attributes (informative)(2), see K(175).
Position 14.5.2 Storage Place Attributes(2), see J. Language-Defined Attributes (informative)(2), see K(179).
Pred 4.5 Scalar Types(25), see J. Language-Defined Attributes (informative)(25), see K(181).
Range 4.5 Scalar Types(14), see 4.6.2 Operations of Array Types(7), see J. Language-Defined Attributes (informative)(14), see 4.6.2 Operations of Array Types(7), see K(187),
J. Language-Defined Attributes (informative).
Range(N) 4.6.2 Operations of Array Types(8), see J. Language-Defined Attributes (informative)(8), see K(185).
Read 14.13.2 Stream-Oriented Attributes(6), see 14.13.2 Stream-Oriented Attributes(14), see J. Language-Defined Attributes (informative)(6), see 14.13.2 Stream-Oriented Attributes(14), see K(191),
J. Language-Defined Attributes (informative).
Remainder A.5.3 Attributes of Floating Point Types(45), see J. Language-Defined Attributes (informative)(45), see K(199).
Round 4.5.10 Operations of Fixed Point Types(12), see J. Language-Defined Attributes (informative)(12), see K(203).
Rounding A.5.3 Attributes of Floating Point Types(36), see J. Language-Defined Attributes (informative)(36), see K(207).
Safe_First A.5.3 Attributes of Floating Point Types(71), see G.2.2 Model-Oriented Attributes of Floating Point Types(5), see J. Language-Defined Attributes (informative)(71), see G.2.2 Model-Oriented Attributes of Floating Point Types(5), see K(211).
Safe_Last A.5.3 Attributes of Floating Point Types(72), see G.2.2 Model-Oriented Attributes of Floating Point Types(6), see J. Language-Defined Attributes (informative)(72), see G.2.2 Model-Oriented Attributes of Floating Point Types(6), see K(213).
Scale 4.5.10 Operations of Fixed Point Types(11), see J. Language-Defined Attributes (informative)(11), see K(215).
Scaling A.5.3 Attributes of Floating Point Types(27), see J. Language-Defined Attributes (informative)(27), see K(217).
Signed_Zeros A.5.3 Attributes of Floating Point Types(13), see J. Language-Defined Attributes (informative)(13), see K(221).
Size 14.3 Representation Attributes(40), see 14.3 Representation Attributes(45), see J. Language-Defined Attributes (informative)(40), see 14.3 Representation Attributes(45), see K(223),
J. Language-Defined Attributes (informative).
Small 4.5.10 Operations of Fixed Point Types(2), see J. Language-Defined Attributes (informative)(2), see K(230).
Storage_Pool 14.11 Storage Management(13), see J. Language-Defined Attributes (informative)(13), see K(232).
Storage_Size 14.3 Representation Attributes(60), see 14.11 Storage Management(14), see I.9 The Storage_Size Attribute(60), see 14.11 Storage Management(14), see J.9(2),
J. Language-Defined Attributes (informative)(234), see J. Language-Defined Attributes (informative)(234), see K(236).
Succ 4.5 Scalar Types(22), see J. Language-Defined Attributes (informative)(22), see K(238).
Tag 4.9 Tagged Types and Type Extensions(16), see 4.9 Tagged Types and Type Extensions(18), see J. Language-Defined Attributes (informative)(16), see 4.9 Tagged Types and Type Extensions(18), see K(242),
J. Language-Defined Attributes (informative).
Terminated 10.9 Task and Entry Attributes(3), see J. Language-Defined Attributes (informative)(3), see K(246).
Truncation A.5.3 Attributes of Floating Point Types(42), see J. Language-Defined Attributes (informative)(42), see K(248).
Unbiased_Rounding A.5.3 Attributes of Floating Point Types(39), see J. Language-Defined Attributes (informative)(39), see K(252).
Unchecked_Access 14.10 Unchecked Access Value Creation(3), see H.4 Safety and Security Restrictions(18), see J. Language-Defined Attributes (informative)(3), see H.4 Safety and Security Restrictions(18), see K(256).
Val 4.5.5 Operations of Discrete Types(5), see J. Language-Defined Attributes (informative)(5), see K(258).
Valid 14.9.2 The Valid Attribute(3), see H. Safety and Security (normative)(6), see J. Language-Defined Attributes (informative)(3), see H. Safety and Security (normative)(6), see K(262).
Value 4.5 Scalar Types(52), see J. Language-Defined Attributes (informative)(52), see K(264).
Version E.3 Consistency of a Distributed System(3), see J. Language-Defined Attributes (informative)(3), see K(268).
Wide_Image 4.5 Scalar Types(28), see J. Language-Defined Attributes (informative)(28), see K(270).
Wide_Value 4.5 Scalar Types(40), see J. Language-Defined Attributes (informative)(40), see K(274).
Wide_Width 4.5 Scalar Types(38), see J. Language-Defined Attributes (informative)(38), see K(278).
Width 4.5 Scalar Types(39), see J. Language-Defined Attributes (informative)(39), see K(280).
Write 14.13.2 Stream-Oriented Attributes(3), see 14.13.2 Stream-Oriented Attributes(11), see J. Language-Defined Attributes (informative)(3), see 14.13.2 Stream-Oriented Attributes(11), see K(282),
J. Language-Defined Attributes (informative).
|
P. index
| | Backus-Naur Form (BNF)
complete listing N. Syntax Summary (informative).
cross reference N. Syntax Summary (informative).
notation 2.1.4 Method of Description and Syntax Notation.
under Syntax heading 2.1.2 Structure.
base 3.4.2 Based Literals(3), see 3.4.2 Based Literals(3), see 2.4.2(6).
base 16 literal 3.4.2 Based Literals.
used 3.4.2 Based Literals(2), see N. Syntax Summary (informative)(2), see P(1).
base 2 literal 3.4.2 Based Literals.
base 8 literal 3.4.2 Based Literals.
Base attribute 4.5 Scalar Types(15), see J. Language-Defined Attributes (informative)(15), see K(17).
base decimal precision
of a floating point type 4.5.7 Floating Point Types(9), see 4.5.7 Floating Point Types(9), see 3.5.7(10).
base priority D.1 Task Priorities.
base range
of a decimal fixed point type 4.5.9 Fixed Point Types.
of a fixed point type 4.5.9 Fixed Point Types.
of a floating point type 4.5.7 Floating Point Types(8), see 4.5.7 Floating Point Types(8), see 3.5.7(10).
of a modular type 4.5.4 Integer Types.
of a scalar type 4.5 Scalar Types.
of a signed integer type 4.5.4 Integer Types.
of an ordinary fixed point type 4.5.9 Fixed Point Types.
base subtype
of a type 4.5 Scalar Types.
based_literal 3.4.2 Based Literals.
used 3.4 Numeric Literals(2), see N. Syntax Summary (informative)(2), see P(1).
based_numeral 3.4.2 Based Literals.
used 3.4.2 Based Literals(2), see N. Syntax Summary (informative)(2), see P(1).
basic letter
a category of Character A.3.2 The Package Characters.Handling.
basic_declaration 4.1 Declarations.
used 4.11 Declarative Parts(4), see N. Syntax Summary (informative)(4), see P(1).
basic_declarative_item 4.11 Declarative Parts.
used 4.11 Declarative Parts(3), see 8.1 Package Specifications and Declarations(3), see N. Syntax Summary (informative)(3), see 8.1 Package Specifications and Declarations(3), see P(1).
Basic_Map A.4.6 String-Handling Sets and Mappings.
Basic_Set A.4.6 String-Handling Sets and Mappings.
become nonlimited 8.3.1 Private Operations(5), see 8.5 Limited Types(5), see 7.5(16).
BEL A.3.3 The Package Characters.Latin_1.
belong
to a range 4.5 Scalar Types.
to a subtype 4.2 Types and Subtypes.
Bias 13.2 Generic Bodies.
bibliography 2.2 Normative References.
big endian 14.5.3 Bit Ordering.
binary B.4 Interfacing with COBOL.
literal 3.4.2 Based Literals.
binary adding operator 5.5.3 Binary Adding Operators.
binary literal 3.4.2 Based Literals.
binary operator 5.5 Operators and Expression Evaluation.
binary_adding_operator 5.5 Operators and Expression Evaluation.
used 5.4 Expressions(4), see N. Syntax Summary (informative)(4), see P(1).
Binary_Format B.4 Interfacing with COBOL.
Binary_Operation 4.9.1 Type Extensions.
Binop_Ptr 4.10 Access Types.
bit field
See record_representation_clause 14.5.1 Record Representation Clauses.
bit ordering 14.5.3 Bit Ordering.
bit string
See logical operators on boolean arrays 5.5.1 Logical Operators and Short-circuit Control Forms.
Bit_Order 14.7 The Package System.
Bit_Order attribute 14.5.3 Bit Ordering(4), see J. Language-Defined Attributes (informative)(4), see K(19).
Bit_Order clause 14.3 Representation Attributes(7), see 14.5.3 Bit Ordering(7), see 13.5.3(4).
Bit_Vector 4.6 Array Types.
blank
in text input for enumeration and numeric types A.10.6 Get and Put Procedures.
block_statement 6.6 Block Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(5), see N. Syntax Summary (informative)(5), see P(1).
blocked
[partial] D.2.1 The Task Dispatching Model.
a task state 10. Tasks and Synchronization.
during an entry call 10.5.3 Entry Calls.
execution of a selective_accept 10.7.1 Selective Accept.
on a delay_statement 10.6 Delay Statements, Duration, and Time.
on an accept_statement 10.5.2 Entries and Accept Statements.
waiting for activations to complete 10.2 Task Execution - Task Activation.
waiting for dependents to terminate 10.3 Task Dependence - Termination of Tasks.
blocked interrupt C.3 Interrupt Support.
blocking, potentially .see 10.5.1 Protected Subprograms and Protected Actions(8)
Abort_Task C.7.1 The Package Task_Identification.
delay_statement 10.6 Delay Statements, Duration, and Time(34), see D.9 Delay Accuracy(34), see D.9(5).
remote subprogram call E.4 Remote Subprogram Calls.
RPC operations E.5 Partition Communication Subsystem.
Suspend_Until_True D.10 Synchronous Task Control.
BMP 4.5.2 Character Types(2), see 4.5.2 Character Types(2), see 3.5.2(3).
BNF (Backus-Naur Form)
complete listing N. Syntax Summary (informative).
cross reference N. Syntax Summary (informative).
notation 2.1.4 Method of Description and Syntax Notation.
under Syntax heading 2.1.2 Structure.
body 4.11 Declarative Parts.
used 4.11 Declarative Parts(3), see N. Syntax Summary (informative)(3), see P(1).
body_stub 11.1.3 Subunits of Compilation Units.
used 4.11 Declarative Parts(5), see N. Syntax Summary (informative)(5), see P(1).
Body_Version attribute E.3 Consistency of a Distributed System(4), see J. Language-Defined Attributes (informative)(4), see K(21).
Boolean 4.5.3 Boolean Types(1), see A.1 The Package Standard(1), see A.1(5).
boolean type 4.5.3 Boolean Types.
Bounded
child of Ada.Strings A.4.4 Bounded-Length String Handling.
bounded error 2.1.2 Structure(31), 2.1.5 Classification of Errors(8), 7.2 Formal Parameter Modes(31), 2.1.5 Classification of Errors(8), 6.2(12),
8.6.1 Completion and Finalization(14), 10.5.1 Protected Subprograms and Protected Actions(8), 10.8 Abort of a Task - Abort of a Sequence of Statements(14), 10.5.1 Protected Subprograms and Protected Actions(8), 9.8(20),
11.2 Program Execution(26), 14.9.1 Data Validity(26), 13.9.1(9),
14.11.2 Unchecked Storage Deallocation(11), see C.7.1 The Package Task_Identification(17), see D.5 Dynamic Priorities(11), see C.7.1 The Package Task_Identification(17), see D.5(11),
E.1 Partitions(10), E.3 Consistency of a Distributed System(6), I.7.1 Interrupt Entries(10), E.3 Consistency of a Distributed System(6), J.7.1(11).
Bounded_String A.4.4 Bounded-Length String Handling.
bounds
of a discrete_range 4.6.1 Index Constraints and Discrete Ranges.
of an array 4.6 Array Types.
of the index range of an array_aggregate 5.3.3 Array Aggregates.
box
compound delimiter 4.6 Array Types.
broadcast signal
See protected object 10.4 Protected Units and Protected Objects.
See requeue 10.5.4 Requeue Statements.
Broken_Bar A.3.3 The Package Characters.Latin_1.
BS A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
Buffer 4.7 Discriminants(33), see 10.11 Example of Tasking and Synchronization(8), see 10.11 Example of Tasking and Synchronization(33), see 10.11 Example of Tasking and Synchronization(8), see 9.11(9),
13.5 Formal Types.
Buffer_Size 4.5.4 Integer Types(35), see A.9 The Generic Package Storage_IO(35), see A.9(4).
Buffer_Type A.9 The Generic Package Storage_IO.
by copy parameter passing 7.2 Formal Parameter Modes.
by reference parameter passing 7.2 Formal Parameter Modes.
by-copy type 7.2 Formal Parameter Modes.
by-reference type 7.2 Formal Parameter Modes.
atomic or volatile C.6 Shared Variable Control.
Byte 4.5.4 Integer Types(36), see 14.3 Representation Attributes(80), see B.4 Interfacing with COBOL(36), see 14.3 Representation Attributes(80), see B.4(29).
See storage element 14.3 Representation Attributes.
byte sex
See ordering of storage elements in a word 14.5.3 Bit Ordering.
Byte_Array B.4 Interfacing with COBOL.
Byte_Mask 14.5.1 Record Representation Clauses.
|
Q. index
| | C 5.3.3 Array Aggregates(42), see B.3 Interfacing with C(77), see B.3.2 The Generic Package Interfaces.C.Pointers(42), see B.3 Interfacing with C(77), see B.3.2(46).
child of Interfaces B.3 Interfacing with C.
C interface B.3 Interfacing with C.
C standard 2.2 Normative References.
C_float B.3 Interfacing with C.
Calendar I.1 Renamings of Ada 83 Library Units.
child of Ada 10.6 Delay Statements, Duration, and Time.
call 7. Subprograms.
call on a dispatching operation 4.9.2 Dispatching Operations of Tagged Types.
callable 10.9 Task and Entry Attributes.
Callable attribute 10.9 Task and Entry Attributes(2), see J. Language-Defined Attributes (informative)(2), see K(23).
callable construct 7. Subprograms.
callable entity 7. Subprograms.
called partition E.4 Remote Subprogram Calls.
Caller attribute C.7.1 The Package Task_Identification(14), see J. Language-Defined Attributes (informative)(14), see K(25).
calling convention 7.3.1 Conformance Rules(2), see B.1 Interfacing Pragmas(2), see B.1(11).
Ada 7.3.1 Conformance Rules.
associated with a designated profile 4.10 Access Types.
entry 7.3.1 Conformance Rules.
Intrinsic 7.3.1 Conformance Rules.
protected 7.3.1 Conformance Rules.
calling partition E.4 Remote Subprogram Calls.
calling stub E.4 Remote Subprogram Calls.
CAN A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
cancellation
of a delay_statement 10.6 Delay Statements, Duration, and Time.
of an entry call 10.5.3 Entry Calls.
cancellation of a remote subprogram call E.4 Remote Subprogram Calls.
canonical form A.5.3 Attributes of Floating Point Types.
canonical semantics 12.6 Exceptions and Optimization.
canonical-form representation A.5.3 Attributes of Floating Point Types.
Car 4.10.1 Incomplete Type Declarations(19), see 4.10.1 Incomplete Type Declarations(21), see 13.5.4 Formal Access Types(19), see 4.10.1 Incomplete Type Declarations(21), see 12.5.4(10),
13.5.4 Formal Access Types.
Car_Name 4.10.1 Incomplete Type Declarations(20), see 13.5.4 Formal Access Types(20), see 12.5.4(10).
case insensitive 3.3 Identifiers.
case_statement 6.4 Case Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(5), see N. Syntax Summary (informative)(5), see P(1).
case_statement_alternative 6.4 Case Statements.
used 6.4 Case Statements(2), see N. Syntax Summary (informative)(2), see P(1).
cast
See type conversion 5.6 Type Conversions.
See unchecked type conversion 14.9 Unchecked Type Conversions.
catch (an exception)
See handle 12. Exceptions.
categorization pragma E.2 Categorization of Library Units.
Remote_Call_Interface E.2.3 Remote Call Interface Library Units.
Remote_Types E.2.2 Remote Types Library Units.
Shared_Passive E.2.1 Shared Passive Library Units.
categorized library unit E.2 Categorization of Library Units.
catenation operator
See concatenation operator 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 4.5.3(3).
CCH A.3.3 The Package Characters.Latin_1.
Cedilla A.3.3 The Package Characters.Latin_1.
Ceiling attribute A.5.3 Attributes of Floating Point Types(33), see J. Language-Defined Attributes (informative)(33), see K(27).
ceiling priority
of a protected object D.3 Priority Ceiling Locking.
Ceiling_Check
[partial] C.3.1 Protected Procedure Handlers(11), see D.3 Priority Ceiling Locking(11), see D.3(13).
Cell 4.10.1 Incomplete Type Declarations(15), see 4.10.1 Incomplete Type Declarations(15), see 3.10.1(16).
Cent_Sign A.3.3 The Package Characters.Latin_1.
change of representation 14.6 Change of Representation.
char B.3 Interfacing with C.
char_array B.3 Interfacing with C.
CHAR_BIT B.3 Interfacing with C.
Char_Ptrs B.3.2 The Generic Package Interfaces.C.Pointers.
Char_Star B.3.2 The Generic Package Interfaces.C.Pointers.
Char_IO A.10.10 Input-Output for Enumeration Types.
character 3.1 Character Set(2), see 4.5.2 Character Types(2), see A.1 The Package Standard(2), see 4.5.2 Character Types(2), see A.1(35).
used 3.7 Comments(2), see N. Syntax Summary (informative)(2), see P(1).
character set 3.1 Character Set.
character set standard
16-bit 2.2 Normative References.
7-bit 2.2 Normative References.
8-bit 2.2 Normative References.
control functions 2.2 Normative References.
character type 4.5.2 Character Types(1), see M. Glossary (informative)(1), see N(5).
character_literal 3.5 Character Literals.
used 4.5.1 Enumeration Types(4), see 5.1 Names(2), see 5.1.3 Selected Components(4), see 5.1 Names(2), see 4.1.3(3),
N. Syntax Summary (informative).
Character_Mapping A.4.2 The Package Strings.Maps.
Character_Mapping_Function A.4.2 The Package Strings.Maps.
Character_Range A.4.2 The Package Strings.Maps.
Character_Ranges A.4.2 The Package Strings.Maps.
Character_Sequence A.4.2 The Package Strings.Maps.
Character_Set A.4.2 The Package Strings.Maps(4), see A.4.7 Wide_String Handling(46), see B.5 Interfacing with Fortran(4), see A.4.7 Wide_String Handling(46), see B.5(11).
characteristics 8.3 Private Types and Private Extensions.
Characters
child of Ada A.3.1 The Package Characters.
chars_ptr B.3.1 The Package Interfaces.C.Strings.
check
language-defined 12.5 Suppressing Checks(2), see 12.6 Exceptions and Optimization(2), see 11.6(1).
check, language-defined
Access_Check 5.1 Names(13), see 5.6 Type Conversions(13), see 4.6(49).
Accessibility_Check 4.10.2 Operations of Access Types(29), see 5.6 Type Conversions(29), see 4.6(48),
7.5 Return Statements(17), see E.4 Remote Subprogram Calls(17), see E.4(18).
Ceiling_Check C.3.1 Protected Procedure Handlers(11), see D.3 Priority Ceiling Locking(11), see D.3(13).
Discriminant_Check 5.1.3 Selected Components(15), see 5.3 Aggregates(15), see 4.3(6),
5.3.2 Extension Aggregates(8), 5.6 Type Conversions(8), 4.6(43),
5.6 Type Conversions(45), 5.6 Type Conversions(45), 4.6(51),
5.6 Type Conversions(52), 5.7 Qualified Expressions(52), 4.7(4),
5.8 Allocators.
Division_Check 4.5.4 Integer Types(20), see 5.5.5 Multiplying Operators(20), see 4.5.5(22),
A.5.1 Elementary Functions(28), see A.5.3 Attributes of Floating Point Types(28), see A.5.3(47),
G.1.1 Complex Types(40), see G.1.2 Complex Elementary Functions(40), see G.1.2(28),
J. Language-Defined Attributes (informative).
Elaboration_Check 4.11 Declarative Parts.
Index_Check 5.1.1 Indexed Components(7), 5.1.2 Slices(7), see 5.3.3 Array Aggregates(7), 5.1.2 Slices(7), see 4.3.3(29),
5.3.3 Array Aggregates(30), see 5.5.3 Binary Adding Operators(8), see 5.6 Type Conversions(30), see 5.5.3 Binary Adding Operators(8), see 4.6(51),
5.7 Qualified Expressions(4), 5.8 Allocators(4), 4.8(10).
Length_Check 5.5.1 Logical Operators and Short-circuit Control Forms(8), see 5.6 Type Conversions(37), see 5.6 Type Conversions(8), see 5.6 Type Conversions(37), see 4.6(52).
Overflow_Check 4.5.4 Integer Types(20), see 5.4 Expressions(20), see 4.4(11),
6.4 Case Statements(13), G.2.1 Model of Floating Point Arithmetic(13), G.2.1(11),
G.2.2 Model-Oriented Attributes of Floating Point Types(7), G.2.3 Model of Fixed Point Arithmetic(7), G.2.3(25),
G.2.4 Accuracy Requirements for the Elementary Functions(2), G.2.6 Accuracy Requirements for Complex Arithmetic(2), G.2.6(3).
Partition_Check E.4(19)
Range_Check 4.2.2 Subtype Declarations(11), see 4.5 Scalar Types(11), see 3.5(24),
4.5 Scalar Types(27), 4.5 Scalar Types(27), 3.5(43),
4.5 Scalar Types(44), 4.5 Scalar Types(44), 3.5(51),
4.5 Scalar Types(55), 4.5.5 Operations of Discrete Types(55), 3.5.5(7),
4.5.9 Fixed Point Types(19), see 5.2 Literals(19), see 4.2(11),
5.3.3 Array Aggregates(28), see 5.5.1 Logical Operators and Short-circuit Control Forms(28), see 4.5.1(8),
5.5.6 Highest Precedence Operators(6), 5.5.6 Highest Precedence Operators(6), 4.5.6(13),
5.6 Type Conversions(28), 5.6 Type Conversions(28), 4.6(38),
5.6 Type Conversions(46), 5.6 Type Conversions(46), 4.6(51),
5.7 Qualified Expressions(4), 14.13.2 Stream-Oriented Attributes(4), 13.13.2(35),
A.5.2 Random Number Generation(39), see A.5.2 Random Number Generation(39), see A.5.2(40),
A.5.3 Attributes of Floating Point Types(26), see A.5.3 Attributes of Floating Point Types(26), see A.5.3(29),
A.5.3 Attributes of Floating Point Types(50), see A.5.3 Attributes of Floating Point Types(50), see A.5.3(53),
A.5.3 Attributes of Floating Point Types(59), see A.5.3 Attributes of Floating Point Types(59), see A.5.3(62),
J. Language-Defined Attributes (informative)(11), J. Language-Defined Attributes (informative)(11), K(41),
J. Language-Defined Attributes (informative)(47), J. Language-Defined Attributes (informative)(47), K(114),
J. Language-Defined Attributes (informative)(122), J. Language-Defined Attributes (informative)(122), K(184),
J. Language-Defined Attributes (informative)(220), J. Language-Defined Attributes (informative)(220), K(241).
Reserved_Check C.3.1 Protected Procedure Handlers.
Storage_Check 12.1 Exception Declarations(6), 14.3 Representation Attributes(6), 13.3(67),
14.11 Storage Management(17), see D.7 Tasking Restrictions(17), see D.7(15).
Tag_Check 4.9.2 Dispatching Operations of Tagged Types(16), see 5.6 Type Conversions(42), see 5.6 Type Conversions(16), see 5.6 Type Conversions(42), see 4.6(52),
6.2 Assignment Statements(10), 7.5 Return Statements(10), 6.5(9).
child
of a library unit 11.1.1 Compilation Units - Library Units.
choice parameter 12.2 Exception Handlers.
choice_parameter_specification 12.2 Exception Handlers.
used 12.2 Exception Handlers(3), see N. Syntax Summary (informative)(3), see P(1).
Circumflex A.3.3 The Package Characters.Latin_1.
class M. Glossary (informative).
See also package 8. Packages.
See also tag 4.9 Tagged Types and Type Extensions.
of types 4.2 Types and Subtypes.
Class attribute 4.9 Tagged Types and Type Extensions(14), see 8.3.1 Private Operations(9), see J. Language-Defined Attributes (informative)(14), see 8.3.1 Private Operations(9), see K(31),
J. Language-Defined Attributes (informative).
class determined for a formal type 13.5 Formal Types.
class-wide type 4.4.1 Derivation Classes(4), see 4.7 Discriminants(4), see 3.7(26).
cleanup
See finalization 8.6.1 Completion and Finalization.
clock 10.6 Delay Statements, Duration, and Time(6), see 10.6 Delay Statements, Duration, and Time(12), see D.8 Monotonic Time(6), see 10.6 Delay Statements, Duration, and Time(12), see D.8(7).
clock jump D.8 Monotonic Time.
clock tick D.8 Monotonic Time.
Close 8.5 Limited Types(19), 8.5 Limited Types(20), A.8.1 The Generic Package Sequential_IO(19), 8.5 Limited Types(20), A.8.1(8),
A.8.4 The Generic Package Direct_IO(8), see A.10.1 The Package Text_IO(11), see A.12.1 The Package Streams.Stream_IO(8), see A.10.1 The Package Text_IO(11), see A.12.1(10).
close result set G.2.3 Model of Fixed Point Arithmetic.
closed entry 10.5.3 Entry Calls.
of a protected object 10.5.3 Entry Calls.
of a task 10.5.3 Entry Calls.
closed under derivation 4.4 Derived Types and Classes(28), see M. Glossary (informative)(6), see M. Glossary (informative)(28), see M. Glossary (informative)(6), see N(41).
closure
downward 4.10.2 Operations of Access Types.
COBOL B.4 Interfacing with COBOL(104), see B.4 Interfacing with COBOL(104), see B.4(113).
child of Interfaces B.4 Interfacing with COBOL.
COBOL interface B.4 Interfacing with COBOL.
COBOL standard 2.2 Normative References.
COBOL_Character B.4 Interfacing with COBOL.
COBOL_Employee_Record_Type B.4 Interfacing with COBOL.
COBOL_Employee_IO B.4 Interfacing with COBOL.
COBOL_Record B.4 Interfacing with COBOL.
Code 5.7 Qualified Expressions.
code_statement 14.8 Machine Code Insertions.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
coding
aspect of representation 14.4 Enumeration Representation Clauses.
Coefficient 4.5.7 Floating Point Types.
Coin A.5.2 Random Number Generation(58)
Col A.10.1 The Package Text_IO.
colon 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(10), see I.5 ASCII(15), see A.3.3 The Package Characters.Latin_1(10), see J.5(6).
Color 4.2.1 Type Declarations(15), see 4.5.1 Enumeration Types(15), see 3.5.1(14).
Column 4.2.1 Type Declarations.
column number A.10 Text Input-Output.
Column_Ptr 4.5.4 Integer Types.
comma 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(15), see A.3.3(8).
Command_Line
child of Ada A.15 The Package Command_Line.
Command_Name A.15 The Package Command_Line.
comment 3.7 Comments.
comments, instructions for submission Introduction.
Commercial_At A.3.3 The Package Characters.Latin_1.
Communication_Error E.5 Partition Communication Subsystem.
comparison operator
See relational operator 5.5.2 Relational Operators and Membership Tests.
compatibility
composite_constraint with an access subtype 4.10 Access Types.
constraint with a subtype 4.2.2 Subtype Declarations.
delta_constraint with an ordinary fixed point subtype
I.3 Reduced Accuracy Subtypes.
digits_constraint with a decimal fixed point subtype
4.5.9 Fixed Point Types.
digits_constraint with a floating point subtype I.3 Reduced Accuracy Subtypes.
discriminant constraint with a subtype 4.7.1 Discriminant Constraints.
index constraint with a subtype 4.6.1 Index Constraints and Discrete Ranges.
range with a scalar subtype 4.5 Scalar Types.
range_constraint with a scalar subtype 4.5 Scalar Types.
compatible
a type, with a convention B.1 Interfacing Pragmas.
compilation 11.1.1 Compilation Units - Library Units.
separate 11.1 Separate Compilation.
Compilation unit 11.1 Separate Compilation(2), see 11.1.1 Compilation Units - Library Units(9), see M. Glossary (informative)(2), see 11.1.1 Compilation Units - Library Units(9), see N(7).
compilation units needed
by a compilation unit 11.2 Program Execution.
remote call interface E.2.3 Remote Call Interface Library Units.
shared passive library unit E.2.1 Shared Passive Library Units.
compilation_unit 11.1.1 Compilation Units - Library Units.
used 11.1.1 Compilation Units - Library Units(2), see N. Syntax Summary (informative)(2), see P(1).
compile-time error 2.1.2 Structure(27), see 2.1.5 Classification of Errors(27), see 1.1.5(4).
compile-time semantics 2.1.2 Structure.
complete context 9.6 The Context of Overload Resolution.
completely defined 4.11.1 Completions of Declarations.
completion
abnormal 8.6.1 Completion and Finalization.
compile-time concept 4.11.1 Completions of Declarations.
normal 8.6.1 Completion and Finalization.
run-time concept 8.6.1 Completion and Finalization.
completion and leaving (completed and left) 8.6.1 Completion and Finalization.
completion legality
entry_body 10.5.2 Entries and Accept Statements.
[partial] 4.10.1 Incomplete Type Declarations.
Complex 4.8 Record Types(28), see B.5 Interfacing with Fortran(9), see G.1.1 Complex Types(28), see B.5 Interfacing with Fortran(9), see G.1.1(3).
Complex_Elementary_Functions
child of Ada.Numerics G.1.2 Complex Elementary Functions.
Complex_Types
child of Ada.Numerics G.1.1 Complex Types.
Complex_IO
child of Ada.Text_IO G.1.3 Complex Input-Output.
child of Ada.Wide_Text_IO G.1.4 The Package Wide_Text_IO.Complex_IO.
component 4.2 Types and Subtypes(2), see 10.4 Protected Units and Protected Objects(31), see 10.4 Protected Units and Protected Objects(2), see 10.4 Protected Units and Protected Objects(31), see 9.4(32).
component subtype 4.6 Array Types.
component_choice_list 5.3.1 Record Aggregates.
used 5.3.1 Record Aggregates(4), see N. Syntax Summary (informative)(4), see P(1).
component_clause 14.5.1 Record Representation Clauses.
used 14.5.1 Record Representation Clauses(2), see N. Syntax Summary (informative)(2), see P(1).
component_declaration 4.8 Record Types.
used 4.8 Record Types(5), see 10.4 Protected Units and Protected Objects(6), see N. Syntax Summary (informative)(5), see 10.4 Protected Units and Protected Objects(6), see P(1).
component_definition 4.6 Array Types.
used 4.6 Array Types(3), see 4.6 Array Types(5), see 4.8 Record Types(6), see N. Syntax Summary (informative)(3), see 4.6 Array Types(5), see 4.8 Record Types(6), see P(1).
component_item 4.8 Record Types.
used 4.8 Record Types(4), see N. Syntax Summary (informative)(4), see P(1).
component_list 4.8 Record Types.
used 4.8 Record Types(3), see 4.8.1 Variant Parts and Discrete Choices(3), see N. Syntax Summary (informative)(3), see 4.8.1 Variant Parts and Discrete Choices(3), see P(1).
Component_Size attribute 14.3 Representation Attributes(69), see J. Language-Defined Attributes (informative)(69), see K(36).
Component_Size clause 14.3 Representation Attributes(7), see 14.3 Representation Attributes(7), see 13.3(70).
components
of a record type 4.8 Record Types.
Compose attribute A.5.3 Attributes of Floating Point Types(24), see J. Language-Defined Attributes (informative)(24), see K(38).
Compose_From_Cartesian G.1.1 Complex Types.
Compose_From_Polar G.1.1 Complex Types.
composite type 4.2 Types and Subtypes(2), see M. Glossary (informative)(2), see N(8).
composite_constraint 4.2.2 Subtype Declarations.
used 4.2.2 Subtype Declarations(5), see N. Syntax Summary (informative)(5), see P(1).
compound delimiter 3.2 Lexical Elements, Separators, and Delimiters.
compound_statement 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(3), see N. Syntax Summary (informative)(3), see P(1).
concatenation operator 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 4.5.3(3).
concrete subprogram
See nonabstract subprogram 4.9.3 Abstract Types and Subprograms.
concrete type
See nonabstract type 4.9.3 Abstract Types and Subprograms.
concurrent processing
See task 10. Tasks and Synchronization.
condition 6.3 If Statements.
used 6.3 If Statements(2), 6.5 Loop Statements(3), 6.7 Exit Statements(2), 6.5 Loop Statements(3), 5.7(2),
10.5.2 Entries and Accept Statements(7), see 10.7.1 Selective Accept(3), see N. Syntax Summary (informative)(7), see 10.7.1 Selective Accept(3), see P(1).
See also exception 12. Exceptions.
conditional_entry_call 10.7.3 Conditional Entry Calls.
used 10.7 Select Statements(2), see N. Syntax Summary (informative)(2), see P(1).
configuration
of the partitions of a program E. Distributed Systems (normative).
configuration pragma 11.1.5 Pragmas and Program Units.
Locking_Policy D.3 Priority Ceiling Locking.
Normalize_Scalars H.1 Pragma Normalize_Scalars.
Queuing_Policy D.4 Entry Queuing Policies.
Restrictions 14.12 Pragma Restrictions.
Reviewable H.3.1 Pragma Reviewable.
Suppress 12.5 Suppressing Checks.
Task_Dispatching_Policy D.2.2 The Standard Task Dispatching Policy.
conformance 7.3.1 Conformance Rules.
of an implementation with the Standard 2.1.3 Conformity of an Implementation with the Standard.
See also full conformance, mode conformance,
subtype conformance, type conformance
Conjugate G.1.1 Complex Types(12), see G.1.1 Complex Types(12), see G.1.1(15).
consistency
among compilation units 11.1.4 The Compilation Process.
constant 4.3 Objects and Named Numbers.
See also literal 5.2 Literals.
See also static 5.9 Static Expressions and Static Subtypes.
result of a function_call 7.4 Subprogram Calls.
constant object 4.3 Objects and Named Numbers.
constant view 4.3 Objects and Named Numbers.
Constants
child of Ada.Strings.Maps A.4.6 String-Handling Sets and Mappings.
constituent
of a construct 2.1.4 Method of Description and Syntax Notation.
constrained 4.2 Types and Subtypes.
object 4.3.1 Object Declarations(9), see 4.10 Access Types(9), see 7.4.1 Parameter Associations(9), see 4.10 Access Types(9), see 6.4.1(16).
subtype 4.2 Types and Subtypes(9), 4.4 Derived Types and Classes(6), 4.5 Scalar Types(9), 4.4 Derived Types and Classes(6), 3.5(7),
4.5.1 Enumeration Types(10), see 4.5.4 Integer Types(9), 4.5.4 Integer Types(10), see 4.5.4 Integer Types(9), 3.5.4(10),
4.5.7 Floating Point Types(11), see 4.5.9 Fixed Point Types(13), see 4.5.9 Fixed Point Types(11), see 4.5.9 Fixed Point Types(13), see 3.5.9(16),
4.6 Array Types(15), 4.6 Array Types(16), 4.7 Discriminants(15), 4.6 Array Types(16), 3.7(26),
4.9 Tagged Types and Type Extensions(15), 4.10 Access Types(14), J. Language-Defined Attributes (informative)(15), 4.10 Access Types(14), K(33).
Constrained attribute 4.7.2 Operations of Discriminated Types(3), see I.4 The Constrained Attribute(2), see J. Language-Defined Attributes (informative)(3), see I.4 The Constrained Attribute(2), see K(42).
constrained by its initial value 4.3.1 Object Declarations(9), see 4.10 Access Types(9), see 3.10(9).
[partial] 5.8 Allocators.
constrained_array_definition 4.6 Array Types.
used 4.6 Array Types(2), see N. Syntax Summary (informative)(2), see P(1).
constraint 4.2.2 Subtype Declarations.
used 4.2.2 Subtype Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
[partial] 4.2 Types and Subtypes.
of a first array subtype 4.6 Array Types.
of an object 4.3.1 Object Declarations.
Constraint_Error A.1 The Package Standard.
raised by failure of run-time check
4.2.2 Subtype Declarations(12), 4.5 Scalar Types(24), 4.5 Scalar Types(12), 4.5 Scalar Types(24), 3.5(27),
4.5 Scalar Types(43), 4.5 Scalar Types(44), 4.5 Scalar Types(43), 4.5 Scalar Types(44), 3.5(51),
4.5 Scalar Types(55), 4.5.4 Integer Types(20), see 4.5.5 Operations of Discrete Types(55), 4.5.4 Integer Types(20), see 3.5.5(7),
4.5.9 Fixed Point Types(19), 4.9.2 Dispatching Operations of Tagged Types(16), see 5.1 Names(19), 4.9.2 Dispatching Operations of Tagged Types(16), see 4.1(13),
5.1.1 Indexed Components(7), 5.1.2 Slices(7), 5.1.3 Selected Components(7), 5.1.2 Slices(7), 4.1.3(15),
5.2 Literals(11), 5.3 Aggregates(6), 5.3.2 Extension Aggregates(11), 5.3 Aggregates(6), 4.3.2(8),
5.3.3 Array Aggregates(31), 5.4 Expressions(11), 5.5 Operators and Expression Evaluation(31), 5.4 Expressions(11), 4.5(10),
5.5 Operators and Expression Evaluation(11), 5.5 Operators and Expression Evaluation(12), 5.5.1 Logical Operators and Short-circuit Control Forms(11), 5.5 Operators and Expression Evaluation(12), 4.5.1(8),
5.5.3 Binary Adding Operators(8), 5.5.5 Multiplying Operators(22), see 5.5.6 Highest Precedence Operators(8), 5.5.5 Multiplying Operators(22), see 4.5.6(6),
5.5.6 Highest Precedence Operators(12), 5.5.6 Highest Precedence Operators(13), see 5.6 Type Conversions(12), 5.5.6 Highest Precedence Operators(13), see 4.6(28),
5.6 Type Conversions(57), 5.6 Type Conversions(60), 5.7 Qualified Expressions(57), 5.6 Type Conversions(60), 4.7(4),
5.8 Allocators(10), 6.2 Assignment Statements(10), 6.4 Case Statements(10), 6.2 Assignment Statements(10), 5.4(13),
7.5 Return Statements(9), 12.1 Exception Declarations(4), 12.4.1 The Package Exceptions(9), 12.1 Exception Declarations(4), 11.4.1(14),
12.5 Suppressing Checks(10), 14.9.1 Data Validity(9), see 14.13.2 Stream-Oriented Attributes(10), 14.9.1 Data Validity(9), see 13.13.2(35),
A.4.3 Fixed-Length String Handling(109), see A.4.7 Wide_String Handling(47), see A.5.1 Elementary Functions(109), see A.4.7 Wide_String Handling(47), see A.5.1(28),
A.5.1 Elementary Functions(34), A.5.2 Random Number Generation(39), see A.5.2 Random Number Generation(34), A.5.2 Random Number Generation(39), see A.5.2(40),
A.5.3 Attributes of Floating Point Types(26), A.5.3 Attributes of Floating Point Types(29), see A.5.3 Attributes of Floating Point Types(26), A.5.3 Attributes of Floating Point Types(29), see A.5.3(47),
A.5.3 Attributes of Floating Point Types(50), A.5.3 Attributes of Floating Point Types(53), see A.5.3 Attributes of Floating Point Types(50), A.5.3 Attributes of Floating Point Types(53), see A.5.3(59),
A.5.3 Attributes of Floating Point Types(62), A.15 The Package Command_Line(14), B.3 Interfacing with C(62), A.15 The Package Command_Line(14), B.3(53),
B.3 Interfacing with C(54), B.4 Interfacing with COBOL(58), E.4 Remote Subprogram Calls(54), B.4 Interfacing with COBOL(58), E.4(19),
G.1.1 Complex Types(40), G.1.2 Complex Elementary Functions(28), see G.2.1 Model of Floating Point Arithmetic(40), G.1.2 Complex Elementary Functions(28), see G.2.1(12),
G.2.2 Model-Oriented Attributes of Floating Point Types(7), G.2.3 Model of Fixed Point Arithmetic(26), see G.2.4 Accuracy Requirements for the Elementary Functions(7), G.2.3 Model of Fixed Point Arithmetic(26), see G.2.4(3),
G.2.6 Accuracy Requirements for Complex Arithmetic(4), J. Language-Defined Attributes (informative)(11), J. Language-Defined Attributes (informative)(4), J. Language-Defined Attributes (informative)(11), K(41),
J. Language-Defined Attributes (informative)(47), J. Language-Defined Attributes (informative)(114), J. Language-Defined Attributes (informative)(47), J. Language-Defined Attributes (informative)(114), K(122),
J. Language-Defined Attributes (informative)(184), J. Language-Defined Attributes (informative)(202), J. Language-Defined Attributes (informative)(184), J. Language-Defined Attributes (informative)(202), K(220),
J. Language-Defined Attributes (informative)(241), J. Language-Defined Attributes (informative)(241), K(261).
Construct 2.1.4 Method of Description and Syntax Notation(16), see M. Glossary (informative)(16), see N(9).
constructor
See initialization 4.3.1 Object Declarations(19), see 8.6 User-Defined Assignment and Finalization(19), see 7.6(1).
See initialization expression 4.3.1 Object Declarations.
See Initialize 8.6 User-Defined Assignment and Finalization.
See initialized alligator 5.8 Allocators.
Consumer 10.11 Example of Tasking and Synchronization(5), see 10.11 Example of Tasking and Synchronization(5), see 9.11(6).
context free grammar
complete listing N. Syntax Summary (informative).
cross reference N. Syntax Summary (informative).
notation 2.1.4 Method of Description and Syntax Notation.
under Syntax heading 2.1.2 Structure.
context_clause 11.1.2 Context Clauses - With Clauses.
used 11.1.1 Compilation Units - Library Units(3), see N. Syntax Summary (informative)(3), see P(1).
context_item 11.1.2 Context Clauses - With Clauses.
used 11.1.2 Context Clauses - With Clauses(2), see N. Syntax Summary (informative)(2), see P(1).
contiguous representation
[partial] 14.5.2 Storage Place Attributes(5), see 14.7.1 The Package System.Storage_Elements(12), see 14.9 Unchecked Type Conversions(5), see 14.7.1 The Package System.Storage_Elements(12), see 13.9(9),
14.9 Unchecked Type Conversions(17), 14.11 Storage Management(17), 13.11(16).
Continue D.11 Asynchronous Task Control.
control character
See also format_effector 3.1 Character Set.
See also other_control_function 3.1 Character Set.
a category of Character A.3.2 The Package Characters.Handling(22), see A.3.3 The Package Characters.Latin_1(22), see A.3.3(4),
A.3.3 The Package Characters.Latin_1.
Control_Set A.4.6 String-Handling Sets and Mappings.
Controlled 8.6 User-Defined Assignment and Finalization.
aspect of representation 14.11.3 Pragma Controlled.
Controlled pragma 14.11.3 Pragma Controlled(3), see K. Language-Defined Pragmas (informative)(3), see L(7).
controlled type 8.6 User-Defined Assignment and Finalization(2), see 8.6 User-Defined Assignment and Finalization(9), see M. Glossary (informative)(2), see 8.6 User-Defined Assignment and Finalization(9), see N(10).
Controller 10.1 Task Units and Task Objects.
controlling formal parameter 4.9.2 Dispatching Operations of Tagged Types.
controlling operand 4.9.2 Dispatching Operations of Tagged Types(2)
controlling result 4.9.2 Dispatching Operations of Tagged Types.
controlling tag
for a call on a dispatching operation 4.9.2 Dispatching Operations of Tagged Types.
controlling tag value 4.9.2 Dispatching Operations of Tagged Types.
for the expression in an assignment_statement 6.2 Assignment Statements.
convention 7.3.1 Conformance Rules(2), see B.1 Interfacing Pragmas(2), see B.1(11).
aspect of representation B.1 Interfacing Pragmas.
Convention pragma B.1 Interfacing Pragmas(7), see K. Language-Defined Pragmas (informative)(7), see L(8).
conversion 5.6 Type Conversions(1), see 5.6 Type Conversions(1), see 4.6(28).
access 5.6 Type Conversions(13), see 5.6 Type Conversions(18), see 5.6 Type Conversions(13), see 5.6 Type Conversions(18), see 4.6(47).
arbitrary order 2.1.4 Method of Description and Syntax Notation.
array 5.6 Type Conversions(9), see 5.6 Type Conversions(9), see 4.6(36).
composite (non-array) 5.6 Type Conversions(21), see 5.6 Type Conversions(21), see 4.6(40).
enumeration 5.6 Type Conversions(21), see 5.6 Type Conversions(21), see 4.6(34).
numeric 5.6 Type Conversions(8), see 5.6 Type Conversions(8), see 4.6(29).
unchecked 14.9 Unchecked Type Conversions.
value 5.6 Type Conversions.
view 5.6 Type Conversions.
Conversion_Error B.4 Interfacing with COBOL.
convertible 5.6 Type Conversions.
required 4.7 Discriminants(16), see 4.7.1 Discriminant Constraints(9), see 5.6 Type Conversions(16), see 4.7.1 Discriminant Constraints(9), see 4.6(11),
5.6 Type Conversions(15), see 7.4.1 Parameter Associations(15), see 6.4.1(6).
Copy E.4.2 Example of Use of a Remote Access-to-Class-Wide Type(2), see E.4.2 Example of Use of a Remote Access-to-Class-Wide Type(2), see E.4.2(5).
copy back of parameters 7.4.1 Parameter Associations.
copy parameter passing 7.2 Formal Parameter Modes.
Copy_Array B.3.2 The Generic Package Interfaces.C.Pointers.
Copy_Sign attribute A.5.3 Attributes of Floating Point Types(51), see J. Language-Defined Attributes (informative)(51), see K(44).
Copy_Terminated_Array B.3.2 The Generic Package Interfaces.C.Pointers.
Copyright_Sign A.3.3 The Package Characters.Latin_1.
core language 2.1.2 Structure.
corresponding constraint 4.4 Derived Types and Classes.
corresponding discriminants 4.7 Discriminants.
corresponding index
for an array_aggregate 5.3.3 Array Aggregates.
corresponding subtype 4.4 Derived Types and Classes.
corresponding value
of the target type of a conversion 5.6 Type Conversions.
Cos A.5.1 Elementary Functions(5), see G.1.2 Complex Elementary Functions(5), see G.1.2(4).
Cosh A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(6).
Cot A.5.1 Elementary Functions(5), see G.1.2 Complex Elementary Functions(5), see G.1.2(4).
Coth A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(6).
Count A.4.3 Fixed-Length String Handling(13), see A.4.3 Fixed-Length String Handling(14), see A.4.3 Fixed-Length String Handling(13), see A.4.3 Fixed-Length String Handling(14), see A.4.3(15),
A.4.4 Bounded-Length String Handling(48), see A.4.4 Bounded-Length String Handling(49), see A.4.4 Bounded-Length String Handling(48), see A.4.4 Bounded-Length String Handling(49), see A.4.4(50),
A.4.5 Unbounded-Length String Handling(43), see A.4.5 Unbounded-Length String Handling(44), see A.4.5 Unbounded-Length String Handling(43), see A.4.5 Unbounded-Length String Handling(44), see A.4.5(45),
A.8.4 The Generic Package Direct_IO(4), A.10 Text Input-Output(10), A.10.1 The Package Text_IO(4), A.10 Text Input-Output(10), A.10.1(5),
A.12.1 The Package Streams.Stream_IO.
Count attribute 10.9 Task and Entry Attributes(5), see J. Language-Defined Attributes (informative)(5), see K(48).
Counter 4.4 Derived Types and Classes.
cover
a type 4.4.1 Derivation Classes.
of a choice and an exception 12.2 Exception Handlers.
cover a value
by a discrete_choice_list 4.8.1 Variant Parts and Discrete Choices.
by a discrete_choice 4.8.1 Variant Parts and Discrete Choices.
CPU_Identifier 8.4 Deferred Constants.
CR A.3.3 The Package Characters.Latin_1.
create 4.1 Declarations(12), A.8.1 The Generic Package Sequential_IO(6), see A.8.4 The Generic Package Direct_IO(12), A.8.1 The Generic Package Sequential_IO(6), see A.8.4(6),
A.10.1 The Package Text_IO(9), see A.12.1 The Package Streams.Stream_IO(9), see A.12.1(8).
creation
of a protected object C.3.1 Protected Procedure Handlers.
of a task object D.1 Task Priorities.
of an object 4.3 Objects and Named Numbers.
critical section
See intertask communication 10.5 Intertask Communication.
CSI A.3.3 The Package Characters.Latin_1.
Currency_Sign A.3.3 The Package Characters.Latin_1.
current column number A.10 Text Input-Output.
current index
of an open direct file A.8 Sequential and Direct Files.
current instance
of a generic unit 9.6 The Context of Overload Resolution.
of a type 9.6 The Context of Overload Resolution.
current line number A.10 Text Input-Output.
current mode
of an open file A.7 External Files and File Objects.
current page number A.10 Text Input-Output.
current size
of an external file A.8 Sequential and Direct Files.
Current_Error A.10.1 The Package Text_IO(17), see A.10.1 The Package Text_IO(17), see A.10.1(20).
Current_Handler C.3.2 The Package Interrupts.
Current_Input A.10.1 The Package Text_IO(17), see A.10.1 The Package Text_IO(17), see A.10.1(20).
Current_Output A.10.1 The Package Text_IO(17), see A.10.1 The Package Text_IO(17), see A.10.1(20).
Current_State D.10 Synchronous Task Control.
Current_Task C.7.1 The Package Task_Identification.
|
R. index
| | dangling references
prevention via accessibility rules 4.10.2 Operations of Access Types.
Data_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(18), A.9 The Generic Package Storage_IO(15), A.8.4 The Generic Package Direct_IO(18), A.9(9),
A.10.1 The Package Text_IO(85), see A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(85), see A.12.1 The Package Streams.Stream_IO(26), see A.13(4).
Date 4.8 Record Types.
Day 4.5.1 Enumeration Types(14), see 10.6 Delay Statements, Duration, and Time(14), see 9.6(13).
Day_Duration 10.6 Delay Statements, Duration, and Time.
Day_Number 10.6 Delay Statements, Duration, and Time.
DC1 A.3.3 The Package Characters.Latin_1.
DC2 A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
DC3 A.3.3 The Package Characters.Latin_1.
DC4 A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
DCS A.3.3 The Package Characters.Latin_1.
Deallocate 14.11 Storage Management.
deallocation of storage 14.11.2 Unchecked Storage Deallocation.
Decimal
child of Ada F.2 The Package Decimal.
decimal digit
a category of Character A.3.2 The Package Characters.Handling.
decimal fixed point type 4.5.9 Fixed Point Types(1), see 4.5.9 Fixed Point Types(1), see 3.5.9(6).
Decimal_Conversions B.4 Interfacing with COBOL.
Decimal_Digit_Set A.4.6 String-Handling Sets and Mappings.
Decimal_Element B.4 Interfacing with COBOL.
decimal_fixed_point_definition 4.5.9 Fixed Point Types.
used 4.5.9 Fixed Point Types(2), see N. Syntax Summary (informative)(2), see P(1).
decimal_literal 3.4.1 Decimal Literals.
used 3.4 Numeric Literals(2), see N. Syntax Summary (informative)(2), see P(1).
Decimal_Output F.3.3 The Package Text_IO.Editing.
Decimal_IO A.10.1 The Package Text_IO.
Declaration 4.1 Declarations(5), see 4.1 Declarations(6), see M. Glossary (informative)(5), see 4.1 Declarations(6), see N(11).
declarative region
of a construct 9.1 Declarative Region.
declarative_item 4.11 Declarative Parts.
used 4.11 Declarative Parts(2), see N. Syntax Summary (informative)(2), see P(1).
declarative_part 4.11 Declarative Parts.
used 6.6 Block Statements(2), see 7.3 Subprogram Bodies(2), 8.2 Package Bodies(2), see 7.3 Subprogram Bodies(2), 7.2(2),
10.1 Task Units and Task Objects(6), see 10.5.2 Entries and Accept Statements(5), see N. Syntax Summary (informative)(6), see 10.5.2 Entries and Accept Statements(5), see P(1).
declare 4.1 Declarations(8), see 4.1 Declarations(8), see 3.1(12).
declared pure 11.2.1 Elaboration Control.
Decrement B.3.2 The Generic Package Interfaces.C.Pointers.
deeper
accessibility level 4.10.2 Operations of Access Types.
statically 4.10.2 Operations of Access Types(4), see 4.10.2 Operations of Access Types(4), see 3.10.2(17).
default entry queuing policy 10.5.3 Entry Calls.
default treatment C.3 Interrupt Support.
Default_Bit_Order 14.7 The Package System.
Default_Currency F.3.3 The Package Text_IO.Editing.
default_expression 4.7 Discriminants.
used 4.7 Discriminants(5), 4.8 Record Types(6), see 7.1 Subprogram Declarations(5), 4.8 Record Types(6), see 6.1(15),
13.4 Formal Objects(2), see N. Syntax Summary (informative)(2), see P(1).
Default_Fill F.3.3 The Package Text_IO.Editing.
Default_Message_Procedure 4.10 Access Types.
default_name 13.6 Formal Subprograms.
used 13.6 Formal Subprograms(3), see N. Syntax Summary (informative)(3), see P(1).
Default_Priority 14.7 The Package System(17), see D.1 Task Priorities(17), see D.1(11).
Default_Radix_Mark F.3.3 The Package Text_IO.Editing.
Default_Separator F.3.3 The Package Text_IO.Editing.
deferred constant 8.4 Deferred Constants.
deferred constant declaration 4.3.1 Object Declarations(6), see 8.4 Deferred Constants(6), see 7.4(2).
defining name 4.1 Declarations.
defining_character_literal 4.5.1 Enumeration Types.
used 4.5.1 Enumeration Types(3), see N. Syntax Summary (informative)(3), see P(1).
defining_designator 7.1 Subprogram Declarations.
used 7.1 Subprogram Declarations(4), see 13.3 Generic Instantiation(2), see N. Syntax Summary (informative)(4), see 13.3 Generic Instantiation(2), see P(1).
defining_identifier 4.1 Declarations.
used 4.2.1 Type Declarations(3), 4.2.2 Subtype Declarations(2), 4.3.1 Object Declarations(3), 4.2.2 Subtype Declarations(2), 3.3.1(3),
4.5.1 Enumeration Types(3), 4.10.1 Incomplete Type Declarations(2), see 6.5 Loop Statements(3), 4.10.1 Incomplete Type Declarations(2), see 5.5(4),
7.1 Subprogram Declarations(7), 8.3 Private Types and Private Extensions(2), 8.3 Private Types and Private Extensions(7), 8.3 Private Types and Private Extensions(2), 7.3(3),
9.5.1 Object Renaming Declarations(2), 9.5.2 Exception Renaming Declarations(2), 10.1 Task Units and Task Objects(2), 9.5.2 Exception Renaming Declarations(2), 9.1(2),
10.1 Task Units and Task Objects(3), 10.1 Task Units and Task Objects(6), 10.4 Protected Units and Protected Objects(3), 10.1 Task Units and Task Objects(6), 9.4(2),
10.4 Protected Units and Protected Objects(3), 10.4 Protected Units and Protected Objects(7), 10.5.2 Entries and Accept Statements(3), 10.4 Protected Units and Protected Objects(7), 9.5.2(2),
10.5.2 Entries and Accept Statements(5), 10.5.2 Entries and Accept Statements(8), 11.1.3 Subunits of Compilation Units(5), 10.5.2 Entries and Accept Statements(8), 10.1.3(4),
11.1.3 Subunits of Compilation Units(5), see 11.1.3 Subunits of Compilation Units(6), see 12.2 Exception Handlers(5), see 11.1.3 Subunits of Compilation Units(6), see 11.2(4),
13.5 Formal Types(2), 13.7 Formal Packages(2), N. Syntax Summary (informative)(2), 13.7 Formal Packages(2), P(1).
defining_identifier_list 4.3.1 Object Declarations.
used 4.3.1 Object Declarations(2), see 4.3.2 Number Declarations(2), see 4.7 Discriminants(2), see 4.3.2 Number Declarations(2), see 3.7(5),
4.8 Record Types(6), 7.1 Subprogram Declarations(15), 12.1 Exception Declarations(6), 7.1 Subprogram Declarations(15), 11.1(2),
13.4 Formal Objects(2), N. Syntax Summary (informative)(2), P(1).
defining_operator_symbol 7.1 Subprogram Declarations.
used 7.1 Subprogram Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
defining_program_unit_name 7.1 Subprogram Declarations.
used 7.1 Subprogram Declarations(4), 7.1 Subprogram Declarations(6), 8.1 Package Specifications and Declarations(4), 7.1 Subprogram Declarations(6), 7.1(3),
8.2 Package Bodies(2), 9.5.3 Package Renaming Declarations(2), see 9.5.5 Generic Renaming Declarations(2), 9.5.3 Package Renaming Declarations(2), see 8.5.5(2),
13.3 Generic Instantiation(2), see N. Syntax Summary (informative)(2), see P(1).
Definite attribute 13.5.1 Formal Private and Derived Types(23), see J. Language-Defined Attributes (informative)(23), see K(50).
definite subtype 4.3 Objects and Named Numbers.
Definition 4.1 Declarations(7), see M. Glossary (informative)(7), see N(12).
Deg_To_Rad 5.9 Static Expressions and Static Subtypes.
Degree_Sign A.3.3 The Package Characters.Latin_1.
DEL A.3.3 The Package Characters.Latin_1(14), see I.5 ASCII(14), see J.5(4).
delay_alternative 10.7.1 Selective Accept.
used 10.7.1 Selective Accept(4), see 10.7.2 Timed Entry Calls(2), see N. Syntax Summary (informative)(4), see 10.7.2 Timed Entry Calls(2), see P(1).
delay_relative_statement 10.6 Delay Statements, Duration, and Time.
used 10.6 Delay Statements, Duration, and Time(2), see N. Syntax Summary (informative)(2), see P(1).
delay_statement 10.6 Delay Statements, Duration, and Time.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see 10.7.1 Selective Accept(6), see 10.7.4 Asynchronous Transfer of Control(4), see 10.7.1 Selective Accept(6), see 9.7.4(4),
N. Syntax Summary (informative).
delay_until_statement 10.6 Delay Statements, Duration, and Time.
used 10.6 Delay Statements, Duration, and Time(2), see N. Syntax Summary (informative)(2), see P(1).
Delete A.4.3 Fixed-Length String Handling(29), see A.4.3 Fixed-Length String Handling(30), see A.4.4 Bounded-Length String Handling(29), see A.4.3 Fixed-Length String Handling(30), see A.4.4(64),
A.4.4 Bounded-Length String Handling(65), see A.4.5 Unbounded-Length String Handling(59), see A.4.5 Unbounded-Length String Handling(65), see A.4.5 Unbounded-Length String Handling(59), see A.4.5(60),
A.8.1 The Generic Package Sequential_IO(8), A.8.4 The Generic Package Direct_IO(8), A.10.1 The Package Text_IO(8), A.8.4 The Generic Package Direct_IO(8), A.10.1(11),
A.12.1 The Package Streams.Stream_IO.
delimiter 3.2 Lexical Elements, Separators, and Delimiters.
delivery
of an interrupt C.3 Interrupt Support.
delta
of a fixed point type 4.5.9 Fixed Point Types.
Delta attribute 4.5.10 Operations of Fixed Point Types(3), see J. Language-Defined Attributes (informative)(3), see K(52).
delta_constraint I.3 Reduced Accuracy Subtypes.
used 4.2.2 Subtype Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
Denorm attribute A.5.3 Attributes of Floating Point Types(9), see J. Language-Defined Attributes (informative)(9), see K(54).
denormalized number A.5.3 Attributes of Floating Point Types.
denote 9.6 The Context of Overload Resolution.
informal definition 4.1 Declarations.
name used as a pragma argument 9.6 The Context of Overload Resolution.
depend on a discriminant
for a constraint or component_definition 4.7 Discriminants.
for a component 4.7 Discriminants.
dependence
elaboration 11.2 Program Execution.
of a task on a master 10.3 Task Dependence - Termination of Tasks.
of a task on another task 10.3 Task Dependence - Termination of Tasks.
semantic 11.1.1 Compilation Units - Library Units.
depth
accessibility level 4.10.2 Operations of Access Types.
dereference 5.1 Names.
Dereference_Error B.3.1 The Package Interfaces.C.Strings.
derivation class
for a type 4.4.1 Derivation Classes.
derived from
directly or indirectly 4.4.1 Derivation Classes.
derived type 4.4 Derived Types and Classes(1), see M. Glossary (informative)(1), see N(13).
[partial] 4.4 Derived Types and Classes.
derived_type_definition 4.4 Derived Types and Classes.
used 4.2.1 Type Declarations(4), see N. Syntax Summary (informative)(4), see P(1).
descendant 11.1.1 Compilation Units - Library Units.
of a type 4.4.1 Derivation Classes.
relationship with scope 9.2 Scope of Declarations.
Descriptor 14.6 Change of Representation.
designate 4.10 Access Types.
designated profile
of an access-to-subprogram type 4.10 Access Types.
designated subtype
of a named access type 4.10 Access Types.
of an anonymous access type 4.10 Access Types.
designated type
of a named access type 4.10 Access Types.
of an anonymous access type 4.10 Access Types.
designator 7.1 Subprogram Declarations.
used 7.3 Subprogram Bodies(2), see N. Syntax Summary (informative)(2), see P(1).
destructor
See finalization 8.6 User-Defined Assignment and Finalization(1), see 8.6.1 Completion and Finalization(1), see 7.6.1(1).
Detach_Handler C.3.2 The Package Interrupts.
determined class for a formal type 13.5 Formal Types.
determines
a type by a subtype_mark 4.2.2 Subtype Declarations.
Device 4.8.1 Variant Parts and Discrete Choices.
Device_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(15), A.8.4(18),
A.10.1 The Package Text_IO(85), see A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(85), see A.12.1 The Package Streams.Stream_IO(26), see A.13(4).
Device_Interface C.3.2 The Package Interrupts.
Device_Priority C.3.2 The Package Interrupts.
Diaeresis A.3.3 The Package Characters.Latin_1.
Dice A.5.2 Random Number Generation.
Dice_Game A.5.2 Random Number Generation.
Die A.5.2 Random Number Generation.
digit 3.1 Character Set.
used 3.1 Character Set(3), 3.3 Identifiers(3), see 3.4.1 Decimal Literals(3), 3.3 Identifiers(3), see 2.4.1(3),
3.4.2 Based Literals(5), see N. Syntax Summary (informative)(5), see P(1).
digits
of a decimal fixed point subtype 4.5.9 Fixed Point Types,
4.5.10 Operations of Fixed Point Types.
Digits attribute 4.5.8 Operations of Floating Point Types(2), see 4.5.10 Operations of Fixed Point Types(2), see 3.5.10(7),
J. Language-Defined Attributes (informative)(56), J. Language-Defined Attributes (informative)(56), K(58).
digits_constraint 4.5.9 Fixed Point Types.
used 4.2.2 Subtype Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
dimensionality
of an array 4.6 Array Types.
direct access A.8 Sequential and Direct Files.
direct file A.8 Sequential and Direct Files.
direct_name 5.1 Names.
used 4.8.1 Variant Parts and Discrete Choices(2), see 5.1 Names(2), 6.1 Simple and Compound Statements - Sequences of Statements(2), see 5.1 Names(2), 5.1(8),
10.5.2 Entries and Accept Statements(3), see 14.1 Representation Items(3), see I.7 At Clauses(3), see 14.1 Representation Items(3), see J.7(1),
N. Syntax Summary (informative).
Direct_IO I.1 Renamings of Ada 83 Library Units.
child of Ada A.8.4 The Generic Package Direct_IO(2), see A.9 The Generic Package Storage_IO(2), see A.9(3).
Direction A.4.1 The Package Strings.
directly specified
of an aspect of representation of an entity 14.1 Representation Items.
directly visible 9.3 Visibility(2), see 9.3 Visibility(2), see 8.3(21).
within a pragma in a context_clause 11.1.6 Environment-Level Visibility Rules.
within a pragma that appears at the place of a compilation unit
11.1.6 Environment-Level Visibility Rules.
within a use_clause in a context_clause 11.1.6 Environment-Level Visibility Rules.
within a with_clause 11.1.6 Environment-Level Visibility Rules.
within the parent_unit_name of a library unit 11.1.6 Environment-Level Visibility Rules.
within the parent_unit_name of a subunit 11.1.6 Environment-Level Visibility Rules.
Discard_Names pragma C.5 Pragma Discard_Names(3), see K. Language-Defined Pragmas (informative)(3), see L(9).
discontiguous representation
partial 14.5.2 Storage Place Attributes(5), see 14.7.1 The Package System.Storage_Elements(12), see 14.9 Unchecked Type Conversions(5), see 14.7.1 The Package System.Storage_Elements(12), see 13.9(9),
14.9 Unchecked Type Conversions(17), 14.11 Storage Management(17), 13.11(16).
discrete array type 5.5.2 Relational Operators and Membership Tests.
discrete type 4.2 Types and Subtypes(3), see 4.5 Scalar Types(1), see M. Glossary (informative)(3), see 4.5 Scalar Types(1), see N(14).
discrete_choice 4.8.1 Variant Parts and Discrete Choices.
used 4.8.1 Variant Parts and Discrete Choices(4), see N. Syntax Summary (informative)(4), see P(1).
discrete_choice_list 4.8.1 Variant Parts and Discrete Choices.
used 4.8.1 Variant Parts and Discrete Choices(3), see 5.3.3 Array Aggregates(5), see 6.4 Case Statements(3), see 5.3.3 Array Aggregates(5), see 5.4(3),
N. Syntax Summary (informative).
Discrete_Random
child of Ada.Numerics A.5.2 Random Number Generation.
discrete_range 4.6.1 Index Constraints and Discrete Ranges.
used 4.6.1 Index Constraints and Discrete Ranges(2), see 4.8.1 Variant Parts and Discrete Choices(5), see 5.1.2 Slices(2), see 4.8.1 Variant Parts and Discrete Choices(5), see 4.1.2(2),
N. Syntax Summary (informative).
discrete_subtype_definition 4.6 Array Types.
used 4.6 Array Types(5), 6.5 Loop Statements(4), see 10.5.2 Entries and Accept Statements(5), 6.5 Loop Statements(4), see 9.5.2(2),
10.5.2 Entries and Accept Statements(8), see N. Syntax Summary (informative)(8), see P(1).
discriminant 4.2 Types and Subtypes(5), see 4.7 Discriminants(1), see M. Glossary (informative)(5), see 4.7 Discriminants(1), see N(15).
of a variant_part 4.8.1 Variant Parts and Discrete Choices.
discriminant_association 4.7.1 Discriminant Constraints.
used 4.7.1 Discriminant Constraints(2), see N. Syntax Summary (informative)(2), see P(1).
Discriminant_Check 12.5 Suppressing Checks.
[partial] 5.1.3 Selected Components(15), see 5.3 Aggregates(6), 5.3.2 Extension Aggregates(15), see 5.3 Aggregates(6), 4.3.2(8),
5.6 Type Conversions(43), 5.6 Type Conversions(45), see 5.6 Type Conversions(43), 5.6 Type Conversions(45), see 4.6(51),
5.6 Type Conversions(52), 5.7 Qualified Expressions(4), 5.8 Allocators(52), 5.7 Qualified Expressions(4), 4.8(10).
discriminant_constraint 4.7.1 Discriminant Constraints.
used 4.2.2 Subtype Declarations(7), see N. Syntax Summary (informative)(7), see P(1).
discriminant_part 4.7 Discriminants.
used 4.10.1 Incomplete Type Declarations(2), see 8.3 Private Types and Private Extensions(2), see 8.3 Private Types and Private Extensions(2), see 8.3 Private Types and Private Extensions(2), see 7.3(3),
13.5 Formal Types(2), N. Syntax Summary (informative)(2), P(1).
discriminant_specification 4.7 Discriminants.
used 4.7 Discriminants(4), see N. Syntax Summary (informative)(4), see P(1).
discriminants
known 4.7 Discriminants.
unknown 4.7 Discriminants.
discriminated type 4.7 Discriminants.
Disk_Unit 4.8.1 Variant Parts and Discrete Choices.
dispatching 4.9 Tagged Types and Type Extensions.
dispatching call
on a dispatching operation 4.9.2 Dispatching Operations of Tagged Types.
dispatching operation 4.9.2 Dispatching Operations of Tagged Types(1), see 4.9.2 Dispatching Operations of Tagged Types(1), see 3.9.2(2).
[partial] 4.9 Tagged Types and Type Extensions.
dispatching point D.2.1 The Task Dispatching Model.
[partial] D.2.1 The Task Dispatching Model(8), see D.2.2 The Standard Task Dispatching Policy(8), see D.2.2(12).
dispatching policy for tasks
[partial] D.2.1 The Task Dispatching Model.
dispatching, task D.2.1 The Task Dispatching Model.
Display_Format B.4 Interfacing with COBOL.
displayed magnitude (of a decimal value) F.3.2 Edited Output Generation.
disruption of an assignment 10.8 Abort of a Task - Abort of a Sequence of Statements(21), see 14.9.1 Data Validity(21), see 13.9.1(5).
[partial] 12.6 Exceptions and Optimization.
distinct access paths 7.2 Formal Parameter Modes.
distributed program E. Distributed Systems (normative).
distributed system E. Distributed Systems (normative).
distributed systems C. Systems Programming (normative).
divide 3.1 Character Set(15), see F.2 The Package Decimal(15), see F.2(6).
divide operator 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
Dividend_Type F.2 The Package Decimal.
Division_Check 12.5 Suppressing Checks.
[partial] 4.5.4 Integer Types(20), see 5.5.5 Multiplying Operators(20), see 4.5.5(22),
A.5.1 Elementary Functions(28), see A.5.3 Attributes of Floating Point Types(28), see A.5.3(47),
G.1.1 Complex Types(40), see G.1.2 Complex Elementary Functions(40), see G.1.2(28),
J. Language-Defined Attributes (informative).
Division_Sign A.3.3 The Package Characters.Latin_1.
Divisor_Type F.2 The Package Decimal.
DLE A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
Do_APC E.5 Partition Communication Subsystem.
Do_RPC E.5 Partition Communication Subsystem.
documentation (required of an implementation) 2.1.3 Conformity of an Implementation with the Standard,
L. Implementation-Defined Characteristics (informative).
documentation requirements 2.1.2 Structure(34), see 2.1.3 Conformity of an Implementation with the Standard(34), see 1.1.3(18),
14.11 Storage Management(22), see A.5.2 Random Number Generation(22), see A.5.2(44),
A.13 Exceptions in Input-Output(15), C.1 Access to Machine Operations(15), C.1(6),
C.3 Interrupt Support(12), C.3.2 The Package Interrupts(12), C.3.2(24),
C.4 Preelaboration Requirements(12), C.7.1 The Package Task_Identification(12), C.7.1(19),
C.7.2 The Package Task_Attributes(18), see D.2.2 The Standard Task Dispatching Policy(18), see D.2.2(14),
D.6 Preemptive Abort(3), D.8 Monotonic Time(3), D.8(33),
D.9 Delay Accuracy(7), D.12 Other Optimizations and Determinism Rules(7), D.12(5),
E.5 Partition Communication Subsystem(25), H.1 Pragma Normalize_Scalars(25), H.1(5),
H.2 Documentation of Implementation Decisions(1), H.3.2 Pragma Inspection_Point(1), H.3.2(8),
H.4 Safety and Security Restrictions(25), I.7.1 Interrupt Entries(25), J.7.1(12).
Dollar_Sign A.3.3 The Package Characters.Latin_1.
Done I.7.1 Interrupt Entries.
dot 3.1 Character Set.
dot selection
See selected_component 5.1.3 Selected Components.
Dot_Product 7.1 Subprogram Declarations(39), see 7.3 Subprogram Bodies(39), see 6.3(11).
double B.3 Interfacing with C.
Double_Precision B.5 Interfacing with Fortran.
Double_Square 4.7 Discriminants.
downward closure 4.10.2 Operations of Access Types.
Dozen 5.6 Type Conversions.
drift rate D.8 Monotonic Time.
Drum_Ref 4.10 Access Types.
Drum_Unit 4.8.1 Variant Parts and Discrete Choices.
Duration A.1 The Package Standard.
dynamic binding
See dispatching operation 4.9 Tagged Types and Type Extensions.
dynamic semantics 2.1.2 Structure.
Dynamic_Priorities
child of Ada D.5 Dynamic Priorities.
dynamically determined tag 4.9.2 Dispatching Operations of Tagged Types.
dynamically enclosing
of one execution by another 12.4 Exception Handling.
dynamically tagged 4.9.2 Dispatching Operations of Tagged Types.
|
S. index
| | e A.5 The Numerics Packages.
edited output F.3 Edited Output for Decimal Types.
Editing
child of Ada.Text_IO F.3.3 The Package Text_IO.Editing.
child of Ada.Wide_Text_IO F.3.4 The Package Wide_Text_IO.Editing.
effect
external 2.1.3 Conformity of an Implementation with the Standard.
efficiency 12.5 Suppressing Checks(29), see 12.6 Exceptions and Optimization(29), see 11.6(1).
Elaborate pragma 11.2.1 Elaboration Control(20), see K. Language-Defined Pragmas (informative)(20), see L(10).
Elaborate_All pragma 11.2.1 Elaboration Control(21), see K. Language-Defined Pragmas (informative)(21), see L(11).
Elaborate_Body pragma 11.2.1 Elaboration Control(22), see K. Language-Defined Pragmas (informative)(22), see L(12).
elaborated 4.11 Declarative Parts.
elaboration 4.1 Declarations(11), see M. Glossary (informative)(11), see N(19).
abstract_subprogram_declaration 7.1 Subprogram Declarations.
access_definition 4.10 Access Types.
access_type_definition 4.10 Access Types.
array_type_definition 4.6 Array Types.
choice_parameter_specification 12.4 Exception Handling.
component_declaration 4.8 Record Types.
component_definition 4.6 Array Types(22), see 4.8 Record Types(22), see 3.8(18).
component_list 4.8 Record Types.
declaration named by a pragma Import B.1 Interfacing Pragmas.
declarative_part 4.11 Declarative Parts.
deferred constant declaration 8.4 Deferred Constants.
delta_constraint I.3 Reduced Accuracy Subtypes.
derived_type_definition 4.4 Derived Types and Classes.
digits_constraint 4.5.9 Fixed Point Types.
discrete_subtype_definition 4.6 Array Types.
discriminant_constraint 4.7.1 Discriminant Constraints.
entry_declaration 10.5.2 Entries and Accept Statements.
enumeration_type_definition 4.5.1 Enumeration Types.
exception_declaration 12.1 Exception Declarations.
fixed_point_definition 4.5.9 Fixed Point Types.
floating_point_definition 4.5.7 Floating Point Types.
full type definition 4.2.1 Type Declarations.
full_type_declaration 4.2.1 Type Declarations.
generic body 13.2 Generic Bodies.
generic_declaration 13.1 Generic Declarations.
generic_instantiation 13.3 Generic Instantiation.
incomplete_type_declaration 4.10.1 Incomplete Type Declarations.
index_constraint 4.6.1 Index Constraints and Discrete Ranges.
integer_type_definition 4.5.4 Integer Types.
loop_parameter_specification 6.5 Loop Statements.
non-generic subprogram_body 7.3 Subprogram Bodies.
nongeneric package_body 8.2 Package Bodies.
number_declaration 4.3.2 Number Declarations.
object_declaration 4.3.1 Object Declarations(15), see 8.6 User-Defined Assignment and Finalization(15), see 7.6(10).
package_body of Standard A.1 The Package Standard.
package_declaration 8.1 Package Specifications and Declarations.
partition E.1 Partitions(6), see E.5 Partition Communication Subsystem(6), see E.5(21).
pragma 3.8 Pragmas.
private_extension_declaration 8.3 Private Types and Private Extensions.
private_type_declaration 8.3 Private Types and Private Extensions.
protected declaration 10.4 Protected Units and Protected Objects.
protected_body 10.4 Protected Units and Protected Objects.
protected_definition 10.4 Protected Units and Protected Objects.
range_constraint 4.5 Scalar Types.
real_type_definition 4.5.6 Real Types.
record_definition 4.8 Record Types.
record_extension_part 4.9.1 Type Extensions.
record_type_definition 4.8 Record Types.
renaming_declaration 9.5 Renaming Declarations.
representation_clause 14.1 Representation Items.
single_protected_declaration 10.4 Protected Units and Protected Objects.
single_task_declaration 10.1 Task Units and Task Objects.
Storage_Size pragma 14.3 Representation Attributes.
subprogram_declaration 7.1 Subprogram Declarations.
subtype_declaration 4.2.2 Subtype Declarations.
subtype_indication 4.2.2 Subtype Declarations.
task declaration 10.1 Task Units and Task Objects.
task_body 10.1 Task Units and Task Objects.
task_definition 10.1 Task Units and Task Objects.
use_clause 9.4 Use Clauses.
variant_part 4.8.1 Variant Parts and Discrete Choices.
elaboration control 11.2.1 Elaboration Control.
elaboration dependence
library_item on another 11.2 Program Execution.
Elaboration_Check 12.5 Suppressing Checks.
[partial] 4.11 Declarative Parts.
Elem 13.1 Generic Declarations.
element A.4.4 Bounded-Length String Handling(26), see A.4.5 Unbounded-Length String Handling(20), see B.3.2 The Generic Package Interfaces.C.Pointers(26), see A.4.5 Unbounded-Length String Handling(20), see B.3.2(4).
of a storage pool 14.11 Storage Management.
Element_Array B.3.2 The Generic Package Interfaces.C.Pointers.
Element_Type 4.9.3 Abstract Types and Subprograms(15), see A.8.1 The Generic Package Sequential_IO(2), see A.8.4 The Generic Package Direct_IO(15), see A.8.1 The Generic Package Sequential_IO(2), see A.8.4(2),
A.9 The Generic Package Storage_IO.
elementary type 4.2 Types and Subtypes(2), see M. Glossary (informative)(2), see N(16).
Elementary_Functions
child of Ada.Numerics A.5.1 Elementary Functions.
eligible
a type, for a convention B.1 Interfacing Pragmas.
else part
of a selective_accept 10.7.1 Selective Accept.
EM A.3.3 The Package Characters.Latin_1.
embedded systems C. Systems Programming (normative)(1), see D. Real-Time Systems (normative)(1), see D(1).
Empty 4.9.3 Abstract Types and Subprograms.
encapsulation
See package 8. Packages.
enclosing
immediately 9.1 Declarative Region.
end of a line 3.2 Lexical Elements, Separators, and Delimiters.
End_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1 The Package Text_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1(85),
A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(26), see A.13(4).
End_Of_File 12.4.2 Example of Exception Handling(4), A.8.1 The Generic Package Sequential_IO(13), see A.8.4 The Generic Package Direct_IO(4), A.8.1 The Generic Package Sequential_IO(13), see A.8.4(16),
A.10.1 The Package Text_IO(34), see A.12.1 The Package Streams.Stream_IO(34), see A.12.1(12).
End_Of_Line A.10.1 The Package Text_IO.
End_Of_Page A.10.1 The Package Text_IO.
endian
big 14.5.3 Bit Ordering.
little 14.5.3 Bit Ordering.
ENQ A.3.3 The Package Characters.Latin_1.
entity
[partial] 4.1 Declarations.
entry
closed 10.5.3 Entry Calls.
open 10.5.3 Entry Calls.
single 10.5.2 Entries and Accept Statements.
entry call 10.5.3 Entry Calls.
simple 10.5.3 Entry Calls.
entry calling convention 7.3.1 Conformance Rules.
entry family 10.5.2 Entries and Accept Statements.
entry index subtype 4.8 Record Types(18), see 10.5.2 Entries and Accept Statements(18), see 9.5.2(20).
entry queue 10.5.3 Entry Calls.
entry queuing policy 10.5.3 Entry Calls.
default policy 10.5.3 Entry Calls.
entry_barrier 10.5.2 Entries and Accept Statements.
used 10.5.2 Entries and Accept Statements(5), see N. Syntax Summary (informative)(5), see P(1).
entry_body 10.5.2 Entries and Accept Statements.
used 10.4 Protected Units and Protected Objects(8), see N. Syntax Summary (informative)(8), see P(1).
entry_body_formal_part 10.5.2 Entries and Accept Statements.
used 10.5.2 Entries and Accept Statements(5), see N. Syntax Summary (informative)(5), see P(1).
entry_call_alternative 10.7.2 Timed Entry Calls.
used 10.7.2 Timed Entry Calls(2), see 10.7.3 Conditional Entry Calls(2), see N. Syntax Summary (informative)(2), see 10.7.3 Conditional Entry Calls(2), see P(1).
entry_call_statement 10.5.3 Entry Calls.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see 10.7.2 Timed Entry Calls(3), see 10.7.4 Asynchronous Transfer of Control(4), see 10.7.2 Timed Entry Calls(3), see 9.7.4(4),
N. Syntax Summary (informative).
entry_declaration 10.5.2 Entries and Accept Statements.
used 10.1 Task Units and Task Objects(5), see 10.4 Protected Units and Protected Objects(5), see N. Syntax Summary (informative)(5), see 10.4 Protected Units and Protected Objects(5), see P(1).
entry_index 10.5.2 Entries and Accept Statements.
used 10.5.2 Entries and Accept Statements(3), see N. Syntax Summary (informative)(3), see P(1).
entry_index_specification 10.5.2 Entries and Accept Statements.
used 10.5.2 Entries and Accept Statements(6), see N. Syntax Summary (informative)(6), see P(1).
Enum 13.5 Formal Types(13), see A.10.1 The Package Text_IO(13), see A.10.1(79).
Enum_IO 9.5.5 Generic Renaming Declarations.
enumeration literal 4.5.1 Enumeration Types.
enumeration type 4.2 Types and Subtypes(3), see 4.5.1 Enumeration Types(1), see M. Glossary (informative)(3), see 4.5.1 Enumeration Types(1), see N(17).
enumeration_aggregate 14.4 Enumeration Representation Clauses.
used 14.4 Enumeration Representation Clauses(2), see N. Syntax Summary (informative)(2), see P(1).
enumeration_literal_specification 4.5.1 Enumeration Types.
used 4.5.1 Enumeration Types(2), see N. Syntax Summary (informative)(2), see P(1).
enumeration_representation_clause 14.4 Enumeration Representation Clauses.
used 14.1 Representation Items(2), see N. Syntax Summary (informative)(2), see P(1).
enumeration_type_definition 4.5.1 Enumeration Types.
used 4.2.1 Type Declarations(4), see N. Syntax Summary (informative)(4), see P(1).
Enumeration_IO A.10.1 The Package Text_IO.
environment declarative_part 11.1.4 The Compilation Process.
for the environment task of a partition 11.2 Program Execution.
environment 11.1.4 The Compilation Process.
environment task 11.2 Program Execution.
EOF 9.5.2 Exception Renaming Declarations.
EOT A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
EPA A.3.3 The Package Characters.Latin_1.
epoch D.8 Monotonic Time.
equal operator 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
equality operator 5.5.2 Relational Operators and Membership Tests.
special inheritance rule for tagged types 4.4 Derived Types and Classes,
5.5.2 Relational Operators and Membership Tests.
equals sign 3.1 Character Set.
Equals_Sign A.3.3 The Package Characters.Latin_1.
erroneous execution 2.1.2 Structure(32), 2.1.5 Classification of Errors(32), 1.1.5(10),
4.7.2 Operations of Discriminated Types(4), 10.8 Abort of a Task - Abort of a Sequence of Statements(4), 9.8(21),
10.10 Shared Variables(11), 12.5 Suppressing Checks(11), 11.5(26),
14.3 Representation Attributes(13), 14.3 Representation Attributes(13), 13.3(27),
14.9.1 Data Validity(8), 14.9.1 Data Validity(8), 13.9.1(12),
14.11 Storage Management(21), 14.11.2 Unchecked Storage Deallocation(21), 13.11.2(16),
A.10.3 Default Input, Output, and Error Files(22), see A.13 Exceptions in Input-Output(22), see A.13(17),
B.3.1 The Package Interfaces.C.Strings(51), B.3.2 The Generic Package Interfaces.C.Pointers(51), B.3.2(35),
C.3.1 Protected Procedure Handlers(14), C.7.1 The Package Task_Identification(14), C.7.1(18),
C.7.2 The Package Task_Attributes(14), D.5 Dynamic Priorities(14), D.5(12),
D.11 Asynchronous Task Control(9), H.4 Safety and Security Restrictions(9), H.4(26).
error 12.1 Exception Declarations.
compile-time 2.1.2 Structure(27), see 2.1.5 Classification of Errors(27), see 1.1.5(4).
link-time 2.1.2 Structure(29), see 2.1.5 Classification of Errors(29), see 1.1.5(4).
run-time 2.1.2 Structure(30), see 2.1.5 Classification of Errors(6), see 12.5 Suppressing Checks(30), see 2.1.5 Classification of Errors(6), see 11.5(2),
12.6 Exceptions and Optimization.
See also bounded error, erroneous execution
ESA A.3.3 The Package Characters.Latin_1.
ESC A.3.3 The Package Characters.Latin_1.
Establish_RPC_Receiver E.5 Partition Communication Subsystem.
ETB A.3.3 The Package Characters.Latin_1.
ETX A.3.3 The Package Characters.Latin_1.
evaluation 4.1 Declarations(11), see M. Glossary (informative)(11), see N(19).
aggregate 5.3 Aggregates.
allocator 5.8 Allocators.
array_aggregate 5.3.3 Array Aggregates.
attribute_reference 5.1.4 Attributes.
concatenation 5.5.3 Binary Adding Operators.
dereference 5.1 Names.
discrete_range 4.6.1 Index Constraints and Discrete Ranges.
extension_aggregate 5.3.2 Extension Aggregates.
generic_association 13.3 Generic Instantiation.
generic_association for a formal object of mode in
13.4 Formal Objects.
indexed_component 5.1.1 Indexed Components.
initialized allocator 5.8 Allocators.
membership test 5.5.2 Relational Operators and Membership Tests.
name 5.1 Names.
name that has a prefix 5.1 Names.
null literal 5.2 Literals.
numeric literal 5.2 Literals.
parameter_association 7.4.1 Parameter Associations.
prefix 5.1 Names.
primary that is a name 5.4 Expressions.
qualified_expression 5.7 Qualified Expressions.
range 4.5 Scalar Types.
range_attribute_reference 5.1.4 Attributes.
record_aggregate 5.3.1 Record Aggregates.
record_component_association_list 5.3.1 Record Aggregates.
selected_component 5.1.3 Selected Components.
short-circuit control form 5.5.1 Logical Operators and Short-circuit Control Forms.
slice 5.1.2 Slices.
string_literal 5.2 Literals.
uninitialized allocator 5.8 Allocators.
Val 4.5.5 Operations of Discrete Types(7), see J. Language-Defined Attributes (informative)(7), see K(261).
Value 4.5 Scalar Types.
value conversion 5.6 Type Conversions.
view conversion 5.6 Type Conversions.
Wide_Value 4.5 Scalar Types.
Exception 12. Exceptions(1), see 12.1 Exception Declarations(1), see M. Glossary (informative)(1), see 12.1 Exception Declarations(1), see N(18).
exception occurrence 12. Exceptions.
exception_choice 12.2 Exception Handlers.
used 12.2 Exception Handlers(3), see N. Syntax Summary (informative)(3), see P(1).
exception_declaration 12.1 Exception Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
exception_handler 12.2 Exception Handlers.
used 12.2 Exception Handlers(2), see N. Syntax Summary (informative)(2), see P(1).
Exception_Identity 12.4.1 The Package Exceptions.
Exception_Information 12.4.1 The Package Exceptions.
Exception_Message 12.4.1 The Package Exceptions.
Exception_Name 12.4.1 The Package Exceptions(2), see 12.4.1 The Package Exceptions(2), see 11.4.1(5).
Exception_Occurrence 12.4.1 The Package Exceptions.
Exception_Occurrence_Access 12.4.1 The Package Exceptions.
exception_renaming_declaration 9.5.2 Exception Renaming Declarations.
used 9.5 Renaming Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
Exception_Id 12.4.1 The Package Exceptions.
Exceptions
child of Ada 12.4.1 The Package Exceptions.
Exchange 13.1 Generic Declarations(21), see 13.2 Generic Bodies(21), see 12.2(5).
Exchange_Handler C.3.2 The Package Interrupts.
Exclam I.5 ASCII.
Exclamation A.3.3 The Package Characters.Latin_1.
execution 4.1 Declarations(11), see M. Glossary (informative)(11), see N(19).
abort_statement 10.8 Abort of a Task - Abort of a Sequence of Statements.
aborting the execution of a construct 10.8 Abort of a Task - Abort of a Sequence of Statements.
accept_statement 10.5.2 Entries and Accept Statements.
Ada program 10. Tasks and Synchronization.
assignment_statement 6.2 Assignment Statements(7), see 8.6 User-Defined Assignment and Finalization(7), see 7.6(17),
8.6.1 Completion and Finalization.
asynchronous_select with a delay_statement trigger
10.7.4 Asynchronous Transfer of Control.
asynchronous_select with an entry call trigger 10.7.4 Asynchronous Transfer of Control.
block_statement 6.6 Block Statements.
call on a dispatching operation 4.9.2 Dispatching Operations of Tagged Types.
call on an inherited subprogram 4.4 Derived Types and Classes.
case_statement 6.4 Case Statements.
conditional_entry_call 10.7.3 Conditional Entry Calls.
delay_statement 10.6 Delay Statements, Duration, and Time.
dynamically enclosing 12.4 Exception Handling.
entry_body 10.5.2 Entries and Accept Statements.
entry_call_statement 10.5.3 Entry Calls.
exit_statement 6.7 Exit Statements.
goto_statement 6.8 Goto Statements.
handled_sequence_of_statements 12.2 Exception Handlers.
handler 12.4 Exception Handling.
if_statement 6.3 If Statements.
instance of Unchecked_Deallocation 8.6.1 Completion and Finalization.
loop_statement 6.5 Loop Statements.
loop_statement with a for iteration_scheme 6.5 Loop Statements.
loop_statement with a while iteration_scheme 6.5 Loop Statements.
null_statement 6.1 Simple and Compound Statements - Sequences of Statements.
partition 11.2 Program Execution.
pragma 3.8 Pragmas.
program 11.2 Program Execution.
protected subprogram call 10.5.1 Protected Subprograms and Protected Actions.
raise_statement with an exception_name 12.3 Raise Statements.
re-raise statement 12.3 Raise Statements.
remote subprogram call E.4 Remote Subprogram Calls.
requeue protected entry 10.5.4 Requeue Statements.
requeue task entry 10.5.4 Requeue Statements.
requeue_statement 10.5.4 Requeue Statements.
return_statement 7.5 Return Statements.
selective_accept 10.7.1 Selective Accept.
sequence_of_statements 6.1 Simple and Compound Statements - Sequences of Statements.
subprogram call 7.4 Subprogram Calls.
subprogram_body 7.3 Subprogram Bodies.
task 10.2 Task Execution - Task Activation.
task_body 10.2 Task Execution - Task Activation.
timed_entry_call 10.7.2 Timed Entry Calls.
execution resource
associated with a protected object 10.4 Protected Units and Protected Objects.
required for a task to run 10. Tasks and Synchronization.
exit_statement 6.7 Exit Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
Exp A.5.1 Elementary Functions(4), see B.1 Interfacing Pragmas(51), see G.1.2 Complex Elementary Functions(4), see B.1 Interfacing Pragmas(51), see G.1.2(3).
expanded name 5.1.3 Selected Components.
Expanded_Name 4.9 Tagged Types and Type Extensions.
expected profile 9.6 The Context of Overload Resolution.
accept_statement entry_direct_name 10.5.2 Entries and Accept Statements.
Access attribute_reference prefix 4.10.2 Operations of Access Types.
attribute_definition_clause name 14.3 Representation Attributes.
character_literal 5.2 Literals.
formal subprogram actual 13.6 Formal Subprograms.
formal subprogram default_name 13.6 Formal Subprograms.
subprogram_renaming_declaration 9.5.4 Subprogram Renaming Declarations.
expected type 9.6 The Context of Overload Resolution.
abort_statement task_name 10.8 Abort of a Task - Abort of a Sequence of Statements.
access attribute_reference 4.10.2 Operations of Access Types.
actual parameter 7.4.1 Parameter Associations.
aggregate 5.3 Aggregates.
allocator 5.8 Allocators.
array_aggregate 5.3.3 Array Aggregates.
array_aggregate component expression 5.3.3 Array Aggregates.
array_aggregate discrete_choice 5.3.3 Array Aggregates.
assignment_statement expression 6.2 Assignment Statements.
assignment_statement variable_name 6.2 Assignment Statements.
attribute_definition_clause expression or name 14.3 Representation Attributes.
attribute_designator expression 5.1.4 Attributes.
case expression 6.4 Case Statements.
case_statement_alternative discrete_choice 6.4 Case Statements.
character_literal 5.2 Literals.
code_statement 14.8 Machine Code Insertions.
component_clause expressions 14.5.1 Record Representation Clauses.
component_declaration default_expression 4.8 Record Types.
condition 6.3 If Statements.
decimal fixed point type digits 4.5.9 Fixed Point Types.
delay_relative_statement expression 10.6 Delay Statements, Duration, and Time.
delay_until_statement expression 10.6 Delay Statements, Duration, and Time.
delta_constraint expression I.3 Reduced Accuracy Subtypes.
dereference name 5.1 Names.
discrete_subtype_definition range 4.6 Array Types.
discriminant default_expression 4.7 Discriminants.
discriminant_association expression 4.7.1 Discriminant Constraints.
entry_index 10.5.2 Entries and Accept Statements.
enumeration_representation_clause expressions 14.4 Enumeration Representation Clauses.
extension_aggregate 5.3.2 Extension Aggregates.
extension_aggregate ancestor expression 5.3.2 Extension Aggregates.
first_bit 14.5.1 Record Representation Clauses.
fixed point type delta 4.5.9 Fixed Point Types.
generic formal in object actual 13.4 Formal Objects.
generic formal object default_expression 13.4 Formal Objects.
index_constraint discrete_range 4.6.1 Index Constraints and Discrete Ranges.
indexed_component expression 5.1.1 Indexed Components.
Interrupt_Priority pragma argument D.1 Task Priorities.
last_bit 14.5.1 Record Representation Clauses.
link name B.1 Interfacing Pragmas.
membership test simple_expression 5.5.2 Relational Operators and Membership Tests.
modular_type_definition expression 4.5.4 Integer Types.
null literal 5.2 Literals.
number_declaration expression 4.3.2 Number Declarations.
object_declaration initialization expression 4.3.1 Object Declarations.
parameter default_expression 7.1 Subprogram Declarations.
position 14.5.1 Record Representation Clauses.
Priority pragma argument D.1 Task Priorities.
range simple_expressions 4.5 Scalar Types.
range_attribute_designator expression 5.1.4 Attributes.
range_constraint range 4.5 Scalar Types.
real_range_specification bounds 4.5.7 Floating Point Types.
record_aggregate 5.3.1 Record Aggregates.
record_component_association expression 5.3.1 Record Aggregates.
requested decimal precision 4.5.7 Floating Point Types.
restriction parameter expression 14.12 Pragma Restrictions.
return expression 7.5 Return Statements.
short-circuit control form relation 5.5.1 Logical Operators and Short-circuit Control Forms.
signed_integer_type_definition simple_expression
4.5.4 Integer Types.
slice discrete_range 5.1.2 Slices.
Storage_Size pragma argument 14.3 Representation Attributes.
string_literal 5.2 Literals.
type_conversion operand 5.6 Type Conversions(6)
variant_part discrete_choice 4.8.1 Variant Parts and Discrete Choices.
expiration time
[partial] 10.6 Delay Statements, Duration, and Time.
for a delay_relative_statement 10.6 Delay Statements, Duration, and Time.
for a delay_until_statement 10.6 Delay Statements, Duration, and Time.
explicit declaration 4.1 Declarations(5), see M. Glossary (informative)(5), see N(11).
explicit initial value 4.3.1 Object Declarations.
explicit_actual_parameter 7.4 Subprogram Calls.
used 7.4 Subprogram Calls(5), see N. Syntax Summary (informative)(5), see P(1).
explicit_dereference 5.1 Names.
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
explicit_generic_actual_parameter 13.3 Generic Instantiation.
used 13.3 Generic Instantiation(4), see N. Syntax Summary (informative)(4), see P(1).
explicitly assign 11.2 Program Execution.
exponent 3.4.1 Decimal Literals(4), see 5.5.6 Highest Precedence Operators(4), see 4.5.6(11).
used 3.4.1 Decimal Literals(2), see 3.4.2 Based Literals(2), see N. Syntax Summary (informative)(2), see 3.4.2 Based Literals(2), see P(1).
Exponent attribute A.5.3 Attributes of Floating Point Types(18), see J. Language-Defined Attributes (informative)(18), see K(60).
exponentiation operator 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(7).
Export pragma B.1 Interfacing Pragmas(6), see K. Language-Defined Pragmas (informative)(6), see L(13).
exported
aspect of representation B.1 Interfacing Pragmas.
exported entity B.1 Interfacing Pragmas.
Expr_Ptr 4.9.1 Type Extensions.
expression 4.9 Tagged Types and Type Extensions(33), see 5.4 Expressions(1), see 5.4 Expressions(33), see 5.4 Expressions(1), see 4.4(2).
used 3.8 Pragmas(3), 4.3.1 Object Declarations(2), see 4.3.2 Number Declarations(3), 4.3.1 Object Declarations(2), see 3.3.2(2),
4.5.4 Integer Types(4), see 4.5.7 Floating Point Types(2), see 4.5.9 Fixed Point Types(4), see 4.5.7 Floating Point Types(2), see 3.5.9(3),
4.5.9 Fixed Point Types(4), see 4.5.9 Fixed Point Types(5), see 4.7 Discriminants(4), see 4.5.9 Fixed Point Types(5), see 3.7(6),
4.7.1 Discriminant Constraints(3), see 4.8.1 Variant Parts and Discrete Choices(5), see 5.1.1 Indexed Components(3), see 4.8.1 Variant Parts and Discrete Choices(5), see 4.1.1(2),
5.1.4 Attributes(3), see 5.1.4 Attributes(5), see 5.3.1 Record Aggregates(3), see 5.1.4 Attributes(5), see 4.3.1(4),
5.3.2 Extension Aggregates(3), see 5.3.3 Array Aggregates(3), see 5.3.3 Array Aggregates(3), see 5.3.3 Array Aggregates(3), see 4.3.3(5),
5.4 Expressions(7), 5.6 Type Conversions(2), 5.7 Qualified Expressions(7), 5.6 Type Conversions(2), 4.7(2),
6.2 Assignment Statements(2), 6.3 If Statements(3), 6.4 Case Statements(2), 6.3 If Statements(3), 5.4(2),
7.4 Subprogram Calls(6), 7.5 Return Statements(2), 10.5.2 Entries and Accept Statements(6), 7.5 Return Statements(2), 9.5.2(4),
10.6 Delay Statements, Duration, and Time(3), 10.6 Delay Statements, Duration, and Time(4), 13.3 Generic Instantiation(3), 10.6 Delay Statements, Duration, and Time(4), 12.3(5),
14.3 Representation Attributes(2), 14.3 Representation Attributes(63), see 14.5.1 Record Representation Clauses(2), 14.3 Representation Attributes(63), see 13.5.1(4),
14.12 Pragma Restrictions(4), see B.1 Interfacing Pragmas(5), B.1 Interfacing Pragmas(4), see B.1 Interfacing Pragmas(5), B.1(6),
B.1 Interfacing Pragmas(8), B.1 Interfacing Pragmas(10), C.3.1 Protected Procedure Handlers(8), B.1 Interfacing Pragmas(10), C.3.1(4),
D.1 Task Priorities(3), D.1 Task Priorities(5), I.3 Reduced Accuracy Subtypes(3), D.1 Task Priorities(5), J.3(2),
I.7 At Clauses(1), I.8 Mod Clauses(1), K. Language-Defined Pragmas (informative)(1), I.8 Mod Clauses(1), L(6),
K. Language-Defined Pragmas (informative)(13), K. Language-Defined Pragmas (informative)(14), K. Language-Defined Pragmas (informative)(13), K. Language-Defined Pragmas (informative)(14), L(18),
K. Language-Defined Pragmas (informative)(19), K. Language-Defined Pragmas (informative)(27), K. Language-Defined Pragmas (informative)(19), K. Language-Defined Pragmas (informative)(27), L(35),
N. Syntax Summary (informative).
extended_digit 3.4.2 Based Literals.
used 3.4.2 Based Literals(4), see N. Syntax Summary (informative)(4), see P(1).
extension
of a private type 4.9 Tagged Types and Type Extensions(2), see 4.9.1 Type Extensions(2), see 3.9.1(1).
of a record type 4.9 Tagged Types and Type Extensions(2), see 4.9.1 Type Extensions(2), see 3.9.1(1).
of a type 4.9 Tagged Types and Type Extensions(2), see 4.9.1 Type Extensions(2), see 3.9.1(1).
extension_aggregate 5.3.2 Extension Aggregates.
used 5.3 Aggregates(2), see N. Syntax Summary (informative)(2), see P(1).
external call 10.5 Intertask Communication.
external effect
of the execution of an Ada program 2.1.3 Conformity of an Implementation with the Standard.
volatile/atomic objects C.6 Shared Variable Control.
external file A.7 External Files and File Objects.
external interaction 2.1.3 Conformity of an Implementation with the Standard.
external name B.1 Interfacing Pragmas.
external requeue 10.5 Intertask Communication.
External_Tag 4.9 Tagged Types and Type Extensions.
External_Tag attribute 14.3 Representation Attributes(75), see J. Language-Defined Attributes (informative)(75), see K(64).
External_Tag clause 14.3 Representation Attributes(7), see 14.3 Representation Attributes(75), see J. Language-Defined Attributes (informative)(7), see 14.3 Representation Attributes(75), see K(65).
extra permission to avoid raising exceptions 12.6 Exceptions and Optimization.
extra permission to reorder actions 12.6 Exceptions and Optimization.
|
T. index
| | factor 5.4 Expressions.
used 5.4 Expressions(5), see N. Syntax Summary (informative)(5), see P(1).
failure A.15 The Package Command_Line.
of a language-defined check 12.5 Suppressing Checks.
False 4.5.3 Boolean Types.
family
entry 10.5.2 Entries and Accept Statements.
Feminine_Ordinal_Indicator A.3.3 The Package Characters.Latin_1.
FF A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
Field A.10.1 The Package Text_IO.
file
as file object A.7 External Files and File Objects.
file terminator A.10 Text Input-Output.
File_Access A.10.1 The Package Text_IO.
File_Descriptor 8.5 Limited Types.
File_Handle 12.4.2 Example of Exception Handling.
File_Mode A.8.1 The Generic Package Sequential_IO(4), see A.8.4 The Generic Package Direct_IO(4), see A.10.1 The Package Text_IO(4), see A.8.4 The Generic Package Direct_IO(4), see A.10.1(4),
A.12.1 The Package Streams.Stream_IO.
File_Name 8.3 Private Types and Private Extensions(22), see 8.5 Limited Types(18), see 8.5 Limited Types(22), see 8.5 Limited Types(18), see 7.5(19).
File_Not_Found 12.4.2 Example of Exception Handling.
File_System 12.4.2 Example of Exception Handling(2), see 12.4.2 Example of Exception Handling(2), see 11.4.2(6).
File_Type A.8.1 The Generic Package Sequential_IO(3), see A.8.4 The Generic Package Direct_IO(3), see A.10.1 The Package Text_IO(3), see A.8.4 The Generic Package Direct_IO(3), see A.10.1(3),
A.12.1 The Package Streams.Stream_IO.
Finalization
child of Ada 8.6 User-Defined Assignment and Finalization.
of a master 8.6.1 Completion and Finalization.
of a protected object 10.4 Protected Units and Protected Objects(20), see C.3.1 Protected Procedure Handlers(20), see C.3.1(12).
of a task object I.7.1 Interrupt Entries.
of an object 8.6.1 Completion and Finalization.
Finalize 8.6 User-Defined Assignment and Finalization(2), see 8.6 User-Defined Assignment and Finalization(6), see 8.6 User-Defined Assignment and Finalization(2), see 8.6 User-Defined Assignment and Finalization(6), see 7.6(8).
Find E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
Find_Token A.4.3 Fixed-Length String Handling(16), see A.4.4 Bounded-Length String Handling(51), see A.4.5 Unbounded-Length String Handling(16), see A.4.4 Bounded-Length String Handling(51), see A.4.5(46).
Fine_Delta 14.7 The Package System.
named number in package System 14.7 The Package System.
First attribute 4.5 Scalar Types(12), see 4.6.2 Operations of Array Types(3), see J. Language-Defined Attributes (informative)(12), see 4.6.2 Operations of Array Types(3), see K(68),
J. Language-Defined Attributes (informative).
first subtype 4.2.1 Type Declarations(6), see 4.4.1 Derivation Classes(6), see 3.4.1(5).
First(N) attribute 4.6.2 Operations of Array Types(4), see J. Language-Defined Attributes (informative)(4), see K(66).
first_bit 14.5.1 Record Representation Clauses.
used 14.5.1 Record Representation Clauses(3), see N. Syntax Summary (informative)(3), see P(1).
First_Bit attribute 14.5.2 Storage Place Attributes(3), see J. Language-Defined Attributes (informative)(3), see K(72).
Fixed
child of Ada.Strings A.4.3 Fixed-Length String Handling.
fixed point type 4.5.9 Fixed Point Types.
fixed_point_definition 4.5.9 Fixed Point Types.
used 4.5.6 Real Types, P(1)
Fixed_IO A.10.1 The Package Text_IO.
Flip_A_Coin A.5.2 Random Number Generation(58)
Float 4.5.7 Floating Point Types(12), see 4.5.7 Floating Point Types(14), see A.1 The Package Standard(12), see 4.5.7 Floating Point Types(14), see A.1(21).
Float_Random
child of Ada.Numerics A.5.2 Random Number Generation.
Float_Text_IO
child of Ada A.10.9 Input-Output for Real Types.
Float_Type A.5.1 Elementary Functions.
Float_Wide_Text_IO
child of Ada A.11 Wide Text Input-Output.
Float_IO A.10.1 The Package Text_IO.
Floating B.4 Interfacing with COBOL.
floating point type 4.5.7 Floating Point Types.
floating_point_definition 4.5.7 Floating Point Types.
used 4.5.6 Real Types(2), see N. Syntax Summary (informative)(2), see P(1).
Floor attribute A.5.3 Attributes of Floating Point Types(30), see J. Language-Defined Attributes (informative)(30), see K(74).
Flush A.10.1 The Package Text_IO(21), see A.12.1 The Package Streams.Stream_IO(21), see A.12.1(25).
Fore attribute 4.5.10 Operations of Fixed Point Types(4), see J. Language-Defined Attributes (informative)(4), see K(78).
form A.8.1 The Generic Package Sequential_IO(9), see A.8.4 The Generic Package Direct_IO(9), see A.10.1 The Package Text_IO(9), see A.8.4 The Generic Package Direct_IO(9), see A.10.1(12),
A.12.1 The Package Streams.Stream_IO.
of an external file A.7 External Files and File Objects.
formal object, generic 13.4 Formal Objects.
formal package, generic 13.7 Formal Packages.
formal parameter
of a subprogram 7.1 Subprogram Declarations.
formal subprogram, generic 13.6 Formal Subprograms.
formal subtype 13.5 Formal Types.
formal type 13.5 Formal Types.
formal_access_type_definition 13.5.4 Formal Access Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_array_type_definition 13.5.3 Formal Array Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_decimal_fixed_point_definition 13.5.2 Formal Scalar Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_derived_type_definition 13.5.1 Formal Private and Derived Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_discrete_type_definition 13.5.2 Formal Scalar Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_floating_point_definition 13.5.2 Formal Scalar Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_modular_type_definition 13.5.2 Formal Scalar Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_object_declaration 13.4 Formal Objects.
used 13.1 Generic Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
formal_ordinary_fixed_point_definition 13.5.2 Formal Scalar Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_package_actual_part 13.7 Formal Packages.
used 13.7 Formal Packages(2), see N. Syntax Summary (informative)(2), see P(1).
formal_package_declaration 13.7 Formal Packages.
used 13.1 Generic Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
formal_part 7.1 Subprogram Declarations.
used 7.1 Subprogram Declarations(12), see 7.1 Subprogram Declarations(13), see N. Syntax Summary (informative)(12), see 7.1 Subprogram Declarations(13), see P(1).
formal_private_type_definition 13.5.1 Formal Private and Derived Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_signed_integer_type_definition 13.5.2 Formal Scalar Types.
used 13.5 Formal Types(3), see N. Syntax Summary (informative)(3), see P(1).
formal_subprogram_declaration 13.6 Formal Subprograms.
used 13.1 Generic Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
formal_type_declaration 13.5 Formal Types.
used 13.1 Generic Declarations(6), see N. Syntax Summary (informative)(6), see P(1).
formal_type_definition 13.5 Formal Types.
used 13.5 Formal Types(2), see N. Syntax Summary (informative)(2), see P(1).
format_effector 3.1 Character Set.
used 3.1 Character Set(2), see N. Syntax Summary (informative)(2), see P(1).
Fortran
child of Interfaces B.5 Interfacing with Fortran.
Fortran interface B.5 Interfacing with Fortran.
FORTRAN standard 2.2 Normative References.
Fortran_Character B.5 Interfacing with Fortran.
Fortran_Integer B.5 Interfacing with Fortran.
Fortran_Library B.1 Interfacing Pragmas.
Fortran_Matrix B.5 Interfacing with Fortran.
Fraction 4.5.9 Fixed Point Types.
Fraction attribute A.5.3 Attributes of Floating Point Types(21), see J. Language-Defined Attributes (informative)(21), see K(80).
Fraction_One_Half A.3.3 The Package Characters.Latin_1.
Fraction_One_Quarter A.3.3 The Package Characters.Latin_1.
Fraction_Three_Quarters A.3.3 The Package Characters.Latin_1.
Free 14.11.2 Unchecked Storage Deallocation(5), see A.4.5 Unbounded-Length String Handling(7), see B.3.1 The Package Interfaces.C.Strings(5), see A.4.5 Unbounded-Length String Handling(7), see B.3.1(11).
freed
See nonexistent 14.11.2 Unchecked Storage Deallocation.
freeing storage 14.11.2 Unchecked Storage Deallocation.
freezing
by a constituent of a construct 14.14 Freezing Rules.
by an expression 14.14 Freezing Rules.
class-wide type caused by the freezing of the specific type
14.14 Freezing Rules.
constituents of a full type definition 14.14 Freezing Rules.
designated subtype caused by an allocator 14.14 Freezing Rules.
entity 14.14 Freezing Rules.
entity caused by a body 14.14 Freezing Rules.
entity caused by a construct 14.14 Freezing Rules.
entity caused by a name 14.14 Freezing Rules.
entity caused by the end of an enclosing construct
14.14 Freezing Rules.
first subtype caused by the freezing of the type
14.14 Freezing Rules.
function call 14.14 Freezing Rules.
generic_instantiation 14.14 Freezing Rules.
nominal subtype caused by a name 14.14 Freezing Rules.
object_declaration 14.14 Freezing Rules.
specific type caused by the freezing of the class-wide type
14.14 Freezing Rules.
subtype caused by a record extension 14.14 Freezing Rules.
subtypes of the profile of a callable entity 14.14 Freezing Rules.
type caused by a range 14.14 Freezing Rules.
type caused by an expression 14.14 Freezing Rules.
type caused by the freezing of a subtype 14.14 Freezing Rules.
freezing points
entity 14.14 Freezing Rules.
FS A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
full conformance
for discrete_subtype_definitions 7.3.1 Conformance Rules.
for known_discriminant_parts 7.3.1 Conformance Rules.
for expressions 7.3.1 Conformance Rules.
for profiles 7.3.1 Conformance Rules.
required 4.10.1 Incomplete Type Declarations(4), see 7.3 Subprogram Bodies(4), 8.3 Private Types and Private Extensions(4), see 7.3 Subprogram Bodies(4), 7.3(9),
9.5.4 Subprogram Renaming Declarations(5), 10.5.2 Entries and Accept Statements(14), 10.5.2 Entries and Accept Statements(5), 10.5.2 Entries and Accept Statements(14), 9.5.2(16),
10.5.2 Entries and Accept Statements(17), see 11.1.3 Subunits of Compilation Units(11), see 11.1.3 Subunits of Compilation Units(17), see 11.1.3 Subunits of Compilation Units(11), see 10.1.3(12).
full constant declaration 4.3.1 Object Declarations.
full declaration 8.4 Deferred Constants.
full stop 3.1 Character Set.
full type 4.2.1 Type Declarations.
full type definition 4.2.1 Type Declarations.
full view
of a type 8.3 Private Types and Private Extensions.
Full_Stop A.3.3 The Package Characters.Latin_1.
full_type_declaration 4.2.1 Type Declarations.
used 4.2.1 Type Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
function 7. Subprograms.
function instance 13.3 Generic Instantiation.
function_call 7.4 Subprogram Calls.
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
|
U. index
| | gaps 14.1 Representation Items.
garbage collection 14.11.3 Pragma Controlled.
Gender 4.5.1 Enumeration Types.
general access type 4.10 Access Types(7), see 4.10 Access Types(7), see 3.10(8).
general_access_modifier 4.10 Access Types.
used 4.10 Access Types(3), see N. Syntax Summary (informative)(3), see P(1).
generation
of an interrupt C.3 Interrupt Support.
Generator A.5.2 Random Number Generation(7), see A.5.2 Random Number Generation(7), see A.5.2(19).
generic actual 13.3 Generic Instantiation.
generic actual parameter 13.3 Generic Instantiation.
generic actual subtype 13.5 Formal Types.
generic actual type 13.5 Formal Types.
generic body 13.2 Generic Bodies.
generic contract issue 11.2.1 Elaboration Control.
[partial] 4.9.1 Type Extensions(3), 4.10.2 Operations of Access Types(3), 3.10.2(28),
4.10.2 Operations of Access Types(32), see 5.6 Type Conversions(32), see 4.6(17),
5.6 Type Conversions(20), 9.3 Visibility(20), 8.3(26),
11.2.1 Elaboration Control.
generic formal 13.1 Generic Declarations.
generic formal object 13.4 Formal Objects.
generic formal package 13.7 Formal Packages.
generic formal subprogram 13.6 Formal Subprograms.
generic formal subtype 13.5 Formal Types.
generic formal type 13.5 Formal Types.
generic function 13.1 Generic Declarations.
generic package 13.1 Generic Declarations.
generic procedure 13.1 Generic Declarations.
generic subprogram 13.1 Generic Declarations.
generic unit 13. Generic Units(1), see M. Glossary (informative)(1), see N(20).
See also dispatching operation 4.9 Tagged Types and Type Extensions.
generic_actual_part 13.3 Generic Instantiation.
used 13.3 Generic Instantiation(2), see 13.7 Formal Packages(3), see N. Syntax Summary (informative)(2), see 13.7 Formal Packages(3), see P(1).
generic_association 13.3 Generic Instantiation.
used 13.3 Generic Instantiation(3), see N. Syntax Summary (informative)(3), see P(1).
Generic_Bounded_Length A.4.4 Bounded-Length String Handling.
Generic_Complex_Elementary_Functions
child of Ada.Numerics G.1.2 Complex Elementary Functions.
Generic_Complex_Types
child of Ada.Numerics G.1.1 Complex Types.
generic_declaration 13.1 Generic Declarations.
used 4.1 Declarations(3), see 11.1.1 Compilation Units - Library Units(5), see N. Syntax Summary (informative)(3), see 11.1.1 Compilation Units - Library Units(5), see P(1).
Generic_Elementary_Functions
child of Ada.Numerics A.5.1 Elementary Functions.
generic_formal_parameter_declaration 13.1 Generic Declarations.
used 13.1 Generic Declarations(5), see N. Syntax Summary (informative)(5), see P(1).
generic_formal_part 13.1 Generic Declarations.
used 13.1 Generic Declarations(3), see 13.1 Generic Declarations(4), see N. Syntax Summary (informative)(3), see 13.1 Generic Declarations(4), see P(1).
generic_instantiation 13.3 Generic Instantiation.
used 4.1 Declarations(3), see 11.1.1 Compilation Units - Library Units(5), see N. Syntax Summary (informative)(3), see 11.1.1 Compilation Units - Library Units(5), see P(1).
generic_package_declaration 13.1 Generic Declarations.
used 13.1 Generic Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
generic_renaming_declaration 9.5.5 Generic Renaming Declarations.
used 9.5 Renaming Declarations(2), see 11.1.1 Compilation Units - Library Units(6), see N. Syntax Summary (informative)(2), see 11.1.1 Compilation Units - Library Units(6), see P(1).
generic_subprogram_declaration 13.1 Generic Declarations.
used 13.1 Generic Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
Get 11.1.1 Compilation Units - Library Units(30), see A.10.1 The Package Text_IO(41), see A.10.1 The Package Text_IO(30), see A.10.1 The Package Text_IO(41), see A.10.1(47),
A.10.1 The Package Text_IO(54), see A.10.1 The Package Text_IO(55), see A.10.1 The Package Text_IO(54), see A.10.1 The Package Text_IO(55), see A.10.1(59),
A.10.1 The Package Text_IO(60), see A.10.1 The Package Text_IO(65), see A.10.1 The Package Text_IO(60), see A.10.1 The Package Text_IO(65), see A.10.1(67),
A.10.1 The Package Text_IO(70), see A.10.1 The Package Text_IO(72), see A.10.1 The Package Text_IO(70), see A.10.1 The Package Text_IO(72), see A.10.1(75),
A.10.1 The Package Text_IO(77), see A.10.1 The Package Text_IO(81), see A.10.1 The Package Text_IO(77), see A.10.1 The Package Text_IO(81), see A.10.1(83),
G.1.3 Complex Input-Output(6), G.1.3 Complex Input-Output(6), G.1.3(8).
Get_Immediate A.10.1 The Package Text_IO(44), see A.10.1 The Package Text_IO(44), see A.10.1(45).
Get_Key 8.3.1 Private Operations(15), see 8.3.1 Private Operations(15), see 7.3.1(16).
Get_Line A.10.1 The Package Text_IO.
Get_Priority D.5 Dynamic Priorities.
Global 10.3 Task Dependence - Termination of Tasks.
global to 9.1 Declarative Region.
Glossary M. Glossary (informative).
goto_statement 6.8 Goto Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
govern a variant_part 4.8.1 Variant Parts and Discrete Choices.
govern a variant 4.8.1 Variant Parts and Discrete Choices.
grammar
complete listing N. Syntax Summary (informative).
cross reference N. Syntax Summary (informative).
notation 2.1.4 Method of Description and Syntax Notation.
resolution of ambiguity 9.6 The Context of Overload Resolution.
under Syntax heading 2.1.2 Structure.
graphic character
a category of Character A.3.2 The Package Characters.Handling.
graphic_character 3.1 Character Set.
used 3.1 Character Set(2), see 3.5 Character Literals(2), see 3.6 String Literals(3), see N. Syntax Summary (informative)(2), see 3.5 Character Literals(2), see 3.6 String Literals(3), see P(1).
Graphic_Set A.4.6 String-Handling Sets and Mappings.
greater than operator 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
greater than or equal operator 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
greater-than sign 3.1 Character Set.
Greater_Than_Sign A.3.3 The Package Characters.Latin_1.
GS A.3.3 The Package Characters.Latin_1.
guard 10.7.1 Selective Accept.
used 10.7.1 Selective Accept(2), see N. Syntax Summary (informative)(2), see P(1).
|
V. index
| | Half_Pi 5.9 Static Expressions and Static Subtypes.
handle
an exception 12. Exceptions(1), see M. Glossary (informative)(1), see N(18).
an exception occurrence 12.4 Exception Handling(1), see 12.4 Exception Handling(1), see 11.4(7).
handled_sequence_of_statements 12.2 Exception Handlers.
used 6.6 Block Statements(2), see 7.3 Subprogram Bodies(2), 8.2 Package Bodies(2), see 7.3 Subprogram Bodies(2), 7.2(2),
10.1 Task Units and Task Objects(6), see 10.5.2 Entries and Accept Statements(3), see 10.5.2 Entries and Accept Statements(6), see 10.5.2 Entries and Accept Statements(3), see 9.5.2(5),
N. Syntax Summary (informative).
Handler C.3.2 The Package Interrupts.
Handling
child of Ada.Characters A.3.2 The Package Characters.Handling.
Hash_Index 4.5.4 Integer Types.
head (of a queue) D.2.1 The Task Dispatching Model.
Head A.4.3 Fixed-Length String Handling(35), see A.4.3 Fixed-Length String Handling(36), see A.4.4 Bounded-Length String Handling(35), see A.4.3 Fixed-Length String Handling(36), see A.4.4(70),
A.4.4 Bounded-Length String Handling(71), see A.4.5 Unbounded-Length String Handling(65), see A.4.5 Unbounded-Length String Handling(71), see A.4.5 Unbounded-Length String Handling(65), see A.4.5(66).
heap management
See also alligator 5.8 Allocators.
user-defined 14.11 Storage Management.
held priority D.11 Asynchronous Task Control.
Hello 4.3.1 Object Declarations.
heterogeneous input-output A.12.1 The Package Streams.Stream_IO.
Hexa 4.5.1 Enumeration Types.
hexadecimal
literal 3.4.2 Based Literals.
hexadecimal digit
a category of Character A.3.2 The Package Characters.Handling.
hexadecimal literal 3.4.2 Based Literals.
Hexadecimal_Digit_Set A.4.6 String-Handling Sets and Mappings.
hidden from all visibility 9.3 Visibility(5), see 9.3 Visibility(5), see 8.3(14).
by lack of a with_clause 9.3 Visibility.
for a declaration completed by a subsequent declaration
9.3 Visibility.
for overridden declaration 9.3 Visibility.
within the declaration itself 9.3 Visibility.
hidden from direct visibility 9.3 Visibility(5), see 9.3 Visibility(5), see 8.3(21).
by an inner homograph 9.3 Visibility.
where hidden from all visibility 9.3 Visibility.
hiding 9.3 Visibility.
High_Order_First 14.5.3 Bit Ordering(2), see B.4 Interfacing with COBOL(2), see B.4(25).
highest precedence operator 5.5.6 Highest Precedence Operators.
highest_precedence_operator 5.5 Operators and Expression Evaluation.
Hold D.11 Asynchronous Task Control.
homograph 9.3 Visibility.
HT A.3.3 The Package Characters.Latin_1.
HTJ A.3.3 The Package Characters.Latin_1.
HTS A.3.3 The Package Characters.Latin_1.
Hyphen A.3.3 The Package Characters.Latin_1.
hyphen-minus 3.1 Character Set.
|
W. index
| | i G.1.1 Complex Types(5), see G.1.1 Complex Types(5), see G.1.1(23).
identifier 3.3 Identifiers.
used 3.8 Pragmas(2), 3.8 Pragmas(3), 3.8 Pragmas(2), 3.8 Pragmas(3), 2.8(21),
3.8 Pragmas(23), 4.1 Declarations(4), 5.1 Names(23), 4.1 Declarations(4), 4.1(3),
5.1.3 Selected Components(3), see 5.1.4 Attributes(3), see 6.5 Loop Statements(3), see 5.1.4 Attributes(3), see 5.5(2),
6.6 Block Statements(2), 7.1 Subprogram Declarations(5), 8.1 Package Specifications and Declarations(2), 7.1 Subprogram Declarations(5), 7.1(3),
8.2 Package Bodies(2), 10.1 Task Units and Task Objects(4), 10.1 Task Units and Task Objects(2), 10.1 Task Units and Task Objects(4), 9.1(6),
10.4 Protected Units and Protected Objects(4), 10.4 Protected Units and Protected Objects(7), 10.5.2 Entries and Accept Statements(4), 10.4 Protected Units and Protected Objects(7), 9.5.2(3),
10.5.2 Entries and Accept Statements(5), see 12.5 Suppressing Checks(4), 14.12 Pragma Restrictions(5), see 12.5 Suppressing Checks(4), 13.12(4),
B.1 Interfacing Pragmas(5), B.1 Interfacing Pragmas(6), B.1 Interfacing Pragmas(5), B.1 Interfacing Pragmas(6), B.1(7),
D.2.2 The Standard Task Dispatching Policy(2), see D.2.2 The Standard Task Dispatching Policy(3), see D.3 Priority Ceiling Locking(2), see D.2.2 The Standard Task Dispatching Policy(3), see D.3(3),
D.3 Priority Ceiling Locking(4), D.4 Entry Queuing Policies(3), D.4 Entry Queuing Policies(4), D.4 Entry Queuing Policies(3), D.4(4),
K. Language-Defined Pragmas (informative)(8), K. Language-Defined Pragmas (informative)(13), K. Language-Defined Pragmas (informative)(8), K. Language-Defined Pragmas (informative)(13), L(14),
K. Language-Defined Pragmas (informative)(20), K. Language-Defined Pragmas (informative)(21), K. Language-Defined Pragmas (informative)(20), K. Language-Defined Pragmas (informative)(21), L(23),
K. Language-Defined Pragmas (informative)(29), K. Language-Defined Pragmas (informative)(36), K. Language-Defined Pragmas (informative)(29), K. Language-Defined Pragmas (informative)(36), L(37),
L. Implementation-Defined Characteristics (informative)(95), L. Implementation-Defined Characteristics (informative)(98), N. Syntax Summary (informative)(95), L. Implementation-Defined Characteristics (informative)(98), P(1).
identifier specific to a pragma 3.8 Pragmas.
identifier_letter 3.1 Character Set.
used 3.1 Character Set(3), see 3.3 Identifiers(2), see 3.3 Identifiers(3), see N. Syntax Summary (informative)(3), see 3.3 Identifiers(2), see 3.3 Identifiers(3), see P(1).
Identity A.4.2 The Package Strings.Maps(22), see A.4.7 Wide_String Handling(22), see A.4.7(22).
Identity attribute 12.4.1 The Package Exceptions(9), see C.7.1 The Package Task_Identification(9), see C.7.1(12),
J. Language-Defined Attributes (informative)(84), J. Language-Defined Attributes (informative)(84), K(86).
idle task D.11 Asynchronous Task Control.
if_statement 6.3 If Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(5), see N. Syntax Summary (informative)(5), see P(1).
illegal
construct 2.1.2 Structure.
partition 2.1.2 Structure.
Im G.1.1 Complex Types.
image A.5.2 Random Number Generation(14), see A.5.2 Random Number Generation(26), see C.7.1 The Package Task_Identification(14), see A.5.2 Random Number Generation(26), see C.7.1(3),
F.3.3 The Package Text_IO.Editing.
of a value 4.5 Scalar Types(30), see J. Language-Defined Attributes (informative)(30), see K(273).
Image attribute 4.5 Scalar Types(35), see J. Language-Defined Attributes (informative)(35), see K(88).
Imaginary B.5 Interfacing with Fortran(10), see G.1.1 Complex Types(4), see G.1.1 Complex Types(10), see G.1.1 Complex Types(4), see G.1.1(23).
immediate scope
of (a view of) an entity 9.2 Scope of Declarations.
of a declaration 9.2 Scope of Declarations.
immediately enclosing 9.1 Declarative Region.
immediately visible 9.3 Visibility(4), see 9.3 Visibility(4), see 8.3(21).
immediately within 9.1 Declarative Region(13)
implementation advice 2.1.2 Structure.
implementation defined 2.1.3 Conformity of an Implementation with the Standard.
summary of characteristics L. Implementation-Defined Characteristics (informative).
implementation permissions 2.1.2 Structure.
implementation requirements 2.1.2 Structure.
implementation-dependent
See unspecified 2.1.3 Conformity of an Implementation with the Standard.
implicit declaration 4.1 Declarations(5), see M. Glossary (informative)(5), see N(11).
implicit initial values
for a subtype 4.3.1 Object Declarations.
implicit subtype conversion 5.6 Type Conversions(59), see 5.6 Type Conversions(59), see 4.6(60).
Access attribute 4.10.2 Operations of Access Types.
access discriminant 4.7 Discriminants.
array bounds 5.6 Type Conversions.
array index 5.1.1 Indexed Components.
assignment to view conversion 5.6 Type Conversions.
assignment_statement 6.2 Assignment Statements.
bounds of a decimal fixed point type 4.5.9 Fixed Point Types.
bounds of a fixed point type 4.5.9 Fixed Point Types.
bounds of a floating point type 4.5.7 Floating Point Types.
bounds of a range 4.5 Scalar Types(9), see 4.6 Array Types(9), see 3.6(18).
bounds of signed integer type 4.5.4 Integer Types.
choices of aggregate 5.3.3 Array Aggregates.
component defaults 4.3.1 Object Declarations.
delay expression 10.6 Delay Statements, Duration, and Time.
derived type discriminants 4.4 Derived Types and Classes.
discriminant values 4.7.1 Discriminant Constraints.
entry index 10.5.2 Entries and Accept Statements.
expressions in aggregate 5.3.1 Record Aggregates.
expressions of aggregate 5.3.3 Array Aggregates.
function return 7.5 Return Statements.
generic formal object of mode in 13.4 Formal Objects(11)
inherited enumeration literal 4.4 Derived Types and Classes.
initialization expression 4.3.1 Object Declarations.
initialization expression of allocator 5.8 Allocators.
named number value 4.3.2 Number Declarations.
operand of concatenation 5.5.3 Binary Adding Operators.
parameter passing 7.4.1 Parameter Associations(10), see 7.4.1 Parameter Associations(10), see 6.4.1(11),
7.4.1 Parameter Associations.
pragma Interrupt_Priority D.1 Task Priorities(17), see D.3 Priority Ceiling Locking(17), see D.3(9).
pragma Priority D.1 Task Priorities(17), see D.3 Priority Ceiling Locking(17), see D.3(9).
qualified_expression 5.7 Qualified Expressions.
reading a view conversion 5.6 Type Conversions.
result of inherited function 4.4 Derived Types and Classes.
implicit_dereference 5.1 Names.
used 5.1 Names(4), see N. Syntax Summary (informative)(4), see P(1).
Import pragma B.1 Interfacing Pragmas(5), see K. Language-Defined Pragmas (informative)(5), see L(14).
imported
aspect of representation B.1 Interfacing Pragmas.
imported entity B.1 Interfacing Pragmas.
in (membership test) 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(2).
inaccessible partition E.1 Partitions.
inactive
a task state 10. Tasks and Synchronization.
included
one range in another 4.5 Scalar Types.
incomplete type 4.10.1 Incomplete Type Declarations.
incomplete_type_declaration 4.10.1 Incomplete Type Declarations.
used 4.2.1 Type Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
Increment 7.1 Subprogram Declarations(37), see B.3.2 The Generic Package Interfaces.C.Pointers(37), see B.3.2(11).
indefinite subtype 4.3 Objects and Named Numbers(23), see 4.7 Discriminants(23), see 3.7(26).
independent subprogram 12.6 Exceptions and Optimization.
independently addressable 10.10 Shared Variables.
Index 13.1 Generic Declarations(19), 13.5.3 Formal Array Types(11), see A.4.3 Fixed-Length String Handling(19), 13.5.3 Formal Array Types(11), see A.4.3(9),
A.4.3 Fixed-Length String Handling(10), see A.4.3 Fixed-Length String Handling(11), A.4.4 Bounded-Length String Handling(10), see A.4.3 Fixed-Length String Handling(11), A.4.4(44),
A.4.4 Bounded-Length String Handling(45), see A.4.4 Bounded-Length String Handling(46), A.4.5 Unbounded-Length String Handling(45), see A.4.4 Bounded-Length String Handling(46), A.4.5(39),
A.4.5 Unbounded-Length String Handling(40), see A.4.5 Unbounded-Length String Handling(41), A.8.4 The Generic Package Direct_IO(40), see A.4.5 Unbounded-Length String Handling(41), A.8.4(15),
A.12.1 The Package Streams.Stream_IO(23), see B.3.2 The Generic Package Interfaces.C.Pointers(23), see B.3.2(4).
of an element of an open direct file A.8 Sequential and Direct Files.
index range 4.6 Array Types.
index subtype 4.6 Array Types.
index type 4.6 Array Types.
Index_Check 12.5 Suppressing Checks.
[partial] 5.1.1 Indexed Components(7), 5.1.2 Slices(7), see 5.3.3 Array Aggregates(7), 5.1.2 Slices(7), see 4.3.3(29),
5.3.3 Array Aggregates(30), see 5.5.3 Binary Adding Operators(8), see 5.6 Type Conversions(30), see 5.5.3 Binary Adding Operators(8), see 4.6(51),
5.7 Qualified Expressions(4), 5.8 Allocators(4), 4.8(10).
index_constraint 4.6.1 Index Constraints and Discrete Ranges.
used 4.2.2 Subtype Declarations(7), see N. Syntax Summary (informative)(7), see P(1).
Index_Non_Blank A.4.3 Fixed-Length String Handling(12), see A.4.4 Bounded-Length String Handling(12), see A.4.4(47),
A.4.5 Unbounded-Length String Handling.
index_subtype_definition 4.6 Array Types.
used 4.6 Array Types(3), see N. Syntax Summary (informative)(3), see P(1).
indexed_component 5.1.1 Indexed Components.
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
indivisible C.6 Shared Variable Control.
information hiding
See package 8. Packages.
See private types and private extensions 8.3 Private Types and Private Extensions.
information systems C. Systems Programming (normative)(1), see F. Information Systems (normative)(1), see F(1).
informative 2.1.2 Structure.
inheritance
See also tagged types and type extension 4.9 Tagged Types and Type Extensions.
See derived types and classes 4.4 Derived Types and Classes.
inherited
from an ancestor type 4.4.1 Derivation Classes.
inherited component 4.4 Derived Types and Classes(11), see 4.4 Derived Types and Classes(11), see 3.4(12).
inherited discriminant 4.4 Derived Types and Classes.
inherited entry 4.4 Derived Types and Classes.
inherited protected subprogram 4.4 Derived Types and Classes.
inherited subprogram 4.4 Derived Types and Classes.
initialization
of a protected object 10.4 Protected Units and Protected Objects(14), see C.3.1 Protected Procedure Handlers(14), see C.3.1(10),
C.3.1 Protected Procedure Handlers.
of a task object 10.1 Task Units and Task Objects(12), see I.7.1 Interrupt Entries(12), see J.7.1(7).
of an object 4.3.1 Object Declarations.
initialization expression 4.3.1 Object Declarations(1), see 4.3.1 Object Declarations(1), see 3.3.1(4).
Initialize 8.6 User-Defined Assignment and Finalization(2), see 8.6 User-Defined Assignment and Finalization(6), see 8.6 User-Defined Assignment and Finalization(2), see 8.6 User-Defined Assignment and Finalization(6), see 7.6(8).
Initialize_Generator A.5.2 Random Number Generation.
initialized allocator 5.8 Allocators.
Inline pragma 7.3.2 Inline Expansion of Subprograms(3), see K. Language-Defined Pragmas (informative)(3), see L(15).
Inner 11.1.3 Subunits of Compilation Units(20), see 11.1.3 Subunits of Compilation Units(21), see 11.1.3 Subunits of Compilation Units(20), see 11.1.3 Subunits of Compilation Units(21), see 10.1.3(23),
11.1.3 Subunits of Compilation Units.
innermost dynamically enclosing 12.4 Exception Handling.
input A.6 Input-Output.
Input attribute 14.13.2 Stream-Oriented Attributes(22), see 14.13.2 Stream-Oriented Attributes(22), see 13.13.2(32),
J. Language-Defined Attributes (informative)(92), J. Language-Defined Attributes (informative)(92), K(96).
Input clause 14.3 Representation Attributes(7), see 14.13.2 Stream-Oriented Attributes(7), see 13.13.2(36).
input-output
unspecified for access types A.7 External Files and File Objects.
Insert A.4.3 Fixed-Length String Handling(25), see A.4.3 Fixed-Length String Handling(26), see A.4.4 Bounded-Length String Handling(25), see A.4.3 Fixed-Length String Handling(26), see A.4.4(60),
A.4.4 Bounded-Length String Handling(61), see A.4.5 Unbounded-Length String Handling(55), see A.4.5 Unbounded-Length String Handling(61), see A.4.5 Unbounded-Length String Handling(55), see A.4.5(56).
inspectable object H.3.2 Pragma Inspection_Point.
inspection point H.3.2 Pragma Inspection_Point.
Inspection_Point pragma H.3.2 Pragma Inspection_Point(3), see K. Language-Defined Pragmas (informative)(3), see L(16).
instance
of a generic function 13.3 Generic Instantiation.
of a generic package 13.3 Generic Instantiation.
of a generic procedure 13.3 Generic Instantiation.
of a generic subprogram 13.3 Generic Instantiation.
of a generic unit 13.3 Generic Instantiation.
instructions for comment submission
Int 4.2.2 Subtype Declarations(15), see 13.5 Formal Types(13), see B.3 Interfacing with C(15), see 13.5 Formal Types(13), see B.3(7).
Int_Plus 9.5.4 Subprogram Renaming Declarations.
Int_Vectors 13.3 Generic Instantiation.
Int_IO A.10.8 Input-Output for Integer Types.
Integer 4.5.4 Integer Types(11), see 4.5.4 Integer Types(21), see A.1 The Package Standard(11), see 4.5.4 Integer Types(21), see A.1(12).
integer literal 3.4 Numeric Literals.
integer literals 4.5.4 Integer Types(14), see 4.5.4 Integer Types(14), see 3.5.4(30).
integer type 4.5.4 Integer Types(1), see M. Glossary (informative)(1), see N(21).
Integer_Address 14.7.1 The Package System.Storage_Elements.
Integer_Text_IO
child of Ada A.10.8 Input-Output for Integer Types.
integer_type_definition 4.5.4 Integer Types.
used 4.2.1 Type Declarations(4), see N. Syntax Summary (informative)(4), see P(1).
Integer_Wide_Text_IO
child of Ada A.11 Wide Text Input-Output.
Integer_IO A.10.1 The Package Text_IO.
interaction
between tasks 10. Tasks and Synchronization.
interface to assembly language C.1 Access to Machine Operations.
interface to C B.3 Interfacing with C.
interface to COBOL B.4 Interfacing with COBOL.
interface to Fortran B.5 Interfacing with Fortran.
interface to other languages B. Interface to Other Languages (normative).
Interfaces B.2 The Package Interfaces.
Interfaces.COBOL B.4 Interfacing with COBOL.
Interfaces.Fortran B.5 Interfacing with Fortran.
Interfaces.C B.3 Interfacing with C.
Interfaces.C.Pointers B.3.2 The Generic Package Interfaces.C.Pointers.
Interfaces.C.Strings B.3.1 The Package Interfaces.C.Strings.
interfacing pragma B.1 Interfacing Pragmas.
Convention B.1 Interfacing Pragmas.
Export B.1 Interfacing Pragmas.
Import B.1 Interfacing Pragmas.
internal call 10.5 Intertask Communication.
internal code 14.4 Enumeration Representation Clauses.
internal requeue 10.5 Intertask Communication.
Internal_Tag 4.9 Tagged Types and Type Extensions.
interpretation
of a complete context 9.6 The Context of Overload Resolution.
of a constituent of a complete context 9.6 The Context of Overload Resolution.
overload resolution 9.6 The Context of Overload Resolution.
interrupt C.3 Interrupt Support.
example using asynchronous_select 10.7.4 Asynchronous Transfer of Control,
10.7.4 Asynchronous Transfer of Control.
interrupt entry I.7.1 Interrupt Entries.
interrupt handler C.3 Interrupt Support.
Interrupt_Handler I.7.1 Interrupt Entries.
Interrupt_Handler pragma C.3.1 Protected Procedure Handlers(2), see K. Language-Defined Pragmas (informative)(2), see L(17).
Interrupt_Priority 14.7 The Package System(16), see D.1 Task Priorities(16), see D.1(10).
Interrupt_Priority pragma D.1 Task Priorities(5), see K. Language-Defined Pragmas (informative)(5), see L(18).
Interrupt_ID C.3.2 The Package Interrupts.
Interrupts
child of Ada C.3.2 The Package Interrupts.
Intersection 4.9.3 Abstract Types and Subprograms.
intertask communication 10.5 Intertask Communication.
See also task 10. Tasks and Synchronization.
Intrinsic calling convention 7.3.1 Conformance Rules.
invalid representation 14.9.1 Data Validity.
Invert B.5 Interfacing with Fortran.
Inverted_Exclamation A.3.3 The Package Characters.Latin_1.
Inverted_Question A.3.3 The Package Characters.Latin_1.
IO_Exceptions I.1 Renamings of Ada 83 Library Units.
child of Ada A.13 Exceptions in Input-Output.
IO_Package 8.5 Limited Types(18), see 8.5 Limited Types(18), see 7.5(20).
Is_Alphanumeric A.3.2 The Package Characters.Handling.
Is_Attached C.3.2 The Package Interrupts.
Is_Basic A.3.2 The Package Characters.Handling.
Is_Callable C.7.1 The Package Task_Identification.
Is_Character A.3.2 The Package Characters.Handling.
Is_Control A.3.2 The Package Characters.Handling.
Is_Decimal_Digit A.3.2 The Package Characters.Handling.
Is_Digit A.3.2 The Package Characters.Handling.
Is_Graphic A.3.2 The Package Characters.Handling.
Is_Held D.11 Asynchronous Task Control.
Is_Hexadecimal_Digit A.3.2 The Package Characters.Handling.
Is_ISO_646 A.3.2 The Package Characters.Handling.
Is_Letter A.3.2 The Package Characters.Handling.
Is_Lower A.3.2 The Package Characters.Handling.
Is_Open A.8.1 The Generic Package Sequential_IO(10), see A.8.4 The Generic Package Direct_IO(10), see A.10.1 The Package Text_IO(10), see A.8.4 The Generic Package Direct_IO(10), see A.10.1(13),
A.12.1 The Package Streams.Stream_IO.
Is_Reserved C.3.2 The Package Interrupts.
Is_Special A.3.2 The Package Characters.Handling.
Is_String A.3.2 The Package Characters.Handling.
Is_Subset A.4.2 The Package Strings.Maps(14), see A.4.7 Wide_String Handling(14), see A.4.7(14).
Is_Terminated C.7.1 The Package Task_Identification.
Is_Upper A.3.2 The Package Characters.Handling.
Is_In A.4.2 The Package Strings.Maps(13), see A.4.7 Wide_String Handling(13), see A.4.7(13).
ISO 10646 4.5.2 Character Types(2), see 4.5.2 Character Types(2), see 3.5.2(3).
ISO 1989:1985 2.2 Normative References.
ISO/IEC 10646-1:1993 2.2 Normative References.
ISO/IEC 1539:1991 2.2 Normative References.
ISO/IEC 6429:1992 2.2 Normative References.
ISO/IEC 646:1991 2.2 Normative References.
ISO/IEC 8859-1:1987 2.2 Normative References.
ISO/IEC 9899:1990 2.2 Normative References.
ISO_646 A.3.2 The Package Characters.Handling.
ISO_646_Set A.4.6 String-Handling Sets and Mappings.
issue
an entry call 10.5.3 Entry Calls.
italics
nongraphic characters 4.5.2 Character Types.
pseudo-names of anonymous types 4.2.1 Type Declarations(7), see A.1 The Package Standard(7), see A.1(2).
syntax rules 2.1.4 Method of Description and Syntax Notation.
terms introduced or defined 2.3 Definitions.
Item 4.7 Discriminants(37), 13.1 Generic Declarations(19), see 13.1 Generic Declarations(37), 13.1 Generic Declarations(19), see 12.1(22),
13.1 Generic Declarations(24), see 13.5 Formal Types(12), see 13.5.3 Formal Array Types(24), see 13.5 Formal Types(12), see 12.5.3(11),
13.8 Example of a Generic Package(3), 13.8 Example of a Generic Package(3), 12.8(14).
Iterate 13.6 Formal Subprograms.
iteration_scheme 6.5 Loop Statements.
used 6.5 Loop Statements(2), see N. Syntax Summary (informative)(2), see P(1).
|
X. index
Y. index
| | Key 8.3 Private Types and Private Extensions(22), see 8.3.1 Private Operations(22), see 7.3.1(15).
Key_Manager 8.3.1 Private Operations(15), see 8.3.1 Private Operations(15), see 7.3.1(16).
Keyboard 10.1 Task Units and Task Objects.
Keyboard_Driver 10.1 Task Units and Task Objects.
Kilo 5.9 Static Expressions and Static Subtypes.
known discriminants 4.7 Discriminants.
known_discriminant_part 4.7 Discriminants.
used 4.2.1 Type Declarations(3), see 4.7 Discriminants(2), see 10.1 Task Units and Task Objects(3), see 4.7 Discriminants(2), see 9.1(2),
10.4 Protected Units and Protected Objects(2), N. Syntax Summary (informative)(2), P(1).
|
Z. index
| | L_Brace I.5 ASCII.
L_Bracket I.5 ASCII.
label 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(3), see N. Syntax Summary (informative)(3), see P(1).
language
interface to assembly C.1 Access to Machine Operations.
interface to non-Ada B. Interface to Other Languages (normative).
language-defined check 12.5 Suppressing Checks(2), see 12.6 Exceptions and Optimization(2), see 11.6(1).
language-defined class
[partial] 4.2 Types and Subtypes.
of types 4.2 Types and Subtypes.
Language-Defined Library Units A. Predefined Language Environment (normative).
Ada A.2 The Package Ada.
Ada.Asynchronous_Task_Control D.11 Asynchronous Task Control.
Ada.Calendar 10.6 Delay Statements, Duration, and Time.
Ada.Characters A.3.1 The Package Characters.
Ada.Characters.Handling A.3.2 The Package Characters.Handling.
Ada.Characters.Latin_1 A.3.3 The Package Characters.Latin_1.
Ada.Command_Line A.15 The Package Command_Line.
Ada.Decimal F.2 The Package Decimal.
Ada.Direct_IO A.8.4 The Generic Package Direct_IO(2), see A.9 The Generic Package Storage_IO(2), see A.9(3).
Ada.Dynamic_Priorities D.5 Dynamic Priorities.
Ada.Exceptions 12.4.1 The Package Exceptions.
Ada.Finalization 8.6 User-Defined Assignment and Finalization.
Ada.Float_Text_IO A.10.9 Input-Output for Real Types.
Ada.Float_Wide_Text_IO A.11 Wide Text Input-Output.
Ada.Integer_Text_IO A.10.8 Input-Output for Integer Types.
Ada.Integer_Wide_Text_IO A.11 Wide Text Input-Output.
Ada.Interrupts C.3.2 The Package Interrupts.
Ada.Interrupts.Names C.3.2 The Package Interrupts.
Ada.IO_Exceptions A.13 Exceptions in Input-Output.
Ada.Numerics A.5 The Numerics Packages.
Ada.Numerics.Complex_Elementary_Functions G.1.2 Complex Elementary Functions.
Ada.Numerics.Complex_Types G.1.1 Complex Types.
Ada.Numerics.Discrete_Random A.5.2 Random Number Generation.
Ada.Numerics.Elementary_Functions A.5.1 Elementary Functions.
Ada.Numerics.Float_Random A.5.2 Random Number Generation.
Ada.Numerics.Generic_Complex_Elementary_Functions
G.1.2 Complex Elementary Functions.
Ada.Numerics.Generic_Complex_Types G.1.1 Complex Types.
Ada.Numerics.Generic_Elementary_Functions A.5.1 Elementary Functions.
Ada.Real_Time D.8 Monotonic Time.
Ada.Sequential_IO A.8.1 The Generic Package Sequential_IO.
Ada.Storage_IO A.9 The Generic Package Storage_IO.
Ada.Streams 14.13.1 The Package Streams.
Ada.Streams.Stream_IO A.12.1 The Package Streams.Stream_IO.
Ada.Strings A.4.1 The Package Strings.
Ada.Strings.Bounded A.4.4 Bounded-Length String Handling.
Ada.Strings.Fixed A.4.3 Fixed-Length String Handling.
Ada.Strings.Maps A.4.2 The Package Strings.Maps.
Ada.Strings.Maps.Constants A.4.6 String-Handling Sets and Mappings.
Ada.Strings.Unbounded A.4.5 Unbounded-Length String Handling.
Ada.Strings.Wide_Bounded A.4.7 Wide_String Handling.
Ada.Strings.Wide_Fixed A.4.7 Wide_String Handling.
Ada.Strings.Wide_Maps A.4.7 Wide_String Handling.
Ada.Strings.Wide_Maps.Wide_Constants A.4.7 Wide_String Handling.
Ada.Strings.Wide_Unbounded A.4.7 Wide_String Handling.
Ada.Synchronous_Task_Control D.10 Synchronous Task Control.
Ada.Tags 4.9 Tagged Types and Type Extensions.
Ada.Task_Attributes C.7.2 The Package Task_Attributes.
Ada.Task_Identification C.7.1 The Package Task_Identification.
Ada.Text_IO A.10.1 The Package Text_IO.
Ada.Text_IO.Complex_IO G.1.3 Complex Input-Output.
Ada.Text_IO.Editing F.3.3 The Package Text_IO.Editing.
Ada.Text_IO.Text_Streams A.12.2 The Package Text_IO.Text_Streams.
Ada.Unchecked_Conversion 14.9 Unchecked Type Conversions.
Ada.Unchecked_Deallocation 14.11.2 Unchecked Storage Deallocation.
Ada.Wide_Text_IO A.11 Wide Text Input-Output.
Ada.Wide_Text_IO.Complex_IO G.1.4 The Package Wide_Text_IO.Complex_IO.
Ada.Wide_Text_IO.Editing F.3.4 The Package Wide_Text_IO.Editing.
Ada.Wide_Text_IO.Text_Streams A.12.3 The Package Wide_Text_IO.Text_Streams.
Interfaces B.2 The Package Interfaces.
Interfaces.C B.3 Interfacing with C.
Interfaces.C.Pointers B.3.2 The Generic Package Interfaces.C.Pointers.
Interfaces.C.Strings B.3.1 The Package Interfaces.C.Strings.
Interfaces.COBOL B.4 Interfacing with COBOL.
Interfaces.Fortran B.5 Interfacing with Fortran.
Standard A.1 The Package Standard.
System 14.7 The Package System.
System.Address_To_Access_Conversions 14.7.2 The Package System.Address_To_Access_Conversions.
System.Machine_Code 14.8 Machine Code Insertions.
System.RPC E.5 Partition Communication Subsystem.
System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
System.Storage_Pools 14.11 Storage Management.
Language-Defined Types
Address, in System 14.7 The Package System.
Alignment, in Ada.Strings A.4.1 The Package Strings.
Alphanumeric, in Interfaces.COBOL B.4 Interfacing with COBOL.
Attribute_Handle, in Ada.Task_Attributes C.7.2 The Package Task_Attributes.
Binary, in Interfaces.COBOL B.4 Interfacing with COBOL.
Binary_Format, in Interfaces.COBOL B.4 Interfacing with COBOL.
Bit_Order, in System 14.7 The Package System.
Boolean, in Standard A.1 The Package Standard.
Bounded_String, in Ada.Strings.Bounded.Generic_Bounded_Length
A.4.4 Bounded-Length String Handling.
Byte, in Interfaces.COBOL B.4 Interfacing with COBOL.
Byte_Array, in Interfaces.COBOL B.4 Interfacing with COBOL.
C_float, in Interfaces.C B.3 Interfacing with C.
char, in Interfaces.C B.3 Interfacing with C.
char_array, in Interfaces.C B.3 Interfacing with C.
char_array_access, in Interfaces.C B.3.1 The Package Interfaces.C.Strings.
Character, in Standard A.1 The Package Standard.
Character_Set, in Ada.Strings.Maps A.4.2 The Package Strings.Maps.
chars_ptr, in Interfaces.C B.3.1 The Package Interfaces.C.Strings.
chars_ptr_array, in Interfaces.C B.3.1 The Package Interfaces.C.Strings.
COBOL_Character, in Interfaces.COBOL B.4 Interfacing with COBOL.
Complex, in Ada.Numerics.Generic_Complex_Types G.1.1 Complex Types.
Controlled, in Ada.Finalization 8.6 User-Defined Assignment and Finalization.
Count, in Ada.Direct_IO A.8.4 The Generic Package Direct_IO.
Count, in Ada.Text_IO A.10.1 The Package Text_IO.
Decimal_Element, in Interfaces.COBOL B.4 Interfacing with COBOL.
Direction, in Ada.Strings A.4.1 The Package Strings.
Display_Format, in Interfaces.COBOL B.4 Interfacing with COBOL.
double, in Interfaces.C B.3 Interfacing with C.
Duration, in Standard A.1 The Package Standard.
Exception_Occurrence, in Ada.Exceptions 12.4.1 The Package Exceptions.
Exception_Occurrence_Access, in Ada.Exceptions 12.4.1 The Package Exceptions.
Exception_Id, in Ada.Exceptions 12.4.1 The Package Exceptions.
File_Mode, in Ada.Direct_IO A.8.4 The Generic Package Direct_IO.
File_Mode, in Ada.Sequential_IO A.8.1 The Generic Package Sequential_IO.
File_Mode, in Ada.Text_IO A.10.1 The Package Text_IO.
File_Type, in Ada.Direct_IO A.8.4 The Generic Package Direct_IO.
File_Type, in Ada.Sequential_IO A.8.1 The Generic Package Sequential_IO.
File_Type, in Ada.Text_IO A.10.1 The Package Text_IO.
Float, in Standard A.1 The Package Standard.
Floating, in Interfaces.COBOL B.4 Interfacing with COBOL.
Generator, in Ada.Numerics.Discrete_Random A.5.2 Random Number Generation.
Generator, in Ada.Numerics.Float_Random A.5.2 Random Number Generation.
Imaginary, in Ada.Numerics.Generic_Complex_Types G.1.1 Complex Types.
int, in Interfaces.C B.3 Interfacing with C.
Integer, in Standard A.1 The Package Standard.
Integer_Address, in System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
Interrupt_ID, in Ada.Interrupts C.3.2 The Package Interrupts.
Limited_Controlled, in Ada.Finalization 8.6 User-Defined Assignment and Finalization.
long, in Interfaces.C B.3 Interfacing with C.
Long_Binary, in Interfaces.COBOL B.4 Interfacing with COBOL.
long_double, in Interfaces.C B.3 Interfacing with C.
Long_Floating, in Interfaces.COBOL B.4 Interfacing with COBOL.
Membership, in Ada.Strings A.4.1 The Package Strings.
Name, in System 14.7 The Package System.
Numeric, in Interfaces.COBOL B.4 Interfacing with COBOL.
Packed_Decimal, in Interfaces.COBOL B.4 Interfacing with COBOL.
Packed_Format, in Interfaces.COBOL B.4 Interfacing with COBOL.
Parameterless_Handler, in Ada.Interrupts C.3.2 The Package Interrupts.
Partition_ID, in System.RPC E.5 Partition Communication Subsystem.
Picture, in Ada.Text_IO.Editing F.3.3 The Package Text_IO.Editing.
Picture, in Ada.Wide_Text_IO.Editing F.3.4 The Package Wide_Text_IO.Editing.
plain_char, in Interfaces.C B.3 Interfacing with C.
Pointer, in Interfaces.C.Pointers B.3.2 The Generic Package Interfaces.C.Pointers.
ptrdiff_t, in Interfaces.C B.3 Interfacing with C.
Root_Storage_Pool, in System.Storage_Pools 14.11 Storage Management.
Root_Stream_Type, in Ada.Streams 14.13.1 The Package Streams.
Seconds_Count, in Ada.Real_Time D.8 Monotonic Time.
short, in Interfaces.C B.3 Interfacing with C.
signed_char, in Interfaces.C B.3 Interfacing with C.
size_t, in Interfaces.C B.3 Interfacing with C.
State, in Ada.Numerics.Discrete_Random A.5.2 Random Number Generation.
State, in Ada.Numerics.Float_Random A.5.2 Random Number Generation.
Storage_Array, in System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
Storage_Element, in System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
Storage_Offset, in System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
Stream_Access, in Ada.Streams.Stream_IO A.12.1 The Package Streams.Stream_IO.
String, in Standard A.1 The Package Standard.
Suspension_Object, in Ada.Synchronous_Task_Control
D.10 Synchronous Task Control.
Tag, in Tags 4.9 Tagged Types and Type Extensions.
Task_ID, in Ada.Task_Identification C.7.1 The Package Task_Identification.
Time, in Ada.Calendar 10.6 Delay Statements, Duration, and Time.
Time, in Ada.Real_Time D.8 Monotonic Time.
Time_Span, in Ada.Real_Time D.8 Monotonic Time.
Trim_End, in Ada.Strings A.4.1 The Package Strings.
Truncation, in Ada.Strings A.4.1 The Package Strings.
Type_Set, in Ada.Text_IO A.10.1 The Package Text_IO.
Unbounded_String, in Ada.Strings.Unbounded A.4.5 Unbounded-Length String Handling.
unsigned, in Interfaces.C B.3 Interfacing with C.
unsigned_char, in Interfaces.C B.3 Interfacing with C.
unsigned_long, in Interfaces.C B.3 Interfacing with C.
unsigned_short, in Interfaces.C B.3 Interfacing with C.
wchar_array, in Interfaces.C B.3 Interfacing with C.
wchar_t, in Interfaces.C B.3 Interfacing with C.
Wide_Character, in Standard A.1 The Package Standard.
Wide_Character_Set, in Ada.Strings.Wide_Maps A.4.7 Wide_String Handling.
Wide_String, in Standard A.1 The Package Standard.
Last attribute 4.5 Scalar Types(13), see 4.6.2 Operations of Array Types(5), see J. Language-Defined Attributes (informative)(13), see 4.6.2 Operations of Array Types(5), see K(102),
J. Language-Defined Attributes (informative).
Last(N) attribute 4.6.2 Operations of Array Types(6), see J. Language-Defined Attributes (informative)(6), see K(100).
last_bit 14.5.1 Record Representation Clauses.
used 14.5.1 Record Representation Clauses(3), see N. Syntax Summary (informative)(3), see P(1).
Last_Bit attribute 14.5.2 Storage Place Attributes(4), see J. Language-Defined Attributes (informative)(4), see K(106).
lateness D.9 Delay Accuracy.
Latin-1 4.5.2 Character Types.
Latin_1
child of Ada.Characters A.3.3 The Package Characters.Latin_1.
layout
aspect of representation 14.5 Record Layout.
Layout_Error A.10.1 The Package Text_IO(85), see A.13 Exceptions in Input-Output(85), see A.13(4).
LC_German_Sharp_S A.3.3 The Package Characters.Latin_1.
LC_Icelandic_Eth A.3.3 The Package Characters.Latin_1.
LC_Icelandic_Thorn A.3.3 The Package Characters.Latin_1.
LC_A A.3.3 The Package Characters.Latin_1(13), see I.5 ASCII(13), see J.5(8).
LC_A_Acute A.3.3 The Package Characters.Latin_1.
LC_A_Circumflex A.3.3 The Package Characters.Latin_1.
LC_A_Diaeresis A.3.3 The Package Characters.Latin_1.
LC_A_Grave A.3.3 The Package Characters.Latin_1.
LC_A_Ring A.3.3 The Package Characters.Latin_1.
LC_A_Tilde A.3.3 The Package Characters.Latin_1.
LC_AE_Diphthong A.3.3 The Package Characters.Latin_1.
LC_B A.3.3 The Package Characters.Latin_1.
LC_C A.3.3 The Package Characters.Latin_1.
LC_C_Cedilla A.3.3 The Package Characters.Latin_1.
LC_D A.3.3 The Package Characters.Latin_1.
LC_E A.3.3 The Package Characters.Latin_1.
LC_E_Acute A.3.3 The Package Characters.Latin_1.
LC_E_Circumflex A.3.3 The Package Characters.Latin_1.
LC_E_Diaeresis A.3.3 The Package Characters.Latin_1.
LC_E_Grave A.3.3 The Package Characters.Latin_1.
LC_F A.3.3 The Package Characters.Latin_1.
LC_G A.3.3 The Package Characters.Latin_1.
LC_H A.3.3 The Package Characters.Latin_1.
LC_I A.3.3 The Package Characters.Latin_1.
LC_I_Acute A.3.3 The Package Characters.Latin_1.
LC_I_Circumflex A.3.3 The Package Characters.Latin_1.
LC_I_Diaeresis A.3.3 The Package Characters.Latin_1.
LC_I_Grave A.3.3 The Package Characters.Latin_1.
LC_J A.3.3 The Package Characters.Latin_1.
LC_K A.3.3 The Package Characters.Latin_1.
LC_L A.3.3 The Package Characters.Latin_1.
LC_M A.3.3 The Package Characters.Latin_1.
LC_N A.3.3 The Package Characters.Latin_1.
LC_N_Tilde A.3.3 The Package Characters.Latin_1.
LC_O A.3.3 The Package Characters.Latin_1.
LC_O_Acute A.3.3 The Package Characters.Latin_1.
LC_O_Circumflex A.3.3 The Package Characters.Latin_1.
LC_O_Diaeresis A.3.3 The Package Characters.Latin_1.
LC_O_Grave A.3.3 The Package Characters.Latin_1.
LC_O_Oblique_Stroke A.3.3 The Package Characters.Latin_1.
LC_O_Tilde A.3.3 The Package Characters.Latin_1.
LC_P A.3.3 The Package Characters.Latin_1.
LC_Q A.3.3 The Package Characters.Latin_1.
LC_R A.3.3 The Package Characters.Latin_1.
LC_S A.3.3 The Package Characters.Latin_1.
LC_T A.3.3 The Package Characters.Latin_1.
LC_U A.3.3 The Package Characters.Latin_1.
LC_U_Acute A.3.3 The Package Characters.Latin_1.
LC_U_Circumflex A.3.3 The Package Characters.Latin_1.
LC_U_Diaeresis A.3.3 The Package Characters.Latin_1.
LC_U_Grave A.3.3 The Package Characters.Latin_1.
LC_V A.3.3 The Package Characters.Latin_1.
LC_W A.3.3 The Package Characters.Latin_1.
LC_X A.3.3 The Package Characters.Latin_1.
LC_Y A.3.3 The Package Characters.Latin_1.
LC_Y_Acute A.3.3 The Package Characters.Latin_1.
LC_Y_Diaeresis A.3.3 The Package Characters.Latin_1.
LC_Z A.3.3 The Package Characters.Latin_1(14), see I.5 ASCII(14), see J.5(8).
Leading_Nonseparate B.4 Interfacing with COBOL.
Leading_Part attribute A.5.3 Attributes of Floating Point Types(54), see J. Language-Defined Attributes (informative)(54), see K(108).
Leading_Separate B.4 Interfacing with COBOL.
leaving 8.6.1 Completion and Finalization.
left 8.6.1 Completion and Finalization.
left curly bracket 3.1 Character Set.
left parenthesis 3.1 Character Set.
left square bracket 3.1 Character Set.
Left_Angle_Quotation A.3.3 The Package Characters.Latin_1.
Left_Curly_Bracket A.3.3 The Package Characters.Latin_1.
Left_Parenthesis A.3.3 The Package Characters.Latin_1.
Left_Square_Bracket A.3.3 The Package Characters.Latin_1.
legal
construct 2.1.2 Structure.
partition 2.1.2 Structure.
legality rules 2.1.2 Structure.
length A.4.4 Bounded-Length String Handling(9), see A.4.5 Unbounded-Length String Handling(6), see B.4 Interfacing with COBOL(9), see A.4.5 Unbounded-Length String Handling(6), see B.4(34),
B.4 Interfacing with COBOL(39), B.4 Interfacing with COBOL(44), F.3.3 The Package Text_IO.Editing(39), B.4 Interfacing with COBOL(44), F.3.3(11).
of a dimension of an array 4.6 Array Types.
of a one-dimensional array 4.6 Array Types.
Length attribute 4.6.2 Operations of Array Types(9), see J. Language-Defined Attributes (informative)(9), see K(117).
Length(N) attribute 4.6.2 Operations of Array Types(10), see J. Language-Defined Attributes (informative)(10), see K(115).
Length_Check 12.5 Suppressing Checks.
[partial] 5.5.1 Logical Operators and Short-circuit Control Forms(8), see 5.6 Type Conversions(37), see 5.6 Type Conversions(8), see 5.6 Type Conversions(37), see 4.6(52).
Length_Error 13.1 Generic Declarations.
Length_Range A.4.4 Bounded-Length String Handling.
less than operator 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
less than or equal operator 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
less-than sign 3.1 Character Set.
Less_Than_Sign A.3.3 The Package Characters.Latin_1.
letter
a category of Character A.3.2 The Package Characters.Handling.
Letter_Set A.4.6 String-Handling Sets and Mappings.
letter_or_digit 3.3 Identifiers.
used 3.3 Identifiers(2), see N. Syntax Summary (informative)(2), see P(1).
Level 4.5.1 Enumeration Types.
accessibility 4.10.2 Operations of Access Types.
library 4.10.2 Operations of Access Types.
lexical element 3.2 Lexical Elements, Separators, and Delimiters.
lexicographic order 5.5.2 Relational Operators and Membership Tests.
LF A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
library 11.1.4 The Compilation Process.
informal introduction 11. Program Structure and Compilation Issues.
library level 4.10.2 Operations of Access Types.
library unit 11.1 Separate Compilation(3), see 11.1.1 Compilation Units - Library Units(9), see M. Glossary (informative)(3), see 11.1.1 Compilation Units - Library Units(9), see N(22).
informal introduction 11. Program Structure and Compilation Issues.
See also language-defined library units
library unit pragma 11.1.5 Pragmas and Program Units.
All_Calls_Remote E.2.3 Remote Call Interface Library Units.
categorization pragmas E.2 Categorization of Library Units.
Elaborate_Body 11.2.1 Elaboration Control.
Preelaborate 11.2.1 Elaboration Control.
Pure 11.2.1 Elaboration Control.
library_item 11.1.1 Compilation Units - Library Units.
used 11.1.1 Compilation Units - Library Units(3), see N. Syntax Summary (informative)(3), see P(1).
informal introduction 11. Program Structure and Compilation Issues.
library_unit_body 11.1.1 Compilation Units - Library Units.
used 11.1.1 Compilation Units - Library Units(4), see N. Syntax Summary (informative)(4), see P(1).
library_unit_declaration 11.1.1 Compilation Units - Library Units.
used 11.1.1 Compilation Units - Library Units(4), see N. Syntax Summary (informative)(4), see P(1).
library_unit_renaming_declaration 11.1.1 Compilation Units - Library Units.
used 11.1.1 Compilation Units - Library Units(4), see N. Syntax Summary (informative)(4), see P(1).
lifetime 4.10.2 Operations of Access Types.
Light 4.5.1 Enumeration Types.
Limit 4.3.1 Object Declarations(33), see 8.5 Limited Types(33), see 7.5(20).
limited type 8.5 Limited Types(1), see 8.5 Limited Types(3), see M. Glossary (informative)(1), see 8.5 Limited Types(3), see N(23).
becoming nonlimited 8.3.1 Private Operations(5), see 8.5 Limited Types(5), see 7.5(16).
Limited_Controlled 8.6 User-Defined Assignment and Finalization.
line 3.2 Lexical Elements, Separators, and Delimiters(2), see 4.6 Array Types(28), see A.10.1 The Package Text_IO(2), see 4.6 Array Types(28), see A.10.1(38).
line terminator A.10 Text Input-Output.
Line_Length A.10.1 The Package Text_IO.
Line_Size 4.5.4 Integer Types.
Link 4.10.1 Incomplete Type Declarations(15), see 13.5.4 Formal Access Types(15), see 12.5.4(8).
link name B.1 Interfacing Pragmas.
link-time error
See post-compilation error 2.1.2 Structure(29), see 2.1.5 Classification of Errors(29), see 1.1.5(4).
Linker_Options pragma B.1 Interfacing Pragmas(8), see K. Language-Defined Pragmas (informative)(8), see L(19).
linking
See partition building 11.2 Program Execution.
List 8.3 Private Types and Private Extensions.
List pragma 3.8 Pragmas(21), see K. Language-Defined Pragmas (informative)(21), see L(20).
literal 4.9.1 Type Extensions(13), see 5.2 Literals(13), see 4.2(1).
See also aggregate 5.3 Aggregates.
based 3.4.2 Based Literals.
decimal 3.4.1 Decimal Literals.
numeric 3.4 Numeric Literals.
little endian 14.5.3 Bit Ordering.
load time C.4 Preelaboration Requirements.
Local 10.3 Task Dependence - Termination of Tasks.
local to 9.1 Declarative Region.
Local_Coordinate 4.4 Derived Types and Classes.
local_name 14.1 Representation Items.
used 14.2 Pragma Pack(3), 14.3 Representation Attributes(2), 14.4 Enumeration Representation Clauses(3), 14.3 Representation Attributes(2), 13.4(2),
14.5.1 Record Representation Clauses(2), see 14.5.1 Record Representation Clauses(3), see 14.11.3 Pragma Controlled(2), see 14.5.1 Record Representation Clauses(3), see 13.11.3(3),
B.1 Interfacing Pragmas(5), B.1 Interfacing Pragmas(6), B.1 Interfacing Pragmas(5), B.1 Interfacing Pragmas(6), B.1(7),
C.5 Pragma Discard_Names(3), C.6 Shared Variable Control(3), C.6 Shared Variable Control(3), C.6 Shared Variable Control(3), C.6(4),
C.6 Shared Variable Control(5), C.6 Shared Variable Control(6), E.4.1 Pragma Asynchronous(5), C.6 Shared Variable Control(6), E.4.1(3),
K. Language-Defined Pragmas (informative)(3), K. Language-Defined Pragmas (informative)(4), K. Language-Defined Pragmas (informative)(3), K. Language-Defined Pragmas (informative)(4), L(5),
K. Language-Defined Pragmas (informative)(7), K. Language-Defined Pragmas (informative)(8), K. Language-Defined Pragmas (informative)(7), K. Language-Defined Pragmas (informative)(8), L(9),
K. Language-Defined Pragmas (informative)(13), K. Language-Defined Pragmas (informative)(14), K. Language-Defined Pragmas (informative)(13), K. Language-Defined Pragmas (informative)(14), L(24),
K. Language-Defined Pragmas (informative)(38), K. Language-Defined Pragmas (informative)(39), N. Syntax Summary (informative)(38), K. Language-Defined Pragmas (informative)(39), P(1).
localization 4.5.2 Character Types(4), see 4.5.2 Character Types(4), see 3.5.2(5).
Lock D.12 Other Optimizations and Determinism Rules(9), see D.12 Other Optimizations and Determinism Rules(9), see D.12(10).
locking policy D.3 Priority Ceiling Locking.
Locking_Policy pragma D.3 Priority Ceiling Locking(3), see K. Language-Defined Pragmas (informative)(3), see L(21).
Log A.5.1 Elementary Functions(4), see G.1.2 Complex Elementary Functions(4), see G.1.2(3).
Logical B.5 Interfacing with Fortran.
logical operator 5.5.1 Logical Operators and Short-circuit Control Forms.
See also not operator 5.5.6 Highest Precedence Operators.
logical_operator 5.5 Operators and Expression Evaluation.
Long 5.9 Static Expressions and Static Subtypes(43), see B.3 Interfacing with C(43), see B.3(7).
Long_Binary B.4 Interfacing with COBOL.
long_double B.3 Interfacing with C.
Long_Float 4.5.7 Floating Point Types(15), see 4.5.7 Floating Point Types(16), see 4.5.7 Floating Point Types(15), see 4.5.7 Floating Point Types(16), see 3.5.7(17).
Long_Floating B.4 Interfacing with COBOL.
Long_Integer 4.5.4 Integer Types(22), see 4.5.4 Integer Types(25), see 4.5.4 Integer Types(22), see 4.5.4 Integer Types(25), see 3.5.4(28).
Look_Ahead A.10.1 The Package Text_IO.
loop parameter 6.5 Loop Statements.
loop_parameter_specification 6.5 Loop Statements.
used 6.5 Loop Statements(3), see N. Syntax Summary (informative)(3), see P(1).
loop_statement 6.5 Loop Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(5), see N. Syntax Summary (informative)(5), see P(1).
low line 3.1 Character Set.
low-level programming C. Systems Programming (normative).
Low_Limit 4.3.1 Object Declarations.
Low_Line A.3.3 The Package Characters.Latin_1.
Low_Order_First 14.5.3 Bit Ordering(2), see B.4 Interfacing with COBOL(2), see B.4(25).
lower bound
of a range 4.5 Scalar Types.
lower-case letter
a category of Character A.3.2 The Package Characters.Handling.
lower_case_identifier_letter 3.1 Character Set.
Lower_Case_Map A.4.6 String-Handling Sets and Mappings.
Lower_Set A.4.6 String-Handling Sets and Mappings.
|
AA. index
| | Machine attribute A.5.3 Attributes of Floating Point Types(60), see J. Language-Defined Attributes (informative)(60), see K(119).
machine code insertion 14.8 Machine Code Insertions(1), see C.1 Access to Machine Operations(1), see C.1(2).
machine numbers
of a floating point type 4.5.7 Floating Point Types.
Machine_Code I.1 Renamings of Ada 83 Library Units.
child of System 14.8 Machine Code Insertions.
Machine_Emax attribute A.5.3 Attributes of Floating Point Types(8), see J. Language-Defined Attributes (informative)(8), see K(123).
Machine_Emin attribute A.5.3 Attributes of Floating Point Types(7), see J. Language-Defined Attributes (informative)(7), see K(125).
Machine_Mantissa attribute A.5.3 Attributes of Floating Point Types(6), see J. Language-Defined Attributes (informative)(6), see K(127).
Machine_Overflows attribute A.5.3 Attributes of Floating Point Types(12), see A.5.4 Attributes of Fixed Point Types(12), see A.5.4(4),
J. Language-Defined Attributes (informative)(129), J. Language-Defined Attributes (informative)(129), K(131).
Machine_Radix attribute A.5.3 Attributes of Floating Point Types(2), see A.5.4 Attributes of Fixed Point Types(2), see A.5.4(2),
J. Language-Defined Attributes (informative)(133), J. Language-Defined Attributes (informative)(133), K(135).
Machine_Radix clause 14.3 Representation Attributes(7), see F.1 Machine_Radix Attribute Definition Clause(7), see F.1(1).
Machine_Rounds attribute A.5.3 Attributes of Floating Point Types(11), see A.5.4 Attributes of Fixed Point Types(11), see A.5.4(3),
J. Language-Defined Attributes (informative)(137), J. Language-Defined Attributes (informative)(137), K(139).
macro
See generic unit 13. Generic Units.
Macron A.3.3 The Package Characters.Latin_1.
Main 11.1.1 Compilation Units - Library Units(33), see 12.4.2 Example of Exception Handling(10)
main subprogram
for a partition 11.2 Program Execution.
Major 4.5.1 Enumeration Types.
Male 4.2.2 Subtype Declarations.
malloc
See allocator 5.8 Allocators.
Maps
child of Ada.Strings A.4.2 The Package Strings.Maps.
Mark_Release_Pool_Type 14.11 Storage Management.
marshalling E.4 Remote Subprogram Calls.
Masculine_Ordinal_Indicator A.3.3 The Package Characters.Latin_1.
Mask 5.7 Qualified Expressions.
Mass 4.5.7 Floating Point Types(21), see 13.5 Formal Types(21), see 12.5(13).
master 8.6.1 Completion and Finalization.
match
a character to a pattern character A.4.2 The Package Strings.Maps.
a character to a pattern character, with
respect to a character mapping function A.4.2 The Package Strings.Maps.
a string to a pattern string A.4.2 The Package Strings.Maps.
matching components 5.5.2 Relational Operators and Membership Tests.
Matrix 4.6 Array Types.
Matrix_Rec 4.7 Discriminants.
Max 4.3.2 Number Declarations.
Max attribute 4.5 Scalar Types(19), see J. Language-Defined Attributes (informative)(19), see K(141).
Max_Base_Digits 4.5.7 Floating Point Types(6), see 14.7 The Package System(6), see 13.7(8).
named number in package System 14.7 The Package System.
Max_Binary_Modulus 4.5.4 Integer Types(7), see 14.7 The Package System(7), see 13.7(7).
named number in package System 14.7 The Package System.
Max_Decimal_Digits F.2 The Package Decimal.
Max_Delta F.2 The Package Decimal.
Max_Digits 4.5.7 Floating Point Types(6), see 14.7 The Package System(6), see 13.7(8).
named number in package System 14.7 The Package System.
Max_Digits_Binary B.4 Interfacing with COBOL.
Max_Digits_Long_Binary B.4 Interfacing with COBOL.
Max_Image_Width A.5.2 Random Number Generation(13), see A.5.2 Random Number Generation(13), see A.5.2(25).
Max_Int 4.5.4 Integer Types(14), see 14.7 The Package System(14), see 13.7(6).
named number in package System 14.7 The Package System.
Max_Length A.4.4 Bounded-Length String Handling.
Max_Line_Size 4.3.2 Number Declarations.
Max_Mantissa 14.7 The Package System.
named number in package System 14.7 The Package System.
Max_Nonbinary_Modulus 4.5.4 Integer Types(7), see 14.7 The Package System(7), see 13.7(7).
named number in package System 14.7 The Package System.
Max_Scale F.2 The Package Decimal.
Max_Size_In_Storage_Elements attribute 14.11.1 The Max_Size_In_Storage_Elements Attribute,
J. Language-Defined Attributes (informative).
maximum box error
for a component of the result of evaluating
a complex function G.2.6 Accuracy Requirements for Complex Arithmetic.
maximum line length A.10 Text Input-Output.
maximum page length A.10 Text Input-Output.
maximum relative error
for a component of the result of evaluating
a complex function G.2.6 Accuracy Requirements for Complex Arithmetic.
for the evaluation of an elementary function G.2.4 Accuracy Requirements for the Elementary Functions.
Medium 14.3 Representation Attributes.
Mega 5.9 Static Expressions and Static Subtypes.
Membership A.4.1 The Package Strings.
membership test 5.5.2 Relational Operators and Membership Tests.
Memory_Size 14.7 The Package System.
mentioned in a with_clause 11.1.2 Context Clauses - With Clauses.
message
See dispatching call 4.9.2 Dispatching Operations of Tagged Types.
Message_Procedure 4.10 Access Types.
method
See dispatching subprogram 4.9.2 Dispatching Operations of Tagged Types.
metrics 2.1.2 Structure(35), see C.3.1 Protected Procedure Handlers(15), see C.7.2 The Package Task_Attributes(35), see C.3.1 Protected Procedure Handlers(15), see C.7.2(20),
D. Real-Time Systems (normative)(2), D.5 Dynamic Priorities(13), D.6 Preemptive Abort(2), D.5 Dynamic Priorities(13), D.6(4),
D.8 Monotonic Time(37), D.9 Delay Accuracy(9), D.12 Other Optimizations and Determinism Rules(37), D.9 Delay Accuracy(9), D.12(6).
Micro_Sign A.3.3 The Package Characters.Latin_1.
Microseconds D.8 Monotonic Time.
Middle_Dot A.3.3 The Package Characters.Latin_1.
Midweek 4.4 Derived Types and Classes.
Milliseconds D.8 Monotonic Time.
Min attribute 4.5 Scalar Types(16), see J. Language-Defined Attributes (informative)(16), see K(147).
Min_Cell 7.1 Subprogram Declarations.
Min_Delta F.2 The Package Decimal.
Min_Int 4.5.4 Integer Types(14), see 14.7 The Package System(14), see 13.7(6).
named number in package System 14.7 The Package System.
Min_Scale F.2 The Package Decimal.
Minimum 9.5.4 Subprogram Renaming Declarations.
minus 3.1 Character Set.
minus operator 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 4.5.4(1).
Mix 13.5.3 Formal Array Types.
Mix_Code 14.4 Enumeration Representation Clauses.
Mixed 4.5.1 Enumeration Types.
mixed-language programs B. Interface to Other Languages (normative)(1), see C.1 Access to Machine Operations(1), see C.1(4).
mod operator 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
mod_clause I.8 Mod Clauses.
used 14.5.1 Record Representation Clauses(2), see N. Syntax Summary (informative)(2), see P(1).
mode 7.1 Subprogram Declarations(16), 9.5 Renaming Declarations(7), 14.5.1 Record Representation Clauses(16), 9.5 Renaming Declarations(7), 13.5.1(26),
A.8.1 The Generic Package Sequential_IO(9), A.8.4 The Generic Package Direct_IO(9), see A.10.1 The Package Text_IO(9), A.8.4 The Generic Package Direct_IO(9), see A.10.1(12),
A.12.1 The Package Streams.Stream_IO.
used 7.1 Subprogram Declarations(15), see 13.4 Formal Objects(2), see N. Syntax Summary (informative)(15), see 13.4 Formal Objects(2), see P(1).
mode conformance 7.3.1 Conformance Rules.
required 9.5.4 Subprogram Renaming Declarations(4), see 13.5.4 Formal Access Types(5), see 13.6 Formal Subprograms(4), see 13.5.4 Formal Access Types(5), see 12.6(7),
13.6 Formal Subprograms.
mode of operation
nonstandard 2.1.5 Classification of Errors.
standard 2.1.5 Classification of Errors.
Mode_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1 The Package Text_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1(85),
A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(26), see A.13(4).
Mode_Mask 14.5.1 Record Representation Clauses.
Model attribute A.5.3 Attributes of Floating Point Types(68), see G.2.2 Model-Oriented Attributes of Floating Point Types(7), see J. Language-Defined Attributes (informative)(68), see G.2.2 Model-Oriented Attributes of Floating Point Types(7), see K(151).
model interval G.2.1 Model of Floating Point Arithmetic.
associated with a value G.2.1 Model of Floating Point Arithmetic.
model number G.2.1 Model of Floating Point Arithmetic.
model-oriented attributes
of a floating point subtype A.5.3 Attributes of Floating Point Types.
Model_Emin attribute A.5.3 Attributes of Floating Point Types(65), see G.2.2 Model-Oriented Attributes of Floating Point Types(65), see G.2.2(4),
J. Language-Defined Attributes (informative).
Model_Epsilon attribute A.5.3 Attributes of Floating Point Types(66), see J. Language-Defined Attributes (informative)(66), see K(157).
Model_Mantissa attribute A.5.3 Attributes of Floating Point Types(64), see G.2.2 Model-Oriented Attributes of Floating Point Types(64), see G.2.2(3),
J. Language-Defined Attributes (informative).
Model_Small attribute A.5.3 Attributes of Floating Point Types(67), see J. Language-Defined Attributes (informative)(67), see K(161).
modular type 4.5.4 Integer Types.
modular_type_definition 4.5.4 Integer Types.
used 4.5.4 Integer Types(2), see N. Syntax Summary (informative)(2), see P(1).
Modular_IO A.10.1 The Package Text_IO.
module
See package 8. Packages.
modulus G.1.1 Complex Types.
of a modular type 4.5.4 Integer Types.
Modulus attribute 4.5.4 Integer Types(17), see J. Language-Defined Attributes (informative)(17), see K(163).
Money 4.5.9 Fixed Point Types(28), see F.1 Machine_Radix Attribute Definition Clause(28), see F.1(4).
Month 10.6 Delay Statements, Duration, and Time.
Month_Number 10.6 Delay Statements, Duration, and Time.
Move A.4.3 Fixed-Length String Handling.
multi-dimensional array 4.6 Array Types.
Multiplication_Sign A.3.3 The Package Characters.Latin_1.
multiply 3.1 Character Set.
multiply operator 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
multiplying operator 5.5.5 Multiplying Operators.
multiplying_operator 5.5 Operators and Expression Evaluation.
used 5.4 Expressions(5), see N. Syntax Summary (informative)(5), see P(1).
MW A.3.3 The Package Characters.Latin_1.
My_Read 14.3 Representation Attributes.
My_Write 9.5.4 Subprogram Renaming Declarations(14), see 14.13.2 Stream-Oriented Attributes(14), see 13.13.2(40).
|
AB. index
| | n-dimensional array_aggregate 5.3.3 Array Aggregates.
NAK A.3.3 The Package Characters.Latin_1.
name 5.1 Names(2), 14.7 The Package System(4), 14.11.2 Unchecked Storage Deallocation(2), 14.7 The Package System(4), 13.11.2(3),
A.8.1 The Generic Package Sequential_IO(9), see A.8.4 The Generic Package Direct_IO(9), see A.10.1 The Package Text_IO(9), see A.8.4 The Generic Package Direct_IO(9), see A.10.1(12),
A.12.1 The Package Streams.Stream_IO.
used 3.8 Pragmas(3), 4.2.2 Subtype Declarations(4), 5.1 Names(3), 4.2.2 Subtype Declarations(4), 4.1(4),
5.1 Names(5), 5.1 Names(6), 5.4 Expressions(5), 5.1 Names(6), 4.4(7),
5.6 Type Conversions(2), 6.2 Assignment Statements(2), 6.7 Exit Statements(2), 6.2 Assignment Statements(2), 5.7(2),
6.8 Goto Statements(2), 7.3.2 Inline Expansion of Subprograms(3), 7.4 Subprogram Calls(2), 7.3.2 Inline Expansion of Subprograms(3), 6.4(2),
7.4 Subprogram Calls(3), 7.4 Subprogram Calls(6), 9.4 Use Clauses(3), 7.4 Subprogram Calls(6), 8.4(3),
9.5.1 Object Renaming Declarations(2), 9.5.2 Exception Renaming Declarations(2), 9.5.3 Package Renaming Declarations(2), 9.5.2 Exception Renaming Declarations(2), 8.5.3(2),
9.5.4 Subprogram Renaming Declarations(2), 9.5.5 Generic Renaming Declarations(2), 10.5.3 Entry Calls(2), 9.5.5 Generic Renaming Declarations(2), 9.5.3(2),
10.5.4 Requeue Statements(2), 10.8 Abort of a Task - Abort of a Sequence of Statements(2), 11.1.1 Compilation Units - Library Units(2), 10.8 Abort of a Task - Abort of a Sequence of Statements(2), 10.1.1(8),
11.1.2 Context Clauses - With Clauses(4), 11.2.1 Elaboration Control(3), 11.2.1 Elaboration Control(4), 11.2.1 Elaboration Control(3), 10.2.1(14),
11.2.1 Elaboration Control(20), see 11.2.1 Elaboration Control(21), see 11.2.1 Elaboration Control(20), see 11.2.1 Elaboration Control(21), see 10.2.1(22),
12.2 Exception Handlers(5), 12.3 Raise Statements(2), 12.5 Suppressing Checks(5), 12.3 Raise Statements(2), 11.5(4),
13.3 Generic Instantiation(2), 13.3 Generic Instantiation(5), 13.6 Formal Subprograms(2), 13.3 Generic Instantiation(5), 12.6(4),
13.7 Formal Packages(2), 14.1 Representation Items(3), 14.3 Representation Attributes(2), 14.1 Representation Items(3), 13.3(2),
C.3.1 Protected Procedure Handlers(2), C.3.1 Protected Procedure Handlers(4), E.2.1 Shared Passive Library Units(2), C.3.1 Protected Procedure Handlers(4), E.2.1(3),
E.2.2 Remote Types Library Units(3), E.2.3 Remote Call Interface Library Units(3), E.2.3 Remote Call Interface Library Units(3), E.2.3 Remote Call Interface Library Units(3), E.2.3(5),
H.3.2 Pragma Inspection_Point(3), K. Language-Defined Pragmas (informative)(2), K. Language-Defined Pragmas (informative)(3), K. Language-Defined Pragmas (informative)(2), L(6),
K. Language-Defined Pragmas (informative)(10), K. Language-Defined Pragmas (informative)(11), K. Language-Defined Pragmas (informative)(10), K. Language-Defined Pragmas (informative)(11), L(12),
K. Language-Defined Pragmas (informative)(15), K. Language-Defined Pragmas (informative)(16), K. Language-Defined Pragmas (informative)(15), K. Language-Defined Pragmas (informative)(16), L(17),
K. Language-Defined Pragmas (informative)(26), K. Language-Defined Pragmas (informative)(28), K. Language-Defined Pragmas (informative)(26), K. Language-Defined Pragmas (informative)(28), L(30),
K. Language-Defined Pragmas (informative)(31), K. Language-Defined Pragmas (informative)(34), K. Language-Defined Pragmas (informative)(31), K. Language-Defined Pragmas (informative)(34), L(36),
N. Syntax Summary (informative).
[partial] 4.1 Declarations.
of (a view of) an entity 4.1 Declarations.
of a pragma 3.8 Pragmas.
of an external file A.7 External Files and File Objects.
name resolution rules 2.1.2 Structure.
Name_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1 The Package Text_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1(85),
A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(26), see A.13(4).
Name_Server E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
named association 7.4 Subprogram Calls(7), see 13.3 Generic Instantiation(7), see 12.3(6).
named component association 5.3.1 Record Aggregates.
named discriminant association 4.7.1 Discriminant Constraints.
named entry index 10.5.2 Entries and Accept Statements.
named number 4.3 Objects and Named Numbers.
named type 4.2.1 Type Declarations.
named_array_aggregate 5.3.3 Array Aggregates.
used 5.3.3 Array Aggregates(2), see N. Syntax Summary (informative)(2), see P(1).
Names
child of Ada.Interrupts C.3.2 The Package Interrupts.
names of special_characters 3.1 Character Set.
Nanoseconds D.8 Monotonic Time.
Native_Binary B.4 Interfacing with COBOL.
Natural 4.5.4 Integer Types(12), see 4.5.4 Integer Types(13), see A.1 The Package Standard(12), see 4.5.4 Integer Types(13), see A.1(13).
NBH A.3.3 The Package Characters.Latin_1.
needed
of a compilation unit by another 11.2 Program Execution.
remote call interface E.2.3 Remote Call Interface Library Units.
shared passive library unit E.2.1 Shared Passive Library Units.
needed component
extension_aggregate record_component_association_list
5.3.2 Extension Aggregates.
record_aggregate record_component_association_list
5.3.1 Record Aggregates.
NEL A.3.3 The Package Characters.Latin_1.
new
See allocator 5.8 Allocators.
New_Char_Array B.3.1 The Package Interfaces.C.Strings.
New_Line A.10.1 The Package Text_IO.
New_Page A.10.1 The Package Text_IO.
New_String B.3.1 The Package Interfaces.C.Strings.
New_Tape E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
Next 9.5.4 Subprogram Renaming Declarations.
Next_Action 10.1 Task Units and Task Objects.
Next_Frame 7.1 Subprogram Declarations.
Next_Lexeme 10.1 Task Units and Task Objects.
Next_Work_Item 10.1 Task Units and Task Objects.
Ninety_Six 4.6.3 String Types.
No_Break_Space A.3.3 The Package Characters.Latin_1.
Node 13.5.4 Formal Access Types.
nominal subtype 4.3 Objects and Named Numbers(23), see 4.3.1 Object Declarations(23), see 3.3.1(8).
associated with a type_conversion 5.6 Type Conversions.
associated with a dereference 5.1 Names.
associated with an indexed_component 5.1.1 Indexed Components.
of a component 4.6 Array Types.
of a formal parameter 7.1 Subprogram Declarations.
of a generic formal object 13.4 Formal Objects.
of a record component 4.8 Record Types.
of the result of a function_call 7.4 Subprogram Calls.
non-normative
See informative 2.1.2 Structure.
nondispatching call
on a dispatching operation 4.9.2 Dispatching Operations of Tagged Types.
nonexistent 14.11.2 Unchecked Storage Deallocation(10), see 14.11.2 Unchecked Storage Deallocation(10), see 13.11.2(16).
nongraphic character 4.5 Scalar Types.
nonlimited type 8.5 Limited Types.
becoming nonlimited 8.3.1 Private Operations(5), see 8.5 Limited Types(5), see 7.5(16).
nonstandard integer type 4.5.4 Integer Types.
nonstandard mode 2.1.5 Classification of Errors.
nonstandard real type 4.5.6 Real Types.
normal completion 8.6.1 Completion and Finalization.
normal library unit E.2 Categorization of Library Units.
normal state of an object 12.6 Exceptions and Optimization(6), see 14.9.1 Data Validity(6), see 13.9.1(4).
[partial] 10.8 Abort of a Task - Abort of a Sequence of Statements(21), see A.13 Exceptions in Input-Output(21), see A.13(17).
Normalize_Scalars pragma H.1 Pragma Normalize_Scalars(3), see K. Language-Defined Pragmas (informative)(3), see L(22).
normalized exponent A.5.3 Attributes of Floating Point Types.
normalized number A.5.3 Attributes of Floating Point Types.
normative 2.1.2 Structure.
not equal operator 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
not in (membership test) 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(2).
not operator 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(3).
Not_Sign A.3.3 The Package Characters.Latin_1.
notes 2.1.2 Structure.
notwithstanding 11.1.6 Environment-Level Visibility Rules(2), see B.1 Interfacing Pragmas(22), see B.1 Interfacing Pragmas(2), see B.1 Interfacing Pragmas(22), see B.1(38),
C.3.1 Protected Procedure Handlers(19), see E.2.1 Shared Passive Library Units(19), see E.2.1(8),
E.2.1 Shared Passive Library Units(11), see E.2.3 Remote Call Interface Library Units(18), see I.3 Reduced Accuracy Subtypes(11), see E.2.3 Remote Call Interface Library Units(18), see J.3(6).
NUL A.3.3 The Package Characters.Latin_1(5), see B.3 Interfacing with C(20), see I.5 ASCII(5), see B.3 Interfacing with C(20), see J.5(4).
null access value 5.2 Literals.
null array 4.6.1 Index Constraints and Discrete Ranges.
null constraint 4.2 Types and Subtypes.
null pointer
See null access value 5.2 Literals.
null range 4.5 Scalar Types.
null record 4.8 Record Types.
null slice 5.1.2 Slices.
null string literal 3.6 String Literals.
null value
of an access type 4.10 Access Types.
Null_Address 14.7 The Package System.
constant in System 14.7 The Package System.
Null_Bounded_String A.4.4 Bounded-Length String Handling.
Null_Key 8.3.1 Private Operations(15), see 8.4 Deferred Constants(15), see 7.4(13).
Null_Occurrence 12.4.1 The Package Exceptions.
Null_Ptr B.3.1 The Package Interfaces.C.Strings.
Null_Set A.4.2 The Package Strings.Maps(5), see A.4.7 Wide_String Handling(5), see A.4.7(5).
null_statement 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
Null_Task_ID C.7.1 The Package Task_Identification.
Null_Unbounded_String A.4.5 Unbounded-Length String Handling.
Null_Id 12.4.1 The Package Exceptions.
Num A.10.1 The Package Text_IO(52), see A.10.1 The Package Text_IO(57), see A.10.1 The Package Text_IO(52), see A.10.1 The Package Text_IO(57), see A.10.1(63),
A.10.1 The Package Text_IO(68), see A.10.1 The Package Text_IO(73), see B.4 Interfacing with COBOL(68), see A.10.1 The Package Text_IO(73), see B.4(31),
F.3.3 The Package Text_IO.Editing.
number sign 3.1 Character Set.
Number_Base A.10.1 The Package Text_IO(6), see A.10.8 Input-Output for Integer Types(6), see A.10.8(3).
number_declaration 4.3.2 Number Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
Number_Sign A.3.3 The Package Characters.Latin_1.
numeral 3.4.1 Decimal Literals.
used 3.4.1 Decimal Literals(2), see 3.4.1 Decimal Literals(4), see 3.4.2 Based Literals(2), see 3.4.1 Decimal Literals(4), see 2.4.2(3),
N. Syntax Summary (informative).
Numeric B.4 Interfacing with COBOL.
numeric type 4.5 Scalar Types.
Numeric_Error I.6 Numeric_Error.
numeric_literal 3.4 Numeric Literals.
used 5.4 Expressions(7), see N. Syntax Summary (informative)(7), see P(1).
Numerics G. Numerics (normative).
child of Ada A.5 The Numerics Packages.
|
AC. index
| | object 4.3 Objects and Named Numbers(2), see 14.7.2 The Package System.Address_To_Access_Conversions(2), see 14.11.2 Unchecked Storage Deallocation(2), see 14.7.2 The Package System.Address_To_Access_Conversions(2), see 13.11.2(3),
M. Glossary (informative).
[partial] 4.2 Types and Subtypes.
object-oriented programming (OOP)
See dispatching operations of tagged types 4.9.2 Dispatching Operations of Tagged Types.
See tagged types and type extensions 4.9 Tagged Types and Type Extensions.
object_declaration 4.3.1 Object Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
Object_Pointer 14.7.2 The Package System.Address_To_Access_Conversions.
object_renaming_declaration 9.5.1 Object Renaming Declarations.
used 9.5 Renaming Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
obsolescent feature I. Obsolescent Features (normative).
occur immediately within 9.1 Declarative Region(13)
occurrence
of an interrupt C.3 Interrupt Support.
octal
literal 3.4.2 Based Literals.
octal literal 3.4.2 Based Literals.
On_Stacks 13.8 Example of a Generic Package.
On_Vectors 13.1 Generic Declarations(24), see 13.2 Generic Bodies(24), see 12.2(9).
one's complement
modular types 4.5.4 Integer Types.
one-dimensional array 4.6 Array Types.
only as a completion
entry_body 10.5.2 Entries and Accept Statements.
OOP (object-oriented programming)
See dispatching operations of tagged types 4.9.2 Dispatching Operations of Tagged Types.
See tagged types and type extensions 4.9 Tagged Types and Type Extensions.
opaque type
See private types and private extensions 8.3 Private Types and Private Extensions.
Open 8.5 Limited Types(19), 8.5 Limited Types(20), 12.4.2 Example of Exception Handling(19), 8.5 Limited Types(20), 11.4.2(3),
12.4.2 Example of Exception Handling(6), A.8.1 The Generic Package Sequential_IO(7), see A.8.4 The Generic Package Direct_IO(6), A.8.1 The Generic Package Sequential_IO(7), see A.8.4(7),
A.10.1 The Package Text_IO(10), see A.12.1 The Package Streams.Stream_IO(10), see A.12.1(9).
open alternative 10.7.1 Selective Accept.
open entry 10.5.3 Entry Calls.
of a protected object 10.5.3 Entry Calls.
of a task 10.5.3 Entry Calls.
operand
of a type_conversion 5.6 Type Conversions.
of a qualified_expression 5.7 Qualified Expressions.
operand interval G.2.1 Model of Floating Point Arithmetic.
operand type
of a type_conversion 5.6 Type Conversions.
operates on a type 4.2.3 Classification of Operations.
operator 7.6 Overloading of Operators.
& 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 4.5.3(3).
* 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
** 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(7).
+ 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 4.5.4(1).
= 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
- 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 4.5.4(1).
/ 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
/= 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
< 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
<= 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
> 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
>= 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
abs 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(1).
ampersand 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(3)
and 5.4 Expressions(1), see 5.5.1 Logical Operators and Short-circuit Control Forms(2)
binary 5.5 Operators and Expression Evaluation.
binary adding 5.5.3 Binary Adding Operators.
concatenation 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 4.5.3(3).
divide 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
equal 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
equality 5.5.2 Relational Operators and Membership Tests.
exponentiation 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(7).
greater than 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
greater than or equal 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
highest precedence 5.5.6 Highest Precedence Operators.
less than 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
less than or equal 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
logical 5.5.1 Logical Operators and Short-circuit Control Forms.
minus 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 4.5.4(1).
mod 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
multiply 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
multiplying 5.5.5 Multiplying Operators.
not 5.4 Expressions(1), see 5.5.6 Highest Precedence Operators(1), see 4.5.6(3).
not equal 5.4 Expressions(1), see 5.5.2 Relational Operators and Membership Tests(1), see 4.5.2(1).
or 5.4 Expressions(1), see 5.5.1 Logical Operators and Short-circuit Control Forms(1), see 4.5.1(2).
ordering 5.5.2 Relational Operators and Membership Tests.
plus 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 4.5.4(1).
predefined 5.5 Operators and Expression Evaluation.
relational 5.5.2 Relational Operators and Membership Tests.
rem 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
times 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
unary 5.5 Operators and Expression Evaluation.
unary adding 5.5.4 Unary Adding Operators.
user-defined 7.6 Overloading of Operators.
xor 5.4 Expressions(1), see 5.5.1 Logical Operators and Short-circuit Control Forms(1), see 4.5.1(2).
operator precedence 5.5 Operators and Expression Evaluation.
operator_symbol 7.1 Subprogram Declarations.
used 5.1 Names(3), 5.1.3 Selected Components(3), see 7.1 Subprogram Declarations(3), 5.1.3 Selected Components(3), see 6.1(5),
7.1 Subprogram Declarations(11), see N. Syntax Summary (informative)(11), see P(1).
optimization 12.5 Suppressing Checks(29), see 12.6 Exceptions and Optimization(29), see 11.6(1).
Optimize pragma 3.8 Pragmas(23), see K. Language-Defined Pragmas (informative)(23), see L(23).
Option 13.5.3 Formal Array Types.
or else (short-circuit control form) 5.4 Expressions,
5.5.1 Logical Operators and Short-circuit Control Forms.
or operator 5.4 Expressions(1), see 5.5.1 Logical Operators and Short-circuit Control Forms(1), see 4.5.1(2).
ordering operator 5.5.2 Relational Operators and Membership Tests.
ordinary fixed point type 4.5.9 Fixed Point Types(1), see 4.5.9 Fixed Point Types(1), see 3.5.9(8).
ordinary_fixed_point_definition 4.5.9 Fixed Point Types.
used 4.5.9 Fixed Point Types(2), see N. Syntax Summary (informative)(2), see P(1).
Origin 4.9.1 Type Extensions(12)
OSC A.3.3 The Package Characters.Latin_1.
other_control_function 3.1 Character Set.
used 3.1 Character Set(2), see N. Syntax Summary (informative)(2), see P(1).
Other_Procedure 4.10 Access Types.
output A.6 Input-Output.
Output attribute 14.13.2 Stream-Oriented Attributes(19), see 14.13.2 Stream-Oriented Attributes(19), see 13.13.2(29),
J. Language-Defined Attributes (informative)(165), J. Language-Defined Attributes (informative)(165), K(169).
Output clause 14.3 Representation Attributes(7), see 14.13.2 Stream-Oriented Attributes(7), see 13.13.2(36).
overall interpretation
of a complete context 9.6 The Context of Overload Resolution.
Overflow_Check 12.5 Suppressing Checks.
[partial] 4.5.4 Integer Types(20), see 5.4 Expressions(11), 6.4 Case Statements(20), see 5.4 Expressions(11), 5.4(13),
G.2.1 Model of Floating Point Arithmetic(11), see G.2.2 Model-Oriented Attributes of Floating Point Types(7), see G.2.3 Model of Fixed Point Arithmetic(11), see G.2.2 Model-Oriented Attributes of Floating Point Types(7), see G.2.3(25),
G.2.4 Accuracy Requirements for the Elementary Functions(2), G.2.6 Accuracy Requirements for Complex Arithmetic(2), G.2.6(3).
overload resolution 9.6 The Context of Overload Resolution.
overloadable 9.3 Visibility.
overloaded 9.3 Visibility.
enumeration literal 4.5.1 Enumeration Types.
overloading rules 2.1.2 Structure(26), see 9.6 The Context of Overload Resolution(26), see 8.6(2).
override 9.3 Visibility(9), see 13.3 Generic Instantiation(9), see 12.3(17).
a primitive subprogram 4.2.3 Classification of Operations.
Overwrite A.4.3 Fixed-Length String Handling(27), see A.4.3 Fixed-Length String Handling(28), see A.4.4 Bounded-Length String Handling(27), see A.4.3 Fixed-Length String Handling(28), see A.4.4(62),
A.4.4 Bounded-Length String Handling(63), see A.4.5 Unbounded-Length String Handling(57), see A.4.5 Unbounded-Length String Handling(63), see A.4.5 Unbounded-Length String Handling(57), see A.4.5(58).
|
AD. index
| | P 10.2 Task Execution - Task Activation(11), see 13.5.3 Formal Array Types(11), see 13.5.4 Formal Access Types(11), see 13.5.3 Formal Array Types(11), see 12.5.4(8).
Pack pragma 14.2 Pragma Pack(3), see K. Language-Defined Pragmas (informative)(3), see L(24).
Package 8. Packages(1), see M. Glossary (informative)(1), see N(25).
package instance 13.3 Generic Instantiation.
package_body 8.2 Package Bodies.
used 4.11 Declarative Parts(6), see 11.1.1 Compilation Units - Library Units(7), see N. Syntax Summary (informative)(6), see 11.1.1 Compilation Units - Library Units(7), see P(1).
package_body_stub 11.1.3 Subunits of Compilation Units.
used 11.1.3 Subunits of Compilation Units(2), see N. Syntax Summary (informative)(2), see P(1).
package_declaration 8.1 Package Specifications and Declarations.
used 4.1 Declarations(3), see 11.1.1 Compilation Units - Library Units(5), see N. Syntax Summary (informative)(3), see 11.1.1 Compilation Units - Library Units(5), see P(1).
package_renaming_declaration 9.5.3 Package Renaming Declarations.
used 9.5 Renaming Declarations(2), see 11.1.1 Compilation Units - Library Units(6), see N. Syntax Summary (informative)(2), see 11.1.1 Compilation Units - Library Units(6), see P(1).
package_specification 8.1 Package Specifications and Declarations.
used 8.1 Package Specifications and Declarations(2), see 13.1 Generic Declarations(4), see N. Syntax Summary (informative)(2), see 13.1 Generic Declarations(4), see P(1).
packed 14.2 Pragma Pack.
Packed_Decimal B.4 Interfacing with COBOL.
Packed_Descriptor 14.6 Change of Representation.
Packed_Format B.4 Interfacing with COBOL.
Packed_Signed B.4 Interfacing with COBOL.
Packed_Unsigned B.4 Interfacing with COBOL.
packing
aspect of representation 14.2 Pragma Pack.
padding bits 14.1 Representation Items.
Page 14.3 Representation Attributes(80), see A.10.1 The Package Text_IO(80), see A.10.1(39).
Page pragma 3.8 Pragmas(22), see K. Language-Defined Pragmas (informative)(22), see L(25).
page terminator A.10 Text Input-Output.
Page_Length A.10.1 The Package Text_IO.
Page_Num 4.5.4 Integer Types.
Painted_Point 4.9.1 Type Extensions.
Pair 7.4 Subprogram Calls.
parallel processing
See task 10. Tasks and Synchronization.
Parallel_Simulation A.5.2 Random Number Generation.
parameter
See also discriminant 4.7 Discriminants.
See also loop parameter 6.5 Loop Statements.
See formal parameter 7.1 Subprogram Declarations.
See generic formal parameter 13. Generic Units.
parameter assigning back 7.4.1 Parameter Associations.
parameter copy back 7.4.1 Parameter Associations.
parameter mode 7.1 Subprogram Declarations.
parameter passing 7.4.1 Parameter Associations.
parameter_and_result_profile 7.1 Subprogram Declarations.
used 4.10 Access Types(5), see 7.1 Subprogram Declarations(4), see N. Syntax Summary (informative)(5), see 7.1 Subprogram Declarations(4), see P(1).
parameter_association 7.4 Subprogram Calls.
used 7.4 Subprogram Calls(4), see N. Syntax Summary (informative)(4), see P(1).
parameter_profile 7.1 Subprogram Declarations.
used 4.10 Access Types(5), 7.1 Subprogram Declarations(4), 10.5.2 Entries and Accept Statements(5), 7.1 Subprogram Declarations(4), 9.5.2(2),
10.5.2 Entries and Accept Statements(3), see 10.5.2 Entries and Accept Statements(6), see N. Syntax Summary (informative)(3), see 10.5.2 Entries and Accept Statements(6), see P(1).
parameter_specification 7.1 Subprogram Declarations.
used 7.1 Subprogram Declarations(14), see N. Syntax Summary (informative)(14), see P(1).
Parameterless_Handler C.3.2 The Package Interrupts.
Params_Stream_Type E.5 Partition Communication Subsystem.
Parent 11.1.3 Subunits of Compilation Units(20), see 11.1.3 Subunits of Compilation Units(21), see 11.1.3 Subunits of Compilation Units(20), see 11.1.3 Subunits of Compilation Units(21), see 10.1.3(23).
parent body
of a subunit 11.1.3 Subunits of Compilation Units.
parent declaration
of a library_item 11.1.1 Compilation Units - Library Units.
of a library unit 11.1.1 Compilation Units - Library Units.
parent subtype 4.4 Derived Types and Classes.
parent type 4.4 Derived Types and Classes.
parent unit
of a library unit 11.1.1 Compilation Units - Library Units.
parent_unit_name 11.1.1 Compilation Units - Library Units.
used 7.1 Subprogram Declarations(5), see 7.1 Subprogram Declarations(7), 8.1 Package Specifications and Declarations(5), see 7.1 Subprogram Declarations(7), 7.1(3),
8.2 Package Bodies(2), see 11.1.3 Subunits of Compilation Units(7), see N. Syntax Summary (informative)(2), see 11.1.3 Subunits of Compilation Units(7), see P(1).
Parser 10.1 Task Units and Task Objects.
part
of an object or value 4.2 Types and Subtypes.
partial view
of a type 8.3 Private Types and Private Extensions.
partition 11.2 Program Execution(2), see M. Glossary (informative)(2), see N(26).
partition building 11.2 Program Execution.
partition communication subsystem (PCS) E.5 Partition Communication Subsystem.
Partition_Check
[partial] E.4 Remote Subprogram Calls.
Partition_ID E.5 Partition Communication Subsystem.
Partition_ID attribute E.1 Partitions(9), see J. Language-Defined Attributes (informative)(9), see K(173).
pass by copy 7.2 Formal Parameter Modes.
pass by reference 7.2 Formal Parameter Modes.
passive partition E.1 Partitions.
PCS (partition communication subsystem) E.5 Partition Communication Subsystem.
pending interrupt occurrence C.3 Interrupt Support.
per-object constraint 4.8 Record Types.
per-object expression 4.8 Record Types.
Percent I.5 ASCII.
Percent_Sign A.3.3 The Package Characters.Latin_1.
perfect result set G.2.3 Model of Fixed Point Arithmetic.
periodic task
See delay_until_statement 10.6 Delay Statements, Duration, and Time.
example 10.6 Delay Statements, Duration, and Time.
Peripheral 4.8.1 Variant Parts and Discrete Choices.
Peripheral_Ref 4.10 Access Types.
Person 4.10.1 Incomplete Type Declarations(19), see 4.10.1 Incomplete Type Declarations(19), see 3.10.1(22).
Person_Name 4.10.1 Incomplete Type Declarations.
Pi A.5 The Numerics Packages.
Pic_String F.3.3 The Package Text_IO.Editing.
Picture F.3.3 The Package Text_IO.Editing.
picture String
for edited output F.3.1 Picture String Formation.
Picture_Error F.3.3 The Package Text_IO.Editing.
Pilcrow_Sign A.3.3 The Package Characters.Latin_1.
plain_char B.3 Interfacing with C.
PLD A.3.3 The Package Characters.Latin_1.
PLU A.3.3 The Package Characters.Latin_1.
plus operator 5.4 Expressions(1), see 5.5.3 Binary Adding Operators(1), see 5.5.4 Unary Adding Operators(1), see 5.5.3 Binary Adding Operators(1), see 4.5.4(1).
plus sign 3.1 Character Set.
Plus_Minus_Sign A.3.3 The Package Characters.Latin_1.
Plus_Sign A.3.3 The Package Characters.Latin_1.
PM A.3.3 The Package Characters.Latin_1.
point 2. General(2.15), see 4.9 Tagged Types and Type Extensions(2.15), see 3.9(32).
pointer B.3.2 The Generic Package Interfaces.C.Pointers.
See access value 4.10 Access Types.
See type System.Address 14.7 The Package System.
pointer type
See access type 4.10 Access Types.
Pointer_Error B.3.2 The Generic Package Interfaces.C.Pointers.
Pointers
child of Interfaces.C B.3.2 The Generic Package Interfaces.C.Pointers.
polymorphism 4.9 Tagged Types and Type Extensions(1), see 4.9.2 Dispatching Operations of Tagged Types(1), see 3.9.2(1).
pool element 4.10 Access Types(7), see 14.11 Storage Management(7), see 13.11(11).
pool type 14.11 Storage Management.
pool-specific access type 4.10 Access Types(7), see 4.10 Access Types(7), see 3.10(8).
Pop 13.8 Example of a Generic Package(3), see 13.8 Example of a Generic Package(7), see 13.8 Example of a Generic Package(3), see 13.8 Example of a Generic Package(7), see 12.8(14).
Pos attribute 4.5.5 Operations of Discrete Types(2), see J. Language-Defined Attributes (informative)(2), see K(175).
position 14.5.1 Record Representation Clauses.
used 14.5.1 Record Representation Clauses(3), see N. Syntax Summary (informative)(3), see P(1).
Position attribute 14.5.2 Storage Place Attributes(2), see J. Language-Defined Attributes (informative)(2), see K(179).
position number 4.5 Scalar Types.
of an enumeration value 4.5.1 Enumeration Types.
of an integer value 4.5.4 Integer Types.
positional association 7.4 Subprogram Calls(7), see 13.3 Generic Instantiation(7), see 12.3(6).
positional component association 5.3.1 Record Aggregates.
positional discriminant association 4.7.1 Discriminant Constraints.
positional_array_aggregate 5.3.3 Array Aggregates.
used 5.3.3 Array Aggregates(2), see N. Syntax Summary (informative)(2), see P(1).
Positive 4.5.4 Integer Types(12), see 4.5.4 Integer Types(13), see 4.6.3 String Types(12), see 4.5.4 Integer Types(13), see 3.6.3(3),
A.1 The Package Standard.
Positive_Count A.8.4 The Generic Package Direct_IO(4), A.10 Text Input-Output(4), A.10(10),
A.10.1 The Package Text_IO(5), see A.12.1 The Package Streams.Stream_IO(5), see A.12.1(7).
possible interpretation 9.6 The Context of Overload Resolution.
for direct_names 9.3 Visibility.
for selector_names 9.3 Visibility.
post-compilation error 2.1.2 Structure.
post-compilation rules 2.1.2 Structure(29), see 11.1.3 Subunits of Compilation Units(29), see 10.1.3(15),
11.1.5 Pragmas and Program Units(8), see 11.2 Program Execution(8), see 10.2(2),
13.3 Generic Instantiation(19), 14.12 Pragma Restrictions(19), 13.12(8),
D.2.2 The Standard Task Dispatching Policy(4), D.3 Priority Ceiling Locking(4), D.3(5),
D.4 Entry Queuing Policies(5), E. Distributed Systems (normative)(5), E(2),
E.1 Partitions(2), E.2.1 Shared Passive Library Units(2), E.2.1(10),
E.2.3 Remote Call Interface Library Units(17), see H.1 Pragma Normalize_Scalars(17), see H.1(4),
H.3.1 Pragma Reviewable.
potentially blocking operation 10.5.1 Protected Subprograms and Protected Actions.
Abort_Task C.7.1 The Package Task_Identification.
delay_statement 10.6 Delay Statements, Duration, and Time(34), see D.9 Delay Accuracy(34), see D.9(5).
remote subprogram call E.4 Remote Subprogram Calls.
RPC operations E.5 Partition Communication Subsystem.
Suspend_Until_True D.10 Synchronous Task Control.
potentially use-visible 9.4 Use Clauses.
Pound_Sign A.3.3 The Package Characters.Latin_1.
Power_16 4.3.2 Number Declarations.
Pragma 3.8 Pragmas(1), see 3.8 Pragmas(2), see K. Language-Defined Pragmas (informative)(1), see M. Glossary (informative)(1), see 3.8 Pragmas(2), see K. Language-Defined Pragmas (informative)(1), see N(27).
pragma argument 3.8 Pragmas.
pragma name 3.8 Pragmas.
pragma, categorization E.2 Categorization of Library Units.
Remote_Call_Interface E.2.3 Remote Call Interface Library Units.
Remote_Types E.2.2 Remote Types Library Units.
Shared_Passive E.2.1 Shared Passive Library Units.
pragma, configuration 11.1.5 Pragmas and Program Units.
Locking_Policy D.3 Priority Ceiling Locking.
Normalize_Scalars H.1 Pragma Normalize_Scalars.
Queuing_Policy D.4 Entry Queuing Policies.
Restrictions 14.12 Pragma Restrictions.
Reviewable H.3.1 Pragma Reviewable.
Suppress 12.5 Suppressing Checks.
Task_Dispatching_Policy D.2.2 The Standard Task Dispatching Policy.
pragma, identifier specific to 3.8 Pragmas.
pragma, interfacing
Convention B.1 Interfacing Pragmas.
Export B.1 Interfacing Pragmas.
Import B.1 Interfacing Pragmas.
Linker_Options B.1 Interfacing Pragmas.
pragma, library unit 11.1.5 Pragmas and Program Units.
All_Calls_Remote E.2.3 Remote Call Interface Library Units.
categorization pragmas E.2 Categorization of Library Units.
Elaborate_Body 11.2.1 Elaboration Control.
Preelaborate 11.2.1 Elaboration Control.
Pure 11.2.1 Elaboration Control.
pragma, program unit 11.1.5 Pragmas and Program Units.
Convention B.1 Interfacing Pragmas.
Export B.1 Interfacing Pragmas.
Import B.1 Interfacing Pragmas.
Inline 7.3.2 Inline Expansion of Subprograms.
library unit pragmas 11.1.5 Pragmas and Program Units.
pragma, representation 14.1 Representation Items.
Asynchronous E.4.1 Pragma Asynchronous.
Atomic C.6 Shared Variable Control.
Atomic_Components C.6 Shared Variable Control.
Controlled 14.11.3 Pragma Controlled.
Convention B.1 Interfacing Pragmas.
Discard_Names C.5 Pragma Discard_Names.
Export B.1 Interfacing Pragmas.
Import B.1 Interfacing Pragmas.
Pack 14.2 Pragma Pack.
Volatile C.6 Shared Variable Control.
Volatile_Components C.6 Shared Variable Control.
pragma_argument_association 3.8 Pragmas.
used 3.8 Pragmas(2), see N. Syntax Summary (informative)(2), see P(1).
pragmas
All_Calls_Remote E.2.3 Remote Call Interface Library Units(5), see K. Language-Defined Pragmas (informative)(5), see L(2).
Asynchronous E.4.1 Pragma Asynchronous(3), see K. Language-Defined Pragmas (informative)(3), see L(3).
Atomic C.6 Shared Variable Control(3), see K. Language-Defined Pragmas (informative)(3), see L(4).
Atomic_Components C.6 Shared Variable Control(5), see K. Language-Defined Pragmas (informative)(5), see L(5).
Attach_Handler C.3.1 Protected Procedure Handlers(4), see K. Language-Defined Pragmas (informative)(4), see L(6).
Controlled 14.11.3 Pragma Controlled(3), see K. Language-Defined Pragmas (informative)(3), see L(7).
Convention B.1 Interfacing Pragmas(7), see K. Language-Defined Pragmas (informative)(7), see L(8).
Discard_Names C.5 Pragma Discard_Names(3), see K. Language-Defined Pragmas (informative)(3), see L(9).
Elaborate 11.2.1 Elaboration Control(20), see K. Language-Defined Pragmas (informative)(20), see L(10).
Elaborate_All 11.2.1 Elaboration Control(21), see K. Language-Defined Pragmas (informative)(21), see L(11).
Elaborate_Body 11.2.1 Elaboration Control(22), see K. Language-Defined Pragmas (informative)(22), see L(12).
Export B.1 Interfacing Pragmas(6), see K. Language-Defined Pragmas (informative)(6), see L(13).
Import B.1 Interfacing Pragmas(5), see K. Language-Defined Pragmas (informative)(5), see L(14).
Inline 7.3.2 Inline Expansion of Subprograms(3), see K. Language-Defined Pragmas (informative)(3), see L(15).
Inspection_Point H.3.2 Pragma Inspection_Point(3), see K. Language-Defined Pragmas (informative)(3), see L(16).
Interrupt_Handler C.3.1 Protected Procedure Handlers(2), see K. Language-Defined Pragmas (informative)(2), see L(17).
Interrupt_Priority D.1 Task Priorities(5), see K. Language-Defined Pragmas (informative)(5), see L(18).
Linker_Options B.1 Interfacing Pragmas(8), see K. Language-Defined Pragmas (informative)(8), see L(19).
List 3.8 Pragmas(21), see K. Language-Defined Pragmas (informative)(21), see L(20).
Locking_Policy D.3 Priority Ceiling Locking(3), see K. Language-Defined Pragmas (informative)(3), see L(21).
Normalize_Scalars H.1 Pragma Normalize_Scalars(3), see K. Language-Defined Pragmas (informative)(3), see L(22).
Optimize 3.8 Pragmas(23), see K. Language-Defined Pragmas (informative)(23), see L(23).
Pack 14.2 Pragma Pack(3), see K. Language-Defined Pragmas (informative)(3), see L(24).
Page 3.8 Pragmas(22), see K. Language-Defined Pragmas (informative)(22), see L(25).
Preelaborate 11.2.1 Elaboration Control(3), see K. Language-Defined Pragmas (informative)(3), see L(26).
Priority D.1 Task Priorities(3), see K. Language-Defined Pragmas (informative)(3), see L(27).
Pure 11.2.1 Elaboration Control(14), see K. Language-Defined Pragmas (informative)(14), see L(28).
Queuing_Policy D.4 Entry Queuing Policies(3), see K. Language-Defined Pragmas (informative)(3), see L(29).
Remote_Call_Interface E.2.3 Remote Call Interface Library Units(3), see K. Language-Defined Pragmas (informative)(3), see L(30).
Remote_Types E.2.2 Remote Types Library Units(3), see K. Language-Defined Pragmas (informative)(3), see L(31).
Restrictions 14.12 Pragma Restrictions(3), see K. Language-Defined Pragmas (informative)(3), see L(32).
Reviewable H.3.1 Pragma Reviewable(3), see K. Language-Defined Pragmas (informative)(3), see L(33).
Shared_Passive E.2.1 Shared Passive Library Units(3), see K. Language-Defined Pragmas (informative)(3), see L(34).
Storage_Size 14.3 Representation Attributes(63), see K. Language-Defined Pragmas (informative)(63), see L(35).
Suppress 12.5 Suppressing Checks(4), see K. Language-Defined Pragmas (informative)(4), see L(36).
Task_Dispatching_Policy D.2.2 The Standard Task Dispatching Policy(2), see K. Language-Defined Pragmas (informative)(2), see L(37).
Volatile C.6 Shared Variable Control(4), see K. Language-Defined Pragmas (informative)(4), see L(38).
Volatile_Components C.6 Shared Variable Control(6), see K. Language-Defined Pragmas (informative)(6), see L(39).
precedence of operators 5.5 Operators and Expression Evaluation.
Pred attribute 4.5 Scalar Types(25), see J. Language-Defined Attributes (informative)(25), see K(181).
predefined environment A. Predefined Language Environment (normative).
predefined exception 12.1 Exception Declarations.
predefined library unit
See language-defined library units
predefined operation
of a type 4.2.3 Classification of Operations.
predefined operations
of a discrete type 4.5.5 Operations of Discrete Types.
of a fixed point type 4.5.10 Operations of Fixed Point Types.
of a floating point type 4.5.8 Operations of Floating Point Types.
of a record type 4.8 Record Types.
of an access type 4.10.2 Operations of Access Types.
of an array type 4.6.2 Operations of Array Types.
predefined operator 5.5 Operators and Expression Evaluation.
[partial] 4.2.1 Type Declarations.
predefined type 4.2.1 Type Declarations.
See language-defined types
preelaborable
of an elaborable construct 11.2.1 Elaboration Control.
Preelaborate pragma 11.2.1 Elaboration Control(3), see K. Language-Defined Pragmas (informative)(3), see L(26).
preelaborated 11.2.1 Elaboration Control.
[partial] 11.2.1 Elaboration Control(11), see E.2.1 Shared Passive Library Units(11), see E.2.1(9).
preempted task D.2.1 The Task Dispatching Model.
preemptible resource D.2.1 The Task Dispatching Model.
preference
for root numeric operators and ranges 9.6 The Context of Overload Resolution.
preference control
See requeue 10.5.4 Requeue Statements.
prefix 5.1 Names.
used 5.1.1 Indexed Components(2), see 5.1.2 Slices(2), see 5.1.3 Selected Components(2), see 5.1.2 Slices(2), see 4.1.3(2),
5.1.4 Attributes(2), see 5.1.4 Attributes(4), see 7.4 Subprogram Calls(2), see 5.1.4 Attributes(4), see 6.4(2),
7.4 Subprogram Calls(3), N. Syntax Summary (informative)(3), P(1).
prescribed result
for the evaluation of a complex arithmetic operation
G.1.1 Complex Types.
for the evaluation of a complex elementary function
G.1.2 Complex Elementary Functions.
for the evaluation of an elementary function A.5.1 Elementary Functions.
primary 5.4 Expressions.
used 5.4 Expressions(6), see N. Syntax Summary (informative)(6), see P(1).
primitive function A.5.3 Attributes of Floating Point Types.
primitive operation
[partial] 4.2 Types and Subtypes.
primitive operations M. Glossary (informative).
of a type 4.2.3 Classification of Operations.
primitive operator
of a type 4.2.3 Classification of Operations.
primitive subprograms
of a type 4.2.3 Classification of Operations.
Print_Header 7.1 Subprogram Declarations.
Priority 14.7 The Package System(16), see D.1 Task Priorities(10), see D.1 Task Priorities(16), see D.1 Task Priorities(10), see D.1(15).
priority inheritance D.1 Task Priorities.
priority inversion D.2.2 The Standard Task Dispatching Policy.
priority of an entry call D.4 Entry Queuing Policies.
Priority pragma D.1 Task Priorities(3), see K. Language-Defined Pragmas (informative)(3), see L(27).
private declaration of a library unit 11.1.1 Compilation Units - Library Units.
private descendant
of a library unit 11.1.1 Compilation Units - Library Units.
private extension 4.2 Types and Subtypes(4), see 4.9 Tagged Types and Type Extensions(2), see 4.9.1 Type Extensions(4), see 4.9 Tagged Types and Type Extensions(2), see 3.9.1(1),
M. Glossary (informative).
[partial] 8.3 Private Types and Private Extensions.
private library unit 11.1.1 Compilation Units - Library Units.
private operations 8.3.1 Private Operations.
private part 9.2 Scope of Declarations.
of a package 8.1 Package Specifications and Declarations.
of a protected unit 10.4 Protected Units and Protected Objects.
of a task unit 10.1 Task Units and Task Objects.
private type 4.2 Types and Subtypes(4), see M. Glossary (informative)(4), see N(30).
[partial] 8.3 Private Types and Private Extensions.
private types and private extensions 8.3 Private Types and Private Extensions.
private_extension_declaration 8.3 Private Types and Private Extensions.
used 4.2.1 Type Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
private_type_declaration 8.3 Private Types and Private Extensions.
used 4.2.1 Type Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
Probability 4.5.7 Floating Point Types.
procedure 7. Subprograms.
procedure instance 13.3 Generic Instantiation.
procedure_call_statement 7.4 Subprogram Calls.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
processing node E. Distributed Systems (normative).
Producer 10.11 Example of Tasking and Synchronization(2), see 10.11 Example of Tasking and Synchronization(2), see 9.11(3).
profile 7.1 Subprogram Declarations.
associated with a dereference 5.1 Names.
fully conformant 7.3.1 Conformance Rules.
mode conformant 7.3.1 Conformance Rules.
subtype conformant 7.3.1 Conformance Rules.
type conformant 7.3.1 Conformance Rules.
profile resolution rule
name with a given expected profile 9.6 The Context of Overload Resolution.
Prog B.4 Interfacing with COBOL.
program 11.2 Program Execution(1), see M. Glossary (informative)(1), see N(32).
program execution 11.2 Program Execution.
program library
See library 11. Program Structure and Compilation Issues(2), see 11.1.4 The Compilation Process(2), see 10.1.4(9).
Program unit 11.1 Separate Compilation(1), see M. Glossary (informative)(1), see N(31).
program unit pragma 11.1.5 Pragmas and Program Units.
Convention B.1 Interfacing Pragmas.
Export B.1 Interfacing Pragmas.
Import B.1 Interfacing Pragmas.
Inline 7.3.2 Inline Expansion of Subprograms.
library unit pragmas 11.1.5 Pragmas and Program Units.
Program_Error A.1 The Package Standard.
raised by failure of run-time check
2.1.3 Conformity of an Implementation with the Standard(20), 2.1.5 Classification of Errors(8), 2.1.5 Classification of Errors(20), 2.1.5 Classification of Errors(8), 1.1.5(12),
4.5.5 Operations of Discrete Types(8), 4.10.2 Operations of Access Types(29), 4.11 Declarative Parts(8), 4.10.2 Operations of Access Types(29), 3.11(14),
5.6 Type Conversions(57), 7.2 Formal Parameter Modes(12), 7.4 Subprogram Calls(57), 7.2 Formal Parameter Modes(12), 6.4(11),
7.5 Return Statements(20), 8.6.1 Completion and Finalization(15), 8.6.1 Completion and Finalization(20), 8.6.1 Completion and Finalization(15), 7.6.1(16),
8.6.1 Completion and Finalization(17), 8.6.1 Completion and Finalization(18), 10.4 Protected Units and Protected Objects(17), 8.6.1 Completion and Finalization(18), 9.4(20),
10.5.1 Protected Subprograms and Protected Actions(17), 10.5.3 Entry Calls(7), 10.7.1 Selective Accept(17), 10.5.3 Entry Calls(7), 9.7.1(21),
10.8 Abort of a Task - Abort of a Sequence of Statements(20), 11.2 Program Execution(26), 12.1 Exception Declarations(20), 11.2 Program Execution(26), 11.1(4),
12.5 Suppressing Checks(19), 14.7.1 The Package System.Storage_Elements(16), 14.9.1 Data Validity(19), 14.7.1 The Package System.Storage_Elements(16), 13.9.1(9),
14.11.2 Unchecked Storage Deallocation(13), see 14.11.2 Unchecked Storage Deallocation(14), see A.7 External Files and File Objects(13), see 14.11.2 Unchecked Storage Deallocation(14), see A.7(14),
C.3.1 Protected Procedure Handlers(10), C.3.1 Protected Procedure Handlers(11), C.3.2 The Package Interrupts(10), C.3.1 Protected Procedure Handlers(11), C.3.2(17),
C.3.2 The Package Interrupts(20), C.3.2 The Package Interrupts(21), C.3.2 The Package Interrupts(20), C.3.2 The Package Interrupts(21), C.3.2(22),
C.7.1 The Package Task_Identification(15), C.7.1 The Package Task_Identification(17), C.7.2 The Package Task_Attributes(15), C.7.1 The Package Task_Identification(17), C.7.2(13),
D.3 Priority Ceiling Locking(13), D.5 Dynamic Priorities(9), D.5 Dynamic Priorities(13), D.5 Dynamic Priorities(9), D.5(11),
D.10 Synchronous Task Control(10), D.11 Asynchronous Task Control(8), E.1 Partitions(10), D.11 Asynchronous Task Control(8), E.1(10),
E.3 Consistency of a Distributed System(6), E.4 Remote Subprogram Calls(18), I.7.1 Interrupt Entries(6), E.4 Remote Subprogram Calls(18), J.7.1(7).
Program_Status_Word 14.5.1 Record Representation Clauses.
propagate 12.4 Exception Handling.
an exception occurrence by an execution, to a dynamically
enclosing execution 12.4 Exception Handling.
proper_body 4.11 Declarative Parts.
used 4.11 Declarative Parts(5), see 11.1.3 Subunits of Compilation Units(7), see N. Syntax Summary (informative)(5), see 11.1.3 Subunits of Compilation Units(7), see P(1).
protected action 10.5.1 Protected Subprograms and Protected Actions.
complete 10.5.1 Protected Subprograms and Protected Actions.
start 10.5.1 Protected Subprograms and Protected Actions.
protected calling convention 7.3.1 Conformance Rules.
protected declaration 10.4 Protected Units and Protected Objects.
protected entry 10.4 Protected Units and Protected Objects.
protected function 10.5.1 Protected Subprograms and Protected Actions.
protected object 10. Tasks and Synchronization(3), see 10.4 Protected Units and Protected Objects(3), see 9.4(1).
protected operation 10.4 Protected Units and Protected Objects.
protected procedure 10.5.1 Protected Subprograms and Protected Actions.
protected subprogram 10.4 Protected Units and Protected Objects(1), see 10.5.1 Protected Subprograms and Protected Actions(1), see 9.5.1(1).
Protected type M. Glossary (informative).
protected unit 10.4 Protected Units and Protected Objects.
protected_body 10.4 Protected Units and Protected Objects.
used 4.11 Declarative Parts(6), see N. Syntax Summary (informative)(6), see P(1).
protected_body_stub 11.1.3 Subunits of Compilation Units.
used 11.1.3 Subunits of Compilation Units(2), see N. Syntax Summary (informative)(2), see P(1).
protected_definition 10.4 Protected Units and Protected Objects.
used 10.4 Protected Units and Protected Objects(2), see 10.4 Protected Units and Protected Objects(3), see N. Syntax Summary (informative)(2), see 10.4 Protected Units and Protected Objects(3), see P(1).
protected_element_declaration 10.4 Protected Units and Protected Objects.
used 10.4 Protected Units and Protected Objects(4), see N. Syntax Summary (informative)(4), see P(1).
protected_operation_declaration 10.4 Protected Units and Protected Objects.
used 10.4 Protected Units and Protected Objects(4), see 10.4 Protected Units and Protected Objects(6), see N. Syntax Summary (informative)(4), see 10.4 Protected Units and Protected Objects(6), see P(1).
protected_operation_item 10.4 Protected Units and Protected Objects.
used 10.4 Protected Units and Protected Objects(7), see N. Syntax Summary (informative)(7), see P(1).
protected_type_declaration 10.4 Protected Units and Protected Objects.
used 4.2.1 Type Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
ptrdiff_t B.3 Interfacing with C.
PU1 A.3.3 The Package Characters.Latin_1.
PU2 A.3.3 The Package Characters.Latin_1.
public declaration of a library unit 11.1.1 Compilation Units - Library Units.
public descendant
of a library unit 11.1.1 Compilation Units - Library Units.
public library unit 11.1.1 Compilation Units - Library Units.
pure 11.2.1 Elaboration Control.
Pure pragma 11.2.1 Elaboration Control(14), see K. Language-Defined Pragmas (informative)(14), see L(28).
Push 7.3 Subprogram Bodies(9), see 13.8 Example of a Generic Package(3), see 13.8 Example of a Generic Package(6), see 13.8 Example of a Generic Package(9), see 13.8 Example of a Generic Package(3), see 13.8 Example of a Generic Package(6), see 12.8(14).
Put 7.4 Subprogram Calls(26), 11.1.1 Compilation Units - Library Units(30), see A.10.1 The Package Text_IO(26), 11.1.1 Compilation Units - Library Units(30), see A.10.1(42),
A.10.1 The Package Text_IO(48), see A.10.1 The Package Text_IO(55), see A.10.1 The Package Text_IO(48), see A.10.1 The Package Text_IO(55), see A.10.1(60),
A.10.1 The Package Text_IO(66), see A.10.1 The Package Text_IO(67), see A.10.1 The Package Text_IO(66), see A.10.1 The Package Text_IO(67), see A.10.1(71),
A.10.1 The Package Text_IO(72), see A.10.1 The Package Text_IO(76), see A.10.1 The Package Text_IO(72), see A.10.1 The Package Text_IO(76), see A.10.1(77),
A.10.1 The Package Text_IO(82), see A.10.1 The Package Text_IO(83), see F.3.3 The Package Text_IO.Editing(82), see A.10.1 The Package Text_IO(83), see F.3.3(14),
F.3.3 The Package Text_IO.Editing(15), F.3.3 The Package Text_IO.Editing(16), G.1.3 Complex Input-Output(15), F.3.3 The Package Text_IO.Editing(16), G.1.3(7),
G.1.3 Complex Input-Output.
Put_Item 13.6 Formal Subprograms.
Put_Line A.10.1 The Package Text_IO.
Put_List 13.6 Formal Subprograms.
|
AE. Index
| | qualified_expression 5.7 Qualified Expressions.
used 5.4 Expressions(7), see 5.8 Allocators(2), see 14.8 Machine Code Insertions(2), see N. Syntax Summary (informative)(7), see 5.8 Allocators(2), see 14.8 Machine Code Insertions(2), see P(1).
Query I.5 ASCII.
Question 4.6.3 String Types(7), see A.3.3 The Package Characters.Latin_1(7), see A.3.3(10).
queuing policy D.4 Entry Queuing Policies(1), see D.4 Entry Queuing Policies(1), see D.4(6).
Queuing_Policy pragma D.4 Entry Queuing Policies(3), see K. Language-Defined Pragmas (informative)(3), see L(29).
Quotation A.3.3 The Package Characters.Latin_1.
quotation mark 3.1 Character Set.
quoted string
See string_literal 3.6 String Literals.
Quotient_Type F.2 The Package Decimal.
|
AF. index
| | R 13.5.3 Formal Array Types(15), see 13.5.4 Formal Access Types(15), see 12.5.4(13).
R_Brace I.5 ASCII.
R_Bracket I.5 ASCII.
Rad_To_Deg 5.9 Static Expressions and Static Subtypes.
Rainbow 4.2.2 Subtype Declarations(15), see 4.5.1 Enumeration Types(15), see 3.5.1(16).
raise
an exception 12. Exceptions(1), see 12.3 Raise Statements(4), see M. Glossary (informative)(1), see 12.3 Raise Statements(4), see N(18).
an exception occurrence 12.4 Exception Handling.
Raise_Exception 12.4.1 The Package Exceptions.
raise_statement 12.3 Raise Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
Random 7.1 Subprogram Declarations(38), see A.5.2 Random Number Generation(8), see A.5.2 Random Number Generation(38), see A.5.2 Random Number Generation(8), see A.5.2(20).
random number A.5.2 Random Number Generation.
Random_Coin A.5.2 Random Number Generation(58)
Random_Die A.5.2 Random Number Generation.
range 4.5 Scalar Types(3), see 4.5 Scalar Types(3), see 3.5(4).
used 4.5 Scalar Types(2), see 4.6 Array Types(6), see 4.6.1 Index Constraints and Discrete Ranges(2), see 4.6 Array Types(6), see 3.6.1(3),
5.4 Expressions(3), see N. Syntax Summary (informative)(3), see P(1).
of a scalar subtype 4.5 Scalar Types.
Range attribute 4.5 Scalar Types(14), see 4.6.2 Operations of Array Types(14), see 3.6.2(7),
J. Language-Defined Attributes (informative)(187), J. Language-Defined Attributes (informative)(187), K(189).
Range(N) attribute 4.6.2 Operations of Array Types(8), see J. Language-Defined Attributes (informative)(8), see K(185).
range_attribute_designator 5.1.4 Attributes.
used 5.1.4 Attributes(4), see N. Syntax Summary (informative)(4), see P(1).
range_attribute_reference 5.1.4 Attributes.
used 4.5 Scalar Types(3), see N. Syntax Summary (informative)(3), see P(1).
Range_Check 12.5 Suppressing Checks.
[partial] 4.2.2 Subtype Declarations(11), see 4.5 Scalar Types(24), 4.5 Scalar Types(11), see 4.5 Scalar Types(24), 3.5(27),
4.5 Scalar Types(43), 4.5 Scalar Types(44), 4.5 Scalar Types(43), 4.5 Scalar Types(44), 3.5(51),
4.5 Scalar Types(55), 4.5.5 Operations of Discrete Types(7), 4.5.9 Fixed Point Types(55), 4.5.5 Operations of Discrete Types(7), 3.5.9(19),
5.2 Literals(11), 5.3.3 Array Aggregates(28), 5.5.1 Logical Operators and Short-circuit Control Forms(11), 5.3.3 Array Aggregates(28), 4.5.1(8),
5.5.6 Highest Precedence Operators(6), 5.5.6 Highest Precedence Operators(13), 5.6 Type Conversions(6), 5.5.6 Highest Precedence Operators(13), 4.6(28),
5.6 Type Conversions(38), 5.6 Type Conversions(46), 5.6 Type Conversions(38), 5.6 Type Conversions(46), 4.6(51),
5.7 Qualified Expressions(4), 14.13.2 Stream-Oriented Attributes(35), see A.5.2 Random Number Generation(4), 14.13.2 Stream-Oriented Attributes(35), see A.5.2(39),
A.5.2 Random Number Generation(40), see A.5.3 Attributes of Floating Point Types(26), A.5.3 Attributes of Floating Point Types(40), see A.5.3 Attributes of Floating Point Types(26), A.5.3(29),
A.5.3 Attributes of Floating Point Types(50), see A.5.3 Attributes of Floating Point Types(53), A.5.3 Attributes of Floating Point Types(50), see A.5.3 Attributes of Floating Point Types(53), A.5.3(59),
A.5.3 Attributes of Floating Point Types(62), see J. Language-Defined Attributes (informative)(11), J. Language-Defined Attributes (informative)(62), see J. Language-Defined Attributes (informative)(11), K(41),
J. Language-Defined Attributes (informative)(47), J. Language-Defined Attributes (informative)(114), J. Language-Defined Attributes (informative)(47), J. Language-Defined Attributes (informative)(114), K(122),
J. Language-Defined Attributes (informative)(184), J. Language-Defined Attributes (informative)(220), J. Language-Defined Attributes (informative)(184), J. Language-Defined Attributes (informative)(220), K(241).
range_constraint 4.5 Scalar Types.
used 4.2.2 Subtype Declarations(6), see 4.5.9 Fixed Point Types(6), see 3.5.9(5),
I.3 Reduced Accuracy Subtypes(2), N. Syntax Summary (informative)(2), P(1).
Rank 13.5 Formal Types(16), see B.5 Interfacing with Fortran(16), see B.5(31).
Rational 8.1 Package Specifications and Declarations.
Rational_Numbers 8.1 Package Specifications and Declarations(12), see 8.2 Package Bodies(10), see 11.1.1 Compilation Units - Library Units(12), see 8.2 Package Bodies(10), see 10.1.1(32).
Rational_Numbers.Reduce 11.1.1 Compilation Units - Library Units.
Rational_Numbers.IO 11.1.1 Compilation Units - Library Units.
Rational_IO 11.1.1 Compilation Units - Library Units.
RCI
generic E.2.3 Remote Call Interface Library Units.
library unit E.2.3 Remote Call Interface Library Units.
package E.2.3 Remote Call Interface Library Units.
Re G.1.1 Complex Types.
re-raise statement 12.3 Raise Statements.
read 8.5 Limited Types(19), 8.5 Limited Types(20), 10.1 Task Units and Task Objects(19), 8.5 Limited Types(20), 9.1(24),
10.5.2 Entries and Accept Statements(33), 10.11 Example of Tasking and Synchronization(8), 10.11 Example of Tasking and Synchronization(33), 10.11 Example of Tasking and Synchronization(8), 9.11(10),
12.4.2 Example of Exception Handling(4), 12.4.2 Example of Exception Handling(7), 14.13.1 The Package Streams(4), 12.4.2 Example of Exception Handling(7), 13.13.1(5),
A.8.1 The Generic Package Sequential_IO(12), A.8.4 The Generic Package Direct_IO(12), A.9 The Generic Package Storage_IO(12), A.8.4 The Generic Package Direct_IO(12), A.9(6),
A.12.1 The Package Streams.Stream_IO(15), see A.12.1 The Package Streams.Stream_IO(16), see D.12 Other Optimizations and Determinism Rules(15), see A.12.1 The Package Streams.Stream_IO(16), see D.12(9),
D.12 Other Optimizations and Determinism Rules(10), E.5 Partition Communication Subsystem(10), E.5(7).
the value of an object 4.3 Objects and Named Numbers.
Read attribute 14.13.2 Stream-Oriented Attributes(6), see 14.13.2 Stream-Oriented Attributes(6), see 13.13.2(14),
J. Language-Defined Attributes (informative)(191), J. Language-Defined Attributes (informative)(191), K(195).
Read clause 14.3 Representation Attributes(7), see 14.13.2 Stream-Oriented Attributes(7), see 13.13.2(36).
ready
a task state 10. Tasks and Synchronization.
ready queue D.2.1 The Task Dispatching Model.
ready task D.2.1 The Task Dispatching Model.
Real 4.5.7 Floating Point Types(21), see B.5 Interfacing with Fortran(6), see G.1.1 Complex Types(21), see B.5 Interfacing with Fortran(6), see G.1.1(2).
real literal 3.4 Numeric Literals.
real literals 4.5.6 Real Types.
real time D.8 Monotonic Time.
real type 4.2 Types and Subtypes(3), see 4.5.6 Real Types(1), see M. Glossary (informative)(3), see 4.5.6 Real Types(1), see N(34).
real-time systems C. Systems Programming (normative)(1), see D. Real-Time Systems (normative)(1), see D(1).
Real_Plus 9.5.4 Subprogram Renaming Declarations.
real_range_specification 4.5.7 Floating Point Types.
used 4.5.7 Floating Point Types(2), see 4.5.9 Fixed Point Types(2), see 3.5.9(3),
4.5.9 Fixed Point Types(4), see N. Syntax Summary (informative)(4), see P(1).
Real_Time
child of Ada D.8 Monotonic Time.
real_type_definition 4.5.6 Real Types.
used 4.2.1 Type Declarations(4), see N. Syntax Summary (informative)(4), see P(1).
Real_IO A.10.9 Input-Output for Real Types.
receiving stub E.4 Remote Subprogram Calls.
reclamation of storage 14.11.2 Unchecked Storage Deallocation.
recommended level of support 14.1 Representation Items.
enumeration_representation_clause 14.4 Enumeration Representation Clauses.
record_representation_clause 14.5.1 Record Representation Clauses.
Address attribute 14.3 Representation Attributes.
Alignment attribute for objects 14.3 Representation Attributes.
Alignment attribute for subtypes 14.3 Representation Attributes.
bit ordering 14.5.3 Bit Ordering.
Component_Size attribute 14.3 Representation Attributes.
pragma Pack 14.2 Pragma Pack.
required in Systems Programming Annex C.2 Required Representation Support.
Size attribute 14.3 Representation Attributes(42), see 14.3 Representation Attributes(42), see 13.3(54).
unchecked conversion 14.9 Unchecked Type Conversions.
with respect to nonstatic expressions 14.1 Representation Items.
record 4.8 Record Types.
record extension 4.4 Derived Types and Classes(5), see 4.9.1 Type Extensions(1), see M. Glossary (informative)(5), see 4.9.1 Type Extensions(1), see N(35).
record layout
aspect of representation 14.5 Record Layout.
record type 4.8 Record Types(1), see M. Glossary (informative)(1), see N(36).
record_aggregate 5.3.1 Record Aggregates.
used 5.3 Aggregates(2), see N. Syntax Summary (informative)(2), see P(1).
record_component_association 5.3.1 Record Aggregates.
used 5.3.1 Record Aggregates(3), see N. Syntax Summary (informative)(3), see P(1).
record_component_association_list 5.3.1 Record Aggregates.
used 5.3.1 Record Aggregates(2), see 5.3.2 Extension Aggregates(2), see N. Syntax Summary (informative)(2), see 5.3.2 Extension Aggregates(2), see P(1).
record_definition 4.8 Record Types.
used 4.8 Record Types(2), see 4.9.1 Type Extensions(2), see N. Syntax Summary (informative)(2), see 4.9.1 Type Extensions(2), see P(1).
record_extension_part 4.9.1 Type Extensions.
used 4.4 Derived Types and Classes(2), see N. Syntax Summary (informative)(2), see P(1).
record_representation_clause 14.5.1 Record Representation Clauses.
used 14.1 Representation Items(2), see N. Syntax Summary (informative)(2), see P(1).
record_type_definition 4.8 Record Types.
used 4.2.1 Type Declarations(4), see N. Syntax Summary (informative)(4), see P(1).
Red_Blue 4.2.2 Subtype Declarations.
Reference C.3.2 The Package Interrupts(10), see C.7.2 The Package Task_Attributes(10), see C.7.2(5).
reference parameter passing 7.2 Formal Parameter Modes.
references 2.2 Normative References.
Register E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
Registered_Trade_Mark_Sign A.3.3 The Package Characters.Latin_1.
Reinitialize C.7.2 The Package Task_Attributes.
relation 5.4 Expressions.
used 5.4 Expressions(2), see N. Syntax Summary (informative)(2), see P(1).
relational operator 5.5.2 Relational Operators and Membership Tests.
relational_operator 5.5 Operators and Expression Evaluation.
used 5.4 Expressions(3), see N. Syntax Summary (informative)(3), see P(1).
relaxed mode G.2 Numeric Performance Requirements.
Release 10.4 Protected Units and Protected Objects(27), see 10.4 Protected Units and Protected Objects(27), see 9.4(29).
execution resource associated with protected object
10.5.1 Protected Subprograms and Protected Actions.
rem operator 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
Remainder attribute A.5.3 Attributes of Floating Point Types(45), see J. Language-Defined Attributes (informative)(45), see K(199).
Remainder_Type F.2 The Package Decimal.
remote access E.1 Partitions.
remote access type E.2.2 Remote Types Library Units.
remote access-to-class-wide type E.2.2 Remote Types Library Units.
remote access-to-subprogram type E.2.2 Remote Types Library Units.
remote call interface E.2 Categorization of Library Units(4), see E.2.3 Remote Call Interface Library Units(4), see E.2.3(7).
remote procedure call
asynchronous E.4.1 Pragma Asynchronous.
remote subprogram E.2.3 Remote Call Interface Library Units.
remote subprogram binding E.4 Remote Subprogram Calls.
remote subprogram call E.4 Remote Subprogram Calls.
remote types library unit E.2 Categorization of Library Units(4), see E.2.2 Remote Types Library Units(4), see E.2.2(4).
Remote_Call_Interface pragma E.2.3 Remote Call Interface Library Units(3), see K. Language-Defined Pragmas (informative)(3), see L(30).
Remote_Types pragma E.2.2 Remote Types Library Units(3), see K. Language-Defined Pragmas (informative)(3), see L(31).
Remove E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
renamed entity 9.5 Renaming Declarations.
renamed view 9.5 Renaming Declarations.
renaming-as-body 9.5.4 Subprogram Renaming Declarations.
renaming-as-declaration 9.5.4 Subprogram Renaming Declarations.
renaming_declaration 9.5 Renaming Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
rendezvous 10.5.2 Entries and Accept Statements.
Replace_Element A.4.4 Bounded-Length String Handling(27), see A.4.5 Unbounded-Length String Handling(27), see A.4.5(21).
Replace_Slice A.4.3 Fixed-Length String Handling(23), see A.4.3 Fixed-Length String Handling(23), see A.4.3(24),
A.4.4 Bounded-Length String Handling(58), see A.4.4 Bounded-Length String Handling(58), see A.4.4(59),
A.4.5 Unbounded-Length String Handling(53), see A.4.5 Unbounded-Length String Handling(53), see A.4.5(54).
Replicate A.4.4 Bounded-Length String Handling(78), see A.4.4 Bounded-Length String Handling(79), see A.4.4 Bounded-Length String Handling(78), see A.4.4 Bounded-Length String Handling(79), see A.4.4(80).
representation
change of 14.6 Change of Representation.
representation aspect 14.1 Representation Items.
representation attribute 14.3 Representation Attributes.
representation item 14.1 Representation Items.
representation of an object 14.1 Representation Items.
representation pragma 14.1 Representation Items.
Asynchronous E.4.1 Pragma Asynchronous.
Atomic C.6 Shared Variable Control.
Atomic_Components C.6 Shared Variable Control.
Controlled 14.11.3 Pragma Controlled.
Convention B.1 Interfacing Pragmas.
Discard_Names C.5 Pragma Discard_Names.
Export B.1 Interfacing Pragmas.
Import B.1 Interfacing Pragmas.
Pack 14.2 Pragma Pack.
Volatile C.6 Shared Variable Control.
Volatile_Components C.6 Shared Variable Control.
representation-oriented attributes
of a fixed point subtype A.5.4 Attributes of Fixed Point Types.
of a floating point subtype A.5.3 Attributes of Floating Point Types.
representation_clause 14.1 Representation Items.
used 4.8 Record Types(5), see 4.11 Declarative Parts(4), see 10.1 Task Units and Task Objects(5), see 4.11 Declarative Parts(4), see 9.1(5),
10.4 Protected Units and Protected Objects(5), see 10.4 Protected Units and Protected Objects(8), N. Syntax Summary (informative)(5), see 10.4 Protected Units and Protected Objects(8), P(1).
represented in canonical form A.5.3 Attributes of Floating Point Types.
Request 10.1 Task Units and Task Objects(26), see 10.5.2 Entries and Accept Statements(26), see 9.5.2(33).
requested decimal precision
of a floating point type 4.5.7 Floating Point Types.
requeue 10.5.4 Requeue Statements.
requeue-with-abort 10.5.4 Requeue Statements.
requeue_statement 10.5.4 Requeue Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
requires a completion 4.11.1 Completions of Declarations(1), see 4.11.1 Completions of Declarations(1), see 3.11.1(6).
incomplete_type_declaration 4.10.1 Incomplete Type Declarations.
protected_declaration 10.4 Protected Units and Protected Objects.
task_declaration 10.1 Task Units and Task Objects.
generic_package_declaration 8.1 Package Specifications and Declarations.
generic_subprogram_declaration 7.1 Subprogram Declarations.
package_declaration 8.1 Package Specifications and Declarations.
subprogram_declaration 7.1 Subprogram Declarations.
declaration of a partial view 8.3 Private Types and Private Extensions.
declaration to which a pragma Elaborate_Body applies
11.2.1 Elaboration Control.
deferred constant declaration 8.4 Deferred Constants.
protected entry_declaration 10.5.2 Entries and Accept Statements.
Reraise_Occurrence 12.4.1 The Package Exceptions.
reserved interrupt C.3 Interrupt Support.
reserved word 3.9 Reserved Words.
Reserved_128 A.3.3 The Package Characters.Latin_1.
Reserved_129 A.3.3 The Package Characters.Latin_1.
Reserved_132 A.3.3 The Package Characters.Latin_1.
Reserved_153 A.3.3 The Package Characters.Latin_1.
Reserved_Check
[partial] C.3.1 Protected Procedure Handlers.
Reset A.5.2 Random Number Generation(9), A.5.2 Random Number Generation(12), see A.5.2 Random Number Generation(9), A.5.2 Random Number Generation(12), see A.5.2(21),
A.5.2 Random Number Generation(24), see A.8.1 The Generic Package Sequential_IO(8), A.8.4 The Generic Package Direct_IO(24), see A.8.1 The Generic Package Sequential_IO(8), A.8.4(8),
A.10.1 The Package Text_IO(11), see A.12.1 The Package Streams.Stream_IO(11), see A.12.1(10).
resolution rules 2.1.2 Structure.
resolve
overload resolution 9.6 The Context of Overload Resolution.
Resource 10.4 Protected Units and Protected Objects(27), see 10.4 Protected Units and Protected Objects(27), see 9.4(28).
restriction 14.12 Pragma Restrictions.
used 14.12 Pragma Restrictions(3), see K. Language-Defined Pragmas (informative)(3), see L(32).
Restrictions
Immediate_Reclamation H.4 Safety and Security Restrictions.
Max_Asynchronous_Select_Nesting D.7 Tasking Restrictions.
Max_Protected_Entries D.7 Tasking Restrictions.
Max_Select_Alternatives D.7 Tasking Restrictions.
Max_Storage_At_Blocking D.7 Tasking Restrictions.
Max_Task_Entries D.7 Tasking Restrictions.
Max_Tasks D.7 Tasking Restrictions.
No_Abort_Statements D.7 Tasking Restrictions.
No_Access_Subprograms H.4 Safety and Security Restrictions.
No_Allocators H.4 Safety and Security Restrictions.
No_Asynchronous_Control D.7 Tasking Restrictions.
No_Delay H.4 Safety and Security Restrictions.
No_Dispatch H.4 Safety and Security Restrictions.
No_Dynamic_Priorities D.7 Tasking Restrictions.
No_Exceptions H.4 Safety and Security Restrictions.
No_Fixed_Point H.4 Safety and Security Restrictions.
No_Floating_Point H.4 Safety and Security Restrictions.
No_Implicit_Heap_Allocations D.7 Tasking Restrictions.
No_Local_Allocators H.4 Safety and Security Restrictions.
No_Nested_Finalization D.7 Tasking Restrictions.
No_Protected_Types H.4 Safety and Security Restrictions.
No_Recursion H.4 Safety and Security Restrictions.
No_Reentrancy H.4 Safety and Security Restrictions.
No_Task_Allocators D.7 Tasking Restrictions.
No_Task_Hierarchy D.7 Tasking Restrictions.
No_Terminate_Alternatives D.7 Tasking Restrictions.
No_Unchecked_Access H.4 Safety and Security Restrictions.
No_Unchecked_Conversion H.4 Safety and Security Restrictions.
No_Unchecked_Deallocation H.4 Safety and Security Restrictions.
No_IO H.4 Safety and Security Restrictions.
Restrictions pragma 14.12 Pragma Restrictions(3), see K. Language-Defined Pragmas (informative)(3), see L(32).
result interval
for a component of the result of evaluating
a complex function G.2.6 Accuracy Requirements for Complex Arithmetic.
for the evaluation of a predefined arithmetic
operation G.2.1 Model of Floating Point Arithmetic.
for the evaluation of an elementary function G.2.4 Accuracy Requirements for the Elementary Functions.
result subtype
of a function 7.5 Return Statements.
Result_Subtype A.5.2 Random Number Generation.
return expression 7.5 Return Statements.
return-by-reference type 7.5 Return Statements.
return_statement 7.5 Return Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(4), see N. Syntax Summary (informative)(4), see P(1).
Reverse_Solidus A.3.3 The Package Characters.Latin_1.
Reviewable pragma H.3.1 Pragma Reviewable(3), see K. Language-Defined Pragmas (informative)(3), see L(33).
Rewind E.4.2 Example of Use of a Remote Access-to-Class-Wide Type(2), see E.4.2 Example of Use of a Remote Access-to-Class-Wide Type(2), see E.4.2(5).
RI A.3.3 The Package Characters.Latin_1.
right curly bracket 3.1 Character Set.
right parenthesis 3.1 Character Set.
right square bracket 3.1 Character Set.
Right_Angle_Quotation A.3.3 The Package Characters.Latin_1.
Right_Curly_Bracket A.3.3 The Package Characters.Latin_1.
Right_Indent 7.1 Subprogram Declarations.
Right_Parenthesis A.3.3 The Package Characters.Latin_1.
Right_Square_Bracket A.3.3 The Package Characters.Latin_1.
Roman 4.6 Array Types.
Roman_Digit 4.5.2 Character Types.
root library unit 11.1.1 Compilation Units - Library Units.
root type
of a class 4.4.1 Derivation Classes.
root_integer 4.5.4 Integer Types.
[partial] 4.4.1 Derivation Classes.
root_real 4.5.6 Real Types.
[partial] 4.4.1 Derivation Classes.
Root_Storage_Pool 14.11 Storage Management.
Root_Stream_Type 14.13.1 The Package Streams.
rooted at a type 4.4.1 Derivation Classes.
Rosso 9.5.4 Subprogram Renaming Declarations.
Rot 9.5.4 Subprogram Renaming Declarations.
rotate B.2 The Package Interfaces.
Rotate_Left B.2 The Package Interfaces.
Rotate_Right B.2 The Package Interfaces.
Rouge 9.5.4 Subprogram Renaming Declarations.
Round attribute 4.5.10 Operations of Fixed Point Types(12), see J. Language-Defined Attributes (informative)(12), see K(203).
Rounding attribute A.5.3 Attributes of Floating Point Types(36), see J. Language-Defined Attributes (informative)(36), see K(207).
Row 13.1 Generic Declarations.
RPC
child of System E.5 Partition Communication Subsystem.
RPC-receiver E.5 Partition Communication Subsystem.
RPC_Receiver E.5 Partition Communication Subsystem.
RS A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
run-time check
See language-defined check 12.5 Suppressing Checks.
run-time error 2.1.2 Structure(30), see 2.1.5 Classification of Errors(30), see 1.1.5(6),
12.5 Suppressing Checks(2), 12.6 Exceptions and Optimization(2), 11.6(1).
run-time polymorphism 4.9.2 Dispatching Operations of Tagged Types.
run-time semantics 2.1.2 Structure.
run-time type
See tag 4.9 Tagged Types and Type Extensions.
running a program
See program execution 11.2 Program Execution.
running task D.2.1 The Task Dispatching Model.
|
AG. index
| | S'Adjacent A.5.3 Attributes of Floating Point Types(49), see J. Language-Defined Attributes (informative)(49), see K(10).
S'Ceiling A.5.3 Attributes of Floating Point Types(34), see J. Language-Defined Attributes (informative)(34), see K(29).
S'Class'Input 14.13.2 Stream-Oriented Attributes(33), see J. Language-Defined Attributes (informative)(33), see K(94).
S'Class'Output 14.13.2 Stream-Oriented Attributes(30), see J. Language-Defined Attributes (informative)(30), see K(167).
S'Class'Read 14.13.2 Stream-Oriented Attributes(15), see J. Language-Defined Attributes (informative)(15), see K(193).
S'Class'Write 14.13.2 Stream-Oriented Attributes(12), see J. Language-Defined Attributes (informative)(12), see K(284).
S'Compose A.5.3 Attributes of Floating Point Types(25), see J. Language-Defined Attributes (informative)(25), see K(40).
S'Copy_Sign A.5.3 Attributes of Floating Point Types(52), see J. Language-Defined Attributes (informative)(52), see K(46).
S'Exponent A.5.3 Attributes of Floating Point Types(19), see J. Language-Defined Attributes (informative)(19), see K(62).
S'Floor A.5.3 Attributes of Floating Point Types(31), see J. Language-Defined Attributes (informative)(31), see K(76).
S'Fraction A.5.3 Attributes of Floating Point Types(22), see J. Language-Defined Attributes (informative)(22), see K(82).
S'Input 14.13.2 Stream-Oriented Attributes(23), see J. Language-Defined Attributes (informative)(23), see K(98).
S'Leading_Part A.5.3 Attributes of Floating Point Types(55), see J. Language-Defined Attributes (informative)(55), see K(110).
S'Machine A.5.3 Attributes of Floating Point Types(61), see J. Language-Defined Attributes (informative)(61), see K(121).
S'Model A.5.3 Attributes of Floating Point Types(69), see J. Language-Defined Attributes (informative)(69), see K(153).
S'Output 14.13.2 Stream-Oriented Attributes(20), see J. Language-Defined Attributes (informative)(20), see K(171).
S'Read 14.13.2 Stream-Oriented Attributes(7), see J. Language-Defined Attributes (informative)(7), see K(197).
S'Remainder A.5.3 Attributes of Floating Point Types(46), see J. Language-Defined Attributes (informative)(46), see K(201).
S'Rounding A.5.3 Attributes of Floating Point Types(37), see J. Language-Defined Attributes (informative)(37), see K(209).
S'Scaling A.5.3 Attributes of Floating Point Types(28), see J. Language-Defined Attributes (informative)(28), see K(219).
S'Truncation A.5.3 Attributes of Floating Point Types(43), see J. Language-Defined Attributes (informative)(43), see K(250).
S'Unbiased_Rounding A.5.3 Attributes of Floating Point Types(40), see J. Language-Defined Attributes (informative)(40), see K(254).
S'Write 14.13.2 Stream-Oriented Attributes(4), see J. Language-Defined Attributes (informative)(4), see K(288).
safe range
of a floating point type 4.5.7 Floating Point Types(9), see 4.5.7 Floating Point Types(9), see 3.5.7(10).
Safe_First attribute A.5.3 Attributes of Floating Point Types(71), see G.2.2 Model-Oriented Attributes of Floating Point Types(71), see G.2.2(5),
J. Language-Defined Attributes (informative).
Safe_Last attribute A.5.3 Attributes of Floating Point Types(72), see G.2.2 Model-Oriented Attributes of Floating Point Types(72), see G.2.2(6),
J. Language-Defined Attributes (informative).
safety-critical systems H. Safety and Security (normative).
Salary 4.5.9 Fixed Point Types.
Salary_Conversions B.4 Interfacing with COBOL(108), see B.4 Interfacing with COBOL(108), see B.4(120).
Salary_Type B.4 Interfacing with COBOL(105), see B.4 Interfacing with COBOL(105), see B.4(114).
Same_Denominator 8.2 Package Bodies.
satisfies
a discriminant constraint 4.7.1 Discriminant Constraints.
a range constraint 4.5 Scalar Types.
an index constraint 4.6.1 Index Constraints and Discrete Ranges.
for an access value 4.10 Access Types.
Save A.5.2 Random Number Generation(12), see A.5.2 Random Number Generation(12), see A.5.2(24).
Save_Occurrence 12.4.1 The Package Exceptions.
scalar type 4.2 Types and Subtypes(3), see 4.5 Scalar Types(1), see M. Glossary (informative)(3), see 4.5 Scalar Types(1), see N(37).
scalar_constraint 4.2.2 Subtype Declarations.
used 4.2.2 Subtype Declarations(5), see N. Syntax Summary (informative)(5), see P(1).
scale
of a decimal fixed point subtype 4.5.10 Operations of Fixed Point Types,
J. Language-Defined Attributes (informative).
Scale attribute 4.5.10 Operations of Fixed Point Types(11), see J. Language-Defined Attributes (informative)(11), see K(215).
Scaling attribute A.5.3 Attributes of Floating Point Types(27), see J. Language-Defined Attributes (informative)(27), see K(217).
SCHAR_MAX B.3 Interfacing with C.
SCHAR_MIN B.3 Interfacing with C.
Schedule 4.6 Array Types.
scope
informal definition 4.1 Declarations.
of (a view of) an entity 9.2 Scope of Declarations.
of a use_clause 9.4 Use Clauses.
of a with_clause 11.1.2 Context Clauses - With Clauses.
of a declaration 9.2 Scope of Declarations.
Seconds 10.6 Delay Statements, Duration, and Time.
Seconds_Count D.8 Monotonic Time.
Section_Sign A.3.3 The Package Characters.Latin_1.
secure systems H. Safety and Security (normative).
Seize 10.4 Protected Units and Protected Objects(27), see 10.4 Protected Units and Protected Objects(28), see 10.5.2 Entries and Accept Statements(27), see 10.4 Protected Units and Protected Objects(28), see 9.5.2(33).
select an entry call
from an entry queue 10.5.3 Entry Calls(13), see 10.5.3 Entry Calls(13), see 9.5.3(16).
immediately 10.5.3 Entry Calls.
select_alternative 10.7.1 Selective Accept.
used 10.7.1 Selective Accept(2), see N. Syntax Summary (informative)(2), see P(1).
select_statement 10.7 Select Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(5), see N. Syntax Summary (informative)(5), see P(1).
selected_component 5.1.3 Selected Components.
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
selection
of an entry caller 10.5.2 Entries and Accept Statements.
selective_accept 10.7.1 Selective Accept.
used 10.7 Select Statements(2), see N. Syntax Summary (informative)(2), see P(1).
selector_name 5.1.3 Selected Components.
used 4.7.1 Discriminant Constraints(3), see 5.1.3 Selected Components(2), see 5.3.1 Record Aggregates(3), see 5.1.3 Selected Components(2), see 4.3.1(5),
7.4 Subprogram Calls(5), 13.3 Generic Instantiation(4), N. Syntax Summary (informative)(5), 13.3 Generic Instantiation(4), P(1).
semantic dependence
of one compilation unit upon another 11.1.1 Compilation Units - Library Units.
semicolon 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(15), see A.3.3(10).
separate compilation 11.1 Separate Compilation.
separator 3.2 Lexical Elements, Separators, and Delimiters.
Sequence 5.6 Type Conversions.
sequence of characters
of a string_literal 3.6 String Literals.
sequence_of_statements 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.3 If Statements(2), 6.4 Case Statements(3), 6.5 Loop Statements(2), 6.4 Case Statements(3), 5.5(2),
10.7.1 Selective Accept(2), see 10.7.1 Selective Accept(5), see 10.7.1 Selective Accept(2), see 10.7.1 Selective Accept(5), see 9.7.1(6),
10.7.2 Timed Entry Calls(3), see 10.7.3 Conditional Entry Calls(2), see 10.7.4 Asynchronous Transfer of Control(3), see 10.7.3 Conditional Entry Calls(2), see 9.7.4(3),
10.7.4 Asynchronous Transfer of Control(5), see 12.2 Exception Handlers(2), 12.2 Exception Handlers(5), see 12.2 Exception Handlers(2), 11.2(3),
N. Syntax Summary (informative).
sequential
actions 10.10 Shared Variables(11), see C.6 Shared Variable Control(11), see C.6(17).
sequential access A.8 Sequential and Direct Files.
sequential file A.8 Sequential and Direct Files.
Sequential_IO I.1 Renamings of Ada 83 Library Units.
child of Ada A.8.1 The Generic Package Sequential_IO.
Server 10.1 Task Units and Task Objects(23), see 10.7.1 Selective Accept(23), see 9.7.1(24).
service
an entry queue 10.5.3 Entry Calls.
Set 4.9.3 Abstract Types and Subprograms(15), see 7.4 Subprogram Calls(15), see 6.4(27),
D.12 Other Optimizations and Determinism Rules(9), D.12 Other Optimizations and Determinism Rules(9), D.12(10).
Set_Col A.10.1 The Package Text_IO.
Set_Component 10.4 Protected Units and Protected Objects(31), see 10.4 Protected Units and Protected Objects(31), see 9.4(33).
Set_Error A.10.1 The Package Text_IO.
Set_False D.10 Synchronous Task Control.
Set_Index A.8.4 The Generic Package Direct_IO(14), see A.12.1 The Package Streams.Stream_IO(14), see A.12.1(22).
Set_Input A.10.1 The Package Text_IO.
Set_Line A.10.1 The Package Text_IO.
Set_Line_Length A.10.1 The Package Text_IO.
Set_Mask 14.8 Machine Code Insertions(13), see 14.8 Machine Code Insertions(13), see 13.8(14).
Set_Mode A.12.1 The Package Streams.Stream_IO.
Set_Output A.10.1 The Package Text_IO.
Set_Page_Length A.10.1 The Package Text_IO.
Set_Priority D.5 Dynamic Priorities.
Set_True D.10 Synchronous Task Control.
Set_Value C.7.2 The Package Task_Attributes.
Set_Im G.1.1 Complex Types.
Set_Re G.1.1 Complex Types.
Sets 4.9.3 Abstract Types and Subprograms.
shared passive library unit E.2 Categorization of Library Units(4), see E.2.1 Shared Passive Library Units(4), see E.2.1(4).
shared variable
protection of 10.10 Shared Variables.
Shared_Array 10.4 Protected Units and Protected Objects(31), see 10.4 Protected Units and Protected Objects(31), see 9.4(32).
Shared_Passive pragma E.2.1 Shared Passive Library Units(3), see K. Language-Defined Pragmas (informative)(3), see L(34).
Sharp I.5 ASCII.
shift B.2 The Package Interfaces.
Shift_Left B.2 The Package Interfaces.
Shift_Right B.2 The Package Interfaces.
Shift_Right_Arithmetic B.2 The Package Interfaces.
Short 14.3 Representation Attributes(82), see B.3 Interfacing with C(82), see B.3(7).
short-circuit control form 5.5.1 Logical Operators and Short-circuit Control Forms.
Short_Float 4.5.7 Floating Point Types.
Short_Integer 4.5.4 Integer Types.
Shut_Down 10.1 Task Units and Task Objects.
SI A.3.3 The Package Characters.Latin_1.
Sigma 13.1 Generic Declarations(24), see 13.2 Generic Bodies(24), see 12.2(12).
signal (an exception)
See raise 12. Exceptions.
signal
See interrupt C.3 Interrupt Support.
as defined between actions 10.10 Shared Variables.
signal handling
example 10.7.4 Asynchronous Transfer of Control.
signed integer type 4.5.4 Integer Types.
signed_char B.3 Interfacing with C.
signed_integer_type_definition 4.5.4 Integer Types.
used 4.5.4 Integer Types(2), see N. Syntax Summary (informative)(2), see P(1).
Signed_Zeros attribute A.5.3 Attributes of Floating Point Types(13), see J. Language-Defined Attributes (informative)(13), see K(221).
simple entry call 10.5.3 Entry Calls.
simple_expression 5.4 Expressions.
used 4.5 Scalar Types(3), see 4.5.4 Integer Types(3), 4.5.7 Floating Point Types(3), see 4.5.4 Integer Types(3), 3.5.7(3),
5.4 Expressions(3), see 14.5.1 Record Representation Clauses(5), see 14.5.1 Record Representation Clauses(3), see 14.5.1 Record Representation Clauses(5), see 13.5.1(6),
N. Syntax Summary (informative).
simple_statement 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(3), see N. Syntax Summary (informative)(3), see P(1).
Sin A.5.1 Elementary Functions(5), see G.1.2 Complex Elementary Functions(4)
single
class expected type 9.6 The Context of Overload Resolution.
single entry 10.5.2 Entries and Accept Statements.
Single_Precision_Complex_Types B.5 Interfacing with Fortran.
single_protected_declaration 10.4 Protected Units and Protected Objects.
used 4.3.1 Object Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
single_task_declaration 10.1 Task Units and Task Objects.
used 4.3.1 Object Declarations(2), see N. Syntax Summary (informative)(2), see P(1).
Singular 12.1 Exception Declarations.
Sinh A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(6).
size A.8.4 The Generic Package Direct_IO(15), see A.12.1 The Package Streams.Stream_IO(15), see A.12.1(23).
of an object 14.1 Representation Items.
Size attribute 14.3 Representation Attributes(40), see 14.3 Representation Attributes(40), see 13.3(45),
J. Language-Defined Attributes (informative)(223), J. Language-Defined Attributes (informative)(223), K(228).
Size clause 14.3 Representation Attributes(7), see 14.3 Representation Attributes(41), see 14.3 Representation Attributes(7), see 14.3 Representation Attributes(41), see 13.3(48).
size_t B.3 Interfacing with C.
Skip_Line A.10.1 The Package Text_IO.
Skip_Page A.10.1 The Package Text_IO.
slice 5.1.2 Slices(2), see A.4.4 Bounded-Length String Handling(28), see A.4.5 Unbounded-Length String Handling(2), see A.4.4 Bounded-Length String Handling(28), see A.4.5(22).
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
small
of a fixed point type 4.5.9 Fixed Point Types.
Small attribute 4.5.10 Operations of Fixed Point Types(2), see J. Language-Defined Attributes (informative)(2), see K(230).
Small clause 4.5.10 Operations of Fixed Point Types(2), see 14.3 Representation Attributes(2), see 13.3(7).
Small_Int 4.2.2 Subtype Declarations(15), see 4.5.4 Integer Types(15), see 3.5.4(35).
SO A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
Soft_Hyphen A.3.3 The Package Characters.Latin_1.
SOH A.3.3 The Package Characters.Latin_1.
solidus 3.1 Character Set(15), see A.3.3 The Package Characters.Latin_1(15), see A.3.3(8).
Source 14.9 Unchecked Type Conversions.
SPA A.3.3 The Package Characters.Latin_1.
Space A.3.3 The Package Characters.Latin_1(8), see A.4.1 The Package Strings(8), see A.4.1(4).
space_character 3.1 Character Set.
used 3.1 Character Set(3), see N. Syntax Summary (informative)(3), see P(1).
special graphic character
a category of Character A.3.2 The Package Characters.Handling.
special_character 3.1 Character Set.
used 3.1 Character Set(3), see N. Syntax Summary (informative)(3), see P(1).
names 3.1 Character Set.
Special_Key 4.4 Derived Types and Classes.
Special_Set A.4.6 String-Handling Sets and Mappings.
Specialized Needs Annexes 2.1.2 Structure.
specifiable (of an attribute and for an entity) 14.3 Representation Attributes.
specifiable
of Address for entries I.7.1 Interrupt Entries.
of Address for stand-alone objects and for program units
14.3 Representation Attributes.
of Alignment for first subtypes and objects 14.3 Representation Attributes.
of Bit_Order for record types and record extensions
14.5.3 Bit Ordering.
of Component_Size for array types 14.3 Representation Attributes.
of External_Tag for a tagged type 14.3 Representation Attributes(75), see J. Language-Defined Attributes (informative)(75), see K(65).
of Input for a type 14.13.2 Stream-Oriented Attributes.
of Machine_Radix for decimal first subtypes F.1 Machine_Radix Attribute Definition Clause.
of Output for a type 14.13.2 Stream-Oriented Attributes.
of Read for a type 14.13.2 Stream-Oriented Attributes.
of Size for first subtypes 14.3 Representation Attributes.
of Size for stand-alone objects 14.3 Representation Attributes.
of Small for fixed point types 4.5.10 Operations of Fixed Point Types.
of Storage_Pool for a non-derived access-to-object type
14.11 Storage Management.
of Storage_Size for a task first subtype I.9 The Storage_Size Attribute.
of Storage_Size for a non-derived access-to-object type
14.11 Storage Management.
of Write for a type 14.13.2 Stream-Oriented Attributes.
specific type 4.4.1 Derivation Classes.
specified (not!) 2.1.3 Conformity of an Implementation with the Standard.
specified
of an aspect of representation of an entity 14.1 Representation Items.
specified discriminant 4.7 Discriminants.
Spin 10.7.3 Conditional Entry Calls(6)
Split 10.6 Delay Statements, Duration, and Time(14), see D.8 Monotonic Time(14), see D.8(16).
Sqrt A.5.1 Elementary Functions(4), see B.1 Interfacing Pragmas(4), see B.1(51), G.1.2(3)
Square 4.2.2 Subtype Declarations(15), see 4.7 Discriminants(35), see 13.3 Generic Instantiation(15), see 4.7 Discriminants(35), see 12.3(24).
Squaring 13.1 Generic Declarations(22), see 13.2 Generic Bodies(22), see 12.2(7).
SS2 A.3.3 The Package Characters.Latin_1.
SS3 A.3.3 The Package Characters.Latin_1.
SSA A.3.3 The Package Characters.Latin_1.
ST A.3.3 The Package Characters.Latin_1.
Stack 13.8 Example of a Generic Package(3), see 13.8 Example of a Generic Package(4), see 13.8 Example of a Generic Package(3), see 13.8 Example of a Generic Package(4), see 12.8(14).
Stack_Bool 13.8 Example of a Generic Package.
Stack_Int 13.8 Example of a Generic Package.
Stack_Real 13.8 Example of a Generic Package.
stand-alone constant 4.3.1 Object Declarations.
corresponding to a formal object of mode in 13.4 Formal Objects(10)
stand-alone object 4.3.1 Object Declarations.
stand-alone variable 4.3.1 Object Declarations.
Standard A.1 The Package Standard.
standard error file A.10 Text Input-Output.
standard input file A.10 Text Input-Output.
standard mode 2.1.5 Classification of Errors.
standard output file A.10 Text Input-Output.
standard storage pool 14.11 Storage Management.
Standard_Error A.10.1 The Package Text_IO(16), see A.10.1 The Package Text_IO(16), see A.10.1(19).
Standard_Input A.10.1 The Package Text_IO(16), see A.10.1 The Package Text_IO(16), see A.10.1(19).
Standard_Output A.10.1 The Package Text_IO(16), see A.10.1 The Package Text_IO(16), see A.10.1(19).
State 4.8.1 Variant Parts and Discrete Choices(24), see 14.5.1 Record Representation Clauses(24), see 13.5.1(26),
A.5.2 Random Number Generation(11), see A.5.2 Random Number Generation(11), see A.5.2(23).
State_Mask 14.5.1 Record Representation Clauses.
statement 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(2), see N. Syntax Summary (informative)(2), see P(1).
statement_identifier 6.1 Simple and Compound Statements - Sequences of Statements.
used 6.1 Simple and Compound Statements - Sequences of Statements(7), see 6.5 Loop Statements(2), see 6.6 Block Statements(2), see N. Syntax Summary (informative)(7), see 6.5 Loop Statements(2), see 6.6 Block Statements(2), see P(1).
static 5.9 Static Expressions and Static Subtypes.
constant 5.9 Static Expressions and Static Subtypes.
constraint 5.9 Static Expressions and Static Subtypes.
delta constraint 5.9 Static Expressions and Static Subtypes.
digits constraint 5.9 Static Expressions and Static Subtypes.
discrete_range 5.9 Static Expressions and Static Subtypes.
discriminant constraint 5.9 Static Expressions and Static Subtypes.
expression 5.9 Static Expressions and Static Subtypes.
function 5.9 Static Expressions and Static Subtypes.
index constraint 5.9 Static Expressions and Static Subtypes.
range 5.9 Static Expressions and Static Subtypes.
range constraint 5.9 Static Expressions and Static Subtypes.
scalar subtype 5.9 Static Expressions and Static Subtypes.
string subtype 5.9 Static Expressions and Static Subtypes.
subtype 5.9 Static Expressions and Static Subtypes(26), see 13.4 Formal Objects(26), see 12.4(9).
static semantics 2.1.2 Structure.
statically
constrained 5.9 Static Expressions and Static Subtypes.
denote 5.9 Static Expressions and Static Subtypes.
statically compatible
for a constraint and a scalar subtype 5.9.1 Statically Matching Constraints and Subtypes.
for a constraint and an access or composite subtype
5.9.1 Statically Matching Constraints and Subtypes.
for two subtypes 5.9.1 Statically Matching Constraints and Subtypes.
statically deeper 4.10.2 Operations of Access Types(4), see 4.10.2 Operations of Access Types(4), see 3.10.2(17).
statically determined tag 4.9.2 Dispatching Operations of Tagged Types.
[partial] 4.9.2 Dispatching Operations of Tagged Types(15), see 4.9.2 Dispatching Operations of Tagged Types(15), see 3.9.2(19).
statically matching
effect on subtype-specific aspects 14.1 Representation Items.
for constraints 5.9.1 Statically Matching Constraints and Subtypes.
for ranges 5.9.1 Statically Matching Constraints and Subtypes.
for subtypes 5.9.1 Statically Matching Constraints and Subtypes.
required 4.9.2 Dispatching Operations of Tagged Types(10), see 4.10.2 Operations of Access Types(27), see 5.6 Type Conversions(10), see 4.10.2 Operations of Access Types(27), see 4.6(12),
5.6 Type Conversions(16), 7.3.1 Conformance Rules(16), 7.3.1 Conformance Rules(16), 7.3.1 Conformance Rules(16), 6.3.1(17),
7.3.1 Conformance Rules(23), see 8.3 Private Types and Private Extensions(13), 13.5.1 Formal Private and Derived Types(23), see 8.3 Private Types and Private Extensions(13), 12.5.1(14),
13.5.3 Formal Array Types(6), see 13.5.3 Formal Array Types(7), 13.5.4 Formal Access Types(6), see 13.5.3 Formal Array Types(7), 12.5.4(3),
13.7 Formal Packages.
statically tagged 4.9.2 Dispatching Operations of Tagged Types.
Status_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1 The Package Text_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1(85),
A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(26), see A.13(4).
storage deallocation
unchecked 14.11.2 Unchecked Storage Deallocation.
storage element 14.3 Representation Attributes.
storage management
user-defined 14.11 Storage Management.
storage node E. Distributed Systems (normative).
storage place
of a component 14.5 Record Layout.
storage place attributes
of a component 14.5.2 Storage Place Attributes.
storage pool 4.10 Access Types.
storage pool element 14.11 Storage Management.
storage pool type 14.11 Storage Management.
Storage_Array 14.7.1 The Package System.Storage_Elements.
Storage_Check 12.5 Suppressing Checks.
[partial] 12.1 Exception Declarations(6), 14.3 Representation Attributes(6), 13.3(67),
14.11 Storage Management(17), see D.7 Tasking Restrictions(17), see D.7(15).
Storage_Count 14.7.1 The Package System.Storage_Elements.
subtype in package System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
Storage_Element 14.7.1 The Package System.Storage_Elements.
Storage_Elements
child of System 14.7.1 The Package System.Storage_Elements.
Storage_Error A.1 The Package Standard.
raised by failure of run-time check
5.8 Allocators(14), 12.1 Exception Declarations(4), 12.1 Exception Declarations(14), 12.1 Exception Declarations(4), 11.1(6),
12.5 Suppressing Checks(23), 14.3 Representation Attributes(67), see 14.11 Storage Management(23), 14.3 Representation Attributes(67), see 13.11(17),
14.11 Storage Management(18), see A.7 External Files and File Objects(14), D.7 Tasking Restrictions(18), see A.7 External Files and File Objects(14), D.7(15).
Storage_Offset 14.7.1 The Package System.Storage_Elements.
Storage_Pool attribute 14.11 Storage Management(13), see J. Language-Defined Attributes (informative)(13), see K(232).
Storage_Pool clause 14.3 Representation Attributes(7), see 14.11 Storage Management(7), see 13.11(15).
Storage_Pools
child of System 14.11 Storage Management.
Storage_Size 14.11 Storage Management.
Storage_Size attribute 14.3 Representation Attributes(60), see 14.11 Storage Management(60), see 13.11(14),
I.9 The Storage_Size Attribute(2), J. Language-Defined Attributes (informative)(2), K(234),
J. Language-Defined Attributes (informative).
Storage_Size clause 14.3 Representation Attributes(7), see 14.11 Storage Management(7), see 13.11(15).
See also pragma Storage_Size 14.3 Representation Attributes.
Storage_Size pragma 14.3 Representation Attributes(63), see K. Language-Defined Pragmas (informative)(63), see L(35).
Storage_Unit 14.7 The Package System.
named number in package System 14.7 The Package System.
Storage_IO
child of Ada A.9 The Generic Package Storage_IO.
Strcpy B.3 Interfacing with C(78), see B.3.2 The Generic Package Interfaces.C.Pointers(78), see B.3.2(48).
stream 14.13 Streams(1), A.12.1 The Package Streams.Stream_IO(1), A.12.1(13),
A.12.2 The Package Text_IO.Text_Streams(4), see A.12.3 The Package Wide_Text_IO.Text_Streams(4), see A.12.3(4).
stream type 14.13 Streams.
Stream_Access A.12.1 The Package Streams.Stream_IO(4), see A.12.2 The Package Text_IO.Text_Streams(3), see A.12.3 The Package Wide_Text_IO.Text_Streams(4), see A.12.2 The Package Text_IO.Text_Streams(3), see A.12.3(3).
Stream_Element 14.13.1 The Package Streams.
Stream_Element_Array 14.13.1 The Package Streams.
Stream_Element_Count 14.13.1 The Package Streams.
Stream_Element_Offset 14.13.1 The Package Streams.
Stream_IO
child of Ada.Streams A.12.1 The Package Streams.Stream_IO.
Streams
child of Ada 14.13.1 The Package Streams.
strict mode G.2 Numeric Performance Requirements.
String 4.6.3 String Types(4), see A.1 The Package Standard(4), see A.1(37).
string type 4.6.3 String Types.
String_Access A.4.5 Unbounded-Length String Handling.
string_element 3.6 String Literals.
used 3.6 String Literals(2), see N. Syntax Summary (informative)(2), see P(1).
string_literal 3.6 String Literals.
used 5.4 Expressions(7), see 7.1 Subprogram Declarations(9), see N. Syntax Summary (informative)(7), see 7.1 Subprogram Declarations(9), see P(1).
Strings
child of Ada A.4.1 The Package Strings.
child of Interfaces.C B.3.1 The Package Interfaces.C.Strings.
Strlen B.3.1 The Package Interfaces.C.Strings.
structure
See record type 4.8 Record Types.
STS A.3.3 The Package Characters.Latin_1.
STX A.3.3 The Package Characters.Latin_1(5), see I.5 ASCII(5), see J.5(4).
SUB A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
subaggregate
of an array_aggregate 5.3.3 Array Aggregates.
subcomponent 4.2 Types and Subtypes.
subprogram 7. Subprograms.
abstract 4.9.3 Abstract Types and Subprograms.
subprogram call 7.4 Subprogram Calls.
subprogram instance 13.3 Generic Instantiation.
subprogram_body 7.3 Subprogram Bodies.
used 4.11 Declarative Parts(6), 10.4 Protected Units and Protected Objects(6), 9.4(8),
11.1.1 Compilation Units - Library Units(7), see N. Syntax Summary (informative)(7), see P(1).
subprogram_body_stub 11.1.3 Subunits of Compilation Units.
used 11.1.3 Subunits of Compilation Units(2), see N. Syntax Summary (informative)(2), see P(1).
subprogram_declaration 7.1 Subprogram Declarations.
used 4.1 Declarations(3), 10.4 Protected Units and Protected Objects(5), see 10.4 Protected Units and Protected Objects(3), 10.4 Protected Units and Protected Objects(5), see 9.4(8),
11.1.1 Compilation Units - Library Units(5), see N. Syntax Summary (informative)(5), see P(1).
subprogram_default 13.6 Formal Subprograms.
used 13.6 Formal Subprograms(2), see N. Syntax Summary (informative)(2), see P(1).
subprogram_renaming_declaration 9.5.4 Subprogram Renaming Declarations.
used 9.5 Renaming Declarations(2), see 11.1.1 Compilation Units - Library Units(6), see N. Syntax Summary (informative)(2), see 11.1.1 Compilation Units - Library Units(6), see P(1).
subprogram_specification 7.1 Subprogram Declarations.
used 7.1 Subprogram Declarations(2), 7.1 Subprogram Declarations(3), 7.3 Subprogram Bodies(2), 7.1 Subprogram Declarations(3), 6.3(2),
9.5.4 Subprogram Renaming Declarations(2), see 11.1.3 Subunits of Compilation Units(3), see 13.1 Generic Declarations(2), see 11.1.3 Subunits of Compilation Units(3), see 12.1(3),
13.6 Formal Subprograms(2), N. Syntax Summary (informative)(2), P(1).
subsystem 11.1 Separate Compilation(3), see M. Glossary (informative)(3), see N(22).
Subtraction 4.9.1 Type Extensions.
subtype (of an object)
See actual subtype of an object 4.3 Objects and Named Numbers(23), see 4.3.1 Object Declarations(23), see 3.3.1(9).
subtype 4.2 Types and Subtypes(8), see M. Glossary (informative)(8), see N(38).
subtype conformance 7.3.1 Conformance Rules.
[partial] 4.10.2 Operations of Access Types(34), see 10.5.4 Requeue Statements(34), see 9.5.4(17).
required 4.9.2 Dispatching Operations of Tagged Types(10), see 4.10.2 Operations of Access Types(32), see 5.6 Type Conversions(10), see 4.10.2 Operations of Access Types(32), see 4.6(19),
9.5.4 Subprogram Renaming Declarations(5), 10.5.4 Requeue Statements(5), 14.3 Representation Attributes(5), 10.5.4 Requeue Statements(5), 13.3(6).
subtype conversion
See also implicit subtype conversion 5.6 Type Conversions.
See type conversion 5.6 Type Conversions.
subtype-specific
of a representation item 14.1 Representation Items.
of an aspect 14.1 Representation Items.
subtype_declaration 4.2.2 Subtype Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
subtype_indication 4.2.2 Subtype Declarations.
used 4.2.2 Subtype Declarations(2), see 4.3.1 Object Declarations(2), see 4.4 Derived Types and Classes(2), see 4.3.1 Object Declarations(2), see 3.4(2),
4.6 Array Types(6), 4.6 Array Types(7), 4.6.1 Index Constraints and Discrete Ranges(6), 4.6 Array Types(7), 3.6.1(3),
4.10 Access Types(3), 5.8 Allocators(2), 8.3 Private Types and Private Extensions(3), 5.8 Allocators(2), 7.3(3),
N. Syntax Summary (informative).
subtype_mark 4.2.2 Subtype Declarations.
used 4.2.2 Subtype Declarations(3), see 4.6 Array Types(4), 4.7 Discriminants(3), see 4.6 Array Types(4), 3.7(5),
4.10 Access Types(6), 5.3.2 Extension Aggregates(3), see 5.4 Expressions(6), 5.3.2 Extension Aggregates(3), see 4.4(3),
5.6 Type Conversions(2), 5.7 Qualified Expressions(2), 7.1 Subprogram Declarations(2), 5.7 Qualified Expressions(2), 6.1(13),
7.1 Subprogram Declarations(15), 9.4 Use Clauses(4), 9.5.1 Object Renaming Declarations(15), 9.4 Use Clauses(4), 8.5.1(2),
13.3 Generic Instantiation(5), 13.4 Formal Objects(2), 13.5.1 Formal Private and Derived Types(5), 13.4 Formal Objects(2), 12.5.1(3),
N. Syntax Summary (informative).
subtypes
of a profile 7.1 Subprogram Declarations.
subunit 11.1.3 Subunits of Compilation Units(7), see 11.1.3 Subunits of Compilation Units(7), see 10.1.3(8).
used 11.1.1 Compilation Units - Library Units(3), see N. Syntax Summary (informative)(3), see P(1).
Succ attribute 4.5 Scalar Types(22), see J. Language-Defined Attributes (informative)(22), see K(238).
Suit 4.5.1 Enumeration Types.
Sum 13.1 Generic Declarations(24), see 13.2 Generic Bodies(24), see 12.2(10).
super
See view conversion 5.6 Type Conversions.
Superscript_One A.3.3 The Package Characters.Latin_1.
Superscript_Three A.3.3 The Package Characters.Latin_1.
Superscript_Two A.3.3 The Package Characters.Latin_1.
Suppress pragma 12.5 Suppressing Checks(4), see K. Language-Defined Pragmas (informative)(4), see L(36).
suppressed check 12.5 Suppressing Checks.
Suspend_Until_True D.10 Synchronous Task Control.
Suspension_Object D.10 Synchronous Task Control.
Swap 13.3 Generic Instantiation.
Switch 7.1 Subprogram Declarations.
SYN A.3.3 The Package Characters.Latin_1(6), see I.5 ASCII(6), see J.5(4).
synchronization 10. Tasks and Synchronization.
Synchronous_Task_Control
child of Ada D.10 Synchronous Task Control.
syntactic category 2.1.4 Method of Description and Syntax Notation.
syntax
complete listing N. Syntax Summary (informative).
cross reference N. Syntax Summary (informative).
notation 2.1.4 Method of Description and Syntax Notation.
under Syntax heading 2.1.2 Structure.
System 14.7 The Package System.
System.Address_To_Access_Conversions 14.7.2 The Package System.Address_To_Access_Conversions.
System.Machine_Code 14.8 Machine Code Insertions.
System.RPC E.5 Partition Communication Subsystem.
System.Storage_Elements 14.7.1 The Package System.Storage_Elements.
System.Storage_Pools 14.11 Storage Management.
System_Name 14.7 The Package System.
systems programming C. Systems Programming (normative).
|
AH. index
| | T 14.11 Storage Management.
Table 4.2.1 Type Declarations(15), 4.6 Array Types(28), see 13.5 Formal Types(15), 4.6 Array Types(28), see 12.5(14),
13.5.3 Formal Array Types(11), see 13.8 Example of a Generic Package(5), see 13.8 Example of a Generic Package(11), see 13.8 Example of a Generic Package(5), see 12.8(14).
Tag 4.9 Tagged Types and Type Extensions.
Tag attribute 4.9 Tagged Types and Type Extensions(16), see 4.9 Tagged Types and Type Extensions(16), see 3.9(18),
J. Language-Defined Attributes (informative)(242), J. Language-Defined Attributes (informative)(242), K(244).
tag indeterminate 4.9.2 Dispatching Operations of Tagged Types.
tag of an object 4.9 Tagged Types and Type Extensions.
class-wide object 4.9 Tagged Types and Type Extensions.
object created by an allocator 4.9 Tagged Types and Type Extensions.
preserved by type conversion and parameter passing
4.9 Tagged Types and Type Extensions.
returned by a function 4.9 Tagged Types and Type Extensions(23), see 4.9 Tagged Types and Type Extensions(23), see 3.9(24).
stand-alone object, component, or aggregate 4.9 Tagged Types and Type Extensions.
Tag_Check 12.5 Suppressing Checks.
[partial] 4.9.2 Dispatching Operations of Tagged Types(16), see 5.6 Type Conversions(42), see 5.6 Type Conversions(16), see 5.6 Type Conversions(42), see 4.6(52),
6.2 Assignment Statements(10), 7.5 Return Statements(10), 6.5(9).
Tag_Error 4.9 Tagged Types and Type Extensions.
tagged type 4.9 Tagged Types and Type Extensions(2), see M. Glossary (informative)(2), see N(39).
Tags
child of Ada 4.9 Tagged Types and Type Extensions.
tail (of a queue) D.2.1 The Task Dispatching Model.
Tail A.4.3 Fixed-Length String Handling(37), see A.4.3 Fixed-Length String Handling(38), see A.4.4 Bounded-Length String Handling(37), see A.4.3 Fixed-Length String Handling(38), see A.4.4(72),
A.4.4 Bounded-Length String Handling(73), see A.4.5 Unbounded-Length String Handling(67), see A.4.5 Unbounded-Length String Handling(73), see A.4.5 Unbounded-Length String Handling(67), see A.4.5(68).
Take 4.9.3 Abstract Types and Subprograms.
Tan A.5.1 Elementary Functions(5), see G.1.2 Complex Elementary Functions(5), see G.1.2(4).
Tanh A.5.1 Elementary Functions(7), see G.1.2 Complex Elementary Functions(7), see G.1.2(6).
Tape E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
Tape_Client E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
Tape_Driver E.4.2 Example of Use of a Remote Access-to-Class-Wide Type(4), see E.4.2 Example of Use of a Remote Access-to-Class-Wide Type(4), see E.4.2(5).
Tape_Ptr E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
Tapes E.4.2 Example of Use of a Remote Access-to-Class-Wide Type.
target 14.9 Unchecked Type Conversions.
of an assignment_statement 6.2 Assignment Statements.
of an assignment operation 6.2 Assignment Statements.
target entry
of a requeue_statement 10.5.4 Requeue Statements.
target object
of a requeue_statement 10.5 Intertask Communication.
of a call on an entry or a protected subprogram 10.5 Intertask Communication.
target statement
of a goto_statement 6.8 Goto Statements.
target subtype
of a type_conversion 5.6 Type Conversions.
task 10. Tasks and Synchronization.
activation 10.2 Task Execution - Task Activation.
completion 10.3 Task Dependence - Termination of Tasks.
dependence 10.3 Task Dependence - Termination of Tasks.
execution 10.2 Task Execution - Task Activation.
termination 10.3 Task Dependence - Termination of Tasks.
task declaration 10.1 Task Units and Task Objects.
task dispatching D.2.1 The Task Dispatching Model.
task dispatching point D.2.1 The Task Dispatching Model.
[partial] D.2.1 The Task Dispatching Model(8), see D.2.2 The Standard Task Dispatching Policy(8), see D.2.2(12).
task dispatching policy D.2.2 The Standard Task Dispatching Policy.
[partial] D.2.1 The Task Dispatching Model.
task priority D.1 Task Priorities.
task state
abnormal 10.8 Abort of a Task - Abort of a Sequence of Statements.
blocked 10. Tasks and Synchronization.
callable 10.9 Task and Entry Attributes.
held D.11 Asynchronous Task Control.
inactive 10. Tasks and Synchronization.
ready 10. Tasks and Synchronization.
terminated 10. Tasks and Synchronization.
Task type M. Glossary (informative).
task unit 10. Tasks and Synchronization.
Task_Attributes
child of Ada C.7.2 The Package Task_Attributes.
task_body 10.1 Task Units and Task Objects.
used 4.11 Declarative Parts(6), see N. Syntax Summary (informative)(6), see P(1).
task_body_stub 11.1.3 Subunits of Compilation Units.
used 11.1.3 Subunits of Compilation Units(2), see N. Syntax Summary (informative)(2), see P(1).
task_definition 10.1 Task Units and Task Objects.
used 10.1 Task Units and Task Objects(2), see 10.1 Task Units and Task Objects(3), see N. Syntax Summary (informative)(2), see 10.1 Task Units and Task Objects(3), see P(1).
Task_Dispatching_Policy pragma D.2.2 The Standard Task Dispatching Policy(2), see K. Language-Defined Pragmas (informative)(2), see L(37).
Task_Identification
child of Ada C.7.1 The Package Task_Identification.
task_item 10.1 Task Units and Task Objects.
used 10.1 Task Units and Task Objects(4), see N. Syntax Summary (informative)(4), see P(1).
task_type_declaration 10.1 Task Units and Task Objects.
used 4.2.1 Type Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
Task_ID C.7.1 The Package Task_Identification.
Tasking_Error A.1 The Package Standard.
raised by failure of run-time check
10.2 Task Execution - Task Activation(5), 10.5.3 Entry Calls(21), 12.1 Exception Declarations(5), 10.5.3 Entry Calls(21), 11.1(4),
14.11.2 Unchecked Storage Deallocation(13), see 14.11.2 Unchecked Storage Deallocation(14), see C.7.2 The Package Task_Attributes(13), see 14.11.2 Unchecked Storage Deallocation(14), see C.7.2(13),
D.5 Dynamic Priorities(8), D.11 Asynchronous Task Control(8), D.11(8).
template 13. Generic Units.
See generic unit 13. Generic Units.
for a formal package 13.7 Formal Packages.
term 5.4 Expressions.
used 5.4 Expressions, P(1)
terminal interrupt
example 10.7.4 Asynchronous Transfer of Control.
terminate_alternative 10.7.1 Selective Accept.
used 10.7.1 Selective Accept(4), see N. Syntax Summary (informative)(4), see P(1).
terminated
a task state 10. Tasks and Synchronization.
Terminated attribute 10.9 Task and Entry Attributes(3), see J. Language-Defined Attributes (informative)(3), see K(246).
termination
of a partition E.1 Partitions.
Terminator_Error B.3 Interfacing with C.
Test B.3 Interfacing with C.
Test_Call B.4 Interfacing with COBOL.
Test_External_Formats B.4 Interfacing with COBOL.
Test_Pointers B.3.2 The Generic Package Interfaces.C.Pointers.
tested type
of a membership test 5.5.2 Relational Operators and Membership Tests.
text of a program 3.2 Lexical Elements, Separators, and Delimiters.
Text_Streams
child of Ada.Text_IO A.12.2 The Package Text_IO.Text_Streams(3), see A.12.3 The Package Wide_Text_IO.Text_Streams(3), see A.12.3(3).
Text_IO I.1 Renamings of Ada 83 Library Units.
child of Ada A.10.1 The Package Text_IO.
throw (an exception)
See raise 12. Exceptions.
tick 3.1 Character Set(15), see 14.7 The Package System(10), see D.8 Monotonic Time(15), see 14.7 The Package System(10), see D.8(7).
named number in package System 14.7 The Package System.
Tilde A.3.3 The Package Characters.Latin_1.
Time 10.6 Delay Statements, Duration, and Time(10), see D.8 Monotonic Time(10), see D.8(4).
time base 10.6 Delay Statements, Duration, and Time.
time limit
example 10.7.4 Asynchronous Transfer of Control.
time type 10.6 Delay Statements, Duration, and Time.
Time-dependent Reset procedure
of the random number generator A.5.2 Random Number Generation.
time-out
See asynchronous_select 10.7.4 Asynchronous Transfer of Control.
See selective_accept 10.7.1 Selective Accept.
See timed_entry_call 10.7.2 Timed Entry Calls.
example 10.7.4 Asynchronous Transfer of Control.
Time_Error 10.6 Delay Statements, Duration, and Time.
Time_First D.8 Monotonic Time.
Time_Last D.8 Monotonic Time.
Time_Span D.8 Monotonic Time.
Time_Span_First D.8 Monotonic Time.
Time_Span_Last D.8 Monotonic Time.
Time_Span_Unit D.8 Monotonic Time.
Time_Span_Zero D.8 Monotonic Time.
Time_Unit D.8 Monotonic Time.
Time_Of 10.6 Delay Statements, Duration, and Time(15), see D.8 Monotonic Time(15), see D.8(16).
timed_entry_call 10.7.2 Timed Entry Calls.
used 10.7 Select Statements(2), see N. Syntax Summary (informative)(2), see P(1).
timer interrupt
example 10.7.4 Asynchronous Transfer of Control.
times operator 5.4 Expressions(1), see 5.5.5 Multiplying Operators(1), see 4.5.5(1).
timing
See delay_statement 10.6 Delay Statements, Duration, and Time.
TM 9.5.3 Package Renaming Declarations.
To_Ada B.3 Interfacing with C(22), see B.3 Interfacing with C(26), see B.3 Interfacing with C(22), see B.3 Interfacing with C(26), see B.3(28),
B.3 Interfacing with C(32), see B.3 Interfacing with C(37), see B.3 Interfacing with C(32), see B.3 Interfacing with C(37), see B.3(39),
B.4 Interfacing with COBOL(17), see B.4 Interfacing with COBOL(19), see B.5 Interfacing with Fortran(17), see B.4 Interfacing with COBOL(19), see B.5(13),
B.5 Interfacing with Fortran(14), see B.5 Interfacing with Fortran(14), see B.5(16).
To_Address 14.7.1 The Package System.Storage_Elements(10), see 14.7.2 The Package System.Address_To_Access_Conversions(10), see 13.7.2(3).
To_Basic A.3.2 The Package Characters.Handling(6), see A.3.2 The Package Characters.Handling(6), see A.3.2(7).
To_Binary B.4 Interfacing with COBOL(45), see B.4 Interfacing with COBOL(45), see B.4(48).
To_Bounded_String A.4.4 Bounded-Length String Handling.
To_Character A.3.2 The Package Characters.Handling.
To_COBOL B.4 Interfacing with COBOL(17), see B.4 Interfacing with COBOL(17), see B.4(18).
To_Decimal B.4 Interfacing with COBOL(35), see B.4 Interfacing with COBOL(35), see B.4(40),
B.4 Interfacing with COBOL(44), see B.4 Interfacing with COBOL(44), see B.4(47).
To_Display B.4 Interfacing with COBOL.
To_Domain A.4.2 The Package Strings.Maps(24), see A.4.7 Wide_String Handling(24)
To_Duration D.8 Monotonic Time.
To_Fortran B.5 Interfacing with Fortran(13), see B.5 Interfacing with Fortran(14), see B.5 Interfacing with Fortran(13), see B.5 Interfacing with Fortran(14), see B.5(15).
To_Integer 14.7.1 The Package System.Storage_Elements.
To_ISO_646 A.3.2 The Package Characters.Handling(11), see A.3.2 The Package Characters.Handling(11), see A.3.2(12).
To_Long_Binary B.4 Interfacing with COBOL.
To_Lower A.3.2 The Package Characters.Handling(6), see A.3.2 The Package Characters.Handling(6), see A.3.2(7).
To_Mapping A.4.2 The Package Strings.Maps(23), see A.4.7 Wide_String Handling(23), see A.4.7(23).
To_Packed B.4 Interfacing with COBOL.
To_Picture F.3.3 The Package Text_IO.Editing.
To_Pointer 14.7.2 The Package System.Address_To_Access_Conversions.
To_Range A.4.2 The Package Strings.Maps(24), see A.4.7 Wide_String Handling(24), see A.4.7(25).
To_Ranges A.4.2 The Package Strings.Maps(10), see A.4.7 Wide_String Handling(10), see A.4.7(10).
To_Sequence A.4.2 The Package Strings.Maps(19), see A.4.7 Wide_String Handling(19), see A.4.7(19).
To_Set A.4.2 The Package Strings.Maps(8), A.4.2 The Package Strings.Maps(9), see A.4.2 The Package Strings.Maps(8), A.4.2 The Package Strings.Maps(9), see A.4.2(17),
A.4.2 The Package Strings.Maps(18), see A.4.7 Wide_String Handling(8), see A.4.7 Wide_String Handling(18), see A.4.7 Wide_String Handling(8), see A.4.7(9),
A.4.7 Wide_String Handling(17), see A.4.7 Wide_String Handling(17), see A.4.7(18).
To_String A.3.2 The Package Characters.Handling(16), see A.4.4 Bounded-Length String Handling(12), see A.4.5 Unbounded-Length String Handling(16), see A.4.4 Bounded-Length String Handling(12), see A.4.5(11).
To_Time_Span D.8 Monotonic Time.
To_Unbounded_String A.4.5 Unbounded-Length String Handling(9), see A.4.5 Unbounded-Length String Handling(9), see A.4.5(10).
To_Upper A.3.2 The Package Characters.Handling(6), see A.3.2 The Package Characters.Handling(6), see A.3.2(7).
To_Wide_Character A.3.2 The Package Characters.Handling.
To_Wide_String A.3.2 The Package Characters.Handling.
To_C B.3 Interfacing with C(21), see B.3 Interfacing with C(25), see B.3 Interfacing with C(21), see B.3 Interfacing with C(25), see B.3(27),
B.3 Interfacing with C(32), see B.3 Interfacing with C(36), see B.3 Interfacing with C(32), see B.3 Interfacing with C(36), see B.3(38).
token
See lexical element 3.2 Lexical Elements, Separators, and Delimiters.
Tolerance 4.3.1 Object Declarations.
Trailing_Nonseparate B.4 Interfacing with COBOL.
Trailing_Separate B.4 Interfacing with COBOL.
transfer of control 6.1 Simple and Compound Statements - Sequences of Statements.
Translate A.4.3 Fixed-Length String Handling(18), see A.4.3 Fixed-Length String Handling(19), see A.4.3 Fixed-Length String Handling(18), see A.4.3 Fixed-Length String Handling(19), see A.4.3(20),
A.4.3 Fixed-Length String Handling(21), see A.4.4 Bounded-Length String Handling(53), see A.4.4 Bounded-Length String Handling(21), see A.4.4 Bounded-Length String Handling(53), see A.4.4(54),
A.4.4 Bounded-Length String Handling(55), see A.4.4 Bounded-Length String Handling(56), see A.4.5 Unbounded-Length String Handling(55), see A.4.4 Bounded-Length String Handling(56), see A.4.5(48),
A.4.5 Unbounded-Length String Handling(49), see A.4.5 Unbounded-Length String Handling(50), see A.4.5 Unbounded-Length String Handling(49), see A.4.5 Unbounded-Length String Handling(50), see A.4.5(51).
Traverse_Tree 7.1 Subprogram Declarations.
triggering_alternative 10.7.4 Asynchronous Transfer of Control.
used 10.7.4 Asynchronous Transfer of Control(2), see N. Syntax Summary (informative)(2), see P(1).
triggering_statement 10.7.4 Asynchronous Transfer of Control.
used 10.7.4 Asynchronous Transfer of Control(3), see N. Syntax Summary (informative)(3), see P(1).
Trim A.4.3 Fixed-Length String Handling(31), see A.4.3 Fixed-Length String Handling(32), see A.4.3 Fixed-Length String Handling(31), see A.4.3 Fixed-Length String Handling(32), see A.4.3(33),
A.4.3 Fixed-Length String Handling(34), see A.4.4 Bounded-Length String Handling(67), see A.4.4 Bounded-Length String Handling(34), see A.4.4 Bounded-Length String Handling(67), see A.4.4(68),
A.4.4 Bounded-Length String Handling(69), see A.4.5 Unbounded-Length String Handling(61), see A.4.5 Unbounded-Length String Handling(69), see A.4.5 Unbounded-Length String Handling(61), see A.4.5(62),
A.4.5 Unbounded-Length String Handling(63), see A.4.5 Unbounded-Length String Handling(63), see A.4.5(64).
Trim_End A.4.1 The Package Strings.
True 4.5.3 Boolean Types.
Truncation A.4.1 The Package Strings.
Truncation attribute A.5.3 Attributes of Floating Point Types(42), see J. Language-Defined Attributes (informative)(42), see K(248).
two's complement
modular types 4.5.4 Integer Types.
Two_Pi 4.3.2 Number Declarations.
type 4.2 Types and Subtypes(1), see M. Glossary (informative)(1), see N(41).
See also tag 4.9 Tagged Types and Type Extensions.
abstract 4.9.3 Abstract Types and Subprograms.
See also language-defined types
type conformance 7.3.1 Conformance Rules.
[partial] 4.4 Derived Types and Classes(17), see 9.3 Visibility(17), see 8.3(8),
9.3 Visibility(26), see 11.1.4 The Compilation Process(26), see 10.1.4(4).
required 4.11.1 Completions of Declarations(5), see 5.1.4 Attributes(5), see 4.1.4(14),
9.6 The Context of Overload Resolution(26), 10.5.4 Requeue Statements(26), 9.5.4(3).
type conversion 5.6 Type Conversions.
See also qualified_expression 5.7 Qualified Expressions.
access 5.6 Type Conversions(13), see 5.6 Type Conversions(18), see 5.6 Type Conversions(13), see 5.6 Type Conversions(18), see 4.6(47).
arbitrary order 2.1.4 Method of Description and Syntax Notation.
array 5.6 Type Conversions(9), see 5.6 Type Conversions(9), see 4.6(36).
composite (non-array) 5.6 Type Conversions(21), see 5.6 Type Conversions(21), see 4.6(40).
enumeration 5.6 Type Conversions(21), see 5.6 Type Conversions(21), see 4.6(34).
numeric 5.6 Type Conversions(8), see 5.6 Type Conversions(8), see 4.6(29).
unchecked 14.9 Unchecked Type Conversions.
type conversion, implicit
See implicit subtype conversion 5.6 Type Conversions.
type extension 4.9 Tagged Types and Type Extensions(2), see 4.9.1 Type Extensions(2), see 3.9.1(1).
type of a discrete_range 4.6.1 Index Constraints and Discrete Ranges.
type of a range 4.5 Scalar Types.
type parameter
See discriminant 4.7 Discriminants.
type profile
See profile, type conformant 7.3.1 Conformance Rules.
type resolution rules 9.6 The Context of Overload Resolution.
if any type in a specified class of types is expected
9.6 The Context of Overload Resolution.
if expected type is specific 9.6 The Context of Overload Resolution.
if expected type is universal or class-wide 9.6 The Context of Overload Resolution.
type tag
See tag 4.9 Tagged Types and Type Extensions.
type-related
aspect 14.1 Representation Items.
representation item 14.1 Representation Items.
type_conversion 5.6 Type Conversions.
used 5.1 Names(2), see N. Syntax Summary (informative)(2), see P(1).
See also unchecked type conversion 14.9 Unchecked Type Conversions.
type_declaration 4.2.1 Type Declarations.
used 4.1 Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
type_definition 4.2.1 Type Declarations.
used 4.2.1 Type Declarations(3), see N. Syntax Summary (informative)(3), see P(1).
Type_Set A.10.1 The Package Text_IO(7), see A.10.10 Input-Output for Enumeration Types(7), see A.10.10(3).
types
of a profile 7.1 Subprogram Declarations.
|
AI. index
| | UC_Icelandic_Eth A.3.3 The Package Characters.Latin_1.
UC_Icelandic_Thorn A.3.3 The Package Characters.Latin_1.
UC_A_Acute A.3.3 The Package Characters.Latin_1.
UC_A_Circumflex A.3.3 The Package Characters.Latin_1.
UC_A_Diaeresis A.3.3 The Package Characters.Latin_1.
UC_A_Grave A.3.3 The Package Characters.Latin_1.
UC_A_Ring A.3.3 The Package Characters.Latin_1.
UC_A_Tilde A.3.3 The Package Characters.Latin_1.
UC_AE_Diphthong A.3.3 The Package Characters.Latin_1.
UC_C_Cedilla A.3.3 The Package Characters.Latin_1.
UC_E_Acute A.3.3 The Package Characters.Latin_1.
UC_E_Circumflex A.3.3 The Package Characters.Latin_1.
UC_E_Diaeresis A.3.3 The Package Characters.Latin_1.
UC_E_Grave A.3.3 The Package Characters.Latin_1.
UC_I_Acute A.3.3 The Package Characters.Latin_1.
UC_I_Circumflex A.3.3 The Package Characters.Latin_1.
UC_I_Diaeresis A.3.3 The Package Characters.Latin_1.
UC_I_Grave A.3.3 The Package Characters.Latin_1.
UC_N_Tilde A.3.3 The Package Characters.Latin_1.
UC_O_Acute A.3.3 The Package Characters.Latin_1.
UC_O_Circumflex A.3.3 The Package Characters.Latin_1.
UC_O_Diaeresis A.3.3 The Package Characters.Latin_1.
UC_O_Grave A.3.3 The Package Characters.Latin_1.
UC_O_Oblique_Stroke A.3.3 The Package Characters.Latin_1.
UC_O_Tilde A.3.3 The Package Characters.Latin_1.
UC_U_Acute A.3.3 The Package Characters.Latin_1.
UC_U_Circumflex A.3.3 The Package Characters.Latin_1.
UC_U_Diaeresis A.3.3 The Package Characters.Latin_1.
UC_U_Grave A.3.3 The Package Characters.Latin_1.
UC_Y_Acute A.3.3 The Package Characters.Latin_1.
UCHAR_MAX B.3 Interfacing with C.
ultimate ancestor
of a type 4.4.1 Derivation Classes.
unary adding operator 5.5.4 Unary Adding Operators.
unary operator 5.5 Operators and Expression Evaluation.
unary_adding_operator 5.5 Operators and Expression Evaluation.
used 5.4 Expressions(4), see N. Syntax Summary (informative)(4), see P(1).
Unbiased_Rounding attribute A.5.3 Attributes of Floating Point Types(39), see J. Language-Defined Attributes (informative)(39), see K(252).
Unbounded A.10.1 The Package Text_IO.
child of Ada.Strings A.4.5 Unbounded-Length String Handling.
Unbounded_String A.4.5 Unbounded-Length String Handling.
unchecked storage deallocation 14.11.2 Unchecked Storage Deallocation.
unchecked type conversion 14.9 Unchecked Type Conversions.
Unchecked_Access attribute 14.10 Unchecked Access Value Creation(3), see H.4 Safety and Security Restrictions(3), see H.4(18),
J. Language-Defined Attributes (informative).
See also Access attribute 4.10.2 Operations of Access Types.
Unchecked_Conversion I.1 Renamings of Ada 83 Library Units.
child of Ada 14.9 Unchecked Type Conversions.
Unchecked_Deallocation I.1 Renamings of Ada 83 Library Units.
child of Ada 14.11.2 Unchecked Storage Deallocation.
unconstrained 4.2 Types and Subtypes.
object 4.3.1 Object Declarations(9), see 4.10 Access Types(9), see 7.4.1 Parameter Associations(9), see 4.10 Access Types(9), see 6.4.1(16).
subtype 4.2 Types and Subtypes(9), 4.4 Derived Types and Classes(6), 4.5 Scalar Types(9), 4.4 Derived Types and Classes(6), 3.5(7),
4.5.1 Enumeration Types(10), see 4.5.4 Integer Types(9), 4.5.4 Integer Types(10), see 4.5.4 Integer Types(9), 3.5.4(10),
4.5.7 Floating Point Types(11), see 4.5.9 Fixed Point Types(13), see 4.5.9 Fixed Point Types(11), see 4.5.9 Fixed Point Types(13), see 3.5.9(16),
4.6 Array Types(15), 4.6 Array Types(16), 4.7 Discriminants(15), 4.6 Array Types(16), 3.7(26),
4.9 Tagged Types and Type Extensions(15), 4.10 Access Types(14), J. Language-Defined Attributes (informative)(15), 4.10 Access Types(14), K(33).
unconstrained_array_definition 4.6 Array Types.
used 4.6 Array Types(2), see N. Syntax Summary (informative)(2), see P(1).
undefined result 12.6 Exceptions and Optimization.
underline 3.1 Character Set(15), see I.5 ASCII(15), see J.5(6).
used 3.3 Identifiers(2), 3.4.1 Decimal Literals(2), 2.4.1(3),
3.4.2 Based Literals(4), see N. Syntax Summary (informative)(4), see P(1).
Uniformly_Distributed A.5.2 Random Number Generation.
uninitialized allocator 5.8 Allocators.
uninitialized variables 14.9.1 Data Validity.
[partial] 4.3.1 Object Declarations.
Union 4.9.3 Abstract Types and Subprograms.
unit consistency E.3 Consistency of a Distributed System.
Unit_Set 4.9.3 Abstract Types and Subprograms.
universal type 4.4.1 Derivation Classes.
universal_fixed
[partial] 4.5.6 Real Types.
universal_integer 4.5.4 Integer Types.
[partial] 4.5.4 Integer Types.
universal_real
[partial] 4.5.6 Real Types.
unknown discriminants 4.7 Discriminants.
unknown_discriminant_part 4.7 Discriminants.
used 4.7 Discriminants(2), see N. Syntax Summary (informative)(2), see P(1).
unmarshalling E.4 Remote Subprogram Calls.
unpolluted 14.13.1 The Package Streams.
unsigned B.3 Interfacing with C, B.4(23)
unsigned type
See modular type 4.5.4 Integer Types.
Unsigned_ B.2 The Package Interfaces.
unsigned_char B.3 Interfacing with C.
unsigned_long B.3 Interfacing with C.
unsigned_short B.3 Interfacing with C.
unspecified 2.1.3 Conformity of an Implementation with the Standard.
[partial] 3.1 Character Set(5), 5.5.2 Relational Operators and Membership Tests(13), see 5.5.5 Multiplying Operators(5), 5.5.2 Relational Operators and Membership Tests(13), see 4.5.5(21),
7.2 Formal Parameter Modes(11), 8.2 Package Bodies(5), 10.8 Abort of a Task - Abort of a Sequence of Statements(11), 8.2 Package Bodies(5), 9.8(14),
11.2 Program Execution(26), 12.1 Exception Declarations(6), 12.5 Suppressing Checks(26), 12.1 Exception Declarations(6), 11.5(27),
14.1 Representation Items(18), 14.7.2 The Package System.Address_To_Access_Conversions(5), see 14.9.1 Data Validity(18), 14.7.2 The Package System.Address_To_Access_Conversions(5), see 13.9.1(7),
14.11 Storage Management(20), A.1 The Package Standard(1), A.5.1 Elementary Functions(20), A.1 The Package Standard(1), A.5.1(34),
A.5.2 Random Number Generation(28), A.5.2 Random Number Generation(34), see A.7 External Files and File Objects(28), A.5.2 Random Number Generation(34), see A.7(6),
A.10 Text Input-Output(8), A.10.7 Input-Output of Characters and Strings(8), see A.10.7 Input-Output of Characters and Strings(8), A.10.7 Input-Output of Characters and Strings(8), see A.10.7(12),
A.10.7 Input-Output of Characters and Strings(19), see A.14 File Sharing(1), A.15 The Package Command_Line(19), see A.14 File Sharing(1), A.15(20),
D.2.2 The Standard Task Dispatching Policy(6), D.8 Monotonic Time(19), G.1.1 Complex Types(6), D.8 Monotonic Time(19), G.1.1(40),
G.1.2 Complex Elementary Functions(33), G.1.2 Complex Elementary Functions(48), see H. Safety and Security (normative)(33), G.1.2 Complex Elementary Functions(48), see H(4),
H.2 Documentation of Implementation Decisions.
Up_To_K 4.2.2 Subtype Declarations.
update B.3.1 The Package Interfaces.C.Strings(18), see B.3.1 The Package Interfaces.C.Strings(18), see B.3.1(19).
the value of an object 4.3 Objects and Named Numbers.
Update_Error B.3.1 The Package Interfaces.C.Strings.
upper bound
of a range 4.5 Scalar Types.
upper-case letter
a category of Character A.3.2 The Package Characters.Handling.
upper_case_identifier_letter 3.1 Character Set.
Upper_Case_Map A.4.6 String-Handling Sets and Mappings.
Upper_Set A.4.6 String-Handling Sets and Mappings.
US A.3.3 The Package Characters.Latin_1.
usage name 4.1 Declarations.
use-visible 9.3 Visibility(4), see 9.4 Use Clauses(4), see 8.4(9).
use_clause 9.4 Use Clauses.
used 4.11 Declarative Parts(4), see 11.1.2 Context Clauses - With Clauses(4), see 10.1.2(3),
13.1 Generic Declarations(5), see N. Syntax Summary (informative)(5), see P(1).
Use_Error A.8.1 The Generic Package Sequential_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1 The Package Text_IO(15), A.8.4 The Generic Package Direct_IO(18), see A.10.1(85),
A.12.1 The Package Streams.Stream_IO(26), see A.13 Exceptions in Input-Output(26), see A.13(4).
use_package_clause 9.4 Use Clauses.
used 9.4 Use Clauses(2), see N. Syntax Summary (informative)(2), see P(1).
use_type_clause 9.4 Use Clauses.
used 9.4 Use Clauses(2), see N. Syntax Summary (informative)(2), see P(1).
User 10.1 Task Units and Task Objects.
user-defined assignment 8.6 User-Defined Assignment and Finalization.
user-defined heap management 14.11 Storage Management.
user-defined operator 7.6 Overloading of Operators.
user-defined storage management 14.11 Storage Management.
|
AJ. index
| | Val attribute 4.5.5 Operations of Discrete Types(5), see J. Language-Defined Attributes (informative)(5), see K(258).
Valid B.4 Interfacing with COBOL(33), B.4 Interfacing with COBOL(38), see B.4 Interfacing with COBOL(33), B.4 Interfacing with COBOL(38), see B.4(43),
F.3.3 The Package Text_IO.Editing(5), see F.3.3 The Package Text_IO.Editing(5), see F.3.3(12).
Valid attribute 14.9.2 The Valid Attribute(3), see H. Safety and Security (normative)(6), see J. Language-Defined Attributes (informative)(3), see H. Safety and Security (normative)(6), see K(262).
Value A.4.2 The Package Strings.Maps(21), see A.5.2 Random Number Generation(14), see A.5.2 Random Number Generation(21), see A.5.2 Random Number Generation(14), see A.5.2(26),
B.3.1 The Package Interfaces.C.Strings(13), see B.3.1 The Package Interfaces.C.Strings(14), see B.3.1 The Package Interfaces.C.Strings(13), see B.3.1 The Package Interfaces.C.Strings(14), see B.3.1(15),
B.3.1 The Package Interfaces.C.Strings(16), see B.3.2 The Generic Package Interfaces.C.Pointers(6), B.3.2 The Generic Package Interfaces.C.Pointers(16), see B.3.2 The Generic Package Interfaces.C.Pointers(6), B.3.2(7),
C.7.2 The Package Task_Attributes.
Value attribute 4.5 Scalar Types(52), see J. Language-Defined Attributes (informative)(52), see K(264).
value conversion 5.6 Type Conversions.
Var_Line 4.6.1 Index Constraints and Discrete Ranges.
variable 4.3 Objects and Named Numbers.
variable object 4.3 Objects and Named Numbers.
variable view 4.3 Objects and Named Numbers.
variant 4.8.1 Variant Parts and Discrete Choices.
used 4.8.1 Variant Parts and Discrete Choices(2), see N. Syntax Summary (informative)(2), see P(1).
See also tagged type 4.9 Tagged Types and Type Extensions.
variant_part 4.8.1 Variant Parts and Discrete Choices.
used 4.8 Record Types(4), see N. Syntax Summary (informative)(4), see P(1).
Vector 4.6 Array Types(26), see 13.1 Generic Declarations(24), see 13.5.3 Formal Array Types(26), see 13.1 Generic Declarations(24), see 12.5.3(11).
version
of a compilation unit E.3 Consistency of a Distributed System.
Version attribute E.3 Consistency of a Distributed System(3), see J. Language-Defined Attributes (informative)(3), see K(268).
vertical line 3.1 Character Set.
Vertical_Line A.3.3 The Package Characters.Latin_1.
view 4.1 Declarations(7), see M. Glossary (informative)(12), see M. Glossary (informative)(7), see M. Glossary (informative)(12), see N(42).
view conversion 5.6 Type Conversions.
virtual function
See dispatching subprogram 4.9.2 Dispatching Operations of Tagged Types.
Virtual_Length B.3.2 The Generic Package Interfaces.C.Pointers.
visibility
direct 9.3 Visibility(2), see 9.3 Visibility(2), see 8.3(21).
immediate 9.3 Visibility(4), see 9.3 Visibility(4), see 8.3(21).
use clause 9.3 Visibility(4), see 9.4 Use Clauses(4), see 8.4(9).
visibility rules 9.3 Visibility.
visible 9.3 Visibility(2), see 9.3 Visibility(2), see 8.3(14).
within a pragma in a context_clause 11.1.6 Environment-Level Visibility Rules.
within a pragma that appears at the place of a compilation unit
11.1.6 Environment-Level Visibility Rules.
within a with_clause 11.1.6 Environment-Level Visibility Rules.
within a use_clause in a context_clause 11.1.6 Environment-Level Visibility Rules.
within the parent_unit_name of a library unit 11.1.6 Environment-Level Visibility Rules.
within the parent_unit_name of a subunit 11.1.6 Environment-Level Visibility Rules.
visible part 9.2 Scope of Declarations.
of a formal package 13.7 Formal Packages.
of a generic unit 9.2 Scope of Declarations.
of a package (other than a generic formal package)
8.1 Package Specifications and Declarations.
of a protected unit 10.4 Protected Units and Protected Objects.
of a task unit 10.1 Task Units and Task Objects.
of a view of a callable entity 9.2 Scope of Declarations.
of a view of a composite type 9.2 Scope of Declarations.
volatile C.6 Shared Variable Control.
Volatile pragma C.6 Shared Variable Control(4), see K. Language-Defined Pragmas (informative)(4), see L(38).
Volatile_Components pragma C.6 Shared Variable Control(6), see K. Language-Defined Pragmas (informative)(6), see L(39).
Volt 4.5.9 Fixed Point Types.
VT A.3.3 The Package Characters.Latin_1.
VTS A.3.3 The Package Characters.Latin_1.
|
AK. index
| | wchar_t B.3 Interfacing with C.
Weekday 4.5.1 Enumeration Types.
well-formed picture String
for edited output F.3.1 Picture String Formation.
Wide_Bounded
child of Ada.Strings A.4.7 Wide_String Handling.
Wide_Character 4.5.2 Character Types(3), see A.1 The Package Standard(3), see A.1(36).
Wide_Character_Mapping A.4.7 Wide_String Handling.
Wide_Character_Mapping_Function A.4.7 Wide_String Handling.
Wide_Character_Range A.4.7 Wide_String Handling.
Wide_Character_Sequence A.4.7 Wide_String Handling.
Wide_Character_Set A.4.7 Wide_String Handling.
Wide_Constants
child of Ada.Strings.Wide_Maps A.4.7 Wide_String Handling.
Wide_Fixed
child of Ada.Strings A.4.7 Wide_String Handling.
Wide_Image attribute 4.5 Scalar Types(28), see J. Language-Defined Attributes (informative)(28), see K(270).
Wide_Maps
child of Ada.Strings A.4.7 Wide_String Handling.
wide_nul B.3 Interfacing with C.
Wide_Space A.4.1 The Package Strings.
Wide_String 4.6.3 String Types(4), see A.1 The Package Standard(4), see A.1(41).
Wide_Text_IO
child of Ada A.11 Wide Text Input-Output.
Wide_Unbounded
child of Ada.Strings A.4.7 Wide_String Handling.
Wide_Value attribute 4.5 Scalar Types(40), see J. Language-Defined Attributes (informative)(40), see K(274).
Wide_Width attribute 4.5 Scalar Types(38), see J. Language-Defined Attributes (informative)(38), see K(278).
Width attribute 4.5 Scalar Types(39), see J. Language-Defined Attributes (informative)(39), see K(280).
with_clause 11.1.2 Context Clauses - With Clauses.
used 11.1.2 Context Clauses - With Clauses(3), see N. Syntax Summary (informative)(3), see P(1).
mentioned in 11.1.2 Context Clauses - With Clauses(6)
within
immediately 9.1 Declarative Region.
word 14.3 Representation Attributes(8), see 14.5.1 Record Representation Clauses(8), see 13.5.1(25).
Word_Size 14.7 The Package System.
named number in package System 14.7 The Package System.
Worker A.5.2 Random Number Generation.
Write 8.5 Limited Types(19), 8.5 Limited Types(20), 10.1 Task Units and Task Objects(19), 8.5 Limited Types(20), 9.1(24),
10.11 Example of Tasking and Synchronization(8), 10.11 Example of Tasking and Synchronization(9), 14.13.1 The Package Streams(8), 10.11 Example of Tasking and Synchronization(9), 13.13.1(6),
A.8.1 The Generic Package Sequential_IO(12), A.8.4 The Generic Package Direct_IO(13), A.9 The Generic Package Storage_IO(12), A.8.4 The Generic Package Direct_IO(13), A.9(7),
A.12.1 The Package Streams.Stream_IO(18), see A.12.1 The Package Streams.Stream_IO(19), see E.5 Partition Communication Subsystem(18), see A.12.1 The Package Streams.Stream_IO(19), see E.5(8).
Write attribute 14.13.2 Stream-Oriented Attributes(3), see 14.13.2 Stream-Oriented Attributes(3), see 13.13.2(11),
J. Language-Defined Attributes (informative)(282), J. Language-Defined Attributes (informative)(282), K(286).
Write clause 14.3 Representation Attributes(7), see 14.13.2 Stream-Oriented Attributes(7), see 13.13.2.
|
AL. index
AM. index
Table of Contents
Short Table of Contents
Foreword
Introduction
2. General
3. Lexical Elements
4. Declarations and Types
5. Names and Expressions
6. Statements
7. Subprograms
8. Packages
9. Visibility Rules
10. Tasks and Synchronization
11. Program Structure and Compilation Issues
12. Exceptions
13. Generic Units
14. Representation Issues
A. Predefined Language Environment (normative)
B. Interface to Other Languages (normative)
C. Systems Programming (normative)
D. Real-Time Systems (normative)
E. Distributed Systems (normative)
F. Information Systems (normative)
G. Numerics (normative)
H. Safety and Security (normative)
I. Obsolescent Features (normative)
J. Language-Defined Attributes (informative)
K. Language-Defined Pragmas (informative)
L. Implementation-Defined Characteristics (informative)
M. Glossary (informative)
N. Syntax Summary (informative)
O. index
P. index
Q. index
R. index
S. index
T. index
U. index
V. index
W. index
X. index
Y. index
Z. index
AA. index
AB. index
AC. index
AD. index
AE. Index
AF. index
AG. index
AH. index
AI. index
AJ. index
AK. index
AL. index
AM. index
About this document
This document was generated by Mail Server on May, 23 2002
using texi2html
The buttons in the navigation panels have the following meaning:
| Button |
Name |
Go to |
From 1.2.3 go to |
|
[ < ] |
Back
|
previous section in reading order
|
1.2.2
|
|
[ > ] |
Forward
|
next section in reading order
|
1.2.4
|
|
[ << ] |
FastBack
|
previous or up-and-previous section
|
1.1
|
|
[ Up ] |
Up
|
up section
|
1.2
|
|
[ >> ] |
FastForward
|
next or up-and-next section
|
1.3
|
|
[Top] |
Top
|
cover (top) of document
|
|
|
[Contents] |
Contents
|
table of contents
|
|
|
[Index] |
Index
|
concept index
|
|
|
[ ? ] |
About
|
this page
|
|
where the Example assumes that the current position
is at Subsubsection One-Two-Three of a document of
the following structure:
- 1. Section One
- 1.1 Subsection One-One
- 1.2 Subsection One-Two
- 1.2.1 Subsubsection One-Two-One
- 1.2.2 Subsubsection One-Two-Two
- 1.2.3 Subsubsection One-Two-Three
<== Current Position
- 1.2.4 Subsubsection One-Two-Four
- 1.3 Subsection One-Three
- 1.4 Subsection One-Four
This document was generated
by Mail Server on May, 23 2002
using texi2html
|