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

diff --git a/gcc/testsuite/ada/acats/tests/cxa/cxa4015.a b/gcc/testsuite/ada/acats/tests/cxa/cxa4015.a
new file mode 100644
index 000000000..83fad3af8
--- /dev/null
+++ b/gcc/testsuite/ada/acats/tests/cxa/cxa4015.a
@@ -0,0 +1,580 @@
+-- CXA4015.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 Count, Find_Token, Index, Index_Non_Blank, and
+--      Move.
+--      
+-- TEST DESCRIPTION:
+--      This test, when combined with tests CXA4013,14,16 will provide 
+--      coverage of the functionality found in Ada.Strings.Wide_Fixed.  
+--      This test contains many small, specific test cases, situations that 
+--      although common in user environments, are often difficult to generate 
+--      in large numbers in a application-based test.
+--
+--       
+-- CHANGE HISTORY:
+--      06 Dec 94   SAIC    ACVC 2.0
+--      02 Nov 95   SAIC    Corrected various accesssibility problems and
+--                          expected result strings for ACVC 2.0.1.
+--
+--!
+
+package CXA40150 is
+
+   -- Wide Character mapping function defined for use with specific 
+   -- versions of functions Index and Count.
+
+   function AK_to_ZQ_Mapping (From : Wide_Character) return Wide_Character;
+
+end CXA40150;
+
+package body CXA40150 is
+
+   function AK_to_ZQ_Mapping (From : Wide_Character) 
+     return Wide_Character is
+   begin
+      if From = 'a' then
+         return 'z';
+      elsif From = 'k' then
+         return 'q';
+      else
+         return From;
+      end if;
+   end AK_to_ZQ_Mapping;
+
+end CXA40150;
+
+
+with CXA40150;
+with Report;
+with Ada.Strings;
+with Ada.Strings.Wide_Fixed;
+with Ada.Strings.Wide_Maps;
+
+procedure CXA4015 is
+begin
+
+   Report.Test("CXA4015", "Check that the subprograms defined in "         &
+                          "package Ada.Strings.Wide_Fixed are available, " &
+                          "and that they produce correct results");
+
+
+   Test_Block:
+   declare
+
+      use CXA40150;
+
+      package ASF  renames Ada.Strings.Wide_Fixed;
+      package Maps renames Ada.Strings.Wide_Maps;
+
+      Result_String  : Wide_String(1..10) := 
+                          (others => Ada.Strings.Wide_Space);
+
+      Source_String1 : Wide_String(1..5)  := "abcde";  -- odd len Wide_String
+      Source_String2 : Wide_String(1..6)  := "abcdef"; -- even len Wide_String
+      Source_String3 : Wide_String(1..12) := "abcdefghijkl";   
+      Source_String4 : Wide_String(1..12) := "abcdefghij  "; -- last 2 ch pad
+      Source_String5 : Wide_String(1..12) := "  cdefghijkl"; -- first 2 ch pad
+      Source_String6 : Wide_String(1..12) := "abcdefabcdef";   
+      
+      Location       : Natural := 0;
+      Slice_Start    : Positive;
+      Slice_End,
+      Slice_Count    : Natural := 0;
+
+      CD_Set         : Maps.Wide_Character_Set := Maps.To_Set("cd");  
+      ABCD_Set       : Maps.Wide_Character_Set := Maps.To_Set("abcd");
+      A_to_F_Set     : Maps.Wide_Character_Set := Maps.To_Set("abcdef");
+                  
+      CD_to_XY_Map   : Maps.Wide_Character_Mapping :=
+                         Maps.To_Mapping(From => "cd",  To => "xy");
+
+
+      -- Access-to-Subprogram object defined for use with specific versions of 
+      -- functions Index and Count.
+      
+      Map_Ptr : Maps.Wide_Character_Mapping_Function := 
+                  AK_to_ZQ_Mapping'Access;
+
+
+   begin
+
+
+      -- Procedure Move
+      -- Evaluate the Procedure Move with various combinations of
+      -- parameters.
+
+      -- Justify = Left (default case)
+
+      ASF.Move(Source => Source_String1,       -- "abcde"
+               Target => Result_String);
+      
+      if Result_String /= "abcde     " then
+         Report.Failed("Incorrect result from Move with Justify = Left");
+      end if;
+ 
+      -- Justify = Right
+ 
+      ASF.Move(Source  => Source_String2,      -- "abcdef"
+               Target  => Result_String,
+               Drop    => Ada.Strings.Error,
+               Justify => Ada.Strings.Right);
+
+      if Result_String /= "    abcdef" then
+         Report.Failed("Incorrect result from Move with Justify = Right");
+      end if;
+
+      -- Justify = Center (two cases, odd and even pad lengths)
+ 
+      ASF.Move(Source_String1,                 -- "abcde"
+               Result_String,
+               Ada.Strings.Error,
+               Ada.Strings.Center,
+               'x');                           -- non-default padding.
+
+      if Result_String /= "xxabcdexxx" then  -- Unequal padding added right
+         Report.Failed("Incorrect result from Move with Justify = Center-1");
+      end if;
+
+      ASF.Move(Source_String2,                 -- "abcdef"
+               Result_String,
+               Ada.Strings.Error,
+               Ada.Strings.Center);
+
+      if Result_String /= "  abcdef  " then  -- Equal padding added on L/R.
+         Report.Failed("Incorrect result from Move with Justify = Center-2");
+      end if;
+
+      -- When the source Wide_String is longer than the target Wide_String,
+      -- several cases can be examined, with the results depending on the 
+      -- value of the Drop parameter.
+
+      -- Drop = Left
+
+      ASF.Move(Source => Source_String3,       -- "abcdefghijkl"
+               Target => Result_String,
+               Drop   => Ada.Strings.Left);
+
+      if Result_String /= "cdefghijkl" then
+         Report.Failed("Incorrect result from Move with Drop = Left");
+      end if;
+
+      -- Drop = Right
+     
+      ASF.Move(Source_String3, Result_String, Ada.Strings.Right);
+
+      if Result_String /= "abcdefghij" then
+         Report.Failed("Incorrect result from Move with Drop = Right");
+      end if;
+
+      -- Drop = Error
+      -- The effect in this case depends on the value of the justify
+      -- parameter, and on whether any characters in Source other than 
+      -- Pad would fail to be copied.
+
+      -- Drop = Error, Justify = Left, right overflow characters are pad.
+
+      ASF.Move(Source  => Source_String4,      -- "abcdefghij  "
+               Target  => Result_String,
+               Drop    => Ada.Strings.Error,
+               Justify => Ada.Strings.Left);
+
+      if not(Result_String = "abcdefghij") then  -- leftmost 10 characters
+          Report.Failed("Incorrect result from Move with Drop = Error - 1");
+      end if;
+
+      -- Drop = Error, Justify = Right, left overflow characters are pad.
+
+      ASF.Move(Source_String5,                 -- "  cdefghijkl"
+               Result_String, 
+               Ada.Strings.Error, 
+               Ada.Strings.Right);
+
+      if Result_String /= "cdefghijkl" then  -- rightmost 10 characters
+         Report.Failed("Incorrect result from Move with Drop = Error - 2");
+      end if;
+
+      -- In other cases of Drop=Error, Length_Error is propagated, such as:
+
+      begin
+
+         ASF.Move(Source_String3,     -- 12 characters, no Pad.
+                  Result_String,      -- 10 characters
+                  Ada.Strings.Error,  
+                  Ada.Strings.Left);  
+
+         Report.Failed("Length_Error not raised by Move - 1");
+
+      exception
+         when Ada.Strings.Length_Error => null;   -- OK
+         when others => 
+            Report.Failed("Incorrect exception raised by Move - 1");
+      end;
+
+
+
+      -- Function Index
+      -- (Other usage examples of this function found in CXA4013-14.)
+      -- Check when the pattern is not found in the source.
+
+      if ASF.Index("abcdef", "gh")       /= 0 or
+         ASF.Index("abcde",  "abcdef")   /= 0 or  -- pattern > source
+         ASF.Index("xyz", 
+                   "abcde", 
+                   Ada.Strings.Backward) /= 0 or
+         ASF.Index("",      "ab")        /= 0 or  -- null source Wide_String.
+         ASF.Index("abcde", "  ")        /= 0     -- blank pattern.
+      then
+         Report.Failed("Incorrect result from Index, no pattern match");
+      end if;
+
+      -- Check that Pattern_Error is raised when the pattern is the 
+      -- null Wide_String.
+      begin
+         Location := ASF.Index(Source_String6,    -- "abcdefabcdef"
+                               "",                -- null pattern Wide_String.
+                               Ada.Strings.Forward);
+         Report.Failed("Pattern_Error not raised by Index");
+      exception
+         when Ada.Strings.Pattern_Error => null;  -- OK, expected exception.
+         when others                    =>
+           Report.Failed("Incorrect exception raised by Index, null pattern");
+      end;
+
+      -- Use the search direction "backward" to locate the particular
+      -- pattern within the source Wide_String.
+
+      Location := ASF.Index(Source_String6,         -- "abcdefabcdef"
+                            "de",                   -- slice 4..5, 10..11
+                            Ada.Strings.Backward);  -- search from right end.
+
+      if Location /= 10  then
+         Report.Failed("Incorrect result from Index going Backward");
+      end if;
+
+
+
+      -- Function Index
+      -- Use the version of Index that takes a Wide_Character_Mapping_Function
+      -- parameter.
+      -- Use the search directions Forward and Backward to locate the 
+      -- particular pattern wide string within the source wide string.
+      
+      Location := ASF.Index("akzqefakzqef",
+                            "qzq",                  -- slice 8..10
+                            Ada.Strings.Backward,
+                            Map_Ptr);      -- perform 'a' to 'z', 'k' to 'q'
+                                           -- translation. 
+      if Location /= 8  then
+         Report.Failed
+           ("Incorrect result from Index w/map ptr going Backward");
+      end if;
+
+      Location := ASF.Index("ddkkddakcdakdefcadckdfzaaqd",
+                            "zq",                  -- slice 7..8
+                            Ada.Strings.Forward,
+                            Map_Ptr);      -- perform 'a' to 'z', 'k' to 'q'
+                                           -- translation. 
+      if Location /= 7  then
+         Report.Failed
+           ("Incorrect result from Index w/map ptr going Forward");
+      end if;
+
+
+      if ASF.Index("aakkzq", "zq",   Ada.Strings.Forward,  Map_Ptr) /= 2 or
+         ASF.Index("qzedka", "qz",   Ada.Strings.Backward, Map_Ptr) /= 5 or
+         ASF.Index("zazaza", "zzzz", Ada.Strings.Backward, Map_Ptr) /= 3 or
+         ASF.Index("kka",    "qqz",  Ada.Strings.Forward,  Map_Ptr) /= 1
+      then
+         Report.Failed("Incorrect result from Index w/map ptr");
+      end if;
+
+
+      -- Check when the pattern wide string is not found in the source.
+
+      if ASF.Index("akzqef", "kzq",    Ada.Strings.Forward,  Map_Ptr) /= 0 or
+         ASF.Index("abcde",  "abcdef", Ada.Strings.Backward, Map_Ptr) /= 0 or
+         ASF.Index("xyz",    "akzde",  Ada.Strings.Backward, Map_Ptr) /= 0 or
+         ASF.Index("",       "zq",     Ada.Strings.Forward,  Map_Ptr) /= 0 or
+         ASF.Index("akcde",  "  ",     Ada.Strings.Backward, Map_Ptr) /= 0
+      then
+         Report.Failed
+           ("Incorrect result from Index w/map ptr, no pattern match");
+      end if;
+
+      -- Check that Pattern_Error is raised when the pattern is a 
+      -- null Wide_String.
+      begin
+         Location := ASF.Index("akzqefakqzef",
+                               "",                -- null pattern Wide_String.
+                               Ada.Strings.Forward,
+                               Map_Ptr);
+         Report.Failed("Pattern_Error not raised by Index w/map ptr");
+      exception
+         when Ada.Strings.Pattern_Error => null;  -- OK, expected exception.
+         when others                    =>
+           Report.Failed
+             ("Incorrect exception raised by Index w/map ptr, null pattern");
+      end;
+
+
+
+      -- Function Index
+      -- Using the version of Index testing wide character set membership, 
+      -- check combinations of forward/backward, inside/outside parameter
+      -- configurations.
+
+      if ASF.Index(Source => Source_String1,              -- "abcde"
+                   Set    => CD_Set,
+                   Test   => Ada.Strings.Inside,
+                   Going  => Ada.Strings.Forward) /= 3 or -- 'c' at pos 3.
+         ASF.Index(Source_String6,                        -- "abcdefabcdef"
+                   CD_Set,
+                   Ada.Strings.Outside,
+                   Ada.Strings.Backward)  /=  12  or   -- 'f' at position 12
+         ASF.Index(Source_String6,                     -- "abcdefabcdef"
+                   CD_Set,
+                   Ada.Strings.Inside,
+                   Ada.Strings.Backward)  /=   10  or  -- 'd' at position 10
+         ASF.Index("cdcdcdcdacdcdcdcd",               
+                   CD_Set,
+                   Ada.Strings.Outside,
+                   Ada.Strings.Forward)   /=    9      -- 'a' at position 9
+      then
+         Report.Failed("Incorrect result from function Index for sets - 1");
+      end if;
+
+      -- Additional interesting uses/combinations using Index for sets.
+
+      if ASF.Index("cd",                               -- same size, str-set
+                   CD_Set,
+                   Ada.Strings.Inside,
+                   Ada.Strings.Forward)   /=    1  or  -- 'c' at position 1
+         ASF.Index("abcd",                             -- same size, str-set,
+                   Maps.To_Set("efgh"),                -- different contents.
+                   Ada.Strings.Outside,                
+                   Ada.Strings.Forward)   /=    1  or
+         ASF.Index("abccd",                            -- set > Wide_String
+                   Maps.To_Set("acegik"),
+                   Ada.Strings.Inside,
+                   Ada.Strings.Backward)  /=    4  or  -- 'c' at position 4
+         ASF.Index("abcde",
+                   Maps.Null_Set)         /=    0  or
+         ASF.Index("",                                 -- Null string.
+                   CD_Set)                /=    0  or
+         ASF.Index("abc ab",                           -- blank included
+                   Maps.To_Set("e "),                  -- in Wide_String and
+                   Ada.Strings.Inside,                 -- set.
+                   Ada.Strings.Backward)  /=    4      -- blank in Wide_Str.
+      then
+         Report.Failed("Incorrect result from function Index for sets - 2");
+      end if;
+
+
+
+      -- Function Index_Non_Blank.
+      -- (Other usage examples of this function found in CXA4013-14.)
+                                                         
+
+      if ASF.Index_Non_Blank(Source => Source_String4,  -- "abcdefghij  "
+                             Going  => Ada.Strings.Backward)  /= 10  or
+         ASF.Index_Non_Blank("abc def ghi jkl  ",
+                             Ada.Strings.Backward)            /= 15  or
+         ASF.Index_Non_Blank("  abcdef")                      /=  3  or
+         ASF.Index_Non_Blank("        ")                      /=  0
+      then
+          Report.Failed("Incorrect result from Index_Non_Blank");
+      end if;
+
+
+
+      -- Function Count
+      -- (Other usage examples of this function found in CXA4013-14.)
+
+      if ASF.Count("abababa",   "aba")            /=  2  or
+         ASF.Count("abababa",   "ab" )            /=  3  or
+         ASF.Count("babababa",  "ab")             /=  3  or
+         ASF.Count("abaabaaba", "aba")            /=  3  or
+         ASF.Count("xxxxxxxxxxxxxxxxxxxy", "xy")  /=  1  or
+         ASF.Count("xxxxxxxxxxxxxxxxxxxx", "x")   /= 20
+      then
+         Report.Failed("Incorrect result from Function Count");
+      end if;
+
+      -- Determine the number of slices of Source that when mapped to a 
+      -- non-identity map, match the pattern Wide_String.
+
+      Slice_Count := ASF.Count(Source_String6, -- "abcdefabcdef"
+                               "xy",
+                               CD_to_XY_Map);  -- maps 'c' to 'x', 'd' to 'y'
+
+      if Slice_Count /= 2 then  -- two slices "xy" in "mapped" Source_String6
+         Report.Failed("Incorrect result from Count with non-identity map");
+      end if;
+
+      -- If the pattern supplied to Function Count is the null Wide_String,
+      -- then Pattern_Error is propagated.
+      declare
+         The_Null_Wide_String : constant Wide_String := "";
+      begin
+         Slice_Count := ASF.Count(Source_String6, The_Null_Wide_String);
+         Report.Failed("Pattern_Error not raised by Function Count");
+      exception
+         when Ada.Strings.Pattern_Error => null;   -- OK
+         when others =>
+           Report.Failed("Incorrect exception from Count with null pattern");
+      end;
+
+
+
+
+      -- Function Count
+      -- Use the version of Count that takes a Wide_Character_Mapping_Function
+      -- value as the basis of its source mapping.
+      
+      if ASF.Count("akakaka",      "zqz", Map_Ptr)          /=  2  or
+         ASF.Count("akakaka",      "qz",  Map_Ptr)          /=  3  or
+         ASF.Count("kakakaka",     "q",   Map_Ptr)          /=  4  or
+         ASF.Count("zzqaakzaqzzk", "zzq", Map_Ptr)          /=  4  or
+         ASF.Count("   ",          "z",   Map_Ptr)          /=  0  or
+         ASF.Count("",             "qz",  Map_Ptr)          /=  0  or
+         ASF.Count("abbababab",    "zq",  Map_Ptr)          /=  0  or
+         ASF.Count("aaaaaaaaaaaaaaaaaakk", "zqq", Map_Ptr)  /=  1  or
+         ASF.Count("azaazaazzzaaaaazzzza", "z",   Map_Ptr)  /= 20  
+      then
+         Report.Failed("Incorrect result from Function Count w/map ptr");
+      end if;
+
+      -- If the pattern supplied to Function Count is a null Wide_String,
+      -- then Pattern_Error is propagated.
+      declare
+         The_Null_Wide_String : constant Wide_String := "";
+      begin
+         Slice_Count := ASF.Count(Source_String6, 
+                                  The_Null_Wide_String, 
+                                  Map_Ptr);
+         Report.Failed
+           ("Pattern_Error not raised by Function Count w/map ptr");
+      exception
+         when Ada.Strings.Pattern_Error => null;   -- OK
+         when others =>
+           Report.Failed
+             ("Incorrect exception from Count w/map ptr, null pattern");
+      end;
+
+
+
+
+      -- Function Count returning the number of characters in a particular
+      -- set that are found in source Wide_String.
+
+      if ASF.Count(Source_String6, CD_Set) /=  4 or  -- 2 'c' and 'd' chars.
+         ASF.Count("cddaccdaccdd", CD_Set) /= 10
+      then
+         Report.Failed("Incorrect result from Count with set");
+      end if;
+
+
+ 
+      -- Function Find_Token.
+      -- (Other usage examples of this function found in CXA4013-14.)
+
+      ASF.Find_Token(Source  => Source_String6,      -- First slice with no 
+                     Set     => ABCD_Set,            -- 'a', 'b', 'c', or 'd'
+                     Test    => Ada.Strings.Outside, -- is "ef" at 5..6.
+                     First   => Slice_Start,
+                     Last    => Slice_End);
+
+      if Slice_Start /= 5  or Slice_End /= 6 then
+         Report.Failed("Incorrect result from Find_Token - 1");
+      end if;
+
+      -- If no appropriate slice is contained by the source Wide_String,
+      -- then the value returned in Last is zero, and the value in First is 
+      -- Source'First.
+
+      ASF.Find_Token(Source_String6,      -- "abcdefabcdef"
+                     A_to_F_Set,          -- Set of characters 'a' thru 'f'.
+                     Ada.Strings.Outside, -- No characters outside this set.
+                     Slice_Start,
+                     Slice_End);
+      
+      if Slice_Start /= Source_String6'First  or Slice_End /= 0 then
+         Report.Failed("Incorrect result from Find_Token - 2");
+      end if;
+
+      -- Additional testing of Find_Token.
+
+      ASF.Find_Token("eabcdabcddcab", 
+                     ABCD_Set, 
+                     Ada.Strings.Inside,
+                     Slice_Start,
+                     Slice_End);
+
+      if Slice_Start /= 2  or Slice_End /= 13 then
+         Report.Failed("Incorrect result from Find_Token - 3");
+      end if;
+
+      ASF.Find_Token("efghijklabcdabcd",
+                     ABCD_Set,
+                     Ada.Strings.Outside,
+                     Slice_Start,
+                     Slice_End);
+
+      if Slice_Start /= 1  or Slice_End /= 8 then
+         Report.Failed("Incorrect result from Find_Token - 4");
+      end if;
+
+      ASF.Find_Token("abcdefgabcdabcd",
+                     ABCD_Set,
+                     Ada.Strings.Outside,
+                     Slice_Start,
+                     Slice_End);
+
+      if Slice_Start /= 5  or Slice_End /= 7 then
+         Report.Failed("Incorrect result from Find_Token - 5");
+      end if;
+
+      ASF.Find_Token("abcdcbabcdcba",
+                     ABCD_Set,
+                     Ada.Strings.Inside,
+                     Slice_Start,
+                     Slice_End);
+
+      if Slice_Start /= 1  or Slice_End /= 13 then
+         Report.Failed("Incorrect result from Find_Token - 6");
+      end if;
+
+
+   exception
+      when others => Report.Failed("Exception raised in Test_Block");
+   end Test_Block;
+
+   Report.Result;
+
+end CXA4015;