a-rbtgso.adb, [...]: New files.

	* a-rbtgso.adb, a-crbtgo.ads, a-crbtgo.adb, a-crbtgk.ads,
	a-crbtgk.adb, a-crbltr.ads, a-coprnu.ads, a-coprnu.adb,
	a-coorse.ads, a-coorse.adb, a-convec.ads, a-convec.adb,
	a-contai.ads, a-coinve.ads, a-coinve.adb, a-cohata.ads,
	a-cohama.ads, a-cohama.adb, a-ciorse.ads, a-ciorse.adb,
	a-cihama.ads, a-cihama.adb, a-cidlli.ads, a-cidlli.adb,
	a-chtgop.ads, a-chtgop.adb, a-cgcaso.ads, a-cgcaso.adb,
	a-cgarso.ads, a-cgarso.adb, a-cdlili.ads, a-cdlili.adb,
	a-cgaaso.adb, a-coormu.adb, a-ciormu.adb, a-cihase.adb,
	a-cihase.ads, a-cohase.adb, a-cohase.ads, a-ciorma.ads,
	a-coorma.ads, a-swunha.ads, a-stunha.ads, a-ciormu.ads,
	a-coormu.ads, a-rbtgso.ads, a-swunha.adb, a-stunha.adb,
	a-cgaaso.ads, a-ciorma.adb, a-coorma.adb, a-secain.adb,
	a-secain.ads, a-slcain.ads, a-slcain.adb, a-shcain.ads,
	a-shcain.adb, a-chtgke.ads, a-chtgke.adb, a-stwiha.ads,
	a-stwiha.adb, a-strhas.ads, a-strhas.adb, a-chzla1.ads,
	a-chzla9.ads, a-lfztio.ads, a-liztio.ads, a-llfzti.ads,
	a-llizti.ads, a-sfztio.ads, a-siztio.ads, a-ssizti.ads,
	a-stzbou.adb, a-stzbou.ads, a-stzfix.adb, a-stzfix.ads,
	a-stzhas.adb, a-stzhas.ads, a-stzmap.adb, a-stzmap.ads,
	a-stzsea.adb, a-stzsea.ads, a-stzsup.adb, a-stzsup.ads,
	a-stzunb.adb, a-stzunb.ads, a-swunau.adb, a-swunau.ads,
	a-szmzco.ads, a-szunau.adb, a-szunau.ads, a-szunha.adb,
	a-szunha.ads, a-szuzti.adb, a-szuzti.ads, a-tiunio.ads,
	a-wwunio.ads, a-ztcoau.adb, a-ztcoau.ads, a-ztcoio.adb,
	a-ztcoio.ads, a-ztcstr.adb, a-ztcstr.ads, a-ztdeau.adb,
	a-ztdeau.ads, a-ztdeio.adb, a-ztdeio.ads, a-ztedit.adb,
	a-ztedit.ads, a-ztenau.adb, a-ztenau.ads, a-ztenio.adb,
	a-ztenio.ads, a-ztexio.adb, a-ztexio.ads, a-ztfiio.adb,
	a-ztfiio.ads, a-ztflau.adb, a-ztflau.ads, a-ztflio.adb,
	a-ztflio.ads, a-ztgeau.adb, a-ztgeau.ads, a-ztinau.adb,
	a-ztinau.ads, a-ztinio.adb, a-ztinio.ads, a-ztmoau.adb,
	a-ztmoau.ads, a-ztmoio.adb, a-ztmoio.ads, a-zttest.adb,
	a-zttest.ads, a-zzunio.ads: New files. Part of new Ada 2005
	library.

From-SVN: r94764

gcc/ada/ChangeLog

+2005-02-09  Arnaud Charlet  <charlet@adacore.com>
+
+	* a-rbtgso.adb, a-crbtgo.ads, a-crbtgo.adb, a-crbtgk.ads,
+	a-crbtgk.adb, a-crbltr.ads, a-coprnu.ads, a-coprnu.adb,
+	a-coorse.ads, a-coorse.adb, a-convec.ads, a-convec.adb,
+	a-contai.ads, a-coinve.ads, a-coinve.adb, a-cohata.ads,
+	a-cohama.ads, a-cohama.adb, a-ciorse.ads, a-ciorse.adb,
+	a-cihama.ads, a-cihama.adb, a-cidlli.ads, a-cidlli.adb,
+	a-chtgop.ads, a-chtgop.adb, a-cgcaso.ads, a-cgcaso.adb,
+	a-cgarso.ads, a-cgarso.adb, a-cdlili.ads, a-cdlili.adb,
+	a-cgaaso.adb, a-coormu.adb, a-ciormu.adb, a-cihase.adb,
+	a-cihase.ads, a-cohase.adb, a-cohase.ads, a-ciorma.ads,
+	a-coorma.ads, a-swunha.ads, a-stunha.ads, a-ciormu.ads,
+	a-coormu.ads, a-rbtgso.ads, a-swunha.adb, a-stunha.adb,
+	a-cgaaso.ads, a-ciorma.adb, a-coorma.adb, a-secain.adb,
+	a-secain.ads, a-slcain.ads, a-slcain.adb, a-shcain.ads,
+	a-shcain.adb, a-chtgke.ads, a-chtgke.adb, a-stwiha.ads,
+	a-stwiha.adb, a-strhas.ads, a-strhas.adb, a-chzla1.ads,
+	a-chzla9.ads, a-lfztio.ads, a-liztio.ads, a-llfzti.ads,
+	a-llizti.ads, a-sfztio.ads, a-siztio.ads, a-ssizti.ads,
+	a-stzbou.adb, a-stzbou.ads, a-stzfix.adb, a-stzfix.ads,
+	a-stzhas.adb, a-stzhas.ads, a-stzmap.adb, a-stzmap.ads,
+	a-stzsea.adb, a-stzsea.ads, a-stzsup.adb, a-stzsup.ads,
+	a-stzunb.adb, a-stzunb.ads, a-swunau.adb, a-swunau.ads,
+	a-szmzco.ads, a-szunau.adb, a-szunau.ads, a-szunha.adb,
+	a-szunha.ads, a-szuzti.adb, a-szuzti.ads, a-tiunio.ads,
+	a-wwunio.ads, a-ztcoau.adb, a-ztcoau.ads, a-ztcoio.adb,
+	a-ztcoio.ads, a-ztcstr.adb, a-ztcstr.ads, a-ztdeau.adb,
+	a-ztdeau.ads, a-ztdeio.adb, a-ztdeio.ads, a-ztedit.adb,
+	a-ztedit.ads, a-ztenau.adb, a-ztenau.ads, a-ztenio.adb,
+	a-ztenio.ads, a-ztexio.adb, a-ztexio.ads, a-ztfiio.adb,
+	a-ztfiio.ads, a-ztflau.adb, a-ztflau.ads, a-ztflio.adb,
+	a-ztflio.ads, a-ztgeau.adb, a-ztgeau.ads, a-ztinau.adb,
+	a-ztinau.ads, a-ztinio.adb, a-ztinio.ads, a-ztmoau.adb,
+	a-ztmoau.ads, a-ztmoio.adb, a-ztmoio.ads, a-zttest.adb,
+	a-zttest.ads, a-zzunio.ads: New files. Part of new Ada 2005
+	library.
+
 2005-01-27  Laurent GUERBY <laurent@guerby.net>
 
 	* Makefile.in: Fix a-intnam.ads from previous commit,

