CVS difference for arm/source/pre_con2.mss

Differences between 1.46 and version 1.47
Log of other versions for file arm/source/pre_con2.mss

--- arm/source/pre_con2.mss	2021/06/12 04:55:54	1.46
+++ arm/source/pre_con2.mss	2021/07/09 03:01:22	1.47
@@ -1,6 +1,6 @@
 @Part(precontainers-2, Root="ada.mss")
 @comment{ $Source: e:\\cvsroot/ARM/Source/pre_con2.mss,v $ }
-@comment{ $Revision: 1.46 $ $Date: 2021/06/12 04:55:54 $ $Author: randy $ }
+@comment{ $Revision: 1.47 $ $Date: 2021/07/09 03:01:22 $ $Author: randy $ }
 
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Multiway_Trees]}
 
@@ -227,8 +227,8 @@
 
 @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0112-1]}
 @ChgAdded{Version=[5],Text=[   @key{function} @AdaSubDefn{Is_Ancestor_Of} (Container : Tree;
-                                          Parent   : Cursor;
-                                          Position : Cursor) @key{return} Boolean
+                            Parent   : Cursor;
+                            Position : Cursor) @key{return} Boolean
       @key{with} Pre => (Meaningful_For (Container, Position)
                       @key{or else raise} Program_Error) @key{and then}
                    (Meaningful_For (Container, Parent)
@@ -3935,7 +3935,7 @@
 
 @begin{Inconsistent2012}
   @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0111-1]}
-  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Corrigendum:>
+  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Correction:>
   Tampering with elements is now defined to be equivalent to tampering with
   cursors for ordinary containers. If a program requires tampering detection
   to work, it might fail in Ada 202x. Needless to say, this shouldn't happen
@@ -5530,6 +5530,15 @@
 @ChgAdded{Version=[3],Noprefix=[T],Text=[  @key{type} Vector (Capacity : Count_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Vector is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type Vector needs finalization if and only if
     type Element_Type needs finalization.]}
@@ -5722,7 +5731,7 @@
 
 @begin{Inconsistent2012}
   @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0111-1]}
-  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Corrigendum:>
+  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Correction:>
   Tampering with elements is now defined to be equivalent to tampering with
   cursors for bounded containers. If a program requires tampering detection
   to work, it might fail in Ada 202x. Needless to say, this shouldn't happen
@@ -5730,6 +5739,17 @@
   @RefSecNum{The Generic Package Containers.Vectors} for more details.]}
 @end{Inconsistent2012}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded vector now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actual for the Element_Type has PI. If an program used
+  a vector whose actual Element_Type does not have PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
 
 
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Bounded_Doubly_Linked_Lists]}
@@ -5774,6 +5794,15 @@
 @ChgAdded{Version=[3],Noprefix=[T],Text=[  @key{type} List (Capacity : Count_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type List is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type List needs finalization if and only if
     type Element_Type needs finalization.]}
@@ -5994,7 +6023,7 @@
 
 @begin{Inconsistent2012}
   @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0111-1]}
-  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Corrigendum:>
+  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Correction:>
   Tampering with elements is now defined to be equivalent to tampering with
   cursors for bounded containers. If a program requires tampering detection
   to work, it might fail in Ada 202x. Needless to say, this shouldn't happen
@@ -6002,6 +6031,17 @@
   @RefSecNum{The Generic Package Containers.Vectors} for more details.]}
 @end{Inconsistent2012}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded list now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actual for the Element_Type has PI. If an program used
+  a list whose actual Element_Type does not have PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
 
 
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Bounded_Hashed_Maps]}
@@ -6040,6 +6080,17 @@
             Modulus  : Hash_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Map is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization
+        @key[and]
+     Key_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type Map needs finalization if and only if type
       Key_Type or type Element_Type needs finalization.]}
@@ -6258,7 +6309,7 @@
 
 @begin{Inconsistent2012}
   @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0111-1]}
-  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Corrigendum:>
+  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Correction:>
   Tampering with elements is now defined to be equivalent to tampering with
   cursors for bounded containers. If a program requires tampering detection
   to work, it might fail in Ada 202x. Needless to say, this shouldn't happen
@@ -6266,6 +6317,19 @@
   @RefSecNum{The Generic Package Containers.Vectors} for more details.]}
 @end{Inconsistent2012}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded map now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actuals for the Element_Type and the Key_Type have PI.
+  If an program used a map whose actual Element_Type or Key_Type does not have
+  PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
+
 
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Bounded_Ordered_Maps]}
 
@@ -6301,6 +6365,17 @@
 @ChgAdded{Version=[3],Noprefix=[T],Text=[  @key[type] Map (Capacity : Count_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Map is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization
+        @key[and]
+     Key_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type Map needs finalization if and only if
      type Key_Type or type Element_Type needs finalization.]}
@@ -6489,7 +6564,7 @@
 
 @begin{Inconsistent2012}
   @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0111-1]}
