CVS difference for ais/ai-00416.txt

Differences between 1.4 and version 1.5
Log of other versions for file ais/ai-00416.txt

--- ais/ai-00416.txt	2005/03/15 02:13:15	1.4
+++ ais/ai-00416.txt	2005/04/13 05:37:23	1.5
@@ -1,5 +1,30 @@
-!standard 3.9.2(2)                                     05-03-10  AI95-00416/04
+!standard 3.2.3(01)                                     05-03-10  AI95-00416/04
+!standard 3.7(27)
+!standard 3.9.2(02)
+!standard 3.9.2(04)
+!standard 3.9.2(05)
+!standard 3.9.2(06)
+!standard 3.9.2(11)
+!standard 3.9.2(18)
+!standard 3.10.2(09)
+!standard 3.10.2(10)
+!standard 3.10.2(11)
+!standard 3.10.2(12)
+!standard 3.10.2(13)
+!standard 3.10.2(14)
+!standard 4.8(05)
+!standard 4.8(07)
+!standard 6.5(05)
+!standard 6.5(06)
+!standard 6.5(20)
+!standard 6.5(22)
+!standard 7.6.1(03)
+!standard 9.2(02)
+!standard 9.2(03)
+!standard 9.2(04)
 !class amendment 05-02-07
+!status Amendment 200Y 05-03-16
+!comment This AI is in the Amendment, but is not yet approved.
 !status work item 05-02-07
 !status received 05-02-07
 !priority High
@@ -109,7 +134,7 @@
     it has an operand whose expected type (see 8.6) is T, or if it has
     an access parameter {or access result type} (see 6.1) designating T.
 
-Change 3.7(27/2) to:
+Change 3.7(27) to:
 
     For an access discriminant, an access_definition is elaborated when
     the value of the corresponding access discriminant is defined: by
@@ -117,7 +142,7 @@
     discriminant_constraint, or by an assignment that initializes the
     enclosing object.
 
-Add to end of 3.9.2(2/2):
+Add to end of 3.9.2(2):
 
     {Similarly, if the call is to a function with access result type
     designating T, then the call has a *controlling access result*, and
@@ -146,7 +171,7 @@
 
 Delete 3.9.2(11.b) (it explained the second sentence of 3.9.2(11)).
 
-Change 3.9.2(18/2):
+Change 3.9.2(18):
 
     * If the call has a controlling result {or controlling access result} and
       is itself{, or designates,} a [(possibly parenthesized or qualified)]
@@ -154,7 +179,7 @@
       descendant of type T, then its controlling tag value is determined
       by the controlling tag value of this enclosing call;
 
-Change 3.9.2(18.1/2):
+Change the paragraph inserted by AI95-00196 after 3.9.2(18):
 
     * If the call has a controlling result {or controlling access result} and
       {(possibly parenthesized, qualified, or dereferenced)} is the
@@ -174,7 +199,7 @@
     value is perfectly acceptable, and can be a useful indication of a
     particular status of the call.
 
-Add after 3.10.2(7/2):
+Add after 3.10.2(7):
 
    AARM NOTE:
      This rule defines the accessibility of all named access types, as
@@ -202,7 +227,7 @@
     * The accessibility level of a view conversion{, qualified expression,
       or parenthesized_expression,} is the same as that of the operand.
 
-Replace 3.10.2(10/2) with:
+Replace 3.10.2(10) with:
 
     * The accessibility level of the result of a function call that is
       used as a prefix of a name or as the actual parameter in a call
@@ -210,7 +235,7 @@
       accessibility level is that of the object being initialized from
       the function result.
 
-Add after 3.10.2(10/2):
+Add after 3.10.2(10):
 
     * Within a return statement, the accessibility level of the return
       object is that of the execution of the return statement. If the
@@ -229,9 +254,9 @@
       due to propagating an exception, or a goto). For a normal return,
       of course, no finalization is done before returning.
 
