Subversion Repositories openrisc

-- C3A0015.A

--

--                             Grant of Unlimited Rights

--

--     The Ada Conformity Assessment Authority (ACAA) holds unlimited

--     rights in the software and documentation contained herein. Unlimited

--     rights are the same as those granted by the U.S. Government for older

--     parts of the Ada Conformity Assessment Test Suite, and are defined

--     in DFAR 252.227-7013(a)(19). By making this public release, the ACAA

--     intends to confer upon all recipients unlimited rights equal to those

--     held by the ACAA. 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 a derived access type has the same storage pool as its

--    parent.  (Defect Report 8652/0012, Technical Corrigendum 3.10(7/1)).

--

-- CHANGE HISTORY:

--    24 JAN 2001   PHL   Initial version.

--    29 JUN 2001   RLB   Reformatted for ACATS.

--

--!

with System.Storage_Elements;

use System.Storage_Elements;

with System.Storage_Pools;

use System.Storage_Pools;

package C3A0015_0 is

    type Pool (Storage_Size : Storage_Count) is new Root_Storage_Pool with

        record

            First_Free : Storage_Count := 1;

            Contents : Storage_Array (1 .. Storage_Size);

        end record;

    procedure Allocate (Pool : in out C3A0015_0.Pool;

                        Storage_Address : out System.Address;

                        Size_In_Storage_Elements : in Storage_Count;

                        Alignment : in Storage_Count);

    procedure Deallocate (Pool : in out C3A0015_0.Pool;

                          Storage_Address : in System.Address;

                          Size_In_Storage_Elements : in Storage_Count;

                          Alignment : in Storage_Count);

    function Storage_Size (Pool : in C3A0015_0.Pool) return Storage_Count;

end C3A0015_0;

package body C3A0015_0 is

    use System;

    procedure Allocate (Pool : in out C3A0015_0.Pool;

                        Storage_Address : out System.Address;

                        Size_In_Storage_Elements : in Storage_Count;

                        Alignment : in Storage_Count) is

        Unaligned_Address : constant System.Address :=

           Pool.Contents (Pool.First_Free)'Address;

        Unalignment : Storage_Count;

    begin

        Unalignment := Unaligned_Address mod Alignment;

        if Unalignment = 0 then

            Storage_Address := Unaligned_Address;

            Pool.First_Free := Pool.First_Free + Size_In_Storage_Elements;

        else

            Storage_Address :=

               Pool.Contents (Pool.First_Free + Alignment - Unalignment)'

                  Address;

            Pool.First_Free := Pool.First_Free + Size_In_Storage_Elements +

                                  Alignment - Unalignment;

        end if;

    end Allocate;

    procedure Deallocate (Pool : in out C3A0015_0.Pool;

                          Storage_Address : in System.Address;

                          Size_In_Storage_Elements : in Storage_Count;

                          Alignment : in Storage_Count) is

    begin

        if Storage_Address + Size_In_Storage_Elements =

           Pool.Contents (Pool.First_Free)'Address then

            -- Only deallocate if the block is at the end.

            Pool.First_Free := Pool.First_Free - Size_In_Storage_Elements;

        end if;

    end Deallocate;

    function Storage_Size (Pool : in C3A0015_0.Pool) return Storage_Count is

    begin

        return Pool.Storage_Size;

    end Storage_Size;

end C3A0015_0;

with Ada.Exceptions;

use Ada.Exceptions;

with Ada.Unchecked_Deallocation;

with Report;

use Report;

with System.Storage_Elements;

use System.Storage_Elements;

with C3A0015_0;

