[Home] [Prev] [Next] [Index]

- operator
& operator
* operator
** operator
+ operator
/ operator
/= operator
< operator
<= operator
= operator
> operator
>= operator

10646-1
1993, ISO/IEC standard
1539
1991, ISO/IEC standard
1989
1985, ISO standard
6429
1992, ISO/IEC standard
646
1991, ISO/IEC standard
8859-1
1987, ISO/IEC standard
9899
1990, ISO/IEC standard

A

abnormal completion
abnormal state of an object
abnormal task
abnormal termination
of a partition
abort
of a partition
of a task
of the execution of a construct
abort completion point
abort-deferred operation
abs operator
absolute value
abstract data type (ADT)
See also abstract type
See private types and private extensions
abstract subprogram
abstract type
acceptable interpretation
Access attribute
See also Unchecked_Access attribute
access discriminant
access parameter
access paths
distinct
access type
access types
input-output unspecified
access value
Access_Check
accessibility
from shared passive library units
accessibility level
accessibility rule
Access attribute
checking in generic units
not part of generic contract
record extension
requeue statement
type conversion
Accessibility_Check
accessible partition
access-to-constant type
access-to-object type
access-to-subprogram type
access-to-variable type
accuracy
ACID
acquire
execution resource associated with protected object
activation
of a task
activation failure
activator
of a task
active partition
active priority
actual
actual duration
actual parameter
for a formal parameter
actual subtype
of an object
actual type
ACVC
Ada Compiler Validation Capability
Ada
Ada calling convention
Ada Commentary Integration Document (ACID)
Ada Compiler Validation Capability
ACVC
Ada Issue (AI)
Ada Rapporteur Group (ARG)
Ada.Asynchronous_Task_Control
Ada.Calendar
Ada.Characters
Ada.Characters.Handling
Ada.Characters.Latin_1
Ada.Command_Line
Ada.Decimal
Ada.Direct_IO
Ada.Dynamic_Priorities
Ada.Exceptions
Ada.Finalization
Ada.Float_Text_IO
Ada.Float_Wide_Text_IO
Ada.Integer_Text_IO
Ada.Integer_Wide_Text_IO
Ada.Interrupts
Ada.Interrupts.Names
Ada.IO_Exceptions
Ada.Numerics
Ada.Numerics.Complex_Elementary_Functions
Ada.Numerics.Complex_Types
Ada.Numerics.Discrete_Random
Ada.Numerics.Elementary_Functions
Ada.Numerics.Float_Random
Ada.Numerics.Generic_Complex_Elementary_Functions
Ada.Numerics.Generic_Complex_Types
Ada.Numerics.Generic_Elementary_Functions
Ada.Real_Time
Ada.Sequential_IO
Ada.Storage_IO
Ada.Streams
Ada.Streams.Stream_IO
Ada.Strings
Ada.Strings.Bounded
Ada.Strings.Fixed
Ada.Strings.Maps
Ada.Strings.Maps.Constants
Ada.Strings.Unbounded
Ada.Strings.Wide_Bounded
Ada.Strings.Wide_Fixed
Ada.Strings.Wide_Maps
Ada.Strings.Wide_Maps.Wide_Constants
Ada.Strings.Wide_Unbounded
Ada.Synchronous_Task_Control
Ada.Tags
Ada.Task_Attributes
Ada.Task_Identification
Ada.Text_IO
Ada.Text_IO.Complex_IO
Ada.Text_IO.Editing
Ada.Text_IO.Text_Streams
Ada.Unchecked_Conversion
Ada.Unchecked_Deallocation
Ada.Wide_Text_IO
Ada.Wide_Text_IO.Complex_IO
Ada.Wide_Text_IO.Editing
Ada.
arithmetic
comparison
null
Address clause
Adjust
adjusting the value of an object
adjustment
as part of assignment
ADT (abstract data type)
See also abstract type
See private types and private extensions
advice
aggregate
See also composite type
AI
aliased
aliasing
See distinct access paths
Alignment clause
All_Checks
alphanumeric character
a category of Character
ambiguous
ambiguous grammar
ampersand
ampersand operator
ancestor
of a library unit
of a type
ultimate
ancestor subtype
of a formal derived type
of a private_extension_declaration
and operator
and then (short-circuit control form)
angle threshold
Annex
informative
normative
Specialized Needs
anonymous access type
anonymous array type
anonymous protected type
anonymous task type
anonymous type
apostrophe
applicable index constraint
application areas
apply
to a callable construct by a return_statement
to a loop_statement by an exit_statement
to a program unit by a program unit pragma
arbitrary order
ARG
argument of a pragma
array
array component expression
array indexing
See indexed_component
array slice
array type
ASCII
package physically nested within the declaration of Standard
aspect of representation
coding
controlled
convention, calling convention
exported
imported
layout
packing
record layout
specifiable attributes
storage place
assembly language
assign
See assignment operation
assigning back of parameters
assignment
user-defined
assignment operation
during elaboration of an object_declaration
during evaluation of a generic_association for a formal object of mode in
during evaluation of a parameter_association
during evaluation of an aggregate
during evaluation of an initialized allocator
during evaluation of an uninitialized allocator
during evaluation of concatenation
during execution of a for loop
during execution of a return_statement
during execution of an assignment_statement
during parameter copy back
list of uses
associated components
of a record_component_association
associated discriminants
of a named discriminant_association
of a positional discriminant_association
associated object
of a value of a by-reference type
of a value of a limited type
asterisk
asynchronous
remote procedure call
asynchronous remote procedure call
at-most-once execution
atomic
attaching
to an interrupt
attribute
representation
specifiable
specifying
avoid overspecifying environmental issues

