Subversion Repositories openrisc

-- CXB3015.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 "+" and "-" functions with Pointer and ptrdiff_t

--      parameters that return Pointer values produce correct results,

--      based on the size of the array elements.

--

--      Check that the "-" function with two Pointer parameters that

--      returns a ptrdiff_t type parameter produces correct results,

--      based on the size of the array elements.

--

--      Check that each of the "+" and "-" functions above will

--      propagate Pointer_Error if a Pointer parameter is null.

--

--      Check that the Increment and Decrement procedures provide the

--      correct "pointer arithmetic" operations.

--

-- TEST DESCRIPTION:

--      This test checks that the functions "+" and "-", and the procedures

--      Increment and Decrement in the generic package Interfaces.C.Pointers

--      will allow the user to perform "pointer arithmetic" operations on

--      Pointer values.

--      Package Interfaces.C.Pointers is instantiated three times, for

--      short values, chars, and arrays of arrays.  Pointers from each

--      instantiated package are then used to reference different elements

--      of array objects.  Pointer arithmetic operations are performed on

--      these pointers, and the results of these operations are verified

--      against expected pointer positions along the referenced arrays.

--      The propagation of Pointer_Error is checked for when the function

--      Pointer parameter is null.

--

--      The following chart indicates the combinations of subprograms and

--      parameter types used in this test.

--

--

--                                 Short    Char    Array

--                               --------------------------

--      "+" Pointer, ptrdiff_t  |   X    |        |   X    |

--                              |--------------------------|

--      "+" ptrdiff_t, Pointer  |   X    |        |   X    |

--                              |--------------------------|

--      "-" Pointer, ptrdiff_t  |        |   X    |   X    |

--                              |--------------------------|

--      "-" Pointer, Pointer    |        |   X    |   X    |

--                              |--------------------------|

--      Increment (Pointer)     |   X    |        |   X    |

--                              |--------------------------|

--      Decrement (Pointer)     |   X    |        |   X    |

--                               --------------------------

--

--      This test assumes that the following characters are all included

--      in the implementation defined type Interfaces.C.char:

--      ' ', and 'a'..'z'.

--

-- APPLICABILITY CRITERIA:

--      This test is applicable to all implementations that provide

--      package Interfaces.C.Pointers.  If an implementation provides

--      package Interfaces.C.Pointers, this test must compile, execute, and

--      report "PASSED".

--

--

-- CHANGE HISTORY:

--      26 Oct 95   SAIC    Initial prerelease version.

--      13 May 96   SAIC    Incorporated reviewer comments for ACVC 2.1.

--      26 Oct 96   SAIC    Incorporated reviewer comments.

--      06 Mar 00   RLB     Repaired so that array of arrays component

--                          type is statically constrained. (C does not have

--                          an analog to an array of dynamically constrained

--                          arrays.)

with Report;

with Ada.Exceptions;

with Interfaces.C.Pointers;                                   -- N/A => ERROR

procedure CXB3015 is

