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

diff --git a/gcc/testsuite/ada/acats/tests/cxb/cxb5002.a b/gcc/testsuite/ada/acats/tests/cxb/cxb5002.a
new file mode 100644
index 000000000..3da7cc9b1
--- /dev/null
+++ b/gcc/testsuite/ada/acats/tests/cxb/cxb5002.a
@@ -0,0 +1,334 @@
+-- CXB5002.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 Function To_Fortran with a Character parameter will
+--      return the corresponding Fortran Character_Set value.
+--
+--      Check that the Function To_Ada with a Character_Set parameter will 
+--      return the corresponding Ada Character value.
+--
+--      Check that the Function To_Fortran with a String parameter will
+--      return the corresponding Fortran_Character value.
+--
+--      Check that the Function To_Ada with a Fortran_Character parameter
+--      will return the corresponding Ada String value.
+--
+-- TEST DESCRIPTION:
+--      This test checks that the functions To_Fortran and To_Ada produce
+--      the correct results, based on a variety of parameter input values.
+--      
+--      In the first series of subtests, the results of the function
+--      To_Fortran are compared against expected Character_Set type results.
+--      In the second series of subtests, the results of the function To_Ada
+--      are compared against expected String type results, and the length of
+--      the String result is also verified against the Fortran_Character type
+--      parameter.
+--      
+--      This test uses Fixed, Bounded, and Unbounded_Strings in combination
+--      with the functions under validation.
+--      
+--      This test assumes that the following characters are all included
+--      in the implementation defined type Interfaces.Fortran.Character_Set:
+--      ' ', 'a'..'z', 'A'..'Z', '1'..'9', '-', '_', '$', '#', and '*'.
+--      
+-- APPLICABILITY CRITERIA: 
+--      This test is applicable to all implementations that provide 
+--      package Interfaces.Fortran.  If an implementation provides
+--      package Interfaces.Fortran, this test must compile, execute, and 
+--      report "PASSED".
+--
+--      This test does not apply to an implementation in which the Fortran
+--      character set ranges are not contiguous (e.g., EBCDIC).
+--      
+--
+--       
+-- CHANGE HISTORY:
+--      11 Mar 96   SAIC    Initial release for 2.1.
+--      10 Jun 96   SAIC    Incorporated reviewer comments for ACVC 2.1.
+--      27 Oct 96   SAIC    Incorporated reviewer comments.
+--
+--!
+
+with Ada.Characters.Latin_1;
+with Ada.Exceptions;
+with Ada.Strings.Bounded;
+with Ada.Strings.Unbounded;
+with Ada.Unchecked_Conversion;
+with Interfaces.Fortran;                                      -- N/A => ERROR
+with Report;
+
+procedure CXB5002 is
+begin
+
+   Report.Test ("CXB5002", "Check that functions To_Fortran and To_Ada " &
+                           "produce correct results");
+
+   Test_Block:
+   declare
+
+      package ACL renames Ada.Characters.Latin_1;
+      package Bnd is new Ada.Strings.Bounded.Generic_Bounded_Length(10);
+      package Unb renames Ada.Strings.Unbounded;
+
+      use Bnd, Unb;
+      use Interfaces.Fortran;
+      use Ada.Exceptions;
+
+      Null_Fortran_Character  : constant Fortran_Character := "";
+      Fortran_Character_1     : Fortran_Character(1..1)    := " ";
+      Fortran_Character_5     : Fortran_Character(1..5)    := "     ";
+      Fortran_Character_10    : Fortran_Character(1..10)   := "          ";
+      Fortran_Character_20    : Fortran_Character(1..20)   := 
+                                  "                    ";
+      TC_Fortran_Character_1  : Fortran_Character(1..1)    := "A";
+      TC_Fortran_Character_5  : Fortran_Character(1..5)    := "ab*de";
+      TC_Fortran_Character_10 : Fortran_Character(1..10)   := "$1a2b3C4D5";
+      TC_Fortran_Character_20 : Fortran_Character(1..20)   := 
+                                  "1234-ABCD_6789#fghij";
+
+      Bnd_String              : Bnd.Bounded_String   :=
+                                  Bnd.To_Bounded_String("          ");
+      TC_Bnd_String           : Bounded_String       :=
+                                  To_Bounded_String("$1a2b3C4D5");
+
+      Unb_String              : Unb.Unbounded_String :=
+                                  Unb.To_Unbounded_String("     ");
+      TC_Unb_String           : Unbounded_String     :=
+                                  To_Unbounded_String("ab*de");
+
+      String_1                : String(1..1)    := " ";
+      String_5                : String(1..5)    := "     ";
+      String_10               : String(1..10)   := "          ";
+      String_20               : String(1..20)   := "                    ";
+      TC_String_1             : String(1..1)    := "A";
+      TC_String_20            : String(1..20)   := "1234-ABCD_6789#fghij";
+      Null_String             : constant String := "";
+
+      Null_Character          : constant Character := ACL.Nul;
+      Character_A             : constant Character := Character'Val(65);
+      Character_Z             : constant Character := Character'Val(90);
+      TC_Character            : Character          := Character'First;
+
+      Null_Character_Set      : Character_Set      := To_Fortran(ACL.Nul);
+      TC_Character_Set,
+      TC_Low_Character_Set,
+      TC_High_Character_Set   : Character_Set      := Character_Set'First;
+
+
+      -- The following procedure checks the results of function To_Ada.
+
+      procedure Check_Length (Str : in String;
+                              Ftn : in Fortran_Character;
+                              Num : in Natural) is
+      begin
+         if Str'Length /= Ftn'Length or
+            Str'Length /= Num
+         then
+            Report.Failed("Incorrect result from Function To_Ada " &
+                          "with string length " & Integer'Image(Num));
+         end if;
+      end Check_Length;
+
+      -- To facilitate the conversion of Character-Character_Set data, the 
+      -- following functions have been instantiated.  
+
+      function Character_to_Character_Set is
+        new Ada.Unchecked_Conversion(Character, Character_Set);
+
+      function Character_Set_to_Character is
+        new Ada.Unchecked_Conversion(Character_Set, Character);
+
+   begin
+
+      -- Check that the Function To_Fortran with a Character parameter
+      -- will return the corresponding Fortran Character_Set value.
+
+      for TC_Character in ACL.LC_A..ACL.LC_Z loop
+         if To_Fortran(Item => TC_Character) /= 
+            Character_to_Character_Set(TC_Character) 
+         then
+            Report.Failed("Incorrect result from To_Fortran with lower " &
+                          "case alphabetic character input");
+         end if;
+      end loop;
+
+      for TC_Character in Character_A..Character_Z loop
+         if To_Fortran(TC_Character) /= 
+            Character_to_Character_Set(TC_Character) 
+         then
+            Report.Failed("Incorrect result from To_Fortran with upper " &
+                          "case alphabetic character input");
+         end if;
+      end loop;
+
+      if To_Fortran(Null_Character) /= 
+         Character_to_Character_Set(Null_Character)
+      then
+         Report.Failed
+           ("Incorrect result from To_Fortran with null character input");
+      end if;
+
+
+      -- Check that the Function To_Ada with a Character_Set parameter 
+      -- will return the corresponding Ada Character value.
+
+      TC_Low_Character_Set  := Character_to_Character_Set('a');
+      TC_High_Character_Set := Character_to_Character_Set('z');
+      for TC_Character_Set in TC_Low_Character_Set..TC_High_Character_Set loop
+         if To_Ada(Item => TC_Character_Set) /= 
+            Character_Set_to_Character(TC_Character_Set) 
+         then
+            Report.Failed("Incorrect result from To_Ada with lower case " &
+                          "alphabetic Character_Set input");
+         end if;
+      end loop;
+
+      TC_Low_Character_Set  := Character_to_Character_Set('A');
+      TC_High_Character_Set := Character_to_Character_Set('Z');
+      for TC_Character_Set in TC_Low_Character_Set..TC_High_Character_Set loop
+         if To_Ada(TC_Character_Set) /= 
+            Character_Set_to_Character(TC_Character_Set) 
+         then
+            Report.Failed("Incorrect result from To_Ada with upper case " &
+                          "alphabetic Character_Set input");
+         end if;
+      end loop;
+
+      if To_Ada(Character_to_Character_Set(Null_Character)) /=
+         Null_Character
+      then
+         Report.Failed("Incorrect result from To_Ada with a null " &
+                       "Character_Set input");
+      end if;
+
+
+      -- Check that the Function To_Fortran with a String parameter 
+      -- will return the corresponding Fortran_Character value.
+      -- Note: The type Fortran_Character is a character array type that
+      --       corresponds to Ada type String.
+
+      Fortran_Character_1 := To_Fortran(Item => TC_String_1);
+
+      if Fortran_Character_1 /= TC_Fortran_Character_1 then
+         Report.Failed("Incorrect result from procedure To_Fortran - 1");
+      end if;
+
+      Fortran_Character_5 := To_Fortran(To_String(TC_Unb_String));
+
+      if Fortran_Character_5 /= TC_Fortran_Character_5 then
+         Report.Failed("Incorrect result from procedure To_Fortran - 2");
+      end if;
+
+      Fortran_Character_10 := To_Fortran(To_String(TC_Bnd_String));
+
+      if Fortran_Character_10 /= TC_Fortran_Character_10 then
+         Report.Failed("Incorrect result from procedure To_Fortran - 3");
+      end if;
+
+      Fortran_Character_20 := To_Fortran(Item => TC_String_20);
+
+      if Fortran_Character_20 /= TC_Fortran_Character_20 then
+         Report.Failed("Incorrect result from procedure To_Fortran - 4");
+      end if;
+
+      if To_Fortran(Null_String) /= Null_Fortran_Character then
+         Report.Failed("Incorrect result from procedure To_Fortran - 5");
+      end if;
+
+
+      -- Check that the Function To_Ada with a Fortran_Character parameter
+      -- will return the corresponding Ada String value.
+
+      String_1 := To_Ada(TC_Fortran_Character_1);
+
+      if String_1 /= TC_String_1 then
+         Report.Failed("Incorrect value returned from function To_Ada - 1");
+      end if;
+
+      Check_Length(To_Ada(TC_Fortran_Character_1),
+                   TC_Fortran_Character_1,
+                   Num => 1);
+
+
+      Unb_String := Unb.To_Unbounded_String(To_Ada(TC_Fortran_Character_5));
+
+      if Unb_String /= TC_Unb_String then
+         Report.Failed("Incorrect value returned from function To_Ada - 2");
+      end if;
+
+      Check_Length(To_Ada(TC_Fortran_Character_5),
+                   TC_Fortran_Character_5,
+                   Num => 5);
+
+
+      Bnd_String := Bnd.To_Bounded_String 
+                         (To_Ada(TC_Fortran_Character_10));
+
+      if Bnd_String /= TC_Bnd_String then
+         Report.Failed("Incorrect value returned from function To_Ada - 3");
+      end if;
+
+      Check_Length(To_Ada(TC_Fortran_Character_10),
+                   TC_Fortran_Character_10,
+                   Num => 10);
+
+
+      String_20 := To_Ada(TC_Fortran_Character_20);
+
+      if String_20 /= TC_String_20 then
+         Report.Failed("Incorrect value returned from function To_Ada - 4");
+      end if;
+
+      Check_Length(To_Ada(TC_Fortran_Character_20),
+                   TC_Fortran_Character_20,
+                   Num => 20);
+
+      if To_Ada(Null_Character_Set) /= Null_Character then
+         Report.Failed("Incorrect value returned from function To_Ada - 5");
+      end if;
+
+
+      -- Check the two functions when used in combination.
+
+      if To_Ada(Item => To_Fortran("This is a test")) /=
+         "This is a test"                                or
+         To_Ada(To_Fortran("1234567890abcdeFGHIJ"))   /=
+         Report.Ident_Str("1234567890abcdeFGHIJ")
+      then
+         Report.Failed("Incorrect result returned when using the " &
+                       "functions To_Ada and To_Fortran in combination");
+      end if;
+
+
+   exception
+      when The_Error : others => 
+         Report.Failed("The following exception was raised in the " &
+                       "Test_Block: " & Exception_Name(The_Error));
+   end Test_Block;
+
+   Report.Result;
+
+end CXB5002;