B

Backus-Naur Form (BNF)
notation
under Syntax heading
base
base 16 literal
base 2 literal
base 8 literal
base decimal precision
of a floating point type
base priority
base range
of a decimal fixed point type
of a fixed point type
of a floating point type
of a modular type
of a scalar type
of a signed integer type
of an enumeration type
of an ordinary fixed point type
base subtype
of a type
basic letter
a category of Character
Beaujolais effect
become nonlimited
belong
to a range
to a subtype
bibliography
big endian
binary
literal
binary adding operator
binary literal
binary operator
bit field
See record_representation_clause
bit ordering
bit string
See logical operators on boolean arrays
Bit_Order clause
blank
in text input for enumeration and numeric types
blocked
a task state
during an entry call
execution of a selective_accept
on a delay_statement
on an accept_statement
waiting for activations to complete
waiting for dependents to terminate
blocked interrupt
blocking, potentially
Abort_Task
delay_statement
remote subprogram call
RPC operations
Suspend_Until_True
BMP
BNF (Backus-Naur Form)
notation
under Syntax heading
Boolean
boolean type
bounded error
bounds
of a discrete_range
of an array
of the index range of an array_aggregate
box
compound delimiter
broadcast signal
See protected object
See requeue
by copy parameter passing
by reference parameter passing
by-copy type
by-reference type
atomic or volatile
byte
See storage element
byte sex
See ordering of storage elements in a word

C

C interface
C standard
call
call on a dispatching operation
callable
callable construct
callable entity
called partition
calling convention
Ada
associated with a designated profile
entry
Intrinsic
protected
calling partition
calling stub
cancellation
of a delay_statement
of an entry call
cancellation of a remote subprogram call
canonical form
canonical semantics
canonical-form representation
case insensitive
cast
See type conversion
See unchecked type conversion
catch (an exception)
See handle
categorization pragma
Remote_Call_Interface
Remote_Types
Shared_Passive
categorized library unit
catenation operator
See concatenation operator
ceiling priority
of a protected object
change of representation
Character
character set
character set standard
16-bit
7-bit
8-bit
control functions
character type
characteristics
check
language-defined
child
of a library unit
choice
of an exception_handler
choice parameter
class
of types
See also package
See also tag
class determined for a formal type
class-wide type
cleanup
See finalization
clock
clock jump
clock tick
close result set
closed entry
of a protected object
of a task
closed under derivation
closure
downward
COBOL interface
COBOL standard
coding
aspect of representation
colon
column number
comma
comments, instructions for submission
comparison operator
See relational operator
compatibility
composite_constraint with an access subtype
constraint with a subtype
delta_constraint with an ordinary fixed point subtype
digits_constraint with a decimal fixed point subtype
digits_constraint with a floating point subtype
discriminant constraint with a subtype
index constraint with a subtype
range with a scalar subtype
range_constraint with a scalar subtype
compatible
a type, with a convention
compilation
separate
compilation unit
compilation units needed
by a compilation unit
remote call interface
shared passive library unit
compile-time error
compile-time semantics
complete context
completely defined
completion
abnormal
compile-time concept
normal
run-time concept
completion and leaving (completed and left)
completion legality
entry_body
component
component subtype
Component_Size clause
components
of a record type
composite type
compound delimiter
concatenation operator
concrete subprogram
See nonabstract subprogram
concrete type
See nonabstract type
concurrent processing
See task
condition
See also exception
configuration
of the partitions of a program
configuration pragma
Locking_Policy
Normalize_Scalars
Queuing_Policy
Restrictions
Reviewable
Suppress
Task_Dispatching_Policy
conformance
of an implementation with the Standard
See also full conformance
See also mode conformance
See also subtype conformance
See also type conformance
consistency
among compilation units
constant
result of a function_call
See also literal
See also static
constant object
constant view
constituent
of a construct
constrained
object
subtype
constrained by its initial value
constraint
of a first array subtype
of an object
Constraint_Error
raised by failure of run-time check
constructor
See initialization
See initialization expression
See Initialize
See initialized alligator
context free grammar
notation
under Syntax heading
contiguous representation
contract model of generics
control character
a category of Character
See also format_effector
See also other_control_function
controlled
aspect of representation
controlled type
controlling formal parameter
controlling operand
controlling result
controlling tag
for a call on a dispatching operation
controlling tag value
for the expression in an assignment_statement
convention
aspect of representation
conversion
access
arbitrary order
array
composite (non-array)
enumeration
numeric
unchecked
value
view
convertible
required
copy back of parameters
copy parameter passing
core language
corresponding constraint
corresponding discriminants
corresponding index
for an array_aggregate
corresponding subtype
corresponding value
of the target type of a conversion
cover
a type
of a choice and an exception
cover a value
by a discrete_choice
by a discrete_choice_list
create
creation
of a protected object
of a task object
of an object
critical section
See intertask communication
current column number
current index
of an open direct file
current instance
of a generic unit
of a type
current line number
current mode
of an open file
current page number
current size
of an external file

D

