Return to getlin.f CVS log

Up to [Research Unix] / researchv10dc / cmd / matlab / src

Annotation of researchv10dc/cmd/matlab/src/getlin.f, revision 1.1.1.1

1.1       root        1:       SUBROUTINE GETLIN
                      2: C     GET A NEW LINE
                      3:       INTEGER ALFA(52),ALFB(52),ALFL,CASE
                      4:       INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE,HIO
                      5:       INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2)
                      6:       COMMON /ALFS/ ALFA,ALFB,ALFL,CASE
                      7:       COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE,HIO
                      8:       COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN
                      9:       INTEGER LRECL,EOL,SLASH,BSLASH,DOT,BLANK,RETU(4)
                     10:       DATA EOL/99/,DOT/47/,BLANK/36/,RETU/27,14,29,30/
                     11:       DATA SLASH/44/,BSLASH/45/,LRECL/80/
                     12: C
                     13:    10 L = LPT(1)
                     14:    11 DO 12 J = 1, LRECL
                     15:          BUF(J) = ALFA(BLANK+1)
                     16:    12 CONTINUE
                     17:       READ(RIO,101,END=50,ERR=10) (BUF(J),J=1,LRECL)
                     18:   101 FORMAT(80A1)
                     19:       N = LRECL+1
                     20:    15 N = N-1
                     21:       IF (BUF(N) .EQ. ALFA(BLANK+1)) GO TO 15
                     22:       IF (MOD(LCT(4),2) .EQ. 1) WRITE(WTE,102) (BUF(J),J=1,N)
                     23:       IF (WIO .NE. 0) WRITE(WIO,102) (BUF(J),J=1,N)
                     24:   102 FORMAT(0X,80A1)
                     25: C
                     26:       DO 40 J = 1, N
                     27:          DO 20 K = 1, ALFL
                     28:            IF (BUF(J).EQ.ALFA(K) .OR. BUF(J).EQ.ALFB(K)) GO TO 30
                     29:    20    CONTINUE
                     30:          K = EOL+1
                     31:          CALL XCHAR(BUF(J),K)
                     32:          IF (K .GT. EOL) GO TO 10
                     33:          IF (K .EQ. EOL) GO TO 45
                     34:          IF (K .EQ. -1) L = L-1
                     35:          IF (K .LE. 0) GO TO 40
                     36: C
                     37:    30    K = K-1
                     38:          IF (K.EQ.SLASH .AND. BUF(J+1).EQ.BUF(J)) GO TO 45
                     39:          IF (K.EQ.DOT .AND. BUF(J+1).EQ.BUF(J)) GO TO 11
                     40:          IF (K.EQ.BSLASH .AND. N.EQ.1) GO TO 60
                     41:          LIN(L) = K
                     42:          IF (L.LT.1024) L = L+1
                     43:          IF (L.EQ.1024) WRITE(WTE,33) L
                     44:    33    FORMAT(0X,'INPUT BUFFER LIMIT IS ',I4,' CHARACTERS.')
                     45:    40 CONTINUE
                     46:    45 LIN(L) = EOL
                     47:       LPT(6) = L
                     48:       LPT(4) = LPT(1)
                     49:       LPT(3) = 0
                     50:       LPT(2) = 0
                     51:       LCT(1) = 0
                     52:       CALL GETCH
                     53:       RETURN
                     54: C
                     55:    50 IF (RIO .EQ. RTE) GO TO 52
                     56:       CALL PUTID(LIN(L),RETU)
                     57:       L = L + 4 
                     58:       GO TO 45 
                     59:    52 CALL FILES(-RTE,BUF,BUF)
                     60:       LIN(L) = EOL
                     61:       RETURN
                     62: C
                     63:    60 N = LPT(6) - LPT(1)
                     64:       DO 61 I = 1, N
                     65:          J = L+I-1
                     66:          K = LIN(J)
                     67:          BUF(I) = ALFA(K+1)
                     68:          IF (CASE.EQ.1 .AND. K.LT.36) BUF(I) = ALFB(K+1)
                     69:    61 CONTINUE
                     70:       CALL EDIT(BUF,N)
                     71:       N = N + 1
                     72:       GO TO 15
                     73:       END

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