gcc/ada/a-cdlili.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.CONTAINERS.DOUBLY_LINKED_LISTS                    --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Finalization;
+with Ada.Streams;
+
+generic
+   type Element_Type is private;
+
+   with function "=" (Left, Right : Element_Type)
+      return Boolean is <>;
+
+package Ada.Containers.Doubly_Linked_Lists is
+   pragma Preelaborate (Doubly_Linked_Lists);
+
+   type List is tagged private;
+
+   type Cursor is private;
+
+   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 Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+   procedure Update_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : in out Element_Type));
+
+   procedure Replace_Element
+     (Position : Cursor;
+      By       : Element_Type);
+
+   procedure Move
+     (Target : in out List;
+      Source : in out List);
+
+   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 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 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);
+
+   generic
+      with function "<" (Left, Right : Element_Type)
+         return Boolean is <>;
+   procedure Generic_Sort (Container : in out List);
+
+   generic
+      with function "<" (Left, Right : Element_Type)
+         return Boolean is <>;
+   procedure Generic_Merge (Target : in out List; Source : in out List);
+
+   procedure Reverse_List (Container : in out List);
+
+   procedure Swap (I, J : in 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;
+      Position : Cursor);
+
+   procedure Splice
+     (Target   : in out List;
+      Before   : Cursor;
+      Source   : in out List;
+      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 Contains
+     (Container : List;
+      Item      : Element_Type) return Boolean;
+
+   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 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
+     (Container : List;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : List;
+      Process   : not null access procedure (Position : Cursor));
+
+private
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   type Node_Type is
+      record
+         Element : Element_Type;
+         Next    : Node_Access;
+         Prev    : Node_Access;
+      end record;
+
+   function "=" (L, R : Node_Type) return Boolean is abstract;
+
+   use Ada.Finalization;
+
+   type List is
+     new Controlled with record
+        First  : Node_Access;
+        Last   : Node_Access;
+        Length : Count_Type := 0;
+     end record;
+
+   procedure Adjust (Container : in out List);
+
+   procedure Finalize (Container : in out List) renames Clear;
+
+   use Ada.Streams;
+
+   procedure Read
+     (Stream : access Root_Stream_Type'Class;
+      Item   : out List);
+
+   for List'Read use Read;
+
+   procedure Write
+     (Stream : access Root_Stream_Type'Class;
+      Item   : List);
+
+   for List'Write use Write;
+
+   Empty_List : constant List := List'(Controlled with null, null, 0);
+
+   type List_Access is access constant List;
+   for List_Access'Storage_Size use 0;
+
+   type Cursor is
+      record
+         Container : List_Access;
+         Node      : Node_Access;
+      end record;
+
+   No_Element : constant Cursor := Cursor'(null, null);
+
+end Ada.Containers.Doubly_Linked_Lists;
+

gcc/ada/a-cgaaso.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--               ADA.CONTAINERS.GENERIC_ANONYMOUS_ARRAY_SORT                --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+procedure Ada.Containers.Generic_Anonymous_Array_Sort
+  (First, Last : Index_Type'Base)
+is
+   Pivot, Lo, Mid, Hi : Index_Type;
+
+begin
+   if Last <= First then
+      return;
+   end if;
+
+   Lo := First;
+   Hi := Last;
+
+   if Last = Index_Type'Succ (First) then
+      if not Less (Lo, Hi) then
+         Swap (Lo, Hi);
+      end if;
+
+      return;
+   end if;
+
+   Mid := Index_Type'Val
+     (Index_Type'Pos (Lo) +
+      (Index_Type'Pos (Hi) - Index_Type'Pos (Lo)) / 2);
+
+   --  We need to figure out which case we have:
+   --  x < y < z
+   --  x < z < y
+   --  z < x < y
+   --  y < x < z
+   --  y < z < x
+   --  z < y < x
+
+   if Less (Lo, Mid) then
+      if Less (Lo, Hi) then
+         if Less (Mid, Hi) then
+            Swap (Lo, Mid);
+
+         else
+            Swap (Lo, Hi);
+
+         end if;
+
+      else
+         null;  --  lo is median
+      end if;
+
+   elsif Less (Lo, Hi) then
+      null; --  lo is median
+
+   elsif Less (Mid, Hi) then
+      Swap (Lo, Hi);
+
+   else
+      Swap (Lo, Mid);
+   end if;
+
+   Pivot := Lo;
+   Outer : loop
+      loop
+         exit Outer when not (Pivot < Hi);
+
+         if Less (Hi, Pivot) then
+            Swap (Hi, Pivot);
+            Pivot := Hi;
+            Lo := Index_Type'Succ (Lo);
+            exit;
+         else
+            Hi := Index_Type'Pred (Hi);
+         end if;
+      end loop;
+
+      loop
+         exit Outer when not (Lo < Pivot);
+
+         if Less (Lo, Pivot) then
+            Lo := Index_Type'Succ (Lo);
+         else
+            Swap (Lo, Pivot);
+            Pivot := Lo;
+            Hi := Index_Type'Pred (Hi);
+            exit;
+         end if;
+      end loop;
+   end loop Outer;
+
+   Generic_Anonymous_Array_Sort (First, Index_Type'Pred (Pivot));
+   Generic_Anonymous_Array_Sort (Index_Type'Succ (Pivot), Last);
+
+end Ada.Containers.Generic_Anonymous_Array_Sort;

gcc/ada/a-cgaaso.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--               ADA.CONTAINERS.GENERIC_ANONYMOUS_ARRAY_SORT                --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+generic
+   type Index_Type is (<>);
+   with function Less (Left, Right : Index_Type) return Boolean is <>;
+   with procedure Swap (Left, Right : Index_Type) is <>;
+
+procedure Ada.Containers.Generic_Anonymous_Array_Sort
+  (First, Last : in Index_Type'Base);
+
+pragma Pure (Ada.Containers.Generic_Anonymous_Array_Sort);

gcc/ada/a-cgarso.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.CONTAINERS.GENERIC_ARRAY_SORT                     --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Generic_Constrained_Array_Sort;
+
+procedure Ada.Containers.Generic_Array_Sort
+  (Container : in out Array_Type)
+is
+   subtype Index_Subtype is
+     Index_Type range Container'First .. Container'Last;
+
+   subtype Array_Subtype is
+     Array_Type (Index_Subtype);
+
+   procedure Sort is
+      new Generic_Constrained_Array_Sort
+       (Index_Type   => Index_Subtype,
+        Element_Type => Element_Type,
+        Array_Type   => Array_Subtype,
+        "<"          => "<");
+
+begin
+   Sort (Container);
+end Ada.Containers.Generic_Array_Sort;

gcc/ada/a-cgarso.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.CONTAINERS.GENERIC_ARRAY_SORT                     --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+generic
+   type Index_Type is (<>);
+   type Element_Type is private;
+   type Array_Type is array (Index_Type range <>) of Element_Type;
+
+   with function "<" (Left, Right : Element_Type)
+      return Boolean is <>;
+
+procedure Ada.Containers.Generic_Array_Sort (Container : in out Array_Type);
+
+pragma Pure (Ada.Containers.Generic_Array_Sort);
+
+

gcc/ada/a-cgcaso.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--              ADA.CONTAINERS.GENERIC_CONSTRAINED_ARRAY_SORT               --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit has originally being developed by Matthew J Heaney.            --
+------------------------------------------------------------------------------
+
+procedure Ada.Containers.Generic_Constrained_Array_Sort
+  (Container : in out Array_Type)
+is
+   function Is_Less (I, J : Index_Type) return Boolean;
+   pragma Inline (Is_Less);
+
+   procedure Swap (I, J : Index_Type);
+   pragma Inline (Swap);
+
+   procedure Sort (First, Last : Index_Type'Base);
+
+   -------------
+   -- Is_Less --
+   -------------
+
+   function Is_Less (I, J : Index_Type) return Boolean is
+   begin
+      return Container (I) < Container (J);
+   end Is_Less;
+
+   ----------
+   -- Sort --
+   ----------
+
+   procedure Sort (First, Last : Index_Type'Base) is
+      Pivot, Lo, Mid, Hi : Index_Type;
+
+   begin
+      if Last <= First then
+         return;
+      end if;
+
+      Lo := First;
+      Hi := Last;
+
+      if Last = Index_Type'Succ (First) then
+         if not Is_Less (Lo, Hi) then
+            Swap (Lo, Hi);
+         end if;
+
+         return;
+      end if;
+
+      Mid := Index_Type'Val
+               (Index_Type'Pos (Lo) +
+                (Index_Type'Pos (Hi) - Index_Type'Pos (Lo)) / 2);
+
+      --  We need to figure out which case we have:
+      --  x < y < z
+      --  x < z < y
+      --  z < x < y
+      --  y < x < z
+      --  y < z < x
+      --  z < y < x
+
+      if Is_Less (Lo, Mid) then
+         if Is_Less (Lo, Hi) then
+            if Is_Less (Mid, Hi) then
+               Swap (Lo, Mid);
+            else
+               Swap (Lo, Hi);
+            end if;
+
+         else
+            null;  --  lo is median
+         end if;
+
+      elsif Is_Less (Lo, Hi) then
+         null; --  lo is median
+
+      elsif Is_Less (Mid, Hi) then
+         Swap (Lo, Hi);
+
+      else
+         Swap (Lo, Mid);
+      end if;
+
+      Pivot := Lo;
+
+      Outer : loop
+         loop
+            exit Outer when not (Pivot < Hi);
+
+            if Is_Less (Hi, Pivot) then
+               Swap (Hi, Pivot);
+               Pivot := Hi;
+               Lo := Index_Type'Succ (Lo);
+               exit;
+            else
+               Hi := Index_Type'Pred (Hi);
+            end if;
+         end loop;
+
+         loop
+            exit Outer when not (Lo < Pivot);
+
+            if Is_Less (Lo, Pivot) then
+               Lo := Index_Type'Succ (Lo);
+            else
+               Swap (Lo, Pivot);
+               Pivot := Lo;
+               Hi := Index_Type'Pred (Hi);
+               exit;
+            end if;
+         end loop;
+      end loop Outer;
+
+      Sort (First, Index_Type'Pred (Pivot));
+      Sort (Index_Type'Succ (Pivot), Last);
+   end Sort;
+
+   ----------
+   -- Swap --
+   ----------
+
+   procedure Swap (I, J : Index_Type) is
+      EI : constant Element_Type := Container (I);
+   begin
+      Container (I) := Container (J);
+      Container (J) := EI;
+   end Swap;
+
+--  Start of processing for Generic_Constrained_Array_Sort
+
+begin
+   Sort (Container'First, Container'Last);
+end Ada.Containers.Generic_Constrained_Array_Sort;

gcc/ada/a-cgcaso.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--              ADA.CONTAINERS.GENERIC_CONSTRAINED_ARRAY_SORT               --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+generic
+   type Index_Type is (<>);
+   type Element_Type is private;
+   type Array_Type is array (Index_Type) of Element_Type;
+
+   with function "<" (Left, Right : Element_Type)
+     return Boolean is <>;
+
+procedure Ada.Containers.Generic_Constrained_Array_Sort
+  (Container : in out Array_Type);
+
+pragma Pure (Ada.Containers.Generic_Constrained_Array_Sort);

gcc/ada/a-chtgke.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                 ADA.CONTAINERS.HASH_TABLES.GENERIC_KEYS                  --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+package body Ada.Containers.Hash_Tables.Generic_Keys is
+
+   --------------------------
+   -- Delete_Key_Sans_Free --
+   --------------------------
+
+   procedure Delete_Key_Sans_Free
+     (HT   : in out HT_Type;
+      Key  : Key_Type;
+      X    : out Node_Access)
+   is
+      Indx : Hash_Type;
+      Prev : Node_Access;
+
+   begin
+      if HT.Length = 0 then
+         X := Null_Node;
+         return;
+      end if;
+
+      Indx := Index (HT, Key);
+      X := HT.Buckets (Indx);
+
+      if X = Null_Node then
+         return;
+      end if;
+
+      if Equivalent_Keys (Key, X) then
+         HT.Buckets (Indx) := Next (X);
+         HT.Length := HT.Length - 1;
+         return;
+      end if;
+
+      loop
+         Prev := X;
+         X := Next (Prev);
+
+         if X = Null_Node then
+            return;
+         end if;
+
+         if Equivalent_Keys (Key, X) then
+            Set_Next (Node => Prev, Next => Next (X));
+            HT.Length := HT.Length - 1;
+            return;
+         end if;
+      end loop;
+   end Delete_Key_Sans_Free;
+
+   ----------
+   -- Find --
+   ----------
+
+   function Find
+     (HT  : HT_Type;
+      Key : Key_Type) return Node_Access is
+
+      Indx : Hash_Type;
+      Node : Node_Access;
+
+   begin
+      if HT.Length = 0 then
+         return Null_Node;
+      end if;
+
+      Indx := Index (HT, Key);
+
+      Node := HT.Buckets (Indx);
+      while Node /= Null_Node loop
+         if Equivalent_Keys (Key, Node) then
+            return Node;
+         end if;
+         Node := Next (Node);
+      end loop;
+
+      return Null_Node;
+   end Find;
+
+   --------------------------------
+   -- Generic_Conditional_Insert --
+   --------------------------------
+
+   procedure Generic_Conditional_Insert
+     (HT      : in out HT_Type;
+      Key     : Key_Type;
+      Node    : out Node_Access;
+      Success : out Boolean)
+   is
+      Indx : constant Hash_Type := Index (HT, Key);
+      B    : Node_Access renames HT.Buckets (Indx);
+
+      subtype Length_Subtype is Count_Type range 0 .. Count_Type'Last - 1;
+
+   begin
+      if B = Null_Node then
+         declare
+            Length : constant Length_Subtype := HT.Length;
+         begin
+            Node := New_Node (Next => Null_Node);
+            Success := True;
+
+            B := Node;
+            HT.Length := Length + 1;
+         end;
+
+         return;
+      end if;
+
+      Node := B;
+      loop
+         if Equivalent_Keys (Key, Node) then
+            Success := False;
+            return;
+         end if;
+
+         Node := Next (Node);
+
+         exit when Node = Null_Node;
+      end loop;
+
+      declare
+         Length : constant Length_Subtype := HT.Length;
+      begin
+         Node := New_Node (Next => B);
+         Success := True;
+
+         B := Node;
+         HT.Length := Length + 1;
+      end;
+   end Generic_Conditional_Insert;
+
+   -----------
+   -- Index --
+   -----------
+
+   function Index
+     (HT  : HT_Type;
+      Key : Key_Type) return Hash_Type is
+   begin
+      return Hash (Key) mod HT.Buckets'Length;
+   end Index;
+
+end Ada.Containers.Hash_Tables.Generic_Keys;

gcc/ada/a-chtgke.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                 ADA.CONTAINERS.HASH_TABLES.GENERIC_KEYS                  --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+generic
+   with package HT_Types is
+     new Generic_Hash_Table_Types (<>);
+
+   type HT_Type is new HT_Types.Hash_Table_Type with private;
+
+   use HT_Types;
+
+   Null_Node : Node_Access;
+
+   with function Next (Node : Node_Access) return Node_Access;
+
+   with procedure Set_Next
+     (Node : Node_Access;
+      Next : Node_Access);
+
+   type Key_Type (<>) is limited private;
+
+   with function Hash (Key : Key_Type) return Hash_Type;
+
+   with function Equivalent_Keys
+     (Key  : Key_Type;
+      Node : Node_Access) return Boolean;
+
+package Ada.Containers.Hash_Tables.Generic_Keys is
+   pragma Preelaborate;
+
+   function Index
+     (HT  : HT_Type;
+      Key : Key_Type) return Hash_Type;
+   pragma Inline (Index);
+
+   procedure Delete_Key_Sans_Free
+     (HT   : in out HT_Type;
+      Key  : Key_Type;
+      X    : out Node_Access);
+
+   function Find (HT  : HT_Type; Key : Key_Type) return Node_Access;
+
+   generic
+      with function New_Node
+        (Next : Node_Access) return Node_Access;
+   procedure Generic_Conditional_Insert
+     (HT      : in out HT_Type;
+      Key     : Key_Type;
+      Node    : out Node_Access;
+      Success : out Boolean);
+
+end Ada.Containers.Hash_Tables.Generic_Keys;

gcc/ada/a-chtgop.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--              ADA.CONTAINERS.HASH_TABLES.GENERIC_OPERATIONS               --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 Free Software Foundation, Inc.            --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Streams;
+
+generic
+
+   with package HT_Types is
+     new Generic_Hash_Table_Types (<>);
+
+   type Hash_Table_Type is new HT_Types.Hash_Table_Type with private;
+
+   use HT_Types;
+
+   Null_Node : in Node_Access;
+
+   with function Hash_Node (Node : Node_Access) return Hash_Type;
+
+   with function Next (Node : Node_Access) return Node_Access;
+
+   with procedure Set_Next
+     (Node : Node_Access;
+      Next : Node_Access);
+
+    with function Copy_Node (Source : Node_Access) return Node_Access;
+
+   with procedure Free (X : in out Node_Access);
+
+package Ada.Containers.Hash_Tables.Generic_Operations is
+   pragma Preelaborate;
+
+   procedure Free_Hash_Table (Buckets : in out Buckets_Access);
+
+   function Index
+     (Buckets : Buckets_Type;
+      Node    : Node_Access) return Hash_Type;
+   pragma Inline (Index);
+
+   function Index
+     (Hash_Table : Hash_Table_Type;
+      Node       : Node_Access) return Hash_Type;
+   pragma Inline (Index);
+
+   procedure Adjust (HT : in out Hash_Table_Type);
+
+   procedure Finalize (HT : in out Hash_Table_Type);
+
+   generic
+      with function Find
+        (HT  : Hash_Table_Type;
+         Key : Node_Access) return Boolean;
+   function Generic_Equal
+     (L, R : Hash_Table_Type) return Boolean;
+
+   procedure Clear (HT : in out Hash_Table_Type);
+
+   procedure Move (Target, Source : in out Hash_Table_Type);
+
+   function Capacity (HT : Hash_Table_Type) return Count_Type;
+
+   procedure Ensure_Capacity
+     (HT : in out Hash_Table_Type;
+      N  : Count_Type);
+
+   procedure Delete_Node_Sans_Free
+     (HT : in out Hash_Table_Type;
+      X  : Node_Access);
+
+   function First (HT : Hash_Table_Type) return Node_Access;
+
+   function Next
+     (HT   : Hash_Table_Type;
+      Node : Node_Access) return Node_Access;
+
+   generic
+      with procedure Process (Node : Node_Access);
+   procedure Generic_Iteration (HT : Hash_Table_Type);
+
+   generic
+      use Ada.Streams;
+      with procedure Write
+        (Stream : access Root_Stream_Type'Class;
+         Node   : Node_Access);
+   procedure Generic_Write
+     (Stream : access Root_Stream_Type'Class;
+      HT     : Hash_Table_Type);
+
+   generic
+      use Ada.Streams;
+      with function New_Node (Stream : access Root_Stream_Type'Class)
+         return Node_Access;
+   procedure Generic_Read
+     (Stream : access Root_Stream_Type'Class;
+      HT     : out Hash_Table_Type);
+
+end Ada.Containers.Hash_Tables.Generic_Operations;
+

gcc/ada/a-cidlli.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--              ADA.CONTAINERS.INDEFINITE_DOUBLY_LINKED_LISTS               --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Finalization;
+with Ada.Streams;
+
+generic
+
+   type Element_Type (<>) is private;
+
+   with function "=" (Left, Right : Element_Type)
+      return Boolean is <>;
+
+package Ada.Containers.Indefinite_Doubly_Linked_Lists is
+   pragma Preelaborate (Indefinite_Doubly_Linked_Lists);
+
+   type List is tagged private;
+
+   type Cursor is private;
+
+   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 Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+   procedure Update_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : in out Element_Type));
+
+   procedure Replace_Element
+     (Position : Cursor;
+      By       : Element_Type);
+
+   procedure Move
+     (Target : in out List;
+      Source : in out List);
+
+   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 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 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);
+
+   generic
+      with function "<" (Left, Right : Element_Type)
+         return Boolean is <>;
+   procedure Generic_Sort (Container : in out List);
+
+   generic
+      with function "<" (Left, Right : Element_Type)
+         return Boolean is <>;
+   procedure Generic_Merge
+     (Target : in out List;
+      Source : in out List);
+
+   procedure Reverse_List (Container : in out List);
+
+   procedure Swap (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;
+      Position : Cursor);
+
+   procedure Splice
+     (Target   : in out List;
+      Before   : Cursor;
+      Source   : in out List;
+      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 Contains
+     (Container : List;
+      Item      : Element_Type) return Boolean;
+
+   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 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
+     (Container : List;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : List;
+      Process   : not null access procedure (Position : Cursor));
+
+private
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   type Element_Access is access Element_Type;
+
+   type Node_Type is
+      record
+         Element : Element_Access;
+         Next    : Node_Access;
+         Prev    : Node_Access;
+      end record;
+
+   function "=" (L, R : Node_Type) return Boolean is abstract;
+
+   use Ada.Finalization;
+
+   type List is
+     new Controlled with record
+        First  : Node_Access;
+        Last   : Node_Access;
+        Length : Count_Type := 0;
+     end record;
+
+   procedure Adjust (Container : in out List);
+
+   procedure Finalize (Container : in out List) renames Clear;
+
+   use Ada.Streams;
+
+   procedure Read
+     (Stream : access Root_Stream_Type'Class;
+      Item   : out List);
+
+   for List'Read use Read;
+
+   procedure Write
+     (Stream : access Root_Stream_Type'Class;
+      Item   : List);
+
+   for List'Write use Write;
+
+   Empty_List : constant List := List'(Controlled with null, null, 0);
+
+   type List_Access is access constant List;
+   for List_Access'Storage_Size use 0;
+
+   type Cursor is
+      record
+         Container : List_Access;
+         Node      : Node_Access;
+      end record;
+
+   No_Element : constant Cursor := Cursor'(null, null);
+
+end Ada.Containers.Indefinite_Doubly_Linked_Lists;
+
+

gcc/ada/a-cihama.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                  ADA.CONTAINERS.INDEFINITE_HASHED_MAPS                   --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Hash_Tables;
+with Ada.Streams;
+
+generic
+   type Key_Type (<>) is private;
+   type Element_Type (<>) is private;
+
+   with function Hash (Key : Key_Type) return Hash_Type;
+   with function Equivalent_Keys (Left, Right : Key_Type) return Boolean;
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Indefinite_Hashed_Maps is
+   pragma Preelaborate (Indefinite_Hashed_Maps);
+
+   type Map is tagged private;
+   type Cursor is private;
+
+   Empty_Map  : constant Map;
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Map) return Boolean;
+
+   function Length (Container : Map) return Count_Type;
+
+   function Is_Empty (Container : Map) return Boolean;
+
+   procedure Clear (Container : in out Map);
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Key     : Key_Type;
+                                            Element : Element_Type));
+
+   procedure Update_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Key     : Key_Type;
+                                            Element : in out Element_Type));
+
+   procedure Replace_Element
+     (Position : Cursor;
+      By       : Element_Type);
+
+   procedure Move (Target : in out Map; Source : in out Map);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Include
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Replace
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Delete
+     (Container : in out Map;
+      Key       : Key_Type);
+
+   procedure Exclude
+     (Container : in out Map;
+      Key       : Key_Type);
+
+   procedure Delete
+     (Container : in out Map;
+      Position  : in out Cursor);
+
+   function Contains
+     (Container : Map;
+      Key       : Key_Type) return Boolean;
+
+   function Find
+     (Container : Map;
+      Key       : Key_Type) return Cursor;
+
+   function Element
+     (Container : Map;
+      Key       : Key_Type) return Element_Type;
+
+   function Capacity (Container : Map) return Count_Type;
+
+   procedure Reserve_Capacity
+     (Container : in out Map;
+      Capacity  : Count_Type);
+
+   function First (Container : Map) return Cursor;
+
+   function Next (Position : Cursor) return Cursor;
+
+   procedure Next (Position : in out Cursor);
+
+   function Has_Element (Position : Cursor) return Boolean;
+
+   function Key (Position : Cursor) return Key_Type;
+
+   function Equivalent_Keys (Left, Right : Cursor)
+     return Boolean;
+
+   function Equivalent_Keys
+     (Left  : Cursor;
+      Right : Key_Type) return Boolean;
+
+   function Equivalent_Keys
+     (Left  : Key_Type;
+      Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Map;
+      Process   : not null access procedure (Position : Cursor));
+
+private
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package HT_Types is
+      new Hash_Tables.Generic_Hash_Table_Types (Node_Access);
+
+   use HT_Types;
+
+   type Map is new Hash_Table_Type with null record;
+
+   procedure Adjust (Container : in out Map);
+
+   procedure Finalize (Container : in out Map);
+
+   type Map_Access is access constant Map;
+   for Map_Access'Storage_Size use 0;
+
+   type Cursor is
+      record
+         Container : Map_Access;
+         Node      : Node_Access;
+      end record;
+
+   No_Element : constant Cursor :=
+     (Container => null,
+      Node      => null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Map);
+
+   for Map'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Map);
+
+   for Map'Read use Read;
+
+   Empty_Map : constant Map := (Hash_Table_Type with null record);
+
+end Ada.Containers.Indefinite_Hashed_Maps;
+
+
+

gcc/ada/a-cihase.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                  ADA.CONTAINERS.INDEFINITE_HASHED_SETS                   --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Hash_Tables;
+with Ada.Streams;
+
+generic
+   type Element_Type (<>) is private;
+
+   with function Hash (Element : Element_Type) return Hash_Type;
+
+   --  TODO: get a ruling from ARG in Atlanta re the name and
+   --  order of these declarations ???
+
+   with function Equivalent_Keys (Left, Right : Element_Type) return Boolean;
+
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Indefinite_Hashed_Sets is
+
+   pragma Preelaborate (Indefinite_Hashed_Sets);
+
+   type Set is tagged private;
+
+   type Cursor is private;
+
+   Empty_Set : constant Set;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Set) return Boolean;
+
+   function Length (Container : Set) return Count_Type;
+
+   function Is_Empty (Container : Set) return Boolean;
+
+   procedure Clear (Container : in out Set);
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+--  TODO: resolve in atlanta ???
+--   procedure Replace_Element (Container : in out Set;
+--                              Position  : Cursor;
+--                              By        : Element_Type);
+
+   procedure Move
+     (Target : in out Set;
+      Source : in out Set);
+
+   procedure Insert
+     (Container : in out Set;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert  (Container : in out Set; New_Item : Element_Type);
+
+   procedure Include (Container : in out Set; New_Item : Element_Type);
+
+   procedure Replace (Container : in out Set; New_Item : Element_Type);
+
+   procedure Delete  (Container : in out Set; Item : Element_Type);
+
+   procedure Exclude (Container : in out Set; Item : Element_Type);
+
+   procedure Delete (Container : in out Set; Position  : in out Cursor);
+
+   procedure Union (Target : in out Set; Source : Set);
+
+   function Union (Left, Right : Set) return Set;
+
+   function "or" (Left, Right : Set) return Set renames Union;
+
+   procedure Intersection (Target : in out Set; Source : Set);
+
+   function Intersection (Left, Right : Set) return Set;
+
+   function "and" (Left, Right : Set) return Set renames Intersection;
+
+   procedure Difference (Target : in out Set; Source : Set);
+
+   function Difference (Left, Right : Set) return Set;
+
+   function "-" (Left, Right : Set) return Set renames Difference;
+
+   procedure Symmetric_Difference (Target : in out Set; Source : Set);
+
+   function Symmetric_Difference (Left, Right : Set) return Set;
+
+   function "xor" (Left, Right : Set) return Set
+     renames Symmetric_Difference;
+
+   function Is_Subset (Subset : Set; Of_Set : Set) return Boolean;
+
+   function Overlap (Left, Right : Set) return Boolean;
+
+   function Contains (Container : Set; Item : Element_Type) return Boolean;
+
+   function Find (Container : Set; Item : Element_Type) return Cursor;
+
+   function Capacity (Container : Set) return Count_Type;
+
+   procedure Reserve_Capacity
+     (Container : in out Set;
+      Capacity  : Count_Type);
+
+   function First (Container : Set) return Cursor;
+
+   function Next (Position : Cursor) return Cursor;
+
+   procedure Next (Position : in out Cursor);
+
+   function Has_Element (Position : Cursor) return Boolean;
+
+   function Equivalent_Keys (Left, Right : Cursor) return Boolean;
+
+   function Equivalent_Keys
+     (Left  : Cursor;
+      Right : Element_Type) return Boolean;
+
+   function Equivalent_Keys
+     (Left  : Element_Type;
+      Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Set;
+      Process   : not null access procedure (Position : Cursor));
+
+   generic
+      type Key_Type (<>) is limited private;
+
+      with function Key (Element : Element_Type) return Key_Type;
+
+      with function Hash (Key : Key_Type) return Hash_Type;
+
+      with function Equivalent_Keys
+        (Key     : Key_Type;
+         Element : Element_Type) return Boolean;
+
+   package Generic_Keys is
+
+      function Contains (Container : Set; Key : Key_Type) return Boolean;
+
+      function Find (Container : Set; Key : Key_Type) return Cursor;
+
+      function Key (Position : Cursor) return Key_Type;
+
+      function Element (Container : Set; Key : Key_Type) return Element_Type;
+
+--  TODO: resolve in atlanta???
+--      procedure Replace (Container : in out Set;
+--                         Key       : Key_Type;
+--                         New_Item  : Element_Type);
+
+      procedure Delete (Container : in out Set; Key : Key_Type);
+
+      procedure Exclude (Container : in out Set; Key : Key_Type);
+
+      procedure Checked_Update_Element
+        (Container : in out Set;
+         Position  : Cursor;
+         Process   : not null access
+                       procedure (Element : in out Element_Type));
+
+      function Equivalent_Keys
+        (Left  : Cursor;
+         Right : Key_Type) return Boolean;
+
+      function Equivalent_Keys
+        (Left  : Key_Type;
+         Right : Cursor) return Boolean;
+   end Generic_Keys;
+
+private
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package HT_Types is
+      new Hash_Tables.Generic_Hash_Table_Types (Node_Access);
+
+   use HT_Types;
+
+   type Set is new Hash_Table_Type with null record;
+
+   procedure Adjust (Container : in out Set);
+
+   procedure Finalize (Container : in out Set);
+
+   type Set_Access is access constant Set;
+   for Set_Access'Storage_Size use 0;
+
+   type Cursor is
+      record
+         Container : Set_Access;
+         Node      : Node_Access;
+      end record;
+
+   No_Element : constant Cursor :=
+                  (Container => null,
+                   Node      => null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Set);
+
+   for Set'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Set);
+
+   for Set'Read use Read;
+
+   Empty_Set : constant Set := (Hash_Table_Type with null record);
+
+end Ada.Containers.Indefinite_Hashed_Sets;
+

gcc/ada/a-ciorma.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                  ADA.CONTAINERS.INDEFINITE_ORDERED_MAPS                  --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Red_Black_Trees;
+with Ada.Finalization;
+with Ada.Streams;
+
+generic
+
+   type Key_Type (<>) is private;
+
+   type Element_Type (<>) is private;
+
+   with function "<" (Left, Right : Key_Type) return Boolean is <>;
+
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Indefinite_Ordered_Maps is
+pragma Preelaborate (Indefinite_Ordered_Maps);
+
+   type Map is tagged private;
+
+   type Cursor is private;
+
+   Empty_Map : constant Map;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Map) return Boolean;
+
+   function Length (Container : Map) return Count_Type;
+
+   function Is_Empty (Container : Map) return Boolean;
+
+   procedure Clear (Container : in out Map);
+
+   function Key (Position : Cursor) return Key_Type;
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Key     : Key_Type;
+                                            Element : Element_Type));
+
+   procedure Update_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Key     : Key_Type;
+                                            Element : in out Element_Type));
+
+   procedure Replace_Element (Position : Cursor; By : Element_Type);
+
+   procedure Move (Target : in out Map; Source : in out Map);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Include
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Replace
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Delete
+     (Container : in out Map;
+      Key       : Key_Type);
+
+   procedure Exclude
+     (Container : in out Map;
+      Key       : Key_Type);
+
+   procedure Delete
+     (Container : in out Map;
+      Position  : in out Cursor);
+
+   procedure Delete_First (Container : in out Map);
+
+   procedure Delete_Last (Container : in out Map);
+
+   function Contains
+     (Container : Map;
+      Key       : Key_Type) return Boolean;
+
+   function Find
+     (Container : Map;
+      Key       : Key_Type) return Cursor;
+
+   function Element
+     (Container : Map;
+      Key       : Key_Type) return Element_Type;
+
+   function Floor
+     (Container : Map;
+      Key       : Key_Type) return Cursor;
+
+   function Ceiling
+     (Container : Map;
+      Key       : Key_Type) return Cursor;
+
+   function First (Container : Map) return Cursor;
+
+   function First_Key (Container : Map) return Key_Type;
+
+   function First_Element (Container : Map) return Element_Type;
+
+   function Last (Container : Map) return Cursor;
+
+   function Last_Key (Container : Map) return Key_Type;
+
+   function Last_Element (Container : Map) return Element_Type;
+
+   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;
+
+   function "<" (Left, Right : Cursor) return Boolean;
+
+   function ">" (Left, Right : Cursor) return Boolean;
+
+   function "<" (Left : Cursor; Right : Key_Type) return Boolean;
+
+   function ">" (Left : Cursor; Right : Key_Type) return Boolean;
+
+   function "<" (Left : Key_Type; Right : Cursor) return Boolean;
+
+   function ">" (Left : Key_Type; Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Map;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : Map;
+      Process   : not null access procedure (Position : Cursor));
+
+private
+
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package Tree_Types is
+     new Red_Black_Trees.Generic_Tree_Types (Node_Access);
+
+   use Tree_Types;
+   use Ada.Finalization;
+
+   type Map is new Controlled with record
+      Tree : Tree_Type := (Length => 0, others => null);
+   end record;
+
+   procedure Adjust (Container : in out Map);
+
+   procedure Finalize (Container : in out Map) renames Clear;
+
+   type Map_Access is access constant Map;
+   for Map_Access'Storage_Size use 0;
+
+   type Cursor is record
+      Container : Map_Access;
+      Node      : Node_Access;
+   end record;
+
+   No_Element : constant Cursor := Cursor'(null, null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Map);
+
+   for Map'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Map);
+
+   for Map'Read use Read;
+
+   Empty_Map : constant Map :=
+     (Controlled with Tree => (Length => 0, others => null));
+
+end Ada.Containers.Indefinite_Ordered_Maps;
+

