Subversion Repositories openrisc

-- C650001.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, for a function result type that is a return-by-reference

--      type, Program_Error is raised if the return expression is a name that

--      denotes an object view whose accessibility level is deeper than that

--      of the master that elaborated the function body.

--

--      Check for cases where the result type is:

--         (a) A tagged limited type.

--         (b) A task type.

--         (c) A protected type.

--         (d) A composite type with a subcomponent of a

--             return-by-reference type (task type).

--

-- TEST DESCRIPTION:

--      The accessibility level of the master that elaborates the body of a

--      return-by-reference function will always be less deep than that of

--      the function (which is itself a master).

--

--      Thus, the return object may not be any of the following, since each

--      has an accessibility level at least as deep as that of the function:

--

--         (1) An object declared local to the function.

--         (2) The result of a local function.

--         (3) A parameter of the function.

--

--      Verify that Program_Error is raised within the return-by-reference

--      function if the return object is any of (1)-(3) above, for various

--      subsets of the return types (a)-(d) above. Include cases where (1)-(3)

--      are operands of parenthesized expressions.

--

--      Verify that no exception is raised if the return object is any of the

--      following:

--

--         (4) An object declared at a less deep level than that of the

--             master that elaborated the function body.

--         (5) The result of a function declared at the same level as the

--             original function (assuming the new function is also legal).

--         (6) A parameter of the master that elaborated the function body.

--

--      For (5), pass the new function as an actual via an access-to-

--      subprogram parameter of the original function. Check for cases where

--      the new function does and does not raise an exception.

--

--      Since the functions to be tested cannot be part of an assignment

--      statement (since they return values of a limited type), pass each

--      function result as an actual parameter to a dummy procedure, e.g.,

--

--         Dummy_Proc ( Function_Call );

--

--

-- CHANGE HISTORY:

--      03 May 95   SAIC    Initial prerelease version.

--      08 Feb 99   RLB     Removed subcase with two errors.

--

--!

package C650001_0 is

   type Tagged_Limited is tagged limited record

      C: String (1 .. 10);

   end record;

   task type Task_Type;

   protected type Protected_Type is

      procedure Op;

   end Protected_Type;

   type Task_Array is array (1 .. 10) of Task_Type;

   type Variant_Record (Toggle: Boolean) is record

      case Toggle is

         when True  =>

            T: Task_Type;  -- Return-by-reference component.

         when False =>

            I: Integer;    -- Non-return-by-reference component.

      end case;

   end record;

   -- Limited type even though variant contains no limited components:

   type Non_Task_Variant is new Variant_Record (Toggle => False);

end C650001_0;

     --==================================================================--

package body C650001_0 is

   task body Task_Type is

   begin

      null;

   end Task_Type;

   protected body Protected_Type is

      procedure Op is

      begin

         null;

      end Op;

   end Protected_Type;

end C650001_0;

     --==================================================================--

with C650001_0;

package C650001_1 is

   type TC_Result_Kind is (OK, P_E, O_E);

   procedure TC_Display_Results (Actual  : in TC_Result_Kind;

                                 Expected: in TC_Result_Kind;

                                 Message : in String);

   -- Dummy procedures:

   procedure Check_Tagged    (P: C650001_0.Tagged_Limited);

   procedure Check_Task      (P: C650001_0.Task_Type);

   procedure Check_Protected (P: C650001_0.Protected_Type);

   procedure Check_Composite (P: C650001_0.Non_Task_Variant);

end C650001_1;

     --==================================================================--

with Report;

package body C650001_1 is

   procedure TC_Display_Results (Actual  : in TC_Result_Kind;

                                 Expected: in TC_Result_Kind;

                                 Message : in String) is

   begin

      if Actual /= Expected then

         case Actual is

            when OK  =>

               Report.Failed ("No exception raised: "         & Message);

            when P_E =>

               Report.Failed ("Program_Error raised: "        & Message);

            when O_E =>

               Report.Failed ("Unexpected exception raised: " & Message);

         end case;

      end if;

   end TC_Display_Results;

   procedure Check_Tagged (P: C650001_0.Tagged_Limited) is

   begin

      null;

   end;

   procedure Check_Task (P: C650001_0.Task_Type) is

   begin

      null;

   end;

   procedure Check_Protected (P: C650001_0.Protected_Type) is

   begin

      null;

   end;

   procedure Check_Composite (P: C650001_0.Non_Task_Variant) is

   begin

      null;

   end;

end C650001_1;

     --==================================================================--

with C650001_0;

with C650001_1;

with Report;

procedure C650001 is

