Annotation of researchv10no/cmd/pfort/EQUIV.f, revision 1.1

1.1     ! root        1:       SUBROUTINE EQUIV
        !             2:       INTEGER STMT, PSTMT, PDSA, DSA, TYPE, STACK, BNEXT, SYMHD
        !             3:       LOGICAL ARDECL, CORNR, SAME, ERR, SYSERR, ABORT
        !             4:       COMMON /DETECT/ ERR, SYSERR, ABORT
        !             5:       COMMON /INPUT/ NSTMT, PSTMT, STMT(1327)
        !             6:       COMMON /TABL/ NEXT, LABHD, SYMHD, BNEXT
        !             7:       COMMON /CTABL/ LDSA, PDSA, DSA(5000)
        !             8:       COMMON /CEXPRS/ LSTACK, STACK(620)
        !             9: C
        !            10: C     PROCESSES AN EQUIVALENCE STMT-FINDS DECLARATORS SEPARATED BY ,
        !            11: C     IF DIFFERENT TYPE VARIABLES INVOLVED, CHECKS FOR USE OF CORNER
        !            12: C     ELEMENTS;  ARDECL CALLED TO PROCESS DECLARATORS
        !            13: C     SAME IS .TRUE. IF ALL ITEMS EQUIVALENCED IN ONE (--) ARE SAME TYPE
        !            14: C     CORNR IS .TRUE. IF ALL ITEMS EQUIV. IN ONE (--) ARE CORNER ELES.
        !            15: C     E.G. A(1,1,1)
        !            16: C
        !            17:    10 IF (STMT(PSTMT).EQ.65) GO TO 30
        !            18:    20 CALL ERROR1(20H ILLEGAL PUNCTUATION, 20)
        !            19:       GO TO 150
        !            20:    30 TYPE = -1
        !            21:       IPT = 1
        !            22:       CORNR = .TRUE.
        !            23:       SAME = .TRUE.
        !            24:    40 PSTMT = PSTMT + 1
        !            25:       IF (PSTMT.GE.NSTMT) GO TO 20
        !            26:       IF (.NOT.ARDECL(K2,KK)) GO TO 150
        !            27:       IF (SYSERR .OR. ERR) GO TO 150
        !            28: C
        !            29: C     KK>= 0 FOR AN ARRAY ELEMENT MEANS IT WASN'T A CORNER ELEMENT
        !            30: C
        !            31:       L = IGATT1(IABS(KK),7)
        !            32:       IF (KK.GT.0 .AND. L.GT.0) CORNR = .FALSE.
        !            33:       KK = IABS(KK)
        !            34: C
        !            35: C     SET USAGE, IF UNSET
        !            36: C
        !            37:       L = IGATT1(KK,8)
        !            38:       IF (L.EQ.0) CALL SATT1(KK, 8, 10)
        !            39: C
        !            40: C     STORE VARIABLE IN STACK, CHECK VARIABLE TYPE
        !            41: C
        !            42:       STACK(IPT) = KK
        !            43:       IPT = IPT + 1
        !            44:       CALL SATT1(KK, 3, 1)
        !            45:       I = IGATT1(KK,1)
        !            46:       I = MOD(I,8)
        !            47:       IF (-1.EQ.TYPE) TYPE = I
        !            48:       IF (TYPE.EQ.I) GO TO 50
        !            49:       SAME = .FALSE.
        !            50: C
        !            51: C     END OF DELARATOR CHECKS; NEED , OR )
        !            52: C
        !            53:    50 IF (STMT(K2).NE.68) GO TO 60
        !            54:       PSTMT = K2
        !            55:       GO TO 40
        !            56:    60 IF (STMT(K2).NE.62) GO TO 20
        !            57: C
        !            58: C     CHECK FOR CORNER ELEMENTS IF ARRAY ELEMENTS WERE USED
        !            59: C
        !            60:       IF (.NOT.SAME .AND. .NOT.CORNR) CALL ERROR1(
        !            61:      *    53H WARNING - USE CORNER ELEMENTS WHEN MIXING DATA TYPES, 53)
        !            62: C
        !            63: C     CHECK FOR ELEMENTS IN COMMON; MAKE SURE ONLY ONE COMMON
        !            64: C     REGION APPEARS
        !            65: C
        !            66:       KK = IPT - 1
        !            67: C
        !            68: C     PUT COMMON REGIONS OF EACH DECLARATOR (IF ANY) ON STACK
        !            69: C
        !            70:       DO 80 I=1,KK
        !            71:         L = IGATT1(STACK(I),2)
        !            72:         IF (L) 80, 80, 70
        !            73:  70   IF(IPT+1.GT.LSTACK) GOTO 160
        !            74:         L = STACK(I)
        !            75:         L = DSA(L+2)
        !            76:         STACK(IPT) = DSA(L+1)
        !            77:         IPT = IPT + 1
        !            78:    80 CONTINUE
        !            79:       IF (KK+2.GE.IPT) GO TO 90
        !            80:       CALL ERROR1(40H EQUIVALENCE CONFLICTS WITH COMMON DEFNS, 40)
        !            81:       GO TO 130
        !            82:    90 IF (KK+1.EQ.IPT) GO TO 130
        !            83: C
        !            84: C     MARK ALL DECLARATORS IN EQUIV (--) AS IF IN COMMON BLOCK
        !            85: C     THAT ANY ONE OF THEM IS ACTUALLY  IN
        !            86: C
        !            87:       DO 120 I=1,KK
        !            88:         L = IGATT1(STACK(I),2)
        !            89:         IF (L.EQ.1) GO TO 120
        !            90:         CALL SATT1(STACK(I), 2, 1)
        !            91:         L = STACK(I)
        !            92:         IF (DSA(L+2)) 100, 100, 110
        !            93:  100  IF(NEXT+2.GE.BNEXT) GOTO 170
        !            94:         DSA(L+2) = NEXT
        !            95:         DSA(NEXT) = 0
        !            96:         DSA(NEXT+1) = STACK(IPT-1)
        !            97:         NEXT = NEXT + 2
        !            98:         GO TO 120
        !            99:   110   L = DSA(L+2)
        !           100:         DSA(L+1) = STACK(IPT-1)
        !           101:   120 CONTINUE
        !           102:   130 IF (K2+1.EQ.NSTMT) GO TO 150
        !           103:       IF (STMT(K2+1).NE.68) GO TO 20
        !           104:       PSTMT = K2 + 2
        !           105:       GO TO 10
        !           106:   150 RETURN
        !           107:  160  CALL ERROR1(34H IN EQUIV, TABLE OVERFLOW OF STACK,34)
        !           108:  180  SYSERR = .TRUE.
        !           109:       GOTO 150
        !           110:  170  CALL ERROR1(32H IN EQUIV, TABLE OVERFLOW OF DSA, 32)
        !           111:       GOTO 180
        !           112:       END

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.