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

Differences between 1.20 and version 1.21
Log of other versions for file ai12s/ai12-0111-1.txt

--- ai12s/ai12-0111-1.txt	2018/12/14 08:31:29	1.20
+++ ai12s/ai12-0111-1.txt	2019/02/21 05:29:33	1.21
@@ -1,4 +1,24 @@
-!standard A.18.2(97.1/3)                             18-12-11 AI12-0111-1/10
+!standard 5.5.1(8/3)                              19-02-18  AI12-0111-1/11
+!standard 5.5.1(9/3)  
+!standard 5.5.1(10/3)  
+!standard 5.5.2(12/3) 
+!standard A.18(2/2) 
+!standard A.18.2(8/3)
+!standard A.18.2(90/2)
+!standard A.18.2(92/2)
+!standard A.18.2(95/2)
+!standard A.18.2(96/2)
+!standard A.18.2(97/2)
+!standard A.18.3(6/3)
+!standard A.18.3(61/2)
+!standard A.18.4(7/2)
+!standard A.18.5(3/3)
+!standard A.18.6(4/3)
+!standard A.18.7(7/2)
+!standard A.18.8(3/3)
+!standard A.18.9(4/3)
+!standard A.18.10(8/3)
+!standard A.18.10(80/3)
 !class Amendment 16-06-06
 !status Amendment 1-2012 18-12-11
 !status ARG Approved 11-0-1  18-12-10
@@ -79,16 +99,22 @@
 The following type-related operational aspects may be specified for an 
 indexable container type T:]
 
+Add to the end of 5.5.1(8/3 and 9/3):
+
+
 Add after 5.5.1(9/3):
 
 Iterator_View
     This aspect is specified by a name that denotes a type T2 with the 
     following properties:
        * T2 is declared in the same compilation unit as T;
-       * T2 is an indexable container type;
+       * T2 is an iterable container type;
        * T2 has a single discriminant which is an access discriminant 
          designating T; and
        * The default iterator subtypes for T and T2 statically match.
+    This aspect is never inherited.
+
+Delete 5.5.1(10/3).
 
 Add to the end of 5.5.2(12/3):
 
@@ -129,7 +155,7 @@
   that prohibits any operations that would tamper with elements. By
   using a Stable view for manipulating a container, the number of
   tampering checks performed while performing the operations can
-  be reduced.  The details of the Stable subpackage are defined separately
+  be reduced. The details of the Stable subpackage are defined separately
   for each child unit of Ada.Containers that includes such a nested
   package.
 
@@ -150,7 +176,7 @@
   (also delete similar paragraphs elsewhere: A.18.3(61/2), A.18.4(7/2),
    A.18.7(7/2), A.18.10(80/3))
 
