10.1.2 Context Clauses - With Clauses
1
A context_clause is used
to specify the library_items whose names are
needed within a compilation unit.
Syntax
2
context_clause ::= {
context_item}
3
context_item ::= with_clause |
use_clause
4/2
with_clause ::= limited_with_clause |
nonlimited_with_clause
4.1/2
limited_with_clause ::= limited [
private]
with library_unit_name {,
library_unit_name};
4.2/2
nonlimited_with_clause ::= [
private]
with library_unit_name {,
library_unit_name};
Name Resolution Rules
5
The
scope of a
with_clause
that appears on a
library_unit_declaration
or
library_unit_renaming_declaration consists
of the entire declarative region of the declaration, which includes all
children and subunits. The scope of a
with_clause
that appears on a body consists of the body, which includes all subunits.
6/2
A
library_item
(and the corresponding library unit) is
named in
a
with_clause if it is denoted by a
library_unit_name
in the
with_clause. A
library_item
(and the corresponding library unit) is
mentioned in a
with_clause
if it is named in the
with_clause or if it
is denoted by a
prefix in the
with_clause.
7
Outside its own declarative region, the declaration
or renaming of a library unit can be visible only within the scope of
a with_clause that mentions it. The visibility
of the declaration or renaming of a library unit otherwise follows from
its placement in the environment.
Legality Rules
8/2
If a with_clause of a
given compilation_unit mentions a private
child of some library unit, then the given compilation_unit
shall be one of:
9/2
- the declaration, body, or subunit
of a private descendant of that library unit;
10/2
- the body or subunit of a public descendant
of that library unit, but not a subprogram body acting as a subprogram
declaration (see 10.1.4); or
11/2
- the declaration of a public descendant
of that library unit, in which case the with_clause
shall include the reserved word private.
12/2
A name
denoting a library item that is visible only due to being mentioned in
one or more with_clauses that include the
reserved word private shall appear only within:
13/2
14/2
- a body, but not within the subprogram_specification
of a library subprogram body;
15/2
- a private descendant of the unit on
which one of these with_clauses appear; or
16/2
- a pragma within a context clause.
17/2
A library_item mentioned
in a limited_with_clause shall be the implicit
declaration of the limited view of a library package, not the declaration
of a subprogram, generic unit, generic instance, or a renaming.
18/2
A limited_with_clause
shall not appear on a library_unit_body, subunit,
or library_unit_renaming_declaration.
19/2
A limited_with_clause
that names a library package shall not appear:
20/2
- in the context_clause
for the explicit declaration of the named library package;
21/2
- in the same context_clause
as, or within the scope of, a nonlimited_with_clause
that mentions the same library package; or
22/2
- in the same context_clause
as, or within the scope of, a use_clause that
names an entity declared within the declarative region of the library
package.
23/2
3 A library_item
mentioned in a nonlimited_with_clause of a
compilation unit is visible within the compilation unit and hence acts
just like an ordinary declaration. Thus, within a compilation unit that
mentions its declaration, the name of a library package can be given
in use_clauses and can be used to form expanded
names, a library subprogram can be called, and instances of a generic
library unit can be declared. If a child of a parent generic package
is mentioned in a nonlimited_with_clause,
then the corresponding declaration nested within each visible instance
is visible within the compilation unit. Similarly, a library_item
mentioned in a limited_with_clause of a compilation
unit is visible within the compilation unit and thus can be used to form
expanded names.
Examples
24/2
package Office is
end Office;
25/2
with Ada.Strings.Unbounded;
package Office.Locations is
type Location is new Ada.Strings.Unbounded.Unbounded_String;
end Office.Locations;
26/2
limited with Office.Departments; -- types are incomplete
private with Office.Locations; -- only visible in private part
package Office.Employees is
type Employee is private;
27/2
function Dept_Of(Emp : Employee) return access Departments.Department;
procedure Assign_Dept(Emp : in out Employee;
Dept : access Departments.Department);
28/2
...
private
type Employee is
record
Dept : access Departments.Department;
Loc : Locations.Location;
...
end record;
end Office.Employees;
29/2
limited with Office.Employees;
package Office.Departments is
type Department is private;
30/2
function Manager_Of(Dept : Department) return access Employees.Employee;
procedure Assign_Manager(Dept : in out Department;
Mgr : access Employees.Employee);
...
end Office.Departments;
31/2
The limited_with_clause
may be used to support mutually dependent abstractions that are split
across multiple packages. In this case, an employee is assigned to a
department, and a department has a manager who is an employee. If a with_clause
with the reserved word private appears on one library unit and
mentions a second library unit, it provides visibility to the second
library unit, but restricts that visibility to the private part and body
of the first unit. The compiler checks that no use is made of the second
unit in the visible part of the first unit.
Sponsored by Ada-Europe