dangling references
prevention via accessibility rules
deallocation of storage
decimal digit
a category of Character
decimal fixed point type
declaration
declarative region
of a construct
declare
declared pure
deeper
accessibility level
statically
default entry queuing policy
default treatment
deferred constant
deferred constant declaration
defining name
definite subtype
delimiter
delivery
of an interrupt
delta
of a fixed point type
denormalized number
denote
informal definition
name used as a pragma argument
depend on a discriminant
for a component
for a constraint or component_definition
dependence
elaboration
of a task on a master
of a task on another task
semantic
depth
accessibility level
dereference
derivation class
for a type
derived from
directly or indirectly
derived type
descendant
of a type
relationship with scope
designate
designated profile
of an access-to-subprogram type
designated subtype
of a named access type
of an anonymous access type
designated type
of a named access type
of an anonymous access type
destructor
See finalization
determined class for a formal type
determines
a type by a subtype_mark
digit
digits
of a decimal fixed point subtype
dimensionality
of an array
direct access
direct file
directly specified
of an aspect of representation of an entity
directly visible
within a pragma in a context_clause
within a pragma that appears at the place of a compilation unit
within a use_clause in a context_clause
within a with_clause
within the parent_unit_name of a library unit
within the parent_unit_name of a subunit
discontiguous representation
discrete array type
discrete type
discriminant
of a variant_part
Discriminant_Check
discriminants
known
unknown
discriminated type
dispatching
dispatching call
on a dispatching operation
dispatching operation
dispatching point
dispatching policy for tasks
dispatching, task
displayed magnitude (of a decimal value)
disruption of an assignment
distinct access paths
distributed program
distributed system
distributed systems
divide
divide operator
Division_Check
documentation (required of an implementation)
documentation requirements
dope
dot
dot selection
See selected_component
downward closure
drift rate
dynamic binding
See dispatching operation
dynamic semantics
dynamically determined tag
dynamically enclosing
of one execution by another
dynamically tagged

E

edited output
effect
external
efficiency
elaborable
elaborated
elaboration
abstract_subprogram_declaration
access_definition
access_type_definition
array_type_definition
choice_parameter_specification
component_declaration
component_definition
component_list
declaration named by a pragma Import
declarative_part
deferred constant declaration
delta_constraint
derived_type_definition
digits_constraint
discrete_subtype_definition
discriminant_constraint
entry_declaration
enumeration_type_definition
exception_declaration
fixed_point_definition
floating_point_definition
full type definition
full_type_declaration
generic body
generic_declaration
generic_instantiation
incomplete_type_declaration
index_constraint
integer_type_definition
loop_parameter_specification
nongeneric package_body
non-generic subprogram_body
number_declaration
object_declaration
package_body of Standard
package_declaration
partition
pragma
private_extension_declaration
private_type_declaration
protected declaration
protected_body
protected_definition
range_constraint
real_type_definition
record_definition
record_extension_part
record_type_definition
renaming_declaration
representation_clause
single_protected_declaration
single_task_declaration
Storage_Size pragma
subprogram_declaration
subtype_declaration
subtype_indication
task declaration
task_body
task_definition
elaboration control
elaboration dependence
library_item on another
Elaboration_Check
element
of a storage pool
elementary type
eligible
a type, for a convention
else part
of a selective_accept
embedded systems
encapsulation
See package
enclosing
immediately
end of a line
endian
big
little
entity
entry
closed
open
single
entry call
simple
entry calling convention
entry family
entry index subtype
entry queue
entry queuing policy
default policy
enumeration literal
enumeration type
environment
environment declarative_part
for the environment task of a partition
environment task
epoch
equal operator
equality operator
special inheritance rule for tagged types
equals sign
equivalence of use_clauses and selected_components
erroneous execution
error
compile-time
link-time
run-time
See also bounded error
See also erroneous execution
evaluable
evaluation
aggregate
allocator
array_aggregate
attribute_reference
concatenation
dereference
discrete_range
extension_aggregate
generic_association
generic_association for a formal object of mode in
indexed_component
initialized allocator
membership test
name
name that has a prefix
null literal
numeric literal
parameter_association
prefix
primary that is a name
qualified_expression
range
range_attribute_reference
record_aggregate
record_component_association_list
selected_component
short-circuit control form
slice
string_literal
uninitialized allocator
Val
Value
value conversion
view conversion
Wide_Value
exception
exception occurrence
executable
execution
abort_statement
aborting the execution of a construct
accept_statement
Ada program
assignment_statement
asynchronous_select with a delay_statement trigger
asynchronous_select with an entry call trigger
block_statement
call on a dispatching operation
call on an inherited subprogram
case_statement
conditional_entry_call
delay_statement
dynamically enclosing
entry_body
entry_call_statement
exit_statement
goto_statement
handled_sequence_of_statements
handler
if_statement
included by another execution
instance of Unchecked_Deallocation
loop_statement
loop_statement with a for iteration_scheme
loop_statement with a while iteration_scheme
null_statement
partition
pragma
program
protected subprogram call
raise_statement with an exception_name
remote subprogram call
requeue protected entry
requeue task entry
requeue_statement
re-raise statement
return_statement
selective_accept
sequence_of_statements
subprogram call
subprogram_body
task
task_body
timed_entry_call
execution resource
associated with a protected object
required for a task to run
expanded name
expected profile
accept_statement entry_direct_name
Access attribute_reference prefix
attribute_definition_clause name
character_literal
formal subprogram actual
formal subprogram default_name
subprogram_renaming_declaration
expected type
abort_statement task_name
access attribute_reference
actual parameter
aggregate
allocator
array_aggregate
array_aggregate component expression
array_aggregate discrete_choice
assignment_statement expression
assignment_statement variable_name
attribute_definition_clause expression or name
attribute_designator expression
case expression
case_statement_alternative discrete_choice
character_literal
code_statement
component_clause expressions
component_declaration default_expression
condition
decimal fixed point type digits
delay_relative_statement expression
delay_until_statement expression
delta_constraint expression
dereference name
discrete_subtype_definition range
discriminant default_expression
discriminant_association expression
entry_index
enumeration_representation_clause expressions
extension_aggregate
extension_aggregate ancestor expression
first_bit
fixed point type delta
generic formal in object actual
generic formal object default_expression
index_constraint discrete_range
indexed_component expression
Interrupt_Priority pragma argument
last_bit
link name
membership test simple_expression
modular_type_definition expression
null literal
number_declaration expression
object_declaration initialization expression
parameter default_expression
position
Priority pragma argument
range simple_expressions
range_attribute_designator expression
range_constraint range
real_range_specification bounds
record_aggregate
record_component_association expression
expiration time
for a delay_relative_statement
for a delay_until_statement
explicit declaration
explicit initial value
explicitly assign
exponent
exponentiation operator
exported
aspect of representation
exported entity
expression
extension
of a private type
of a record type
of a type
extensions to Ada 83
external call
external effect
of the execution of an Ada program
volatile/atomic objects
external file
external interaction
external name
external requeue
External_Tag clause
extra permission to avoid raising exceptions
extra permission to reorder actions

