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)].
7.a
Reason: The reason for forbidding constraints
in subtype_indications is that it simplifies
the elaboration of generic_declarations (since
there is nothing to evaluate), and that it simplifies the matching rules,
and makes them more checkable at compile time.
Static Semantics
8/2
{
AI95-00434-01}
{generic package} {generic
subprogram} {generic
procedure} {generic
function} A
generic_declaration
declares a generic unit — a generic package, generic procedure
,
or generic function, as appropriate.
9
{generic formal}
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
{elaboration (generic_declaration)
[partial]} 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.
11.a
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;
Extensions to Ada 83
24.a
{
extensions to Ada 83}
The
syntax rule for
generic_formal_parameter_declaration
is modified to allow the reserved words
tagged and
abstract,
to allow formal derived types, and to allow formal packages.
24.b
Use_clauses are allowed
in generic_formal_parts. This is necessary
in order to allow a use_clause within a formal
part to provide direct visibility of declarations within a generic formal
package.
Wording Changes from Ada 83
24.c
The syntax for generic_formal_parameter_declaration
and formal_type_definition is split up into
more named categories. The rules for these categories are moved to the
appropriate clauses and subclauses. The names of the categories are changed
to be more intuitive and uniform. For example, we changed generic_parameter_declaration
to generic_formal_parameter_declaration, because
the thing it declares is a generic formal, not a generic. In the others,
we abbreviate “generic_formal” to just “formal”.
We can't do that for generic_formal_parameter_declaration,
because of confusion with normal formal parameters of subprograms.
Sponsored by Ada-Europe