*DECK,NP$STPR 
*IF,DEF,XFR 
USETEXT NX$ACBF 
USETEXT AIPDEF
USETEXT HEADER
USETEXT NP$STAT 
USETEXT NP$DB 
USETEXT NP$NWL
USETEXT NP$MODE 
USETEXT NP$GETS 
USETEXT NX$ACBX 
USETEXT NX$MSG
      PROC NP$STPR(NETCON,NTRIGGER,NBACKTRIG);
      BEGIN 
# 
**
*1DC  NP$STPR 
* 
*     1. PROC NAME         AUTHOR               DATE
*        NP$STPR           Y. C. YIP            02/19/1985
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTINE ACTS AS A CENTRAL PROCESSOR FOR THE RESPONSE
*        RETURNED BY CALLING NP$STTP, THE STATE TABLE DRIVER FOR
*        ACTIONS TAKEN DURING A FILE TRANSFER STATE. THE ACTIONS, 
*        STATE TRANSITION, AND THE REASON ARE THEN EXECUTED 
*        BY DOING A TABLE JUMP DEPENDING ON THE ACTION NUMBER AND 
*        AND THE TABLE NUMBER WHETHER IT IS A PRU( SEND, RECEIVE) OR
*        CHARACTER (SEND , RECEIVE).
* 
*     3. METHOD USED
*        THE PROCESSOR HAS TWO BANKS  OF ACTIONS, ONE FOR PRU 
*        SENDER AND RECEIVER AND THE OTHER FOR CHARACTER SENDER 
*        AND RECEIVER. THE JUMPS TO THESE BANKS ARE FIRST TRIGGERED 
*        BY TABLE ORDINAL SWITCHES AND THEN BY ACTION STATUS
*        SWITCHES. THERE ARE FOUR TABLES ORDINALS: 0 AND 1 FOR
*        PRU SENDER AND RECEIVER AND 2 AND 3 FOR CHARACTER SENDER 
*        AND RECEIVER. IT OBTAINS THE ORDINALS AND CURRENT STATE
*        BY A TABLE LOOK OF THE FILE TRANSFER TABLE AND THE KEY IS
*        THE CONNECTION INDEX. THEN IT CALLS NP$STTP AND PERFORMS 
*        ACTION1 AND ACTION2, UPDATING REASON CODE, NEWSTATE AND
*        PREVIOUS STATE OF THE FILE TRANSFER TABLE. 
*        NP$STPR SETS NTRIGGER TO A NULL TRIGGER VALUE , 0, AT
*        ENTRY OF THE ROUTINE.
*        NORMALLY NBACKTRIG IS SET TO NULL, 0, AFTER A REGULAR
*        CALL TO NP$STTP. IN CASE, ANOTHER CALL TO NP$STPR
*        IS NEEDED, NBACKTRIG IS SET TO A NON-NULL VALUE. 
*        EXAMPLES ARE ACTION "CLOSE". 
* 
*     4. ENTRY CONDITIONS 
*        NETCON - CONNECTION INDEX IN THE FTT.
*        NTRIGGER - VALUE OF THE TRIGGER FOR THE STATE TABLE. 
*        NBACKTRIG - RETURN TRIGGER.
* 
*     5. EXIT CONDITONS 
*        NETCON - UNCHANGED.
*        NTRIGGER - UNCHANGED.
*        NBACKTRIG - NULL IF NO RETURN ELSE VALUE OF
*                    THE RETURN TRIGGER.
*        FTTSTATE, FTTSTRC ARE UPDATED TO THE CURRENT 
*        FILE TRANSFER STATE AND REASON.
* 
*     6. COMDECKS CALLED AND SYMPL TEXTS USED.
*        NX$ACBX, NP$NWL. 
* 
*     7. ROUTINES CALLED
*        NP$MSG - DAYFILE PROCESSOR.
*        NP$STTP - COMPASS ROUTINE FOR STATE TABLE LOOKUP.
* 
*     8. DAYFILE MESSAGES 
*         - ERROR IN INTERFACING WITH NAM.
* 
# 
      CONTROL EJECT;
# 
**** PROC NP$STPR - XREF LIST.
# 
      XREF
        BEGIN 
        PROC NP$STTP;              # NP$STTP PROCESSOR                 #
        PROC NETPUT;               # NETPUT                            #
        PROC NP$PUT;               # NP$PUT                            #
        PROC NP$BTO8;              # CONVERTS BINARY TO ASCII          #
        PROC NP$8TIN;              # CONVERTS ASCII TO BINARY          #
        PROC NP$SHRK;              # SHRINK CHECKMARK TABLE            #
        PROC NP$XCMP;              # COMPLETE NET TRNASFER             #
        PROC NP$MSG;               # DAYFILE MESSAGE                   #
        FUNC NP$CDD C(10);         # CONVERT INTEGER TO DISPLAY CODE   #
        PROC NP$CIO;               # PERFORMS CIO FUNCTIONS            #
        PROC NP$SENF;              # CHARCTER SENDER                   #
        PROC NP$RECV;              # CHARACTER RECEIVER                #
        PROC NP$RTIM;              # PROC FOR UPDATING TIMER INFO      #
        PROC NP$RLOC;              # PROC FOR REALLOCATION BUFFERS     #
        PROC NP$XLCH;              # LOCATE CHECK MARK NUMBER          #
        PROC NP$UPRU;              # UPDATE PRU NUMBER IN FTT          #
        PROC NETWAIT;              # PROCEDURE TO DO NETWAIT           #
        END 
