Contents Index Search Previous Next
10.2.1 Elaboration Control
This subclause defines pragmas
that help control the elaboration order of library_item
The form of
a pragma Preelaborate is as follows:
Preelaborate is a library
elaborable construct is preelaborable unless its elaboration performs
any of the following actions:
- The execution of a statement
other than a null_statement.
- A call to a subprogram other than
a static function.
- The evaluation of a primary
that is a name of an object, unless
the name is a static expression,
or statically denotes a discriminant of an enclosing type.
- The creation of a default-initialized
object (including a component) of a descendant of a private type, private
extension, controlled type, task type, or protected type with entry_declarations;
similarly the evaluation of an extension_aggregate
with an ancestor subtype_mark denoting
a subtype of such a type.
A generic body is preelaborable only if elaboration
of a corresponding instance body would not perform any such actions,
presuming that the actual for each formal private type (or extension)
is a private type (or extension), and the actual for each formal subprogram
is a user-defined subprogram.
If a pragma
Preelaborate (or pragma
see below) applies to a library unit, then it is preelaborated
If a library unit is preelaborated, then its declaration,
if any, and body, if any, are elaborated prior to all non-preelaborated
s of the partition.
The declaration and body of a preelaborated library unit, and all subunits
that are elaborated as part of elaborating the library unit, shall be
In addition to the places where Legality
Rules normally apply (see 12.3
), this rule
applies also in the private part of an instance of a generic unit. In
addition, all compilation units of a preelaborated library unit shall
depend semantically only on compilation units of other preelaborated
In an implementation, a type declared in a preelaborated
package should have the same representation in every elaboration of a
given version of the package, whether the elaborations occur in distinct
executions of the same program, or in executions of distinct programs
or partitions that include the given version.
The form of
a pragma Pure is as follows:
Pure is a library unit pragma.
A pure library_item
is a preelaborable library_item
that does not contain the declaration of any variable or named access
type, except within a subprogram, generic subprogram, task unit, or protected
Pure is used to declare that a library unit is pure. If a pragma
Pure applies to a library unit, then its compilation units shall be pure,
and they shall depend semantically only on compilation units of other
library units that are declared pure.
If a library unit is declared pure, then the
implementation is permitted to omit a call on a library-level subprogram
of the library unit if the results are not needed after the call. Similarly,
it may omit such a call and simply reuse the results produced by an earlier
call on the same subprogram, provided that none of the parameters are
of a limited type, and the addresses and values of all by-reference actual
parameters, and the values of all by-copy-in actual parameters, are the
same as they were at the earlier call. This permission applies even if
the subprogram produces other side effects when called.
The form of
a pragma Elaborate, Elaborate_All,
or Elaborate_Body is as follows:
Elaborate or Elaborate_All is only allowed within a context_clause.
Elaborate_Body is a library
If a pragma
Elaborate_Body applies to a declaration, then the declaration requires
a completion (a body).
Elaborate specifies that the body of the named library unit is elaborated
before the current library_item.
A pragma Elaborate_All specifies
that each library_item that is needed
by the named library unit declaration is elaborated before the current
library_item. A pragma
Elaborate_Body specifies that the body of the library unit is elaborated
immediately after its declaration.
12 A preelaborated library
unit is allowed to have non-preelaborable children.
13 A library unit that
is declared pure is allowed to have impure children.
Contents Index Search Previous Next Legal