-Modify A.18.2(92/2) (and similar paragraphs elsewhere):
+Modify A.18.2(92/2):
 
   * it inserts or deletes elements of V, that is, it calls the Insert,
     Insert_Space, Clear, Delete, or Set_Length procedures{,or Merge
@@ -168,7 +194,7 @@
 
    AARM Reason: A definite element cannot change size, so there are no other
    operations that tamper with elements. That's not true for the indefinite
-   containers, which is why we leave this separate definition.
+   containers, which is why this is a separate definition.
 
 
 Insert after A.18.2(79/2):
@@ -276,7 +302,7 @@
 
     - it replaces one or more elements of V, that is, it calls the
       Replace_Element, Reverse_Elements, or Swap procedures, or the Sort
-      procedures of an instance of Generic_Sorting, with V as a parameter.
+      procedure of an instance of Generic_Sorting, with V as a parameter.
 
      AARM Reason: Complete replacement of an element can cause its memory to 
      be deallocated while another operation is holding onto a reference to it.
@@ -847,6 +873,311 @@
 packages, but the complexity of using child generic packages, requiring
 a separate "with" clause and an appropriate parameterless instantiation,
 made that a less attractive option.
+
+!corrigendum 5.5.1(8/3)
+
+@drepl
+@xhang<@xterm<Default_Iterator>This aspect is specified by a @fa<name> that denotes
+exactly one function declared immediately within the same
+declaration list in which @i<T> is declared, whose first parameter is
+of type @i<T> or @i<T>'Class or an access parameter whose designated type
+is type @i<T> or @i<T>'Class, whose other parameters, if any, have
+default expressions, and whose result type is an iterator type.
+This function is the @i<default iterator function> for @i<T>. Its
+result subtype is the @i<default iterator subtype> for @i<T>. The
+iteration cursor subtype for the default iterator subtype is the
+@i<default cursor subtype> for @i<T>.>
+@dby
+@xhang<@xterm<Default_Iterator>This aspect is specified by a @fa<name> that denotes
+exactly one function declared immediately within the same
+declaration list in which @i<T> is declared, whose first parameter is
+of type @i<T> or @i<T>'Class or an access parameter whose designated type
+is type @i<T> or @i<T>'Class, whose other parameters, if any, have
+default expressions, and whose result type is an iterator type.
+This function is the @i<default iterator function> for @i<T>. Its
+result subtype is the @i<default iterator subtype> for @i<T>. The
+iteration cursor subtype for the default iterator subtype is the
+@i<default cursor subtype> for @i<T>. This aspect is inherited by descendants 
+of type @i<T> (including @i<T>'Class).>
+
+!corrigendum 5.5.1(9/3)
+
+@drepl
+@xhang<@xterm<Iterator_Element>This aspect is specified by a @fa<name> that denotes
+a subtype. This is the @i<default element subtype> for @i<T>.>
+@dby
+@xhang<@xterm<Iterator_Element>This aspect is specified by a @fa<name> that denotes
+a subtype. This is the @i<default element subtype> for @i<T>. This aspect is 
+inherited by descendants of type @i<T> (including @i<T>'Class).>
+
+@xhang<@xterm<Iterator_View>This aspect is specified by a @fa<name> that denotes a 
+type @i<T2> with the following properties:>
+
+@xinbull<@i<T2> is declared in the same compilation unit as @i<T>;>
+@xinbull<@i<T2> is an iterable container type;>
+@xinbull<@i<T2> has a single discriminant which is an access discriminant 
+designating @i<T>; and>
+@xinbull<The default iterator subtypes for @i<T> and @i<T2> statically match.>
+
+This aspect is never inherited, even by @i<T>'Class.
+
+!corrigendum 5.5.1(10/3)
+
+@ddel
+These aspects are inherited by descendants of type @i<T> (including 
+@i<T>'Class).
+
+!corrigendum 5.5.2(12/3)
+
+@drepl
+For a container element iterator, the @i<iterable_>@fa<name> is evaluated
+and the denoted iterable container object becomes the @i<iterable
+container object for the loop>. The default iterator function for the type of
+the iterable container object for the loop is called on the iterable container 
+object and the result is the @i<loop iterator>. An object of the default
+cursor subtype is created (the @i<loop cursor>).
+@dby
+For a container element iterator, the @i<iterable_>@fa<name> is evaluated.
+If the container type has Iterator_View specified, an object of the 
+Iterator_View type is created with the discriminant referencing the 
+iterable container object denoted by the @i<iterable_>@fa<name>. This is 
+the @i<iterable container object for the loop>. Otherwise, the iterable 
+container object denoted by the @i<iterable_>@fa<name>is the iterable 
+container object for the loop. The default iterator function for the type of
+the iterable container object for the loop is called on the iterable container 
+object and the result is the @i<loop iterator>. An object of the default
+cursor subtype is created (the @i<loop cursor>).
+
+!corrigendum A.18(2/2)
+
+@dinsa
+A variety of sequence and associative containers are provided. Each container
+includes a @i<cursor> type. A cursor is a reference to an element within a
+container. Many operations on cursors are common to all of the containers. A
+cursor referencing an element in a container is considered to be overlapping
+with the container object itself.
+@dinss
+Some operations of the language-defined child units of Ada.Containers
+have access-to-subprogram parameters. To ensure such operations are
+well-defined, they guard against certain actions by the designated
+subprogram. An action on a container that might add or remove an
+element is considered to @i<tamper with cursors>, and these are
+prohibited during all such operations. An action on a container that might 
+replace an element with one of a different size is considered to
+@i<tamper with elements>, and these are prohibited during certain of such
+operations. The details of the specific actions that are considered to
+tamper with cursors or elements are defined for each child unit of
+Ada.Containers.
+
+Several of the language-defined child units of Ada.Containers include
+a nested package named Stable, which provides a view of a container
+that prohibits any operations that would tamper with elements. By
+using a Stable view for manipulating a container, the number of
+tampering checks performed while performing the operations can
+be reduced. The details of the Stable subpackage are defined separately
+for each child unit of Ada.Containers that includes such a nested
+package.
+
+!corrigendum A.18.2(8/3)
+
+@drepl
+@xcode<   @b<type> Vector @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Variable_Indexing =@> Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(Vector);>
+@dby
+See the conflict file!!
+
+!corrigendum A.18.2(90/2)
+
+@drepl
+Some operations of this generic package have access-to-subprogram
+parameters. To ensure such operations are well-defined, they guard
+against certain actions by the designated subprogram. In particular, some
+operations check for "tampering with cursors" of a container because they
+depend on the set of elements of the container remaining constant, and others
+check for "tampering with elements" of a container because they depend on
+elements of the container not being replaced.
+@dby
+Some operations check for "tampering with cursors" of a container because they
+depend on the set of elements of the container remaining constant, and others
+check for "tampering with elements" of a container because they depend on
+elements of the container not being replaced. When tampering with cursors
+is @i<prohibited> for a particular vector object @i<V>, Program_Error is propagated 
+by the finalization of @i<V>, as well as by a call that passes @i<V> to 
+certain of the operations of this package, as indicated by the precondition 
+of such an operation. Similarly, when tampering with elements is @i<prohibited>
+for @i<V>, Program_Error is by a call that passes @i<V> to 
+certain of other operations of this package, as indicated by the precondition 
+of such an operation.
+
+!corrigendum A.18.2(92/2)
+
+@ddel
+@xbullet<it inserts or deletes elements of @i<V>, that is, it calls the Insert,
+Insert_Space, Clear, Delete, or Set_Length procedures with @i<V> as a
+parameter; or>
+
+!corrigendum A.18.2(95/2)
+
+@ddel
+A subprogram is said to @i<tamper with elements> of a vector object @i<V> if:
+
+!corrigendum A.18.2(96/2)
+
+@ddel
+@xbullet<it tampers with cursors of @i<V>; or>
+
+!corrigendum A.18.2(97/2)
+
+@ddel
+@xbullet<it replaces one or more elements of @i<V>, that is, it calls the
+Replace_Element, Reverse_Elements, or Swap procedures or the Sort or Merge
+procedures of an instance of Generic_Sorting with @i<V> as a parameter.>
+
+
+!corrigendum A.18.3(6/3)
+
+@drepl
+@xcode<   @b<type> List @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Variable_Indexing =@> Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(List);>
+@dby
+See the conflict file!!
+
+!corrigendum A.18.3(61/2)
+
+@ddel
+Some operations of this generic package have access-to-subprogram
+parameters. To ensure such operations are well-defined, they guard
+against certain actions by the designated subprogram. In particular, some
+operations check for "tampering with cursors" of a container because they
+depend on the set of elements of the container remaining constant, and others
+check for "tampering with elements" of a container because they depend on
+elements of the container not being replaced.
+
+!corrigendum A.18.4(7/2)
+
+@ddel
+Some operations of these generic packages have access-to-subprogram
+parameters. To ensure such operations are well-defined, they guard
+against certain actions by the designated subprogram. In particular, some
+operations check for "tampering with cursors" of a container because they
+depend on the set of elements of the container remaining constant, and others
+check for "tampering with elements" of a container because they depend on
+elements of the container not being replaced.
+
+
+!corrigendum A.18.5(3/2)
+
+@drepl
+@xcode<   @b<type> Map @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Variable_Indexing =@> Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(Map);>
+@dby
+See the conflict file!!
+
+
+!corrigendum A.18.6(4/3)
+
+@drepl
+@xcode<   @b<type> Map @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Variable_Indexing =@> Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(Map);>
+@dby
+See the conflict file!!
+
+
+!corrigendum A.18.7(7/2)
+
+@ddel
+Some operations of these generic packages have access-to-subprogram
+parameters. To ensure such operations are well-defined, they guard
+against certain actions by the designated subprogram. In particular, some
+operations check for "tampering with cursors" of a container because they
+depend on the set of elements of the container remaining constant, and others
+check for "tampering with elements" of a container because they depend on
+elements of the container not being replaced.
+
+
+!corrigendum A.18.8(3/3)
+
+@drepl
+@xcode<   @b<type> Set @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(Set);>
+@dby
+See the conflict file!!
+
+
+!corrigendum A.18.9(4/3)
+
+@drepl
+@xcode<   @b<type> Set @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(Set);>
+@dby
+See the conflict file!!
+
+
+!corrigendum A.18.10(8/3)
+
+@drepl
+@xcode<   @b<type> Tree @b<is tagged private>
+      @b<with> Constant_Indexing =@> Constant_Reference,
+           Variable_Indexing =@> Reference,
+           Default_Iterator  =@> Iterate,
+           Iterator_Element  =@> Element_Type;
+   @b<pragma> Preelaborable_Initialization(Tree);>
+@dby
+See the conflict file!!
+
+!corrigendum A.18.10(80/3)
+
+@ddel
+Some operations of these generic packages have access-to-subprogram
+parameters. To ensure such operations are well-defined, they guard
+against certain actions by the designated subprogram. In particular, some
+operations check for "tampering with cursors" of a container because they
+depend on the set of elements of the container remaining constant, and others
+check for "tampering with elements" of a container because they depend on
+elements of the container not being replaced.
+
+!corrigendum A.18.11(9/4)
+
+@dinsa
+@xbullet<The operations "&", Append, Insert, Prepend, Replace_Element, and
+To_Vector that have a formal parameter of type Element_Type perform
+indefinite insertion (see A.18).>
+@dinss
+
+@xbullet<The description of Tampering_With_Elements_Prohibited is replaced by:>
+
+@xindent<Returns True if tampering with elements is prohibited for Container, 
+and False otherwise.>
+
+@xbullet<Tampering_With_Cursors_Prohibited is replaced by
+Tampering_With_Elements_Prohibited in the postcondition for the operations
+Reference and Constant_Reference.>
+
+@xbullet<The operations Replace_Element, Reverse_Elements, and Swap, and 
+the nested generic unit Generic_Sorting are omitted from the nested
+package Stable.>
 
 !ASIS
 

Questions? Ask the ACAA Technical Agent