F

failure
of a language-defined check
False
family
entry
file
as file object
file terminator
finalization
of a master
of a protected object
of a task object
of an object
Finalize
Fine_Delta
named number in package System
first subtype
fixed point type
Float
floating point type
form
of an external file
formal object, generic
formal package, generic
formal parameter
of a subprogram
formal subprogram, generic
formal subtype
formal type
format_effector
Fortran interface
FORTRAN standard
freed
See nonexistent
freeing storage
freezing
by a constituent of a construct
by an expression
class-wide type caused by the freezing of the specific type
constituents of a full type definition
designated subtype caused by an allocator
entity
entity caused by a body
entity caused by a construct
entity caused by a name
entity caused by the end of an enclosing construct
first subtype caused by the freezing of the type
function call
generic_instantiation
nominal subtype caused by a name
object_declaration
specific type caused by the freezing of the class-wide type
subtype caused by a record extension
subtypes of the profile of a callable entity
type caused by a range
type caused by an expression
type caused by the freezing of a subtype
freezing points
entity
full conformance
for discrete_subtype_definitions
for expressions
for known_discriminant_parts
for profiles
required
full constant declaration
full declaration
full stop
full type
full type definition
full view
of a type
function
function instance

G

gaps
garbage collection
general access type
generation
of an interrupt
generic actual
generic actual parameter
generic actual subtype
generic actual type
generic body
generic contract issue
generic contract model
generic contract/private type contract analogy
generic formal
generic formal object
generic formal package
generic formal subprogram
generic formal subtype
generic formal type
generic function
generic package
generic procedure
generic subprogram
generic unit
See also dispatching operation
global to
govern a variant
govern a variant_part
grammar
ambiguous
notation
resolution of ambiguity
under Syntax heading
graphic character
a category of Character
greater than operator
greater than or equal operator
greater-than sign

H

handle
an exception
an exception occurrence
handler
head (of a queue)
heap management
See also alligator
user-defined
held priority
heterogeneous input-output
hexadecimal
literal
hexadecimal digit
a category of Character
hexadecimal literal
hidden from all visibility
by lack of a with_clause
for a declaration completed by a subsequent declaration
for overridden declaration
within the declaration itself
hidden from direct visibility
by an inner homograph
where hidden from all visibility
hiding
High_Order_First
highest precedence operator
homograph

hyphen-minus

I

identifier specific to a pragma
identifier_letter
idle task
IEC 559
1989
IEEE floating point arithmetic
illegal
construct
partition
image
of a value
immediate scope
of (a view of) an entity
of a declaration
immediately enclosing
immediately visible
immediately within
implementation
implementation advice
implementation defined
implementation permissions
implementation requirements
implementation-dependent
See unspecified
implicit declaration
implicit initial values
for a subtype
implicit subtype conversion
Access attribute
access discriminant
array bounds
array index
assignment to view conversion
assignment_statement
bounds of a decimal fixed point type
bounds of a fixed point type
bounds of a floating point type
bounds of a range
bounds of signed integer type
choices of aggregate
component defaults
delay expression
derived type discriminants
discriminant values
entry index
expressions in aggregate
expressions of aggregate
function return
generic formal object of mode in
inherited enumeration literal
initialization expression
initialization expression of allocator
named number value
operand of concatenation
parameter passing
pragma Interrupt_Priority
pragma Priority
qualified_expression
reading a view conversion
result of inherited function
imported
aspect of representation
imported entity
in (membership test)
inaccessible partition
inactive
a task state
included
one execution by another
one range in another
incompatibilities with Ada 83
incomplete type
inconsistencies with Ada 83
indefinite subtype
independent subprogram
independently addressable
index
of an array
of an element of an open direct file
index range
index subtype
index type
Index_Check
indivisible
information hiding
See package
See private types and private extensions
information systems
informative
inheritance
See also tagged types and type extension
See derived types and classes
inherited
from an ancestor type
inherited component
inherited discriminant
inherited entry
inherited protected subprogram
inherited subprogram
initialization
of a protected object
of a task object
of an object
initialization expression
Initialize
initialized allocator
innermost dynamically enclosing
input
Input clause
input-output
unspecified for access types
inspectable object
inspection point
instance
of a generic function
of a generic package
of a generic procedure
of a generic subprogram
of a generic unit
instructions for comment submission
Integer
integer literal
integer literals
integer type
interaction
between tasks
interface to assembly language
interface to C
interface to COBOL
interface to Fortran
interface to other languages
Interfaces
Interfaces.C
Interfaces.C.Pointers
Interfaces.C.Strings
Interfaces.COBOL
Interfaces.Fortran
interfacing pragma
Convention
Export
Import
internal call
internal code
internal requeue
interpretation
of a complete context
of a constituent of a complete context
overload resolution
interrupt
example using asynchronous_select
interrupt entry
interrupt handler
intertask communication
See also task
Intrinsic calling convention
invalid representation
ISO 10646
ISO 1989
1985
ISO/IEC 10646-1
1993
ISO/IEC 1539
1991
ISO/IEC 6429
1992
ISO/IEC 646
1991
ISO/IEC 8859-1
1987
ISO/IEC 9899
1990
issue
an entry call
italics
formal parameters of attribute functions
implementation-defined
nongraphic characters
pseudo-names of anonymous types
syntax rules
terms introduced or defined
italics, like this