# 
****
# 
      ITEM NETCON;                 # CONNECTION INDEX                  #
      ITEM NTRIGGER;               # TRIGGER                           #
      ITEM NBACKTRIG;              # RETURN TRIGGER                    #
      ITEM ITEMP;                  # INTEGER TEMPORARY                 #
      ITEM ITEMP2;                 # INTEGER TEMPORARY                 #
      ITEM ORUDIFF;                # DIFFERENCE IN PRU                 #
      SWITCH ORDLST ORD0,          # SWITCH ITEM FOR TABLE ORDINAL     #
                                   # 0 FOR PRU SENDER                  #
                    ORD1,          # 1 FOR PRU RECEIVER                #
                    ORD2,          # 2 FOR CHARACTER SENDER            #
                    ORD3,          # 3 FOR CHARACTER RECEIVER          #
                    EXITT;         # DUMMY LABEL FOR ERROR EXIT        #
  
      SWITCH PJUMP  PLACT0,        # ACTION0 : STATUS = -1             #
                    PLACT1,        # ACITON1 : SS(CKPT) SENT           #
                    PLACT2,        # ACTION2 : RETURN                  #
                    PLACT3,        # ACTION3 : PRU/ON                  #
                    PLACT4,        # ACTION4 : STATUS = 0              #
                    PLACT5,        # ACTION5 : OFT/START SENT          #
                    PLACT6,        # ACTION6 : OFT/OFF/R               #
                    PLACT7,        # ACTION7 : STATUS = -2             #
                    PLACT8,        # ACTION8 : ES(OK) SENT             #
                    PLACT9,        # ACTION9 : FC/RST SENT             #
                    PLACT10,       # ACTION10: ES(E) SENT              #
                    PLACT11,       # ACTION11: IFT/START SENT          #
                    PLACT12,       # ACTION12: IFT/OFF/R               #
                    PLACT13,       # ACTION13: ER(OK) SENT             #
                    PLACT14,       # ACTION14: FC/BRK SENT             #
                    PLACT15,       # ACTION15: RR(CKPT) SENT           #
                    PLACT16,       # ACTION16: ER(E) SENT              #
                    PLACT17,       # ACTION17: QR(E) SENT              #
                    PLACT18,       # ACTION19: INTRRSP                 #
                    PLACT19,       # ACTION19: SET IDLEDOWN            #
                    PLACT20,       # ACTION20: SPECIAL RETURN ACTION   #
                                   # FOR PRUONA                        #
                    PLACT21,       # ACTION21: SPECIAL RECEIVER'S      #
                                   # ACTION FOR REALLOCATION OF BUFFERS#
                                   # AFTER RECEIVING PRUONA WITH RC= 4 #
                    PLACT22,       # ACTION22: LSTOFF                  #
                    PLACT23;       # ACTION23: LSTON                   #
  
  
  
      SWITCH CJUMP  CLACT0,        # ACTION 0: STATUS = -1             #
                    CLACT1,        # ACTION 1: SS(0) SENT              #
                    CLACT2,        # ACTION 2:  STATUS = 0             #
                    CLACT3,        # ACTION 3: ES(E) SENT              #
                    CLACT4,        # ACTION 4: ADVANCE ABL WINDOW      #
                    CLACT5,        # ACTION 5: RETURN                  #
                    CLACT6,        # ACTION 6: RESET ABL WINDOW + FCRST#
                    CLACT7,        # ACTION 7: INTRRSP SENT            #
                    CLACT8,        # ACTION 8: IDLEDOWN = TRUE         #
                    CLACT9,        # ACTION 9 : STATUS = -1 AND RESET  #
                    CLACT10,       # ACTION 10: ES(OK) SENT            #
                    CLACT11,       # ACTION 11: ADV CHECKMARK WINDOW   #
                    CLACT12,       # ACTION 12: SEND DATA              #
                    CLACT13,       # ACTION 13: SEND SR                #
                    CLACT14,       # ACTION 14: ER(E) SENT             #
                    CLACT15,       # ACTION 15: STATUS = -1 AND RWL    #
                    CLACT16,       # ACTION 16: SS(CHECKMARK)          #
                    CLACT17,       # ACTION 17: STATUS = -2            #
                    CLACT18,       # ACTION 18: QR(E) SENT             #
                    CLACT19,       # ACTION 19: CLOSE                  #
                    CLACT20,       # ACTION 20: SAVE CHECKMARK         #
                    CLACT21,       # ACTION 21: STORE DATA             #
                    CLACT22,       # ACTION 22: FCBRK SENT             #
                    CLACT23,       # ACTION 23: MR SENT                #
                    CLACT24,       # ACTION 24: RR(CHECKMARK)          #
                    CLACT25,       # ACTION 25: ER(OK)                 #
                    CLACT26,       # ACTION 26: LSTOFF                 #
                    CLACT27,       # ACTION 27: LSTON                  #
                    CLACT28;       # ACTION 28: SPECIAL ADVANCE WINDOW #
  
  
      BASED ARRAY TABRESP[0:0] S(1);  # TEMPLATE FOR RESPONSE WORD     #
        BEGIN 
        ITEM LEGB U(00,00,01);     # LEGAL BIT                         #
        ITEM NEWSTATE U(00,30,06); # NEWSTATE                          #
        ITEM ACTION1 U(00,36,06);  # ACTION 1                          #
        ITEM ACTION2 U(00,42,06);  # ACTION 2                          #
        ITEM REASON U(00,48,06);   # REASON CODE                       #
        END 
  
      BASED ARRAY COPYAREA[0:0] S(1); 
        BEGIN 
        ITEM WORD U(00,00,60);
        END 
      ITEM RESP;                   # RESPONSE WORD                     #
      ITEM ACTIONC;                # ACTION COUNT                      #
      ITEM CRNT$ACTION;            # CURRENT ACTION                    #
      ITEM I;                      # LOOP INDEX                        #
      ITEM NINDX;                  # LOOP INDEX                        #
      ITEM CRNT$ORD;               # CURRENT TABLE ORDINAL             #
      ITEM CRNT$STATE;             # CURRENT STATE                     #
      ITEM PRUDIFF;                # DIFFERENCE IN PRU NUMBER          #
      ITEM CTEMP C(10);            # CHARACTER TEMPORARY               #
      ITEM SAVE$WORD;              # COPY OF DATAWORD 1                #
  
      CONTROL EJECT;
      PROC NET$SENDL7(NETLV7PFC,NETL7DD); 
      BEGIN 
# 
**
*     1. FUNCTIONAL DESCRIPTION.
*        NET$SENDL7 TRANSMITS A LEVEL 7 MESSAGE TO A CERTAIN
*        CONNECTION NUMBER. 
* 
*     2. METHOD USED. 
*        NET$SENDL7 BLOCKS THE APPLICATION BLOCK HEADER WITH
*        THE CONNECTION NUMBER FROM FTT TABLE. IT THEN BUFFERS
*        THE PFC FIELD OF THE LEVEVL 7 TEXT AREA WITH THE 
*        NETLV7PFC WHICH IS PASSED AS A PARAMETER AND THE DD
*        (CHECK MARK OR ERROR CODE ) FIELD OF THE LEVEL 7 TEXT
*         WITH NETL7DD PASSED AS A PARAMETER. 
* 
*     3.  ENTRY CONDITIONS -
*         NETLV7PFC - LEVEL 7 PFC.
*         NETL7DD  -  LEVEL 7 D1-D4.
* 
*     4.  EXIT CONDITIONS.
* 
*         NETLV7PFC - UNCHANGED.
*         NETL7DD - UNCHANGED.
*         NP$PUT CALLED TO SEND LEVEL 7 MESSAGE.
* 
# 
  
      ITEM NETLV7PFC;                    # LEVEL 7 PFC                 #
      ITEM NETL7DD;                      # LEVEL 7 D1-D4               #
  
      CONTROL EJECT;
#                                                                      #
#                   PROC NET$SENDL7 CODE BEGINS HERE                   #
#                                                                      #
      ABH$L7ADR = FTTACN[FTTINDEX];      # SET CONNECTION NUMBER IN    #
                                         # APPLICATIONS BLOCK HEADER   #
      L7$PFC = NETLV7PFC;                # UPDATE PFC IN TEXT AREA     #
      L7$DD = B<STARTBIT,DDLEN>NETL7DD;  # UPDATE ERROR CODE OR        #
                                         # CHECK MARK                  #
      OPCODE = OP$PUT;                   # UPDATE OPCODE               #
      LOC$HA = LOC(ABH$LEV7);            # UPDATE HEADER ADDRESS       #
      LOC$TA = LOC(LV7$MSG);             # UPDATE TEXT AREA ADDRESS    #
