Makefile.rtl, [...]: Added bounded list container.

2010-10-26  Matthew Heaney  <heaney@adacore.com>

	* Makefile.rtl, impunit.adb: Added bounded list container.
	* a-cbdlli.ads, a-cbdlli.adb: New file.

From-SVN: r165938

gcc/ada/ChangeLog

+2010-10-26  Matthew Heaney  <heaney@adacore.com>
+
+	* Makefile.rtl, impunit.adb: Added bounded list container.
+	* a-cbdlli.ads, a-cbdlli.adb: New file.
+
 2010-10-25  Eric Botcazou  <ebotcazou@adacore.com>
 
 	* gcc-interface/utils2.c: Include flags.h and remove prototypes.

gcc/ada/Makefile.rtl

@@ -87,6 +87,7 @@ GNATRTL_NONTASKING_OBJS= \
   a-calfor$(objext) \
   a-catizo$(objext) \
   a-cborse$(objext) \
+  a-cbdlli$(objext) \
   a-cborma$(objext) \
   a-cdlili$(objext) \
   a-cgaaso$(objext) \

gcc/ada/a-cbdlli.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--               ADA.CONTAINERS.BOUNDED_DOUBLY_LINKED_LISTS                 --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--          Copyright (C) 2004-2010, 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 --
+-- apply solely to the  contents of the part following the private keyword. --
+--                                                                          --
+-- GNAT is free software;  you can  redistribute it  and/or modify it under --
+-- terms of the  GNU General Public License as published  by the Free Soft- --
+-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
+-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
+-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
+-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
+--                                                                          --
+-- As a special exception under Section 7 of GPL version 3, you are granted --
+-- additional permissions described in the GCC Runtime Library Exception,   --
+-- version 3.1, as published by the Free Software Foundation.               --
+--                                                                          --
+-- You should have received a copy of the GNU General Public License and    --
+-- a copy of the GCC Runtime Library Exception along with this program;     --
+-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
+-- <http://www.gnu.org/licenses/>.                                          --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+private with Ada.Streams;
+
+generic
+   type Element_Type is private;
+
+   with function "=" (Left, Right : Element_Type)
+      return Boolean is <>;
+
+package Ada.Containers.Bounded_Doubly_Linked_Lists is
+   pragma Pure;
+   pragma Remote_Types;
+
+   type List (Capacity : Count_Type) is tagged private;
+   pragma Preelaborable_Initialization (List);
+
+   type Cursor is private;
+   pragma Preelaborable_Initialization (Cursor);
+
+   Empty_List : constant List;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : List) return Boolean;
+
+   function Length (Container : List) return Count_Type;
+
+   function Is_Empty (Container : List) return Boolean;
+
+   procedure Clear (Container : in out List);
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Replace_Element
+     (Container : in out List;
+      Position  : Cursor;
+      New_Item  : Element_Type);
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+   procedure Update_Element
+     (Container : in out List;
+      Position  : Cursor;
+      Process   : not null access procedure (Element : in out Element_Type));
+
+   procedure Assign (Target : in out List; Source : List);
+
+   function Copy (Source : List; Capacity : Count_Type := 0) return List;
+
+   procedure Move
+     (Target : in out List;
+      Source : in out List);
+
+   procedure Insert
+     (Container : in out List;
+      Before    : Cursor;
+      New_Item  : Element_Type;
+      Count     : Count_Type := 1);
+
+   procedure Insert
+     (Container : in out List;
+      Before    : Cursor;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Count     : Count_Type := 1);
+
+   procedure Insert
+     (Container : in out List;
+      Before    : Cursor;
+      Position  : out Cursor;
+      Count     : Count_Type := 1);
+
+   procedure Prepend
+     (Container : in out List;
+      New_Item  : Element_Type;
+      Count     : Count_Type := 1);
+
+   procedure Append
+     (Container : in out List;
+      New_Item  : Element_Type;
+      Count     : Count_Type := 1);
+
+   procedure Delete
+     (Container : in out List;
+      Position  : in out Cursor;
+      Count     : Count_Type := 1);
+
+   procedure Delete_First
+     (Container : in out List;
+      Count     : Count_Type := 1);
+
+   procedure Delete_Last
+     (Container : in out List;
+      Count     : Count_Type := 1);
+
+   procedure Reverse_Elements (Container : in out List);
+
+   procedure Swap
+     (Container : in out List;
+      I, J      : Cursor);
+
+   procedure Swap_Links
+     (Container : in out List;
+      I, J      : Cursor);
+
+   procedure Splice
+     (Target : in out List;
+      Before : Cursor;
+      Source : in out List);
+
+   procedure Splice
+     (Target   : in out List;
+      Before   : Cursor;
+      Source   : in out List;
+      Position : in out Cursor);
+
+   procedure Splice
+     (Container : in out List;
+      Before    : Cursor;
+      Position  : Cursor);
+
+   function First (Container : List) return Cursor;
+
+   function First_Element (Container : List) return Element_Type;
+
+   function Last (Container : List) return Cursor;
+
+   function Last_Element (Container : List) return Element_Type;
+
+   function Next (Position : Cursor) return Cursor;
+
+   procedure Next (Position : in out Cursor);
+
+   function Previous (Position : Cursor) return Cursor;
+
+   procedure Previous (Position : in out Cursor);
+
+   function Find
+     (Container : List;
+      Item      : Element_Type;
+      Position  : Cursor := No_Element) return Cursor;
+
+   function Reverse_Find
+     (Container : List;
+      Item      : Element_Type;
+      Position  : Cursor := No_Element) return Cursor;
+
+   function Contains
+     (Container : List;
+      Item      : Element_Type) return Boolean;
+
+   function Has_Element (Position : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : List;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : List;
+      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 : List) return Boolean;
+
+      procedure Sort (Container : in out List);
+
+      procedure Merge (Target, Source : in out List);
+
+   end Generic_Sorting;
+
+private
+
+   pragma Inline (Next);
+   pragma Inline (Previous);
+
+   type Node_Type is record
+      Prev    : Count_Type'Base;
+      Next    : Count_Type;
+      Element : Element_Type;
+   end record;
+
+   type Node_Array is array (Count_Type range <>) of Node_Type;
+
+   type List (Capacity : Count_Type) is tagged record
+      Nodes  : Node_Array (1 .. Capacity) := (others => <>);
+      Free   : Count_Type'Base := -1;
+      First  : Count_Type := 0;
+      Last   : Count_Type := 0;
+      Length : Count_Type := 0;
+      Busy   : Natural := 0;
+      Lock   : Natural := 0;
+   end record;
+
+   use Ada.Streams;
+
+   procedure Read
+     (Stream : not null access Root_Stream_Type'Class;
+      Item   : out List);
+
+   for List'Read use Read;
+
+   procedure Write
+     (Stream : not null access Root_Stream_Type'Class;
+      Item   : List);
+
+   for List'Write use Write;
+
+   type List_Access is access all List;
+   for List_Access'Storage_Size use 0;
+
+   type Cursor is
+      record
+         Container : List_Access;
+         Node      : Count_Type := 0;
+      end record;
+
+   procedure Read
+     (Stream : not null access Root_Stream_Type'Class;
+      Item   : out Cursor);
+
+   for Cursor'Read use Read;
+
+   procedure Write
+     (Stream : not null access Root_Stream_Type'Class;
+      Item   : Cursor);
+
+   for Cursor'Write use Write;
+
+   Empty_List : constant List := (Capacity => 0, others => <>);
+
+   No_Element : constant Cursor := Cursor'(null, 0);
+
+end Ada.Containers.Bounded_Doubly_Linked_Lists;

gcc/ada/impunit.adb

@@ -508,6 +508,7 @@ package body Impunit is
      "s-multip",    -- System.Multiprocessors
      "s-mudido",    -- System.Multiprocessors.Dispatching_Domains
      "a-cobove",    -- Ada.Containers.Bounded_Vectors
+     "a-cbdlli",    -- Ada.Containers.Bounded_Doubly_Linked_Lists
      "a-cborse",    -- Ada.Containers.Bounded_Ordered_Sets
      "a-cborma");   -- Ada.Containers.Bounded_Ordered_Maps