gcc/ada/a-ciorse.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                  ADA.CONTAINERS.INDEFINITE_ORDERED_SETS                  --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Red_Black_Trees;
+with Ada.Finalization;
+with Ada.Streams;
+
+generic
+   type Element_Type (<>) is private;
+
+   with function "<" (Left, Right : Element_Type) return Boolean is <>;
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Indefinite_Ordered_Sets is
+pragma Preelaborate (Indefinite_Ordered_Sets);
+
+   type Set is tagged private;
+
+   type Cursor is private;
+
+   Empty_Set : constant Set;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Set) return Boolean;
+
+   function Length (Container : Set) return Count_Type;
+
+   function Is_Empty (Container : Set) return Boolean;
+
+   procedure Clear (Container : in out Set);
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+   --  TODO: resolve in Atlanta???
+   --   procedure Replace_Element
+   --     (Container : in out Set;
+   --      Position  : Cursor;
+   --      By        : Element_Type);
+
+   procedure Move (Target : in out Set; Source : in out Set);
+
+   procedure Insert
+     (Container : in out Set;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert
+     (Container : in out Set;
+      New_Item  : Element_Type);
+
+   procedure Include
+     (Container : in out Set;
+      New_Item  : Element_Type);
+
+   procedure Replace
+     (Container : in out Set;
+      New_Item  : Element_Type);
+
+   procedure Delete
+     (Container : in out Set;
+      Item      : Element_Type);
+
+   procedure Exclude
+     (Container : in out Set;
+      Item      : Element_Type);
+
+   procedure Delete
+     (Container : in out Set;
+      Position  : in out Cursor);
+
+   procedure Delete_First (Container : in out Set);
+
+   procedure Delete_Last (Container : in out Set);
+
+   procedure Union (Target : in out Set; Source : Set);
+
+   function Union (Left, Right : Set) return Set;
+
+   function "or" (Left, Right : Set) return Set renames Union;
+
+   procedure Intersection (Target : in out Set; Source : Set);
+
+   function Intersection (Left, Right : Set) return Set;
+
+   function "and" (Left, Right : Set) return Set renames Intersection;
+
+   procedure Difference (Target : in out Set;
+                         Source : Set);
+
+   function Difference (Left, Right : Set) return Set;
+
+   function "-" (Left, Right : Set) return Set renames Difference;
+
+   procedure Symmetric_Difference (Target : in out Set; Source : Set);
+
+   function Symmetric_Difference (Left, Right : Set) return Set;
+
+   function "xor" (Left, Right : Set) return Set renames Symmetric_Difference;
+
+   function Overlap (Left, Right : Set) return Boolean;
+
+   function Is_Subset (Subset : Set; Of_Set : Set) return Boolean;
+
+   function Contains (Container : Set; Item : Element_Type) return Boolean;
+
+   function Find (Container : Set; Item : Element_Type) return Cursor;
+
+   function Floor (Container : Set; Item : Element_Type) return Cursor;
+
+   function Ceiling (Container : Set; Item : Element_Type) return Cursor;
+
+   function First (Container : Set) return Cursor;
+
+   function First_Element (Container : Set) return Element_Type;
+
+   function Last (Container : Set) return Cursor;
+
+   function Last_Element (Container : Set) return Element_Type;
+
+   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;
+
+   function "<" (Left, Right : Cursor) return Boolean;
+
+   function ">" (Left, Right : Cursor) return Boolean;
+
+   function "<" (Left : Cursor; Right : Element_Type) return Boolean;
+
+   function ">" (Left : Cursor; Right : Element_Type) return Boolean;
+
+   function "<" (Left : Element_Type; Right : Cursor) return Boolean;
+
+   function ">" (Left : Element_Type; Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Set;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : Set;
+      Process   : not null access procedure (Position : Cursor));
+
+   generic
+      type Key_Type (<>) is limited private;
+
+      with function Key (Element : Element_Type) return Key_Type;
+
+      with function "<" (Left : Key_Type; Right : Element_Type)
+          return Boolean is <>;
+
+      with function ">" (Left : Key_Type; Right : Element_Type)
+          return Boolean is <>;
+
+   package Generic_Keys is
+
+      function Contains
+        (Container : Set;
+         Key       : Key_Type) return Boolean;
+
+      function Find
+        (Container : Set;
+         Key       : Key_Type) return Cursor;
+
+      function Floor
+        (Container : Set;
+         Key       : Key_Type) return Cursor;
+
+      function Ceiling
+        (Container : Set;
+         Key       : Key_Type) return Cursor;
+
+      function Key (Position : Cursor) return Key_Type;
+
+      function Element
+        (Container : Set;
+         Key       : Key_Type) return Element_Type;
+
+      --  TODO: resolve in Atlanta???
+      --      procedure Replace
+      --        (Container : in out Set;
+      --         Key       : Key_Type;
+      --         New_Item  : Element_Type);
+
+      procedure Delete (Container : in out Set; Key : Key_Type);
+
+      procedure Exclude (Container : in out Set; Key : Key_Type);
+
+      function "<" (Left : Cursor; Right : Key_Type) return Boolean;
+
+      function ">" (Left : Cursor; Right : Key_Type) return Boolean;
+
+      function "<" (Left : Key_Type; Right : Cursor) return Boolean;
+
+      function ">" (Left : Key_Type; Right : Cursor) return Boolean;
+
+      --  TODO: resolve name in Atlanta???
+      procedure Checked_Update_Element
+        (Container : in out Set;
+         Position  : Cursor;
+         Process   : not null access
+                       procedure (Element : in out Element_Type));
+
+   end Generic_Keys;
+
+private
+
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package Tree_Types is
+     new Red_Black_Trees.Generic_Tree_Types (Node_Access);
+
+   use Tree_Types;
+   use Ada.Finalization;
+
+   type Set is new Controlled with record
+      Tree : Tree_Type := (Length => 0, others => null);
+   end record;
+
+   procedure Adjust (Container : in out Set);
+
+   procedure Finalize (Container : in out Set) renames Clear;
+
+   type Set_Access is access constant Set;
+   for Set_Access'Storage_Size use 0;
+
+   type Cursor is record
+      Container : Set_Access;
+      Node      : Node_Access;
+   end record;
+
+   No_Element : constant Cursor := Cursor'(null, null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Set);
+
+   for Set'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Set);
+
+   for Set'Read use Read;
+
+   Empty_Set : constant Set :=
+                 (Controlled with Tree => (Length => 0, others => null));
+
+end Ada.Containers.Indefinite_Ordered_Sets;

gcc/ada/a-cohama.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                        ADA.CONTAINERS.HASHED_MAPS                        --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Hash_Tables;
+with Ada.Streams;
+
+generic
+   type Key_Type is private;
+
+   type Element_Type is private;
+
+   with function Hash (Key : Key_Type) return Hash_Type;
+
+   with function Equivalent_Keys (Left, Right : Key_Type) return Boolean;
+
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Hashed_Maps is
+pragma Preelaborate (Hashed_Maps);
+
+   type Map is tagged private;
+
+   type Cursor is private;
+
+   Empty_Map : constant Map;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Map) return Boolean;
+
+   function Length (Container : Map) return Count_Type;
+
+   function Is_Empty (Container : Map) return Boolean;
+
+   procedure Clear (Container : in out Map);
+
+   function Element (Position : Cursor)
+      return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access
+                   procedure (Key : Key_Type; Element : Element_Type));
+
+   procedure Update_Element
+     (Position : Cursor;
+      Process  : not null access
+                   procedure (Key : Key_Type; Element : in out Element_Type));
+
+   procedure Replace_Element (Position : Cursor; By : Element_Type);
+
+   procedure Move (Target : in out Map; Source : in out Map);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Include
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Replace
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Delete (Container : in out Map; Key : Key_Type);
+
+   procedure Exclude (Container : in out Map; Key : Key_Type);
+
+   procedure Delete (Container : in out Map; Position : in out Cursor);
+
+   function Contains (Container : Map; Key : Key_Type) return Boolean;
+
+   function Find (Container : Map; Key : Key_Type) return Cursor;
+
+   function Element (Container : Map; Key : Key_Type) return Element_Type;
+
+   function Capacity (Container : Map) return Count_Type;
+
+   procedure Reserve_Capacity (Container : in out Map;
+                               Capacity  : Count_Type);
+
+   function First (Container : Map) return Cursor;
+
+   function Next (Position : Cursor) return Cursor;
+
+   procedure Next (Position : in out Cursor);
+
+   function Has_Element (Position : Cursor) return Boolean;
+
+   function Key (Position : Cursor) return Key_Type;
+
+   function Equivalent_Keys (Left, Right : Cursor) return Boolean;
+
+   function Equivalent_Keys (Left : Cursor; Right : Key_Type) return Boolean;
+
+   function Equivalent_Keys (Left : Key_Type; Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Map;
+      Process   : not null access procedure (Position : Cursor));
+
+private
+
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package HT_Types is new Hash_Tables.Generic_Hash_Table_Types (Node_Access);
+
+   use HT_Types;
+
+   type Map is new Hash_Table_Type with null record;
+
+   procedure Adjust (Container : in out Map);
+
+   procedure Finalize (Container : in out Map);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Map);
+
+   for Map'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Map);
+
+   for Map'Read use Read;
+
+   Empty_Map : constant Map := (Hash_Table_Type with null record);
+
+   type Map_Access is access constant Map;
+   for Map_Access'Storage_Size use 0;
+
+   type Cursor is
+      record
+         Container : Map_Access;
+         Node      : Node_Access;
+      end record;
+
+   No_Element : constant Cursor := (Container => null, Node => null);
+
+end Ada.Containers.Hashed_Maps;