K

known discriminants

L

language
interface to assembly
interface to non-Ada
language-defined check
language-defined class
of types
Language-Defined Library Units
Language-Defined Types
Address in System
Alignment in Ada.Strings
Alphanumeric in Interfaces.COBOL
Attribute_Handle in Ada.Task_Attributes
Binary in Interfaces.COBOL
Binary_Format in Interfaces.COBOL
Bit_Order in System
Boolean in Standard
Bounded_String in Ada.Strings.Bounded.Generic_Bounded_Length
Byte in Interfaces.COBOL
Byte_Array in Interfaces.COBOL
C_float in Interfaces.C
char in Interfaces.C
char_array in Interfaces.C
char_array_access in Interfaces.C
Character in Standard
Character_Set in Ada.Strings.Maps
chars_ptr in Interfaces.C
chars_ptr_array in Interfaces.C
COBOL_Character in Interfaces.COBOL
Complex in Ada.Numerics.Generic_Complex_Types
Controlled in Ada.Finalization
Count in Ada.Direct_IO
Count in Ada.Text_IO
Decimal_Element in Interfaces.COBOL
Direction in Ada.Strings
Display_Format in Interfaces.COBOL
double in Interfaces.C
Duration in Standard
Exception_Id in Ada.Exceptions
Exception_Occurrence in Ada.Exceptions
Exception_Occurrence_Access in Ada.Exceptions
File_Mode in Ada.Direct_IO
File_Mode in Ada.Sequential_IO
File_Mode in Ada.Text_IO
File_Type in Ada.Direct_IO
File_Type in Ada.Sequential_IO
File_Type in Ada.Text_IO
Float in Standard
Floating in Interfaces.COBOL
Generator in Ada.Numerics.Discrete_Random
Generator in Ada.Numerics.Float_Random
Imaginary in Ada.Numerics.Generic_Complex_Types
int in Interfaces.C
Integer in Standard
Integer_Address in System.Storage_Elements
Interrupt_ID in Ada.Interrupts
lateness
Latin-1
layout
aspect of representation
leaving
left
left curly bracket
left parenthesis
left square bracket
legal
construct
partition
legality determinable via semantic dependences
legality rules
length
of a dimension of an array
of a one-dimensional array
Length_Check
less than operator
less than or equal operator
less-than sign
letter
a category of Character
level
accessibility
library
lexical element
lexicographic order
library
informal introduction
library level
library unit
informal introduction
See also language-defined library units
library unit pragma
All_Calls_Remote
categorization pragmas
Elaborate_Body
Preelaborate
Pure
library_item
informal introduction
lifetime
limited type
becoming nonlimited
line
line terminator
link name
linking
See partition building
link-time error
See post-compilation error
literal
based
decimal
numeric
See also aggregate
little endian
load time
local to
localization
locking policy
logical operator
See also not operator
Long_Float
Long_Integer
loop parameter
low line
Low_Order_First
lower bound
of a range
lower_case_identifier_letter
lower-case letter
a category of Character
low-level programming
LR(1)

M

machine code insertion
machine numbers
of a floating point type
Machine_Radix clause
macro
See generic unit
main subprogram
for a partition
malloc
See allocator
marshalling
master
match
a character to a pattern character
a character to a pattern character, with respect to a character mapping function
a string to a pattern string
matching components
Max_Base_Digits
named number in package System
Max_Binary_Modulus
named number in package System
Max_Digits
named number in package System
Max_Int
named number in package System
Max_Mantissa
named number in package System
Max_Nonbinary_Modulus
named number in package System
maximum box error
for a component of the result of evaluating a complex function
maximum line length
maximum page length
maximum relative error
for a component of the result of evaluating a complex function
for the evaluation of an elementary function
membership test
mentioned in a with_clause
message
See dispatching call
method
See dispatching subprogram
methodological restriction
metrics
Min_Int
named number in package System
minus
minus operator
mixed-language programs
mod operator
mode conformance
required
mode of operation
nonstandard
standard
model interval
associated with a value
model number
model-oriented attributes
of a floating point subtype
modular type
module
See package
modulus
of a modular type
multi-dimensional array
multiply
multiply operator
multiplying operator
mutable