*IF DEF,STAT,1
      IAM = TYPE"PUT";                   # UPDATE EXECUTING ROUTING    #
                                         # TYPE                        #
*IF DEF,DEBUG,1 
      DB$CALL = LOC(NETPUT);
      NP$PUT;                            # SEND LEVEL 7 MESSAGE        #
      RETURN;                            # RETURN TO CALLER            #
      END                                # END OF PROC NET$SENDL7      #
  
      CONTROL EJECT;
#**********************************************************************#
#                                                                      #
#      NP$STPR CODE BEGINS HERE                                        #
#                                                                      #
#**********************************************************************#
  
      NBACKTRIG = NIL;             # SET BACKTRIG TO NULL              #
      P<TABRESP> = LOC(RESP);      # PULL TEMPLATE OVER RESPONSE WORD  #
      P<STATUSWORD> = FTTSTATUS[FTTINDEX];  # GET ADDRESS OF STATUS    #
      P<CHK> = FTTCKTBL[FTTINDEX]; # PULL CHECKMARK TEMPLATE TO THE    #
                                   # THE ADDRESS STORED IN FTT         #
      P<SUPMSG> = LOC(DATA$BUF);   # PULL SUPERVISORY MSG TEMPLATE     #
                                   # OVER TO DATA$BUF                  #
      P<FET$CIO> = FTTFETADR[FTTINDEX];  # SET DISK FET ADDRESS        #
      P<CMB> = FTTCMV$BLK[FTTINDEX];
      SAVE$WORD    = DATA$WORD[1]; # SAVE DATAWORD IN CASE OF TBN CHECK#
      DATA$WORD[0] = 0;            # CLEAR DATA$WORD AT OFFSET 0       #
      DATA$WORD[1] = 0;            # CLEAR DATA$WORD AT OFFSET 1       #
      CRNT$ORD = FTTSTORD[FTTINDEX]; # UPDATE CURRENT TABLE ORDINAL    #
      CRNT$STATE = FTTSTATE[FTTINDEX];  # UPDATE CURRENT STATE OF FTT  #
      FTTPRETRIG[FTTINDEX] = NTRIGGER;   # SAVE CURRENT TRIGGER        #
      NP$RTIM(TIME$WORD);          #  GENERATE TIMESTAMP               #
      FTTTIME[FTTINDEX] = TIME$SEC[0];  # UPDATE FTTTIME               #
      NP$STTP(CRNT$ORD,CRNT$STATE,NTRIGGER,RESP);  # CALL STATE TABLE  #
      IF LEGB NQ ONE               # IF ILLEGAL ENTRY                  #
      THEN
        BEGIN 
        FTTSTRC[FTTINDEX] = NAM$ERR; # UPDATE REASON CODE              #
        NP$XCMP;                   # COMPLETE FILE TRANSFER            #
        END 
      ELSE
        BEGIN 
        IF REASON NQ NOCHG         # IF REASON NOT EQUAL TO NO CHANGE  #
        THEN
          BEGIN 
          FTTSTRC[FTTINDEX] = REASON; # UPDATE FTT REASON CODE         #
          END 
         CRNT$ACTION = ACTION1;     # UPDATE CURRENT ACTION            #
         ACTIONC = ONE;             # INITIALIZE ACTION COUNT TO 1     #
        FOR I = 0 WHILE (CRNT$ACTION NQ NOCHG AND ACTIONC LQ TWO) 
        DO
          BEGIN 
          ACTIONC = ACTIONC + 1;  # INCREMENT ACTION COUNT             #
          GOTO ORDLST[CRNT$ORD];   # GOTO ORDINAL LABEL                #
  
ORD0:     GOTO PJUMP[CRNT$ACTION];   # JUMP TO PRU ACTION TABLE        #
  
ORD1:     GOTO PJUMP[CRNT$ACTION];   # JUMP TO PRU ACTION TABLE        #
  
ORD2:     GOTO CJUMP[CRNT$ACTION];   # JUMP TO CHARACTER ACTION TABLE  #
  
ORD3:     GOTO CJUMP[CRNT$ACTION];   # JUMP TO CHARACTER ACTION TABLE  #
  
PLACT0:                              # **** STATUS = -1 ****           #
          STATUSWD = -1;             # STATUS = -1                     #
          GOTO NEXTAT;
  
PLACT1:                              # **** SS(CKPT) ****              #
          NP$BTO8(FTTICKVAL[FTTINDEX],ITEMP);  # GET ASCII VALUE OF    #
                                               # CHECK MARK VALUE      #
          NET$SENDL7(LEV7$SS,ITEMP);      # SEND SS(CHECKMARK)         #
          GOTO NEXTAT;
  
PLACT2:                                  # **** RETURN ****            #
          IF IDLEDOWN                    # IF IDLEDOWN FLAG SET        #
          THEN
            BEGIN 
            IF REASON EQ RC1             # IF COMPLETE WITHOUT ERROR   #
            THEN
              BEGIN 
              REASON = RC12;             # SET REASON CODE TO 12       #
              FTTSTRC[FTTINDEX] = RC12;  # ALSO SET THE REASON CODE IN #
              END 
            ELSE
              BEGIN 
              REASON = RC13;             # ELSE SET TO RC13 IF COMPLETE#
                                         # WITH ERROR                  #
              FTTSTRC[FTTINDEX] = RC13;  # ALSO UPDATE THE REASON CODE #
                                         # IN THE FTT TABLE            #
              END 
            END 
          NP$XCMP;                       # COMPLETE FILE TRANSFER      #
          GOTO NEXTAT;
  
PLACT3:                                  # **** PRU ON ****            #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY2;         # TLC = 2                     #
          PFCSFC[0] = PRUON;             # PFCSFC = PRUON              #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT        #
          IF FTTOPCODE[FTTINDEX] EQ 0    # IF RECEIVING SIDE           #
          THEN
            BEGIN 
            SPMUBZ[0]= FTTBSIZE[FTTINDEX]/ONE$PRU;   #   UBZ FOR RECVER#
            SPMDBZ[0] = 0;               # ZERO OUT DBZ                #
            END 
          ELSE
            BEGIN                        # ELSE IF SENDER SIDE         #
            SPMUBZ[0] = 0;               # ZERO OUT UBZ FOR SENDER     #
            SPMDBZ[0]= FTTBSIZE[FTTINDEX]/ONE$PRU;   #   DBZ FOR SENDER#
            END 
          IF FTTMFACIL[FTTINDEX]         # M-FACIL SPECIFIED           #
          THEN
            BEGIN 
            SPMCWS[0] = FTTCWS[FTTINDEX]; # SET WINDOW SIZE            #
            END 
          ELSE
            BEGIN 
            SPMCWS[0] = 0;               # NO CHECKMARKS SENT BY PIP   #
            END 
          SPMICK[0] = FTTICKVAL[FTTINDEX];  # SET CHECK MARK VALUE     #
          SPMDD[0] = FTTUDD[FTTINDEX];   # SET DATA DECLARATION FLAG   #
          SPMFL1[0] = TRUE;              # IN DATA TRANSFER MODE       #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET EXECUTING ROUTINE TYPE  #
          NP$PUT;                        # NETPUT PRUON                #
          GOTO NEXTAT;
  
