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, 585 insertions, 0 deletions

diff --git a/gcc/testsuite/ada/acats/tests/cxa/cxa4023.a b/gcc/testsuite/ada/acats/tests/cxa/cxa4023.a
new file mode 100644
index 000000000..d0325fc88
--- /dev/null
+++ b/gcc/testsuite/ada/acats/tests/cxa/cxa4023.a
@@ -0,0 +1,585 @@
+-- CXA4023.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_Unbounded are available, and that they produce 
+--      correct results. Specifically, check the subprograms Delete, 
+--      Find_Token, Translate, Trim, and "*".
+--      
+-- TEST DESCRIPTION:
+--      This test demonstrates the uses of many of the subprograms defined
+--      in package Ada.Strings.Wide_Unbounded for use with unbounded wide 
+--      strings.  The test simulates how unbounded wide strings 
+--      will be processed in a user environment, using the subprograms 
+--      provided in this package.
+--
+--      This test, when taken in conjunction with tests CXA4021-22, will 
+--      constitute a test of the functionality contained in package
+--      Ada.Strings.Wide_Unbounded.  This test uses a variety
+--      of the subprograms defined in the unbounded wide string package
+--      in ways typical of common usage, with different combinations of
+--      available subprograms being used to accomplish similar 
+--      unbounded wide string processing goals.
+--
+--       
+-- CHANGE HISTORY:
+--      06 Dec 94   SAIC    ACVC 2.0
+--      08 Nov 95   SAIC    Corrected accessibility level and type 
+--                          visibility problems for ACVC 2.0.1.
+--
+--!
+
+with Ada.Characters.Handling;
+with Ada.Strings;
+
+package CXA40230 is
+
+   -- The following two functions are used to translate character and string
+   -- values to non-character "Wide" values.  They will be applied to all the
+   -- Wide_Bounded subprogram character and string parameters to simulate the
+   -- use of Wide_Characters and Wide_Strings in actual practice.
+   -- Note: These functions do not actually return "equivalent" wide
+   --       characters to their character inputs, just "non-character"
+   --       wide characters.
+
+   function Equiv (Ch : Character) return Wide_Character;
+
+   function Equiv (Str : String) return Wide_String;
+
+   -- Functions and access-to-subprogram object used to supply mapping
+   -- capability to the appropriate versions of Translate.
+
+   function AB_to_US_Mapping_Function (From : Wide_Character) 
+     return Wide_Character;
+
+   function AB_to_Blank_Mapping_Function (From : Wide_Character) 
+     return Wide_Character;
+
+end CXA40230;
+
+
+package body CXA40230 is
+
+   function Equiv (Ch : Character) return Wide_Character is
+      C : Character := Ch;
+   begin
+      if Ch = ' ' then
+         return Ada.Characters.Handling.To_Wide_Character(C);
+      else
+         return Wide_Character'Val(Character'Pos(Ch) + 
+                Character'Pos(Character'Last) + 1);
+      end if;
+   end Equiv;
+
+
+   function Equiv (Str : String) return Wide_String is
+      WS : Wide_String(Str'First..Str'Last);
+   begin
+      for i in Str'First..Str'Last loop
+         WS(i) := Equiv(Str(i));
+      end loop;
+      return WS;
+   end Equiv;
+
+
+   function AB_to_US_Mapping_Function (From : Wide_Character) 
+     return Wide_Character is
+      UnderScore : constant Wide_Character := Equiv('_');
+   begin
+      if From = Equiv('a')  or  From = Equiv('b')  then
+         return UnderScore;
+      else
+         return From;
+      end if;
+   end AB_to_US_Mapping_Function;
+
+
+   function AB_to_Blank_Mapping_Function (From : Wide_Character) 
+     return Wide_Character is
+   begin
+      if From = Equiv('a')  or  From = Equiv('b') then
+         return Ada.Strings.Wide_Space;
+      else
+         return From;
+      end if;
+   end AB_to_Blank_Mapping_Function;
+
+end CXA40230;
+
+
+with CXA40230;
+with Report;
+with Ada.Characters.Handling;
+with Ada.Strings.Wide_Maps;
+with Ada.Strings.Wide_Unbounded;
+
+procedure CXA4023 is
+begin
+
+   Report.Test ("CXA4023", "Check that the subprograms defined in "    &
+                           "package Ada.Strings.Wide_Unbounded are "   &
+                           "available, and that they produce correct " &
+                           "results");
+
+   Test_Block:
+   declare
+
+      use CXA40230;
+
+      package ASW renames Ada.Strings.Wide_Unbounded;
+      use Ada.Strings;
+      use type Wide_Maps.Wide_Character_Set;
+      use type ASW.Unbounded_Wide_String;
+
+      Test_String   : ASW.Unbounded_Wide_String;
+      AtoE_Str      : ASW.Unbounded_Wide_String :=
+                        ASW.To_Unbounded_Wide_String(Equiv("abcde"));
+
+      Cad_String    : ASW.Unbounded_Wide_String := 
+                        ASW.To_Unbounded_Wide_String(Equiv("cad"));
+
+      Magic_String  : ASW.Unbounded_Wide_String := 
+                        ASW.To_Unbounded_Wide_String(Equiv("abracadabra"));
+
+      Incantation   : ASW.Unbounded_Wide_String := Magic_String;
+
+
+      A_Small_G : Wide_Character := Equiv('g');
+      
+      ABCD_Set  : Wide_Maps.Wide_Character_Set := 
+                    Wide_Maps.To_Set(Equiv("abcd"));
+      B_Set     : Wide_Maps.Wide_Character_Set := 
+                    Wide_Maps.To_Set(Equiv('b'));
+      AB_Set    : Wide_Maps.Wide_Character_Set := 
+                    Wide_Maps."OR"(Wide_Maps.To_Set(Equiv('a')), B_Set);
+
+
+      AB_to_YZ_Map     : Wide_Maps.Wide_Character_Mapping := 
+                           Wide_Maps.To_Mapping(From => Equiv("ab"), 
+                                                To   => Equiv("yz"));
+      Code_Map         : Wide_Maps.Wide_Character_Mapping := 
+                           Wide_Maps.To_Mapping(Equiv("abcd"), Equiv("wxyz"));
+      Reverse_Code_Map : Wide_Maps.Wide_Character_Mapping :=
+                           Wide_Maps.To_Mapping(Equiv("wxyz"), Equiv("abcd"));
+      Non_Existent_Map : Wide_Maps.Wide_Character_Mapping :=
+                           Wide_Maps.To_Mapping(Equiv("jkl"), Equiv("mno"));
+
+
+      Token_Start      : Positive;
+      Token_End        : Natural := 0;
+
+      Map_Ptr  : Wide_Maps.Wide_Character_Mapping_Function :=
+                   AB_to_US_Mapping_Function'Access;
+
+
+   begin
+
+      -- Find_Token
+
+      ASW.Find_Token(Magic_String,      -- Find location of first "ab" equiv.
+                     AB_Set,            -- Should be (1..2).
+                     Ada.Strings.Inside,
+                     Token_Start,
+                     Token_End);
+
+      if Natural(Token_Start) /= ASW.To_Wide_String(Magic_String)'First  or
+         Token_End            /= ASW.Index(Magic_String, B_Set)          or
+         Token_End            /= 2
+      then 
+         Report.Failed("Incorrect result from Procedure Find_Token - 1");
+      end if;
+
+
+      ASW.Find_Token(Source => Magic_String, -- Find location of char 'r'equiv
+                     Set    => ABCD_Set,     -- in wide str, should be (3..3)
+                     Test   => Ada.Strings.Outside,
+                     First  => Token_Start,
+                     Last   => Token_End);
+
+      if Natural(Token_Start) /= 3  or  Token_End /= 3 then
+         Report.Failed("Incorrect result from Procedure Find_Token - 2");
+      end if;
+
+
+      ASW.Find_Token(Magic_String,                -- No 'g' "equivalent in 
+                     Wide_Maps.To_Set(A_Small_G), -- the wide str, so the
+                     Ada.Strings.Inside,          -- result params should be 
+                     First => Token_Start,        -- First = Source'First and
+                     Last  => Token_End);         -- Last = 0.
+
+
+      if Token_Start /= ASW.To_Wide_String(Magic_String)'First  or
+         Token_End   /= 0
+      then
+         Report.Failed("Incorrect result from Procedure Find_Token - 3");
+      end if;
+ 
+
+      ASW.Find_Token(ASW.To_Unbounded_Wide_String(Equiv("abpqpqrttrcpqr")),
+                     Wide_Maps.To_Set(Equiv("trpq")),
+                     Ada.Strings.Inside,
+                     Token_Start,
+                     Token_End);
+
+      if Token_Start /= 3 or
+         Token_End   /= 10
+      then
+         Report.Failed("Incorrect result from Procedure Find_Token - 4");
+      end if;
+
+      ASW.Find_Token(ASW.To_Unbounded_Wide_String(Equiv("abpqpqrttrcpqr")),
+                     Wide_Maps.To_Set(Equiv("abpq")),
+                     Ada.Strings.Outside,
+                     Token_Start,
+                     Token_End);
+
+      if Token_Start /= 7 or
+         Token_End   /= 11
+      then
+         Report.Failed("Incorrect result from Procedure Find_Token - 5");
+      end if;
+
+
+
+      -- Translate
+
+      -- Use a mapping ("abcd" -> "wxyz") to transform the contents of 
+      -- the unbounded wide string.
+      -- Magic_String = "abracadabra"
+
+      Incantation := ASW.Translate(Magic_String, Code_Map); 
+
+      if Incantation /= 
+         ASW.To_Unbounded_Wide_String(Equiv("wxrwywzwxrw")) 
+      then
+         Report.Failed("Incorrect result from Function Translate - 1");
+      end if;
+
+      -- (Note: See below for additional testing of Function Translate)
+
+      -- Use the inverse mapping of the one above to return the "translated"
+      -- unbounded wide string to its original form.
+
+      ASW.Translate(Incantation, Reverse_Code_Map);
+
+      -- The map contained in the following call to Translate contains three
+      -- elements, and these elements are not found in the unbounded wide
+      -- string, so this call to Translate should have no effect on it.
+
+      if Incantation /= ASW.Translate(Magic_String, Non_Existent_Map) then
+         Report.Failed("Incorrect result from Procedure Translate - 1");
+      end if;
+
+      -- Partial mapping of source.
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("abcdeabcab"));
+
+      ASW.Translate(Source => Test_String, Mapping => AB_to_YZ_Map);
+
+      if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("yzcdeyzcyz")) then
+         Report.Failed("Incorrect result from Procedure Translate - 2");
+      end if;
+
+      -- Total mapping of source.
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("abbaaababb"));
+
+      ASW.Translate(Source => Test_String, Mapping => AB_to_YZ_Map);
+
+      if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("yzzyyyzyzz")) then
+         Report.Failed("Incorrect result from Procedure Translate - 3");
+      end if;
+
+      -- No mapping of source.
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc"));
+
+      ASW.Translate(Source => Test_String, Mapping => AB_to_YZ_Map);
+
+      if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc")) then
+         Report.Failed("Incorrect result from Procedure Translate - 4");
+      end if;
+
+      -- Map > 2 characters, partial mapping.
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("opabcdelmn"));
+
+      ASW.Translate(Test_String, 
+                    Wide_Maps.To_Mapping(Equiv("abcde"), Equiv("lmnop")));
+
+      if Test_String /= ASW.To_Unbounded_Wide_String(Equiv("oplmnoplmn")) then
+         Report.Failed("Incorrect result from Procedure Translate - 5");
+      end if;
+
+
+
+      -- Various degrees of mapping of source (full, partial, none) used 
+      -- with Function Translate.
+
+      if ASW.Translate(
+               ASW.To_Unbounded_Wide_String(Equiv("abcdeabcabbbaaacaa")), 
+                       AB_to_YZ_Map)                               /= 
+         ASW.To_Unbounded_Wide_String(Equiv("yzcdeyzcyzzzyyycyy"))   or
+
+         ASW.Translate(
+               ASW.To_Unbounded_Wide_String(Equiv("abbaaababbaaaaba")), 
+                       AB_to_YZ_Map)                               /= 
+         ASW.To_Unbounded_Wide_String(Equiv("yzzyyyzyzzyyyyzy"))     or
+
+         ASW.Translate(ASW.To_Unbounded_Wide_String(Equiv("cABcABBAc")),
+                       Mapping => AB_to_YZ_Map)                    /= 
+         ASW.To_Unbounded_Wide_String(Equiv("cABcABBAc"))            or
+
+         ASW.Translate(ASW.To_Unbounded_Wide_String("opabcdelmnddeaccabec"),
+                       Wide_Maps.To_Mapping("abcde", "lmnop"))     /=
+         ASW.To_Unbounded_Wide_String("oplmnoplmnooplnnlmpn") 
+      then
+         Report.Failed("Incorrect result from Function Translate - 2");
+      end if;
+
+
+
+      -- Procedure Translate using access-to-subprogram mapping.
+      -- Partial mapping of source.
+
+      Map_Ptr := AB_to_Blank_Mapping_Function'Access;
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("abABaABbaBAbba"));
+
+      ASW.Translate(Source  => Test_String, -- change equivalent of 'a' and
+                    Mapping => Map_Ptr);    -- 'b' to ' '
+
+      if Test_String /= 
+         ASW.To_Unbounded_Wide_String(Equiv("  AB AB  BA   ")) 
+      then
+         Report.Failed
+           ("Incorrect result from Proc Translate, w/ access value map - 1");
+      end if;
+
+      -- Total mapping of source to blanks.
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("abbbab"));
+
+      ASW.Translate(Source  => Test_String, 
+                    Mapping => Map_Ptr);
+
+      if Test_String /= 
+         ASW.To_Unbounded_Wide_String(Equiv("      ")) 
+      then
+         Report.Failed
+           ("Incorrect result from Proc Translate, w/ access value map - 2");
+      end if;
+
+      -- No mapping of source.
+
+      Map_Ptr := AB_to_US_Mapping_Function'Access;
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc"));
+
+      ASW.Translate(Source  => Test_String, 
+                    Mapping => Map_Ptr);
+
+      if Test_String /= 
+         ASW.To_Unbounded_Wide_String(Equiv("xyzsypcc"))   -- no change
+      then
+         Report.Failed
+           ("Incorrect result from Proc Translate, w/ access value map - 3");
+      end if;
+
+
+      -- Function Translate using access-to-subprogram mapping value.
+
+      Map_Ptr  := AB_to_Blank_Mapping_Function'Access;
+
+      Test_String := ASW.To_Unbounded_Wide_String(Equiv("abAbBBAabbacD"));
+
+      if ASW.Translate(ASW.Translate(Test_String, Map_Ptr), Map_Ptr)  /=
+         ASW.To_Unbounded_Wide_String(Equiv("  A BBA    cD")) 
+      then
+         Report.Failed
+           ("Incorrect result from Function Translate, access value map - 1");
+      end if;
+
+      if ASW.Translate(Source  => ASW.To_Unbounded_Wide_String(Equiv("a")), 
+                       Mapping => Map_Ptr)                            /= 
+         ASW.To_Unbounded_Wide_String(Equiv(" "))                       or
+         ASW.Translate(ASW.To_Unbounded_Wide_String
+                         (Equiv(" aa Aa A AAaaa a   aA")),
+                       Map_Ptr)                                       /=
+         ASW.To_Unbounded_Wide_String(Equiv("    A  A AA         A"))   or
+         ASW.Translate(Source  => ASW.To_Unbounded_Wide_String(Equiv("a ")), 
+                       Mapping => Map_Ptr)                            /= 
+         ASW.To_Unbounded_Wide_String(Equiv("  "))                      or
+         ASW.Translate(Source  => ASW.To_Unbounded_Wide_String(Equiv("xyz")),
+                       Mapping => Map_Ptr)                            /= 
+         ASW.To_Unbounded_Wide_String(Equiv("xyz"))
+      then
+         Report.Failed
+           ("Incorrect result from Function Translate, access value map - 2");
+      end if;
+
+
+
+      -- Trim
+
+      Trim_Block:
+      declare
+
+         XYZ_Set     : Wide_Maps.Wide_Character_Set :=
+                         Wide_Maps.To_Set(Equiv("xyz"));
+         PQR_Set     : Wide_Maps.Wide_Character_Set := 
+                         Wide_Maps.To_Set(Equiv("pqr"));
+
+         Pad         : constant ASW.Unbounded_Wide_String := 
+                                 ASW.To_Unbounded_Wide_String(Equiv("Pad"));
+
+         The_New_Ada : constant ASW.Unbounded_Wide_String :=
+                                 ASW.To_Unbounded_Wide_String(Equiv("Ada9X"));
+
+         Space_Array : array (1..4) of ASW.Unbounded_Wide_String :=
+                         (ASW.To_Unbounded_Wide_String(Equiv("  Pad    ")),
+                          ASW.To_Unbounded_Wide_String(Equiv("Pad   ")),
+                          ASW.To_Unbounded_Wide_String(Equiv("     Pad")),
+                          Pad);
+
+         String_Array : array (1..5) of ASW.Unbounded_Wide_String := 
+                        (ASW.To_Unbounded_Wide_String(Equiv("xyzxAda9Xpqr")),
+                         ASW.To_Unbounded_Wide_String(Equiv("Ada9Xqqrp")),
+                         ASW.To_Unbounded_Wide_String(Equiv("zxyxAda9Xqpqr")),
+                         ASW.To_Unbounded_Wide_String(Equiv("xxxyAda9X")),
+                         The_New_Ada);
+           
+      begin
+
+         -- Examine the version of Trim that removes blanks from
+         -- the left and/or right of a wide string.
+
+         for i in 1..4 loop
+            if ASW.Trim(Space_Array(i), Ada.Strings.Both) /= Pad then
+               Report.Failed("Incorrect result from Trim for spaces - " &
+                             Integer'Image(i));
+            end if;
+         end loop;   
+
+         -- Examine the version of Trim that removes set characters from
+         -- the left and right of a wide string.
+
+         for i in 1..5 loop
+            if ASW.Trim(String_Array(i),
+                        Left   => XYZ_Set,
+                        Right  => PQR_Set) /= The_New_Ada then
+               Report.Failed
+                 ("Incorrect result from Trim for set characters - " &
+                  Integer'Image(i));
+            end if;
+         end loop;   
+
+         -- No trimming.
+
+         if ASW.Trim(
+              ASW.To_Unbounded_Wide_String(Equiv("prqqprAda9Xyzzxyzzyz")),
+                     XYZ_Set,
+                     PQR_Set)  /=
+            ASW.To_Unbounded_Wide_String(Equiv("prqqprAda9Xyzzxyzzyz"))
+         then
+            Report.Failed
+              ("Incorrect result from Trim for set, no trimming");
+         end if;
+
+      end Trim_Block;
+
+
+
+      -- Delete
+
+      -- Use the Delete function to remove the first four and last four
+      -- characters from the wide string.
+
+      if ASW.Delete(Source  => ASW.Delete(Magic_String,
+                                          8,
+                                          ASW.Length(Magic_String)),
+                    From    => ASW.To_Wide_String(Magic_String)'First,
+                    Through => 4)   /= 
+         Cad_String
+      then
+         Report.Failed("Incorrect results from Function Delete");
+      end if;
+
+
+
+      -- Constructors ("*")
+
+      Constructor_Block:
+      declare
+      
+         SOS      : ASW.Unbounded_Wide_String;
+
+         Dot      : constant ASW.Unbounded_Wide_String := 
+                               ASW.To_Unbounded_Wide_String(Equiv("Dot_"));
+         Dash     : constant Wide_String := Equiv("Dash_");
+
+         Distress : ASW.Unbounded_Wide_String := 
+                      ASW."&"(ASW.To_Unbounded_Wide_String
+                                (Equiv("Dot_Dot_Dot_")),
+                              ASW."&"(ASW.To_Unbounded_Wide_String
+                                        (Equiv("Dash_Dash_Dash_")), 
+                                      ASW.To_Unbounded_Wide_String
+                                        (Equiv("Dot_Dot_Dot"))));
+                      
+         Repeat        : constant Natural        := 3;
+         Separator     : constant Wide_Character := Equiv('_');
+
+         Separator_Set : Wide_Maps.Wide_Character_Set := 
+                           Wide_Maps.To_Set(Separator);
+
+      begin
+
+         -- Use the following constructor forms to construct the wide string
+         -- "Dot_Dot_Dot_Dash_Dash_Dash_Dot_Dot_Dot".  Note that the 
+         -- trailing underscore in the wide string is removed in the call to 
+         -- Trim in the If statement condition.
+
+         SOS := ASW."*"(Repeat, Dot);                   -- "*"(#, W Unb Str)
+
+         SOS := ASW."&"(SOS,
+                        ASW."&"(ASW."*"(Repeat, Dash),  -- "*"(#, W Str)
+                                ASW."*"(Repeat, Dot))); -- "*"(#, W Unb Str)
+
+         if ASW.Trim(SOS, Wide_Maps.Null_Set, Separator_Set) /= Distress then
+            Report.Failed("Incorrect results from Function ""*""");
+         end if;
+
+      end Constructor_Block;
+      
+
+   exception
+      when others => Report.Failed ("Exception raised in Test_Block");
+   end Test_Block;
+
+
+   Report.Result;
+
+end CXA4023;