begin

   Report.Test ("CXB3015", "Check that +, -, Increment, and Decrement "    &

                           "subprograms in Package Interfaces.C.Pointers " &

                           "produce correct results");

   Test_Block:

   declare

      use Ada.Exceptions;

      use type Interfaces.C.short;

      use type Interfaces.C.size_t, Interfaces.C.ptrdiff_t;

      use type Interfaces.C.char,   Interfaces.C.char_array;

      TC_Count         : Interfaces.C.size_t;

      TC_Increment     : Interfaces.C.ptrdiff_t;

      TC_ptrdiff_t     : Interfaces.C.ptrdiff_t;

      TC_Short         : Interfaces.C.short  :=   0;

      TC_Verbose       : Boolean             := False;

      Constant_Min_Array_Size   : constant Interfaces.C.size_t :=   0;

      Constant_Max_Array_Size   : constant Interfaces.C.size_t :=  20;

      Min_Array_Size   : Interfaces.C.size_t :=  Interfaces.C.size_t(

                         Report.Ident_Int(Integer(Constant_Min_Array_Size)));

      Max_Array_Size   : Interfaces.C.size_t :=  Interfaces.C.size_t(

                         Report.Ident_Int(Integer(Constant_Max_Array_Size)));

      Min_size_t,

      Max_size_t       : Interfaces.C.size_t;

      Short_Terminator : Interfaces.C.short  := Interfaces.C.short'Last;

      Alphabet         : constant String     := "abcdefghijklmnopqrstuvwxyz";

      type Short_Array_Type is

        array (Interfaces.C.size_t range <>) of aliased Interfaces.C.short;

      type Constrained_Array_Type is

        array (Min_Array_Size..Max_Array_Size) of aliased Interfaces.C.short;

      type Static_Constrained_Array_Type is

        array (Constant_Min_Array_Size .. Constant_Max_Array_Size) of

          aliased Interfaces.C.short;

      type Array_of_Arrays_Type is

        array (Interfaces.C.size_t range <>) of aliased

        Static_Constrained_Array_Type;

      Short_Array       : Short_Array_Type(Min_Array_Size..Max_Array_Size);

      Constrained_Array : Constrained_Array_Type;

      Terminator_Array  : Static_Constrained_Array_Type :=

                            (others => Short_Terminator);

      Ch_Array          : Interfaces.C.char_array

                            (0..Interfaces.C.size_t(Alphabet'Length)) :=

                              Interfaces.C.To_C(Alphabet, True);

      Array_of_Arrays   : Array_of_Arrays_Type

                            (Min_Array_Size..Max_Array_Size);

      package Short_Pointers is new

        Interfaces.C.Pointers (Index              => Interfaces.C.size_t,

                               Element            => Interfaces.C.short,

                               Element_Array      => Short_Array_Type,

                               Default_Terminator => Short_Terminator);

      package Char_Pointers is new

        Interfaces.C.Pointers (Interfaces.C.size_t,

                               Interfaces.C.char,

                               Element_Array      => Interfaces.C.char_array,

                               Default_Terminator => Interfaces.C.nul);

      package Array_Pointers is new

        Interfaces.C.Pointers (Interfaces.C.size_t,

                               Static_Constrained_Array_Type,

                               Array_of_Arrays_Type,

                               Terminator_Array);

      use Short_Pointers, Char_Pointers, Array_Pointers;

      Short_Ptr       : Short_Pointers.Pointer := Short_Array(0)'Access;

      Char_Ptr        : Char_Pointers.Pointer  := Ch_Array(0)'Access;

      Start_Char_Ptr  : Char_Pointers.Pointer  := Ch_Array(1)'Access;

      End_Char_Ptr    : Char_Pointers.Pointer  := Ch_Array(10)'Access;

      Array_Ptr       : Array_Pointers.Pointer := Array_of_Arrays(0)'Access;

      Start_Array_Ptr : Array_Pointers.Pointer := Array_of_Arrays(1)'Access;

      End_Array_Ptr   : Array_Pointers.Pointer := Array_of_Arrays(10)'Access;

   begin

      -- Provide initial values for the arrays that hold short int values.

      for i in Min_Array_Size..Max_Array_Size-1 loop

         Short_Array(i) := Interfaces.C.short(i);

         for j in Min_Array_Size..Max_Array_Size loop

            -- Initialize this "array of arrays" so that element (i)(0)

            -- is different for each value of i.

            Array_of_Arrays(i)(j) := TC_Short;

            TC_Short := TC_Short + 1;

         end loop;

      end loop;

      -- Set the final element of each array object to be the "terminator"

      -- element used in the instantiations above.

      Short_Array(Max_Array_Size)     := Short_Terminator;

      Array_of_Arrays(Max_Array_Size) := Terminator_Array;

      -- Check starting pointer positions.

      if Short_Ptr.all /= 0           or

         Char_Ptr.all  /= Ch_Array(0) or

         Array_Ptr.all /= Array_of_Arrays(0)

      then

         Report.Failed("Incorrect initial value for the first " &

                       "Short_Array, Ch_Array, or Array_of_Array values");

      end if;

      -- Check that both versions of the "+" function with Pointer and

      -- ptrdiff_t parameters, that return a Pointer value, produce correct

      -- results, based on the size of the array elements.

      for i in Min_Array_Size + 1 .. Max_Array_Size loop

         if Integer(i)/2*2 /= Integer(i)  then -- Odd numbered loops.

            -- Pointer + ptrdiff_t, increment by 1.

            Short_Ptr := Short_Ptr + 1;

         else                                  -- Even numbered loops.

            -- ptrdiff_t + Pointer, increment by 1.

            Short_Ptr := 1 + Short_Ptr;

         end if;

         if Short_Ptr.all /= Short_Array(i) then

            Report.Failed("Incorrect value returned following use " &

                          "of the function +, incrementing by 1, "  &

                          "array position : " & Integer'Image(Integer(i)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

      end loop;

      Array_Ptr    := Array_of_Arrays(Min_Array_Size)'Access;

      TC_Count     := Min_Array_Size;

      TC_Increment := 3;

      while TC_Count+Interfaces.C.size_t(TC_Increment) < Max_Array_Size loop

         if Integer(TC_Count)/2*2 /= Integer(TC_Count) then

            -- Odd numbered loops.

            -- Pointer + ptrdiff_t, increment by 3.

            Array_Ptr := Array_Pointers."+"(Array_Ptr, TC_Increment);

         else

            -- Odd numbered loops.

            -- ptrdiff_t + Pointer, increment by 3.

            Array_Ptr := Array_Pointers."+"(Left  => TC_Increment,

                                            Right => Array_Ptr);

         end if;

         if Array_Ptr.all /=

            Array_of_Arrays(TC_Count+Interfaces.C.size_t(TC_Increment))

         then

            Report.Failed("Incorrect value returned following use " &

                          "of the function +, incrementing by "     &

                          Integer'Image(Integer(TC_Increment))      &

                          ", array position : "                     &

                          Integer'Image(Integer(TC_Count) +

                                        Integer(TC_Increment)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

         TC_Count := TC_Count + Interfaces.C.size_t(TC_Increment);

      end loop;

      -- Check that the "-" function with Pointer and ptrdiff_t parameters,

      -- that returns a Pointer result, produces correct results, based

      -- on the size of the array elements.

      -- Set the pointer to the last element in the char_array, which is a

      -- nul char.

      Char_Ptr := Ch_Array(Interfaces.C.size_t(Alphabet'Length))'Access;

      if Char_Ptr.all /= Interfaces.C.nul then

         Report.Failed("Incorrect initial value for the last " &

                       "Ch_Array value");

      end if;

      Min_size_t := 1;

      Max_size_t := Interfaces.C.size_t(Alphabet'Length);

      for i in reverse Min_size_t..Max_size_t loop

         -- Subtract 1 from the pointer; it should now point to the previous

         -- element in the array.

         Char_Ptr := Char_Ptr - 1;

         if Char_Ptr.all /= Ch_Array(i-1) then

            Report.Failed("Incorrect value returned following use "        &

                          "of the function '-' with char element values, " &

                          "array position : " & Integer'Image(Integer(i-1)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

      end loop;

      Array_Ptr    := Array_of_Arrays(Max_Array_Size)'Access;

      TC_Count     := Max_Array_Size;

      TC_Increment := 3;

      while TC_Count > Min_Array_Size+Interfaces.C.size_t(TC_Increment) loop

         -- Decrement the pointer by 3.

         Array_Ptr := Array_Pointers."-"(Array_Ptr, Right => 3);

         if Array_Ptr.all /=

            Array_of_Arrays(TC_Count - Interfaces.C.size_t(TC_Increment))

         then

            Report.Failed("Incorrect value returned following use " &

                          "of the function -, decrementing by "     &

                          Integer'Image(Integer(TC_Increment))      &

                          ", array position : "                     &

                          Integer'Image(Integer(TC_Count-3)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

         TC_Count := TC_Count - Interfaces.C.size_t(TC_Increment);

      end loop;

      -- Check that the "-" function with two Pointer parameters, that

      -- returns a ptrdiff_t type result, produces correct results,

      -- based on the size of the array elements.

      TC_ptrdiff_t := 9;

      if Char_Pointers."-"(Left  => End_Char_Ptr,

                           Right => Start_Char_Ptr) /= TC_ptrdiff_t

      then

         Report.Failed("Incorrect result from pointer-pointer " &

                       "subtraction - 1");

      end if;

      Start_Char_Ptr := Ch_Array(1)'Access;

      End_Char_Ptr   := Ch_Array(25)'Access;

      TC_ptrdiff_t := 24;

      if Char_Pointers."-"(End_Char_Ptr,

                           Right => Start_Char_Ptr) /= TC_ptrdiff_t

      then

         Report.Failed("Incorrect result from pointer-pointer " &

                       "subtraction - 2");

      end if;

      TC_ptrdiff_t := 9;

      if Array_Pointers."-"(End_Array_Ptr,

                            Start_Array_Ptr) /= TC_ptrdiff_t

      then

         Report.Failed("Incorrect result from pointer-pointer " &

                       "subtraction - 3");

      end if;

      Start_Array_Ptr := Array_of_Arrays(Min_Array_Size)'Access;

      End_Array_Ptr   := Array_of_Arrays(Max_Array_Size)'Access;

      TC_ptrdiff_t := Interfaces.C.ptrdiff_t(Max_Array_Size) -

                      Interfaces.C.ptrdiff_t(Min_Array_Size);

      if End_Array_Ptr - Start_Array_Ptr /= TC_ptrdiff_t then

         Report.Failed("Incorrect result from pointer-pointer " &

                       "subtraction - 4");

      end if;

      -- Check that the Increment procedure produces correct results,

      -- based upon the size of the array elements.

      Short_Ptr := Short_Array(0)'Access;

      for i in Min_Array_Size + 1 .. Max_Array_Size loop

         -- Increment the value of the Pointer; it should now point

         -- to the next element in the array.

         Increment(Ref => Short_Ptr);

         if Short_Ptr.all /= Short_Array(i) then

            Report.Failed("Incorrect value returned following use "      &

                          "of the Procedure Increment on pointer to an " &

                          "array of short values, array position : "     &

                          Integer'Image(Integer(i)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

      end loop;

      Array_Ptr := Array_of_Arrays(0)'Access;

      for i in Min_Array_Size + 1 .. Max_Array_Size loop

         -- Increment the value of the Pointer; it should now point

         -- to the next element in the array.

         Increment(Array_Ptr);

         if Array_Ptr.all /= Array_of_Arrays(i) then

            Report.Failed("Incorrect value returned following use "    &

                          "of the Procedure Increment on an array of " &

                          "arrays, array position : "                  &

                          Integer'Image(Integer(i)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

      end loop;

      -- Check that the Decrement procedure produces correct results,

      -- based upon the size of the array elements.

      Short_Ptr := Short_Array(Max_Array_Size)'Access;

      for i in reverse Min_Array_Size .. Max_Array_Size - 1 loop

         -- Decrement the value of the Pointer; it should now point

         -- to the previous element in the array.

         Decrement(Ref => Short_Ptr);

         if Short_Ptr.all /= Short_Array(i) then

            Report.Failed("Incorrect value returned following use "      &

                          "of the Procedure Decrement on pointer to an " &

                          "array of short values, array position : "     &

                          Integer'Image(Integer(i)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

      end loop;

      Array_Ptr := Array_of_Arrays(Max_Array_Size)'Access;

      for i in reverse Min_Array_Size .. Max_Array_Size - 1 loop

         -- Decrement the value of the Pointer; it should now point

         -- to the previous array element.

         Decrement(Array_Ptr);

         if Array_Ptr.all /= Array_of_Arrays(i) then

            Report.Failed("Incorrect value returned following use "    &

                          "of the Procedure Decrement on an array of " &

                          "arrays, array position : "                  &

                          Integer'Image(Integer(i)));

            if not TC_Verbose then

               exit;

            end if;

         end if;

      end loop;

      -- Check that each of the "+" and "-" functions above will

      -- propagate Pointer_Error if a Pointer parameter is null.

      begin

         Short_Ptr := null;

         Short_Ptr := Short_Ptr + 4;

         Report.Failed("Pointer_Error not raised by Function + when " &

                       "the Pointer parameter is null");

         if Short_Ptr /= null then  -- To avoid optimization.

            Report.Comment("This should never be printed");

         end if;

      exception

         when Short_Pointers.Pointer_Error => null; -- OK, expected exception.

         when others =>

           Report.Failed("Unexpected exception raised by Function + " &

                         "when the Pointer parameter is null");

      end;

      begin

         Char_Ptr := null;

         Char_Ptr := Char_Ptr - 1;

         Report.Failed("Pointer_Error not raised by Function - when " &

                       "the Pointer parameter is null");

         if Char_Ptr /= null then  -- To avoid optimization.

            Report.Comment("This should never be printed");

         end if;

      exception

         when Char_Pointers.Pointer_Error => null; -- OK, expected exception.

         when others =>

           Report.Failed("Unexpected exception raised by Function - " &

                         "when the Pointer parameter is null");

      end;

      begin

         Array_Ptr := null;

         Decrement(Array_Ptr);

         Report.Failed("Pointer_Error not raised by Procedure Decrement " &

                       "when the Pointer parameter is null");

         if Array_Ptr /= null then  -- To avoid optimization.

            Report.Comment("This should never be printed");

         end if;

      exception

         when Array_Pointers.Pointer_Error => null; -- OK, expected exception.

         when others =>

           Report.Failed("Unexpected exception raised by Procedure " &

                         "Decrement when the Pointer parameter is null");

      end;

   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 CXB3015;