DocAda^(tm) is a productivity tool of KSCE

| | | |
About DocAda Light: Preface / Preliminary / Help / TOC / Copyright
DocAda Online at the Ada Home: Complete RM95 / Updates / News

6.4 Subprogram Calls

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

Subclauses

1. Parameter Associations

About DocAda Light: Preface / Preliminary / Help / TOC / Copyright
DocAda Online at the Ada Home: Complete RM95 / Updates / News
| | | |