N

name
of (a view of) an entity
of a pragma
of an external file
name resolution rules
named association
named component association
named discriminant association
named entry index
named number
named type
names of special_characters
Natural
n-dimensional array_aggregate
needed
of a compilation unit by another
remote call interface
shared passive library unit
needed component
extension_aggregate record_component_association_list
record_aggregate record_component_association_list
new
See allocator
nominal subtype
associated with a dereference
associated with a type_conversion
associated with an indexed_component
of a component
of a formal parameter
of a generic formal object
of a name
of a record component
of the result of a function_call
nondispatching call
on a dispatching operation
nonexistent
nongraphic character
nonlimited type
becoming nonlimited
non-normative
See informative
nonstandard integer type
nonstandard mode
nonstandard real type
normal completion
normal library unit
normal state of an object
normal termination
of a partition
normalized exponent
normalized number
normative
not equal operator
not in (membership test)
not operator
notes
notwithstanding
null access value
null array
null constraint
null pointer
See null access value
null range
null record
null slice
null string literal
null value
of an access type
Null_Address
constant in System
number sign
numeric type
numerics

O

object
object-oriented programming (OOP)
See dispatching operations of tagged types
See tagged types and type extensions
obsolescent feature
occur immediately within
occurrence
of an interrupt
occurrence (of an exception)
octal
literal
octal literal
one's complement
modular types
one-dimensional array
one-pass context_clauses
only as a completion
entry_body
OOP (object-oriented programming)
See dispatching operations of tagged types
See tagged types and type extensions
opaque type
See private types and private extensions
open alternative
open entry
of a protected object
of a task
operand
of a qualified_expression
of a type_conversion
operand interval
operand type
of a type_conversion
operates on a type
operation
operator
-
&
*
**
+
/
/=
<
<=
=
>
>=
abs
ampersand
and
binary
binary adding
concatenation
divide
equal
equality
exponentiation
greater than
greater than or equal
highest precedence
less than
less than or equal
logical
minus
mod
multiply
multiplying
not
not equal
or
ordering
plus
predefined
relational
rem
times
unary
unary adding
user-defined
xor
operator precedence
optimization
or else (short-circuit control form)
or operator
ordering operator
ordinary fixed point type
other_control_function
others choice
output
Output clause
overall interpretation
of a complete context
Overflow_Check
overload resolution
overloadable
overloaded
enumeration literal
overloading rules
override
a primitive subprogram

P

package instance
package-private extension
package-private type
packed
packing
aspect of representation
padding bits
page terminator
parallel processing
See task
parameter
See also discriminant
See also loop parameter
See formal parameter
See generic formal parameter
parameter assigning back
parameter copy back
parameter mode
parameter passing
parent body
of a subunit
parent declaration
of a library unit
of a library_item
parent subtype
parent type
parent unit
of a library unit
part
of an object or value
Access_Check
Accessibility_Check
Ceiling_Check
Discriminant_Check
Division_Check
Elaboration_Check
Index_Check
Length_Check
Overflow_Check
Partition_Check
Range_Check
Reserved_Check
Storage_Check
Tag_Check
partial view
of a type
partition
partition building
partition communication subsystem (PCS)
pass by copy
pass by reference
passive partition
PC-map approach to finalization
PCS (partition communication subsystem)
pending interrupt occurrence
perfect result set
periodic task
example
See delay_until_statement
per-object constraint
per-object expression
picture String
for edited output
plus operator
plus sign
point
pointer
See access value
See type System.Address
pointer type
See access type
polymorphism
pool element
pool type
pool-specific access type
position number
of an enumeration value
of an integer value
positional association
positional component association
positional discriminant association
Positive
POSIX
possible interpretation
for direct_names
for selector_names
post-compilation error
post-compilation rules
potentially blocking operation
Abort_Task
delay_statement
remote subprogram call
RPC operations
Suspend_Until_True
potentially use-visible
pragma argument
pragma name
pragma, categorization
Remote_Call_Interface
Remote_Types
Shared_Passive
pragma, configuration
Locking_Policy
Normalize_Scalars
Queuing_Policy
Restrictions
Reviewable
Suppress
Task_Dispatching_Policy
pragma, identifier specific to
pragma, interfacing
Convention
Export
Import
Linker_Options
pragma, library unit
All_Calls_Remote
categorization pragmas
Elaborate_Body
Preelaborate
Pure
pragma, program unit
Convention
Export
Import
Inline
library unit pragmas
pragma, representation
Asynchronous
Atomic
Atomic_Components
Controlled
Convention
Discard_Names
Export
Import
Pack
Volatile
Volatile_Components
precedence of operators
predefined environment
predefined exception
predefined library unit
See language-defined library units
predefined operation
of a type
predefined operations
of a discrete type
of a fixed point type
of a floating point type
of a record type
of an access type
of an array type
predefined operator
predefined type
See language-defined types
preelaborable
of an elaborable construct
preelaborated
preempted task
preemptible resource
preference
for root numeric operators and ranges
preference control
See requeue
prescribed result
for the evaluation of a complex arithmetic operation
for the evaluation of a complex elementary function
for the evaluation of an elementary function
primitive function
primitive operation
primitive operations
of a type
primitive operator
of a type
primitive subprograms
of a type
priority
priority inheritance
priority inversion
priority of an entry call
private declaration of a library unit
private descendant
of a library unit
private extension
private library unit
private operations
private part
of a package
of a protected unit
of a task unit
private type
private types and private extensions
procedure
procedure instance
processing node
profile
associated with a dereference
fully conformant
mode conformant
subtype conformant
type conformant
profile resolution rule
name with a given expected profile
program
program execution
program library
See library
program unit pragma
Convention
Export
Import
Inline
library unit pragmas
Program_Error
raised by failure of run-time check
program-counter-map approach to finalization
propagate
an exception by a construct
an exception by an execution
an exception occurrence by an execution, to a dynamically enclosing execution
protected action
complete
start
protected calling convention
protected declaration
protected entry
protected function
protected object
protected operation
protected procedure
protected subprogram
protected unit
public declaration of a library unit
public descendant
of a library unit
public library unit
pure