PLACT4:                                  # **** STATUS = 0 ****        #
          STATUSWD = 0;                  # STATUS = 0                  #
          GOTO NEXTAT;
  
PLACT5:                                  # **** OFT/START ****         #
          LOC$HA = LOC(OUT$ABH);         # UPDAT HEADER ADDRESS        #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY2;         # TWO WORD MSG                #
          PFCSFC[0] = OFTSTRT;           # COMMAND IS OFT/START        #
          SPACN[0] = FTTACN[FTTINDEX];   # GET ACN FROM FTT TABLE      #
          P<FET$CIO> = FTTFETADR[FTTINDEX]; # PULL FET CIO TEMPLATE TO #
                                         # FET ADDRESS FROM THE FTT    #
                                         # TABLE                       #
          SPCURPR[0] = FTTCURPRU[FTTINDEX];  # GET START ADDRESS OF PRU#
          SPLFN[0] = FETLFN[0];          # GET FILE NAME FROM FET      #
          SPFNT[0] = FETFNT[0];          # GET FNT POINTER FROM FET    #
          OPCODE = OP$PUT;               # SET OPCODE FOR NETPUTTING   #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET EXECUTING ROUTINE       #
          NP$PUT;                        # NETPUT COMMAND              #
          GOTO NEXTAT;
  
PLACT6:                                  # **** OFT/OFF ****           #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # ONE WORD MSG                #
          SPACN[0] = FTTACN[FTTINDEX];   # GET ACN FROM FTT TABLE      #
          PFCSFC[0] = OFTOFF;            # SUPERVISORY MSF IS OFT/OFF  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # NETPUT MESSAGE              #
          GOTO NEXTAT;
  
PLACT7:                                  # **** STATUS = -2 ****       #
          STATUSWD = MINUS2;             # SET STATUS = -2             #
          GOTO NEXTAT;
  
PLACT8:                                  # **** ES(OK) ****            #
          NET$SENDL7(LEV7$ES,PRDER1);    # SEND ES(OK)                 #
          GOTO NEXTAT;
  
PLACT9:                                  # **** FCRST ****             #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # ENTRY SIZE OF MESSAGE       #
          PFCSFC[0] = FCRST;             # MESSAGE IS FCRST            #
          SPACN[0] = FTTACN[FTTINDEX];   # GET ACN FROM FTT TABLE      #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # NETPUT NMESSAGE             #
          GOTO NEXTAT;
  
  
PLACT10:                                 # **** ES(E) ****             #
          IF FTTOPCODE[FTTINDEX] EQ 0    # IF RECEIVER                 #
          THEN
            BEGIN 
            NET$SENDL7(LEV7$ES,PRDER3);  # NON-RETRYABLE RECEIVE ERROR #
            END 
          ELSE
            BEGIN 
            NET$SENDL7(LEV7$ES,PRDER7);  # NON-RETRYABLE SEND ERROR    #
            END 
          GOTO NEXTAT;
  
PLACT11:                                 # **** IFTSTART ****          #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY2;         # WORD SIZE OF MESSAGE        #
          PFCSFC[0] = IFTSTRT;           # MESSAGE IS IFT/START        #
          SPACN[0] = FTTACN[FTTINDEX];   # GET ACN FROM FTT TABLE      #
          P<FET$CIO> = FTTFETADR[FTTINDEX]; # PULL CIO TEMPLATE OVER   #
                                         # FET ADDRESS                 #
          SPCURPR[0] = FTTCURPRU[FTTINDEX];   # GET CURRENT PRU        #
                                         # POSITION WITHIN THE FILE    #
          SPLFN[0] = FETLFN[0];          # GET FILE NAME FROM FET      #
          SPFNT[0] = FETFNT[0];          # FET FNT POINTER FROM FET    #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
PLACT12:                                 # **** IFT/OFF ****           #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = IFTOFF;            # MESSAGE IS OFT/OFF          #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # NETPUT MESSAGE              #
          GOTO NEXTAT;
  
PLACT13:                                 # **** ER(OK) ****            #
          NET$SENDL7(LEV7$ER,PRDER1);    # ER(OK) SENT                 #
          GOTO NEXTAT;
  
PLACT14:                                 # **** FCBRK ****             #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = FCBRK;             # SEND FCBRK                  #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
PLACT15:                                 # **** RR(CKPT) ****          #
          IF FTTRFACIL[FTTINDEX]         # IF RFACIL SPECIFIED         #
          THEN
            BEGIN 
            IF FTTNRETRY[FTTINDEX ] NQ 0 # IF RETRY COUNT NOT 0        #
            THEN
              BEGIN 
              FTTNRETRY[FTTINDEX] = FTTNRETRY[FTTINDEX] - 1;
              NP$BTO8(FTTICKVAL[FTTINDEX],ITEMP);  # CONVERT TO ASCII  #
              NET$SENDL7(LEV7$RR,ITEMP); # SEND RR                     #
              END 
            ELSE
              BEGIN 
              FTTSTRC[FTTINDEX] = MAX$RTY;  # MAXIMUM RETRY REACHED    #
              NP$XCMP;                   # END FILE TRANSFER           #
              END 
            END 
          ELSE
            BEGIN 
            NP$XCMP;                     # END FILE TRANSFER IF R NOT  #
            END                          # SEPECIFIED                  #
          GOTO NEXTAT;
  
  
PLACT16:                                 # **** ER(E) ****             #
          IF FTTOPCODE[FTTINDEX] EQ 0    # IF RECEIVER                 #
          THEN
            BEGIN 
            NET$SENDL7(LEV7$ER,PRDER4);  # NON-RETRYABLE RECEIVE ERROR #
            END 
          ELSE
            BEGIN 
            NET$SENDL7(LEV7$ER,PRDER7);  # NON-RETRYABLE SEND ERROR    #
            END 
          GOTO NEXTAT;
  
PLACT17:                                 # **** QR(E) ****             #
          NET$SENDL7(LEV7$QR,PRDER4);    # NON-RETRYABLE RECEIVE ERROR #
          GOTO NEXTAT;
  
