*DECK FETCMP
USETEXT COMCBEG 
USETEXT COMRRTN 
USETEXT COMRAPL 
USETEXT COMREVN 
USETEXT COMRNDR 
USETEXT COMRQUE 
USETEXT COMRSTA 
PROC FETCMP;
# TITLE FETCMP - FET I/O COMPLETE.  # 
  
      BEGIN  # FETCMP # 
  
# 
**    FETCMP  - FET I/O COMPLETE. 
* 
*     PROCESS FET I/O COMPLETION. 
* 
*     PROC FETCMP.
* 
*     ENTRY   - NDR$COMMUN IS BASED ARRAY CONTAINING FET COMPLETION.
*               NAD$ENTRY IS BASED ARRAY CONTAINING LOCAL NAD ENTRY.
*               QU$ADDRESS IS BASED ARRAY CONTAINING FET REQUEST. 
* 
*     EXIT    - FET I/O COMPLETE HANDLED. 
* 
*     PROCESS - INITIALIZE APPLICATION AND CONNECTION POINTERS. 
*               DEPENDING ON WHICH RETURN CODE: 
*                 CASE (FET I/O COMPLETE):  
*                   SET COMPLETE FLAG.
*                 CASE (NAD IS OFF):  
*                   SET COMPLETE FLAG.
*                   CALL TO CREATE NAD OFF QUEUE ENTRY. 
*                   POINT TO FET REQUEST QUEUE ENTRY. 
*                 CASE (USER SWAPPED):  
*                   QUEUE REQUEST ON SWAP QUEUE.
*                   CALL TO CREATE SWAP IN REQUEST. 
*                 CASE (OUTPUT THRESHOLD REACHED):  
*                   INCREMENT RETRY COUNT.
*                   QUEUE ON DELAY QUEUE. 
*                 CASE (NO INPUT AVAILABLE):  
*                   INCREMENT RETRY COUNT.
*                   QUEUE ON DELAY QUEUE. 
*                 CASE (USER PARAMETER ERROR):  
*                   QUEUE ON ERROR LOGICAL QUEUE. 
*                   FREE QUEUE ENTRY. 
*               IF COMPLETE FLAG SET
*               THEN: 
*                 SET QUEUE TYPE TO UCP COMPLETE. 
*                 INITIATE UCP REPLY. 
*               UPDATE BLOCKS READ. 
*               IF OVERFLOW 
*               THEN: 
*                 WRAP COUNT AROUND.
*                 CALL CREATE OVERFLOW ENTRY. 
*               UPDATE BLOCKS WRITTEN.
*               IF OVERFLOW 
*               THEN: 
*                 WRAP COUNT AROUND.
*                 CALL CREATE OVERFLOW ENTRY. 
*               CALL STATUS TO PROCESS ENTRY. 
*               RETURN. 
# 
  
# 
****  PROC FETCMP - XREF LIST BEGIN.
# 
      XREF
        BEGIN 
        PROC QUEUE;                  # QUEUE #
        PROC QUEOFF;                 # QUEUE NAD OFF #
        PROC QERRLGL;                # QUEUE ON ERR/LGL QUEUE # 
        PROC FREE;                   # FREE QUEUE ENTRY # 
        PROC SWAPIN;                 # CREATE SWAP IN REQUEST # 
        PROC UCPRPLY;                # INITIATE UCP REPLY # 
        PROC OVRFLOW;                # CREATE OVERFLOW QUEUE ENTRY #
        PROC STATUSF;                # STATUS # 
        END 
  
# 
****  PROC FETCMP - XREF LIST END.
# 
  
      ITEM COMPLETE   B;             # COMPLETE REQUEST FLAG #
      ITEM ACN I;                    # ACN OF REQUEST # 
  
      SWITCH RETURNCODE 
             COMPLETEIO,             # FET I/O COMPLETE # 
             NADOFF,                 # NAD OFF #
             SWAPPED,                # USER SWAPPED # 
             NOBUFF,                 # NO OUTPUT BUFFERS AVAILABLE #
             NOINPUT,                # NO INPUT AVAILABLE # 
             PARMERR,                # USER PARAMETER ERROR # 
             ;
  
CONTROL EJECT;
  
      P<APL$HEADER> = QU$APLADR;
      P<CONNECTION> = P<APL$HEADER> + APL$LENGTH +
                      (QU$UCPACN - APL$MINACN) * CON$LENGTH;
      ACN = QU$UCPACN;
      COMPLETE = FALSE; 
  
# 
*     PROCESS RETURN CODE THRU SIMULATED CASE STATEMENT.
# 
  
      GOTO RETURNCODE[NDR$RTNCOD];
  
COMPLETEIO:                          # COMPLETE FET I/O # 
      COMPLETE = TRUE;
      GOTO ENDCASE; 
  
NADOFF:                              # NAD OFF #
      COMPLETE = TRUE;
      QUEOFF; 
      P<QU$ADDRESS> = NDR$QADDR;
      GOTO ENDCASE; 
  
SWAPPED:                             # USER SWAPPED # 
      QUEUE(LOC(APL$SWAPQ));
      SWAPIN; 
      GOTO ENDCASE; 
  
NOBUFF:                              # NO OUTPUT BUFFERS AVAILABLE #
      QU$RETRY = QU$RETRY + 1;
      QU$EVENT = EVNT$OUT;
      QUEUE(LOC(CON$DELAYQ)); 
      GOTO ENDCASE; 
  
NOINPUT:                             # NO INPUT AVAILABLE # 
      QU$RETRY = QU$RETRY + 1;
      QU$EVENT = EVNT$IN; 
      QUEUE(LOC(CON$DELAYQ)); 
      GOTO ENDCASE; 
  
PARMERR:                             # USER PARAMETER ERROR # 
      QERRLGL(LGL$NULERR,LES$FAERR,QU$FETADR,0,0,QU$WD4,QU$WD5);
      FREE; 
      GOTO ENDCASE; 
  
# 
*     END OF SIMULATED CASE STATEMENT.
# 
ENDCASE:  
      IF COMPLETE 
      THEN
        BEGIN  # COMPLETE UCP REQUEST OUTSTANDING # 
        QU$TYPE = QT$UCPCOMP; 
        UCPRPLY;
        END 
  
        IF CON$BLKRD + NDR$BLKRED LQ O"77777" 
        THEN
          BEGIN  # UPDATE BLOCKS READ # 
          CON$BLKRD = CON$BLKRD + NDR$BLKRED; 
          END 
  
        ELSE
          BEGIN  # BLOCKS READ OVERFLOW # 
          CON$BLKRD  = CON$BLKRD + NDR$BLKRED - O"77776"; 
          OVRFLOW(CNT$BLKRD); 
          END 
  
        IF CON$BLKWRT + NDR$BLKWRT LQ O"77777"
        THEN
          BEGIN  # UPDATE BLOCKS WRITTEN #
          CON$BLKWRT = CON$BLKWRT + NDR$BLKWRT; 
          END 
  
        ELSE
          BEGIN  # BLOCKS WRITTEN OVERFLOW #
          CON$BLKWRT = CON$BLKWRT + NDR$BLKWRT - O"77776";
          OVRFLOW(CNT$BLKWRT);
          END 
  
      P<EVNT$ENTRY> = P<NDR$COMMUN> + 4;
      IF EVNT$WD NQ 0 
      THEN
        BEGIN  # PROCESS EVENT #
        EVNT$ACN = ACN; 
        EVNT$APPL = P<APL$HEADER>;
        STATUSF;
        END 
  
      RETURN; 
      END  # FETCMP # 
  
      TERM
