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;