gcc/ada/a-cohase.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                        ADA.CONTAINERS.HASHED_SETS                        --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Hash_Tables;
+with Ada.Streams;
+
+generic
+   type Element_Type is private;
+
+   with function Hash (Element : Element_Type) return Hash_Type;
+
+   --  TODO: get a ruling from ARG in Atlanta re the name and
+   --  order of these declarations. ???
+   --
+   with function Equivalent_Keys (Left, Right : Element_Type) return Boolean;
+
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Hashed_Sets is
+pragma Preelaborate (Hashed_Sets);
+
+   type Set is tagged private;
+
+   type Cursor is private;
+
+   Empty_Set : constant Set;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Set) return Boolean;
+
+   function Length (Container : Set) return Count_Type;
+
+   function Is_Empty (Container : Set) return Boolean;
+
+   procedure Clear (Container : in out Set);
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+   --  TODO: resolve in atlanta
+   --   procedure Replace_Element
+   --     (Container : in out Set;
+   --      Position  : Cursor;
+   --      By        : Element_Type);
+
+   procedure Move (Target : in out Set; Source : in out Set);
+
+   procedure Insert
+     (Container : in out Set;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert  (Container : in out Set; New_Item : Element_Type);
+
+   procedure Include (Container : in out Set; New_Item : Element_Type);
+
+   procedure Replace (Container : in out Set; New_Item : Element_Type);
+
+   procedure Delete  (Container : in out Set; Item     : Element_Type);
+
+   procedure Exclude (Container : in out Set; Item     : Element_Type);
+
+   procedure Delete (Container : in out Set; Position  : in out Cursor);
+
+   procedure Union (Target : in out Set; Source : Set);
+
+   function Union (Left, Right : Set) return Set;
+
+   function "or" (Left, Right : Set) return Set renames Union;
+
+   procedure Intersection (Target : in out Set; Source : Set);
+
+   function Intersection (Left, Right : Set) return Set;
+
+   function "and" (Left, Right : Set) return Set renames Intersection;
+
+   procedure Difference (Target : in out Set; Source : Set);
+
+   function Difference (Left, Right : Set) return Set;
+
+   function "-" (Left, Right : Set) return Set renames Difference;
+
+   procedure Symmetric_Difference (Target : in out Set; Source : Set);
+
+   function Symmetric_Difference (Left, Right : Set) return Set;
+
+   function "xor" (Left, Right : Set) return Set
+     renames Symmetric_Difference;
+
+   function Overlap (Left, Right : Set) return Boolean;
+
+   function Is_Subset (Subset : Set; Of_Set : Set) return Boolean;
+
+   function Contains (Container : Set; Item : Element_Type) return Boolean;
+
+   function Find
+     (Container : Set;
+      Item      : Element_Type) return Cursor;
+
+   function Capacity (Container : Set) return Count_Type;
+
+   procedure Reserve_Capacity
+     (Container : in out Set;
+      Capacity  : Count_Type);
+
+   function First (Container : Set) return Cursor;
+
+   function Next (Position : Cursor) return Cursor;
+
+   procedure Next (Position : in out Cursor);
+
+   function Has_Element (Position : Cursor) return Boolean;
+
+   function Equivalent_Keys (Left, Right : Cursor) return Boolean;
+
+   function Equivalent_Keys
+     (Left  : Cursor;
+      Right : Element_Type) return Boolean;
+
+   function Equivalent_Keys
+     (Left  : Element_Type;
+      Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Set;
+      Process   : not null access procedure (Position : Cursor));
+
+   generic
+      type Key_Type (<>) is limited private;
+
+      with function Key (Element : Element_Type) return Key_Type;
+
+      with function Hash (Key : Key_Type) return Hash_Type;
+
+      with function Equivalent_Keys
+        (Key     : Key_Type;
+         Element : Element_Type) return Boolean;
+
+   package Generic_Keys is
+
+      function Contains (Container : Set; Key : Key_Type) return Boolean;
+
+      function Find (Container : Set; Key : Key_Type) return Cursor;
+
+      function Key (Position : Cursor) return Key_Type;
+
+      function Element (Container : Set; Key : Key_Type) return Element_Type;
+
+      --  TODO: resolve in atlanta
+      --      procedure Replace
+      --        (Container : in out Set;
+      --         Key       : Key_Type;
+      --         New_Item  : Element_Type);
+
+      procedure Delete (Container : in out Set; Key : Key_Type);
+
+      procedure Exclude (Container : in out Set; Key : Key_Type);
+
+      --  TODO: resolve name in atlanta: ???
+      procedure Checked_Update_Element
+        (Container : in out Set;
+         Position  : Cursor;
+         Process   : not null access
+                       procedure (Element : in out Element_Type));
+
+      function Equivalent_Keys
+        (Left  : Cursor;
+         Right : Key_Type) return Boolean;
+
+      function Equivalent_Keys
+        (Left  : Key_Type;
+         Right : Cursor) return Boolean;
+
+   end Generic_Keys;
+
+private
+
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package HT_Types is
+     new Hash_Tables.Generic_Hash_Table_Types (Node_Access);
+
+   use HT_Types;
+
+   type Set is new Hash_Table_Type with null record;
+
+   procedure Adjust (Container : in out Set);
+
+   procedure Finalize (Container : in out Set);
+
+   type Set_Access is access constant Set;
+   for Set_Access'Storage_Size use 0;
+
+   type Cursor is record
+      Container : Set_Access;
+      Node      : Node_Access;
+   end record;
+
+   No_Element : constant Cursor := (Container => null, Node => null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Set);
+
+   for Set'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Set);
+
+   for Set'Read use Read;
+
+   Empty_Set : constant Set := (Hash_Table_Type with null record);
+
+end Ada.Containers.Hashed_Sets;

gcc/ada/a-cohata.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                        ADA.CONTAINERS.HASH_TABLES                        --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Finalization;
+
+package Ada.Containers.Hash_Tables is
+pragma Preelaborate;
+
+   generic
+      type Node_Access is private;
+
+   package Generic_Hash_Table_Types is
+      type Buckets_Type is array (Hash_Type range <>) of Node_Access;
+
+      type Buckets_Access is access Buckets_Type;
+
+      type Hash_Table_Type is new Ada.Finalization.Controlled with record
+         Buckets : Buckets_Access;
+         Length  : Count_Type := 0;
+      end record;
+   end Generic_Hash_Table_Types;
+
+end Ada.Containers.Hash_Tables;

gcc/ada/a-contai.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                              ADA.CONTAINERS                              --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+package Ada.Containers is
+pragma Pure (Containers);
+
+   type Hash_Type is mod 2**32;
+   type Count_Type is range 0 .. 2**31 - 1;
+
+end Ada.Containers;

gcc/ada/a-coorma.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                       ADA.CONTAINERS.ORDERED_MAPS                        --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Red_Black_Trees;
+with Ada.Finalization;
+with Ada.Streams;
+
+generic
+
+   type Key_Type is private;
+
+   type Element_Type is private;
+
+   with function "<" (Left, Right : Key_Type) return Boolean is <>;
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Ordered_Maps is
+pragma Preelaborate (Ordered_Maps);
+
+   type Map is tagged private;
+
+   type Cursor is private;
+
+   Empty_Map : constant Map;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Map) return Boolean;
+
+   function Length (Container : Map) return Count_Type;
+
+   function Is_Empty (Container : Map) return Boolean;
+
+   procedure Clear (Container : in out Map);
+
+   function Key (Position : Cursor) return Key_Type;
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access
+                   procedure (Key : Key_Type; Element : Element_Type));
+
+   procedure Update_Element
+     (Position : Cursor;
+      Process  : not null access
+                   procedure (Key : Key_Type; Element : in out Element_Type));
+
+   procedure Replace_Element (Position : Cursor; By : in Element_Type);
+
+   procedure Move (Target : in out Map; Source : in out Map);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Include
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Replace
+     (Container : in out Map;
+      Key       : Key_Type;
+      New_Item  : Element_Type);
+
+   procedure Insert
+     (Container : in out Map;
+      Key       : Key_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Delete (Container : in out Map; Key : Key_Type);
+
+   procedure Exclude (Container : in out Map; Key : Key_Type);
+
+   procedure Delete (Container : in out Map; Position : in out Cursor);
+
+   procedure Delete_First (Container : in out Map);
+
+   procedure Delete_Last (Container : in out Map);
+
+   function Contains (Container : Map; Key : Key_Type) return Boolean;
+
+   function Find (Container : Map; Key : Key_Type) return Cursor;
+
+   function Element (Container : Map; Key : Key_Type) return Element_Type;
+
+   function Floor (Container : Map; Key : Key_Type) return Cursor;
+
+   function Ceiling (Container : Map; Key : Key_Type) return Cursor;
+
+   function First (Container : Map) return Cursor;
+
+   function First_Key (Container : Map) return Key_Type;
+
+   function First_Element (Container : Map) return Element_Type;
+
+   function Last (Container : Map) return Cursor;
+
+   function Last_Key (Container : Map) return Key_Type;
+
+   function Last_Element (Container : Map) return Element_Type;
+
+   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;
+
+   function "<" (Left, Right : Cursor) return Boolean;
+
+   function ">" (Left, Right : Cursor) return Boolean;
+
+   function "<" (Left : Cursor; Right : Key_Type) return Boolean;
+
+   function ">" (Left : Cursor; Right : Key_Type) return Boolean;
+
+   function "<" (Left : Key_Type; Right : Cursor) return Boolean;
+
+   function ">" (Left : Key_Type; Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Map;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : Map;
+      Process   : not null access procedure (Position : Cursor));
+
+private
+
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package Tree_Types is
+     new Red_Black_Trees.Generic_Tree_Types (Node_Access);
+
+   use Tree_Types;
+   use Ada.Finalization;
+
+   type Map is new Controlled with record
+      Tree : Tree_Type := (Length => 0, others => null);
+   end record;
+
+   procedure Adjust (Container : in out Map);
+
+   procedure Finalize (Container : in out Map) renames Clear;
+
+   type Map_Access is access constant Map;
+   for Map_Access'Storage_Size use 0;
+
+   type Cursor is record
+      Container : Map_Access;
+      Node      : Node_Access;
+   end record;
+
+   No_Element : constant Cursor := Cursor'(null, null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Map);
+
+   for Map'Write use Write;
+
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Map);
+
+   for Map'Read use Read;
+
+   Empty_Map : constant Map :=
+                 (Controlled with Tree => (Length => 0, others => null));
+
+end Ada.Containers.Ordered_Maps;