-Delete 3.10.2(11.1/2) (it is redundant).
+Delete the paragraph added by AI95-00385 after 3.10.2(11) (it is redundant).
 
-Change 3.10.2(12/2) to be:
+Change 3.10.2(12) to be:
 
     * For an access discriminant, the accessibility level of its
       anonymous access type is determined as follows:
@@ -267,7 +292,7 @@
 
 Delete 3.10.2(12.a/2) (it was moved up to be after paragraph 7/2).
 
-Delete 3.10.2(13.2/2) (it is redundant).
+Delete the second paragraph inserted by AI95-00318 after 3.10.2(13) (it is redundant).
 
 Change 3.10.2(14):
 
@@ -284,7 +309,7 @@
          + for an allocator used to define the discriminant of an object,
            the level of the object.
 
-Add after 4.8(5.1/2):
+Add after the paragraph inserted by AI95-00344 after 4.8(5):
 
     If the designated subtype of the type of the allocator has one or
     more unconstrained access discriminants, then the accessibility
@@ -293,7 +318,7 @@
     allocator, shall not be statically deeper than that of the type of
     the allocator (see 3.10.2).
 
-Change 4.8(7/2):
+Change 4.8(7) as amended by AI95-00344:
 
     ... is not deeper than that of the type of the allocator. {If the
     designated subtype of the allocator has one or more unconstrained
@@ -302,7 +327,7 @@
     not deeper than that of the type of the allocator.} Program_Error
     is raised if [this] {either such} check fails.
 
-Add after 6.5(5.3/2):
+Add after the third paragraph inserted by AI95-00318 after 6.5(5):
 
     If the result type is class-wide, the accessibility level of the
     type of the return_expression shall not be statically deeper than
@@ -334,12 +359,8 @@
     of statements), the return object is finalized prior to leaving the
     return statement.
 
-Change 6.5(6/2):
+Add after 6.5(6):
 
-    For the execution of a {simple_}return_statement, ...
-
-Add after 6.5(6/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).
 
@@ -353,7 +374,7 @@
     part if the function is being used to initialize part of a declared
     object.
 
-Change 6.5(20.1/2):
+Change the paragraph inserted by AI95-00318 after 6.5(20):
 
     If the result type is class-wide, a check is made that the
     accessibility level of the type identified by the tag of the result
@@ -389,7 +410,7 @@
      implementation may need to simulate a goto to a point outside any
      local exception handlers prior to raising the exception.
 
-Change 7.6.1(3/2):
+Change 7.6.1(3) as amended by AI95-00162:
 
      ... except in the case of a master: the execution of a body other
      than a package_body; the elaboration of a declaration other than
@@ -518,11 +539,521 @@
 !example
 
 (See umm, er...imagine one here. - ED)
+
+!corrigendum 3.2.3(01)
 
