CVS difference for ais/ai-20302.txt

--- ais/ai-20302.txt	2005/05/15 23:43:07	1.20
+++ ais/ai-20302.txt	2005/06/16 23:47:50	1.21
@@ -241,15 +241,15 @@
 the STL where that better maps to common Ada usage. For instance, what the STL
 calls "iterators" are called "cursors" here.
 
-The following major non-limited containers are provided:
-   * (Expandable) Vectors of any non-limited type;
-   * Doubly-linked Lists of any non-limited type;
-   * Hashed Maps keyed by any non-limited hashable type, and containing any non-
-limited type;
-   * Ordered Maps keyed by any non-limited ordered type, and containing any non-
-limited type;
-   * Hashed Sets of any non-limited hashable type;
-   * Ordered Sets of any non-limited ordered type.
+The following major nonlimited containers are provided:
+   * (Expandable) Vectors of any nonlimited type;
+   * Doubly-linked Lists of any nonlimited type;
+   * Hashed Maps keyed by any nonlimited hashable type, and containing any
+nonlimited type;
+   * Ordered Maps keyed by any nonlimited ordered type, and containing any
+nonlimited type;
+   * Hashed Sets of any nonlimited hashable type;
+   * Ordered Sets of any nonlimited ordered type.
 
 Separate versions for definite and indefinite element types are provided, as
 those for definite types can be implemented more efficiently.
@@ -300,11 +300,11 @@
 well, as Delete for a Vector does not finalize the element, while Delete for
 an Ordered_Set does.)
 
-This is not likely to be a hardship, as the element type has to be non-limited.
+This is not likely to be a hardship, as the element type has to be nonlimited.
 Types used to manage scarce resources generally need to be limited. Otherwise,
 the amount of resources needed is hard to control, as the language allows
 a lot of variation in the number or order of adjusts/finalizations. For
-common uses of non-limited controlled types such as managing storage, the
+common uses of nonlimited controlled types such as managing storage, the
 types already have to manage arbitrary copies.
 
 The use of controlled type also brings up the possibility of failure of
@@ -417,10 +417,10 @@
    subtype Index_Subtype is Index_Type;
 
    type Vector is tagged private;
-   pragma preelaborable_initialization(Vector);
+   pragma Preelaborable_Initialization(Vector);
 
    type Cursor is private;
-   pragma preelaborable_initialization(Cursor);
+   pragma Preelaborable_Initialization(Cursor);
 
    Empty_Vector : constant Vector;
 
@@ -1188,7 +1188,7 @@
 This implies swapping the elements, usually including an intermediate copy.
 This means that the elements will usually be copied. (As with Swap,
 if the implementation can do this some other way, it is allowed to.) Since
-the elements are non-limited, this usually will not be a problem. Note that
+the elements are nonlimited, this usually will not be a problem. Note that
 there is Implementation Advice below that the implementation should use
 a sort that minimizes copying of elements.
 
@@ -1533,10 +1533,10 @@
    pragma Preelaborate (Doubly_Linked_Lists);
 
    type List is tagged private;
-   pragma preelaborable_initialization(List);
+   pragma Preelaborable_Initialization(List);
 
    type Cursor is private;
-   pragma preelaborable_initialization(Cursor);
+   pragma Preelaborable_Initialization(Cursor);
 
    Empty_List : constant List;
 
@@ -1544,7 +1544,7 @@
 
    function "=" (Left, Right : List) return Boolean;
 
-   function Length (Container : List) return Natural;
+   function Length (Container : List) return Count_Type;
 
    function Is_Empty (Container : List) return Boolean;
 
@@ -2551,10 +2551,10 @@
    pragma Preelaborate (Hashed_Maps);
 
    type Map is tagged private;
-   pragma preelaborable_initialization(Map);
+   pragma Preelaborable_Initialization(Map);
 
    type Cursor is private;
-   pragma preelaborable_initialization(Cursor);
+   pragma Preelaborable_Initialization(Cursor);
 
    Empty_Map : constant Map;
 
@@ -2903,10 +2903,10 @@
    pragma Preelaborate (Ordered_Maps);
 
    type Map is tagged private;
-   pragma preelaborable_initialization(Map);
+   pragma Preelaborable_Initialization(Map);
 
    type Cursor is private;
-   pragma preelaborable_initialization(Cursor);
+   pragma Preelaborable_Initialization(Cursor);
 
    Empty_Map : constant Map;
 
@@ -3646,10 +3646,10 @@
    pragma Preelaborate (Hashed_Sets);
 
    type Set is tagged private;
-   pragma preelaborable_initialization(Set);
+   pragma Preelaborable_Initialization(Set);
 
    type Cursor is private;
-   pragma preelaborable_initialization(Cursor);
+   pragma Preelaborable_Initialization(Cursor);
 
    Empty_Set : constant Set;
 
@@ -3963,10 +3963,10 @@
    pragma Preelaborate (Ordered_Sets);
 
    type Set is tagged private;
-   pragma preelaborable_initialization(Set);
+   pragma Preelaborable_Initialization(Set);
 
    type Cursor is private;
-   pragma preelaborable_initialization(Cursor);
+   pragma Preelaborable_Initialization(Cursor);
 
    Empty_Set : constant Set;
 
@@ -4511,7 +4511,7 @@
 AARM Notes
 This implies swapping the elements, usually including an intermediate copy.
 This of course means that the elements will be copied. Since the elements are
-non-limited, this usually will not be a problem. Note that there is
+nonlimited, this usually will not be a problem. Note that there is
 Implementation Advice below that the implementation should use
 a sort that minimizes copying of elements.
 
@@ -4822,7 +4822,7 @@
       Replace_Element (V, Index => I, By => E); -- aka V(I) := E;
    end;
 
