Ada Reference Manual (Ada 2022) — Legal Information

6.1 Subprogram Declarations

A subprogram_declaration declares a procedure or function.

Syntax

2/3

subprogram_declaration ::=
    [overriding_indicator]
    subprogram_specification
        [aspect_specification];

3/2

This paragraph was deleted.

4/2

subprogram_specification ::=
procedure_specification
| function_specification

4.1/2

procedure_specification ::=
procedure defining_program_unit_name parameter_profile

4.2/2

function_specification ::=
function defining_designator parameter_and_result_profile

designator ::= [parent_unit_name . ]identifier | operator_symbol

defining_designator ::=
defining_program_unit_name | defining_operator_symbol

defining_program_unit_name ::= [parent_unit_name . ]defining_identifier

The optional parent_unit_name is only allowed for library units (see 10.1.1).

operator_symbol ::= string_literal

10/5

The sequence of characters in an operator_symbol shall form a reserved word, a delimiter, or compound delimiter that corresponds to an operator belonging to one of the six categories of operators defined in 4.5.

defining_operator_symbol ::= operator_symbol

parameter_profile ::= [formal_part]

13/2

parameter_and_result_profile ::=
[formal_part] return [null_exclusion] subtype_mark
| [formal_part] return access_definition

formal_part ::=
(parameter_specification {; parameter_specification})

15/5

parameter_specification ::=
    defining_identifier_list : [aliased] mode [null_exclusion] subtype_mark [:= default_expression]
        [aspect_specification]
  | defining_identifier_list : access_definition [:= default_expression]
        [aspect_specification]

mode ::= [in] | in out | out

Name Resolution Rules

A formal parameter is an object directly visible within a subprogram_body that represents the actual parameter passed to the subprogram in a call; it is declared by a parameter_specification. For a formal parameter, the expected type for its default_expression, if any, is that of the formal parameter.

Legality Rules

18/3

The parameter mode of a formal parameter conveys the direction of information transfer with the actual parameter: in, in out, or out. Mode in is the default, and is the mode of a parameter defined by an access_definition.

A default_expression is only allowed in a parameter_specification for a formal parameter of mode in.

20/3

A subprogram_declaration or a generic_subprogram_declaration requires a completion unless the Import aspect (see B.1) is True for the declaration; the completion shall be a body or a renaming_declaration (see 8.5). A completion is not allowed for an abstract_subprogram_declaration (see 3.9.3), a null_procedure_declaration (see 6.7), or an expression_function_declaration (see 6.8).

A name that denotes a formal parameter is not allowed within the formal_part in which it is declared, nor within the formal_part of a corresponding body or accept_statement.

Static Semantics

The profile of (a view of) a callable entity is either a parameter_profile or parameter_and_result_profile; it embodies information about the interface to that entity — for example, the profile includes information about parameters passed to the callable entity. All callable entities have a profile — enumeration literals, other subprograms, and entries. An access-to-subprogram type has a designated profile. Associated with a profile is a calling convention. A subprogram_declaration declares a procedure or a function, as indicated by the initial reserved word, with name and profile as given by its specification.

23/2

The nominal subtype of a formal parameter is the subtype determined by the optional null_exclusion and the subtype_mark, or defined by the access_definition, in the parameter_specification. The nominal subtype of a function result is the subtype determined by the optional null_exclusion and the subtype_mark, or defined by the access_definition, in the parameter_and_result_profile.

23.1/3

An explicitly aliased parameter is a formal parameter whose parameter_specification includes the reserved word aliased.

24/2

An access parameter is a formal in parameter specified by an access_definition. An access result type is a function result type specified by an access_definition. An access parameter or result type is of an anonymous access type (see 3.10). Access parameters of an access-to-object type allow dispatching calls to be controlled by access values. Access parameters of an access-to-subprogram type permit calls to subprograms passed as parameters irrespective of their accessibility level.

The subtypes of a profile are:

For any non-access parameters, the nominal subtype of the parameter.

27/2

For any access parameters of an access-to-object type, the designated subtype of the parameter type.

27.1/3

For any access parameters of an access-to-subprogram type, the subtypes of the designated profile of the parameter type.

28/2

For any non-access result, the nominal subtype of the function result.

28.1/2

For any access result type of an access-to-object type, the designated subtype of the result type.

28.2/3

For any access result type of an access-to-subprogram type, the subtypes of the designated profile of the result type.

The types of a profile are the types of those subtypes.

30/3

A subprogram declared by an abstract_subprogram_declaration is abstract; a subprogram declared by a subprogram_declaration is not. See 3.9.3, “Abstract Types and Subprograms”. Similarly, a procedure declared by a null_procedure_declaration is a null procedure; a procedure declared by a subprogram_declaration is not. See 6.7, “Null Procedures”. Finally, a function declared by an expression_function_declaration is an expression function; a function declared by a subprogram_declaration is not. See 6.8, “Expression Functions”.

30.1/2

An overriding_indicator is used to indicate whether overriding is intended. See 8.3.1, “Overriding Indicators”.

Dynamic Semantics

31/2

The elaboration of a subprogram_declaration has no effect.

NOTE 1 A parameter_specification with several identifiers is equivalent to a sequence of single parameter_specifications, as explained in 3.3.

NOTE 2 Abstract subprograms do not have bodies, and cannot be used in a nondispatching call (see 3.9.3, “Abstract Types and Subprograms”).

NOTE 3 The evaluation of default_expressions is caused by certain calls, as described in 6.4.1. They are not evaluated during the elaboration of the subprogram declaration.

NOTE 4 Subprograms can be called recursively and can be called concurrently from multiple tasks.

Examples

Examples of subprogram declarations:

procedure Traverse_Tree;
procedure Increment(X : in out Integer);
procedure Right_Indent(Margin : out Line_Size); -- see 3.5.4
procedure Switch(From, To : in out Link); -- see 3.10.1

function Random return Probability; -- see 3.5.7

39/4

function Min_Cell(X : Link) return Cell;                 -- see 3.10.1
function Next_Frame(K : Positive) return Frame;          -- see 3.10
function Dot_Product(Left, Right : Vector) return Real;  -- see 3.6
function Find(B : aliased in out Barrel; Key : String) return Real;
                                                         -- see 4.1.5

function "*"(Left, Right : Matrix) return Matrix; -- see 3.6

Examples of in parameters with default expressions:

procedure Print_Header(Pages  : in Natural;
            Header : in Line    :=  (1 .. Line'Last => ' '); -- see 3.6
            Center : in Boolean := True);

Ada 2005 and 2012 Editions sponsored in part by Ada-Europe