gcc/ada/a-coorse.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                       ADA.CONTAINERS.ORDERED_SETS                        --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Red_Black_Trees;
+with Ada.Finalization;
+with Ada.Streams;
+
+generic
+
+   type Element_Type is private;
+
+   with function "<" (Left, Right : Element_Type) return Boolean is <>;
+   with function "=" (Left, Right : Element_Type) return Boolean is <>;
+
+package Ada.Containers.Ordered_Sets is
+pragma Preelaborate (Ordered_Sets);
+
+   type Set is tagged private;
+
+   type Cursor is private;
+
+   Empty_Set : constant Set;
+
+   No_Element : constant Cursor;
+
+   function "=" (Left, Right : Set) return Boolean;
+
+   function Length (Container : Set) return Count_Type;
+
+   function Is_Empty (Container : Set) return Boolean;
+
+   procedure Clear (Container : in out Set);
+
+   function Element (Position : Cursor) return Element_Type;
+
+   procedure Query_Element
+     (Position : Cursor;
+      Process  : not null access procedure (Element : Element_Type));
+
+--  TODO: resolve in Atlanta. ???
+--   procedure Replace_Element
+--     (Container : in out Set;
+--      Position  : Cursor;
+--      By        : Element_Type);
+
+   procedure Move
+     (Target : in out Set;
+      Source : in out Set);
+
+   procedure Insert
+     (Container : in out Set;
+      New_Item  : Element_Type;
+      Position  : out Cursor;
+      Inserted  : out Boolean);
+
+   procedure Insert
+     (Container : in out Set;
+      New_Item  : Element_Type);
+
+   procedure Include
+     (Container : in out Set;
+      New_Item  : Element_Type);
+
+   procedure Replace
+     (Container : in out Set;
+      New_Item  : Element_Type);
+
+   procedure Delete
+     (Container : in out Set;
+      Item      : Element_Type);
+
+   procedure Exclude
+     (Container : in out Set;
+      Item      : Element_Type);
+
+   procedure Delete
+     (Container : in out Set;
+      Position  : in out Cursor);
+
+   procedure Delete_First (Container : in out Set);
+
+   procedure Delete_Last (Container : in out Set);
+
+   procedure Union (Target : in out Set; Source : Set);
+
+   function Union (Left, Right : Set) return Set;
+
+   function "or" (Left, Right : Set) return Set renames Union;
+
+   procedure Intersection (Target : in out Set; Source : Set);
+
+   function Intersection (Left, Right : Set) return Set;
+
+   function "and" (Left, Right : Set) return Set renames Intersection;
+
+   procedure Difference (Target : in out Set;
+                         Source : Set);
+
+   function Difference (Left, Right : Set) return Set;
+
+   function "-" (Left, Right : Set) return Set renames Difference;
+
+   procedure Symmetric_Difference (Target : in out Set; Source : Set);
+
+   function Symmetric_Difference (Left, Right : Set) return Set;
+
+   function "xor" (Left, Right : Set) return Set renames Symmetric_Difference;
+
+   function Overlap (Left, Right : Set) return Boolean;
+
+   function Is_Subset (Subset : Set; Of_Set : Set) return Boolean;
+
+   function Contains (Container : Set; Item : Element_Type) return Boolean;
+
+   function Find (Container : Set; Item : Element_Type) return Cursor;
+
+   function Floor (Container : Set; Item : Element_Type) return Cursor;
+
+   function Ceiling (Container : Set; Item : Element_Type) return Cursor;
+
+   function First (Container : Set) return Cursor;
+
+   function First_Element (Container : Set) return Element_Type;
+
+   function Last (Container : Set) return Cursor;
+
+   function Last_Element (Container : Set) return Element_Type;
+
+   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;
+
+   function "<" (Left, Right : Cursor) return Boolean;
+
+   function ">" (Left, Right : Cursor) return Boolean;
+
+   function "<" (Left : Cursor; Right : Element_Type) return Boolean;
+
+   function ">" (Left : Cursor; Right : Element_Type) return Boolean;
+
+   function "<" (Left : Element_Type; Right : Cursor) return Boolean;
+
+   function ">" (Left : Element_Type; Right : Cursor) return Boolean;
+
+   procedure Iterate
+     (Container : Set;
+      Process   : not null access procedure (Position : Cursor));
+
+   procedure Reverse_Iterate
+     (Container : Set;
+      Process   : not null access procedure (Position : Cursor));
+
+   generic
+      type Key_Type (<>) is limited private;
+
+      with function Key (Element : Element_Type) return Key_Type;
+
+      with function "<"
+        (Left  : Key_Type;
+         Right : Element_Type) return Boolean is <>;
+
+      with function ">"
+        (Left  : Key_Type;
+         Right : Element_Type) return Boolean is <>;
+
+   package Generic_Keys is
+
+      function Contains (Container : Set; Key : Key_Type) return Boolean;
+
+      function Find (Container : Set; Key : Key_Type) return Cursor;
+
+      function Floor (Container : Set; Key : Key_Type) return Cursor;
+
+      function Ceiling (Container : Set; Key : Key_Type) return Cursor;
+
+      function Key (Position : Cursor) return Key_Type;
+
+      function Element (Container : Set; Key : Key_Type) return Element_Type;
+
+--  TODO: resolve in Atlanta ???
+--      procedure Replace
+--        (Container : in out Set;
+--         Key       : Key_Type;
+--         New_Item  : Element_Type);
+
+      procedure Delete (Container : in out Set; Key : Key_Type);
+
+      procedure Exclude (Container : in out Set; Key : Key_Type);
+
+      function "<" (Left : Cursor; Right : Key_Type) return Boolean;
+
+      function ">" (Left : Cursor; Right : Key_Type) return Boolean;
+
+      function "<" (Left : Key_Type; Right : Cursor) return Boolean;
+
+      function ">" (Left : Key_Type; Right : Cursor) return Boolean;
+
+--  TODO: resolve name in Atlanta. Should name be just "Update_Element" ???
+      procedure Checked_Update_Element
+        (Container : in out Set;
+         Position  : Cursor;
+         Process   : not null access
+                       procedure (Element : in out Element_Type));
+
+   end Generic_Keys;
+
+private
+
+   type Node_Type;
+   type Node_Access is access Node_Type;
+
+   package Tree_Types is
+     new Red_Black_Trees.Generic_Tree_Types (Node_Access);
+
+   use Tree_Types;
+   use Ada.Finalization;
+
+   type Set is new Controlled with record
+      Tree : Tree_Type := (Length => 0, others => null);
+   end record;
+
+   procedure Adjust (Container : in out Set);
+
+   procedure Finalize (Container : in out Set) renames Clear;
+
+   type Set_Access is access constant Set;
+
+   type Cursor is record
+      Container : Set_Access;
+      Node      : Node_Access;
+   end record;
+
+   No_Element : constant Cursor := Cursor'(null, null);
+
+   use Ada.Streams;
+
+   procedure Write
+     (Stream    : access Root_Stream_Type'Class;
+      Container : Set);
+
+   for Set'Write use Write;
+
+   procedure Read
+     (Stream    : access Root_Stream_Type'Class;
+      Container : out Set);
+
+   for Set'Read use Read;
+
+   Empty_Set : constant Set :=
+                 (Controlled with Tree => (Length => 0, others => null));
+
+end Ada.Containers.Ordered_Sets;

