*DECK STATCMP 
USETEXT COMCBEG 
USETEXT COMREVN 
USETEXT COMRNET 
USETEXT COMRNDR 
USETEXT COMRQUE 
PROC STATCMP; 
# TITLE STATCMP - STATUS COMPLETE.  # 
  
      BEGIN  # STATCMP #
  
# 
**    STATCMP - STATUS COMPLETE.
* 
*     PROCESS STATUS COMPLETE.
* 
*     PROC STATCMP. 
* 
*     ENTRY   - NDR$COMMUN IS BASED ARRAY CONTAINING STATUS COMPLETION. 
                NAD$ENTRY IS BASED ARRAY CONTAINING LOCAL NAD ENTRY.
*               QU$ADDRESS IS BASED ARRAY CONTAINING (POSSIBLE) 
*                 CONTROL MESSAGE.
* 
*     EXIT    - STATUS HANDLED. 
* 
*     PROCESS - IF CONTROL MESSAGE INPUT
*               THEN: 
*                 CLEAR STATUS RECALL COUNT.
*                 IF BLOCK TYPE BACK
*                 THEN: 
*                   CALL CREATE FC/ACK. 
*                 ELSE: 
*                   SET QUEUE TYPE TO INCOMING CONTROL MESSAGE. 
*                   QUEUE ON CONTROL MESSAGE QUEUE. 
*               ELSE: 
*                 FREE QUEUE ENTRY. 
*               IF CONNECT REQUEST AVAILABLE
*               THEN: 
*                 GET FREE QUEUE ENTRY. 
*                 SET QUEUE TYPE TO CONNECT REQUEST AVAILABLE.
*                 MOVE LOCAL NAD ORDINAL. 
*                 QUEUE TO STATUS EVENT QUEUE.
*               IF EST IS OFF 
*               THEN: 
*                 SET EST OFF IN LOCAL NAD ENTRY. 
*               IF RETURN CODE IS NAD OFF 
*               THEN: 
*                 CALL TO CREATE NAD OFF QUEUE ENTRY. 
*               FOR EACH EVENT LIST ENTRY:  
*                 CLEAR STATUS RECALL COUNT.
*                 CALL STATUS TO PROCESS ENTRY. 
*               IF NAD CONNECTION COUNT IS NON ZERO 
*               THEN: 
*                 GET FREE QUEUE ENTRY. 
*                 SET QUEUE TYPE TO STATUS. 
*                 QUEUE ON NAD QUEUE. 
*               ELSE: 
*                 CLEAR STATUS QUEUED FLAG. 
*               RETURN. 
# 
  
# 
****  PROC STATCMP - XREF LIST BEGIN. 
# 
      XREF
        BEGIN 
        PROC FCACK;                  # CREATE FC/ACK MESSAGE #
        PROC QUEUE;                  # QUEUE #
        PROC FREE;                   # FREE QUEUE ENTRY # 
        PROC GETFREE;                # GET FREE QUEUE ENTRY # 
        PROC QUEOFF;                 # QUEUE NAD OFF #
        PROC STATUSF;                # PROCESS STATUS ENTRY # 
        END 
  
# 
****  PROC STATCMP - XREF LIST END. 
# 
  
  
      ITEM I I;                      # LOOP CONTROL VARIABLE #
      ITEM DONE B;                   # DONE FLAG #
  
CONTROL EJECT;
  
      IF NDR$CTLMSG 
      THEN
        BEGIN  # CONTROL MESSAGE INPUT #
        NDR$RECALL = 0; 
          IF QU$BLKTYP EQ BACK
            AND QU$APPL NE 0
            AND NOT QU$REJECT 
          THEN
            BEGIN  # CREATE FC/ACK #
            FCACK;
            END 
  
          ELSE
            BEGIN  # QUEUE ON CONTROL MESSAGE QUEUE # 
            QU$TYPE = QT$INCTLMG; 
            QUEUE(LOC(CTLMSGQ));
            END 
  
        END 
  
      ELSE
        BEGIN  # FREE QUEUE ENTRY. #
        FREE; 
        END 
  
      IF NDR$CONREQ 
        AND (CONAVAILQ EQ 0)
      THEN
        BEGIN  # CONNECT REQUEST AVAILABLE. # 
        NDR$RECALL = 0; 
        GETFREE;
        QU$TYPE = QT$CONAVL;
        QU$NADORD = NDR$NADORD; 
        QUEUE(LOC(CONAVAILQ));
        END 
  
      IF NDR$ESTOFF 
      THEN
        BEGIN  # EST IS OFF # 
        P<NST$ENTRY> = LOC(NAD$NSTWD0); 
        NST$STATE = NS$DISAB;      # NAD DISABLED # 
        NST$DMPCTR = 0;            # RESET NAD DUMP COUNTER # 
        END 
  
      IF NDR$RTNCOD EQ RTN$OFF
        OR NDR$ESTOFF 
      THEN
        BEGIN  # NAD OFF #
        QUEOFF; 
        END 
  
      DONE = FALSE; 
      SLOWFOR I=3 STEP 1 WHILE I LS NDR$LENGTH AND NOT DONE 
      DO
        BEGIN  # PROCESS EACH STATUS ENTRY #
        P<EVNT$ENTRY> = P<NDR$COMMUN> + I;
        IF EVNT$WD EQ 0 
        THEN
          BEGIN  # NO MORE STATUS WORDS # 
          DONE = TRUE;
          END 
  
        ELSE
          BEGIN  # PROCESS STATUS # 
          NDR$RECALL = 0; 
          STATUSF;
          END 
  
        END 
  
      IF NAD$CCOUNT NQ 0
      THEN
        BEGIN  # QUEUE STATUS REQUEST # 
        GETFREE;
        QU$TYPE = QT$STATUS;
        QUEUE(LOC(NAD$Q));
        NAD$QCOUNT = NAD$QCOUNT + 1;
        END 
  
      ELSE
        BEGIN  # CLEAR STATUS QUEUED FLAG # 
        NAD$STATQ = FALSE;
        END 
  
      RETURN; 
      END  # STATCMP #
  
      TERM