---!corrigendum 02.09(2)
+@drepl
+An operation @i<operates on a type T> if it yields a value of type @i<T>, if it
+has an operand whose expected type (see 8.6) is @i<T>, or if it has an access
+parameter (see 6.1) designating @i<T>. A predefined operator, or other
+language-defined operation such as assignment or a membership test, that
+operates on a type, is called a @i<predefined operation> of the type. The
+@i<primitive operations> of a type are the predefined operations of the type,
+plus any user-defined primitive subprograms.
+@dby
+An operation @i<operates on a type T> if it yields a value of type @i<T>, if it
+has an operand whose expected type (see 8.6) is @i<T>, or if it has an access
+parameter or access result type (see 6.1) designating @i<T>. A predefined
+operator, or other language-defined operation such as assignment or a
+membership test, that operates on a type, is called a @i<predefined operation>
+of the type. The @i<primitive operations> of a type are the predefined
+operations of the type, plus any user-defined primitive subprograms.
+
+
+!corrigendum 3.7(27)
+
+@drepl
+An @fa<access_definition> is elaborated when the value of a corresponding
+access discriminant is defined, either by evaluation of its
+@fa<default_expression> or by elaboration of a @fa<discriminant_constraint>.
+The elaboration of an @fa<access_definition> creates the anonymous access
+type. When the expression defining the access discriminant is evaluated, it is
+converted to this anonymous access type (see 4.6).
+@dby
+For an access discriminant, an @fa<access_definition> is elaborated when
+the value of the corresponding access discriminant is defined: by
+evaluation of its @fa<default_expression>, by elaboration of a
+@fa<discriminant_constraint>, or by an assignment that initializes the
+enclosing object.
+
+
+!corrigendum 3.9.2(02)
+!comment This includes the wording change from AI-260-2.
+
+@drepl
+A @i<call on a dispatching operation> is a call whose @fa<name> or @fa<prefix>
+denotes the declaration of a primitive subprogram of a tagged type, that is, a
+dispatching operation. A @i<controlling operand> in a call on a dispatching
+operation of a tagged type @i<T> is one whose corresponding formal parameter is
+of type @i<T> or is of an anonymous access type with designated type @i<T>; the
+corresponding formal parameter is called a @i<controlling formal parameter>. If
+the controlling formal parameter is an access parameter, the controlling
+operand is the object designated by the actual parameter, rather than the
+actual parameter itself. If the call is to a (primitive) function with result
+type @i<T>, then the call has a @i<controlling result> -- the context of the
+call can control the dispatching.
+@dby
+A @i<call on a dispatching operation> is a call whose @fa<name> or @fa<prefix>
+denotes the declaration of a dispatching operation. A @i<controlling operand>
+in a call on a dispatching operation of a tagged type @i<T> is one whose
+corresponding formal parameter is of type @i<T> or is of an anonymous access
+type with designated type @i<T>; the corresponding formal parameter is called a
+@i<controlling formal parameter>. If the controlling formal parameter is an
+access parameter, the controlling operand is the object designated by the
+actual parameter, rather than the actual parameter itself. If the call is to a
+(primitive) function with result type @i<T>, then the call has a @i<controlling
+result> -- the context of the call can control the dispatching. Similarly, if
+the call is to a function with access result type designating @i<T>, then the
+call has a @i<controlling access result>, and the context can similarly control
+dispatching.
+
+
+!corrigendum 3.9.2(04)
+
+@drepl
+@xbullet<The @fa<name> or expression is @i<statically tagged> if it is of a
+specific tagged type and, if it is a call with a controlling result, it has at
+least one statically tagged controlling operand; >
+@dby
+@xbullet<The @fa<name> or expression is @i<statically tagged> if it is of a
+specific tagged type and, if it is a call with a controlling result or
+controlling access result, it has at least one statically tagged controlling
+operand;>
+
+
+!corrigendum 3.9.2(05)
+
+@drepl
+@xbullet<The @fa<name> or expression is @i<dynamically tagged> if it is of a
+class-wide type, or it is a call with a controlling result and at least one
+dynamically tagged controlling operand;>
+@dby
+@xbullet<The @fa<name> or expression is @i<dynamically tagged> if it is of a
+class-wide type, or it is a call with a controlling result or controlling
+access result and at least one dynamically tagged controlling operand;>
+
+
+!corrigendum 3.9.2(06)
+
+@drepl
+@xbullet<The @fa<name> or expression is @i<tag indeterminate> if it is a call
+with a controlling result, all of whose controlling operands (if any) are tag
+indeterminate.>
+@dby
+@xbullet<The @fa<name> or expression is @i<tag indeterminate> if it is a call
+with a controlling result or controlling access result, all of whose
+controlling operands (if any) are tag indeterminate.>
+
+
+!corrigendum 3.9.2(11)
+
+@drepl
+The @fa<default_expression> for a controlling formal parameter of a dispatching
+operation shall be tag indeterminate. A controlling formal parameter that is an
+access parameter shall not have a @fa<default_expression>.
+@dby
+The @fa<default_expression> for a controlling formal parameter of a dispatching
+operation shall be tag indeterminate.
+
+If a dispatching operation is defined by a @fa<subprogram_renaming_declaration>
+or the instantiation of a generic subprogram, any access parameter of the
+renamed subprogram or the generic subprogram that corresponds to a
+controlling access parameter of the dispatching operation, shall be
+null excluding.
+
+
+!corrigendum 3.9.2(18)
+
+@drepl
+@xbullet<If the call has a controlling result and is itself a (possibly
+parenthesized or qualified) controlling operand of an enclosing call on a
+dispatching operation of type @i<T>, then its controlling tag value is
+determined by the controlling tag value of this enclosing call;>
+@dby
+@xbullet<If the call has a controlling result or controlling access result and
+is itself, or designates, a controlling operand of an enclosing call on a
+dispatching operation of a descendant of type @i<T>, then its controlling tag
+value is determined by the controlling tag value of this enclosing call;>
+
+@xbullet<If the call has a controlling result or controlling access result and
+(possibly parenthesized, qualified, or dereferenced) is the expression of an
+@fa<assignment_statement> whose target is of a class-wide type, then
+its controlling tag value is determined by the target;>
+
+
+!corrigendum 3.10.2(09)
+
+@drepl
+@xbullet<The accessibility level of a view conversion is the same as that of
+the operand.>
+@dby
+@xbullet<The accessibility level of a view conversion, qualified expression,
+or parenthesized_expression, is the same as that of the operand.>
+
+
+!corrigendum 3.10.2(10)
+
+@drepl
+@xbullet<For a function whose result type is a return-by-reference type, the
+accessibility level of the result object is the same as that of the master that
+elaborated the function body. For any other function, the accessibility level
+of the result object is that of the execution of the called function.>
+@dby
+@xbullet<The accessibility level of the result of a function call that is
+used as a prefix of a name or as the actual parameter in a call
+is that of the immediately enclosing master. In other contexts, the
+accessibility level is that of the object being initialized from
+the function result.>
+
+@xbullet<Within a return statement, the accessibility level of the return
+object is that of the execution of the return statement. If the
+return statement completes normally by returning from the
+function, prior to leaving the function, the accessibility level
+of the return object changes to be a level determined by the point
+of call.>
+
+!comment !corrigendum 3.10.2(11)
+!comment Since we want no change, we commented out the change in AI-385.
+!comment @ddel This paragraph, added by AI95-00385, should be deleted.
+
+!corrigendum 3.10.2(12)
+
+@drepl
+@xbullet<The accessibility level of the anonymous access type of an access
+discriminant is the same as that of the containing object or associated
+constrained subtype.>
+@dby
+@xbullet<The accessibility level of the anonymous access type defined by an
+@fa<access_definition> of an @fa<object_renaming_declaration> is the same as
+that of the renamed view.>
+
+@xbullet<For an access discriminant, the accessibility level of its
+anonymous access type is determined as follows:>
+
+@xinbull<For an access discriminant whose value is determined by a
+@fa<discriminant_association> in a @fa<subtype_indication>, the
+accessibility level of the object or subprogram designated by
+the associated value (or library level if the value is @b<null>);>
+
+@xinbull<For an access discriminant of an object defined by an @fa<aggregate>
+where the value of the discriminant is determined by a
+@fa<component_association> in the @fa<aggregate>, the accessibility
+level of the object or subprogram designated by the associated
+value (or library level if the value is @b<null>);>
+
+@xinbull<For an access discriminant of any other object with an unconstrained
+nominal subtype, the accessibility level of the object.>
+
+!corrigendum 3.10.2(13)
+!comment A fake to force a conflict.
+
+@ddel The second paragraph added by AI95-00318 should be deleted.
+
+!corrigendum 3.10.2(14)
+
+@drepl
+@xbullet<The accessibility level of an object created by an @fa<allocator> is
+the same as that of the access type.>
+@dby
+@xbullet<The accessibility level of an object created by an @fa<allocator> is
+the same as that of the access type, except for an @fa<allocator> that
+defines the value of an access parameter or an access discriminant.
+For an access parameter, the accessibility level is that of the
+master immediately enclosing the call. For an access discriminant,
+the accessibility level is determined as follows:>
+
+@xinbull<for an @fa<allocator> used to define the constraint in a
+@fa<subtype_declaration>, the level of the @fa<subtype_declaration>;>
+
+@xinbull<for an @fa<allocator> used to define the constraint in a
+@fa<component_definition>, the level of the enclosing type;>
+
+@xinbull<for an @fa<allocator> used to define the discriminant of an object,
+the level of the object.>
+
+!corrigendum 04.08(05)
+
+@dinsa
+If the type of the @fa<allocator> is an access-to-constant type, the
+@fa<allocator> shall be an initialized allocator. If the designated type is
+limited, the @fa<allocator> shall be an uninitialized allocator.
+@dinst
+If the designated subtype of the type of the @fa<allocator> has one or
+more unconstrained access discriminants, then the accessibility level
+of the anonymous access type of each access discriminant, as
+determined by the @fa<subtype_indication> or @fa<qualified_expression> of the
+@fa<allocator>, shall not be statically deeper than that of the type of
+the @fa<allocator> (see 3.10.2).
+
+
+!corrigendum 04.08(07)
+!comment This includes the AI-344 change.
+
+@drepl
+For the evaluation of an @fa<allocator>, the elaboration of the
+@fa<subtype_indication> or the evaluation of the @fa<qualified_expression> is
+performed first. For the evaluation of an initialized allocator, an object of
+the designated type is created and the value of the @fa<qualified_expression>
+is converted to the designated subtype and assigned to the object.
+@dby
+For the evaluation of an @fa<allocator>, the elaboration of the
+@fa<subtype_indication> or the evaluation of the @fa<qualified_expression> is
+performed first. For the evaluation of an initialized allocator, an object of
+the designated type is created and the value of the @fa<qualified_expression>
+is converted to the designated subtype and assigned to the object. If the
+designated type of the type of the @fa<allocator> is class-wide, then
+a check is made that the accessibility level of the type identified by
+the tag of the value of the @fa<qualified_expression> is not deeper than that
+of the type of the @fa<allocator>. If the
+designated subtype of the @fa<allocator> has one or more unconstrained
+access discriminants, then a check is made that the accessibility
+level of the anonymous access type of each access discriminant is
+not deeper than that of the type of the @fa<allocator>.
+Program_Error is raised if either such check fails.
+
+
+!corrigendum 6.5(05)
+
+@drepl
+A function body shall contain at least one @fa<return_statement> that applies
+to the function body, unless the function contains @fa<code_statement>s. A
+@fa<return_statement> shall include a return expression if and only if
+it applies to a function body.
+@dby
+A function body shall contain at least one @fa<return_statement> that applies
+to the function body, unless the function contains @fa<code_statement>s. A
+@fa<simple_return_statement> shall include a return expression if and only if
+it applies to a function body. An @fa<extended_return_statement> shall apply to
+a function body.
+
+If the result subtype of a function is defined by a @fa<subtype_mark>, the
+@fa<return_subtype_indication> of an @fa<extended_return_statement> that
+applies to the function body shall be a @fa<subtype_indication>. The type of
+the @fa<subtype_indication> shall be the result type of the function. If the
+result subtype of the function is constrained, then the subtype defined by the
+@fa<subtype_indication> shall also be constrained and shall statically match
+this result subtype. If the result subtype of the function is unconstrained,
+then the subtype defined by the @fa<subtype_indication> shall be a definite
+subtype, or there shall be a return expression.
+
+If the result subtype of the function is defined by an @fa<access_definition>,
+the @fa<return_subtype_indication> shall be an @fa<access_definition>. The
+subtype defined by the @fa<access_definition> shall statically match the result
+subtype of the function. The accessibility level of this anonymous access
+subtype is that of the result subtype.
+
+If the type of the return expression is limited, then the return expression
+shall be an aggregate, a function call (or equivalent use of an operator),
+or a @fa<qualified_expression> or parenthesized expression whose operand is one
+of these.
+
+If the result type is class-wide, the accessibility level of the
+type of the return expression shall not be statically deeper than
+that of the master that elaborated the function body. If the result
+subtype has one or more unconstrained access discriminants, the
+accessibility level of the anonymous access type of each access
+discriminant, as determined by the @fa<return_subtype_indication> or the
+return expression, shall not be statically deeper than that of the
+master that elaborated the function body.
+
+@i<@s8<Static Semantics>>
+
+Within an @fa<extended_return_statement>, the @i<return object> is declared
+with the given identifier, with nominal subtype defined by the
+@fa<return_subtype_indication>.
+
+
+!corrigendum 6.5(06)
+
+@drepl
+For the execution of a @fa<return_statement>, the @fa<expression> (if any) is
+first evaluated and converted to the result subtype.
+@dby
+For the execution of an @fa<extended_return_statement>, the
+@fa<subtype_indication> or @fa<access_definition> is elaborated. This creates
+the nominal subtype of the return object. If there is a return expression,
+it is evaluated and converted
+to the nominal subtype (which might raise Constraint_Error -- see 4.6) and
+becomes the initial value of the return object; otherwise, the return object is
+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. The @fa<handled_sequence_of_statements>, if
+any, is then executed.
+
+For the execution of a @fa<simple_return_statement>, the @fa<expression>
+(if any) is first evaluated and converted to the result subtype to become
+the value of the anonymous @i<return object>.
+
+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).
+
+
+!corrigendum 6.5(20)
+
+@dinsa
+The exception Program_Error is raised if this check fails.
+@dby
+If the result type is class-wide, 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 the result subtype 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 @fa<return_subtype_indication> or return expression, is not deeper
+than that of the master that elaborated the function body.
+If either check fails, Program_Error is raised.
+
+
+!corrigendum 6.5(22)
+
+@dinsa
+Finally, a transfer of control is performed which completes the
+execution of the construct to which the @fa<return_statement> applies,
+and returns to the caller.
+@dinst
+@i<@s8<Implementation Permission>>
+
+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 while elaborating a
+@fa<return_subtype_indication> or evaluating a return expression within
+the function, if it is determined that the value of the result will
+violate the constraint of this object's subtype.
+
+
+!corrigendum 7.6.1(03)
+
+@drepl
+After execution of a construct or entity is complete, it is @i<left>, meaning
+that execution continues with the next action, as defined for the execution
+that is taking place. Leaving an execution happens immediately after its
+completion, except in the case of a master: the execution of a @fa<task_body>,
+a @fa<block_statement>, a @fa<subprogram_body>, an @fa<entry_body>, or an
+@fa<accept_statement>. A master is finalized after it is complete, and before
+it is left.
+@dby
+After execution of a construct or entity is complete, it is @i<left>, meaning
+that execution continues with the next action, as defined for the execution
+that is taking place. Leaving an execution happens immediately after its
+completion, except in the case of a master: the execution of a body other than
+a @fa<package_body>; the elaboration of a declaration other than the
+declaration of a package or of a type; the execution of a @fa<statement>; or
+the evaluation of an @fa<expression> or @fa<range> that is not part of an
+enclosing @fa<expression>, @fa<range>, or @fa<simple_statement>. A master is
+finalized after it is complete, and before it is left.
+
+
+!corrigendum 9.2(02)
+
+@drepl
+A task object (which represents one task) can be created either as part of the
+elaboration of an @fa<object_declaration> occurring immediately within some
+declarative region, or as part of the evaluation of an @fa<allocator>. All
+tasks created by the elaboration of @fa<object_declaration>s of a single
+declarative region (including subcomponents of the declared objects) are
+activated together. Similarly, all tasks created by the evaluation of a single
+@fa<allocator> are activated together. The activation of a task is associated
+with the innermost @fa<allocator> or @fa<object_declaration> that is
+responsible for its creation.
+@dby
+A task object (which represents one task) can be a part of a
+stand-alone object, of an object created by an allocator, or of an
+anonymous object of a limited type. All tasks that are part of any
+of the stand-alone objects created by the elaboration of @fa<object_declaration>s (or
+@fa<generic_association>s of formal objects of mode @b<in>) of a single declarative region are activated together. All
+tasks that are part of a single object that is not a stand-alone
+object are activated together.
+
+
+!corrigendum 9.2(03)
+
+@drepl
+For tasks created by the elaboration of @fa<object_declaration>s of a given
+declarative region, the activations are initiated within the context of the
+@fa<handled_sequence_of_statements> (and its associated @fa<exception_handler>s
+if any -- see 11.2), just prior to executing the statements of the
+@fa<_sequence>. For a package without an explicit body or an explicit
+@fa<handled_sequence_of_statements>, an implicit body or an implicit
+@fa<null_statement> is assumed, as defined in 7.2.
+@dby
+For the tasks of a given declarative region, the activations are initiated
+within the context of the @fa<handled_sequence_of_statements> (and its
+associated @fa<exception_handler>s if any -- see 11.2), just prior to executing
+the statements of the @fa<_sequence>. For a package without an explicit body or
+an explicit @fa<handled_sequence_of_statements>, an implicit body or an
+implicit @fa<null_statement> is assumed, as defined in 7.2.
+
+
+!corrigendum 9.2(04)
+
+@drepl
+For tasks created by the evaluation of an @fa<allocator>, the activations are
+initiated as the last step of evaluating the @fa<allocator>, after completing
+any initialization for the object created by the @fa<allocator>, and prior to
+returning the new access value.
+@dby
+For tasks that are part a single object that is not a stand-alone
+object, activations are initiated after completing any
+initialization of the outermost object enclosing these tasks, prior
+to performing any other operation on the outermost object. In
+particular, for tasks that are part of the object created
+by the evaluation of an @fa<allocator>, the activations are initiated as
+the last step of evaluating the @fa<allocator>, prior
+to returning the new access value. For tasks that are part of an
+object that is the result of a function call, the activations are
+not initiated until after the function returns.
 
