Contents   Index   Search   Previous   Next

3.11 Declarative Parts

   [A declarative_part contains declarative_items (possibly none).]


declarative_part ::= {declarative_item}
declarative_item ::=
    basic_declarative_item | body
{8652/0009} basic_declarative_item ::=
    basic_declaration | aspect_clause representation_clause | use_clause
body ::= proper_body | body_stub
proper_body ::=
    subprogram_body | package_body | task_body | protected_body

Dynamic Semantics

   {elaboration (declarative_part) [partial]} The elaboration of a declarative_part consists of the elaboration of the declarative_items, if any, in the order in which they are given in the declarative_part.
   {elaborated} An elaborable construct is in the elaborated state after the normal completion of its elaboration. Prior to that, it is not yet elaborated.
Ramification: The elaborated state is only important for bodies; certain uses of a body raise an exception if the body is not yet elaborated.
Note that "prior" implies before the start of elaboration, as well as during elaboration.
The use of the term "normal completion" implies that if the elaboration propagates an exception or is aborted, the declaration is not elaborated. RM83 missed the aborted case.
   {Elaboration_Check [partial]} {check, language-defined (Elaboration_Check)} For a construct that attempts to use a body, a check (Elaboration_Check) is performed, as follows:
Discussion: AI83-00180 specifies that there is no elaboration check for a subprogram defined by a pragma Interface (or equivalently, pragma Import). AI83-00430 specifies that there is no elaboration check for an enumeration literal. AI83-00406 specifies that the evaluation of parameters and the elaboration check occur in an arbitrary order. AI83-00406 applies to generic instantiation as well (see below).
{8652/0014} A subprogram can be completed by a renames-as-body, and we need to make an elaboration check on such a body, so we use ``body'' rather than subprogram_body above.
Discussion: A protected type has only one elaboration ``bit,'' rather than one for each operation, because one call may result in evaluating the barriers of other entries, and because there are no elaborable declarations between the bodies of the operations. In fact, the elaboration of a protected_body does not elaborate the enclosed bodies, since they are not considered independently elaborable.
Note that there is no elaboration check when calling a task entry. Task entry calls are permitted even before the associated task_body has been seen. Such calls are simply queued until the task is activated and reaches a corresponding accept_statement. We considered a similar rule for protected entries -- simply queuing all calls until the protected_body was seen, but felt it was not worth the possible implementation overhead, particularly given that there might be multiple instances of the protected type.
Reason: As specified by AI83-00149, the check is done by the activator, rather than by the task itself. If it were done by the task itself, it would be turned into a Tasking_Error in the activator, and the other tasks would still be activated.
    {Program_Error (raised by failure of run-time check)} The exception Program_Error is raised if any of these checks fails.

Extensions to Ada 83

{extensions to Ada 83} The syntax for declarative_part is modified to remove the ordering restrictions of Ada 83; that is, the distinction between basic_declarative_items and later_declarative_items within declarative_parts is removed. This means that things like use_clauses and variable_declarations can be freely intermixed with things like bodies.
The syntax rule for proper_body now allows a protected_body, and the rules for elaboration checks now cover calls on protected operations.

Wording Changes from Ada 83

The syntax rule for later_declarative_item is removed; the syntax rule for declarative_item is new.
RM83 defines ``elaborated'' and ``not yet elaborated'' for declarative_items here, and for other things in 3.1, ``Declarations''. That's no longer necessary, since these terms are fully defined in 3.1.
In RM83, all uses of declarative_part are optional (except for the one in block_statement with a declare) which is sort of strange, since a declarative_part can be empty, according to the syntax. That is, declarative_parts are sort of ``doubly optional''. In Ada 95, these declarative_parts are always required (but can still be empty). To simplify description, we go further and say (see 5.6, ``Block Statements'') that a block_statement without an explicit declarative_part is equivalent to one with an empty one.

Contents   Index   Search   Previous   Next   Legal