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

Differences between 1.5 and version 1.6
Log of other versions for file ai12s/ai12-0409-1.txt

--- ai12s/ai12-0409-1.txt	2021/01/15 07:40:06	1.5
+++ ai12s/ai12-0409-1.txt	2021/01/19 06:31:51	1.6
@@ -139,7 +139,7 @@
   initialization.] {The Preelaborable_Initialization aspect of a partial
   view of a type may be specified as False, even if the full view of the
   type has preelaborable initialization. Similarly, a generic formal
-  type need hot be specified to have preelaborable initialization, even
+  type need not be specified to have preelaborable initialization, even
   if the actual type in an instance has preelaborable initialization.}
 
 In place of 10.2.1(11.6/2), which is moved to Annex J with modifications
@@ -147,7 +147,7 @@
 
   The following attribute is defined for a nonformal composite subtype S
   declared within the visible part of a package or a generic package, or
-  a generic formal private subtype or formal derived subtype.
+  a generic formal private subtype or formal derived subtype:
 
   S'Preelaborable_Initialization
   
@@ -167,7 +167,6 @@
     those that might have been declared in formal packages or in 
     child packages.
 
-
 Modify 10.2.1(11.7/3):
 
   [If the pragma appears in the first
@@ -197,13 +196,13 @@
 Modify 10.2.1(11.c/3):
 
     AARM Reason: {AI05-0028-1} The reason why we need [the pragma]{to
-    specify the aspect} for private types, private extensions, and
-    protected types is fairly clear: the properties of the full view
+    to be allowed to specify the aspect} for private types, private extensions,
+    and protected types is fairly clear: the properties of the full view
     determine whether the type has preelaborable initialization or not;
     in order to preserve privacy we need a way to express on the partial
     view that the full view is well-behaved. The reason why we need [the
-    pragma]{to specify the aspect} for other composite types is more
-    subtle: a nonnull override for Initialize might occur in the private
+    pragma]{to be allowed to specify the aspect} for other composite types is
+    more subtle: a nonnull override for Initialize might occur in the private
     part, even for a nonprivate type; in order to preserve privacy, we
     need a way to express on a type declared in a visible part that the
     private part does not contain any nasty override of Initialize.
@@ -382,6 +381,137 @@
 !examples
 
 See the updates to A.18.19-25 above.
