CVS difference for ai05s/ai05-0051-1.txt

Differences between 1.14 and version 1.15
Log of other versions for file ai05s/ai05-0051-1.txt

--- ai05s/ai05-0051-1.txt	2010/11/18 07:07:34	1.14
+++ ai05s/ai05-0051-1.txt	2011/01/25 08:00:07	1.15
@@ -760,6 +760,201 @@
 fail if the dynamic check at (1) were against the level of
 the master that elaborated Get_Comp.
 
+!corrigendum 3.10.2(14/2)
+
+@drepl
+@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> of an
+anonymous access type that defines the value of an access parameter or
+an access discriminant. For an @fa<allocator> defining the value of
+an access parameter, the accessibility level is that of the
+innermost master of the call. For one defining an access
+discriminant, the accessibility level is determined as follows:>
+@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> of an
+anonymous access type (an @i<anonymous allocator>) in certain
+contexts, as follows: For an anonymous allocator
+that defines the result of a function with an access result, the
+accessibility level is determined as though the @fa<allocator> were in
+place of the call of the function; in the special case of a call
+that is the operand of a type conversion, the level is that of the
+target access type of the conversion. For an anonymous allocator
+defining the value of an access parameter, the accessibility level is
+that of the innermost master of the call. For one defining an access
+discriminant, the accessibility level is determined as follows:>
+
+!corrigendum 3.10.2(14.4/2)
+
+@dinsa
+@xindent<In this last case, the allocated object
+is said to be a @i<coextension> of the object whose discriminant designates it,
+as well as of any object of which the discriminated object is itself a
+coextension or subcomponent. All coextensions of an object are finalized when
+the object is finalized (see 7.6.1).>
+@dinst
+@xbullet<Within a return statement, the accessibility level of the 
+anonymous access type of an access result is determined by the
+point of call. If the call is the operand of an explicit type
+conversion, the accessibility level is that of the target access
+type of the conversion. If the call is an actual parameter of
+another call or the @fa<prefix> of a name, the accessibility level is
+that of the innermost master of the call. If the call defines an
+access discriminant, the level is the same as that given above for
+an object created by an anonymous allocator that defines an access
+discriminant (even if the access result is of an access-to-
+subprogram type). If the call itself defines the result of a
+function with an access result, this rule is applied recursively.>
+
+!corrigendum 3.10.2(19/2)
+
+@dinsa
+@xbullet<The statically deeper relationship does not apply to the accessibility
+level of the anonymous type of an access parameter specifying an
+access-to-object type; that is, such an accessibility level is not
+considered to be statically deeper, nor statically shallower, than
+any other.>
+@dinst
+@xbullet<For determining whether a level is statically deeper than the 
+level of the anonymous access type of an access result of a function,
+when within a return statement that applies to the function, the
+level determined by the point of call is presumed to be the same
+as that of the level of the master that elaborated the function
+body.>
+
+!corrigendum 4.8(5.2/2)
+
+@drepl
+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).
+@dby
+If the subtype determined by the @fa<subtype_indication> or
+@fa<qualified_expression> of the @fa<allocator> has one or more access
+discriminants, then the accessibility level of the anonymous access
+type of each access discriminant shall not be statically deeper than
+that of the type of the @fa<allocator> (see 3.10.2).
+
+!corrigendum 4.8(10.1/2)
+
+@drepl
+For any @fa<allocator>, 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 determined by
+the @fa<subtype_indication>, or 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.
+@dby
+For any @fa<allocator>, 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 determined by
+the @fa<subtype_indication>, or 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 subtype determined by the
+@fa<subtype_indication> or @fa<qualified_expression>
+of the @fa<allocator> has one or more 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(5.6/2)
+
+!corrigendum 6.5(5.6/2)
+
+@drepl
+@xbullet<If the result subtype of the function is class-wide, the
+accessibility level of the type of the @fa<expression> of the
+return statement 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<expression> of the @fa<simple_return_statement> or the
+@fa<return_subtype_indication>, shall not be statically deeper than that of the
+master that elaborated the function body.>
+@dby
+@xbullet<If the result subtype of the function is class-wide, the
+accessibility level of the type of the @fa<expression> (if any) of the
+return statement shall not be statically deeper than that of the master
+that elaborated the function body.>
+
+@xbullet<If the subtype determined by the @fa<expression> of the
+@fa<simple_return_statement> or by the @fa<return_subtype_indication> has one or more
+access discriminants, the accessibility level of the anonymous access
+type of each access discriminant shall not be statically deeper than that
+of the master that elaborated the function body.>
+
+!corrigendum 6.5(21/2)
+
+@drepl
+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 @fa<expression>
+or the @fa<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.
+@dby
+If any part of the return object (or coextension thereof) of a function has
+one or more access discriminants whose value is not constrained by the result
+subtype of the function, a check is made that the accessibility level of the
+anonymous access type of each access discriminant, as determined by
+the @fa<expression> or the @fa<return_subtype_indication> of the function, is
+not deeper than the level of the return object as determined by the point of
+call (see 3.10.2). If this check fails, Program_Error is raised. 
+
+!corrigendum 7.6.1(11/2)
+
+@drepl
+The order in which the finalization of a master performs finalization of
+objects is as follows: Objects created by declarations in the master are
+finalized in the reverse order of their creation. For objects that were
+created by @fa<allocator>s for an access type whose ultimate ancestor is
+declared in the master, this rule is applied as though each such object that
+still exists had been created in an arbitrary order at the first freezing
+point (see 13.14) of the ultimate ancestor type; the finalization of these
+objects is called the @i<finalization of the collection>.
+After the finalization of a master is complete, the objects finalized as part
+of its finalization cease to @i<exist>, as do any types and subtypes defined
+and created within the master.
+@dby
+The order in which the finalization of a master performs finalization of
+objects is as follows: Objects created by declarations in the master are
+finalized in the reverse order of their creation. For objects that were
+created by @fa<allocator>s for a named access type whose ultimate ancestor is
+declared in the master, this rule is applied as though each such object that
+still exists had been created in an arbitrary order at the first freezing
+point (see 13.14) of the ultimate ancestor type; the finalization of these
+objects is called the @i<finalization of the collection>.
+Objects created by @fa<allocator>s for an anonymous access
+type that are not coextensions of some other object, are finalized
+in an arbitrary order during the finalization of their associated
+master. After the finalization of a master is complete, the
+objects finalized as part of its finalization cease to @i<exist>, as
+do any types and subtypes defined and created within the master.
+
+!corrigendum 13.11(25.2/2)
+
+@dinsa
+@xbullet<For other access discriminants and access parameters, the storage pool
+should be created at the point of the @fa<allocator>, and be reclaimed when
+the allocated object becomes inaccessible;>
+@dinst
+@xbullet<If the @fa<allocator> defines the result of a function with an
+access result, the storage pool is determined as though the
+@fa<allocator> were in place of the call of the function.  If the call
+is the operand of a type conversion, the storage pool is that of
+the target access type of the conversion. If the call is itself
+defining the result of a function with an access result, this rule
+is applied recursively;>
+
+
 !ACATS test
 
 B-Tests and C-Tests need to be constructed to check all of these new legality

Questions? Ask the ACAA Technical Agent