AARM95 - Subunits of Compilation Units
Author: JTC1/SC22/WG9/ARG, by Randall Brukardt, ARG Editor

Contents Index Previous Next

# 10.1.3 Subunits of Compilation Units

1
[Subunits are like child units, with these (important) differences: subunits support the separate compilation of bodies only (not declarations); the parent contains a body_stub to indicate the existence and place of each of its subunits; declarations appearing in the parent's body can be visible within the subunits.]

#### Syntax

2
body_stub ::= subprogram_body_stub | package_body_stub | task_body_stub | protected_body_stub
3
subprogram_body_stub ::= subprogram_specification is separate;
3.a
Discussion: Although this syntax allows a parent_unit_name, that is disallowed by 10.1.1, ``Compilation Units - Library Units''.
4
package_body_stub ::= package body defining_identifier is separate;
5
task_body_stub ::= task body defining_identifier is separate;
6
protected_body_stub ::= protected body defining_identifier is separate;
7
subunit ::= separate (parent_unit_name) proper_body

#### Legality Rules

8
The parent body of a subunit is the body of the program unit denoted by its parent_unit_name. The term subunit is used to refer to a subunit and also to the proper_body of a subunit.
9
The parent body of a subunit shall be present in the current environment, and shall contain a corresponding body_stub with the same defining_identifier as the subunit.
9.a
Discussion: This can't be a Name Resolution Rule, because a subunit is not a complete context.
10
A package_body_stub shall be the completion of a package_declaration or generic_package_declaration; a task_body_stub shall be the completion of a task_declaration; a protected_body_stub shall be the completion of a protected_declaration.
11
In contrast, a subprogram_body_stub need not be the completion of a previous declaration, [in which case the _stub declares the subprogram]. If the _stub is a completion, it shall be the completion of a subprogram_declaration or generic_subprogram_declaration. The profile of a subprogram_body_stub that completes a declaration shall conform fully to that of the declaration.
11.a
Discussion: The part about subprogram_body_stubs echoes the corresponding rule for subprogram_bodies in 6.3, ``Subprogram Bodies''.
12
A subunit that corresponds to a body_stub shall be of the same kind (package_, subprogram_, task_, or protected_) as the body_stub. The profile of a subprogram_body subunit shall be fully conformant to that of the corresponding body_stub.
13
A body_stub shall appear immediately within the declarative_part of a compilation unit body. This rule does not apply within an instance of a generic unit.
13.a
Discussion: This is a methodological restriction; that is, it is not necessary for the semantics of the language to make sense.
14
The defining_identifiers of all body_stubs that appear immediately within a particular declarative_part shall be distinct.

#### Post-Compilation Rules

15
For each body_stub, there shall be a subunit containing the corresponding proper_body.
NOTES
16
4 The rules in 10.1.4, ``The Compilation Process'' say that a body_stub is equivalent to the corresponding proper_body. This implies:
17

- Visibility within a subunit is the visibility that would be obtained at the place of the corresponding body_stub (within the parent body) if the context_clause of the subunit were appended to that of the parent body.

17.a
Ramification: Recursively. Note that this transformation might make the parent illegal; hence it is not a true equivalence, but applies only to visibility within the subunit.
18

- The effect of the elaboration of a body_stub is to elaborate the subunit.

18.a
Ramification: The elaboration of a subunit is part of its parent body's elaboration, whereas the elaboration of a child unit is not part of its parent declaration's elaboration.
18.b
Ramification: A library_item that is mentioned in a with_clause of a subunit can be hidden (from direct visiblity) by a declaration (with the same identifier) given in the subunit. Moreover, such a library_item can even be hidden by a declaration given within the parent body since a library unit is declared in its parent's declarative region; this however does not affect the interpretation of the with_clauses themselves, since only library_items are visible or directly visible in with_clauses.
18.c
The body of a protected operation cannot be a subunit. This follows from the syntax rules. The body of a protected unit can be a subunit.

#### Examples

19
The package Parent is first written without subunits:
20
`package Parent is
procedure Inner;
end Parent;`
21
`with Ada.Text_IO;
package body Parent is
Variable : String := "Hello, there.";
procedure Inner is
begin
Ada.Text_IO.Put_Line(Variable);
end Inner;
end Parent;`
22
The body of procedure Inner may be turned into a subunit by rewriting the package body as follows (with the declaration of Parent remaining the same):
23
`package body Parent is
Variable : String := "Hello, there.";
procedure Inner is separate;
end Parent;`
24
`with Ada.Text_IO;
separate(Parent)
procedure Inner is
begin
Ada.Text_IO.Put_Line(Variable);
end Inner;`

#### Extensions to Ada 83

24.a
Subunits of the same ancestor library unit are no longer restricted to have distinct identifiers. Instead, we require only that the full expanded names be distinct.

Contents Index Previous Next Legal