PLACT18:                                 # **** INTRRSP ****           #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = INTRRSP;           # SEND INTRRSP                #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
PLACT19:                                 # **** IDLE = TRUE ****       #
          IDLEDOWN = TRUE;               # SET IDLEDOWN TO TRUE        #
          GOTO NEXTAT;
PLACT20:                                 # *** PRUONA RECEIVED ***     #
          IF PRERC EQ RETRY$PRA          # IF REASON CODE FROM PRUONA  #
          THEN                           # IS 5                        #
            BEGIN                        # CHANGE STATE TO STATE 15    #
            NEWSTATE =  NSPWACK;         # SO THAT IT CAN RETRY PRUON  #
                                         # WHEN IT RECEIVES A FCACK    #
            END 
          ELSE
            BEGIN 
            IF PRERC EQ INTRA$PRA        # REASON CODE 4               #
            THEN                         # SWITCH TO INTRAHOST BINARY  #
              BEGIN                      # FILE XFR                    #
              NP$RLOC;                   # CALL BUFFER REALLOCATION    #
                                         # PROCEDURE                   #
              FTTSTORD[FTTINDEX] = NETSCOD;  # SET TABLE ORDINAL       #
                                         # TO CHARACTER MODE SENDER    #
              FTTSTATE[FTTINDEX] = NSCDATA;  # STATE IS DATA PHASE     #
              END 
            ELSE
              BEGIN 
              IF IDLEDOWN                # IF IDLEDOWN FLAG SET        #
              THEN
                BEGIN 
                IF REASON EQ RC1         # IF COMPLETE WITHOUT ERROR   #
                THEN
                  BEGIN 
                  REASON = RC12;         # SET REASON CODE TO 12       #
                  FTTSTRC[FTTINDEX] = RC12;# SET REASON CODE TO 12     #
                  END 
                ELSE
                  BEGIN 
                  REASON = RC13;         # ELSE SET TO RC13 IF COMPLETE#
                                         # WITH ERROR                  #
                  FTTSTRC[FTTINDEX] = RC13;#    UPDATE THE REASON CODE #
                                         # IN THE FTT TABLE            #
                  END 
                END 
              NP$XCMP;                   # EXIT FILE TRANSFER          #
              END 
            END 
          GOTO NEXTAT;
PLACT21:                                 # *** PRUONA RECEIVED ***     #
                                         # *** FOR RECEIVER    ***     #
          IF PRERC EQ INTRA$PRA          # REASON CODE 4 FROM PRUONA   #
          THEN                           # SWITCH TO INTRAHOST BINARY  #
            BEGIN                        # FILE XFR                    #
            NP$RLOC;                     # CALL BUFFER REALLOCATION    #
                                         # PROCEDURE                   #
            FTTSTORD[FTTINDEX] = NETRCOD;    # SET TABLE ORDINAL       #
                                         # TO CHARACTER MODE SENDER    #
            FTTSTATE[FTTINDEX] = NRCDATA;    # STATE IS DATA PHASE     #
            NP$BTO8(FTTICKVAL[FTTINDEX],ITEMP);  # FAKE SR             #
            NET$SENDL7(LEV7$SR,ITEMP);
            FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
            END 
          ELSE
            BEGIN 
            IF IDLEDOWN                  # IF IDLEDOWN FLAG SET        #
            THEN
              BEGIN 
              IF REASON EQ RC1           # IF COMPLETE WITHOUT ERROR   #
              THEN
                BEGIN 
                REASON = RC12;
                FTTSTRC[FTTINDEX] = RC12;# SET REASON CODE TO 12       #
                END 
              ELSE
                BEGIN 
                REASON = RC13;           # ELSE SET TO RC13 IF COMPLETE#
                                         # WITH ERROR                  #
                FTTSTRC[FTTINDEX] = RC13;#      UPDATE THE REASON CODE #
                                         # IN THE FTT TABLE            #
                END 
              END 
            NP$XCMP;                     # EXIT FILE TRANSFER          #
            END 
          GOTO NEXTAT;
PLACT22:                                 # **** LSTOFF ****            #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = LSTOFF;            # SEND LSTOFF                 #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
PLACT23:                                 # **** LSTON ****             #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = LSTON;             # SEND LSTON                  #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
CLACT0:                                  # **** STATUS = -1 ****       #
          STATUSWD = -1;
          GOTO NEXTAT;
  
CLACT1:                                  # **** SS(CHECKMARK) ****     #
          NP$BTO8(FTTICKVAL[FTTINDEX],ITEMP);  # CONVERT TO ASCII      #
          NET$SENDL7(LEV7$SS,ITEMP);     # SEND SS                     #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;  # DECREASE   #
                                         # WINDOW SIZE                 #
          GOTO NEXTAT;
  
CLACT2:                                  # **** STATUS = 0 ****        #
          STATUSWD = 0;                  # SET STATUS TO 0             #
          GOTO NEXTAT;
CLACT3:                                  # **** ES(E) ****             #
          IF FTTOPCODE[FTTINDEX] EQ 0    # NON-RETRYABLE RECEIVE ERROR #
          THEN
            BEGIN 
            NET$SENDL7(LEV7$ES,PRDER3);  # SEND ES(E)                  #
            END 
          ELSE
            BEGIN 
            NET$SENDL7(LEV7$ES,PRDER7);  # SEND ES(E)                  #
            END 
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;  # DECREASE   #
                                         # WINDOW SIZE                 #
          GOTO NEXTAT;
  
CLACT4:                                  # **** ADVANCE ABL WINDOW *** #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] + 1;
          GOTO NEXTAT;
  
CLACT5:                                  # **** RETURN ****            #
          IF IDLEDOWN                    # IF IDLEDOWN FLAG SET        #
          THEN
            BEGIN 
            IF REASON EQ RC1             # IF COMPLETE WITHOUT ERROR   #
            THEN
              BEGIN 
              REASON = RC12;             # SET REASON CODE TO 12       #
              FTTSTRC[FTTINDEX] = RC12;  # ALSO SET THE REASON CODE IN #
              END 
            ELSE
              BEGIN 
              REASON = RC13;             # ELSE SET TO RC13 IF COMPLETE#
                                         # WITH ERROR                  #
              FTTSTRC[FTTINDEX] = RC13;  # ALSO UPDATE THE REASON CODE #
                                         # IN THE FTT TABLE            #
              END 
            END 
          IF FTTOPCODE[FTTINDEX] EQ 0 OR # RECEIVER OR ABL WINDOW      #
             FTTABL[FTTINDEX] EQ FTTCURBLK[FTTINDEX] OR# FULLY OPEN    #
             REASON EQ RC2 OR REASON EQ RC3 OR # OR REAOSN CODE = 2,3,5#
             REASON EQ RC5
          THEN
            BEGIN 
            NP$XCMP;                     # COMPLETE FILE TRANSFER      #
            END 
          ELSE
            BEGIN 
            FTTSTATE[FTTINDEX] = NSCWACK;# INTERNALLY CHANGE STATE TO  #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = LSTOFF;            # SEND LSTOFF                 #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
            END                          # WAIT FOR ALL FCACKS PENDING #
          GOTO NEXTAT;