-All containers are non-limited, and hence allow ordinary assignment. In
+All containers are nonlimited, and hence allow ordinary assignment. In
 the unique case of a vector, there is a separate assignment procedure:
 
    Assign (Target => V1, Source => V2);
@@ -6464,10 +6464,10 @@
    @b<subtype> Index_Subtype @b<is> Index_Type;
 
    @b<type> Vector @b<is tagged private>;
-   @b<pragma> preelaborable_initialization(Vector);
+   @b<pragma> Preelaborable_Initialization(Vector);
 
    @b<type> Cursor @b<is private>;
-   @b<pragma> preelaborable_initialization(Cursor);
+   @b<pragma> Preelaborable_Initialization(Cursor);
 
    Empty_Vector : @b<constant> Vector;
 
@@ -7062,7 +7062,7 @@
 
 @xindent<If Length (Container) <= Count then Delete_Last is equivalent to
 Clear (Container). Otherwise it is equivalent to Delete (Container,
-Index_Type'Val(Index_Type'Pos(Last_Index(Container)) - Count + 1), Count).>
+Index_Type'Val(Index_Type'Pos(Last_Index(Container)) @endash Count + 1), Count).>
 
 @xcode<@b<function> First_Index (Container : Vector) @b<return> Index_Type;>
 
@@ -7193,8 +7193,8 @@
 
 @xindent<If Position equals No_Element or designates the first element of the container,
 then Previous returns the value No_Element. Otherwise, returns a cursor that
-designates the element with index (To_Index (Position) - 1) in the same vector
-as Position.>
+designates the element with index (To_Index (Position) @endash 1) in the same
+vector as Position.>
 
 @xcode<@b<procedure> Next (Position : @b<in out> Cursor);>
 
@@ -7339,10 +7339,10 @@
    @b<pragma> Preelaborate (Doubly_Linked_Lists);
 
    @b<type> List @b<is tagged private>;
-   @b<pragma> preelaborable_initialization(List);
+   @b<pragma> Preelaborable_Initialization(List);
 
    @b<type> Cursor @b<is private>;
-   @b<pragma> preelaborable_initialization(Cursor);
+   @b<pragma> Preelaborable_Initialization(Cursor);
 
    Empty_List : @b<constant> List;
 
@@ -7350,7 +7350,7 @@
 
    @b<function> "=" (Left, Right : List) @b<return> Boolean;
 
-   @b<function> Length (Container : List) @b<return> Natural;
+   @b<function> Length (Container : List) @b<return> Count_Type;
 
    @b<function> Is_Empty (Container : List) @b<return> Boolean;
 
@@ -7634,8 +7634,8 @@
 prior to the element designated by Before. If Before equals No_Element, the new
 elements are inserted after the last node (if any). The new elements are
 initialized with any implicit initial value for any part (as for an
-object_declaration with no initialization expression - see 3.3.1). Any
-exception raised during allocation of internal storage is propagated, and
+@fa<object_declaration> with no initialization expression @emdash see 3.3.1).
+Any exception raised during allocation of internal storage is propagated, and
 Container is not modified.>
 
 @xcode<@b<procedure> Delete (Container : @b<in out> List;
@@ -8041,8 +8041,8 @@
 
 @xindent<Insert inserts Key into Container as per the five-parameter Insert, with the
 difference that an element initialized with any implicit initial values for any
-part (as for an object_declaration with no initialization expression - see
-3.3.1) is inserted.>
+part (as for an @fa<object_declaration> with no initialization expression @emdash
+see 3.3.1) is inserted.>
 
 @xcode<@b<procedure> Insert (Container : @b<in out> Map;
                   Key       : @b<in>     Key_Type;
@@ -8186,10 +8186,10 @@
    @b<pragma> Preelaborate (Hashed_Maps);
 
    @b<type> Map @b<is tagged private>;
-   @b<pragma> preelaborable_initialization(Map);
+   @b<pragma> Preelaborable_Initialization(Map);
 
    @b<type> Cursor @b<is private>;
-   @b<pragma> preelaborable_initialization(Cursor);
+   @b<pragma> Preelaborable_Initialization(Cursor);
 
    Empty_Map : @b<constant> Map;
 
@@ -8403,10 +8403,10 @@
    @b<pragma> Preelaborate (Ordered_Maps);
 
    @b<type> Map @b<is tagged private>;
-   @b<pragma> preelaborable_initialization(Map);
+   @b<pragma> Preelaborable_Initialization(Map);
 
    @b<type> Cursor @b<is private>;
-   @b<pragma> preelaborable_initialization(Cursor);
+   @b<pragma> Preelaborable_Initialization(Cursor);
 
    Empty_Map : @b<constant> Map;
 
@@ -9042,10 +9042,10 @@
    @b<pragma> Preelaborate (Hashed_Sets);
 
    @b<type> Set @b<is tagged private>;
-   @b<pragma> preelaborable_initialization(Set);
+   @b<pragma> Preelaborable_Initialization(Set);
 
    @b<type> Cursor @b<is private>;
-   @b<pragma> preelaborable_initialization(Cursor);
+   @b<pragma> Preelaborable_Initialization(Cursor);
 
    Empty_Set : @b<constant> Set;
 
@@ -9348,10 +9348,10 @@
    @b<pragma> Preelaborate (Ordered_Sets);
 
    @b<type> Set @b<is tagged private>;
-   @b<pragma> preelaborable_initialization(Set);
+   @b<pragma> Preelaborable_Initialization(Set);
 
    @b<type> Cursor @b<is private>;
-   @b<pragma> preelaborable_initialization(Cursor);
+   @b<pragma> Preelaborable_Initialization(Cursor);
 
    Empty_Set : @b<constant> Set;