*DECK READCMP 
USETEXT COMCBEG 
USETEXT COMRRTN 
USETEXT COMRAPL 
USETEXT COMREVN 
USETEXT COMRNET 
USETEXT COMRNDR 
USETEXT COMRQUE 
USETEXT COMRSTA 
PROC READCMP; 
# TITLE READCMP - READ PATH DATA COMPLETE.  # 
  
      BEGIN  # READCMP #
  
# 
**    READCMP - READ PATH DATA COMPLETE.
* 
*     PROCESS READ PATH DATA COMPLETION.
* 
*     PROC READCMP. 
* 
*     ENTRY   - NDR$COMMUN IS BASED ARRAY CONTAINING READ COMPLETION. 
*               NAD$ENTRY IS BASED ARRAY CONTAINING LOCAL NAD ENTRY.
*               QU$ADDRESS IS BASED ARRAY CONTAINING READ REQUEST.
* 
*     EXIT    - READ COMPLETE HANDLED.
* 
*     PROCESS - INITIALIZE APPLICATION AND CONNECTION POINTERS. 
*               POINT TO ACK QUEUE ENTRY. 
*               IF RETURN CODE IS QUEUE ACK 
*               THEN: 
*                 QUEUE ACK ON LOCAL NAD QUEUE. 
*               ELSE: 
*                 FREE QUEUE ENTRY. 
*               POINT TO READ REQUEST QUEUE ENTRY.
*               DEPENDING ON WHICH RETURN CODE: 
*                 CASE (PATH DATA BLOCK READ, NO ACK):  
*                   SET BLOCK READ FLAG.
*                 CASE (NAD IS OFF):  
*                   RETURN NSUP REPLY.
*                   CALL TO CREATE NAD OFF QUEUE ENTRY. 
*                 CASE (PATH DATA BLOCK READ, ACK SENT):  
*                   SET ACK FLAG. 
*                 CASE (PATH DATA BLOCK READ, QUEUE ACK): 
*                   SET ACK FLAG. 
*                 CASE (USER SWAPPED):  
*                   QUEUE REQUEST ON SWAP QUEUE.
*                   CALL TO CREATE SWAP IN REQUEST. 
*                 CASE (USER PARAMETER ERROR):  
*                   QUEUE ON ERROR LOGICAL QUEUE. 
*                   FREE QUEUE ENTRY. 
*                 CASE (REISSUE. INPUT NOT AVAILABLE.): 
*                   RETURN NSUP REPLY.
*               IF BLOCK READ OR ACK FLAG SET 
*               THEN: 
*                 RETURN NSUP REPLY.
*                 INCREMENT BLOCKS READ.
*                 IF OVERFLOW 
*                 THEN: 
*                   RESET COUNT TO ONE. 
*                   CALL CREATE OVERFLOW ENTRY. 
*                 IF ACK FLAG SET 
*                 THEN: 
*                   INCREMENT ACKS WRITTEN. 
*                   IF OVERFLOW 
*                   THEN: 
*                     RESET COUNT TO ONE. 
*                     CALL CREATE OVERFLOW ENTRY. 
*               CALL STATUS TO PROCESS ENTRY. 
*               RETURN. 
# 
  
# 
****  PROC READCMP - XREF LIST BEGIN. 
# 
      XREF
        BEGIN 
        PROC QUEUE;                  # QUEUE #
        PROC QERRLGL;                # QUEUE ON ERR/LGL QUEUE # 
        PROC FREE;                   # FREE QUEUE ENTRY # 
        PROC RTNNSUP;                # RETURN NSUP REPLY #
        PROC QUEOFF;                 # QUEUE NAD OFF #
        PROC SWAPIN;                 # CREATE SWAP IN REQUEST # 
        PROC OVRFLOW;                # CREATE OVERFLOW QUEUE ENTRY #
        PROC STATUSF;                # STATUS # 
        END 
  
