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

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

--- ai12s/ai12-0200-1.txt	2016/11/24 02:32:19	1.3
+++ ai12s/ai12-0200-1.txt	2016/11/24 02:51:56	1.4
@@ -78,27 +78,53 @@
 From: Randy Brukardt
 Sent: Tuesday, November 22, 2016  6:05 PM
 
-In his review of the minutes (aside: should be posted soon), Jeff notes that the AI12-0200-1 "doesn't flow". The approved wording is:
+In his review of the minutes (aside: should be posted soon), Jeff notes that the
+AI12-0200-1 "doesn't flow". The approved wording is:
 
-The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same) language-defined subprograms perform as specified, so long as all pairs of objects (one from each call) th
at {either} are denoted by parameters that could be passed by reference{,} or designated by parameters of an access type are nonoverlapping.
+The implementation shall ensure that each language-defined subprogram is
+reentrant in the sense that concurrent calls on any two (possibly the same)
+language-defined subprograms perform as specified, so long as all pairs of
+objects (one from each call) that {either} are denoted by parameters that could
+be passed by reference{,} or designated by parameters of an access type are
+nonoverlapping.
 
 ---
 
-The problem here is that the "are nonoverlapping" applies to both kinds of parameters; the inserted comma tends to make it read as if that only applies to the second part. Jeff suggested adding an "are" and another comma, thus:
+The problem here is that the "are nonoverlapping" applies to both kinds of
+parameters; the inserted comma tends to make it read as if that only applies to
+the second part. Jeff suggested adding an "are" and another comma, thus:
+
+The implementation shall ensure that each language-defined subprogram is
+reentrant in the sense that concurrent calls on any two (possibly the same)
+language-defined subprograms perform as specified, so long as all pairs of
+objects (one from each call) that {either} are denoted by parameters that could
+be passed by reference{,} or {are} designated by parameters of an access type{,}
+are nonoverlapping.
 
-The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same) language-defined subprograms perform as specified, so long as all pairs of objects (one from each call) th
at {either} are denoted by parameters that could be passed by reference{,} or {are} designated by parameters of an access type{,} are nonoverlapping.
+But I don't think that helps; now "are nonoverlapping" is completely hanging in
+space.
 
-But I don't think that helps; now "are nonoverlapping" is completely hanging in space.
-
 The usual fix for such dangling items is to pull them to the front part:
 
-The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same) language-defined subprograms perform as specified, so long as all pairs of objects (one from each call) {a
re nonoverlapping} that {either} are denoted by parameters that could be passed by reference{,} or {are} designated by parameters of an access type[ are nonoverlapping].
+The implementation shall ensure that each language-defined subprogram is
+reentrant in the sense that concurrent calls on any two (possibly the same)
+language-defined subprograms perform as specified, so long as all pairs of
+objects (one from each call) {are nonoverlapping} that {either} are denoted by
+parameters that could be passed by reference{,} or {are} designated by
+parameters of an access type[ are nonoverlapping].
 
 The "that" doesn't make much sense here, perhaps "if" would be better:
-
-The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same) language-defined subprograms perform as specified, so long as all pairs of objects (one from each call) {a
re nonoverlapping if either} [that] are denoted by parameters that could be passed by reference{,} or {are} designated by parameters of an access type[ are nonoverlapping].
 
-But this doesn't seem to have the right meaning (it seems to say that it applies if either parameter meets these requirements, the  rule applies, while we want it to apply only if both parameters meet the requirements.
+The implementation shall ensure that each language-defined subprogram is
+reentrant in the sense that concurrent calls on any two (possibly the same)
+language-defined subprograms perform as specified, so long as all pairs of
+objects (one from each call) {are nonoverlapping if either} [that] are denoted
+by parameters that could be passed by reference{,} or {are} designated by
+parameters of an access type[ are nonoverlapping].
+
+But this doesn't seem to have the right meaning (it seems to say that it applies
+if either parameter meets these requirements, the  rule applies, while we want
+it to apply only if both parameters meet the requirements.
 
 I'm out of ideas at this point. Any better suggestions???
 
@@ -106,16 +132,29 @@
 
 From: Jeff Cousins
 Sent: Wednesday, November 23, 2016  4:32 AM
