*DECK MOPQACN 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMREVN 
USETEXT COMRNET 
USETEXT COMRQUE 
PROC MOPQACN; 
# TITLE MOPQACN - PROCESS ALL ACN - RELATED QUEUE ENTRIES.  # 
  
      BEGIN  # MOPQACN #
  
# 
**    MOPQACN - PROCESS ALL ACN - RELATED QUEUE ENTRIES.
* 
*     PROCESS ALL ACN - RELATED QUEUE ENTRIES.
* 
*     PROC MOPQACN. 
* 
*     ENTRY   - APL$HEADER IS BASED ARRAY FOR APPLICATION HEADER. 
*               CONNECTION IS BASED ARRAY FOR CONNECTION ENTRY
*               BEING RELEASED. 
* 
*     EXIT    - ALL QUEUE ENTRIES FOR THIS ACN PROCESSED. 
* 
*     PROCESS - FOR EACH ENTRY IN EACH LOCAL NAD QUEUE: 
*                 IF ENTRY FOR THIS ACN 
*                 THEN: 
*                   DEQUEUE ENTRY.
*                   INITIATE GRACEFUL QUEUE RELEASE.
*               FOR EACH ENTRY ON DELAY QUEUE:  
*                 DEQUEUE ENTRY.
*                 IF REMOTE CONNECTION REQUEST
*                 THEN: 
*                   REQUEUE ON AWAITING ASSIGNMENT QUEUE. 
*                 ELSE: 
*                   IF CON/ACRQ/R REQUEST 
*                    THEN:  
*                      FREE ENTRY.
*                    ELSE:  
*                      INITIATE GRACEFUL QUEUE RELEASE. 
*               FOR EACH ENTRY IN STATUS EVENT QUEUE: 
*                 IF ACN MATCHES
*                 THEN: 
*                   FREE ENTRY. 
*               FOR EACH ENTRY IN CONTROL MESSAGE QUEUE:  
*                 IF ACN MATCHES
*                 THEN: 
*                   FREE ENTRY. 
*               FOR EACH ENTRY IN SWAP QUEUE: 
*                 IF ACN MATCHES
*                 THEN: 
*                   INITIATE GRACEFUL QUEUE RELEASE.
*               RETURN. 
* 
* 
****  PROC MOPQACN - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC DEQUEUE;                # REMOVE ENTRY FROM QUEUE #
        PROC FREE;                   # RELEASE QUEUE ENTRY #
        ITEM NADTBL  I;              # NAD TABLE ADDRESS #
        ITEM NUMNADS    I;           # MAXIMUM NUMBER OF NADS # 
        PROC QUEUE;                  # ADD ENTRY TO QUEUE # 
        PROC REQUECS;                # GRACEFULLY RELEASE QUEUE # 
        END 
  
# 
****  PROC MOPQACN - XREF LIST END. 
# 
  
      ITEM TEMPQ      I;             # TEMPORARY QUEUE POINTER #
      ITEM NADORD     I;             # INDEX FOR LOOP THRU NADTBL # 
      ITEM ACN        I;             # ACN FOR THIS CONNECTION #
  
CONTROL EJECT;
  
      ACN = (P<CONNECTION> - P<APL$HEADER> - APL$LENGTH)
             / CON$LENGTH + APL$MINACN; 
      P<NAD$ENTRY> = NADTBL + CON$NADORD * NAD$LENGTH;
      TEMPQ = NAD$Q;
      NAD$Q = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF ((QU$TYPE EQ QT$UCPREQ) AND (QU$APLADR EQ P<APL$HEADER>) 
            AND (QU$UCPACN EQ ACN)) 
          OR (((QU$TYPE EQ QT$ACKMSG) OR (QU$TYPE EQ QT$OUTCTLM)) 
               AND ((QU$APPL EQ P<APL$HEADER>) AND (QU$ACN EQ ACN)))
        THEN
          BEGIN 
          REQUECS;
          NAD$QCOUNT = NAD$QCOUNT -1; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(NAD$Q));
          END 
  
        END 
  
      ASLONGAS CON$DELAYQ NE 0
      DO
        BEGIN 
        DEQUEUE(LOC(CON$DELAYQ)); 
        IF QU$TYPE EQ QT$CONWAIT
        THEN
          BEGIN 
          QUEUE(LOC(WAITASIGNQ)); 
          END 
  
        ELSE
          BEGIN 
          IF QU$TYPE EQ QT$UCPMSGI
          THEN
            BEGIN 
            FREE; 
            END 
  
          ELSE
            BEGIN 
            REQUECS;
            END 
  
          END 
  
        END 
  
      TEMPQ = STATUSQ;
      STATUSQ = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        P<EVNT$ENTRY> = P<QU$ADDRESS> + 1;
        IF EVNT$ACN EQ ACN
          AND EVNT$APPL EQ P<APL$HEADER>
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(STATUSQ));
          END 
  
        END 
  
      TEMPQ = CTLMSGQ;
      CTLMSGQ = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF QU$APPL EQ P<APL$HEADER> 
          AND QU$ACN EQ ACN 
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(CTLMSGQ));
          END 
  
        END 
  
      TEMPQ = APL$SWAPQ;
      APL$SWAPQ = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF QU$TYPE EQ QT$UCPREQ 
          AND QU$UCPACN EQ ACN
        THEN
          BEGIN 
          REQUECS;
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(APL$SWAPQ));
          END 
  
        END 
  
      END  # MOPQACN #
  
      TERM
