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

Differences between 1.1 and version 1.2
Log of other versions for file ai12s/ai12-0047-1.txt

--- ai12s/ai12-0047-1.txt	2012/12/02 01:03:37	1.1
+++ ai12s/ai12-0047-1.txt	2013/01/01 03:10:23	1.2
@@ -1,4 +1,4 @@
-!standard 4.6(8/2)                                   12-12-01    AI12-0047-1/01
+!standard 4.6(8/2)                                   12-12-08    AI12-0047-1/02
 !standard 4.6(24.8/2)
 !class binding interpretation 12-12-01
 !status work item 12-12-01
@@ -27,7 +27,7 @@
     end loop;
 In this case, the assignment to X makes the array object disappear. This
-has to be either erroneous or illegal, right? (Yes.)
+should be illegal, right? (Yes.)
 2) The following is defined to be a master (7.6.1(3/2)):
@@ -52,7 +52,37 @@
-** TBD.
+Add after 5.5.2(6/3):
+The iterator_name or iterable_name of a iterator_specification shall
+not be a subcomponent that depends on discriminants of an object
+whose nominal subtype is unconstrained, unless the object is known
+to be constrained. 
+Modify 7.6.1(3/2):
+After execution of a construct or entity is complete, it is 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 package_body; the execution of a
+statement; or the evaluation of {a scalar} expression, {a scalar}
+function_call, or {a} range that is not part of an enclosing
+expression, function_call, range, or simple_statement other than a
+simple_return_statement. A master is finalized after it is complete,
+and before it is left.
+Add after 7.6.1(3.c/2) [continuing the existing AARM note]:
+The above definition states that only scalar, as opposed to all,
+expressions and function calls occurring immediately within a compound
+statement are masters. This distinction only makes a difference in the
+case of a loop statement with an iterator_specification because other
+compound statements (e.g., case statements) can only immediately
+enclose scalar expressions. When iterating over the result of a
+function call, we want that function result to be finalized at the end
+of the loop statement, as opposed to finalizing it before executing the
+first iteration of the loop. This rule accomplishes that.

Questions? Ask the ACAA Technical Agent