CLACT6:                                  # **** RESET ABL WINDOW ****  #
                                         # **** SEND FCRST       ****  #
                                         # **** FCBRK IS RECEIVED **** #
          FTTOUTCWS[FTTINDEX] = 0;       # RESET OUTSTANDING CHECKMARK #
          FTTBLK$MS[FTTINDEX] = MSWINDOWSZ;  # RESET CHECKMARK WINDOW  #
          FTTCURBLK[FTTINDEX] = FTTABL[FTTINDEX]; 
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = FCRST;             # SEND FCRST                  #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
CLACT7:                                  # **** INTRRSP ****           #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = INTRRSP;           # SEND INTRRSP                #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
CLACT8:                                  # **** IDLEDOWN = TRUE ****   #
          IDLEDOWN = TRUE;
          GOTO NEXTAT;
  
CLACT9:                                  # ** STATUS = -1 AND RESET ** #
          STATUSWD = -1;                 # STATUS = -1                 #
          FTTOUTCWS[FTTINDEX] = 0;       # RESET OUTSTANDING CHECKMARK #
          FTTBLK$MS[FTTINDEX] = MSWINDOWSZ;  # RESET CHECKMARK WINDOW  #
          NP$8TIN(DATA$WORD[2],ITEMP);   #       GET CHECKMARK NUMBER  #
          IF ITEMP LS FTTLCKACK[FTTINDEX] 
             OR ITEMP GR FTTLCKSNT[FTTINDEX]  # IF CHECKMARK OUT OF    #
          THEN                           # RANGE                       #
            BEGIN 
            FTTSTRC[FTTINDEX] = BAD$CHK; # SET REASON CODE TO 22       #
            NP$XCMP;                     # EXIT WITH REASON CODE       #
            END 
          ELSE
            BEGIN                        # OTHERWISE READY TO RESTART  #
            IF FTTRFACIL[FTTINDEX]       # IF RESTART ALLOWED          #
            THEN
              BEGIN 
              IF FTTNRETRY[FTTINDEX] NQ 0  # MAXRETRY NOT REACHED      #
              THEN
                BEGIN 
                FTTNRETRY[FTTINDEX] = FTTNRETRY[FTTINDEX] - 1;
                FTTRPND[FTTINDEX] = TRUE;  # SET RESTART PENDING FLAG  #
                IF ITEMP NQ 0          # IF NON-ZERO CHECKMARK         #
                THEN
                  BEGIN 
                  NP$XLCH(ITEMP,ITEMP2); # LOCATE CHECK MARK ENTRY     #
                  IF ITEMP2 GR CHK$START # IF ENTRY IS OTHER THAN      #
                  THEN
                    BEGIN                # THE DEFAULT ENTRY           #
                    CHK$IDX[0] = CHK$START;  # RESET CHK$IDX           #
                    CHK$WRD1[CHK$START] = CHK$WRD1[ITEMP2]; 
                    CHK$WRD2[CHK$START] = CHK$WRD2[ITEMP2]; 
                    END                  # COLLAPSE TABLE TO DEFAULT   #
                                         # ENTRY + THE ENTRY OF RR     #
                  ITEMP2 = FETIN[0] - FETOUT[0]; # COMPUTE PRU         #
                  IF ITEMP2 LS 0       # GET DIFFERENCE IN WORD NUMBER #
                  THEN
                    BEGIN 
                    ITEMP2 = ITEMP2 + FETLIM[0] - FETFIR[0];
                    END 
                  ITEMP2 = ITEMP2 + FTTWORD[FTTINDEX];
                  FTTCURPRU[FTTINDEX] = FTTCURPRU[FTTINDEX] + 
                                        ITEMP2/64;
                  IF FTTEOR[FTTINDEX]    # IF EOR                      #
                  THEN
                    BEGIN 
                    IF FTTEOI[FTTINDEX]  # IF EOI                      #
                    THEN
                      BEGIN 
                      IF ( FETIN[0] NQ FETOUT[0]) OR
                         (CMB$DBIT[0] NQ CMB$STEP[0]) 
                      THEN
                        BEGIN 
                        FTTCURPRU[FTTINDEX] = FTTCURPRU[FTTINDEX] + 1;
                        END 
                      END                # END OF EOI                  #
                    ELSE                 # NOT EOI BUT EOR/EOF         #
                      BEGIN 
                      FTTCURPRU[FTTINDEX] = FTTCURPRU[FTTINDEX] + 1;
                      END 
                    FTTTBC[FTTINDEX] = 0;# CLEAR LEVEL NO + EORI FLAGS #
                    END                  # END OF EOR                  #
                  PRUDIFF = FTTCURPRU[FTTINDEX]- CHK$PRUNO[CHK$START];
                  CIOSKIP[0] = PRUDIFF;  # SET NUMBER OF PRU BACKSPACED#
                                         # BACKSPACED                  #
                  NP$CIO(CIO$BKSPRU);    #    BACKSPACE PRU            #
                  CIOSKIP[0] = 0;        # CLEAR SKIP COUNT            #
                  FETIN[0] = FETFIR[0];  # RESET DISK IN POINTER       #
                  FETOUT[0] = FETFIR[0] ; 
                  CMB$STATE[0] = CHK$STATE[CHK$START];
                  CMB$DBIT[0] = CHK$DBIT[CHK$START];
                  FTTWORD[FTTINDEX] = CHK$WORD[CHK$START];
                  FTTCURPRU[FTTINDEX] = CHK$PRUNO[CHK$START]; 
                  FTTDBIT[FTTINDEX] = CHK$DBIT[CHK$START];
                  FTTMSTATE[FTTINDEX] = CHK$STATE[CHK$START]; 
                  FTTTBN[FTTINDEX] = 0;  # CRUDGE FOR RVL              #
                  END                  # COPY CHECKMARK INFO TO FTT    #
                ELSE
                  BEGIN 
                  NP$CIO(CIO$REWIND);    # REWIND DISK FILE            #
                  CMB$STATE[0] = CHK$STATE[1];
                  CMB$DBIT[0] = CHK$DBIT[1];
                  CHK$IDX[0] = 1;        # COLLAPSE TABLE TO DEFAULT   #
                  FTTWORD[FTTINDEX] = CHK$WORD[1];     # ENTRY         #
                  FTTCURPRU[FTTINDEX] = CHK$PRUNO[1]; 
                  FTTDBIT[FTTINDEX] = CHK$DBIT[1];
                  FTTMSTATE[FTTINDEX] = CHK$STATE[1]; 
                  FTTTBN[FTTINDEX] = 0; 
                  END 
                FTTLCKACK[FTTINDEX] = ITEMP;  # SET LAST CHEKMARK ACKED#
                FTTLCKSNT[FTTINDEX] = ITEMP;  # TO CHECKMARK OF RR     #
                FTTICKVAL[FTTINDEX] = ITEMP;  # UPDATE INITIAL CHECK   #
                END                           # MARK NUMBER            #
              ELSE
                BEGIN 
                FTTSTRC[FTTINDEX] = MAX$RTY; # SET REASON CODE TO      #
                                       # MAXRETRY COUNT REACHED        #
                NP$XCMP;               # QUIT NETXFR                   #
                END 
              END 
            ELSE
              BEGIN 
              FTTSTRC[FTTINDEX] = BSN$ERR; # ERROR EXIT NO RESTART     #
              NP$XCMP;
              END 
            END 
          GOTO NEXTAT;
  