+
+!corrigendum 10.2.1(4.1/2)
+
+@ddel
+The form of a @fa<pragma> Preelaborable_Initialization is as follows: 
+
+!corrigendum 10.2.1(4.2/2)
+
+@ddel
+@xindent<@b<pragma> Preelaborable_Initialization(@fa<direct_name>)>
+
+!corrigendum 10.2.1(11.1/2)
+
+@drepl
+The following rules specify which entities have @i<preelaborable initialization>:
+@dby
+The following rules specify which entities have @i<preelaborable initialization>,
+namely that the Preelaborable_Initialization aspect of the entity is True:
+
+!corrigendum 10.2.1(11.2/3)
+
+@drepl
+@xbullet<The partial view
+of a private type or private extension, a protected type without
+@fa<entry_declaration>s, a generic formal private type, or a generic formal
+derived type, has preelaborable
+initialization if and only if the @fa<pragma> Preelaborable_Initialization has
+been applied to them. A protected type with @fa<entry_declaration>s
+or a task type never has preelaborable initialization.>
+@dby
+@xbullet<The partial view
+of a private type or private extension, a protected type without
+@fa<entry_declaration>s, a generic formal private type, or a generic formal
+derived type, has preelaborable
+initialization if and only if the Preelaborable_Initialization aspect has
+been specified True for them. A protected type with @fa<entry_declaration>s
+or a task type never has preelaborable initialization. The 
+Preelaborable_Initialization aspect of a partial
+view of a type may be specified as False, even if the full view of the
+type has preelaborable initialization. Similarly, a generic formal
+type need not be specified to have preelaborable initialization, even
+if the actual type in an instance has preelaborable initialization.>
+
+!corrigendum 10.2.1(11.6/2)
+
+@drepl
+A @fa<pragma> Preelaborable_Initialization specifies that a type has 
+preelaborable initialization. This pragma shall appear in the visible 
+part of a package or generic package.
+@dby
+The following attribute is defined for a nonformal composite subtype S
+declared within the visible part of a package or a generic package, or
+a generic formal private subtype or formal derived subtype:
+
+@xhang<@xterm<S'Preelaborable_Initialization>
+This attribute is of Boolean type, and its value reflects whether
+the type of S has preelaborable initialization. The value of this
+attribute, the type-related Preelaborable_Initialization aspect, may
+be specified for any type for which the attribute is defined. The
+value shall be specified by a static expression, unless the type is
+not a formal type but is nevertheless declared within a generic
+package. In this latter case, the value may also be specified by
+references to the Preelaborable_Initialization attribute of one or
+more formal types visible at the point of the declaration of the
+composite type, conjoined with @b<and>.>
+
+!corrigendum 10.2.1(11.7/3)
+
+@drepl
+If the pragma appears in the first list of
+@fa<basic_declarative_item>s of a
+@fa<package_specification>, then the @fa<direct_name> shall denote the first
+subtype of a composite type, and the type shall
+be declared immediately within the same package
+as the @fa<pragma>. If the @fa<pragma> is applied to a private type or a
+private extension, the full view of the type shall have preelaborable
+initialization. If the @fa<pragma> is applied to a protected type, the
+protected type shall not have entries, and each
+component of the protected type shall have preelaborable initialization. For
+any other composite type, the type shall have preelaborable initialization. In
+addition to the places where Legality Rules normally apply (see 12.3), these rules
+apply also in the private part of an instance of a generic unit.
+@dby
+If the Preelaborable_Initialization
+aspect is specified True for a private type or a
+private extension, the full view of the type shall have preelaborable
+initialization. If the aspect is specified True for a protected type, the
+protected type shall not have entries, and each
+component of the protected type shall have preelaborable initialization.
+If the aspect is specified True
+for a generic formal type, then in a @fa<generic_instantiation> the
+corresponding actual type shall have preelaborable initialization. If 
+the aspect definition includes one or more Preelaborable_Initialization
+@fa<attribute_reference>s, then the full view of the type shall have
+preelaborable initialization presuming the types mentioned in the
+@fa<prefix>es of the @fa<attribute_reference>s all have 
+preelaborable initialization. For
+any other composite type, the aspect shall be 
+specified statically True or False only if it is confirming. In
+addition to the places where Legality Rules normally apply (see 12.3), these rules
+apply also in the private part of an instance of a generic unit.
+
+!corrigendum 10.2.1(11.8/2)
+
+@ddel
+If the @fa<pragma> appears in a @fa<generic_formal_part>, then the
+@fa<direct_name> shall denote a generic formal private type or a generic formal
+derived type declared in the same @fa<generic_formal_part> as the @fa<pragma>.
+In a @fa<generic_instantiation> the corresponding actual type shall have
+preelaborable initialization.
+
+
+!corrigendum 13.1(11/3)
+
+@drepl
+Operational and representation aspects of a generic formal parameter are the
+same as those of the actual. Operational and representation aspects
+are the same for all views of a type. Specification of a type-related
+representation aspect is not allowed for a descendant of a generic formal
+untagged type.
+@dby
+If a type-related aspect is defined for the partial view of a type,
+then it has the same definition for the full view of the type, except
+for certain Boolean-valued operational aspects where the language
+specifies that the partial view can have the value False even when the
+full view has the value True.
+Type-related aspects cannot be specified, and are not
+defined for an incomplete view of a type. Representation aspects of a 
+generic formal parameter are the same as those of the actual. Specification
+of a type-related representation aspect is not allowed for a descendant of 
+a generic formal untagged type.
 
 !corrigendum J.15.14(0)
 

Questions? Ask the ACAA Technical Agent