Contents Index Search Related Documents Previous Next
Annex N
(informative)
Glossary
1/2
This Annex contains informal
descriptions of some of the terms used in this International Standard.
The index provides references to more formal definitions of all of the
terms used in this International Standard.
1.1/2
Abstract type.
An abstract type is a tagged type intended for use as an ancestor of
other types, but which is not allowed to have objects of its own.
2
Access type. An access
type has values that designate aliased objects. Access types correspond
to “pointer types” or “reference types” in some
other languages.
3
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.
3.1/2
Ancestor. An ancestor
of a type is the type itself or, in the case of a type derived from other
types, its parent type or one of its progenitor types or one of their
ancestors. Note that ancestor and descendant are inverse relationships.
4
Array type. An array
type is a composite type whose components are all of the same type. Components
are selected by indexing.
4.1/2
Category (of types).
A category of types is a set of types with one or more common properties,
such as primitive operations. A category of types that is closed under
derivation is also known as a
class.
5
Character type. A character
type is an enumeration type whose values include characters.
6/2
Class (of types).
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.
7
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.
8/2
Composite type. A
composite type may have components.
9
Construct. A
construct
is a piece of text (explicit or implicit) that is an instance of a syntactic
category defined under “Syntax”.
10
Controlled type. A
controlled type supports user-defined assignment and finalization. Objects
are always finalized before being destroyed.
11
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).
12/2
This paragraph was deleted.
13/2
Derived type. A
derived type is a type defined in terms of one or more other types given
in a derived type definition. The first of those types is the parent
type of the derived type and any others are progenitor types. Each class
containing the parent type or a progenitor type also contains the derived
type. The derived type inherits properties such as components and primitive
operations from the parent and progenitors. A type together with the
types derived from it (directly or indirectly) form a derivation class.
13.1/2
Descendant. A
type is a descendant of itself, its parent and progenitor types, and
their ancestors. Note that descendant and ancestor are inverse relationships.
14
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.
15/2
Discriminant. A
discriminant is a parameter for a composite type. It can control, for
example, the bounds of a component of the type if the component is an
array. A discriminant for a task type can be used to pass data to a task
of the type upon creation.
15.1/2
Elaboration. The
process by which a declaration has its run-time effect is called elaboration.
Elaboration is one of the forms of execution.
16
Elementary type. An
elementary type does not have components.
17
Enumeration type.
An enumeration type is defined by an enumeration of its values, which
may be named by identifiers or character literals.
17.1/2
Evaluation. The
process by which an expression has its run-time effect is called evaluation.
Evaluation is one of the forms of execution.
18
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.
19
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.
19.1/2
Function. A function
is a form of subprogram that returns a result and can be called as part
of an expression.
20
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.
20.1/2
Incomplete type.
An incomplete type gives a view of a type that reveals only some of its
properties. The remaining properties are provided by the full view given
elsewhere. Incomplete types can be used for defining recursive data structures.
21
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.
21.1/2
Interface type.
An interface type is a form of abstract tagged type which has no components
or concrete operations except possibly null procedures. Interface types
are used for composing other interfaces and tagged types and thereby
provide multiple inheritance. Only an interface type can be used as a
progenitor of another type.
22
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.
23/2
Limited type. A
limited type is a type for which copying (such as in an
assignment_statement)
is not allowed. A nonlimited type is a type for which copying is allowed.
24
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.
24.1/2
Overriding operation.
An overriding operation is one that replaces an inherited primitive operation.
Operations may be marked explicitly as overriding or not overriding.
25
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.
25.1/2
Parent. The parent
of a derived type is the first type given in the definition of the derived
type. The parent can be almost any kind of type, including an interface
type.
26
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.
27
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.
28
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.
29/2
Private extension.
A private extension is a type that extends another type, with the additional
properties hidden from its clients.
30/2
Private type. A
private type gives a view of a type that reveals only some of its properties.
The remaining properties are provided by the full view given elsewhere.
Private types can be used for defining abstractions that hide unnecessary
details from a client.
30.1/2
Procedure. A procedure
is a form of subprogram that does not return a result and can only be
called by a
statement.
30.2/2
Progenitor. A
progenitor of a derived type is one of the types given in the definition
of the derived type other than the first. A progenitor is always an interface
type. Interfaces, tasks, and protected types may also have progenitors.
31
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.
32
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.
33/2
Protected type.
A protected type is a composite type whose components are accessible
only through one of its protected operations which synchronize concurrent
access by multiple tasks.
34
Real type. A real
type has values that are approximations of the real numbers. Floating
point and fixed point types are real types.
35
Record extension.
A record extension is a type that extends another type by adding additional
components.
36
Record type. A record
type is a composite type consisting of zero or more named components,
possibly of different types.
36.1/2
Renaming. A
renaming_declaration
is a declaration that does not define a new entity, but instead defines
a view of an existing entity.
37
Scalar type. A scalar
type is either a discrete type or a real type.
37.1/2
Subprogram. A
subprogram is a section of program that can be executed in various contexts.
It is invoked by a subprogram call that may qualify the effect of the
subprogram through the passing of parameters. There are two forms of
subprograms: functions, which return values, and procedures, which do
not.
38/2
Subtype. A subtype
is a type together with a constraint or null exclusion, 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.
38.1/2
Synchronized.
A synchronized entity is one that will work safely with multiple tasks
at one time. A synchronized interface can be an ancestor of a task or
a protected type. Such a task or protected type is called a synchronized
tagged type.
39
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.
40/2
Task type. A task
type is a composite type used to represent active entities which execute
concurrently and which can communicate via queued task entries. The top-level
task of a partition is called the environment task.
41/2
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
categories. The types
of a given category share a set of primitive operations. Most language-defined
categories of types are also
classes of types.
42/2
View. A view of
an entity reveals some or all of the properties of the entity. A single
entity may have multiple views..)
Contents Index Search Related Documents Previous Next Legal