procedure C3A0015 is

    type Standard_Pool is access Float;

    type Derived_Standard_Pool is new Standard_Pool;

    type Derived_Derived_Standard_Pool is new Derived_Standard_Pool;

    type User_Defined_Pool is access Integer;

    type Derived_User_Defined_Pool is new User_Defined_Pool;

    type Derived_Derived_User_Defined_Pool is new Derived_User_Defined_Pool;

    My_Pool : C3A0015_0.Pool (1024);

    for User_Defined_Pool'Storage_Pool use My_Pool;

    generic

        type Designated is private;

        Value : Designated;

        type Acc is access Designated;

        type Derived_Acc is new Acc;

    procedure Check (Subtest : String; User_Defined_Pool : Boolean);

    procedure Check (Subtest : String; User_Defined_Pool : Boolean) is

        procedure Deallocate is

           new Ada.Unchecked_Deallocation (Object => Designated,

                                           Name => Acc);

        procedure Deallocate is

           new Ada.Unchecked_Deallocation (Object => Designated,

                                           Name => Derived_Acc);

        First_Free : Storage_Count;

        X : Acc;

        Y : Derived_Acc;

    begin

        if User_Defined_Pool then

            First_Free := My_Pool.First_Free;

        end if;

        X := new Designated'(Value);

        if User_Defined_Pool and then First_Free >= My_Pool.First_Free then

            Failed (Subtest &

                    " - Allocation didn't consume storage in the pool - 1");

        else

            First_Free := My_Pool.First_Free;

        end if;

        Y := Derived_Acc (X);

        if User_Defined_Pool and then First_Free /= My_Pool.First_Free then

            Failed (Subtest &

                    " - Conversion did consume storage in the pool - 1");

        end if;

        if Y.all /= Value then

            Failed (Subtest &

                    " - Incorrect allocation/conversion of access values - 1");

        end if;

        Deallocate (Y);

        if User_Defined_Pool and then First_Free <= My_Pool.First_Free then

            Failed (Subtest &

                    " - Deallocation didn't release storage from the pool - 1");

        else

            First_Free := My_Pool.First_Free;

        end if;

        Y := new Designated'(Value);

        if User_Defined_Pool and then First_Free >= My_Pool.First_Free then

            Failed (Subtest &

                    " - Allocation didn't consume storage in the pool - 2");

        else

            First_Free := My_Pool.First_Free;

        end if;

        X := Acc (Y);

        if User_Defined_Pool and then First_Free /= My_Pool.First_Free then

            Failed (Subtest &

                    " - Conversion did consume storage in the pool - 2");

        end if;

        if X.all /= Value then

            Failed (Subtest &

                    " - Incorrect allocation/conversion of access values - 2");

        end if;

        Deallocate (X);

        if User_Defined_Pool and then First_Free <= My_Pool.First_Free then

            Failed (Subtest &

                    " - Deallocation didn't release storage from the pool - 2");

        end if;

    exception

        when E: others =>

            Failed (Subtest & " - Exception " & Exception_Name (E) &

                    " raised - " & Exception_Message (E));

    end Check;

begin

    Test ("C3A0015", "Check that a dervied access type has the same " &

                        "storage pool as its parent");

    Comment ("Access types using the standard storage pool");

    Std:

        declare

            procedure Check1 is

               new Check (Designated => Float,

                          Value => 3.0,

                          Acc => Standard_Pool,

                          Derived_Acc => Derived_Standard_Pool);

            procedure Check2 is

               new Check (Designated => Float,

                          Value => 4.0,

                          Acc => Standard_Pool,

                          Derived_Acc => Derived_Derived_Standard_Pool);

            procedure Check3 is

               new Check (Designated => Float,

                          Value => 5.0,

                          Acc => Derived_Standard_Pool,

                          Derived_Acc => Derived_Derived_Standard_Pool);

        begin

            Check1 ("Standard_Pool/Derived_Standard_Pool",

                    User_Defined_Pool => False);

            Check2 ("Standard_Pool/Derived_Derived_Standard_Pool",

                    User_Defined_Pool => False);

            Check3 ("Derived_Standard_Pool/Derived_Derived_Standard_Pool",

                    User_Defined_Pool => False);

        end Std;

    Comment ("Access types using a user-defined storage pool");

    User:

        declare

            procedure Check1 is

               new Check (Designated => Integer,

                          Value => 17,

                          Acc => User_Defined_Pool,

                          Derived_Acc => Derived_User_Defined_Pool);

            procedure Check2 is

               new Check (Designated => Integer,

                          Value => 18,

                          Acc => User_Defined_Pool,

                          Derived_Acc => Derived_Derived_User_Defined_Pool);

            procedure Check3 is

               new Check (Designated => Integer,

                          Value => 19,

                          Acc => Derived_User_Defined_Pool,

                          Derived_Acc => Derived_Derived_User_Defined_Pool);

        begin

            Check1 ("User_Defined_Pool/Derived_User_Defined_Pool",

                    User_Defined_Pool => True);

            Check2 ("User_Defined_Pool/Derived_Derived_User_Defined_Pool",

                    User_Defined_Pool => True);

            Check3

               ("Derived_User_Defined_Pool/Derived_Derived_User_Defined_Pool",

                User_Defined_Pool => True);

        end User;

    Result;

end C3A0015;