CLACT10:                                 # **** ES(OK) ****            #
          NET$SENDL7(LEV7$ES,PRDER1);    # SEND ES(OK)                 #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW VALUE   #
          IF FTTCURBLK[FTTINDEX] EQ 0    # IF ABL WINDOW CLOSED        #
          THEN
            BEGIN 
            NBACKTRIG = NSCTABE;         # ABL CLOSED AFTER ES(OK) SENT#
            END 
          GOTO NEXTAT;
  
CLACT11:                                 # ** ADVANCE CHECHMARK WINDOW #
           NP$8TIN(DATA$WORD[2],ITEMP);  # EXTRACT CHECKMARK NUMBER    #
           IF ITEMP LS FTTLCKACK[FTTINDEX] OR 
              ITEMP GR FTTLCKSNT[FTTINDEX] # CHECKMARK OUT OF RANGE    #
           THEN 
             BEGIN
             FTTSTRC[FTTINDEX] = BAD$CHK;# SET REASON CODE TO 22       #
             NP$XCMP;                    # QUIT NETXFR                 #
             END
           ELSE 
             BEGIN
             FTTOUTCWS[FTTINDEX] = FTTOUTCWS[FTTINDEX] - 1; 
             FTTLCKACK[FTTINDEX] = ITEMP;# UPDATE LAST CHECKMARK ACKED #
             NP$XLCH(ITEMP,ITEMP2);      # LOCATE CHECK MARK ENTRY     #
             IF ITEMP2 GR CHK$START      # IF ENTRY IS NOT THE DEFAULT #
             THEN 
               BEGIN                     # ENTRY                       #
               NP$SHRK(ITEMP2);          # SHRINK CHECKMARK TABLE UP TO#
               END                       # THIS ENTRY                  #
             END
           GOTO NEXTAT; 
  
CLACT12:                                 # **** SEND DATA     ****     #
          NP$SENF(NBACKTRIG);            # CALL SEND DATA              #
          GOTO NEXTAT;
  
CLACT13:                                 # **** SR ****                #
          P<LV7$BASE> = LOC(DATA$WORD[1]);# SET LEVEL 7 BASE TO DATAWOR#
          ITEMP = LV7$ERROR[0];          # EXTRACT CHECKMARK NUMBER    #
          NET$SENDL7(LEV7$SR,ITEMP);
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW BY 1    #
          GOTO NEXTAT;
  
CLACT14:                                 # **** ER(E) ****             #
          IF FTTOPCODE[FTTINDEX] EQ 0    # IF RECEIVER                 #
          THEN
            BEGIN 
            NET$SENDL7(LEV7$ER,PRDER4);  # NON-RETRYABLE RECEIVE ERROR #
            END 
          ELSE
            BEGIN 
            NET$SENDL7(LEV7$ER,PRDER7);  # NON-RETRYABLE SEND ERROR    #
            END 
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW BY 1    #
          GOTO NEXTAT;
  
CLACT15:                                 # ** STATUS = -1 AND RWL **   #
          STATUSWD = -1;                 # STATUS = -1                 #
          FTTCURBLK[FTTINDEX] = FTTABL[FTTINDEX]; 
          GOTO NEXTAT;
  
CLACT16:                                 # **** SS(CHECKMARK)****      #
          P<LV7$BASE> = LOC(DATA$WORD[1]);# SET LEVEL 7 BASE TO DATAWOR#
          ITEMP = LV7$ERROR[0];          # EXTRACT CHECKMARK NUMBER    #
          NET$SENDL7(LEV7$SS,ITEMP);     # SEND SS THE CHECKMAR USED   #
                                         # IS THE SAME AS RR AS A      #
                                         # CONFIRMATION                #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW         #
          GOTO NEXTAT;
  
CLACT17:                                 # **** STATUS = -2 ****       #
          STATUSWD = MINUS2;             # SET STATUS = -2             #
          GOTO NEXTAT;
  
CLACT18:                                 # **** QR(E) ****             #
          NET$SENDL7(LEV7$QR,PRDER3);    # NON-RETRYABLE RECEIVE ERROR #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW BY 1    #
          GOTO NEXTAT;
  
CLACT19:                                 # **** CLOSE ****             #
          NP$CIO(CIO$CLOSE);             # CLOSE FILE                  #
          IF FETEC[0] NQ 0               # IF ERROR EXISTS IN  CLOSE   #
          THEN
            BEGIN 
            NBACKTRIG = NRCTITR;         # SET BACK TRIGGER TO INTERNAL#
            END                          # ERROR                       #
          ELSE
            BEGIN 
            NBACKTRIG = NRCTEOK;         # SET BACK TRIGGER TO ENDOK   #
            END 
          GOTO NEXTAT;
  
CLACT20:                                 # **** SAVE CHECKMARK ****    #
          NP$8TIN(DATA$WORD[2],ITEMP);   # GET CHECKMARK VALUE         #
          CHK$IDX[0] = CHK$START;        # SET ENTRY POINTER TO SECOND #
                                         # ENTRY                       #
          CHK$MARK[CHK$START] = ITEMP;   # COPY CHECKMARK NUMBER       #
          CHK$PRUNO[CHK$START] = FTTCURPRU[FTTINDEX];# UPDATE CHECKMARK#
          CHK$WORD[CHK$START] = FTTWORD[FTTINDEX];   # TABLE           #
          CHK$DBIT[CHK$START] = FTTDBIT[FTTINDEX];
          CHK$STATE[CHK$START] = FTTMSTATE[FTTINDEX]; 
          CHK$TBN[CHK$START] = FTTTBN[FTTINDEX];
          FTTLCKACK[FTTINDEX] = ITEMP;   # SAVE LAST MS RECEIVED       #
          NBACKTRIG = NRCTCHM;           # SET BACKTRIG TO SEND MR     #
          GOTO NEXTAT;
  
CLACT21:  
          DATA$WORD[1] = SAVE$WORD;      # RESTORE DATA$WORD 1         #
          NP$RECV(NBACKTRIG);            # RECEIVER                    #
          DATA$WORD[1] = 0;              # CLEAR DATA$WORD 1           #
          GOTO NEXTAT;
  