Q

queuing policy
quotation mark
quoted string
See string_literal

R

raise
an exception
an exception occurrence
random number
range
of a scalar subtype
Range_Check
RCI
generic
library unit
package
read
the value of an object
Read clause
ready
a task state
ready queue
ready task
real literal
real literals
real time
real type
real-time systems
receiving stub
reclamation of storage
recommended level of support
Address attribute
Alignment attribute for objects
Alignment attribute for subtypes
bit ordering
Component_Size attribute
enumeration_representation_clause
pragma Pack
record_representation_clause
required in Systems Programming Annex
Size attribute
unchecked conversion
with respect to nonstatic expressions
record
record extension
record layout
aspect of representation
record type
reference parameter passing
references
relational operator
relaxed mode
release
execution resource associated with protected object
rem operator
remote access
remote access type
remote access-to-class-wide type
remote access-to-subprogram type
remote call interface
remote procedure call
asynchronous
remote subprogram
remote subprogram binding
remote subprogram call
remote types library unit
renamed entity
renamed view
renaming-as-body
renaming-as-declaration
rendezvous
representation
change of
representation aspect
representation attribute
representation item
representation of an object
representation pragma
Asynchronous
Atomic
Atomic_Components
Controlled
Convention
Discard_Names
Export
Import
Pack
Volatile
Volatile_Components
representation-oriented attributes
of a fixed point subtype
of a floating point subtype
represented in canonical form
requested decimal precision
of a floating point type
requeue
requeue-with-abort
requires a completion
declaration of a partial view
declaration to which a pragma Elaborate_Body applies
deferred constant declaration
generic_package_declaration
generic_subprogram_declaration
incomplete_type_declaration
library_unit_declaration
package_declaration
protected entry_declaration
protected_declaration
subprogram_declaration
task_declaration
re-raise statement
reserved interrupt
reserved word
resolution rules
resolve
overload resolution
Restrictions
Immediate_Reclamation
Max_Asynchronous_Select_Nesting
Max_Protected_Entries
Max_Select_Alternatives
Max_Storage_At_Blocking
Max_Task_Entries
Max_Tasks
No_Abort_Statements
No_Access_Subprograms
No_Allocators
No_Asynchronous_Control
No_Delay
No_Dispatch
No_Dynamic_Priorities
No_Exceptions
No_Fixed_Point
No_Floating_Point
No_Implicit_Heap_Allocations
No_IO
No_Local_Allocators
No_Nested_Finalization
No_Protected_Types
No_Recursion
No_Reentrancy
No_Task_Allocators
No_Task_Hierarchy
No_Terminate_Alternatives
No_Unchecked_Access
No_Unchecked_Conversion
No_Unchecked_Deallocation
result interval
for a component of the result of evaluating a complex function
for the evaluation of a predefined arithmetic operation
for the evaluation of an elementary function
result subtype
of a function
return expression
return-by-reference type
right curly bracket
right parenthesis
right square bracket
root library unit
root type
of a class
root_integer
root_real
rooted at a type
rotate
RPC-receiver
running a program
See program execution
running task
run-time check
See language-defined check
run-time error
run-time polymorphism
run-time semantics
run-time type
See tag

S

