-- CB40005.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 exceptions raised in non-generic code can be handled by
--      a procedure in a generic package.  Check that the exception identity
--      can be properly retrieved from the generic code and used by the
--      non-generic code.
--
-- TEST DESCRIPTION:
--      This test models a possible usage paradigm for the type:
--        Ada.Exceptions.Exception_Occurrence.
--
--      A generic package takes access to procedure types (allowing it to
--      be used at any accessibility level) and defines a "fail soft"
--      procedure that takes designators to a procedure to call, a
--      procedure to call in the event that it fails, and a function to
--      call to determine the next action.
--
--      In the event an exception occurs on the call to the first procedure,
--      the exception is stored in a stack; along with the designator to the
--      procedure that caused it; allowing the procedure to be called again, 
--      or the exception to be re-raised.
--
--      A full implementation of such a tool would use a more robust storage
--      mechanism, and would provide a more flexible interface.
--
--
-- CHANGE HISTORY:
--      29 MAR 96   SAIC   Initial version
--      12 NOV 96   SAIC   Revised for 2.1 release
--
--!

----------------------------------------------------------------- CB40005_0

with Ada.Exceptions;
generic
  type Proc_Pointer is access procedure;
  type Func_Pointer is access function return Proc_Pointer;
package CB40005_0 is -- Fail_Soft


  procedure Fail_Soft_Call( Proc_To_Call : Proc_Pointer;
                            Proc_To_Call_On_Exception : Proc_Pointer := null;
                            Retry_Routine : Func_Pointer := null );

  function Top_Event_Exception return Ada.Exceptions.Exception_Occurrence;

  function Top_Event_Procedure return Proc_Pointer;

  procedure Pop_Event;

  function Event_Stack_Size return Natural;

end CB40005_0; -- Fail_Soft

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- CB40005_0

with Report;
package body CB40005_0 is

  type History_Event is record
    Exception_Event  : Ada.Exceptions.Exception_Occurrence_Access;
    Procedure_Called : Proc_Pointer;
  end record;

  procedure Store_Event( Proc_Called : Proc_Pointer;
                         Error       : Ada.Exceptions.Exception_Occurrence );

  procedure Fail_Soft_Call( Proc_To_Call : Proc_Pointer;
                            Proc_To_Call_On_Exception : Proc_Pointer := null;
                            Retry_Routine : Func_Pointer := null ) is

    Current_Proc_To_Call : Proc_Pointer := Proc_To_Call;

  begin
    while Current_Proc_To_Call /= null loop
      begin
        Current_Proc_To_Call.all;  -- call procedure through pointer
        Current_Proc_To_Call := null;
      exception
        when Capture: others =>
          Store_Event( Current_Proc_To_Call, Capture );
          if Proc_To_Call_On_Exception /= null then
            Proc_To_Call_On_Exception.all;
          end if;
          if Retry_Routine /= null then
            Current_Proc_To_Call := Retry_Routine.all;
          else
            Current_Proc_To_Call := null;
          end if;
      end;
    end loop;
  end Fail_Soft_Call;
  
  Stack : array(1..10) of History_Event;  -- minimal, sufficient for testing

  Stack_Top : Natural := 0;

  procedure Store_Event( Proc_Called : Proc_Pointer;
                         Error       : Ada.Exceptions.Exception_Occurrence )
  is
  begin
    Stack_Top := Stack_Top +1;
    Stack(Stack_Top) := ( Ada.Exceptions.Save_Occurrence(Error),
                          Proc_Called );
  end Store_Event;

  function Top_Event_Exception return Ada.Exceptions.Exception_Occurrence is
  begin
    if Stack_Top > 0 then
      return Stack(Stack_Top).Exception_Event.all;
    else
      return Ada.Exceptions.Null_Occurrence;
    end if;
  end Top_Event_Exception;

  function Top_Event_Procedure return Proc_Pointer is
  begin
    if Stack_Top > 0 then
      return Stack(Stack_Top).Procedure_Called;
    else
      return null;
    end if;
  end Top_Event_Procedure;

  procedure Pop_Event is
  begin
    if Stack_Top > 0 then
      Stack_Top := Stack_Top -1;
    else
      Report.Failed("Stack Error");
    end if;
  end Pop_Event;

  function Event_Stack_Size return Natural is
  begin
    return Stack_Top;
  end Event_Stack_Size;

end CB40005_0;

------------------------------------------------------------------- CB40005