# 
****  PROC READCMP - XREF LIST END. 
# 
  
  
      ITEM BLKREAD    B;             # BLOCK READ FLAG #
      ITEM ACKWRITTEN B;             # ACK WRITTEN FLAG # 
  
      ARRAY READRETCOD [0:2] S(1);
        BEGIN  # READ RETURN CODES #
        ITEM RRC$LE     U(00,00,30) = 
          [LGL$NULERR,LGL$NULERR,LGL$BADTLC]; 
        ITEM RRC$SC     U(00,30,30) = [LES$HAERR,LES$TAERR,0];
        END 
  
      SWITCH RETURNCODE 
             NOACK,                  # BLOCK READ, NO ACK # 
             NADOFF,                 # NAD OFF #
             ACK,                    # BLOCK READ, ACK SENT # 
             QACK,                   # BLOCK READ, QUEUE ACK #
             SWAPPED,                # USER SWAPPED # 
             PARMERR,                # USER PARAMETER ERROR # 
             NOINPUT,                # INPUT NOT AVAILABLE #
             ;
  
CONTROL EJECT;
  
      P<APL$HEADER> = QU$APLADR;
      P<CONNECTION> = P<APL$HEADER> + APL$LENGTH +
                      (QU$UCPACN - APL$MINACN) * CON$LENGTH;
      P<QU$ADDRESS> = NDR$ACKQ; 
      IF NDR$RTNCOD EQ RC$QACK
      THEN
        BEGIN  # QUEUE ACKNOWLEDGE MESSAGE #
        QUEUE(LOC(NAD$Q));
        NAD$QCOUNT = NAD$QCOUNT + 1;
        END 
  
      ELSE
        BEGIN  # FREE ACK QUEUE ENTRY # 
        FREE; 
        END 
  
      P<QU$ADDRESS> = NDR$QADDR;
      BLKREAD = FALSE;
      ACKWRITTEN = FALSE; 
  
# 
*     PROCESS RETURN CODE THRU SIMULATED CASE STATEMENT.
# 
  
      GOTO RETURNCODE[NDR$RTNCOD];
  
NOACK:                               # BLOCK READ, NO ACK#
      BLKREAD = TRUE; 
      GOTO ENDCASE; 
  
NADOFF:                              # NAD OFF #
      RTNNSUP;
      QUEOFF; 
      GOTO ENDCASE; 
  
ACK:                                 # BLOCK READ, ACK SENT # 
      ACKWRITTEN = TRUE;
      GOTO ENDCASE; 
  
QACK:                                # BLOCK READ, QUEUE ACK #
      ACKWRITTEN = TRUE;
      GOTO ENDCASE; 
  
SWAPPED:                             # USER SWAPPED # 
      QUEUE(LOC(APL$SWAPQ));
      SWAPIN; 
      GOTO ENDCASE; 
  
PARMERR:                             # USER PARAMETER ERROR # 
      QERRLGL(RRC$LE[NDR$UPERR],RRC$SC[NDR$UPERR],QU$UCPA,
        0,0,QU$WD4,QU$WD5); 
      FREE; 
      GOTO ENDCASE; 
  
NOINPUT:                             # INPUT NOT AVAILABLE #
      RTNNSUP;
      GOTO ENDCASE; 
  
# 
*     END OF STIMULATED CASE STATEMENT. 
# 
ENDCASE:  
      IF BLKREAD OR ACKWRITTEN
      THEN
        BEGIN  # RETURN NSUP REPLY AND INCREMENT COUNTS # 
        RTNNSUP;
        IF CON$BLKRD LS O"77777"
        THEN
          BEGIN  # INCREMENT BLOCKS READ #
          CON$BLKRD = CON$BLKRD + 1;
          END 
  
        ELSE
          BEGIN  # BLOCKS READ OVERFLOW # 
          CON$BLKRD = 1;
          OVRFLOW(CNT$BLKRD); 
          END 
  
        IF ACKWRITTEN 
        THEN
          BEGIN  # INCREMENT ACK COUNTER #
          IF CON$ACKWRT LS O"77777" 
          THEN
            BEGIN  # INCREMENT ACKS WRITTEN # 
            CON$ACKWRT = CON$ACKWRT + 1;
            END 
  
          ELSE
            BEGIN  # ACKS WRITTEN OVERFLOW #
            CON$ACKWRT = 1; 
            OVRFLOW(CNT$ACKWRT);
            END 
  
          END 
  
        END 
  
      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  # READCMP #
  
      TERM
