Next: , Previous: 6.3.2, Up: 6


6.4 Subprogram Calls

1
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

2

procedure_call_statement::=
    procedure_name;
  procedure_prefix actual_parameter_part;

3

function_call::=
    function_name
  function_prefix actual_parameter_part

4

actual_parameter_part::=
    (parameter_association {, parameter_association})

5

parameter_association::=
   [formal_parameter_selector_name =>] explicit_actual_parameter

6

explicit_actual_parameter::= expression variable_name

7

A parameter_association is named or positional according to whether or not the formal_parameter_selector_name (see 4.1.3) 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 (see 4.1.4).
Name Resolution Rules

8/2
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. The name or prefix shall not resolve to denote an abstract subprogram unless it is also a dispatching subprogram. When there is an actual_parameter_part (see 6.4), the prefix can be an implicit_dereference (see 4.1) of an access−to−subprogram value.

9
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

10/2
For the execution of a subprogram call, the name or prefix of the call is evaluated, and each parameter_association (see 6.4) is evaluated (see 6.4.1). If a default_expression (see 3.7) is used, an implicit parameter_association (see 6.4) is assumed for this rule. These evaluations are done in an arbitrary order. The subprogram_body (see 6.3) is then executed, or a call on an entry or protected subprogram is performed (see 3.9.2). 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).

10.1/2
If the name or prefix of a subprogram call denotes a prefixed view (see 4.1.3), the subprogram call is equivalent to a call on the underlying subprogram, with the first actual parameter being provided by the prefix of the prefixed view (or the Access attribute of this prefix if the first formal parameter is an access parameter), and the remaining actual parameters given by the actual_parameter_part, if any.

11/2
The exception Program_Error is raised at the point of a function_call if the function completes normally without executing a return statement.

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

Examples

13
Examples of procedure calls:

14

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

15

     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

16
Examples of function calls:

17

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

18
Examples of procedures with default expressions:

19

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

20

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

21
Examples of their calls:

22

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

23

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

     NOTES

24

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

25
Examples of overloaded subprograms:

26

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

27

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

28
Examples of their calls:

29

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

30

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

31

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