Sat Dec 23 07:59:23 PST 2006
Glossary of Ada 1983 Language Reference Manual
This is a translation of
section D. Glossary of the 1983 Language Reference Manual(LRM)
This appendix is informative and is not part of the standard definition of
the Ada programming language.
- 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..
Q & R
- 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..
U & V
- 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..