c67003f.ada

linux下编程用 编译软件

-- C67003F.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 THE PREDEFINED OPERATORS FOR THE PREDEFINED TYPES CAN BE 
--   REDEFINED.
-- CHECK THAT THE REDEFINED OPERATOR IS INVOKED WHEN INFIX OR PREFIX
--   NOTATION IS USED.

-- HISTORY:
--   WMC 03/21/92   TEST CREATED FROM CONSOLIDATION OF C67003[A-E].ADA


WITH REPORT;

PROCEDURE C67003F IS

     USE REPORT;

BEGIN

     TEST ("C67003F", "CHECK THAT REDEFINITION OF " &
           "OPERATORS FOR PREDEFINED TYPES WORKS");

     DECLARE     -- INTEGER OPERATORS.

          -- INTEGER INFIX OPERATORS.

          FUNCTION "*" (X, Y : INTEGER) RETURN INTEGER IS
          BEGIN
               IF X /= Y THEN
                    RETURN 1;
               ELSE RETURN 0;
               END IF;
          END "*";

          FUNCTION "+" (X, Y : INTEGER) RETURN INTEGER IS
          BEGIN
               IF X /= Y THEN
                    RETURN 2;
               ELSE RETURN 0;
               END IF;
          END "+";
     
          FUNCTION "REM" (X, Y : INTEGER) RETURN INTEGER IS
          BEGIN
               IF X /= Y THEN
                    RETURN 3;
               ELSE RETURN 0;
               END IF;
          END "REM";
     
          -- INTEGER PREFIX OPERATORS.

          FUNCTION "+" (X : INTEGER) RETURN INTEGER IS
          BEGIN
               IF X /= 0 THEN
                    RETURN 4;
               ELSE RETURN 0;
               END IF;
          END "+";

          FUNCTION "ABS" (X : INTEGER) RETURN INTEGER IS
          BEGIN
               IF X /= 0 THEN
                    RETURN 5;
               ELSE RETURN 0;
               END IF;
          END "ABS";

          -- INTEGER RELATIONAL OPERATOR.

          FUNCTION "<" (X, Y : INTEGER) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END "<";

     BEGIN

          IF IDENT_INT (3) * IDENT_INT (5) /= 1 THEN
               FAILED ("REDEFINITION OF INTEGER ""*"" IS DEFECTIVE");
          END IF;

          IF IDENT_INT (1) + IDENT_INT (30) /= 2 THEN
               FAILED ("REDEFINITION OF INTEGER ""+"" IS DEFECTIVE");
          END IF;

          IF IDENT_INT (7) REM IDENT_INT (8) /= 3 THEN
               FAILED ("REDEFINITION OF ""REM"" IS DEFECTIVE");
          END IF;

          IF + (IDENT_INT (10)) /= 4 THEN
               FAILED ("REDEFINITION OF INTEGER UNARY ""+"" IS DEFECTIVE");
          END IF;

          IF ABS (IDENT_INT (2)) /= 5 THEN
               FAILED ("REDEFINITION OF INTEGER ""ABS"" IS DEFECTIVE");
          END IF;

          IF IDENT_INT (7) < IDENT_INT (8) THEN
               FAILED ("REDEFINITION OF INTEGER ""<"" IS DEFECTIVE");
          END IF;

     END;

     DECLARE   -- FLOAT OPERATORS.

          -- NOTE THAT ALL LITERAL VALUES USED SHOULD BE
          --   REPRESENTABLE EXACTLY.

          FUNCTION IDENT_FLOAT (X : FLOAT) RETURN FLOAT IS
             I : INTEGER := INTEGER (X);
          BEGIN
             IF EQUAL (I, I) THEN          -- ALWAYS EQUAL.
                  RETURN X;
             END IF;
             RETURN 0.0;
          END IDENT_FLOAT;

          -- FLOAT INFIX OPERATORS.

          FUNCTION "-" (X, Y : FLOAT) RETURN FLOAT IS
          BEGIN
               IF X /= Y THEN
                    RETURN 1.0;
               ELSE RETURN 0.0;
               END IF;
          END "-";

          FUNCTION "/" (X, Y : FLOAT) RETURN FLOAT IS
          BEGIN
               IF X /= Y THEN
                    RETURN 2.0;
               ELSE RETURN 0.0;
               END IF;
          END "/";

          FUNCTION "**" (X : FLOAT; Y : INTEGER) RETURN FLOAT IS
          BEGIN
               IF INTEGER (X) /= Y THEN
                    RETURN 3.0;
               ELSE RETURN 0.0;
               END IF;
          END "**";

          -- FLOAT PREFIX OPERATOR.

          FUNCTION "-" (X : FLOAT) RETURN FLOAT IS
          BEGIN
               IF X /= 0.0 THEN
                    RETURN 4.0;
               ELSE RETURN 0.0;
               END IF;
          END "-";

          -- FLOAT RELATIONAL OPERATOR.

          FUNCTION "<=" (X, Y : FLOAT) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END "<=";

     BEGIN

          IF IDENT_FLOAT (50.0) - IDENT_FLOAT (100.0) /= 1.0 THEN
               FAILED ("REDEFINITION OF FLOAT ""-"" IS DEFECTIVE");
          END IF;

          IF IDENT_FLOAT (5.0) / IDENT_FLOAT (1.0) /= 2.0 THEN
               FAILED ("REDEFINITION OF FLOAT ""/"" IS DEFECTIVE");
          END IF;

          IF IDENT_FLOAT (3.0) ** IDENT_INT (2) /= 3.0 THEN
               FAILED ("REDEFINITION OF FLOAT ""**"" IS DEFECTIVE");
          END IF;

          IF -(IDENT_FLOAT (5.0)) /= 4.0 THEN
               FAILED ("REDEFINITION OF FLOAT UNARY ""-"" IS DEFECTIVE");
          END IF;

          IF IDENT_FLOAT (1.0) <= IDENT_FLOAT (5.0) THEN
               FAILED ("REDEFINITION OF FLOAT ""<="" IS DEFECTIVE");
          END IF;

     END;

     DECLARE     -- BOOLEAN OPERATORS.

          -- BOOLEAN LOGICAL OPERATORS.

          FUNCTION "AND" (X, Y : BOOLEAN) RETURN BOOLEAN IS
          BEGIN
               IF X AND THEN Y THEN
                    RETURN FALSE;
               ELSE RETURN TRUE;
               END IF;
          END "AND";

          FUNCTION "XOR" (X, Y : BOOLEAN) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END "XOR";

          -- BOOLEAN RELATIONAL OPERATOR.

          FUNCTION ">" (X, Y : BOOLEAN) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END ">";

     BEGIN

          IF IDENT_BOOL (TRUE) AND IDENT_BOOL (TRUE) THEN
               FAILED ("REDEFINITION OF ""AND"" IS DEFECTIVE");
          END IF;

          IF IDENT_BOOL (TRUE) XOR IDENT_BOOL (FALSE) THEN
               FAILED ("REDEFINITION OF ""XOR"" IS DEFECTIVE");
          END IF;

          IF IDENT_BOOL (TRUE) > IDENT_BOOL (FALSE) THEN
               FAILED ("REDEFINITION OF BOOLEAN "">"" IS DEFECTIVE");
          END IF;

     END;
    
     DECLARE     -- STRING OPERATORS.

          S1 : STRING (1..2) := "A" & IDENT_CHAR ('B');
          S2 : STRING (1..2) := "C" & IDENT_CHAR ('D');

          FUNCTION "&" (X, Y : STRING) RETURN STRING IS
               Z : STRING (1 .. X'LENGTH + Y'LENGTH);
          BEGIN
               Z (1 .. Y'LENGTH) := Y;
               Z (Y'LENGTH + 1 .. Z'LAST) := X;
               RETURN Z;
          END "&";

          FUNCTION "&" (X : CHARACTER; Y : STRING) RETURN STRING IS
               Z : STRING (1 .. Y'LENGTH + 1);
          BEGIN
               Z (1 .. Y'LENGTH) := Y;
               Z (Z'LAST) := X;
               RETURN Z;
          END "&";

          -- STRING RELATIONAL OPERATOR.

          FUNCTION ">=" (X, Y : STRING) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END ">=";

     BEGIN

          IF S1 & S2 /= "CDAB" THEN
               FAILED ("BAD REDEFINITION OF ""&"" (S,S)");
          END IF;

          IF IDENT_CHAR ('C') & S1 /= "ABC" THEN
               FAILED ("BAD REDEFINITION OF ""&"" (C,S)");
          END IF;

          IF S2 >= S1 THEN
               FAILED ("BAD REDEFINITION OF STRING "">=""");
          END IF;

     END;

     DECLARE      -- CHARACTER OPERATORS.

          -- CHARACTER RELATIONAL OPERATORS.

          FUNCTION ">" (X, Y : CHARACTER) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END ">";

          FUNCTION "<=" (X, Y : CHARACTER) RETURN BOOLEAN IS
          BEGIN
               RETURN X = Y;
          END "<=";

     BEGIN

          IF IDENT_CHAR ('C') > IDENT_CHAR ('B') THEN
               FAILED ("REDEFINITION OF CHARACTER "">"" IS DEFECTIVE");
          END IF;

          IF IDENT_CHAR ('A') <= IDENT_CHAR ('E') THEN
               FAILED ("REDEFINITION OF CHARACTER ""<="" IS DEFECTIVE");
          END IF;

     END;

     RESULT;

END C67003F;