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

1.1     ! root        1:       SUBROUTINE INSTMT(EOF, NCARD)
        !             2:       LOGICAL ILLEG, ILHOL, ILCONT
        !             3:       LOGICAL NEWRD, EOF, CONT, OPT, P1ERR
        !             4:       INTEGER PSTMT, CARD(80), OUTUT, BLK, STATE, HCOUNT, STMT
        !             5:       INTEGER SYMLEN, OUTUT2, OUTUT3, OUTUT4
        !             6:       DIMENSION IBR(5)
        !             7:       COMMON /INPUT/ NSTMT, PSTMT, STMT(1327)
        !             8:       COMMON /OPTNS/ OPT(5), P1ERR
        !             9:       COMMON /PARAMS/ INUT, OUTUT, NOCHAR, SYMLEN, OUTUT2, OUTUT3,
        !            10:      *    OUTUT4
        !            11:       COMMON /FACTS/ NAME, NOST, ITYP, IASF
        !            12:       DATA NEWRD /.TRUE./
        !            13:       DATA IBR(1), IBR(2), IBR(3), IBR(4), IBR(5) /1H*,1HC,1H.,1H0,1H /
        !            14:       DATA CARD(1) /1H /
        !            15: C
        !            16: C     ROUTINE INPUTS AN ENTIRE FORTRAN STATEMENT. IT IS PASSED 1 CHAR
        !            17: C     PER ELEMENT IN THE ARRAY STMT.
        !            18: C     IN SHOULD BE CALLED AGAIN IF ERR IS TRUE.
        !            19: C     EACH CARD IS WRITTEN OUT BEFORE BEING PARSED.
        !            20: C     IN DEBLANKS CARDS USES THE VARIABLE STATE TO FIND
        !            21: C     HOLLERITHS:
        !            22: C     STATE = 0.....LOOK FOR BREAK CHAR
        !            23: C     1.....HAVE BREAK CHAR AND NEED DIGIT
        !            24: C     2.....HAVE DIGIT AND NEED DIGIT OR "H"
        !            25: C     3....NEED TO SKIP OVER THESE CHARS, PART OF HOLLERITH
        !            26: C     NOTE: USE "90" AS AN END OF STMT MARKER
        !            27: C
        !            28: C     NEWRD IS TRUE IF A NEW CARD IS NECESSARY; ELSE CARD IN BUFFER
        !            29: C     IS USED.  EOF IS TRUE WHEN END-OF-FILE CARD ("." IN COL 1)
        !            30: C     IS READ     NCARD GIVES # OF CARDS READ FOR THIS STMT
        !            31: C
        !            32:    10 NOST = NOST + 1
        !            33:       STATE = 0
        !            34:       NSTMT = 0
        !            35:       ILLEG = .FALSE.
        !            36:       ILCONT = .FALSE.
        !            37:       ILHOL = .FALSE.
        !            38:       NCARD = 0
        !            39:       CONT = .FALSE.
        !            40:    20 IF (NEWRD) CALL IN(CARD, INUT)
        !            41:       IF (CARD(1).NE.IBR(2) .OR. CARD(2).NE.IBR(1)) GO TO 40
        !            42: C
        !            43: C     DEAL WITH OPTIONS CARD
        !            44: C
        !            45:       IF (CONT) GO TO 50
        !            46:       CALL INOPT(CARD)
        !            47:    30 IF (OPT(4)) WRITE (OUTUT,99999) CARD
        !            48: 99999 FORMAT (11X, 80A1)
        !            49:       NEWRD = .TRUE.
        !            50:       GO TO 20
        !            51:    40 IF (CARD(1).NE.IBR(2)) GO TO 70
        !            52: C
        !            53: C     DEAL WITH COMMENT CARD
        !            54: C
        !            55:       IF (.NOT.CONT) GO TO 30
        !            56: C
        !            57: C     HAVE COMPLETED STMT
        !            58: C
        !            59:    50 NEWRD = .FALSE.
        !            60:       NSTMT = NSTMT + 1
        !            61:       STMT(NSTMT) = 90
        !            62:    60 IF (ILLEG) CALL ERROR1(
        !            63:      *    40H WARNING - NON-FORTRAN CHARACTER IGNORED, 40)
        !            64:       IF (ILHOL) CALL ERROR1(
        !            65:      *    46H WARNING - NON-FORTRAN CHARACTER IN HOLLERITH , 46)
        !            66:       IF (ILCONT) CALL ERROR1(
        !            67:      *    45H WARNING - NON-FORTRAN CONTINUATION CHARACTER, 45)
        !            68:       RETURN
        !            69:    70 IF (CARD(1).NE.IBR(3)) GO TO 80
        !            70: C
        !            71: C     HAVE EOF
        !            72: C
        !            73:       IF (CONT) GO TO 50
        !            74:       EOF = .TRUE.
        !            75:       GO TO 60
        !            76:    80 IF (CARD(6).EQ.IBR(4) .OR. CARD(6).EQ.IBR(5)) GO TO 100
        !            77: C
        !            78: C     DEAL WITH CONTINUATION CARD
        !            79: C
        !            80:       II = MAPCHR(CARD(6),ILCONT)
        !            81:       IF (CONT) GO TO 110
        !            82:       CALL ERROR1(40H WARNING - CONTINUATION NOT ALLOWED HERE, 40)
        !            83: C
        !            84: C     FLUSH TO NEXT NONCONTINUATION CARD
        !            85: C
        !            86:    90 IF (OPT(4)) WRITE (OUTUT,99998) NOST, CARD
        !            87: 99998 FORMAT (1H , I5, 5X, 80A1)
        !            88:       CALL IN(CARD, INUT)
        !            89:       IF (CARD(1).NE.IBR(1) .AND. CARD(1).NE.IBR(2) .AND.
        !            90:      *    CARD(1).NE.IBR(3) .AND. CARD(6).NE.IBR(4) .AND.
        !            91:      *    CARD(6).NE.IBR(5)) GO TO 90
        !            92:       NEWRD = .FALSE.
        !            93:       GO TO 10
        !            94: C
        !            95: C     DEAL WITH A NON-CONTINUATION CARD
        !            96: C
        !            97:   100 IF (CONT) GO TO 50
        !            98: C     DEAL WITH A LEGAL CONTIN OR NONCONTIN CARD
        !            99:   110 NCARD = NCARD + 1
        !           100:       IF (NCARD.LT.21) GO TO 120
        !           101:       CALL ERROR1(33H WARNING - TOO MANY CONTINUATIONS, 33)
        !           102:       GO TO 90
        !           103:   120 IF (OPT(4)) WRITE (OUTUT,99998) NOST, CARD
        !           104:       NEWRD = .TRUE.
        !           105:       BLK = 0
        !           106:       IF (NSTMT.NE.0) GO TO 150
        !           107:       DO 130 I=1,5
        !           108:         NSTMT = NSTMT + 1
        !           109:         STMT(NSTMT) = MAPCHR(CARD(I),ILLEG)
        !           110:   130 CONTINUE
        !           111:   140 I = 7
        !           112:       GO TO 180
        !           113:   150 DO 160 I=1,5
        !           114:         IF (MAPCHR(CARD(I),ILLEG).NE.69) GO TO 170
        !           115:   160 CONTINUE
        !           116:       GO TO 140
        !           117:   170 CALL ERROR1(40H WARNING - ILLEGAL LABEL WILL BE IGNORED, 40)
        !           118:       GO TO 140
        !           119:   180 IF (I.LE.72) GO TO 200
        !           120: C
        !           121: C     AFTER TRANSLATE CARD CHECK FOR BLANK CARD
        !           122: C     AND GO BACK FOR A CONTINUATION CARD
        !           123: C
        !           124:       IF (BLK.NE.66) GO TO 190
        !           125:       CALL ERROR1(33H WARNING - BLANK CARD ENCOUNTERED, 33)
        !           126:       GO TO 90
        !           127:   190 CONT = .TRUE.
        !           128:       GO TO 20
        !           129:   200 IF (STATE.NE.3) GO TO 210
        !           130: C
        !           131: C     STATE 3 --ARE PROCESSING A HOLLERITH
        !           132: C
        !           133:       HCOUNT = HCOUNT - 1
        !           134:       KK = MAPCHR(CARD(I),ILHOL)
        !           135:       IF (HCOUNT.EQ.0) STATE = 0
        !           136:       GO TO 290
        !           137:   210 NSTMT = NSTMT + 1
        !           138:       STMT(NSTMT) = MAPCHR(CARD(I),ILLEG)
        !           139:       IF (STMT(NSTMT).NE.69) GO TO 220
        !           140: C
        !           141: C     BLANK ENCOUNTERED AND DELETED
        !           142: C
        !           143:       BLK = BLK + 1
        !           144:       NSTMT = NSTMT - 1
        !           145:       GO TO 290
        !           146:   220 KK = STATE + 1
        !           147:       GO TO (280, 260, 230), KK
        !           148: C
        !           149: C     STATE 2--SKIP OVER LEADING DIGIT STRING; LOOK FOR H
        !           150: C
        !           151:   230 IF (STMT(NSTMT).LE.9) GO TO 290
        !           152:       IF (STMT(NSTMT).NE.37) GO TO 270
        !           153: C
        !           154: C     PROCESS HOLLERITH COUNT
        !           155: C
        !           156:       STMT(NSTMT) = -STMT(NSTMT)
        !           157:       STATE = 3
        !           158:       KK = NSTMT - KST
        !           159:       I10 = 1
        !           160:       HCOUNT = 0
        !           161:       DO 240 K=1,KK
        !           162:         JJ = NSTMT - K
        !           163:         HCOUNT = HCOUNT + I10*STMT(JJ)
        !           164:         I10 = I10*10
        !           165:   240 CONTINUE
        !           166:       STMT(KST) = HCOUNT - 2048
        !           167:       NSTMT = KST
        !           168:       IF (HCOUNT.LE.0) GO TO 250
        !           169:       GO TO 290
        !           170: C
        !           171: C     AVOID THE 0H CONSTRUCTION
        !           172: C
        !           173:   250 CALL ERROR1(44H WARNING - 0H ILLEGAL HOLLERITH CONSTRUCTION, 44)
        !           174:       STATE = 0
        !           175:       GO TO 290
        !           176: C
        !           177: C     STATE 1--LOOK FOR START OF DIGIT STRING BEFORE H
        !           178: C
        !           179:   260 IF (STMT(NSTMT).GT.9) GO TO 270
        !           180:       STATE = 2
        !           181:       KST = NSTMT
        !           182:       GO TO 290
        !           183: C
        !           184: C     CHECK FOR NESTED SPECIAL HEADING CHARS
        !           185: C
        !           186:   270 STATE = 0
        !           187:   280 IF ((STMT(NSTMT).LT.65) .OR. (STMT(NSTMT).GT.68)) GO TO 290
        !           188:       STATE = 1
        !           189:   290 I = I + 1
        !           190:       GO TO 180
        !           191:       END

unix.superglobalmegacorp.com

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