obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 359 insertions, 0 deletions

diff --git a/gcc/testsuite/ada/acats/tests/cxa/cxa4014.a b/gcc/testsuite/ada/acats/tests/cxa/cxa4014.a
new file mode 100644
index 000000000..6e26a0330
--- /dev/null
+++ b/gcc/testsuite/ada/acats/tests/cxa/cxa4014.a
@@ -0,0 +1,359 @@
+-- CXA4014.A
+--
+--                             Grant of Unlimited Rights
+--
+--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
+--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained 
+--     unlimited rights in the software and documentation contained herein.
+--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making 
+--     this public release, the Government intends to confer upon all 
+--     recipients unlimited rights  equal to those held by the Government.  
+--     These rights include rights to use, duplicate, release or disclose the 
+--     released technical data and computer software in whole or in part, in 
+--     any manner and for any purpose whatsoever, and to have or permit others 
+--     to do so.
+--
+--                                    DISCLAIMER
+--
+--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
+--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED 
+--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
+--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE 
+--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
+--     PARTICULAR PURPOSE OF SAID MATERIAL.
+--*
+--
+-- OBJECTIVE:
+--      Check that the subprograms defined in package Ada.Strings.Wide_Fixed
+--      are available, and that they produce correct results.  Specifically, 
+--      check the subprograms Find_Token, Head, Index, Index_Non_Blank, Move,
+--      Overwrite, and Replace_Slice, Tail, and Translate. 
+--      Use the access-to-subprogram mapping version of Translate (function
+--      and procedure).
+--
+-- TEST DESCRIPTION:
+--      This test demonstrates how certain wide fixed string operations could
+--      be used in wide string information processing.  A procedure is defined
+--      that will extract portions of a 50 character string that correspond to
+--      certain data items (i.e., name, address, state, zip code). These
+--      parsed items will then be added to the appropriate fields of data
+--      base elements.  These data base elements are then compared for
+--      accuracy against a similar set of predefined data base
+--      elements.
+--      A variety of wide fixed string processing subprograms are used in this
+--      test.  Each parsing operation attempts to use a different combination
+--      of the available subprograms to accomplish the same goal, therefore
+--      continuity of approach to wide string parsing is not seen in this
+--      test.
+--      However, a wide variety of possible approaches are demonstrated, while
+--      exercising a large number of the total predefined subprograms of
+--      package Ada.Strings.Wide_Fixed.
+--      
+--       
+-- CHANGE HISTORY:
+--      06 Dec 94   SAIC    ACVC 2.0
+--      02 Nov 95   SAIC    Update and repair for ACVC 2.0.1.
+--
+--!
+
+package CXA40140 is
+
+   UnderScore  : Wide_Character := '_';
+   Blank       : Wide_Character := ' ';
+
+   -- Function providing a mapping to a blank Wide_Character.
+   function US_to_Blank_Map (From : Wide_Character) return Wide_Character;
+
+end CXA40140;
+
+package body CXA40140 is
+
+   function US_to_Blank_Map (From : Wide_Character) return Wide_Character is
+   begin
+      if From = UnderScore then
+         return Blank;
+      else
+         return From;
+      end if;
+   end US_to_Blank_Map;
+
+end CXA40140;
+
+
+with CXA40140;
+with Ada.Strings.Wide_Fixed;
+with Ada.Strings.Wide_Maps;
+with Report;
+
+procedure CXA4014 is
+   use CXA40140;
+begin
+
+   Report.Test ("CXA4014", "Check that the subprograms defined in package "  &
+                           "Ada.Strings.Wide_Fixed are available, and that " &
+                           "they produce correct results");
+
+   Test_Block:
+   declare
+
+      Number_Of_Info_Strings : constant Natural := 3;
+      DB_Size                : constant Natural := Number_Of_Info_Strings;
+      Count                  : Natural          := 0;
+      Finished_Processing    : Boolean          := False;
+      Blank_Wide_String      : constant Wide_String  := " ";
+
+      subtype Info_Wide_String_Type         is Wide_String (1..50);
+      type    Info_Wide_String_Storage_Type is 
+                array (1..Number_Of_Info_Strings) of Info_Wide_String_Type;
+
+
+      subtype Name_Type                is Wide_String (1..10);
+      subtype Street_Number_Type       is Wide_String (1..5);
+      subtype Street_Name_Type         is Wide_String (1..10);
+      subtype City_Type                is Wide_String (1..10);
+      subtype State_Type               is Wide_String (1..2);
+      subtype Zip_Code_Type            is Wide_String (1..5);
+
+      type Data_Base_Element_Type is
+         record
+            Name          : Name_Type          := (others => ' ');
+            Street_Number : Street_Number_Type := (others => ' ');
+            Street_Name   : Street_Name_Type   := (others => ' ');
+            City          : City_Type          := (others => ' ');
+            State         : State_Type         := (others => ' ');
+            Zip_Code      : Zip_Code_Type      := (others => ' ');
+         end record;
+
+      type Data_Base_Type is array (1..DB_Size) of Data_Base_Element_Type;
+
+      Data_Base : Data_Base_Type;
+
+      ---
+
+      Info_String_1 : Info_Wide_String_Type := 
+        "Joe_Jones 123   Sixth_St   San_Diego    CA   98765"; 
+
+      Info_String_2 : Info_Wide_String_Type := 
+        "Sam_Smith 56789  S._Seventh   Carlsbad  CA   92177";
+
+      Info_String_3 : Info_Wide_String_Type := 
+        "Jane_Brown 1219   Info_Lane  Tuscon     AZ   85643";
+
+
+      Info_Strings : Info_Wide_String_Storage_Type :=
+                       (1 => Info_String_1,
+                        2 => Info_String_2,
+                        3 => Info_String_3);
+
+
+
+      TC_DB_Element_1 : Data_Base_Element_Type := 
+        ("Joe Jones ", "123  ", "Sixth St  ", "San Diego ", "CA", "98765");
+
+      TC_DB_Element_2 : Data_Base_Element_Type := 
+        ("Sam Smith ", "56789", "S. Seventh", "Carlsbad  ", "CA", "92177");
+
+      TC_DB_Element_3 : Data_Base_Element_Type := 
+        ("Jane Brown", "1219 ", "Info Lane ", "Tuscon    ", "AZ", "85643");
+
+      TC_Data_Base : Data_Base_Type := (TC_DB_Element_1,
+                                        TC_DB_Element_2,
+                                        TC_DB_Element_3);
+
+      ---
+
+
+      procedure Store_Information 
+         (Info_String : in     Info_Wide_String_Type;
+          DB_Record   : in out Data_Base_Element_Type) is
+
+         package  AS renames Ada.Strings;
+         use type AS.Wide_Maps.Wide_Character_Set;
+
+         Start,
+         Stop        : Natural := 0;
+
+         Numeric_Set    : constant AS.Wide_Maps.Wide_Character_Set :=
+                            AS.Wide_Maps.To_Set("0123456789");
+
+         Cal            : constant 
+                            AS.Wide_Maps.Wide_Character_Sequence := "CA";
+         California_Set : constant AS.Wide_Maps.Wide_Character_Set := 
+                            AS.Wide_Maps.To_Set(Cal);
+         Arizona_Set    : constant AS.Wide_Maps.Wide_Character_Set := 
+                            AS.Wide_Maps.To_Set("AZ");
+         Nevada_Set     : constant AS.Wide_Maps.Wide_Character_Set := 
+                            AS.Wide_Maps.To_Set("NV");
+
+         Blank_Ftn_Ptr : AS.Wide_Maps.Wide_Character_Mapping_Function :=
+                           US_to_Blank_Map'Access;
+
+      begin
+
+         -- Find the starting position of the name field (first non-blank),
+         -- then, from that position, find the end of the name field (first
+         -- blank).
+
+         Start := AS.Wide_Fixed.Index_Non_Blank(Info_String); 
+         Stop  := AS.Wide_Fixed.Index (Info_String(Start..Info_String'Length),
+                                       AS.Wide_Maps.To_Set(Blank),
+                                       AS.Inside,
+                                       AS.Forward) - 1 ;
+
+         -- Store the name field in the data base element field for "Name".
+
+         DB_Record.Name := AS.Wide_Fixed.Head(Info_String(1..Stop), 
+                                         DB_Record.Name'Length);
+
+         -- Replace any underscore characters in the name field
+         -- that were used to separate first/middle/last names.
+         -- Use the overloaded version of Translate that takes an
+         -- access-to-subprogram value.
+
+         AS.Wide_Fixed.Translate (DB_Record.Name, Blank_Ftn_Ptr);
+
+         
+         -- Continue the extraction process; now find the position of
+         -- the street number in the string.
+
+         Start := Stop + 1;
+
+         AS.Wide_Fixed.Find_Token(Info_String(Start..Info_String'Length),
+                                  Numeric_Set,
+                                  AS.Inside,
+                                  Start,
+                                  Stop);
+
+         -- Store the street number field in the appropriate data base 
+         -- element.
+         -- No modification of the default parameters of procedure Move
+         -- is required.
+
+         AS.Wide_Fixed.Move(Source => Info_String(Start..Stop),
+                            Target => DB_Record.Street_Number);
+
+
+         -- Continue the extraction process; find the street name in the
+         -- info string.  Skip blanks to the start of the street name, then
+         -- search for the index of the next blank character in the string.
+
+         Start := AS.Wide_Fixed.Index_Non_Blank
+                                  (Info_String(Stop+1..Info_String'Length)); 
+
+         Stop := 
+           AS.Wide_Fixed.Index(Info_String(Start..Info_String'Length),
+                               Blank_Wide_String) - 1; 
+
+         -- Store the street name in the appropriate data base element field.
+
+         AS.Wide_Fixed.Overwrite(DB_Record.Street_Name, 
+                                 1, 
+                                 Info_String(Start..Stop));
+                           
+         -- Replace any underscore characters in the street name field
+         -- that were used as word separation with blanks.  Again, use the 
+         -- access-to-subprogram value to provide the mapping.
+         
+         DB_Record.Street_Name := 
+           AS.Wide_Fixed.Translate(DB_Record.Street_Name, 
+                                   Blank_Ftn_Ptr);
+
+
+         -- Continue the extraction; remove the city name from the string.
+
+         Start := AS.Wide_Fixed.Index_Non_Blank
+                                  (Info_String(Stop+1..Info_String'Length)); 
+
+         Stop := 
+           AS.Wide_Fixed.Index(Info_String(Start..Info_String'Length), 
+                               Blank_Wide_String) - 1; 
+
+         -- Store the city name field in the appropriate data base element.
+
+         AS.Wide_Fixed.Replace_Slice(DB_Record.City, 
+                                     1,
+                                     DB_Record.City'Length,
+                                     Info_String(Start..Stop));
+                           
+         -- Replace any underscore characters in the city name field
+         -- that were used as word separation.
+         
+         AS.Wide_Fixed.Translate (DB_Record.City, 
+                                  Blank_Ftn_Ptr);
+
+
+         -- Continue the extraction; remove the state identifier from the 
+         -- info string.
+
+         Start := Stop + 1;
+
+         AS.Wide_Fixed.Find_Token(Info_String(Start..Info_String'Length),
+                                  AS.Wide_Maps."OR"(California_Set,
+                                    AS.Wide_Maps."OR"(Nevada_Set,
+                                                      Arizona_Set)),
+                                  AS.Inside,
+                                  Start,
+                                  Stop);
+
+         -- Store the state indicator into the data base element.
+
+         AS.Wide_Fixed.Move(Source  => Info_String(Start..Stop),
+                            Target  => DB_Record.State,
+                            Drop    => Ada.Strings.Right,
+                            Justify => Ada.Strings.Left,
+                            Pad     => AS.Wide_Space);
+
+
+         -- Continue the extraction process; remove the final data item in 
+         -- the info string, the zip code, and place it into the 
+         -- corresponding data base element.
+
+         DB_Record.Zip_Code := 
+           AS.Wide_Fixed.Tail(Info_String, DB_Record.Zip_Code'Length);
+
+      exception 
+         when AS.Length_Error      =>
+            Report.Failed ("Length_Error raised in procedure");
+         when AS.Pattern_Error     =>
+            Report.Failed ("Pattern_Error raised in procedure");
+         when AS.Translation_Error =>
+            Report.Failed ("Translation_Error raised in procedure");
+         when others            =>
+            Report.Failed ("Exception raised in procedure");
+      end Store_Information;
+
+
+   begin
+
+      -- Loop thru the information strings, extract the name and address
+      -- information, place this info into elements of the data base.
+
+      while not Finished_Processing loop
+
+         Count := Count + 1;
+
+         Store_Information (Info_Strings(Count), Data_Base(Count));
+
+         Finished_Processing := (Count = Number_Of_Info_Strings);
+
+      end loop;
+
+
+      -- Verify that the string processing was successful.
+
+      for i in 1..DB_Size loop
+         if Data_Base(i) /= TC_Data_Base(i) then
+            Report.Failed 
+              ("Data processing error on record " & Integer'Image(i));
+         end if;
+      end loop;
+
+
+   exception
+      when others => Report.Failed ("Exception raised in Test_Block");
+   end Test_Block;
+
+
+   Report.Result;
+
+end CXA4014;