begin

   Report.Test ("C650001", "Check that, for a function result type that " &

                "is a return-by-reference type, Program_Error is raised " &

                "if the return expression is a name that denotes an "     &

                "object view whose accessibility level is deeper than "   &

                "that of the master that elaborated the function body");

   SUBTEST1:

   declare

      Result: C650001_1.TC_Result_Kind;

      PO    : C650001_0.Protected_Type;

      function Return_Prot (P: C650001_0.Protected_Type)

        return C650001_0.Protected_Type is

      begin

         Result := C650001_1.OK;

         return P;                                     -- Formal parameter (3).

      exception

         when Program_Error =>

            Result := C650001_1.P_E;                        -- Expected result.

            return PO;

         when others        =>

            Result := C650001_1.O_E;

            return PO;

      end Return_Prot;

   begin  -- SUBTEST1.

      C650001_1.Check_Protected ( Return_Prot(PO) );

      C650001_1.TC_Display_Results (Result, C650001_1.P_E, "SUBTEST #1");

   exception

      when others =>

         Report.Failed ("SUBTEST #1: Unexpected exception in outer block");

   end SUBTEST1;

   SUBTEST2:

   declare

      Result: C650001_1.TC_Result_Kind;

      Comp  : C650001_0.Non_Task_Variant;

      function Return_Composite return C650001_0.Non_Task_Variant is

         Local: C650001_0.Non_Task_Variant;

      begin

         Result := C650001_1.OK;

         return (Local);                     -- Parenthesized local object (1).

      exception

         when Program_Error =>

            Result := C650001_1.P_E;                        -- Expected result.

            return Comp;

         when others        =>

            Result := C650001_1.O_E;

            return Comp;

      end Return_Composite;

   begin -- SUBTEST2.

      C650001_1.Check_Composite ( Return_Composite );

      C650001_1.TC_Display_Results (Result, C650001_1.P_E, "SUBTEST #2");

   exception

      when others =>

         Report.Failed ("SUBTEST #2: Unexpected exception in outer block");

   end SUBTEST2;

   SUBTEST3:

   declare

      Result: C650001_1.TC_Result_Kind;

      Tsk   : C650001_0.Task_Type;

      TskArr: C650001_0.Task_Array;

      function Return_Task (P: C650001_0.Task_Array)

        return C650001_0.Task_Type is

         function Inner return C650001_0.Task_Type is

         begin

            return P(P'First);           -- OK: should not raise exception (6).

         exception

            when Program_Error =>

               Report.Failed ("SUBTEST #3: Program_Error incorrectly " &

                              "raised within function Inner");

               return Tsk;

            when others        =>

               Report.Failed ("SUBTEST #3: Unexpected exception " &

                              "raised within function Inner");

               return Tsk;

         end Inner;

      begin -- Return_Task.

         Result := C650001_1.OK;

         return Inner;                           -- Call to local function (2).

      exception

         when Program_Error =>

            Result := C650001_1.P_E;                        -- Expected result.

            return Tsk;

         when others        =>

            Result := C650001_1.O_E;

            return Tsk;

      end Return_Task;

   begin -- SUBTEST3.

      C650001_1.Check_Task ( Return_Task(TskArr) );

      C650001_1.TC_Display_Results (Result, C650001_1.P_E, "SUBTEST #3");

   exception

      when others =>

         Report.Failed ("SUBTEST #3: Unexpected exception in outer block");

   end SUBTEST3;

   SUBTEST4:

   declare

      Result: C650001_1.TC_Result_Kind;

      TagLim: C650001_0.Tagged_Limited;

      function Return_TagLim (P: C650001_0.Tagged_Limited'Class)

        return C650001_0.Tagged_Limited is

      begin

         Result := C650001_1.OK;

         return C650001_0.Tagged_Limited(P); -- Conversion of formal param (3).

      exception

         when Program_Error =>

            Result := C650001_1.P_E;                        -- Expected result.

            return TagLim;

         when others        =>

            Result := C650001_1.O_E;

            return TagLim;

      end Return_TagLim;

   begin -- SUBTEST4.

      C650001_1.Check_Tagged ( Return_TagLim(TagLim) );

      C650001_1.TC_Display_Results (Result, C650001_1.P_E,

                                    "SUBTEST #4 (root type)");

   exception

      when others =>

         Report.Failed ("SUBTEST #4: Unexpected exception in outer block");

   end SUBTEST4;

   SUBTEST5:

   declare

      Tsk : C650001_0.Task_Type;

   begin  -- SUBTEST5.

      declare

         Result: C650001_1.TC_Result_Kind;

         type AccToFunc is access function return C650001_0.Task_Type;

         function Return_Global return C650001_0.Task_Type is

         begin

            return Tsk;                  -- OK: should not raise exception (4).

         end Return_Global;

         function Return_Local return C650001_0.Task_Type is

            Local : C650001_0.Task_Type;

         begin

            return Local;                           -- Propagate Program_Error.

         end Return_Local;

         function Return_Func (P: AccToFunc) return C650001_0.Task_Type is

         begin

            Result := C650001_1.OK;

            return P.all;                                 -- Function call (5).

         exception

            when Program_Error =>

               Result := C650001_1.P_E;

               return Tsk;

            when others        =>

               Result := C650001_1.O_E;

               return Tsk;

         end Return_Func;

         RG : AccToFunc := Return_Global'Access;

         RL : AccToFunc := Return_Local'Access;

      begin

         C650001_1.Check_Task ( Return_Func(RG) );

         C650001_1.TC_Display_Results (Result, C650001_1.OK,

                                       "SUBTEST #5 (global task)");

         C650001_1.Check_Task ( Return_Func(RL) );

         C650001_1.TC_Display_Results (Result, C650001_1.P_E,

                                       "SUBTEST #5 (local task)");

      exception

         when others =>

            Report.Failed ("SUBTEST #5: Unexpected exception in outer block");

      end;

   end SUBTEST5;

   Report.Result;

end C650001;