6.4 Subprogram Calls

Contents | Index | Previous | Next

A subprogram call is either a procedure_call_statement or a function_call; it invokes the execution of the subprogram_body. The call specifies the association of the actual parameters, if any, with formal parameters of the subprogram.

Syntax

procedure_call_statement ::=
    procedure_name;
  | procedure_prefix actual_parameter_part;

function_call ::=
    function_name
  | function_prefix actual_parameter_part

actual_parameter_part ::=
    (parameter_association {, parameter_association})

parameter_association ::=
    [formal_parameter_selector_name =>] explicit_actual_parameter

explicit_actual_parameter ::= expression | variable_name

A parameter_association is named or positional according to whether or not the formal_parameter_selector_name is specified. Any positional associations shall precede any named associations. Named associations are not allowed if the prefix in a subprogram call is an attribute_reference.

Name Resolution Rules

The name or prefix given in a procedure_call_statement shall resolve to denote a callable entity that is a procedure, or an entry renamed as (viewed as) a procedure. The name or prefix given in a function_call shall resolve to denote a callable entity that is a function. When there is an actual_parameter_part, the prefix can be an implicit_dereference of an access-to-subprogram value.

A subprogram call shall contain at most one association for each formal parameter. Each formal parameter without an association shall have a default_expression (in the profile of the view denoted by the name or prefix). This rule is an overloading rule (see 8.6).

Dynamic Semantics

For the execution of a subprogram call, the name or prefix of the call is evaluated, and each parameter_association is evaluated (see 6.4.1). If a default_expression is used, an implicit parameter_association is assumed for this rule. These evaluations are done in an arbitrary order. The subprogram_body is then executed. Finally, if the subprogram completes normally, then after it is left, any necessary assigning back of formal to actual parameters occurs (see 6.4.1).

The exception Program_Error is raised at the point of a function_call if the function completes normally without executing a return_statement.

A function_call denotes a constant, as defined in 6.5; the nominal subtype of the constant is given by the result subtype of the function.

Examples

Examples of procedure calls:

Traverse_Tree;                                               --  see 6.1 
Print_Header(128, Title, True);                              --  see 6.1

Switch(From => X, To => Next);                               --  see 6.1 
Print_Header(128, Header => Title, Center => True);          --  see 6.1 
Print_Header(Header => Title, Center => True, Pages => 128); --  see 6.1

Examples of function calls:

Dot_Product(U, V)   --  see 6.1 and 6.3
Clock               --  see 9.6 
F.all               --  presuming F is of an access-to-subprogram type -- see 3.10

Examples of procedures with default expressions:

procedure Activate(Process : in Process_Name; 
                After   : in Process_Name := No_Process; 
                Wait    : in Duration := 0.0; 
                Prior   : in Boolean := False);

procedure Pair(Left, Right : in Person_Name := new Person);   --  see 3.10.1

Examples of their calls:

Activate(X); 
Activate(X, After => Y); 
Activate(X, Wait => 60.0, Prior => True); 
Activate(X, Y, 10.0, False);

Pair; 
Pair(Left => new Person, Right => new Person);

Notes

7 If a default_expression is used for two or more parameters in a multiple parameter_specification, the default_expression is evaluated once for each omitted parameter. Hence in the above examples, the two calls of Pair are equivalent.

Examples

Examples of overloaded subprograms:

procedure Put(X : in Integer);
procedure Put(X : in String);

procedure Set(Tint   : in Color);
procedure Set(Signal : in Light);

Examples of their calls:

Put(28); 
Put("no possible ambiguity here");

Set(Tint   => Red); 
Set(Signal => Red); 
Set(Color'(Red));

--  Set(Red) would be ambiguous since Red may 
--  denote a value either of type Color or of type Light

Contents | Index | Previous | Next Legal