-- C854002.A
--
--                             Grant of Unlimited Rights
--
--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687 and
--     F08630-91-C-0015, 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 WHATSOVER, 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 the requirements of the new 8.5.4(8.A) from Technical
--     Corrigendum 1 (originally discussed as AI95-00064).
--     This paragraph requires an elaboration check on renamings-as-body:
--     even if the body of the ultimately-called subprogram has been
--     elaborated, the check should fail if the renaming-as-body
--     itself has not yet been elaborated.
--
-- TEST DESCRIPTION
--     We declare two functions F and G, and ensure that they are
--     elaborated before anything else, by using pragma Pure.  Then we
--     declare two renamings-as-body: the renaming of F is direct, and
--     the renaming of G is via an access-to-function object.  We call
--     the renamings during elaboration, and check that they raise
--     Program_Error.  We then call them again after elaboration; this
--     time, they should work.
--
-- CHANGE HISTORY:
--      29 JUN 1999   RAD   Initial Version
--      23 SEP 1999   RLB   Improved comments, renamed, issued.
--      28 JUN 2002   RLB   Added pragma Elaborate_All for Report.
--!

package C854002_1 is
    pragma Pure;
    -- Empty.
end C854002_1;

package C854002_1.Pure is
    pragma Pure;
    function F return String;
    function G return String;
end C854002_1.Pure;

with C854002_1.Pure;
package C854002_1.Renamings is

    F_Result: constant String := C854002_1.Pure.F; -- Make sure we can call F.
    function Renamed_F return String;

    G_Result: constant String := C854002_1.Pure.G;
    type String_Function is access function return String;
    G_Pointer: String_Function := null;
        -- Will be set to C854002_1.Pure.G'Access in the body.
    function Renamed_G return String;

end C854002_1.Renamings;

package C854002_1.Caller is

    -- These procedures call the renamings; when called during elaboration,
    -- we pass Should_Fail => True, which checks that Program_Error is
    -- raised.  Later, we use Should_Fail => False.

    procedure Call_Renamed_F(Should_Fail: Boolean);
    procedure Call_Renamed_G(Should_Fail: Boolean);

end C854002_1.Caller;

with Report; use Report; pragma Elaborate_All (Report);
with C854002_1.Renamings;
package body C854002_1.Caller is

    Some_Error: exception;

    procedure Call_Renamed_F(Should_Fail: Boolean) is
    begin
        if Should_Fail then
            begin
                Failed(C854002_1.Renamings.Renamed_F);
                raise Some_Error;
                    -- This raise statement is necessary, because the
                    -- Report package has a bug -- if Failed is called
                    -- before Test, then the failure is ignored, and the
                    -- test prints "PASSED".
                    -- Presumably, this raise statement will cause the
                    -- program to crash, thus avoiding the PASSED message.
            exception
                when Program_Error =>
                    Comment("Program_Error -- OK");
            end;
        else
            if C854002_1.Renamings.F_Result /= C854002_1.Renamings.Renamed_F then
                Failed("Bad result from renamed F");
            end if;
        end if;
    end Call_Renamed_F;

    procedure Call_Renamed_G(Should_Fail: Boolean) is
    begin
        if Should_Fail then
            begin
                Failed(C854002_1.Renamings.Renamed_G);
                raise Some_Error;
            exception
                when Program_Error =>
                    Comment("Program_Error -- OK");
            end;
        else
            if C854002_1.Renamings.G_Result /= C854002_1.Renamings.Renamed_G then
                Failed("Bad result from renamed G");
            end if;
        end if;
    end Call_Renamed_G;

begin
    -- At this point, the bodies of Renamed_F and Renamed_G have not yet
    -- been elaborated, so calling them should raise Program_Error:
    Call_Renamed_F(Should_Fail => True);
    Call_Renamed_G(Should_Fail => True);
end C854002_1.Caller;

package body C854002_1.Pure is

    function F return String is
    begin
        return "This is function F";
    end F;

    function G return String is
    begin
        return "This is function G";
    end G;

end C854002_1.Pure;

with C854002_1.Pure;
with C854002_1.Caller; pragma Elaborate(C854002_1.Caller);
    -- This pragma ensures that this package body (Renamings)
    -- will be elaborated after Caller, so that when Caller calls
    -- the renamings during its elaboration, the renamings will
    -- not have been elaborated (although what the rename have been).
package body C854002_1.Renamings is

    function Renamed_F return String renames C854002_1.Pure.F;

    package Dummy is end; -- So we can insert statements here.
    package body Dummy is
    begin
        G_Pointer := C854002_1.Pure.G'Access;
    end Dummy;

    function Renamed_G return String renames G_Pointer.all;

end C854002_1.Renamings;

with Report; use Report;
with C854002_1.Caller;
procedure C854002 is
begin
    Test("C854002",
         "An elaboration check is performed for a call to a subprogram"
         & " whose body is given as a renaming-as-body");

    -- By the time we get here, all library units have been elaborated,
    -- so the following calls should not raise Program_Error:
    C854002_1.Caller.Call_Renamed_F(Should_Fail => False);
    C854002_1.Caller.Call_Renamed_G(Should_Fail => False);

    Result;
end C854002;