Subversion Repositories openrisc_me

-- A87B59A.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 BECAUSE A GENERIC ACTUAL PROGRAM PARAMETER MUST BE A 
-- SUBPROGRAM, AN ENUMERATION LITERAL, OR AN ENTRY WITH THE SAME 
-- PARAMETER AND RESULT TYPE PROFILE AS THE FORMAL PARAMETER, AN 
-- OVERLOADED NAME APPEARING AS AN ACTUAL PARAMETER CAN BE RESOLVED.
 
-- R.WILLIAMS 9/24/86
 
WITH REPORT; USE REPORT;
PROCEDURE A87B59A IS
 
BEGIN
     TEST ( "A87B59A", "CHECK THAT BECAUSE A GENERIC ACTUAL PROGRAM " &
                       "PARAMETER MUST BE A SUBPROGRAM, AN " &
                       "ENUMERATION LITERAL, OR AN ENTRY WITH THE " &
                       "SAME PARAMETER AND RESULT TYPE PROFILE AS " &
                       "THE FORMAL PARAMETER, AN OVERLOADED NAME " &
                       "APPEARING AS AN ACTUAL PARAMETER CAN BE " &
                       "RESOLVED" );
 
     DECLARE -- A.
          FUNCTION F1 RETURN INTEGER IS
          BEGIN
               RETURN IDENT_INT (0);
          END F1;
 
          FUNCTION F1 RETURN BOOLEAN IS
          BEGIN
               RETURN IDENT_BOOL (TRUE);
          END F1;
 
          GENERIC
               TYPE T IS (<>);
               WITH FUNCTION F RETURN T;
          PROCEDURE P;
 
          PROCEDURE P IS
          BEGIN
               NULL;
          END P;
 
          PROCEDURE P1 IS NEW P (INTEGER, F1);
          PROCEDURE P2 IS NEW P (BOOLEAN, F1);
 
     BEGIN         
          P1;
          P2;
     END; -- A.
 
     DECLARE -- B.
          FUNCTION F1 (X : INTEGER; B : BOOLEAN) RETURN INTEGER IS
          BEGIN
               RETURN IDENT_INT (X);
          END F1;
 
          FUNCTION F1 (X : INTEGER; B : BOOLEAN) RETURN BOOLEAN IS
          BEGIN
               RETURN IDENT_BOOL (B);
          END F1;
 
          FUNCTION F1 (B : BOOLEAN; X : INTEGER) RETURN BOOLEAN IS
          BEGIN
               RETURN IDENT_BOOL (B);
          END F1;
 
          GENERIC
               TYPE T1 IS (<>);
               TYPE T2 IS (<>);
               WITH FUNCTION F (A : T1; B : T2) RETURN T1;
          PROCEDURE P1;
 
          PROCEDURE P1 IS
          BEGIN
               NULL;
          END P1;
 
          GENERIC
               TYPE T1 IS (<>);
               TYPE T2 IS (<>);
               WITH FUNCTION F (A : T1; B : T2) RETURN T2;
          PROCEDURE P2;
 
          PROCEDURE P2 IS
          BEGIN
               NULL;
          END P2;
 
          PROCEDURE PROC1 IS NEW P1 (INTEGER, BOOLEAN, F1);
          PROCEDURE PROC2 IS NEW P1 (BOOLEAN, INTEGER, F1);
          PROCEDURE PROC3 IS NEW P2 (INTEGER, BOOLEAN, F1);
 
     BEGIN         
          PROC1;
          PROC2;
     END; -- B.
 
     DECLARE -- C.
          TYPE COLOR IS (RED, YELLOW, BLUE);
          C : COLOR;
 
          TYPE LIGHT IS (RED, YELLOW, GREEN);          
          L : LIGHT;
 
          GENERIC
               TYPE T IS (<>);
               WITH FUNCTION F RETURN T;
          FUNCTION GF RETURN T;
 
          FUNCTION GF RETURN T IS
          BEGIN
               RETURN T'VAL (IDENT_INT (T'POS (F)));
          END GF;
 
          FUNCTION F1 IS NEW GF (COLOR, RED);
          FUNCTION F2 IS NEW GF (LIGHT, YELLOW);
     BEGIN
          C := F1;
          L := F2;
     END; -- C.
 
     DECLARE -- D.
          TASK TK IS
               ENTRY E (X : INTEGER);
               ENTRY E (X : BOOLEAN);
               ENTRY E (X : INTEGER; Y : BOOLEAN);
               ENTRY E (X : BOOLEAN; Y : INTEGER);
          END TK;
 
          TASK BODY TK IS
          BEGIN
               LOOP
                    SELECT
                         ACCEPT E (X : INTEGER);
                    OR
                         ACCEPT E (X : BOOLEAN);
                    OR 
                         ACCEPT E (X : INTEGER; Y : BOOLEAN);
                    OR 
                         ACCEPT E (X : BOOLEAN; Y : INTEGER);
                    OR 
                         TERMINATE;
                    END SELECT;
               END LOOP;
          END TK;
 
          GENERIC
               TYPE T1 IS (<>);
               TYPE T2 IS (<>);
               WITH PROCEDURE P1 (X : T1);
               WITH PROCEDURE P2 (X : T1; Y : T2);
          PACKAGE PKG IS 
               PROCEDURE P;
          END PKG;
 
          PACKAGE BODY PKG IS
               PROCEDURE P IS
               BEGIN
                    IF EQUAL (3, 3) THEN
                         P1 (T1'VAL (1));
                         P2 (T1'VAL (0), T2'VAL (1));
                    END IF;
               END P;
          END PKG;
 
          PACKAGE PK1 IS NEW PKG (INTEGER, BOOLEAN, TK.E, TK.E);
          PACKAGE PK2 IS NEW PKG (BOOLEAN, INTEGER, TK.E, TK.E);
 
     BEGIN
          PK1.P;
          PK2.P;               
     END; -- D.
 
     DECLARE -- E.
          FUNCTION "+" (X, Y : BOOLEAN) RETURN BOOLEAN IS
          BEGIN
               RETURN IDENT_BOOL (X OR Y);
          END "+";
 
          GENERIC
               TYPE T IS (<>);
               WITH FUNCTION "+" (X, Y : T) RETURN T;
          PROCEDURE P;
 
          PROCEDURE P IS
               S : T;
          BEGIN
               S := "+" (T'VAL (0), T'VAL (1));
          END P;
 
          PROCEDURE P1 IS NEW P (BOOLEAN, "+");
          PROCEDURE P2 IS NEW P (INTEGER, "+");
 
     BEGIN
          P1;
          P2;
     END; -- E.
 
     DECLARE -- F.
          TYPE ADD_OPS IS ('+', '-', '&');
 
          GENERIC
               TYPE T1 IS (<>);
               TYPE T2 IS (<>);
               TYPE T3 IS ARRAY (POSITIVE RANGE <> ) OF T2;
               X2 : T2;
               X3 : T3;
               WITH FUNCTION F1 RETURN T1;
               WITH FUNCTION F2 (X : T2; Y : T3) RETURN T3;
          PROCEDURE P;
 
          PROCEDURE P IS
               A : T1;
               S : T3 (IDENT_INT (1) .. IDENT_INT (2));               
          BEGIN
               A := F1;
               S := F2 (X2, X3);               
          END P;
 
          PROCEDURE P1 IS NEW P (ADD_OPS, CHARACTER, STRING,
                                 '&', "&", '&', "&");
 
     BEGIN
          P1;
     END; -- F.
 
     RESULT;
END A87B59A;