CVS difference for ais/ai-00162.txt

Differences between 1.6 and version 1.7
Log of other versions for file ais/ai-00162.txt

--- ais/ai-00162.txt	2004/07/29 04:02:24	1.6
+++ ais/ai-00162.txt	2004/12/09 19:55:14	1.7
@@ -1,5 +1,16 @@
-!standard 03.10.02 (13)                               04-07-28  AI95-00162/05
+!standard 03.10.02 (3)                               04-12-03  AI95-00162/06
+!standard 03.10.02 (7)
+!standard 03.10.02 (13)
+!standard 06.05 (18)
+!standard 07.06.01 (3)
+!standard 07.06.01 (13)
+!standard 07.06.01 (13.1)
+!standard 09.03 (2)
+!standard 09.03 (3)
+!standard 13.11.02 (17)
 !class binding interpretation 96-09-10
+!status Amendment 200Y 04-12-03
+!status ARG Approved 7-0-2  04-11-21
 !status work item 98-10-02
 !status received 96-09-10
 !priority Medium
@@ -106,25 +117,15 @@
 
 Replace 7.6.1(13/1 - 13.1/1) with
 
-  The accessibility level of an anonymous object created as part of
-  the evaluation of an expression is the accessibility level of the
-  innermost enclosing master except in the following cases:
-
-    - If the object is created as part of a rename declaration which renames
-      any part of the object, then the accessibility level of the object
-      is defined to be the accessibility level of the innermost master
-      enclosing the rename declaration.
-
-    - If the object is created by an allocator of an anonymous access type
-      which is used to initialize an access discriminant of another
-      object, then the accessibility level of the allocated object is
-      defined to be that of the discriminated object. The allocated
-      object is finalized when the discriminated object is finalized.
+  The master of an object is the master enclosing its creation whose
+  accessibility level (see 3.10.2) is equal to that of the object.
 
   In the case of a potentially blocking operation which is a master,
-  finalization of these anonymous objects occurs before the operation
-  blocks the current task. In the case of an expression which is a master,
-  finalization of these anonymous objects occurs as the final part of
+  finalization of an (anonymous) object occurs before blocking if the last use of
+  the object occurs before blocking. In particular, for a delay_statement, any
+  finalization occurs before delaying the task.
+  In the case of an expression which is a master,
+  finalization of any (anonymous) objects occurs as the final part of
   evaluation of the expression.
 
 In 9.3(2) replace
@@ -344,7 +345,159 @@
     , the function result object has a deeper accessibility level than the two
     tasks (which have the same accessibility level).
 
