Ada '83 Language Reference Manual

Copyright 1980, 1982, 1983 owned by the United States Government. Direct reproduction and usage requests to the Ada Information Clearinghouse.

D. Glossary

This appendix is informative and is not part of the standard definition of the Ada programming language. Italicized terms in the abbreviated descriptions below either have glossary entries themselves or are described in entries for related terms.

Accept statement.: See entry.
Access type.: A value of an access type (an access value) is either a null value, or a value that designates an object created by an allocator. The designated object can be read and updated via the access value. The definition of an access type specifies the type of the objects designated by values of the access type. See also collection.
Actual parameter.: See parameter.
Aggregate.: The evaluation of an aggregate yields a value of a composite type. The value is specified by giving the value of each of the components. Either positional association or named association may be used to indicate which value is associated with which component.
Allocator.: The evaluation of an allocator creates an object and returns a new access value which designates the object.
Array type.: A value of an array type consists of components which are all of the same subtype (and hence, of the same type). Each component is uniquely distinguished by an index (for a one-dimensional array) or by a sequence of indices (for a multidimensional array). Each index must be a value of a discrete type and must lie in the correct index range.
Assignment.: Assignment is the operation that replaces the current value of a variable by a new value. An assignment statement specifies a variable on the left, and on the right, an expression whose value is to be the new value of the variable.
Attribute.: The evaluation of an attribute yields a predefined characteristic of a named entity; some attributes are functions.
Block statement.: A block statement is a single statement that may contain a sequence of statements. It may also include a declarative part, and exception handlers; their effects are local to the block statement.
Body.: A body defines the execution of a subprogram, package, or task. A body stub is a form of body that indicates that this execution is defined in a separately compiled subunit.
Collection.: A collection is the entire set of objects created by evaluation of allocators for an access type.
Compilation unit.: A compilation unit is the declaration or the body of a program unit, presented for compilation as an independent text. It is optionally preceded by a context clause, naming other compilation units upon which it depends by means of one more with clauses.
Component.: A component is a value that is a part of a larger value, or an object that is part of a larger object.
Composite type.: A composite type is one whose values have components. There are two kinds of composite type: array types and record types.
Constant.: See object.
Constraint.: A constraint determines a subset of the values of a type. A value in that subset satisfies the constraint.
Context clause.: See compilation unit.
Declaration.: A declaration associates an identifier (or some other notation) with an entity. This association is in effect within a region of text called the scope of the declaration. Within the scope of a declaration, there are places where it is possible to use the identifier to refer to the associated declared entity. At such places the identifier is said to be a simple name of the entity; the name is said to denote the associated entity.
Declarative Part.: A declarative part is a sequence of declarations. It may also contain related information such as subprogram bodies and representation clauses.
Denote.: See declaration.
Derived Type.: A derived type is a type whose operations and values are replicas of those of an existing type. The existing type is called the parent type of the derived type.
Designate.: See access type, task.
Direct visibility.: See visibility.
Discrete Type.: A discrete type is a type which has an ordered set of distinct values. The discrete types are the enumeration and integer types. Discrete types are used for indexing and iteration, and for choices in case statements and record variants.
Discriminant.: A discriminant is a distinguished component of an object or value of a record type. The subtypes of other components, or even their presence or absence, may depend on the value of the discriminant.
Discriminant constraint.: A discriminant constraint on a record type or private type specifies a value for each discriminant of the type.
Elaboration.: The elaboration of a declaration is the process by which the declaration achieves its effect (such as creating an object); this process occurs during program execution.
Entry.: An entry is used for communication between tasks. Externally, an entry is called just as a subprogram is called; its internal behavior is specified by one or more accept statements specifying the actions to be performed when the entry is called.
Enumeration type.: An enumeration type is a discrete type whose values are represented by enumeration literals which are given explicitly in the type declaration. These enumeration literals are either identifiers or character literals.
Evaluation.: The evaluation of an expression is the process by which the value of the expression is computed. This process occurs during program execution.
Exception.: An exception is an error situation which may arise during program execution. To raise an exception is to abandon normal program execution so as to signal that the error has taken place. An exception handler is a portion of program text specifying a response to the exception. Execution of such a program text is called handling the exception.
Expanded name.: An expanded name denotes an entity which is declared immediately within some construct. An expanded name has the form of a selected component: the prefix denotes the construct (a program unit; or a block, loop, or accept statement); the selector is the simple name of the entity.
Expression.: An expression defines the computation of a value.
Fixed point type.: See real type.
Floating point type.: See real type.
Formal parameter.: See parameter.
Function.: See subprogram.
Generic unit.: A generic unit is a template either for a set of subprograms or for a set of packages. A subprogram or package created using the template is called an instance of the generic unit. A generic instantiation is the kind of declaration that creates an instance. A generic unit is written as a subprogram or package but with the specification prefixed by a generic formal part which may declare generic formal parameters. A generic formal parameter is either a type, a subprogram, or an object. A generic unit is one of the kinds of program unit.
Handler.: See exception.
Index.: See array type.
Index constraint.: An index constraint for an array type specifies the lower and upper bounds for each index range of the array type.
Indexed component.: An indexed component denotes a component in an array. It is a form of name containing expressions which specify the values of the indices of the array component. An indexed component may also denote an entry in a family of entries.
Instance.: See generic unit.
Integer type.: An integer type is a discrete type whose values represent all integer numbers within a specific range.
Lexical element.: A lexical element is an identifier, a literal, a delimiter, or a comment.
Limited type.: A limited type is a type for which neither assignment nor the predefined comparison for equality is implicitly declared. All task types are limited. A private type can be defined to be limited. An equality operator can be explicitly declared for a limited type.
Literal.: A literal represents a value literally, that is, by means of letters and other characters. A literal is either a numeric literal, an enumeration literal, a character literal, or a string literal.
Mode.: See parameter.
Model number.: A model number is an exactly representable value of a real type. Operations of a real type are defined in terms of operations on the model numbers of the type. The properties of the model numbers and of their operations are the minimal properties preserved by all implementations of the real type.
Name.: A name is a construct that stands for an entity: it is said that the name denotes the entity, and that the entity is the meaning of the name. See also declaration, prefix.
Named association.: A named association specifies the association of an item with one or more positions in a list, by naming the positions.
Object.: An object contains a value. A program creates an object either by elaborating an object declaration or by evaluating an allocator. The declaration or allocator specifies a type for the object: the object can only contain values of that type.
Operation.: An operation is an elementary action associated with one or more types. It is either implicitly declared by the declaration of the type, or it is a subprogram that has a parameter or result of the type.
Operator.: An operator is an operation which has one or two operands. A unary operator is written before an operand; a binary operator is written between two operands. This notation is a special kind of function call. An operator can be declared as a function. Many operators are implicitly declared by the declaration of a type (for example, most type declarations imply the declaration of the equality operator for values of the type).
Overloading.: An identifier can have several alternative meanings at a given point in the program text: this property is called overloading. For example, an overloaded enumeration literal can be an identifier that appears in the definitions of two or more enumeration types. The effective meaning of an overloaded identifier is determined by the context. Subprograms, aggregates, allocators, and string literals can also be overloaded.
Package.: A package specifies a group of logically related entities, such as types, objects of those types, and subprograms with parameters of those types. It is written as a package declaration and a package body. The package declaration has a visible part, containing the declarations of all entities that can be explicitly used outside the package. It may also have a private part containing structural details that complete the specification of the visible entities, but which are irrelevant to the user of the package. The package body contains implementations of subprograms (and possibly tasks as other packages) that have been specified in the package declaration. A package is one of the kinds of program unit.
Parameter.: A parameter is one of the named entities associated with a subprogram, entry, or generic unit, and used to communicate with the corresponding subprogram body, accept statement or generic body. A formal parameter is an identifier used to denote the named entity within the body. An actual parameter is the particular entity associated with the corresponding formal parameter by a subprogram call, entry call, or generic instantiation. The mode of a formal parameter specifies whether the associated actual parameter supplies a value for the formal parameter, or the formal supplies a value for the actual parameter, or both. The association of actual parameters with formal parameters can be specified by named associations, by positional associations, or by a combination of these.
Parent type.: See derived type.
Positional association.: A positional association specifies the association of an item with a position in a list, by using the same position in the text to specify the item.
Pragma.: A pragma conveys information to the compiler.
Prefix.: A prefix is used as the first part of certain kinds of name. A prefix is either a function call or a name.
Private part.: See package.
Private type.: A private type is a type whose structure and set of values are clearly defined, but not directly available to the user of the type. A private type is known only by its discriminants (if any) and by the set of operations defined for it. A private type and its applicable operations are defined in the visible part of a package, or in a generic formal part. Assignment, equality, and inequality are also defined for private types, unless the private type is limited.
Procedure.: See subprogram.
Program.: A program is composed of a number of compilation units, one of which is a subprogram called the main program. Execution of the program consists of execution of the main program, which may invoke subprograms declared in the other compilation units of the program.
Program unit.: A program unit is any one of a generic unit, package, subprogram, or task unit.
Qualified expression.: A qualified expression is an expression preceded by an indication of its type or subtype. Such qualification is used when, in its absence, the expression might be ambiguous (for example as a consequence of overloading).
Raising an exception.: See exception.
Range.: A range is a contiguous set of values of a scalar type. A range is specified by giving the lower and upper bounds for the values. A value in the range is said to belong to the range.
Range constraint.: A range constraint of a type specifies a range, and thereby determines the subset of the values of the type that belong to the range.
Real type.: A real type is a type whose values represent approximations to the real numbers. There are two kinds of real type: fixed point types are specified by absolute error bound; floating point types are specified by a relative error bound expressed as a number of significant decimal digits.
Record type.: A value of a record type consists of components which are usually of different types or subtypes. For each component of a record value or record object, the definition of the record type specifies an identifier that uniquely determines the component within the record.
Renaming declaration.: A renaming declaration declares another name for an entity.
Rendezvous.: A rendezvous is the interaction that occurs between two parallel tasks when one task has called an entry of the other task, and a corresponding accept statement is being executed by the other task on behalf of the calling task.
Representation clause.: A representation clause directs the compiler in the selection of the mapping of a type, an object, or a task onto features of the underlying machine that executes a program. In some cases, representation clauses completely specify the mapping; in other cases, they provide criteria for choosing a mapping.
Satisfy.: See constraint, subtype.
Scalar type.: An object or value of a scalar type does not have components. A scalar type is either a discrete type or a real type. The values of a scalar type are ordered.
Scope.: See declaration.
Selected component.: A selected component is a name consisting of a prefix and of an identifier called the selector. Selected components are used to denote record components, entries, and objects designated by access values; they are also used as expanded names.
Selector.: See selected component.
Simple name.: See declaration, name.
Statement.: A statement specifies one or more actions to be performed during the execution of a program.
Subcomponent.: A subcomponent is either a component, or a component of another subcomponent.
Subprogram.: A subprogram is either a procedure or a function. A procedure specifies a sequence of actions and is invoked by a procedure call statement. A function specifies a sequence of actions and also returns a value called the result, and so a function call is an expression. A subprogram is written as a subprogram declaration, which specifies its name, formal parameters, and (for a function) its result; and a subprogram body which specifies the sequence of actions. The subprogram call specifies the actual parameters that are to be associated with the formal parameters. A subprogram is one of the kinds of program unit.
Subtype.: A subtype of a type characterizes a subset of the values of the type. The subset is determined by a constraint on the type. Each value in the set of values of a subtype belongs to the subtype and satisfies the constraint determining the subtype.
Subunit.: See body.
Task.: A task operates in parallel with other parts of the program. It is written as a task specification (which specifies the name of the task and the names and formal parameters of its entries), and a task body which defines its execution. A task unit is one of the kinds of program unit. A task type is a type that permits the subsequent declaration of any number of similar tasks of the type. A value of a task type is said to designate a task.
Type.: A type characterizes both a set of values, and a set of operations applicable to those values. A type definition is a language construct that defines a type. A particular type is either an access type, an array type, a private type, a record type, a scalar type, or a task type.
Use clause.: A use clause achieves direct visibility of declarations that appear in the visible parts of named packages.
Variable.: See object.
Variant part.: A variant part of a record specifies alternative record components, depending on a discriminant of the record. Each value of the discriminant establishes a particular alternative of the variant part.
Visibility.: At a given point in a program text, the declaration of an entity with a certain identifier is said to be visible if the entity is an acceptable meaning for an occurrence at that point of the identifier. The declaration is visible by selection at the place of the selector in a selected component or at the place of the name in a named association. Otherwise, the declaration is directly visible, that is, if the identifier alone has that meaning.
Visible part.: See package.
With clause.: See compilation unit.

Address any questions or comments to adainfo@sw-eng.falls-church.va.us.