gcc/ada/a-coprnu.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                       ADA.CONTAINERS.PRIME_NUMBERS                       --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+package body Ada.Containers.Prime_Numbers is
+
+   --------------
+   -- To_Prime --
+   --------------
+
+   function To_Prime (Length : Count_Type) return Hash_Type is
+      I, J, K : Integer'Base;
+      Index   : Integer'Base;
+
+   begin
+      I := Primes'Last - Primes'First;
+      Index := Primes'First;
+      while I > 0 loop
+         J := I / 2;
+         K := Index + J;
+
+         if Primes (K) < Hash_Type (Length) then
+            Index := K + 1;
+            I := I - J - 1;
+         else
+            I := J;
+         end if;
+      end loop;
+
+      return Primes (Index);
+   end To_Prime;
+
+end Ada.Containers.Prime_Numbers;

gcc/ada/a-coprnu.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                       ADA.CONTAINERS.PRIME_NUMBERS                       --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+package Ada.Containers.Prime_Numbers is
+pragma Pure (Prime_Numbers);
+
+   type Primes_Type is array (Positive range <>) of Hash_Type;
+
+   Primes : constant Primes_Type :=
+     (53,         97,         193,       389,       769,
+      1543,       3079,       6151,      12289,     24593,
+      49157,      98317,      196613,    393241,    786433,
+      1572869,    3145739,    6291469,   12582917,  25165843,
+      50331653,   100663319,  201326611, 402653189, 805306457,
+      1610612741, 3221225473, 4294967291);
+
+   function To_Prime (Length : Count_Type) return Hash_Type;
+
+end Ada.Containers.Prime_Numbers;

