Ada Conformity Assessment Authority      Home Conformity Assessment   Test Suite ARGAda Standard
 
Annotated Ada Reference Manual (Ada 202x Draft 27)Legal Information
Contents   Index   References   Search   Previous   Next 

6.5.1 Nonreturning SubprogramsPragma No_Return

1/5
{AI95-00329-01} {AI95-00414-01} {AI05-0229-1} {AI12-0269-1} Specifying aspect No_Return to have the value True indicates that a subprogram procedure cannot return normally[; it may propagate an exception or loop forever].
1.a/5
Discussion: Aspect No_Deposit will have to wait for Ada 2028 2020. :-) 
Paragraphs 2 and 3 were moved to Annex J, “Obsolescent Features”. 

Static Semantics

3.1/5
 {AI05-0229-1} {AI12-0269-1} For a subprogram procedure or generic subprogram procedure, the following language-defined representation aspect may be specified:
3.2/3
 No_Return
The type of aspect No_Return is Boolean. When aspect No_Return is True for an entity, the entity is said to be nonreturning.
3.3/3
If directly specified, the aspect_definition shall be a static expression. [This aspect is never inherited;] if not directly specified, the aspect is False.
3.a/5
Aspect Description for No_Return: A subprogram procedure will not return normally.
3.4/5
 {AI05-0229-1} {AI12-0269-1} If a generic subprogram procedure is nonreturning, then so are its instances. If a subprogram procedure declared within a generic unit is nonreturning, then so are the corresponding copies of that subprogram procedure in instances.

Legality Rules

4/3
{AI95-00329-01} {AI95-00414-01} {AI05-0229-1} Aspect No_Return shall not be specified for a null procedure nor an instance of a generic unit.
4.a/2
Reason: A null procedure cannot have the appropriate nonreturning semantics, as it does not raise an exception or loop forever. 
4.b/5
Ramification: {AI05-0229-1} {AI12-0269-1} The procedure can be abstract. If a nonreturning subprogram procedure is renamed (anywhere) calls through the new name still have the nonreturning semantics. 
5/2
{AI95-00329-01} {AI95-00414-01} A return statement shall not apply to a nonreturning procedure or generic procedure.
5.1/5
 {AI12-0269-1} Any return statement that applies to a nonreturning function or generic function shall be a simple_return_statement with an expression that is a raise_expression, a call on a nonreturning function, or a parenthesized expression of one of these.
5.a/5
Ramification: We still require at least one return statement in a function; we just require that all such return statements don't actually return a value.
6/5
{AI95-00414-01} {AI12-0269-1} A subprogram procedure shall be nonreturning if it overrides a dispatching nonreturning subprogram procedure. In addition to the places where Legality Rules normally apply (see 12.3), this rule applies also in the private part of an instance of a generic unit.
6.a/5
Reason: This ensures that dispatching calls to nonreturning subprograms procedures will, in fact, not return. 
7/5
{AI95-00414-01} {AI12-0269-1} If a renaming-as-body completes a nonreturning subprogram procedure declaration, then the renamed subprogram procedure shall be nonreturning.
7.a/2
Reason: This ensures that no extra code is needed to implement the renames (that is, no wrapper is needed) as the body has the same property. 
Paragraph 8 was deleted.

Dynamic Semantics

9/2
{AI95-00329-01} {AI95-00414-01} If the body of a nonreturning procedure completes normally, Program_Error is raised at the point of the call.
9.a/5
Discussion: {AI12-0269-1} Note that there is no name for suppressing this check, since the check represents a bug, imposes no time overhead, and minimal space overhead (since it can usually be statically eliminated as dead code). We don't need a similar rule for nonreturning functions as this is standard semantics for all functions that normally complete without a transfer of control (such as a return statement). 
9.b/2
Implementation Note: If a nonreturning procedure tries to return, we raise Program_Error. This is stated as happening at the call site, because we do not wish to allow the procedure to handle the exception (and then, perhaps, try to return again!). However, the expected run-time model is that the compiler will generate raise Program_Error at the end of the procedure body (but not handleable by the procedure itself), as opposed to doing it at the call site. (This is just like the typical run-time model for functions that fall off the end without returning a value). The reason is indirect calls: in P.all(...);, the compiler cannot know whether P designates a nonreturning procedure or a normal one. Putting the raise Program_Error in the procedure's generated code solves this problem neatly.
9.c/2
Similarly, if one passes a nonreturning procedure to a generic formal parameter, the compiler cannot know this at call sites (in shared code implementations); the raise-in-body solution deals with this neatly. 

Examples

10/3
{AI95-00433-01} {AI05-0229-1} procedure Fail(Msg : String)  -- raises Fatal_Error exception
   with No_Return;
   -- Inform compiler and reader that procedure never returns normally

Extensions to Ada 95

10.a/2
{AI95-00329-01} {AI95-00414-01} Pragma No_Return is new. 

Extensions to Ada 2005

10.b/3
{AI05-0229-1} Aspect No_Return is new; pragma No_Return is now obsolescent. 

Extensions to Ada 2012

10.c/5
{AI12-0269-1} Aspect No_Return can now be applied to functions as well as procedures. 

Contents   Index   References   Search   Previous   Next 
Ada-Europe Ada 2005 and 2012 Editions sponsored in part by Ada-Europe