Contents Index Search Previous Next
12.1 Generic Declarations
1
A generic_declaration
declares a generic unit, which is either a generic subprogram or a generic
package. A generic_declaration includes
a generic_formal_part declaring
any generic formal parameters. A generic formal parameter can be an object;
alternatively (unlike a parameter of a subprogram), it can be a type,
a subprogram, or a package.
Syntax
2
generic_declaration
::= generic_subprogram_declaration |
generic_package_declaration
3
generic_subprogram_declaration
::=
generic_formal_part subprogram_specification;
4
generic_package_declaration
::=
generic_formal_part package_specification;
5
generic_formal_part
::= generic {
generic_formal_parameter_declaration |
use_clause}
6
generic_formal_parameter_declaration
::=
formal_object_declaration
|
formal_type_declaration
|
formal_subprogram_declaration
|
formal_package_declaration
7
The only form of subtype_indication
allowed within a generic_formal_part
is a subtype_mark (that is, the
subtype_indication shall not include
an explicit constraint). The defining
name of a generic subprogram shall be an identifier
(not an operator_symbol).
Static Semantics
8
A
generic_declaration declares a generic
unit -- a generic package, generic procedure or generic function, as
appropriate.
9
An entity is a
generic
formal entity if it is declared by a
generic_formal_parameter_declaration.
``Generic formal,'' or simply ``formal,'' is used as a prefix in referring
to objects, subtypes (and types), functions, procedures and packages,
that are generic formal entities, as well as to their respective declarations.
Examples: ``generic formal procedure'' or a ``formal integer type declaration.''
Dynamic Semantics
10
The elaboration of a
generic_declaration
has no effect.
11
1 Outside a generic unit
a name that denotes the generic_declaration
denotes the generic unit. In contrast, within the declarative region
of the generic unit, a name that
denotes the generic_declaration
denotes the current instance.
12
2 Within a generic subprogram_body,
the name of this program unit acts as the name of a subprogram. Hence
this name can be overloaded, and it can appear in a recursive call of
the current instance. For the same reason, this name cannot appear after
the reserved word new in a (recursive) generic_instantiation.
13
3 A default_expression
or default_name appearing in a generic_formal_part
is not evaluated during elaboration of the generic_formal_part;
instead, it is evaluated when used. (The usual visibility rules apply
to any name used in a default: the
denoted declaration therefore has to be visible at the place of the expression.)
Examples
14
Examples of
generic formal parts:
15
generic -- parameterless
16
generic
Size : Natural; -- formal object
17
generic
Length : Integer := 200; -- formal object with a default expression
18
Area : Integer := Length*Length; -- formal object with a default expression
19
generic
type Item is private; -- formal type
type Index is (<>); -- formal type
type Row is array(Index range <>) of Item; -- formal type
with function "<"(X, Y : Item) return Boolean; -- formal subprogram
20
Examples of generic
declarations declaring generic subprograms Exchange and Squaring:
21
generic
type Elem is private;
procedure Exchange(U, V : in out Elem);
22
generic
type Item is private;
with function "*"(U, V : Item) return Item is <>;
function Squaring(X : Item) return Item;
23
Example of a generic
declaration declaring a generic package:
24
generic
type Item is private;
type Vector is array (Positive range <>) of Item;
with function Sum(X, Y : Item) return Item;
package On_Vectors is
function Sum (A, B : Vector) return Vector;
function Sigma(A : Vector) return Item;
Length_Error : exception;
end On_Vectors;
Contents Index Search Previous Next Legal