gcc/ada/a-crbltr.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                      ADA.CONTAINERS.RED_BLACK_TREES                      --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+package Ada.Containers.Red_Black_Trees is
+pragma Pure (Red_Black_Trees);
+
+   type Color_Type is (Red, Black);
+
+   generic
+      type Node_Access is private;
+   package Generic_Tree_Types is
+      type Tree_Type is record
+         First  : Node_Access;
+         Last   : Node_Access;
+         Root   : Node_Access;
+         Length : Count_Type;
+      end record;
+   end Generic_Tree_Types;
+end Ada.Containers.Red_Black_Trees;

gcc/ada/a-crbtgk.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--               ADA.CONTAINERS.RED_BLACK_TREES.GENERIC_KEYS                --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Red_Black_Trees.Generic_Operations;
+
+generic
+   with package Tree_Operations is new Generic_Operations (<>);
+
+   use Tree_Operations.Tree_Types;
+
+   type Key_Type (<>) is limited private;
+
+   with function Is_Less_Key_Node
+     (L : Key_Type;
+      R : Node_Access) return Boolean;
+
+   with function Is_Greater_Key_Node
+     (L : Key_Type;
+      R : Node_Access) return Boolean;
+
+package Ada.Containers.Red_Black_Trees.Generic_Keys is
+pragma Pure (Generic_Keys);
+
+   generic
+      with function New_Node return Node_Access;
+   procedure Generic_Insert_Post
+     (Tree : in out Tree_Type;
+      X, Y : Node_Access;
+      Key  : Key_Type;
+      Z    : out Node_Access);
+
+   generic
+      with procedure Insert_Post
+        (Tree : in out Tree_Type;
+         X, Y : Node_Access;
+         Key  : Key_Type;
+         Z    : out Node_Access);
+
+   procedure Generic_Conditional_Insert
+     (Tree    : in out Tree_Type;
+      Key     : Key_Type;
+      Node    : out Node_Access;
+      Success : out Boolean);
+
+   generic
+      with procedure Insert_Post
+        (Tree : in out Tree_Type;
+         X, Y : Node_Access;
+         Key  : Key_Type;
+         Z    : out Node_Access);
+
+   procedure Generic_Unconditional_Insert
+     (Tree : in out Tree_Type;
+      Key  : Key_Type;
+      Node : out Node_Access);
+
+   generic
+      with procedure Insert_Post
+        (Tree : in out Tree_Type;
+         X, Y : Node_Access;
+         Key  : Key_Type;
+         Z    : out Node_Access);
+
+      with procedure Unconditional_Insert_Sans_Hint
+        (Tree    : in out Tree_Type;
+         Key     : Key_Type;
+         Node    : out Node_Access);
+
+   procedure Generic_Unconditional_Insert_With_Hint
+     (Tree : in out Tree_Type;
+      Hint : Node_Access;
+      Key  : Key_Type;
+      Node : out Node_Access);
+
+   generic
+      with procedure Insert_Post
+        (Tree : in out Tree_Type;
+         X, Y : Node_Access;
+         Key  : Key_Type;
+         Z    : out Node_Access);
+
+      with procedure Conditional_Insert_Sans_Hint
+        (Tree    : in out Tree_Type;
+         Key     : Key_Type;
+         Node    : out Node_Access;
+         Success : out Boolean);
+
+   procedure Generic_Conditional_Insert_With_Hint
+     (Tree     : in out Tree_Type;
+      Position : Node_Access;
+      Key      : Key_Type;
+      Node     : out Node_Access;
+      Success  : out Boolean);
+
+   function Find
+     (Tree : Tree_Type;
+      Key  : Key_Type) return Node_Access;
+
+   function Ceiling
+     (Tree : Tree_Type;
+      Key  : Key_Type) return Node_Access;
+
+   function Floor
+     (Tree : Tree_Type;
+      Key  : Key_Type) return Node_Access;
+
+   function Upper_Bound
+     (Tree : Tree_Type;
+      Key  : Key_Type) return Node_Access;
+
+   generic
+      with procedure Process (Node : Node_Access);
+   procedure Generic_Iteration
+     (Tree : Tree_Type;
+      Key  : Key_Type);
+
+   generic
+      with procedure Process (Node : Node_Access);
+   procedure Generic_Reverse_Iteration
+     (Tree : Tree_Type;
+      Key  : Key_Type);
+
+end Ada.Containers.Red_Black_Trees.Generic_Keys;
+
+
+

gcc/ada/a-crbtgo.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--            ADA.CONTAINERS.RED_BLACK_TREES.GENERIC_OPERATIONS             --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+generic
+   with package Tree_Types is new Generic_Tree_Types (<>);
+   use Tree_Types;
+
+   Null_Node : Node_Access;
+
+   with function  Parent (Node : Node_Access) return Node_Access is <>;
+   with procedure Set_Parent (Node : Node_Access; Parent : Node_Access) is <>;
+   with function  Left (Node : Node_Access) return Node_Access is <>;
+   with procedure Set_Left (Node : Node_Access; Left : Node_Access) is <>;
+   with function  Right (Node : Node_Access) return Node_Access is <>;
+   with procedure Set_Right (Node : Node_Access; Right : Node_Access) is <>;
+   with function  Color (Node : Node_Access) return Color_Type is <>;
+   with procedure Set_Color (Node : Node_Access; Color : Color_Type) is <>;
+
+package Ada.Containers.Red_Black_Trees.Generic_Operations is
+pragma Pure;
+
+   function Min (Node : Node_Access) return Node_Access;
+
+   function Max (Node : Node_Access) return Node_Access;
+
+   procedure Check_Invariant (Tree : Tree_Type);
+
+   function Next (Node : Node_Access) return Node_Access;
+
+   function Previous (Node : Node_Access) return Node_Access;
+
+   procedure Move (Target, Source : in out Tree_Type);
+
+   generic
+      with function Is_Equal (L, R : Node_Access) return Boolean;
+   function Generic_Equal (Left, Right : Tree_Type) return Boolean;
+
+   procedure Delete_Node_Sans_Free
+     (Tree : in out Tree_Type;
+      Node : Node_Access);
+
+   generic
+      with procedure Process (Node : Node_Access) is <>;
+   procedure Generic_Iteration (Tree : Tree_Type);
+
+   generic
+      with procedure Process (Node : Node_Access) is <>;
+   procedure Generic_Reverse_Iteration (Tree : Tree_Type);
+
+   generic
+      with function New_Node return Node_Access is <>;
+   procedure Generic_Read (Tree : in out Tree_Type; N : Count_Type);
+
+   procedure Rebalance_For_Insert
+     (Tree : in out Tree_Type;
+      Node : Node_Access);
+
+end Ada.Containers.Red_Black_Trees.Generic_Operations;

