*DECK MOPUPQS 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRQUE 
PROC MOPUPQS; 
# TITLE MOPUPQS - PROCESS ALL APPLICATION RELATED QUEUE ENTRIES.  # 
  
      BEGIN  # MOPUPQS #
  
# 
**    MOPUPQS - PROCESS ALL APPLICATION RELATED QUEUE ENTRIES.
* 
*     PROCESS ALL APPLICATION RELATED QUEUE ENTRIES.
* 
*     PROC MOPUPQS. 
* 
*     ENTRY   - APL$HEADER IS BASED ARRAY FOR APPLICATION HEADER. 
* 
*     EXIT    - QUEUE ENTRIES FOR APPLICATION PROCESSED.
* 
*     PROCESS - FOR EACH ENTRY IN APPLICATION MESSAGE QUEUE:  
*                 DEQUEUE ENTRY.
*                 FREE ENTRY. 
*               CLEAR NETWAIT FLAGS IN APPLICATION TABLE. 
*               DEQUEUE AND FREE EACH ENTRY ASSOCIATED WITH THIS
*               APPLICATION IN THE FOLLOWING QUEUES:  
*                 NETWAIT QUEUE.
*                 ERROR LOGICAL QUEUE.
*                 SUPERVISORY MESSAGE QUEUE.
*                 UNKNOWN REQUEST QUEUE.
*               INITIATE OVERFLOW PROCESSING. 
*               FOR EACH ENTRY IN APPLICATION UCP QUEUE:  
*                 DEQUEUE ENTRY.
*                 IF FOR INCOMPLETE SWAP IN REQUEST 
*                 THEN: 
*                   REQUEUE ON WAIT SWAP QUEUE. 
*                 ELSE: 
*                   FREE ENTRY. 
*               SEARCH WAIT UCP SWAP IN QUEUE AND ELIMINATE 
*               AUX$QUEUE ENTRIES FOR INCOMING SUPERVISORY
*               MESSAGES. 
*               RETURN. 
* 
* 
****  PROC MOPUPQS - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC DEQUEUE;                # REMOVE ENRY FROM QUEUE # 
        PROC FREE;                   # RELEASE QEUE ENTRY # 
        PROC OVERFLO;                # PROCESS OVERFLOW QUEUE # 
        PROC QUEUE;                  # ADD ENTRY TO QUEUE # 
        END 
  
# 
****  PROC MOPUPQS - XREF LIST END. 
# 
  
  
      ITEM TEMPQ      I;             # TEMPORARY QUEUE POINTER #
  
CONTROL EJECT;
  
      ASLONGAS APL$MSGQ NE 0
      DO
        BEGIN 
        DEQUEUE(LOC(APL$MSGQ)); 
        FREE; 
        END 
      APL$MSGCNT = 0; 
      APL$ERRLGL = 0; 
  
      IF APL$WAIT NE 0
      THEN
        BEGIN 
        APL$WAIT = 0; 
        APL$TIMER = 0;
        END 
  
      TEMPQ = NETWAITQ; 
      NETWAITQ = 0; 
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF QU$APLADR EQ P<APL$HEADER> 
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(NETWAITQ)); 
          END 
  
        END 
  
      TEMPQ = ERRLGLQ;
      ERRLGLQ = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF QU$SUPAPAD EQ P<APL$HEADER>
          OR QU$APLADR EQ P<APL$HEADER> 
          OR QU$APPL EQ P<APL$HEADER> 
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(ERRLGLQ));
          END 
  
        END 
  
      TEMPQ = SUPERMSGQ;
      SUPERMSGQ = 0;
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF QU$SUPAPAD EQ P<APL$HEADER>
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(SUPERMSGQ));
          END 
  
        END 
  
      TEMPQ = UNKNOWNREQ; 
      UNKNOWNREQ = 0; 
      ASLONGAS TEMPQ NE 0 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
        IF QU$APLADR EQ P<APL$HEADER> 
          OR QU$JOBID EQ APL$JOBID
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(UNKNOWNREQ)); 
          END 
  
        END 
  
      OVERFLO;
  
      ASLONGAS APL$UCPQ NE 0
      DO
        BEGIN 
        DEQUEUE(LOC(APL$UCPQ)); 
        IF QU$TYPE EQ QT$UCPSWAP
        THEN
          BEGIN 
          QUEUE(LOC(WAITSWAPQ));
          END 
  
        ELSE
          BEGIN 
          FREE; 
          END 
  
        END 
  
      TEMPQ = NETOFFQ;
      NETOFFQ = 0;
  
      ASLONGAS TEMPQ NE 0            # REMOVE DUPLICATE NETOFFS # 
      DO
        BEGIN 
        DEQUEUE(LOC(TEMPQ));
  
        IF QU$APLADR EQ P<APL$HEADER> 
        THEN
          BEGIN 
          FREE; 
          END 
  
        ELSE
          BEGIN 
          QUEUE(LOC(NETOFFQ));
          END 
  
        END 
  
      END  # MOPUPQS #
  
      TERM
