Contents Index Search Previous Next
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.
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
Character type. A character type is an
enumeration type whose values include characters.
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
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.
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
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
an example of a declaration that does not define a new entity, but instead
defines a view of an existing entity (see 8.5
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.
a kind of exceptional situation; an occurrence of such a situation (at
run time) is called an exception occurrence
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 process by which a construct
achieves its run-time effect is called 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 sometimes 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.
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)
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. 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
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.
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
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.
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
. The types of a given class share a set of primitive
Classes are closed under derivation;
that is, if a type is in a class, then all of its derivatives are in
View. (See Definition.)
Contents Index Search Previous Next Legal