*DECK WRITCMP 
USETEXT COMCBEG 
USETEXT COMRRTN 
USETEXT COMRAPL 
USETEXT COMREVN 
USETEXT COMRNET 
USETEXT COMRNDR 
USETEXT COMRQUE 
USETEXT COMRSTA 
PROC WRITCMP; 
# TITLE WRITCMP - WRITE PATH DATA COMPLETE.  #
  
      BEGIN  # WRITCMP #
  
# 
**    WRITCMP - WRITE PATH DATA COMPLETE. 
* 
*     PROCESS WRITE PATH DATA COMPLETION. 
* 
*     PROC WRITCMP. 
* 
*     ENTRY   - NDR$COMMUN IS BASED ARRAY CONTAINING WRITE COMPLETION.
*               NAD$ENTRY IS BASED ARRAY CONTAINING LOCAL NAD ENTRY.
*               QU$ADDRESS IS BASED ARRAY CONTAINING WRITE REQUEST. 
* 
*     EXIT    - WRITE COMPLETE HANDLED. 
* 
*     PROCESS - INITIALIZE APPLICATION AND CONNECTION POINTERS. 
*               DEPENDING ON WHICH RETURN CODE: 
*                 CASE (BLOCK WRITTEN): 
*                   RETURN NSUP REPLY.
*                   INCREMENT BLOCKS WRITTEN. 
*                   IF OVERFLOW 
*                   THEN: 
*                     RESET COUNT TO ONE. 
*                     CALL CREATE OVERFLOW ENTRY. 
*                 CASE (NAD IS OFF):  
*                   RETURN NSUP REPLY.
*                   CALL TO CREATE NAD OFF QUEUE ENTRY. 
*                 CASE (USER SWAPPED):  
*                   QUEUE REQUEST ON SWAP QUEUE.
*                   CALL TO CREATE SWAP IN REQUEST. 
*                 CASE (NO BUFFERS AVAILABLE):  
*                   INCREMENT RETRY COUNT.
*                   IF RETRY EXCEEDED 
*                   THEN: 
*                     CREATE AN FCNAK RETURN. 
*                   ELSE: 
*                     QUEUE ON DELAY QUEUE. 
*                 CASE (USER PARAMETER ERROR):  
*                   QUEUE ON ERROR LOGICAL QUEUE. 
*                   FREE QUEUE ENTRY. 
*                 CASE  ( BLOCK WRITTEN, QUEUE LOCAL ACK ): 
*                   QUEUE LOCAL ACK.
*                   RETURN NSUP REPLY.
*                   INCREMENT BLOCKS WRITTEN
*                   IF OVERFLOW 
*                   THEN: 
*                     RESET COUNT TO ONE. 
*                     CALL CREATE OVERFLOW ENTRY. 
* 
*               CALL STATUS TO PROCESS ENTRY. 
*               RETURN. 
# 
  
# 
****  PROC WRITCAP - XREF LIST BEGIN. 
# 
      XREF
        BEGIN 
        PROC RTNNSUP;                # RETURN NSUP REPLY #
        PROC OVRFLOW;                # CREATE OVERFLOW QUEUE ENTRY #
        PROC QUEOFF;                 # QUEUE NAD OFF #
        PROC SWAPIN;                 # CREATE SWAP IN REQUEST # 
        PROC FCNAK;                  # CREATE FC/NAK #
        PROC LOCACK;                 # CREATE LOCAL FC/ACK #
        PROC QUEUE;                  # QUEUE #
        PROC QERRLGL;                # QUEUE ON ERR/LGL QUEUE # 
        PROC FREE;                   # FREE QUEUE ENTRY # 
        PROC STATUSF;                # STATUS # 
        END 
  