safe range
of a floating point type
safe separate compilation
safety-critical systems
same value
for a limited type
satisfies
a discriminant constraint
a range constraint
an index constraint
for an access value
scalar type
scale
of a decimal fixed point subtype
scope
informal definition
of (a view of) an entity
of a declaration
of a use_clause
of a with_clause
secure systems
select an entry call
from an entry queue
immediately
selection
of an entry caller
semantic dependence
of one compilation unit upon another
semicolon
separate compilation
safe
separator
sequence of characters
of a string_literal
sequential
actions
sequential access
sequential file
service
an entry queue
shared passive library unit
shared variable
protection of
shift
Short_Float
Short_Integer
short-circuit control form
signal
as defined between actions
See interrupt
signal (an exception)
See raise
signal handling
example
signed integer type
simple entry call
single
class expected type
single entry
size
of an object
Size clause
small
of a fixed point type
Small clause
solidus
space_character
special graphic character
a category of Character
special_character
names
Specialized Needs Annexes
specifiable
of Address for entries
of Address for stand-alone objects and for program units
of Alignment for first subtypes and objects
of Bit_Order for record types and record extensions
of Component_Size for array types
of External_Tag for a tagged type
of Input for a type
of Machine_Radix for decimal first subtypes
of Output for a type
of Read for a type
of Size for first subtypes
of Size for stand-alone objects
of Small for fixed point types
of Storage_Pool for a non-derived access-to-object type
of Storage_Size for a non-derived access-to-object type
of Storage_Size for a task first subtype
of Write for a type
specifiable (of an attribute and for an entity)
specific type
specified
of an aspect of representation of an entity
specified (not!)
specified discriminant
squirrel away
included in fairness to alligators
stand-alone constant
corresponding to a formal object of mode in
stand-alone object
stand-alone variable
Standard
standard error file
standard input file
standard mode
standard output file
standard storage pool
static
constant
constraint
delta constraint
digits constraint
discrete_range
discriminant constraint
expression
function
index constraint
range
range constraint
scalar subtype
string subtype
subtype
value
static semantics
statically
constrained
denote
statically compatible
for a constraint and a scalar subtype
for a constraint and an access or composite subtype
for two subtypes
statically deeper
statically determined tag
statically matching
effect on subtype-specific aspects
for constraints
for ranges
for subtypes
required
statically tagged
storage deallocation
unchecked
storage element
storage management
user-defined
storage node
storage place
of a component
storage place attributes
of a component
storage pool
storage pool element
storage pool type
Storage_Check
Storage_Count
subtype in package System.Storage_Elements
Storage_Error
raised by failure of run-time check
Storage_Pool clause
Storage_Size clause
See also pragma Storage_Size
Storage_Unit
named number in package System
stream
stream type
strict mode
string type
structure
See record type
subaggregate
of an array_aggregate
subcomponent
subprogram
abstract
subprogram call
subprogram instance
subsystem
subtype
of a generic formal object
subtype (of an object)
See actual subtype of an object
subtype conformance
required
subtype conversion
See also implicit subtype conversion
See type conversion
subtypes
of a profile
subtype-specific
attribute_definition_clause
of a representation item
of an aspect
subunit
super
See view conversion
suppressed check
synchronization
syntactic category
syntax
notation
under Syntax heading
System
System.Address_To_Access_Conversions
System.Machine_Code
System.RPC
System.Storage_Elements
System.Storage_Pools
systems programming

T

tag indeterminate
tag of an object
class-wide object
object created by an allocator
preserved by type conversion and parameter passing
returned by a function
stand-alone object, component, or aggregate
Tag_Check
tagged type
tail (of a queue)
target
of an assignment operation
of an assignment_statement
target entry
of a requeue_statement
target object
of a call on an entry or a protected subprogram
of a requeue_statement
target statement
of a goto_statement
target subtype
of a type_conversion
task
activation
completion
dependence
execution
termination
task declaration
task dispatching
task dispatching point
task dispatching policy
task priority
task state
abnormal
blocked
callable
held
inactive
ready
terminated
task unit
Tasking_Error
raised by failure of run-time check
template
for a formal package
See generic unit
terminal interrupt
example
terminated
a task state
termination
abnormal
normal
of a partition
tested type
of a membership test
text of a program
throw (an exception)
See raise
thunk
Tick
named number in package System
tick
time base
time limit
example
time type
Time-dependent Reset procedure
of the random number generator
time-out
example
See asynchronous_select
See selective_accept
See timed_entry_call
timer interrupt
example
times operator
timing
See delay_statement
token
See lexical element
transfer of control
True
two's complement
modular types
type
abstract
See also language-defined types
See also tag
type conformance
required
type conversion
access
arbitrary order
array
composite (non-array)
enumeration
numeric
See also qualified_expression
unchecked
type conversion, implicit
See implicit subtype conversion
type extension
type of a discrete_range
type of a range
type parameter
See discriminant
type profile
See profile, type conformant
type resolution rules
if any type in a specified class of types is expected
if expected type is specific
if expected type is universal or class-wide
type tag
See tag
type_conversion
See also unchecked type conversion
type-related
aspect
attribute_definition_clause
representation item
types
of a profile

U

UI
ultimate ancestor
of a type
unary adding operator
unary operator
unchecked storage deallocation
unchecked type conversion
Unchecked_Access attribute
See also Access attribute
unconstrained
object
subtype
undefined result
underline
Uniformity Issue (UI)
Uniformity Rapporteur Group (URG)
uninitialized allocator
uninitialized variables
unit consistency
universal type
universal_fixed
universal_integer
universal_real
unknown discriminants
unmarshalling
unpolluted
unsigned type
See modular type
unspecified
update
the value of an object
upper bound
of a range
upper_case_identifier_letter
upper-case letter
a category of Character
URG
usage name
user-defined assignment
user-defined heap management
user-defined operator
user-defined storage management
use-visible

V

value
value conversion
variable
variable object
variable view
variant
See also tagged type
version
of a compilation unit
vertical line
view
view conversion
virtual function
See dispatching subprogram
visibility
direct
immediate
use clause
visibility rules
visible
within a pragma in a context_clause
within a pragma that appears at the place of a compilation unit
within a use_clause in a context_clause
within a with_clause
within the parent_unit_name of a library unit
within the parent_unit_name of a subunit
visible part
of a formal package
of a generic unit
of a package (other than a generic formal package)
of a protected unit
of a task unit
of a view of a callable entity
of a view of a composite type
of an instance
volatile

W

well-formed picture String
for edited output
Wide_Character
with_clause
mentioned in
within
immediately
word
Word_Size
named number in package System
wording changes from Ada 83
Write clause

XYZ

xor operator


[Home] [Prev] [Next] [Index]

documentation@rational.com
Copyright © 1993-1998, Rational Software Corporation.   All rights reserved.