CVS difference for ai05s/ai05-0028-1.txt

--- ai05s/ai05-0028-1.txt	2007/04/05 01:49:14	1.5
+++ ai05s/ai05-0028-1.txt	2007/07/26 02:58:05	1.6
@@ -1,8 +1,11 @@
-!standard 10.2.1(9/2)                                     07-04-04    AI05-0028-1/04
+!standard 10.2.1(9/2)                                     07-06-18    AI05-0028-1/05
 !standard 10.2.1(10.1/2)
+!standard 10.2.1(11.1/2)
+!standard 10.2.1(11.2/2)
 !standard 10.2.1(11.4/2)
 !standard 10.2.1(11.8/2)
 !class binding interpretation 06-11-13
+!status ARG Approved  8-0-2  07-06-03
 !status work item 06-11-13
 !status received 06-10-11
 !priority Medium
@@ -98,8 +101,8 @@
 
 For questions 1 and 2, change 10.2.1(10.1/2) as follows:
 
-the actual for each discriminated formal derived type, formal private type, [(]or
-formal private extension[)] declared within the formal part of the generic unit is
+the actual for each {discriminated formal derived type, }formal private type{,} [(]or
+{formal private} extension[)] declared within the formal part of the generic unit is
 a type that does not have preelaborable initialization{, unless pragma
 Preelaborable_Initialization has been applied to the formal type};
 
@@ -108,19 +111,21 @@
 However, a [user-defined] controlled type with an [overriding] Initialize procedure
 {that is not a null procedure} does not have preelaborable initialization.
 
-For question 5, change 10.2.1(11.7/1) as follows:
+For question 5, change 10.2.1(11.7/2) as follows:
 
 If the pragma appears in the first list of basic_declarative_items of a
-package_specification, then the direct_name shall denote the first subtype of
-a [private type, private extension, or protected type] {composite type} that is
-not an interface type{, a task type, or a protected_type with} [and is without]
-entry_declarations, and the type shall be declared immediately within the same
-package as the pragma. If the pragma is applied to a private type or a private
-extension, the full view of the type shall have preelaborable initialization. If
-the pragma is applied to [a protected type, each component of the protected] {any
-other composite type, the} type shall have preelaborable initialization. In addition
-to the places where Legality Rules normally apply, these rules apply also in the
-private part of an instance of a generic unit.
+package_specification, then the direct_name shall denote the first subtype
+of a [private type, private extension, or protected type that is not an
+interface type and is without entry_declarations] {composite type}, and
+the type shall be declared immediately within the same package as the
+pragma. If the pragma is applied to a private type or a private extension,
+the full view of the type shall have preelaborable initialization. If the
+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.
 
 AARM Note: The reason why we need the pragma for private types, private extensions,
 and protected types is fairly clear: the properties of the full view determine whether
@@ -131,10 +136,13 @@
 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.
 
+Also change 10.2.1(11.2/2) to fix a typo:
+...or a generic formal derived type, [have] {has} preelaborable initialization...
+
 For question 7, replace the first sentence of 10.2.1(9/2) with:
 
-The creation of an object [(including a component)] {that is initialized by default}
-of a type that does not have preelaborable initialization.
+The creation of an object (including a component) {that is initialized by default, if its}
+[of a] type [that] does not have preelaborable initialization.
 
 !discussion
 
@@ -174,12 +182,105 @@
 For question 7, it is obvious that the mysterious disappearance of "initialized
 by default" was not intended, as the entire purpose of the pragma is to properly
 deal with objects that are initialized by default (it has no effect in other cases).
+
+!corrigendum 10.2.1(9/2)
 
---!corrigendum A.18.2(239/2)
+@drepl
+The creation of an object (including a component) of
+a type that does not have preelaborable initialization. Similarly,
+of a descendant of a private type, private extension, controlled type,
+task type, or protected type with @fa<entry_declaration>s; similarly
+the evaluation of an @fa<extension_aggregate> with
+an ancestor @fa<subtype_mark> denoting a subtype of such a type.
+@dby
+The creation of an object (including a component) that is initialized by
+default, if its type does not have preelaborable initialization. Similarly,
+of a descendant of a private type, private extension, controlled type,
+task type, or protected type with @fa<entry_declaration>s; similarly
+the evaluation of an @fa<extension_aggregate> with
+an ancestor @fa<subtype_mark> denoting a subtype of such a type.
+
+!corrigendum 10.2.1(10.1/2)
+
+@drepl
+@xbullet<the actual for each formal private type (or
+extension) declared within the formal part of the generic unit is a private
+type (or extension) that does not have preelaborable initialization;>
+@dby
+@xbullet<the actual for each discriminated formal derived type, formal private type, or
+formal private extension declared within the formal part of the generic unit is
+a type that does not have preelaborable initialization, unless @fa<pragma>
+Preelaborable_Initialization has been applied to the formal type;>
+
+!corrigendum 10.2.1(11.2/2)
+
+@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, have 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 @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.>
+
+!corrigendum 10.2.1(11.4/2)
+
+@drepl
+@xbullet<A derived type has preelaborable initialization
+if its parent type has preelaborable initialization and (in the case of a
+derived record extension) if the non-inherited components all have
+preelaborable initialization. However, a user-defined controlled type with an
+overriding Initialize procedure does not have preelaborable initialization.>
+@dby
+@xbullet<A derived type has preelaborable initialization
+if its parent type has preelaborable initialization and (in the case of a
+derived record extension) if the non-inherited components all have
+preelaborable initialization. However, a controlled type with an
+Initialize procedure that is not a null procedure does not have preelaborable
+initialization.>
+
+!corrigendum 10.2.1(11.7/2)
+
+@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 private type, private extension, or protected type that is not
+an interface type and is without @fa<entry_declaration>s, 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, each
+component of the protected type shall have preelaborable initialization. In
+addition to the places where Legality Rules normally apply, these rules apply
+also in the private part of an instance of a generic unit.]}
+@dby
+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.]}
 
 
 !ACATS test
 
+Better be some.
 
 !appendix