CVS difference for ai12s/ai12-0406-1.txt

Differences between 1.3 and version 1.4
Log of other versions for file ai12s/ai12-0406-1.txt

--- ai12s/ai12-0406-1.txt	2020/12/11 22:22:26	1.3
+++ ai12s/ai12-0406-1.txt	2020/12/17 04:15:24	1.4
@@ -1,4 +1,4 @@
-!standard 3.10.2(3/2)                                    20-12-09  AI12-0406-1/03
+!standard 3.10.2(3/2)                                    20-12-15  AI12-0406-1/04
 !standard 3.10.2(18)
 !standard 3.10.2(19/3)
 !standard 3.10.2(19.1/3)
@@ -53,7 +53,7 @@
 
 Modify 3.10.2(3/2):
 
- [The accessibility rules, which prevent dangling references, are written in 
+ The accessibility rules, which prevent dangling references, are written in 
  terms of /accessibility levels/, which reflect the run-time nesting of /masters/.
  As explained in 7.6.1, a master is the execution of a certain construct
  {(called a /master construct/)}, such as a subprogram_body. An accessibility 
@@ -121,7 +121,7 @@
 
 Master construct: A master construct is one of certain executable constructs
 listed in 7.6.1. Execution of a master construct is a master, with which 
-objects and tasks are associated for the purposes of finalization and waiting.
+objects and tasks are associated for the purposes of waiting and finalization.
 
 !discussion
 
@@ -191,6 +191,104 @@
 wording change proposed by this AI, (1) becomes legal as the "statically 
 deeper" relationship does not apply. A dynamic check is still required at (1),
 in case the instance of G2 is nested more than type Ref.
+
+
+!corrigendum 3.10.2(3/2)
+
+@drepl
+The accessibility rules, which prevent dangling references, are written in
+terms of @i<accessibility levels>, which reflect the run-time nesting of
+@i<masters>. As explained in 7.6.1, a master is the execution of a
+certain construct, such as a @fa<subprogram_body>.
+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
+@i<masters>. As explained in 7.6.1, a master is the execution of a
+certain construct (called a @i<master construct>), such as a @fa<subprogram_body>.
+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(18)
+
+@drepl
+@xbullet<For a master that is statically nested within another master, the 
+accessibility level of the inner master is statically deeper than that of 
+the outer master.>
+@dby
+@xbullet<For a master construct that is statically nested within another 
+master construct, the accessibility level of the inner master construct is 
+statically deeper than that of the outer master construct.>
+
+!corrigendum 3.10.2(19/3)
+
+@drepl
+@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 nor does it apply to a descendant of a generic
+formal type; that is, such an accessibility level is not
+considered to be statically deeper, nor statically shallower, than
+any other.>
+@dby
+@xbullet<The statically deeper relationship does not apply to the 
+accessibility level of the following:>
+
+!corrigendum 3.10.2(19.1/3)
+
+@drepl
+@xbullet<The statically deeper relationship does not apply to the accessibility 
+level of the type of a stand-alone object of an anonymous access-to-object 
+type; that is, such an accessibility level is not considered to be statically
+deeper, nor statically shallower, than any other.>
+@dby
+@xinbull<the anonymous type of an access parameter specifying an access-to-object 
+type;>
+@xinbull<the type of a stand-alone object of an anonymous access-to-object type;>
+@xinbull<a @fa<raise_expression>;>
+@xinbull<a descendant of a generic formal type;>
+@xinbull<a descendant of a type declared in a generic formal package.>
+@xindent<That is, such an accessibility level is not considered to be statically 
+deeper, nor statically shallower, than any other.>
+
+
+!corrigendum 7.6.1(3/2)
+
+@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 @i<master>: the execution of a body other than
+a @fa<package_body>; the execution of a @fa<statement>; or
+the evaluation of an @fa<expression>, @fa<function_call>, or @fa<range> that is not part of an
+enclosing @fa<expression>, @fa<function_call>, @fa<range>, or @fa<simple_statement>
+other than a @fa<simple_return_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 the execution of a @i<master construct>: a 
+body other than a @fa<package_body>; a @fa<statement>; or
+an @fa<expression>, @fa<function_call>, or @fa<range> that is not part of an
+enclosing @fa<expression>, @fa<function_call>, @fa<range>, or @fa<simple_statement>
+other than a @fa<simple_return_statement>. The term @i<master> by itself 
+refers to the execution of a master construct. A master is finalized after it
+is complete, and before it is left.
 
 !ASIS
 

Questions? Ask the ACAA Technical Agent