Contents   Index   Search   Related Documents   Previous   Next

6.5 Return Statements

1/2
     A simple_return_statement or extended_return_statement (collectively called a return statement) is used to complete the execution of the innermost enclosing subprogram_body, entry_body, or accept_statement.

Syntax

2/2
simple_return_statement ::= return [expression];
2.1/2
extended_return_statement ::=
    return identifier : [aliased] return_subtype_indication [:= expression] [do
        handled_sequence_of_statements
    end return];
2.2/2
return_subtype_indication ::= subtype_indication | access_definition

Name Resolution Rules

3/2
     The result subtype of a function is the subtype denoted by the subtype_mark, or defined by the access_definition, after the reserved word return in the profile of the function. The expected type for the expression, if any, of a simple_return_statement is the result type of the corresponding function. The expected type for the expression of an extended_return_statement is that of the return_subtype_indication.

Legality Rules

4/2
     A return statement shall be within a callable construct, and it applies to the innermost callable construct or extended_return_statement that contains it. A return statement shall not be within a body that is within the construct to which the return statement applies.
5/2
     A function body shall contain at least one return statement that applies to the function body, unless the function contains code_statements. A simple_return_statement shall include an expression if and only if it applies to a function body. An extended_return_statement shall apply to a function body.
5.1/2
       For an extended_return_statement that applies to a function body:
5.2/2
5.3/2
5.4/2
5.5/2
5.6/2

Static Semantics

5.7/2
       Within an extended_return_statement, the return object is declared with the given identifier, with the nominal subtype defined by the return_subtype_indication.

Dynamic Semantics

5.8/2
       For the execution of an extended_return_statement, the subtype_indication or access_definition is elaborated. This creates the nominal subtype of the return object. If there is an expression, it is evaluated and converted to the nominal subtype (which might raise Constraint_Error — see 4.6); the return object is created and the converted value is assigned to the return object. Otherwise, the return object is created and initialized by default as for a stand-alone object of its nominal subtype (see 3.3.1). If the nominal subtype is indefinite, the return object is constrained by its initial value.
6/2
     For the execution of a simple_return_statement, the expression (if any) is first evaluated, converted to the result subtype, and then is assigned to the anonymous return object.
7/2
     If the return object has any parts that are tasks, the activation of those tasks does not occur until after the function returns (see 9.2).
8/2
     If the result type of a function is a specific tagged type, the tag of the return object is that of the result type. If the result type is class-wide, the tag of the return object is that of the value of the expression. A check is made that the accessibility level of the type identified by the tag of the result is not deeper than that of the master that elaborated the function body. If this check fails, Program_Error is raised.
9/2
10/2
11/2
      This paragraph was deleted.
12/2
13/2
14/2
15/2
16/2
17/2
      This paragraph was deleted.
18/2
19/2
20/2
      This paragraph was deleted.
20.1/2
        If the result subtype of a function has one or more unconstrained access discriminants, a check is made that the accessibility level of the anonymous access type of each access discriminant, as determined by the expression or the return_subtype_indication of the function, is not deeper than that of the master that elaborated the function body. If this check fails, Program_Error is raised.
21/2
      This paragraph was deleted.
22/2
      For the execution of an extended_return_statement, the handled_sequence_of_statements is executed. Within this handled_sequence_of_statements, the execution of a simple_return_statement that applies to the extended_return_statement causes a transfer of control that completes the extended_return_statement. Upon completion of a return statement that applies to a callable construct, a transfer of control is performed which completes the execution of the callable construct, and returns to the caller.
23/2
      In the case of a function, the function_call denotes a constant view of the return object.

Implementation Permissions

24/2
      If the result subtype of a function is unconstrained, and a call on the function is used to provide the initial value of an object with a constrained nominal subtype, Constraint_Error may be raised at the point of the call (after abandoning the execution of the function body) if, while elaborating a return_subtype_indication or evaluating the expression of a return statement within the function, it is determined that the value of the result will violate the constraint of this object's subtype.

Examples

25
    Examples of return statements:
26/2
return;                         -- in a procedure body, entry_body,
                                -- accept_statement, or extended_return_statement
27
return Key_Value(Last_Index);   -- in a function body
28/2
return Node : Cell do           -- in a function body, see 3.10.1 for Cell
   Node.Value := Result;
   Node.Succ := Next_Node;
end return;

Contents   Index   Search   Related Documents   Previous   Next   Legal