- The language defines several kinds of named entities that are declared by
declarations. The entity's name is defined by the declaration, usually by a
defining_identifier, but sometimes by a defining_character_literal or
- There are several forms of declaration. A basic_declaration is a form of
declaration defined as follows.
type_declaration | subtype_declaration
| object_declaration | number_declaration
| subprogram_declaration | abstract_subprogram_declaration
| package_declaration | renaming_declaration
| exception_declaration | generic_declaration
defining_identifier ::= identifier
- 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
- Each of the following is defined to be a declaration: any basic_declaration; an enumeration_literal_specification; a discriminant_specification; a component_declaration; a loop_parameter_specification; a parameter_specification; a subprogram_body; an entry_declaration; an entry_index_specification; a choice_parameter_specification; a generic_formal_parameter_declaration.
- All declarations 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
is an example of a declaration that does not define a new entity, but instead
defines a view of an existing entity (see 8.5)).
- For each declaration, the language rules define a certain region of text
called the scope of the declaration (see 8.2). Most
declarations associate an identifier with a declared entity. Within its scope,
and only there, there are places where it is possible to use the identifier
to refer to the declaration, the view it defines, and the associated entity;
these places are defined by the visibility rules (see
8.3). At such places the identifier is said to be a name of the entity
(the direct_name or selector_name); the name is said to denote the declaration,
the view, and the associated entity (see 8.6). The
declaration is said to declare the name, the view, and in most cases, the
- As an alternative to an identifier, an enumeration literal can be declared
with a character_literal as its name (see 3.5.1),
and a function can be declared with an operator_symbol as its name (see
- The syntax rules use the terms defining_identifier, defining_character_literal, and defining_operator_symbol for the defining occurrence of a name;
these are collectively called defining names. The terms direct_name and
selector_name are used for usage occurrences of identifiers, character_literals, and operator_symbols. These are collectively called usage names.
- The process by which a construct achieves its run-time effect is called
execution. This process is also called elaboration for declarations and
evaluation for expressions. One of the terms execution, elaboration, or
evaluation is defined by this International Standard for each construct that
has a run-time effect.
(1) At compile time, the declaration of an entity declares the entity.
At run time, the elaboration of the declaration creates the entity.
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe -- Magnus.Kempe@di.epfl.ch
Page last generated: 95-03-12