Subversion Repositories openrisc

-- C74209A.ADA

--                             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.

--*

-- CHECK THAT OUTSIDE A PACKAGE WHICH DEFINES PRIVATE TYPES AND LIMITED

--    PRIVATE TYPES  IT IS POSSIBLE TO DECLARE SUBPROGRAMS WHICH USE

--    THOSE TYPES AS TYPES FOR PARAMETERS (OF ANY MODE EXCEPT OUT FOR A

--    LIMITED TYPE) OR AS THE TYPE FOR THE RESULT (FOR FUNCTION

--    SUBPROGRAMS). 

-- RM 07/14/81

WITH REPORT;

PROCEDURE  C74209A  IS

     USE  REPORT;

BEGIN

     TEST( "C74209A" , "CHECK THAT PROCEDURE SIGNATURES CAN USE " &

                       "PRIVATE TYPES" );

     DECLARE

          PACKAGE  PACK  IS

               TYPE  LIM_PRIV  IS LIMITED PRIVATE;

               TYPE  PRIV      IS         PRIVATE;

               PRIV_CONST_IN   :  CONSTANT  PRIV;

               PRIV_CONST_OUT  :  CONSTANT  PRIV;

               FUNCTION  PACKAGED( X: IN INTEGER )  RETURN LIM_PRIV;

               FUNCTION  EQUALS( X , Y : LIM_PRIV ) RETURN BOOLEAN ;

               PROCEDURE ASSIGN( X : IN  LIM_PRIV; Y : OUT LIM_PRIV );

          PRIVATE

               TYPE  LIM_PRIV  IS NEW INTEGER;

               TYPE  PRIV      IS NEW STRING( 1..5 );

               PRIV_CONST_IN   :  CONSTANT  PRIV :=  "ABCDE";

               PRIV_CONST_OUT  :  CONSTANT  PRIV :=  "FGHIJ";

          END  PACK;

          PRIV_VAR_1 ,     PRIV_VAR_2      :  PACK.PRIV;

          LIM_PRIV_VAR_1 , LIM_PRIV_VAR_2  :  PACK.LIM_PRIV;

          USE  PACK;

          PACKAGE BODY  PACK  IS

               FUNCTION  PACKAGED( X: IN INTEGER )  RETURN LIM_PRIV  IS

               BEGIN

                    RETURN  LIM_PRIV(X);

               END  PACKAGED;

               FUNCTION  EQUALS( X , Y : LIM_PRIV ) RETURN BOOLEAN  IS

               BEGIN

                    RETURN  X = Y ;

               END  EQUALS;

               PROCEDURE ASSIGN( X : IN  LIM_PRIV; Y : OUT LIM_PRIV) IS

               BEGIN

                    Y := X;

               END  ASSIGN;

          END  PACK;

          PROCEDURE  PROC1( X : IN OUT PACK.PRIV;

                            Y : IN     PACK.PRIV := PACK.PRIV_CONST_IN;

                            Z : OUT    PACK.PRIV;

                            U :        PACK.PRIV )  IS

          BEGIN

               IF  X /= PACK.PRIV_CONST_IN  OR

                   Y /= PACK.PRIV_CONST_IN  OR

                   U /= PACK.PRIV_CONST_IN

               THEN

                    FAILED( "WRONG INPUT VALUES  -  PROC1" );

               END IF;

               X := PACK.PRIV_CONST_OUT;

               Z := PACK.PRIV_CONST_OUT;

          END  PROC1;

          PROCEDURE  PROC2( X : IN OUT LIM_PRIV;

                            Y : IN     LIM_PRIV;

                            Z : IN OUT LIM_PRIV;

                            U :        LIM_PRIV )  IS

          BEGIN

               IF  NOT(EQUALS( X , PACKAGED(17) ))  OR

                   NOT(EQUALS( Y , PACKAGED(17) ))  OR

                   NOT(EQUALS( U , PACKAGED(17) ))

               THEN

                    FAILED( "WRONG INPUT VALUES  -  PROC2" );

               END IF;

               ASSIGN( PACKAGED(13) , X );

               ASSIGN( PACKAGED(13) , Z );

          END  PROC2;

          FUNCTION  FUNC1( Y : IN  PRIV  :=  PRIV_CONST_IN;

                           U :     PRIV  )   RETURN  PRIV  IS

          BEGIN

               IF  Y /= PRIV_CONST_IN  OR

                   U /= PRIV_CONST_IN

               THEN

                    FAILED( "WRONG INPUT VALUES  -  FUNC1" );

               END IF;

               RETURN  PRIV_CONST_OUT;

          END  FUNC1;

          FUNCTION  FUNC2( Y : IN  LIM_PRIV;

                           U :     LIM_PRIV )  RETURN  LIM_PRIV  IS

          BEGIN

               IF  NOT(EQUALS( Y , PACKAGED(17) ))  OR

                   NOT(EQUALS( U , PACKAGED(17) ))

               THEN

                    FAILED( "WRONG INPUT VALUES  -  FUNC2" );

               END IF;

               RETURN  PACKAGED(13);

          END  FUNC2;

     BEGIN

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

          PRIV_VAR_1 := PRIV_CONST_IN;

          PRIV_VAR_2 := PRIV_CONST_IN;

          PROC1( PRIV_VAR_1 , Z => PRIV_VAR_2 , U => PRIV_CONST_IN );

          IF  PRIV_VAR_1 /= PACK.PRIV_CONST_OUT  OR

              PRIV_VAR_2 /= PACK.PRIV_CONST_OUT

          THEN

               FAILED( "WRONG OUTPUT VALUES  -  PROC1" );

          END IF;

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

          ASSIGN( PACKAGED(17) , LIM_PRIV_VAR_1 );

          ASSIGN( PACKAGED(17) , LIM_PRIV_VAR_2 );

          PROC2( LIM_PRIV_VAR_1 , PACKAGED(17) ,

                 LIM_PRIV_VAR_2 , PACKAGED(17) );

          IF  NOT(EQUALS( LIM_PRIV_VAR_1 , PACKAGED(13) ))  OR

              NOT(EQUALS( LIM_PRIV_VAR_2 , PACKAGED(13) ))

          THEN

               FAILED( "WRONG OUTPUT VALUES  -  PROC2" );

          END IF;

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

          PRIV_VAR_1 := PRIV_CONST_IN;

          PRIV_VAR_2 := PRIV_CONST_IN;

          PRIV_VAR_1 :=

              FUNC1( PRIV_VAR_1 , U => PRIV_CONST_IN );

          IF  PRIV_VAR_1 /= PACK.PRIV_CONST_OUT

          THEN

               FAILED( "WRONG OUTPUT VALUES  -  FUNC1" );

          END IF;

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

          ASSIGN( PACKAGED(17) , LIM_PRIV_VAR_1 );

          ASSIGN( PACKAGED(17) , LIM_PRIV_VAR_2 );

          ASSIGN( FUNC2( LIM_PRIV_VAR_1 , PACKAGED(17)) ,

                  LIM_PRIV_VAR_1 );

          IF  NOT(EQUALS( LIM_PRIV_VAR_1 , PACKAGED(13) ))

          THEN

               FAILED( "WRONG OUTPUT VALUES  -  FUNC2" );

          END IF;

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

     END;

     RESULT;

END C74209A;