+
 !ACATS test
 
+Create C-Tests to check that controlling access results dispatch properly.
+
 !appendix
+
+From: Tucker Taft
+Sent: Thursday, February 17, 2005  3:17 AM
+
+Our last discussion about access discriminants
+and allocators in Paris was a bit concerning,
+I'm sure.  For what it's worth, I believe I have
+worked out all the problems, and the "joined at
+the hip" model will work for nonlimited types
+as well.  Generally, the solution is to return
+more closely to the rule that an access discriminant
+always has the same level as the object it is
+a component of.  I had broken that rule for objects
+returned by functions when referring to an
+access discriminant of a subcomponent of the
+result, and that was causing the trouble, I
+believe.  Calling a function and then only using
+a part of the result is quite rare, and using
+a part that happens to have an access discriminant
+that is initialized from the enclosing object's
+access discriminant is well below the noise
+level.
+
+Overall, the general rule becomes that as soon
+as you select a component of a function result,
+the function result is treated as a "temp",
+and it takes on a very local accessibility
+level, as do any access discriminants it has.
+E.g.:
+
+     X : T := func().component;
+
+is not permitted if component has an access
+discrim. initialized from the enclosing object,
+because the call is a temp, and we are
+trying to initialize a longer-lasting
+object.  Another way to think about it is
+that only when "build-in-place" is possible
+can the result of the function call be
+long-lived.
+
+I'll write all this up in the next version of
+the AI.
+
+So those who were concerned can breathe easier. ;-)
 
 *************************************************************

Questions? Ask the ACAA Technical Agent