Next: , Previous: 7.1, Up: 7


7.2 Package Bodies

1
In contrast to the entities declared in the visible part of a package, the entities declared in the package_body are visible only within the package_body itself. As a consequence, a package with a package_body can be used for the construction of a group of related subprograms in which the logical operations available to clients are clearly isolated from the internal entities.

Syntax

2

package_body::=
    package body defining_program_unit_name is
       declarative_part
   [begin
        handled_sequence_of_statements]
    end [[parent_unit_name.]identifier];

3

If an identifier or parent_unit_name.identifier appears at the end of a package_body, then this sequence of lexical elements shall repeat the defining_program_unit_name.
Legality Rules

4
A package_body shall be the completion of a previous package_declaration (see 7.1) or generic_package_declaration (see 12.1). A library package_declaration (see 7.1) or library generic_package_declaration (see 12.1) shall not have a body unless it requires a body; pragma Elaborate_Body can be used to require a library_unit_declaration (see 10.1.1) to have a body (see 10.2.1) if it would not otherwise require one.

Static Semantics

5
In any package_body without statements there is an implicit null_statement (see 5.1). For any package_declaration (see 7.1) without an explicit completion, there is an implicit package_body (see 7.2) containing a single null_statement. For a noninstance, nonlibrary package, this body occurs at the end of the declarative_part (see 3.11) of the innermost enclosing program unit or block_statement (see 5.6); if there are several such packages, the order of the implicit package_bodies is unspecified. (For an instance, the implicit package_body (see 7.2) occurs at the place of the instantiation (see 12.3). For a library package, the place is partially determined by the elaboration dependences (see Section 10).)

Dynamic Semantics

6
For the elaboration of a nongeneric package_body, its declarative_part (see 3.11) is first elaborated, and its handled_sequence_of_statements (see 11.2) is then executed.

     NOTES

7

 A variable declared in the body of a package is only visible within this body and, consequently, its value can only be changed within the package_body. In the absence of local tasks, the value of such a variable remains unchanged between calls issued from outside the package to subprograms declared in the visible part. The properties of such a variable are similar to those of a "static" variable of C.

8

 The elaboration of the body of a subprogram explicitly declared in the visible part of a package is caused by the elaboration of the body of the package. Hence a call of such a subprogram by an outside program unit raises the exception Program_Error if the call takes place before the elaboration of the package_body (see 3.11).
Examples

9
Example of a package body (see 7.1):

10

     package body Rational_Numbers is

11

        procedure Same_Denominator (X,Y in out Rational) is
        begin
           −−  reduces and to the same denominator:
           ...
        end Same_Denominator;

12

        function "="(X,Y Rational) return Boolean is
           Rational := X;
           Rational := Y;
        begin
           Same_Denominator (U,V);
           return U.Numerator V.Numerator;
        end "=";

13

        function "/" (X,Y Integer) return Rational is
        begin
           if then
              return (Numerator => X,  Denominator => Y);
           else
              return (Numerator => −X, Denominator => −Y);
           end if;
        end "/";

14

        function "+" (X,Y Rational) return Rational is ... end "+";
        function "−" (X,Y Rational) return Rational is ... end "−";
        function "*" (X,Y Rational) return Rational is ... end "*";
        function "/" (X,Y Rational) return Rational is ... end "/";

15

     end Rational_Numbers;