2007-04-20 Vincent Celier <celier@adacore.com>

[pf3gnuchains/gcc-fork.git] / gcc / ada / a-convec.ads

diff --git a/gcc/ada/a-convec.ads b/gcc/ada/a-convec.ads
index c8e6e99..bceea17 100644 (file)
--- a/gcc/ada/a-convec.ads
+++ b/gcc/ada/a-convec.ads
@@ -6,7 +6,7 @@
 --                                                                          --
 --                                 S p e c                                  --
 --                                                                          --
---          Copyright (C) 2004-2005 Free Software Foundation, Inc.          --
+--          Copyright (C) 2004-2006, Free Software Foundation, Inc.         --
 --                                                                          --
 -- This specification is derived from the Ada Reference Manual for use with --
 -- GNAT. The copyright notice above, and the license provisions that follow --
@@ -42,25 +42,26 @@ generic
    with function "=" (Left, Right : Element_Type) return Boolean is <>;
 
 package Ada.Containers.Vectors is
-pragma Preelaborate (Vectors);
+   pragma Preelaborate;
 
    subtype Extended_Index is Index_Type'Base
      range Index_Type'First - 1 ..
-           Index_Type'Last +
-              Boolean'Pos (Index_Type'Base'Last > Index_Type'Last);
+           Index_Type'Min (Index_Type'Base'Last - 1, Index_Type'Last) + 1;
 
    No_Index : constant Extended_Index := Extended_Index'First;
 
-   subtype Index_Subtype is Index_Type;
-
    type Vector is tagged private;
+   pragma Preelaborable_Initialization (Vector);
 
    type Cursor is private;
+   pragma Preelaborable_Initialization (Cursor);
 
    Empty_Vector : constant Vector;
 
    No_Element : constant Cursor;
 
+   function "=" (Left, Right : Vector) return Boolean;
+
    function To_Vector (Length : Count_Type) return Vector;
 
    function To_Vector
@@ -75,8 +76,6 @@ pragma Preelaborate (Vectors);
 
    function "&" (Left, Right : Element_Type) return Vector;
 
-   function "=" (Left, Right : Vector) return Boolean;
-
    function Capacity (Container : Vector) return Count_Type;
 
    procedure Reserve_Capacity
@@ -85,6 +84,10 @@ pragma Preelaborate (Vectors);
 
    function Length (Container : Vector) return Count_Type;
 
+   procedure Set_Length
+     (Container : in out Vector;
+      Length    : Count_Type);
+
    function Is_Empty (Container : Vector) return Boolean;
 
    procedure Clear (Container : in out Vector);
@@ -101,6 +104,16 @@ pragma Preelaborate (Vectors);
 
    function Element (Position : Cursor) return Element_Type;
 
+   procedure Replace_Element
+     (Container : in out Vector;
+      Index     : Index_Type;
+      New_Item  : Element_Type);
+
+   procedure Replace_Element
+     (Container : in out Vector;
+      Position  : Cursor;
+      New_Item  : Element_Type);
+
    procedure Query_Element
      (Container : Vector;
       Index     : Index_Type;
@@ -111,22 +124,14 @@ pragma Preelaborate (Vectors);
       Process  : not null access procedure (Element : Element_Type));
 
    procedure Update_Element
-     (Container : Vector;
+     (Container : in out Vector;
       Index     : Index_Type;
       Process   : not null access procedure (Element : in out Element_Type));
 
    procedure Update_Element
-     (Position : Cursor;
-      Process  : not null access procedure (Element : in out Element_Type));
-
-   procedure Replace_Element
-     (Container : Vector;
-      Index     : Index_Type;
-      By        : Element_Type);
-
-   procedure Replace_Element (Position : Cursor; By : Element_Type);
-
-   procedure Assign (Target : in out Vector; Source : Vector);
+     (Container : in out Vector;
+      Position  : Cursor;
+      Process   : not null access procedure (Element : in out Element_Type));
 
    procedure Move (Target : in out Vector; Source : in out Vector);
 
@@ -165,6 +170,17 @@ pragma Preelaborate (Vectors);
       Position  : out Cursor;
       Count     : Count_Type := 1);
 
