Annotation of researchv10dc/cmd/pfort/INVOKE.f, revision 1.1.1.1

1.1       root        1:       SUBROUTINE INVOKE
                      2: C
                      3: C      PGM UNIT STEPS THROUGH NODES IN INVOCATION ORDER
                      4: C      PUSHING ACTUAL PROC ARGS DOWN LATTICE WHERE NECESSARY
                      5: C      AND READJUSTING LEVEL IF NECESSARY
                      6: C
                      7:       INTEGER PNODE, PLAT, PDSA, DSA, SYMLEN, PREF, REF, FIND, CHK1,
                      8:      *  ZERO(1), FINDND
                      9:       LOGICAL ERR, SYSERR, ABORT, OK, AOK
                     10:       COMMON /PARAMS/ I1, I2, I3, SYMLEN, I4, I5, I6
                     11:       COMMON /DETECT/ ERR, SYSERR, ABORT
                     12:       COMMON /HEAD/ LNODE, PNODE, NODE(500)
                     13:       COMMON /SCR1/ LINODE, INODE(500)
                     14:       COMMON /GRAPH/ LLAT, PLAT, LAT(6000)
                     15:       COMMON /CTABL/ LDSA, PDSA, DSA(5000)
                     16:       COMMON /CREF/ LREF, PREF, REF(100)
                     17:       COMMON /FACTS/ NAME, NOST, ITYPE, IASF
                     18:       DATA ZERO(1)/0/
                     19: C      NC IS CURRENT NODE, NP IS PREVIOUS NODE PROCESSED
                     20:       NC = 0
                     21:    10 NP = NC
                     22:       OK = .TRUE.
                     23:       AOK = .TRUE.
                     24: C
                     25: C      SEARCH FOR NEXT NODE TO DO, NODE WITH LOWEST POSIT LEVEL IN INODE
                     26: C      UPON ENTRY TO INVOKE, SUPEROOT IS -1, ASFS AND BLOCK DATA
                     27: C      ARE -2. IF CANT FIND A POSITIVE LEVEL ARE DONE
                     28: C
                     29:       L = PNODE - 1
                     30:       DO 20 I=1,L
                     31:         IF (INODE(I).LT.0) GO TO 20
                     32:         NC = I
                     33:         GO TO 40
                     34:    20 CONTINUE
                     35:    30 RETURN
                     36:    40 J = NC
                     37:       DO 50 I=J,L
                     38:         IF (INODE(I).GE.0 .AND. INODE(I).LT.INODE(NC)) NC = I
                     39:    50 CONTINUE
                     40: C      READ IN SYMBOL TABLE FOR NODE(NC) AND POSITION REFS CORRECTLY
                     41:       CALL RDSYM(NC, NP)
                     42:    60 IF (INREF(I6)) 140, 140, 70
                     43: C      HAVE A REFERENCE TO PROCESS
                     44:    70 IF (IGATT1(REF(2),4).EQ.1) GO TO 80
                     45: C      PROCESSING A DIRECT REFERENCE
                     46: C      NEED ONLY PROCESS REF TEMPLATE IF ANY PROC ACTUAL ARGS IN REF
                     47:       L = REF(2)
                     48:       L = FINDND(DSA(L+4),K)
                     49:       CALL PROC(NODE(NC), L, K, AOK)
                     50:       IF (SYSERR .OR. ABORT) GO TO 30
                     51:       GO TO 60
                     52: C      PROCESSING AN INDIRECT REF
                     53:    80 K = NODE(NC) + SYMLEN + 5
                     54:       K = LAT(K)
                     55:       IF (K.EQ.0) GO TO 150
                     56: C      K PTS TO A TEMPLATE OF ACTUALS AT LAT(NODE(NC))
                     57: C      L GIVES REL POSIT AMONG PROC DUMMIES IN LAT(NODE(NC))
                     58: C      OF PROC DUMMY BEING CALLED
                     59:       L = REF(2)
                     60:       L = DSA(L+2)
                     61:       I = NODE(NC) + SYMLEN + 1
                     62:       I = LAT(I)
                     63:       IF (L.EQ.1) GO TO 100
                     64:       DO 90 M=2,L
                     65:         I = LAT(I+3)
                     66:    90 CONTINUE
                     67: C
                     68: C      I PTS TO DUMMY PROC ARG ENTRY IN LAT
                     69: C
                     70:   100 M = LAT(I+1) + K
                     71:       M = LAT(M)
                     72: C      M PTS TO ACTUAL SUBSTITUTABLE FOR I
                     73:       L = FIND(M)
                     74: C      RECURSION DUE TO INDIRECT REF COMPLETING THE LOOP
                     75:       IF (-1.NE.INODE(L)) GO TO 110
                     76:       ABORT = .TRUE.
                     77:       CALL ERROR2(26H RECURSIVE LOOP INVOLVING , 26, DSA(NAME+4), 1,1,0)
                     78:       CALL ERROR2(14H AND POSSIBLY , 14, LAT(M), 1, 0, 1)
                     79:       GO TO 30
                     80: C      NOTE NEED NOT WORRY ABOUT MISSING SUBPGM SINCE
                     81: C      THEN ITS LAT INDEX COULDNOT BE IN TEMPLATE
                     82:   110 IF (CHK1(NODE(NC),M).EQ.0) GO TO 130
                     83: C      PROCESSED A LEGAL INDIRET REF
                     84:       CALL SETPD(M, NODE(NC))
                     85:       IF (SYSERR) GO TO 30
                     86:       IF (-2.EQ.INODE(L) .OR. INODE(NC).LT.INODE(L)) GO TO 120
                     87:       INODE(L) = INODE(NC) + 1
                     88:       CALL ASLEV(L)
                     89:       IF (ABORT .OR. SYSERR) GO TO 30
                     90: C      LOOK FOR MORE ACTUALS
                     91:  120  CALL PROC(NODE(NC), M, L, AOK)
                     92:       IF (SYSERR .OR. ABORT) GO TO 30
                     93:   130 K = LAT(K) + K
                     94:       K = LAT(K)
                     95:       IF (K) 60, 60, 100
                     96: C      MARK CURRENT NODE DONE
                     97:   140 INODE(NC) = -1
                     98:       GO TO 10
                     99:   150 IF (.NOT.OK) GO TO 60
                    100:       K = NODE(NC)
                    101:       CALL ERROR2(20H NO ACTUAL PROCS IN ,20, LAT(K), 1, 1, 0)
                    102:       CALL ERROR2(28H CANNOT PROCESS FORMAL REFS , 28,
                    103:      *  ZERO, -3, 0, 1)
                    104:       OK = .FALSE.
                    105:       GO TO 60
                    106:       END

unix.superglobalmegacorp.com

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