gcc/ada/a-lfztio.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--     A D A . L O N G _ F L O A T _ W I D E _ W I D E _ T E X T _ I O      --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Long_Float_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Float_IO (Long_Float);

gcc/ada/a-liztio.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--   A D A . L O N G _ I N T E G E R _ W I D E _ W I D E _ T E X T _ I O    --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Long_Integer_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Integer_IO (Long_Integer);

gcc/ada/a-llfzti.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--A D A . L O N G _ L O N G _ F L O A T _ W I D E _ W I D E _ T E X T _ I O --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Long_Long_Float_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Float_IO (Long_Long_Float);

gcc/ada/a-llizti.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--   A D A . L O N G _ L O N G _ I N T E G E R _ W I D E _ T E X T _ I O    --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Long_Long_Integer_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Integer_IO (Long_Long_Integer);

gcc/ada/a-rbtgso.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--          ADA.CONTAINERS.RED_BLACK_TREES.GENERIC_SET_OPERATIONS           --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Containers.Red_Black_Trees.Generic_Operations;
+
+generic
+   with package Tree_Operations is new Generic_Operations (<>);
+
+   use Tree_Operations.Tree_Types;
+
+   with procedure Insert_With_Hint
+     (Dst_Tree : in out Tree_Type;
+      Dst_Hint : Node_Access;
+      Src_Node : Node_Access;
+      Dst_Node : out Node_Access);
+
+   with function Copy_Tree (Source_Root : Node_Access)
+       return Node_Access;
+
+   with procedure Delete_Tree (X : in out Node_Access);
+
+   with function Is_Less (Left, Right : Node_Access) return Boolean;
+
+   with procedure Free (X : in out Node_Access);
+
+package Ada.Containers.Red_Black_Trees.Generic_Set_Operations is
+pragma Pure (Generic_Set_Operations);
+
+   procedure Union (Target : in out Tree_Type; Source : Tree_Type);
+
+   function Union (Left, Right : Tree_Type) return Tree_Type;
+
+   procedure Intersection (Target : in out Tree_Type; Source : Tree_Type);
+
+   function Intersection (Left, Right : Tree_Type) return Tree_Type;
+
+   procedure Difference (Target : in out Tree_Type; Source : Tree_Type);
+
+   function Difference (Left, Right : Tree_Type) return Tree_Type;
+
+   procedure Symmetric_Difference
+     (Target : in out Tree_Type;
+      Source : Tree_Type);
+
+   function Symmetric_Difference (Left, Right : Tree_Type) return Tree_Type;
+
+   function Is_Subset (Subset : Tree_Type; Of_Set : Tree_Type) return Boolean;
+
+   function Overlap (Left, Right : Tree_Type) return Boolean;
+
+end Ada.Containers.Red_Black_Trees.Generic_Set_Operations;

gcc/ada/a-secain.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.STRINGS.EQUAL_CASE_INSENSITIVE                    --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Characters.Handling;  use Ada.Characters.Handling;
+
+function Ada.Strings.Equal_Case_Insensitive
+  (Left, Right : String) return Boolean
+is
+   LI : Integer := Left'First;
+   RI : Integer := Right'First;
+
+begin
+   if Left'Length /= Right'Length then
+      return False;
+   end if;
+
+   if Left'Length = 0 then
+      return True;
+   end if;
+
+   loop
+      if To_Lower (Left (LI)) /= To_Lower (Right (RI)) then
+         return False;
+      end if;
+
+      if LI = Left'Last then
+         return True;
+      end if;
+
+      LI := LI + 1;
+      RI := RI + 1;
+   end loop;
+end Ada.Strings.Equal_Case_Insensitive;
+
+
+
+
+

gcc/ada/a-secain.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.STRINGS.EQUAL_CASE_INSENSITIVE                    --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+function Ada.Strings.Equal_Case_Insensitive
+  (Left, Right : String) return Boolean;
+
+pragma Pure (Ada.Strings.Equal_Case_Insensitive);
+

gcc/ada/a-sfztio.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--    A D A . S H O R T _ F L O A T _ W I D E _ W I D E _ T E X T _ I O     --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Short_Float_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Float_IO (Short_Float);

gcc/ada/a-shcain.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.STRINGS.HASH_CASE_INSENSITIVE                     --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Characters.Handling;  use Ada.Characters.Handling;
+
+--  Note: source of this algorithm: GNAT.HTable.Hash (g-htable.adb)
+
+function Ada.Strings.Hash_Case_Insensitive
+  (Key : String) return Containers.Hash_Type
+is
+   use Ada.Containers;
+
+   Tmp : Hash_Type;
+
+   function Rotate_Left
+     (Value  : Hash_Type;
+      Amount : Natural) return Hash_Type;
+   pragma Import (Intrinsic, Rotate_Left);
+
+begin
+   Tmp := 0;
+   for J in Key'Range loop
+      Tmp := Rotate_Left (Tmp, 1) + Character'Pos (To_Lower (Key (J)));
+   end loop;
+
+   return Tmp;
+end Ada.Strings.Hash_Case_Insensitive;
+
+
+
+
+
+
+
+
+

gcc/ada/a-shcain.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.STRINGS.HASH_CASE_INSENSITIVE                     --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Containers;
+
+function Ada.Strings.Hash_Case_Insensitive
+  (Key : String) return Containers.Hash_Type;
+
+pragma Pure (Ada.Strings.Hash_Case_Insensitive);

gcc/ada/a-siztio.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+--  A D A . S H O R T _ I N T E G E R _ W I D E _ W I D E _ T E X T _ I O   --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Short_Integer_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Integer_IO (Short_Integer);

gcc/ada/a-slcain.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.STRINGS.LESS_CASE_INSENSITIVE                     --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+with Ada.Characters.Handling;  use Ada.Characters.Handling;
+
+function Ada.Strings.Less_Case_Insensitive
+  (Left, Right : String) return Boolean
+is
+   LI : Integer := Left'First;
+   RI : Integer := Right'First;
+
+   LC, RC : Character;
+
+begin
+   if LI > Left'Last then
+      return RI <= Right'Last;
+   end if;
+
+   if RI > Right'Last then
+      return False;
+   end if;
+
+   loop
+      LC := To_Lower (Left (LI));
+      RC := To_Lower (Right (RI));
+
+      if LC < RC then
+         return True;
+      end if;
+
+      if LC > RC then
+         return False;
+      end if;
+
+      if LI = Left'Last then
+         return RI < Right'Last;
+      end if;
+
+      if RI = Right'Last then
+         return False;
+      end if;
+
+      LI := LI + 1;
+      RI := RI + 1;
+   end loop;
+end Ada.Strings.Less_Case_Insensitive;
+
+

gcc/ada/a-slcain.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                    ADA.STRINGS.LESS_CASE_INSENSITIVE                     --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+function Ada.Strings.Less_Case_Insensitive
+  (Left, Right : String) return Boolean;
+
+pragma Pure (Ada.Strings.Less_Case_Insensitive);

gcc/ada/a-ssizti.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT RUNTIME COMPONENTS                          --
+--                                                                          --
+-- A D A . S H O R T _ S H O R T _ I N T E G E R _ W I D E _ T E X T _ I O  --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Wide_Wide_Text_IO;
+
+package Ada.Short_Short_Integer_Wide_Wide_Text_IO is
+  new Ada.Wide_Wide_Text_IO.Integer_IO (Short_Short_Integer);

gcc/ada/a-strhas.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                             ADA.STRINGS.HASH                             --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+--  Note: source of this algorithm: GNAT.HTable.Hash (g-htable.adb)
+
+function Ada.Strings.Hash (Key : String) return Containers.Hash_Type is
+   use Ada.Containers;
+
+   function Rotate_Left
+     (Value  : Hash_Type;
+      Amount : Natural) return Hash_Type;
+   pragma Import (Intrinsic, Rotate_Left);
+
+   Tmp : Hash_Type;
+
+begin
+   Tmp := 0;
+   for J in Key'Range loop
+      Tmp := Rotate_Left (Tmp, 1) + Character'Pos (Key (J));
+   end loop;
+
+   return Tmp;
+end Ada.Strings.Hash;
+
+
+
+
+
+
+
+

gcc/ada/a-strhas.ads

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                             ADA.STRINGS.HASH                             --
+--                                                                          --
+--                                 S p e c                                  --
+--                                                                          --
+-- This specification is adapted from the Ada Reference Manual for use with --
+-- GNAT.  In accordance with the copyright of that document, you can freely --
+-- copy and modify this specification,  provided that if you redistribute a --
+-- modified version,  any changes that you have made are clearly indicated. --
+--                                                                          --
+------------------------------------------------------------------------------
+
+with Ada.Containers;
+
+function Ada.Strings.Hash (Key : String) return Containers.Hash_Type;
+
+pragma Pure (Ada.Strings.Hash);
+
+

gcc/ada/a-stunha.adb

+------------------------------------------------------------------------------
+--                                                                          --
+--                         GNAT LIBRARY COMPONENTS                          --
+--                                                                          --
+--                        ADA.STRINGS.UNBOUNDED.HASH                        --
+--                                                                          --
+--                                 B o d y                                  --
+--                                                                          --
+--             Copyright (C) 2004 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 2,  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.  See the GNU General Public License --
+-- for  more details.  You should have  received  a copy of the GNU General --
+-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
+-- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
+-- MA 02111-1307, USA.                                                      --
+--                                                                          --
+-- As a special exception,  if other files  instantiate  generics from this --
+-- unit, or you link  this unit with other files  to produce an executable, --
+-- this  unit  does not  by itself cause  the resulting  executable  to  be --
+-- covered  by the  GNU  General  Public  License.  This exception does not --
+-- however invalidate  any other reasons why  the executable file  might be --
+-- covered by the  GNU Public License.                                      --
+--                                                                          --
+-- This unit was originally developed by Matthew J Heaney.                  --
+------------------------------------------------------------------------------
+
+--  Note: source of this algorithm: GNAT.HTable.Hash (g-htable.adb)
+
+function Ada.Strings.Unbounded.Hash
+  (Key : Unbounded_String) return Containers.Hash_Type
+is
+   use Ada.Containers;
+
+   function Rotate_Left
+     (Value  : Hash_Type;
+      Amount : Natural) return Hash_Type;
+   pragma Import (Intrinsic, Rotate_Left);
+
+   Tmp : Hash_Type;
+
+begin
+   Tmp := 0;
+   for J in 1 .. Key.Last loop
+      Tmp := Rotate_Left (Tmp, 1) + Character'Pos (Key.Reference (J));
+   end loop;
+
+   return Tmp;
+end Ada.Strings.Unbounded.Hash;