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

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

--- ai12s/ai12-0374-1.txt	2020/05/10 23:03:36	1.3
+++ ai12s/ai12-0374-1.txt	2020/06/02 23:35:18	1.4
@@ -1,5 +1,6 @@
-!standard 9.5(24/5)                                   20-04-29  AI12-0374-1/02
+!standard 9.5(24/5)                                   20-06-01  AI12-0374-1/03
 !standard 9.5(27/5)
+!standard 9.5(34/5)
 !standard 9.5(36/5)
 !standard 9.5(47/5)
 !standard 9.5(49/5)
@@ -110,6 +111,23 @@
   literal, and for a {sub}type (including a formal {sub}type), the
   following language-defined operational aspect is defined:
 
+Replace 9.5(34/5):
+
+  For a full type declaration that has a partial view, the aspect is 
+  the same as that of the partial view.
+
+with:
+
+  For the base type of a scalar (sub)type, the Nonblocking aspect is the 
+  Boolean literal True.
+
+  AARM Reason: The first subtype of a scalar type can allow 
+    blocking (which can be useful so a predicate can allow blocking), but the
+    base type is always Nonblocking. We need this so the Nonblocking value
+    is well-defined for any subtype that is built from the base type (T'Base).
+    T'Base of any scalar type, including a generic formal type, is always 
+    nonblocking.
+
 Modify 9.5(36/5):
 
   Unless directly specified, for a formal {sub}type, formal package, or
@@ -154,7 +172,11 @@
   literal True. {Aspect Nonblocking shall be specified for a nonfirst
   subtype S only if it fully conforms to the nonblocking expression of the
   subtype identified in the subtype_indication defining S or if it is
-  specified to have the Boolean literal True.}
+  specified to have the Boolean literal True. Aspect Nonblocking shall be
+  specified for a first subtype S that completes an incomplete or partial
+  view P only if it fully conforms to the nonblocking expression of the
+  subtype P or if it is specified to have the Boolean literal True.}
+
 
 Modify AARM 9.5(88.f/5):
 
@@ -212,8 +234,8 @@
 forcing the type Nonblocking aspect specifications to cover all possible subtypes 
 that might ever be declared seemed quite limiting, as far as interesting 
 predicates. It seems clear that some predicates may want to use a blocking
-operation. [Editor's note: This seems *much* less clear than it does for
-Global!! A blocking predicate is pretty weird.] Forcing the type declaration
+operation. [Editor's note: This seems less clear than it does for
+Global. A blocking predicate is pretty weird.] Forcing the type declaration
 to worry about this seems painful. 
 
 An example of the problem in a predicate could be:
@@ -251,6 +273,21 @@
 
 If the declaration of Wild wasn't illegal, then P would be legal even
 though the predicate would potentially block.
+
+We require that non-first subtypes and first-subtypes that are completions
+have a confirming or True Nonblocking aspect so that a non-first or completing
+subtype never allows blocking when the original first subtype does not allow
+it. (This is necessary so that the programmer can be assured that any subtype
+of a nonblocking first subtype is nonblocking. This is critical in generic
+units as objects of unknown subtypes could be passed to the unit. If whether
+assignment is blocking depended upon the subtype, one could never assume any
+formal type assignment was nonblocking, even when the type is explicitly
+declared to be nonblocking.)
+
+As part of this change, we have to define the nonblocking value for scalar
+base types, as these can be used to define subtypes. As there is no reason
+for a scalar base type to allow blocking (no predicate is possible), we say
+that the base type is always nonblocking.
 
 =========
 

Questions? Ask the ACAA Technical Agent