-
-> The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same) language-defined subprograms perform as specified, so long as all pairs of objects (one from each call) 
{are nonoverlapping if either} [that] are denoted by parameters that could be passed by reference{,} or {are} designated by parameters of an access type[ are nonoverlapping].
 
-> But this doesn't seem to have the right meaning (it seems to say that it applies if either parameter meets these requirements, the  rule applies, while we want it to apply only if both parameters meet the requirements.
+> The implementation shall ensure that each language-defined subprogram is
+> reentrant in the sense that concurrent calls on any two (possibly the same)
+> language-defined subprograms perform as specified, so long as all pairs of
+> objects (one from each call) {are nonoverlapping if either} [that] are denoted
+> by parameters that could be passed by reference{,} or {are} designated by
+> parameters of an access type[ are nonoverlapping].
+
+> But this doesn't seem to have the right meaning (it seems to say that it
+> applies if either parameter meets these requirements, the  rule applies, while
+> we want it to apply only if both parameters meet the requirements.
 
 > I'm out of ideas at this point. Any better suggestions???
 
 It's getting rather long for a single sentence, but here's another attempt:
 
-The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same) language-defined subprograms perform as specified, so long as all pairs of objects (one from each call) {a
re nonoverlapping if both objects of such a pair are either} [that are] denoted by {a }parameter[s] that could be passed by reference or designated by {a }parameter[s] of an access type[ are nonoverlapping].
+The implementation shall ensure that each language-defined subprogram is
+reentrant in the sense that concurrent calls on any two (possibly the same)
+language-defined subprograms perform as specified, so long as all pairs of
+objects (one from each call) {are nonoverlapping if both objects of such a pair
+are either} [that are] denoted by {a }parameter[s] that could be passed by
+reference or designated by {a }parameter[s] of an access type[ are
+nonoverlapping].
 
 ****************************************************************
 
@@ -124,11 +163,18 @@
 
 I don't think that putting "are overlapping" earlier helps at all.
 
-I think that Jeff's suggestion is not bad. However, I suggest reversing "either" and "are" so we end up with:
+I think that Jeff's suggestion is not bad. However, I suggest reversing "either"
+and "are" so we end up with:
 
-The implementation shall ensure that each language-defined subprogram is reentrant in the sense that concurrent calls on any two (possibly the same)  language-defined subprograms perform as specified, so long as all pairs of  objects (one from each call) 
that are either denoted by parameters that could be passed by reference, or are designated by parameters of an access type, are nonoverlapping.
+The implementation shall ensure that each language-defined subprogram is
+reentrant in the sense that concurrent calls on any two (possibly the same)
+language-defined subprograms perform as specified, so long as all pairs of
+objects (one from each call) that are either denoted by parameters that could be
+passed by reference, or are designated by parameters of an access type, are
+nonoverlapping.
 
-I find it helps to remove square and curly brackets so that the result is clearer and then when satisified to put them back for the record.
+I find it helps to remove square and curly brackets so that the result is
+clearer and then when satisified to put them back for the record.
 
 ****************************************************************
 
@@ -142,13 +188,17 @@
 From: Tucker Taft
 Sent: Wednesday, November 23, 2016  3:06 PM
 
-Johns version works for me.  Next approach would probably be bullets, but John's seems good enough without them.
+Johns version works for me.  Next approach would probably be bullets, but John's
+seems good enough without them.
 
 ****************************************************************
 
 From: Randy Brukardt
 Sent: Wednesday, November 23, 2016  8:20 PM
 
-I prefer Jeff's (Wednesday) suggestion to Jeff's (Monday) suggestion as modified by John. But it appears that I'm outnumbered, so I'll shut up (at least until we have someone who can't understand it - that may be a while, since Adam isn't around anymore).

+I prefer Jeff's (Wednesday) suggestion to Jeff's (Monday) suggestion as modified
+by John. But it appears that I'm outnumbered, so I'll shut up (at least until we
+have someone who can't understand it - that may be a while, since Adam isn't
+around anymore).
 
 ****************************************************************

Questions? Ask the ACAA Technical Agent