CLACT22:                                 # **** FCBRK ****             #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = FCBRK;             # SEND FCBRK                  #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
CLACT23:                                 # **** MR ****                #
          NP$BTO8(FTTLCKACK[FTTINDEX],ITEMP);  # CONVERTS TO ASCII     #
          NET$SENDL7(LEV7$MR,ITEMP);     # SEND MR                     #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW BY 1    #
          GOTO NEXTAT;
  
CLACT24:                                 # **** RR(CHECKMARK) ****     #
            IF FTTRFACIL[FTTINDEX]       # IF RFACIL SPECIFIED         #
            THEN
              BEGIN 
              IF FTTNRETRY[FTTINDEX] GR 0# IF MAXRETRY COUNT NOT EXCEED#
              THEN
                BEGIN 
                FTTNRETRY[FTTINDEX] = FTTNRETRY[FTTINDEX] - 1;
                IF CHK$IDX GQ CHK$START  # NON-ZERO CHECKMARK          #
                THEN
                  BEGIN 
                  NP$BTO8(CHK$MARK[CHK$START],ITEMP);# GET ASCII VALUE #
                  PRUDIFF = FTTCURPRU[FTTINDEX] - CHK$PRUNO[CHK$START]; 
                                         # COMPUTE PRU DIFFERENCE      #
                  IF PRUDIFF GR 0        # HAVE TO BACKSPACE AND READ  #
                  THEN
                    BEGIN 
                    CIOSKIP[0] = PRUDIFF;  # SET PRU TO BE BACKSPACED  #
                    NP$CIO(CIO$BKSPRU);  #      BACKSPACE PRU'S        #
                    CIOSKIP[0] = 0;      # CLEAR SKIP COUNT            #
                    FETOUT[0] = FETFIR[0];
                    FETIN[0] = FETFIR[0]; 
                    NP$CIO(CIO$RPHR);    # READ IN THAT PRU            #
                    CIOSKIP[0] = 1; 
                    NP$CIO(CIO$BKSPRU); 
                    CIOSKIP[0] = 0; 
                    FETIN[0] = CHK$WORD[CHK$START] + FETFIR[0]; 
                    END 
                  ELSE
                    BEGIN                # NO NEED TO BACKSPACE        #
                    FETIN[0] = FETOUT[0] + CHK$WORD[CHK$START]; 
                    IF FETIN[0] GQ FETLIM[0]#WRAP AROUND HAS OCCURRED  #
                    THEN
                      BEGIN 
                      FETIN[0] = FETFIR[0] + (FETIN[0] - FETLIM[0]);
                      END 
                    END 
                  CMB$DBIT[0] = CHK$DBIT[CHK$START]; # SET DBIT        #
                  CMB$STATE[0] = CHK$STATE[CHK$START];
                  FTTMSTATE[FTTINDEX] = CHK$STATE[CHK$START]; 
                  FTTCURPRU[FTTINDEX] = CHK$PRUNO[CHK$START]; 
                  FTTWORD[FTTINDEX] = CHK$WORD[CHK$START];
                  FTTDBIT[FTTINDEX] = CHK$DBIT[CHK$START];
                  FTTTBN[FTTINDEX] = 0;  # CRUDGE FOR RVL              #
                  P<COPYAREA> = FETIN[0]; 
                  ITEMP2 = WORDLENGTH - CMB$DBIT[0];
                  B<ITEMP2,CMB$DBIT[0]>WORD[0] = 0;  # CLEAR WORD      #
                  END 
                ELSE
                  BEGIN 
                  NP$CIO(CIO$REWIND);    # REWIND FILE                 #
                  P<COPYAREA> = 0;
                  WORD[FETIN[0]] = 0;    # CLEAR FIRST WORD OF DBUF    #
                  CMB$DBIT[0] = CHK$DBIT[1]; # SET DBIT                #
                  CMB$STATE[0] = 0; 
                  FTTMSTATE[FTTINDEX] = 0;
                  FTTCURPRU[FTTINDEX] = 0;   # START FROM PRU 0        #
                  FTTWORD[FTTINDEX] = 0;
                  FTTTBN[FTTINDEX] = 0; 
                  FTTDBIT[FTTINDEX] = CMB$DBIT[0];
                  ITEMP = PRDER1;        # SET ASCII 0 CHECKMARK       #
                  END 
                NET$SENDL7(LEV7$RR,ITEMP); # SEND RR AS LEVEL 7 MESSAGE#
                FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                END 
              ELSE
                BEGIN 
                FTTSTRC[FTTINDEX] = MAX$RTY; # SET REASON CODE         #
                NP$XCMP;                   # QUIT NETXFR               #
                END 
              END 
            ELSE
              BEGIN 
              NP$XCMP;
              END 
          GOTO NEXTAT;
  
CLACT25:                                 # **** ER(OK) ****            #
          NET$SENDL7(LEV7$ER,PRDER1);    # SEND ER(OK)                 #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] - 1;
                                         # DECREASE ABL WINDOW BY 1    #
          GOTO NEXTAT;
CLACT26:                                 # **** LSTOFF ****            #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = LSTOFF;            # SEND LSTOFF                 #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
CLACT27:                                 # **** LSTON ****             #
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = LSTON;             # SEND LSTON                  #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
CLACT28:                                 # *** ADV WINDOW + LSTON      #
          FTTCURBLK[FTTINDEX] = FTTCURBLK[FTTINDEX] + 1;
          LOC$HA = LOC(OUT$ABH);         # UPDATE HEADER ADDRESS       #
          LOC$TA = LOC(DATA$BUF);        # UPDATE TEXT AREA ADDRESS    #
          OUT$ABHTLC[0] = ENTY1;         # WORD COUNT OF MESSAGE       #
          PFCSFC[0] = LSTON;             # SEND LSTON                  #
          SPACN[0] = FTTACN[FTTINDEX];   # PICK UP ACN FROM FTT TABLE  #
          OPCODE = OP$PUT;               # SET OPCODE                  #
*IF DEF,STAT,1
          IAM = TYPE"PUT";               # SET TYPE OF ROUTINE         #
          NP$PUT;                        # SEND MESSAGE                #
          GOTO NEXTAT;
  
NEXTAT:     CRNT$ACTION = ACTION2;        # GET ACTION2                #
          END                             # END WHILE                  #
        IF NEWSTATE NQ NOCHG       # IF NOT SAME STATE                 #
        THEN
          BEGIN 
*IF DEF,DEBUG,1 
          FTTPREST[NETCON]= FTTSTATE[NETCON]; #       UPDATE FILE TABLE#
*IF DEF,DEBUG,1 
          FTTPREST[NETCON  ] = FTTSTATE[NETCON  ];  # UPDATE FILE TABLE#
          FTTSTATE[NETCON] = NEWSTATE;
          END 
        END                        # END IF                            #
EXITT:  RETURN;                    # RETURN TO CALLER                  #
      END                          # END OF NP$STPR                    #
TERM
*ENDIF