+   procedure Insert
+     (Container : in out Vector;
+      Before    : Extended_Index;
+      Count     : Count_Type := 1);
+
+   procedure Insert
+     (Container : in out Vector;
+      Before    : Cursor;
+      Position  : out Cursor;
+      Count     : Count_Type := 1);
+
    procedure Prepend
      (Container : in out Vector;
       New_Item  : Vector);
@@ -194,10 +210,6 @@ pragma Preelaborate (Vectors);
       Position  : out Cursor;
       Count     : Count_Type := 1);
 
-   procedure Set_Length
-     (Container : in out Vector;
-      Length    : Count_Type);
-
    procedure Delete
      (Container : in out Vector;
       Index     : Extended_Index;
@@ -216,6 +228,12 @@ pragma Preelaborate (Vectors);
      (Container : in out Vector;
       Count     : Count_Type := 1);
 
+   procedure Reverse_Elements (Container : in out Vector);
+
+   procedure Swap (Container : in out Vector; I, J : Index_Type);
+
+   procedure Swap (Container : in out Vector; I, J : Cursor);
+
    function First_Index (Container : Vector) return Index_Type;
 
    function First (Container : Vector) return Cursor;
@@ -228,21 +246,13 @@ pragma Preelaborate (Vectors);
 
    function Last_Element (Container : Vector) return Element_Type;
 
-   procedure Swap (Container : Vector; I, J : Index_Type);
-
-   procedure Swap (I, J : Cursor);
-
-   generic
-      with function "<" (Left, Right : Element_Type) return Boolean is <>;
-   package Generic_Sorting is
-
-      function Is_Sorted (Container : Vector) return Boolean;
+   function Next (Position : Cursor) return Cursor;
 
-      procedure Sort (Container : in out Vector);
+   procedure Next (Position : in out Cursor);
 
-      procedure Merge (Target, Source : in out Vector);
+   function Previous (Position : Cursor) return Cursor;
 
-   end Generic_Sorting;
+   procedure Previous (Position : in out Cursor);
 
    function Find_Index
      (Container : Vector;
@@ -268,14 +278,6 @@ pragma Preelaborate (Vectors);
      (Container : Vector;
       Item      : Element_Type) return Boolean;
 
-   function Next (Position : Cursor) return Cursor;
-
-   function Previous (Position : Cursor) return Cursor;
-
-   procedure Next (Position : in out Cursor);
-
-   procedure Previous (Position : in out Cursor);
-
    function Has_Element (Position : Cursor) return Boolean;
 
    procedure Iterate
@@ -286,6 +288,18 @@ pragma Preelaborate (Vectors);
      (Container : Vector;
       Process   : not null access procedure (Position : Cursor));
 
+   generic
+      with function "<" (Left, Right : Element_Type) return Boolean is <>;
+   package Generic_Sorting is
+
+      function Is_Sorted (Container : Vector) return Boolean;
+
+      procedure Sort (Container : in out Vector);
+
+      procedure Merge (Target : in out Vector; Source : in out Vector);
+
+   end Generic_Sorting;
+
 private
 
    pragma Inline (First_Index);
@@ -320,13 +334,13 @@ private
    use Ada.Streams;
 
    procedure Write
-     (Stream    : access Root_Stream_Type'Class;
+     (Stream    : not null access Root_Stream_Type'Class;
       Container : Vector);
 
    for Vector'Write use Write;
 
    procedure Read
-     (Stream    : access Root_Stream_Type'Class;
+     (Stream    : not null access Root_Stream_Type'Class;
       Container : out Vector);
 
    for Vector'Read use Read;
@@ -341,6 +355,18 @@ private
       Index     : Index_Type := Index_Type'First;
    end record;
 
+   procedure Write
+     (Stream   : not null access Root_Stream_Type'Class;
+      Position : Cursor);
+
+   for Cursor'Write use Write;
+
+   procedure Read
+     (Stream   : not null access Root_Stream_Type'Class;
+      Position : out Cursor);
+
+   for Cursor'Read use Read;
+
    No_Element : constant Cursor := Cursor'(null, Index_Type'First);
 
 end Ada.Containers.Vectors;