Subversion Repositories openrisc

-- CXB30132.AM
--
--                             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 imported, user-defined C language functions can be 
--      called from an Ada program.
--      
-- TEST DESCRIPTION:
--      This test checks that user-defined C language functions can be
--      imported and referenced from an Ada program.  Two C language
--      functions are specified in files CXB30130.C and CXB30131.C.  
--      These two functions are imported to this test program, using two
--      calls to Pragma Import.  Each function is then called in this test,
--      and the results of the call are verified.
--      
--      This test assumes that the following characters are all included
--      in the implementation defined type Interfaces.C.char:
--      ' ', 'a'..'z', and 'A'..'Z'.
--      
-- APPLICABILITY CRITERIA: 
--      This test is applicable to all implementations that provide 
--      packages Interfaces.C and Interfaces.C.Strings.  If an 
--      implementation provides packages Interfaces.C and 
--      Interfaces.C.Strings, this test must compile, execute, and 
--      report "PASSED".
--
-- SPECIAL REQUIREMENTS:
--      The files CXB30130.C and CXB30131.C must be compiled with a C 
--      compiler.  Implementation dialects of C may require alteration of 
--      the C program syntax (see individual C files).
--     
--      Note that the compiled C code must be bound with the compiled Ada
--      code to create an executable image.  An implementation must provide
--      the necessary commands to accomplish this.
--     
--      Note that the C code included in CXB30130.C and CXB30131.C conforms
--      to ANSI-C.  Modifications to these files may be required for other
--      C compilers.  An implementation must provide the necessary 
--      modifications to satisfy the function requirements.
--     
-- TEST FILES:
--      The following files comprise this test:
--
--         CXB30130.C
--         CXB30131.C
--         CXB30132.AM
--
--       
-- CHANGE HISTORY:
--      13 Oct 95   SAIC    Initial prerelease version.
--      13 May 96   SAIC    Incorporated reviewer comments for ACVC 2.1.
--      26 Oct 96   SAIC    Incorporated reviewer comments.
--
--!

with Report;
with Impdef;
with Interfaces.C;                                            -- N/A => ERROR
with Interfaces.C.Strings;                                    -- N/A => ERROR

procedure CXB30132 is
begin

   Report.Test ("CXB3013", "Check that user-defined C functions can " &
                           "be imported into an Ada program");

   Test_Block:
   declare

      package IC  renames Interfaces.C;
      package ICS renames Interfaces.C.Strings;

      use type IC.char_array;
      use type IC.int;
      use type IC.short;
      use type IC.C_float;
      use type IC.double;

      type Short_Ptr          is access all IC.short;
      type Float_Ptr          is access all IC.C_float;
      type Double_Ptr         is access all IC.double;
      subtype Char_Array_Type is IC.char_array(0..20);

      TC_Default_int      : IC.int             :=   49;
      TC_Default_short    : IC.short           :=    3;
      TC_Default_float    : IC.C_float         :=   50.0;
      TC_Default_double   : IC.double          := 1209.0; 

      An_Int_Value        : IC.int             := TC_Default_int;
      A_Short_Value       : aliased IC.short   := TC_Default_short;
      A_Float_Value       : aliased IC.C_float := TC_Default_float; 
      A_Double_Value      : aliased IC.double  := TC_Default_double;

      A_Short_Int_Pointer : Short_Ptr          := A_Short_Value'access;
      A_Float_Pointer     : Float_Ptr          := A_Float_Value'access;
      A_Double_Pointer    : Double_Ptr         := A_Double_Value'access;

      Char_Array_1        : Char_Array_Type;
      Char_Array_2        : Char_Array_Type;
      Char_Pointer        : ICS.chars_ptr;

      TC_Char_Array       : constant Char_Array_Type := 
                              "Look before you leap" & IC.nul;
      TC_Return_int       : IC.int := 0;

      -- The Square_It function returns the square of the value The_Int 
      -- through the function name, and returns the square of the other
      -- parameters through the parameter list (the last three parameters 
      -- are access values).

      function Square_It (The_Int    : in IC.int;
                          The_Short  : in Short_Ptr;
                          The_Float  : in Float_Ptr;
                          The_Double : in Double_Ptr) return IC.int;

      -- The Combine_Strings function returns the result of the catenation
      -- of the two string parameters through the function name.

      function Combine_Strings (First_Part  : in IC.char_array;
                                Second_Part : in IC.char_array) 
        return ICS.chars_ptr;


      -- Use the user-defined C function square_it as a completion to the
      -- function specification above.

     pragma Import (Convention    => C, 
                    Entity        => Square_It, 
                    External_Name => Impdef.CXB30130_External_Name);

      -- Use the user-defined C function combine_two_strings as a completion
      -- to the function specification above.

     pragma Import (C, Combine_Strings, Impdef.CXB30131_External_Name);


   begin

      -- Check that the imported version of C function CXB30130 produces 
      -- the correct results.

      TC_Return_int := Square_It (The_Int    => An_Int_Value,
                                  The_Short  => A_Short_Int_Pointer,
                                  The_Float  => A_Float_Pointer,
                                  The_Double => A_Double_Pointer);

      -- Compare the results with the expected results.  Note that in the
      -- case of the three "pointer" parameters, the objects being pointed
      -- to have been modified as a result of the function.

      if TC_Return_int           /= An_Int_Value      * An_Int_Value      or
         A_Short_Int_Pointer.all /= TC_Default_short  * TC_Default_Short  or
         A_Short_Value           /= TC_Default_short  * TC_Default_Short  or
         A_Float_Pointer.all     /= TC_Default_float  * TC_Default_float  or
         A_Float_Value           /= TC_Default_float  * TC_Default_float  or
         A_Double_Pointer.all    /= TC_Default_double * TC_Default_double or
         A_Double_Value          /= TC_Default_double * TC_Default_double 
      then
         Report.Failed("Incorrect results returned from function square_it");
      end if;


      -- Check that two char_array values are combined by the imported 
      -- C function CXB30131.

      Char_Array_1(0..12) := "Look before " & IC.nul;
      Char_Array_2(0..8)  := "you leap"     & IC.nul;

      Char_Pointer := Combine_Strings (Char_Array_1, Char_Array_2);

      if ICS.Value(Char_Pointer) /= TC_Char_Array then
         Report.Failed("Incorrect value returned from imported function " &
                       "combine_two_strings");
      end if;


   exception
      when others => Report.Failed ("Exception raised in Test_Block");
   end Test_Block;

   Report.Result;

end CXB30132;