-- C67002C.ADA
|
-- C67002C.ADA
|
|
|
-- Grant of Unlimited Rights
|
-- Grant of Unlimited Rights
|
--
|
--
|
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
|
-- 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
|
-- 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 in the software and documentation contained herein.
|
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
|
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
|
-- this public release, the Government intends to confer upon all
|
-- this public release, the Government intends to confer upon all
|
-- recipients unlimited rights equal to those held by the Government.
|
-- recipients unlimited rights equal to those held by the Government.
|
-- These rights include rights to use, duplicate, release or disclose the
|
-- These rights include rights to use, duplicate, release or disclose the
|
-- released technical data and computer software in whole or in part, in
|
-- 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
|
-- any manner and for any purpose whatsoever, and to have or permit others
|
-- to do so.
|
-- to do so.
|
--
|
--
|
-- DISCLAIMER
|
-- DISCLAIMER
|
--
|
--
|
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
|
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
|
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
|
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
|
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
|
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
|
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
|
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
|
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
|
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
|
-- PARTICULAR PURPOSE OF SAID MATERIAL.
|
-- PARTICULAR PURPOSE OF SAID MATERIAL.
|
--*
|
--*
|
-- CHECK THAT ALL OPERATOR SYMBOLS CAN BE USED IN (OVERLOADED)
|
-- CHECK THAT ALL OPERATOR SYMBOLS CAN BE USED IN (OVERLOADED)
|
-- FUNCTION SPECIFICATIONS WITH THE REQUIRED NUMBER OF PARAMETERS.
|
-- FUNCTION SPECIFICATIONS WITH THE REQUIRED NUMBER OF PARAMETERS.
|
-- THIS TEST CHECKS FORMAL SUBPROGRAM PARAMETERS.
|
-- THIS TEST CHECKS FORMAL SUBPROGRAM PARAMETERS.
|
-- SUBTESTS ARE:
|
-- SUBTESTS ARE:
|
-- (A) THROUGH (P): "=", "AND", "OR", "XOR", "<", "<=",
|
-- (A) THROUGH (P): "=", "AND", "OR", "XOR", "<", "<=",
|
-- ">", ">=", "&", "*", "/", "MOD", "REM", "**", "+", "-",
|
-- ">", ">=", "&", "*", "/", "MOD", "REM", "**", "+", "-",
|
-- RESPECTIVELY. ALL OF THESE HAVE TWO PARAMETERS.
|
-- RESPECTIVELY. ALL OF THESE HAVE TWO PARAMETERS.
|
-- (Q), (R), (S), AND (T): "+", "-", "NOT", "ABS", RESPECTIVELY,
|
-- (Q), (R), (S), AND (T): "+", "-", "NOT", "ABS", RESPECTIVELY,
|
-- WITH ONE PARAMETER.
|
-- WITH ONE PARAMETER.
|
|
|
-- CPP 6/26/84
|
-- CPP 6/26/84
|
|
|
WITH REPORT; USE REPORT;
|
WITH REPORT; USE REPORT;
|
PROCEDURE C67002C IS
|
PROCEDURE C67002C IS
|
|
|
FUNCTION TWO_PARAMS (I1, I2 : INTEGER) RETURN CHARACTER IS
|
FUNCTION TWO_PARAMS (I1, I2 : INTEGER) RETURN CHARACTER IS
|
BEGIN
|
BEGIN
|
IF I1 > I2 THEN
|
IF I1 > I2 THEN
|
RETURN 'G';
|
RETURN 'G';
|
ELSE RETURN 'L';
|
ELSE RETURN 'L';
|
END IF;
|
END IF;
|
END TWO_PARAMS;
|
END TWO_PARAMS;
|
|
|
FUNCTION ONE_PARAM (I1 : INTEGER) RETURN CHARACTER IS
|
FUNCTION ONE_PARAM (I1 : INTEGER) RETURN CHARACTER IS
|
BEGIN
|
BEGIN
|
IF I1 < IDENT_INT(0) THEN
|
IF I1 < IDENT_INT(0) THEN
|
RETURN 'N';
|
RETURN 'N';
|
ELSE RETURN 'P';
|
ELSE RETURN 'P';
|
END IF;
|
END IF;
|
END ONE_PARAM;
|
END ONE_PARAM;
|
|
|
BEGIN
|
BEGIN
|
TEST ("C67002C", "USE OF OPERATOR SYMBOLS IN " &
|
TEST ("C67002C", "USE OF OPERATOR SYMBOLS IN " &
|
"(OVERLOADED) FUNCTION SPECIFICATIONS");
|
"(OVERLOADED) FUNCTION SPECIFICATIONS");
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (A)
|
DECLARE -- (A)
|
|
|
PACKAGE EQU IS
|
PACKAGE EQU IS
|
TYPE LP IS LIMITED PRIVATE;
|
TYPE LP IS LIMITED PRIVATE;
|
FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN;
|
FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN;
|
PRIVATE
|
PRIVATE
|
TYPE LP IS NEW INTEGER;
|
TYPE LP IS NEW INTEGER;
|
END EQU;
|
END EQU;
|
USE EQU;
|
USE EQU;
|
|
|
LP1, LP2 : LP;
|
LP1, LP2 : LP;
|
|
|
PACKAGE BODY EQU IS
|
PACKAGE BODY EQU IS
|
FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN IS
|
FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN IS
|
BEGIN
|
BEGIN
|
RETURN LPA > LPB;
|
RETURN LPA > LPB;
|
END "=";
|
END "=";
|
BEGIN
|
BEGIN
|
LP1 := LP (IDENT_INT (7));
|
LP1 := LP (IDENT_INT (7));
|
LP2 := LP (IDENT_INT (8));
|
LP2 := LP (IDENT_INT (8));
|
END EQU;
|
END EQU;
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN;
|
WITH FUNCTION "=" (LPA, LPB : LP) RETURN BOOLEAN;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (LP1 = LP2) OR NOT (LP2 = LP1) OR
|
IF (LP1 = LP2) OR NOT (LP2 = LP1) OR
|
(LP1 = LP1) OR (LP2 /= LP1) THEN
|
(LP1 = LP1) OR (LP2 /= LP1) THEN
|
FAILED ("OVERLOADING OF ""="" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""="" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE EQUAL IS NEW PKG ("=" => EQU."=");
|
PACKAGE EQUAL IS NEW PKG ("=" => EQU."=");
|
|
|
BEGIN -- (A)
|
BEGIN -- (A)
|
NULL;
|
NULL;
|
END; -- (A)
|
END; -- (A)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (B)
|
DECLARE -- (B)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "AND" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "AND" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) AND 1) /= 'G' OR
|
IF (IDENT_INT (10) AND 1) /= 'G' OR
|
(5 AND 10) /= 'L' THEN
|
(5 AND 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""AND"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""AND"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("AND" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("AND" => TWO_PARAMS);
|
|
|
BEGIN -- (B)
|
BEGIN -- (B)
|
NULL;
|
NULL;
|
END; -- (B)
|
END; -- (B)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (C)
|
DECLARE -- (C)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "OR" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "OR" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) OR 1) /= 'G' OR
|
IF (IDENT_INT (10) OR 1) /= 'G' OR
|
(5 OR 10) /= 'L' THEN
|
(5 OR 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""OR"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""OR"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("OR" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("OR" => TWO_PARAMS);
|
|
|
BEGIN -- (C)
|
BEGIN -- (C)
|
NULL;
|
NULL;
|
END; -- (C)
|
END; -- (C)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (D)
|
DECLARE -- (D)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "XOR" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "XOR" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) XOR 1) /= 'G' OR
|
IF (IDENT_INT (10) XOR 1) /= 'G' OR
|
(5 XOR 10) /= 'L' THEN
|
(5 XOR 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""XOR"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""XOR"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("XOR" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("XOR" => TWO_PARAMS);
|
|
|
BEGIN -- (D)
|
BEGIN -- (D)
|
NULL;
|
NULL;
|
END; -- (D)
|
END; -- (D)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (E)
|
DECLARE -- (E)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "<" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "<" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) < 1) /= 'G' OR
|
IF (IDENT_INT (10) < 1) /= 'G' OR
|
(5 < 10) /= 'L' THEN
|
(5 < 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""<"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""<"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("<" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("<" => TWO_PARAMS);
|
|
|
BEGIN -- (E)
|
BEGIN -- (E)
|
NULL;
|
NULL;
|
END; -- (E)
|
END; -- (E)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (F)
|
DECLARE -- (F)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "<=" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "<=" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) <= 1) /= 'G' OR
|
IF (IDENT_INT (10) <= 1) /= 'G' OR
|
(5 <= 10) /= 'L' THEN
|
(5 <= 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""<="" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""<="" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("<=" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("<=" => TWO_PARAMS);
|
|
|
BEGIN -- (F)
|
BEGIN -- (F)
|
NULL;
|
NULL;
|
END; -- (F)
|
END; -- (F)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (G)
|
DECLARE -- (G)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION ">" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION ">" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) > 1) /= 'G' OR
|
IF (IDENT_INT (10) > 1) /= 'G' OR
|
(5 > 10) /= 'L' THEN
|
(5 > 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF "">"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF "">"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG (">" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG (">" => TWO_PARAMS);
|
|
|
BEGIN -- (G)
|
BEGIN -- (G)
|
NULL;
|
NULL;
|
END; -- (G)
|
END; -- (G)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (H)
|
DECLARE -- (H)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION ">=" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION ">=" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) >= 1) /= 'G' OR
|
IF (IDENT_INT (10) >= 1) /= 'G' OR
|
(5 >= 10) /= 'L' THEN
|
(5 >= 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF "">="" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF "">="" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG (">=" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG (">=" => TWO_PARAMS);
|
|
|
BEGIN -- (H)
|
BEGIN -- (H)
|
NULL;
|
NULL;
|
END; -- (H)
|
END; -- (H)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (I)
|
DECLARE -- (I)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "&" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "&" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) & 1) /= 'G' OR
|
IF (IDENT_INT (10) & 1) /= 'G' OR
|
(5 & 10) /= 'L' THEN
|
(5 & 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""&"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""&"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("&" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("&" => TWO_PARAMS);
|
|
|
BEGIN -- (I)
|
BEGIN -- (I)
|
NULL;
|
NULL;
|
END; -- (I)
|
END; -- (I)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (J)
|
DECLARE -- (J)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "*" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "*" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) * 1) /= 'G' OR
|
IF (IDENT_INT (10) * 1) /= 'G' OR
|
(5 * 10) /= 'L' THEN
|
(5 * 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""*"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""*"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("*" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("*" => TWO_PARAMS);
|
|
|
BEGIN -- (J)
|
BEGIN -- (J)
|
NULL;
|
NULL;
|
END; -- (J)
|
END; -- (J)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (K)
|
DECLARE -- (K)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "/" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "/" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) / 1) /= 'G' OR
|
IF (IDENT_INT (10) / 1) /= 'G' OR
|
(5 / 10) /= 'L' THEN
|
(5 / 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""/"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""/"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("/" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("/" => TWO_PARAMS);
|
|
|
BEGIN -- (K)
|
BEGIN -- (K)
|
NULL;
|
NULL;
|
END; -- (K)
|
END; -- (K)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (L)
|
DECLARE -- (L)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "MOD" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "MOD" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) MOD 1) /= 'G' OR
|
IF (IDENT_INT (10) MOD 1) /= 'G' OR
|
(5 MOD 10) /= 'L' THEN
|
(5 MOD 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""MOD"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""MOD"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("MOD" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("MOD" => TWO_PARAMS);
|
|
|
BEGIN -- (L)
|
BEGIN -- (L)
|
NULL;
|
NULL;
|
END; -- (L)
|
END; -- (L)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (M)
|
DECLARE -- (M)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "REM" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "REM" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) REM 1) /= 'G' OR
|
IF (IDENT_INT (10) REM 1) /= 'G' OR
|
(5 REM 10) /= 'L' THEN
|
(5 REM 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""REM"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""REM"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("REM" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("REM" => TWO_PARAMS);
|
|
|
BEGIN -- (M)
|
BEGIN -- (M)
|
NULL;
|
NULL;
|
END; -- (M)
|
END; -- (M)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (N)
|
DECLARE -- (N)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "**" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "**" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) ** 1) /= 'G' OR
|
IF (IDENT_INT (10) ** 1) /= 'G' OR
|
(5 ** 10) /= 'L' THEN
|
(5 ** 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""**"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""**"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("**" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("**" => TWO_PARAMS);
|
|
|
BEGIN -- (N)
|
BEGIN -- (N)
|
NULL;
|
NULL;
|
END; -- (N)
|
END; -- (N)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (O)
|
DECLARE -- (O)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "+" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "+" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) + 1) /= 'G' OR
|
IF (IDENT_INT (10) + 1) /= 'G' OR
|
(5 + 10) /= 'L' THEN
|
(5 + 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""+"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""+"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("+" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("+" => TWO_PARAMS);
|
|
|
BEGIN -- (O)
|
BEGIN -- (O)
|
NULL;
|
NULL;
|
END; -- (O)
|
END; -- (O)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (P)
|
DECLARE -- (P)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "-" (I1, I2 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "-" (I1, I2 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (IDENT_INT (10) - 1) /= 'G' OR
|
IF (IDENT_INT (10) - 1) /= 'G' OR
|
(5 - 10) /= 'L' THEN
|
(5 - 10) /= 'L' THEN
|
FAILED ("OVERLOADING OF ""-"" OPERATOR DEFECTIVE");
|
FAILED ("OVERLOADING OF ""-"" OPERATOR DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("-" => TWO_PARAMS);
|
PACKAGE PACK IS NEW PKG ("-" => TWO_PARAMS);
|
|
|
BEGIN -- (P)
|
BEGIN -- (P)
|
NULL;
|
NULL;
|
END; -- (P)
|
END; -- (P)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (Q)
|
DECLARE -- (Q)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "+" (I1 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "+" (I1 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (+ IDENT_INT(25) /= 'P') OR
|
IF (+ IDENT_INT(25) /= 'P') OR
|
(+ (0-25) /= 'N') THEN
|
(+ (0-25) /= 'N') THEN
|
FAILED ("OVERLOADING OF ""+"" " &
|
FAILED ("OVERLOADING OF ""+"" " &
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("+" => ONE_PARAM);
|
PACKAGE PACK IS NEW PKG ("+" => ONE_PARAM);
|
|
|
BEGIN -- (Q)
|
BEGIN -- (Q)
|
NULL;
|
NULL;
|
END; -- (Q)
|
END; -- (Q)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (R)
|
DECLARE -- (R)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "-" (I1 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "-" (I1 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (- IDENT_INT(25) /= 'P') OR
|
IF (- IDENT_INT(25) /= 'P') OR
|
(- (0-25) /= 'N') THEN
|
(- (0-25) /= 'N') THEN
|
FAILED ("OVERLOADING OF ""-"" " &
|
FAILED ("OVERLOADING OF ""-"" " &
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("-" => ONE_PARAM);
|
PACKAGE PACK IS NEW PKG ("-" => ONE_PARAM);
|
|
|
BEGIN -- (R)
|
BEGIN -- (R)
|
NULL;
|
NULL;
|
END; -- (R)
|
END; -- (R)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (S)
|
DECLARE -- (S)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "NOT" (I1 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "NOT" (I1 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (NOT IDENT_INT(25) /= 'P') OR
|
IF (NOT IDENT_INT(25) /= 'P') OR
|
(NOT (0-25) /= 'N') THEN
|
(NOT (0-25) /= 'N') THEN
|
FAILED ("OVERLOADING OF ""NOT"" " &
|
FAILED ("OVERLOADING OF ""NOT"" " &
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("NOT" => ONE_PARAM);
|
PACKAGE PACK IS NEW PKG ("NOT" => ONE_PARAM);
|
|
|
BEGIN -- (S)
|
BEGIN -- (S)
|
NULL;
|
NULL;
|
END; -- (S)
|
END; -- (S)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
DECLARE -- (T)
|
DECLARE -- (T)
|
|
|
GENERIC
|
GENERIC
|
WITH FUNCTION "ABS" (I1 : INTEGER) RETURN CHARACTER;
|
WITH FUNCTION "ABS" (I1 : INTEGER) RETURN CHARACTER;
|
PACKAGE PKG IS
|
PACKAGE PKG IS
|
END PKG;
|
END PKG;
|
|
|
PACKAGE BODY PKG IS
|
PACKAGE BODY PKG IS
|
BEGIN
|
BEGIN
|
IF (ABS IDENT_INT(25) /= 'P') OR
|
IF (ABS IDENT_INT(25) /= 'P') OR
|
(ABS (0-25) /= 'N') THEN
|
(ABS (0-25) /= 'N') THEN
|
FAILED ("OVERLOADING OF ""ABS"" " &
|
FAILED ("OVERLOADING OF ""ABS"" " &
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
"OPERATOR (ONE OPERAND) DEFECTIVE");
|
END IF;
|
END IF;
|
END PKG;
|
END PKG;
|
|
|
PACKAGE PACK IS NEW PKG ("ABS" => ONE_PARAM);
|
PACKAGE PACK IS NEW PKG ("ABS" => ONE_PARAM);
|
|
|
BEGIN -- (T)
|
BEGIN -- (T)
|
NULL;
|
NULL;
|
END; -- (T)
|
END; -- (T)
|
|
|
-------------------------------------------------
|
-------------------------------------------------
|
|
|
RESULT;
|
RESULT;
|
END C67002C;
|
END C67002C;
|
|
|
|
|