---!corrigendum
+!corrigendum 3.10.2(3)
+
+@drepl
+The accessibility rules, which prevent dangling references, are written in
+terms of @i<accessibility levels>, which reflect the run-time nesting of
+masters. As explained in 7.6.1, a master is the execution of a @fa<task_body>,
+a @fa<block_statement>, a @fa<subprogram_body>, an @fa<entry_body>, or an
+@fa<accept_statement>. An accessibility level is @i<deeper than> another if it
+is more deeply nested at run time. For example, an object declared local to a
+called subprogram has a deeper accessibility level than an object declared
+local to the calling subprogram. The accessibility rules for access types
+require that the accessibility level of an object designated by an access value
+be no deeper than that of the access type. This ensures that the object will
+live at least as long as the access type, which in turn ensures that the access
+value cannot later designate an object that no longer exists. The
+Unchecked_Access attribute may be used to circumvent the accessibility rules.
+@dby
+The accessibility rules, which prevent dangling references, are written in
+terms of @i<accessibility levels>, which reflect the run-time nesting of
+masters (see 7.6.1). An accessibility level is @i<deeper than> another if it
+is more deeply nested at run time. For example, an object declared local to a
+called subprogram has a deeper accessibility level than an object declared
+local to the calling subprogram. The accessibility rules for access types
+require that the accessibility level of an object designated by an access value
+be no deeper than that of the access type. This ensures that the object will
+live at least as long as the access type, which in turn ensures that the access
+value cannot later designate an object that no longer exists. The
+Unchecked_Access attribute may be used to circumvent the accessibility rules.
+
+!corrigendum 3.10.2(7)
+
+@drepl
+@xbullet<An entity or view created by a declaration has the same accessibility
+level as the innermost enclosing master, except in the cases of renaming and
+derived access types described below. A parameter of a master has the same
+accessibility level as the master.>
+@dby
+@xbullet<An entity or view created by a declaration has the same accessibility
+level as the innermost enclosing master other than the declaration itself,
+except in the cases of renaming and derived access types described below. A
+parameter of a master has the same accessibility level as the master.>
+
+!corrigendum 3.10.2(13)
+
+@drepl
+@xbullet<The accessibility level of the anonymous access type of an access
+parameter is the same as that of the view designated by the actual. If the
+actual is an @fa<allocator>, this is the accessibility level of the execution
+of the called subprogram.>
+@dby
+@xbullet<The accessibility level of the anonymous access type of an access
+parameter is the same as that of the view designated by the actual.>
+
+!corrigendum 6.5(18)
+
+@drepl
+@xbullet<a @fa<name> that denotes an object view whose accessibility level is
+not deeper than that of the master that elaborated the function body; or>
+@dby
+@xbullet<a @fa<name> that denotes an object view whose accessibility level is
+not deeper than or equal to that of the master that elaborated the function
+body; or>
+
+
+!corrigendum 7.6.1(3)
+
+@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; the execution of an @fa<accept_statement>, a
+@fa<block_statement>, or a @fa<simple_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 7.6.1(13)
+
+@drepl
+If the @fa<object_name> in an @fa<object_renaming_declaration>, or the actual
+parameter for a generic formal @b<in out> parameter in a
+@fa<generic_instantiation>, denotes any part of an anonymous object created by
+a function call, the anonymous object is not finalized until after
+it is no longer accessible via any name. Otherwise, an anonymous
+object created by a function call or by an @fa<aggregate> is finalized no later
+than the end of the innermost enclosing @fa<declarative_item> or
+@fa<statement>; if that is a @fa<compound_statement>, the object is finalized
+before starting the execution of any @fa<statement> within the
+@fa<compound_statement>.
+@dby
+The master of an object is the master enclosing its creation whose
+accessibility level (see 3.10.2) is equal to that of the object.
+
+!corrigendum 7.6.1(13.1)
+
+@drepl
+If a transfer of control or raising of an exception occurs prior to performing
+a finalization of an anonymous object, the anonymous object is finalized as
+part of the finalizations due to be performed for the object's innermost
+enclosing master.
+@dby
+In the case of a potentially blocking operation which is a master,
+finalization of an (anonymous) object occurs before blocking if the last use of
+the object occurs before blocking. In particular, for a @fa<delay_statement>,
+any finalization occurs before delaying the task.
+In the case of an @fa<expression> which is a master,
+finalization of any (anonymous) objects occurs as the final part of
+evaluation of the @fa<expression>.
+
+
+!corrigendum 9.3(2)
+
+@drepl
+@xbullet<If the task is created by the evaluation of an @fa<allocator> for a
+given access type, it depends on each master that includes the elaboration of
+the declaration of the ultimate ancestor of the given access type.>
+@dby
+@xbullet<If the task is created by the evaluation of an @fa<allocator> for a
+given access type, it depends on each master that includes the elaboration of
+the declaration of the ultimate ancestor of the given access type other than
+the declaration itself.>
+
+!corrigendum 9.3(3)
+
+@drepl
+@xbullet<If the task is created by the elaboration of an
+@fa<object_declaration>, it depends on each master that includes this
+elaboration.>
+@dby
+@xbullet<If the task is created by the elaboration of an
+@fa<object_declaration>, it depends on each master that includes this
+elaboration other than the declaration itself.>
+
+!corrigendum 13.11.2(17)
+
+@drepl
+For a standard storage pool, Free should actually reclaim the storage.
+@dby
+For a standard storage pool, Free should actually reclaim the storage.
+If the object being reclaimed has an access discriminant which designates
+an object which was created by an allocator of the (anonymous) type
+of the access discriminant, then the designated object should also be
+reclaimed.
 
 !ACATS Test
 

Questions? Ask the ACAA Technical Agent