with Report;
with TCTouch;
with CB40005_0;
with Ada.Exceptions;
procedure CB40005 is

  type Proc_Pointer is access procedure;
  type Func_Pointer is access function return Proc_Pointer;

  package Fail_Soft is new CB40005_0(Proc_Pointer, Func_Pointer);

  procedure Cause_Standard_Exception;

  procedure Cause_Visible_Exception;

  procedure Cause_Invisible_Exception;

  Exception_Procedure_Pointer : Proc_Pointer;

  Visible_Exception : exception;

  procedure Action_On_Exception;

  function Retry_Procedure return Proc_Pointer;

  Raise_Error : Boolean;

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

  procedure Cause_Standard_Exception is
  begin
    TCTouch.Touch('S');  --------------------------------------------------- S
    if Raise_Error then
      raise Constraint_Error;
    end if;
  end Cause_Standard_Exception;

  procedure Cause_Visible_Exception is
  begin
    TCTouch.Touch('V');  --------------------------------------------------- V
    if Raise_Error then
      raise Visible_Exception;
    end if;
  end Cause_Visible_Exception;

  procedure Cause_Invisible_Exception is
    Invisible_Exception : exception;
  begin
    TCTouch.Touch('I');  --------------------------------------------------- I
    if Raise_Error then
      raise Invisible_Exception;
    end if;
  end Cause_Invisible_Exception;

  procedure Action_On_Exception is
  begin
    TCTouch.Touch('A');  --------------------------------------------------- A
  end Action_On_Exception;

  function Retry_Procedure return Proc_Pointer is
  begin
    TCTouch.Touch('R');  --------------------------------------------------- R
    return Action_On_Exception'Access;
  end Retry_Procedure;

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

begin  -- Main test procedure.

  Report.Test ("CB40005", "Check that exceptions raised in non-generic " &
                          "code can be handled by a procedure in a generic " &
                          "package.  Check that the exception identity can " &
                          "be properly retrieved from the generic code and " &
                          "used by the non-generic code" );

  -- first, check that the no exception cases cause no action on the stack
  Raise_Error := False;

  Fail_Soft.Fail_Soft_Call( Cause_Standard_Exception'Access );    -- S

  Fail_Soft.Fail_Soft_Call( Cause_Visible_Exception'Access,       -- V
                            Action_On_Exception'Access,
                            Retry_Procedure'Access );

  Fail_Soft.Fail_Soft_Call( Cause_Invisible_Exception'Access,     -- I
                            null,
                            Retry_Procedure'Access );

  TCTouch.Assert( Fail_Soft.Event_Stack_Size = 0, "Empty stack");

  TCTouch.Validate( "SVI", "Non error case check" );

  -- second, check that error cases add to the stack
  Raise_Error := True;

  Fail_Soft.Fail_Soft_Call( Cause_Standard_Exception'Access );    -- S

  Fail_Soft.Fail_Soft_Call( Cause_Visible_Exception'Access,       -- V
                            Action_On_Exception'Access,           -- A
                            Retry_Procedure'Access );             -- RA

  Fail_Soft.Fail_Soft_Call( Cause_Invisible_Exception'Access,     -- I
                            null,
                            Retry_Procedure'Access );             -- RA

  TCTouch.Assert( Fail_Soft.Event_Stack_Size = 3, "Stack = 3");

  TCTouch.Validate( "SVARAIRA", "Error case check" );

  -- check that the exceptions and procedure were stored correctly
  -- on the stack
  Raise_Error := False;

  -- return procedure pointer from top of stack and call the procedure
  -- through that pointer:

  Fail_Soft.Top_Event_Procedure.all;

  TCTouch.Validate( "I", "Invisible case unwind" );

  begin
    Ada.Exceptions.Raise_Exception( 
      Ada.Exceptions.Exception_Identity(Fail_Soft.Top_Event_Exception) );
    Report.Failed("1: Exception not raised");
  exception
    when Constraint_Error  => Report.Failed("1: Raised Constraint_Error");
    when Visible_Exception => Report.Failed("1: Raised Visible_Exception");
    when others            => null; -- expected case
  end;

  Fail_Soft.Pop_Event;

  -- return procedure pointer from top of stack and call the procedure
  -- through that pointer:

  Fail_Soft.Top_Event_Procedure.all;

  TCTouch.Validate( "V", "Visible case unwind" );

  begin
    Ada.Exceptions.Raise_Exception( 
      Ada.Exceptions.Exception_Identity(Fail_Soft.Top_Event_Exception) );
    Report.Failed("2: Exception not raised");
  exception
    when Constraint_Error  => Report.Failed("2: Raised Constraint_Error");
    when Visible_Exception => null; -- expected case
    when others            => Report.Failed("2: Raised Invisible_Exception");
  end;

  Fail_Soft.Pop_Event;

  Fail_Soft.Top_Event_Procedure.all;

  TCTouch.Validate( "S", "Standard case unwind" );

  begin
    Ada.Exceptions.Raise_Exception( 
      Ada.Exceptions.Exception_Identity(Fail_Soft.Top_Event_Exception) );
    Report.Failed("3: Exception not raised");
  exception
    when Constraint_Error  => null; -- expected case
    when Visible_Exception => Report.Failed("3: Raised Visible_Exception");
    when others            => Report.Failed("3: Raised Invisible_Exception");
  end;

  Fail_Soft.Pop_Event;

  TCTouch.Assert( Fail_Soft.Event_Stack_Size = 0, "Stack empty after pops");

  Report.Result;

end CB40005;