-  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Corrigendum:>
+  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Correction:>
   Tampering with elements is now defined to be equivalent to tampering with
   cursors for bounded containers. If a program requires tampering detection
   to work, it might fail in Ada 202x. Needless to say, this shouldn't happen
@@ -6497,6 +6572,19 @@
   @RefSecNum{The Generic Package Containers.Vectors} for more details.]}
 @end{Inconsistent2012}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded map now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actuals for the Element_Type and the Key_Type have PI.
+  If an program used a map whose actual Element_Type or Key_Type does not have
+  PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
+
 
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Bounded_Hashed_Sets]}
 
@@ -6533,6 +6621,15 @@
             Modulus  : Hash_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Set is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type Set needs finalization if and only if
     type Element_Type needs finalization.]}
@@ -6742,6 +6839,18 @@
   Containers.Bounded_Hashed_Sets is new.]}
 @end{Extend2005}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded set now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actual for the Element_Type has PI. If an program used a
+  set whose actual Element_Type does not have PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
+
 
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Bounded_Ordered_Sets]}
 
@@ -6777,6 +6886,15 @@
 @ChgAdded{Version=[3],Noprefix=[T],Text=[  @key{type} Set (Capacity : Count_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Set is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type Set needs finalization if and only if
     type Element_Type needs finalization.]}
@@ -6957,7 +7075,20 @@
   Containers.Bounded_Ordered_Sets is new.]}
 @end{Extend2005}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded set now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actual for the Element_Type has PI. If an program used
+  a set whose actual Element_Type does not have PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
 
+
+
 @LabeledAddedSubclause{Version=[3],Name=[The Generic Package Containers.Bounded_Multiway_Trees]}
 
 @begin{Intro}
@@ -6995,6 +7126,15 @@
 @ChgAdded{Version=[3],Noprefix=[T],Text=[  @key{type} Tree (Capacity : Count_Type) @key[is tagged private]@Chg{Version=[5],New=[...],Old=[;]}]}
 @end{Example}
 
+  @ChgRef{Version=[5],Kind=[Added],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Tree is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[Added]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization]}
+@end{Example}
+
   @ChgRef{Version=[3],Kind=[AddedNormal]}
   @ChgAdded{Version=[3],Text=[The type Tree needs finalization if and only if
     type Element_Type needs finalization.]}
@@ -7249,7 +7389,7 @@
 
 @begin{Inconsistent2012}
   @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0111-1]}
-  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Corrigendum:>
+  @ChgAdded{Version=[5],Text=[@Defn{inconsistencies with Ada 2012}@b<Correction:>
   Tampering with elements is now defined to be equivalent to tampering with
   cursors for bounded containers. If a program requires tampering detection
   to work, it might fail in Ada 202x. Needless to say, this shouldn't happen
@@ -7257,6 +7397,17 @@
   @RefSecNum{The Generic Package Containers.Vectors} for more details.]}
 @end{Inconsistent2012}
 
+@begin{Incompatible2012}
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Text=[@Defn{incompatibilities with Ada 2012}@b<Correction:>A
+  bounded tree now only has Preelaborable_Initialization (abbreviated PI in
+  this note) when the actual for the Element_Type has PI. If an program used
+  a tree whose actual Element_Type does not have PI in a context when PI is
+  required (such as a library-level object in a preelaborated unit or as a 
+  component of a type with PI), the program would be illegal in Ada 202x but
+  legal in original Ada 2012. This situation is unlikely, especially as
+  some existing Ada 2012 implementations reject the instance in this case.]}
+@end{Incompatible2012}
 
 @RMNewPageVer{Version=[3]}@Comment{For printed version of Ada 2012 RM}
 @LabeledAddedSubclause{Version=[2],Name=[Array Sorting]}
@@ -8217,6 +8368,15 @@
    to be different for different containers, so making it a discriminant (as
    Capacity is) provides no useful capability.]}
 @end{Reason}
+
+  @ChgRef{Version=[5],Kind=[AddedNormal],ARef=[AI12-0409-1]}
+  @ChgAdded{Version=[5],Type=[Leading],Text=[The @nt{aspect_definition} for 
+  Preelaborable_Initialization for type Holder is changed to:]}
+@begin{Example}
+@ChgRef{Version=[5],Kind=[AddedNormal]}
+@ChgAdded{Version=[5],Noprefix=[T],Text=[  Preelaborable_Initialization =>
+     Element_Type'Preelaborable_Initialization]}
+@end{Example}
 
  @ChgRef{Version=[5],Kind=[AddedNormal]}
  @ChgAdded{Version=[5],Type=[Leading],Text=[Add to the precondition of To_Holder

Questions? Ask the ACAA Technical Agent