# 
****  PROC WRITCMP - XREF LIST END. 
# 
  
      DEF RETRY$WRITE #10#;          # RETRY WRITE COUNT #
  
      ARRAY WRITRETCOD [0:4] S(1);
        BEGIN  # WRITE RETURN CODES # 
        ITEM WRC$LE     U(00,00,30) = 
          [LGL$NULERR,LGL$BADACT,LGL$BADTLC,LGL$BADABT,LGL$NULERR]; 
        ITEM WRC$SC     U(00,30,30) = [LES$HAERR,0,0,0,LES$TAERR];
        END 
      SWITCH RETURNCODE 
             BLKWRTN,                # BLOCK WRITTEN #
             NADOFF,                 # NAD OFF #
             SWAPPED,                # USER SWAPPED # 
             NOBUFF,                 # NO BUFFERS AVAILABLE # 
             PARMERR,                # USER PARAMETER ERROR # 
             QUELAK,                 # BLK WRTN, QUEUE LOCAL ACK #
             ;
  
CONTROL EJECT;
  
      P<APL$HEADER> = QU$APLADR;
      P<CONNECTION> = P<APL$HEADER> + APL$LENGTH +
                      (QU$UCPACN - APL$MINACN) * CON$LENGTH;
  
# 
*     PROCESS RETURN CODE THRU SIMULATED CASE STATEMENT.
# 
  
      GOTO RETURNCODE[NDR$RTNCOD];
  
BLKWRTN:                             # BLOCK WRITTEN #
      RTNNSUP;
      IF CON$BLKWRT LS O"77777" 
      THEN
        BEGIN  # INCREMENT BLOCKS WRITTEN # 
        CON$BLKWRT = CON$BLKWRT + 1;
        END 
  
      ELSE
        BEGIN  # BLOCKS WRITTEN OVERFLOW #
        CON$BLKWRT = 1; 
        OVRFLOW(CNT$BLKWRT);
        END 
  
      GOTO ENDCASE; 
  
NADOFF:                              # MAD OFF #
      RTNNSUP;
      QUEOFF; 
      GOTO ENDCASE; 
  
SWAPPED:                             # USER SWAPPED # 
      QUEUE(LOC(APL$SWAPQ));
      SWAPIN; 
      GOTO ENDCASE; 
  
NOBUFF:                              # NO BUFFERS AVAILABLE # 
      QU$RETRY = QU$RETRY + 1;
      IF QU$RETRY EQ RETRY$WRITE
      THEN
        BEGIN  # RETURN NSUP REPLY AND CREATE FC/NAK #
        FCNAK;
        P<QU$ADDRESS> = NDR$QADDR;
        RTNNSUP;
        END 
  
      ELSE
        BEGIN  # QUEUE ON DELAY QUEUE # 
        QU$EVENT = EVNT$OUT;
        QUEUE(LOC(CON$DELAYQ)); 
        END 
  
      GOTO ENDCASE; 
  
PARMERR:                             # USER PARAMETER ERROR # 
      QERRLGL(WRC$LE[NDR$UPERR],WRC$SC[NDR$UPERR],QU$UCPA,0,0,
        QU$WD4,QU$WD5); 
      FREE; 
      GOTO ENDCASE; 
  
QUELAK:                              # QUEUE LOCAL ACK #
      LOCACK; 
      RTNNSUP;
      IF CON$BLKWRT LS O"77777" 
      THEN
        BEGIN  #INCREMENT BLOCKS WRITTEN #
        CON$BLKWRT = CON$BLKWRT + 1;
        END 
  
      ELSE
        BEGIN  # BLOCKS WRITTEN OVERFLOW #
        CON$BLKWRT = 1; 
        OVRFLOW(CNT$BLKWRT);
        END 
  
      GOTO ENDCASE; 
  
# 
*     END OF SIMULATED CASE STATEMENT.
# 
ENDCASE:  
      P<EVNT$ENTRY> = P<NDR$COMMUN> + 3;
      IF EVNT$WD NQ 0 
      THEN
        BEGIN  # PROCESS EVENT #
        EVNT$ACN = NDR$ACN; 
        EVNT$APPL = P<APL$HEADER>;
        STATUSF;
        END 
  
      RETURN; 
      END  # WRITCMP #
  
      TERM
