*DECK RTNSMSG 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRQUE 
PROC RTNSMSG; 
# TITLE RTNSMSG - RETURN SUPERVISORY MESSAGE  # 
  
      BEGIN  # RTNSMSG #
  
# 
**    RTNSMSG - RETURN SUPERVISORY MESSAGE. 
* 
*     RETURN ASYNCHRONOUS SUPERVISORY MESSAGE TO THE UCP. 
* 
*     PROC RTNSMSG. 
* 
*     ENTRY   - QU$ADDRESS IS BASED ARRAY CONTAINING NETGET OR NETGETL. 
*               APL$HEADER IS BASED ARRAY POINTING TO APPLICATION TABLE.
*               SUPERVISORY MESSAGE IS QUEUED.
* 
*     EXIT    - QUEUE ENTRY IS PROPERLY DISPOSED. 
* 
*     PROCESS - IF TEXT AREA IS TOO SMALL FOR MESSAGE 
*               THEN: 
*                 COPY BLOCK HEADER TO REQUEST QUEUE ENTRY. 
*                 SET INPUT BLOCK UNDELIVERABLE.
*                 MOVE HEADER ADDRESS TO PROPER POSITION. 
*                 CLEAR ERROR LOGICAL BIT.
*                 SET QUEUE TYPE TO SUPERVISORY MESSAGE REPLY.
*               ELSE: 
*                 COPY HEADER AND TEXT ADDRESS. 
*                 COPY UCP REQUEST ADDRESS. 
*                 COPY CHARGE.
*                 FREE REQUEST QUEUE ENTRY. 
*                 DELINK SUPERVISORY MESSAGE. 
*                 IF MESSAGE QUEUE EMPTY
*                   AND ERR/LGL COUNT NON-ZERO
*                 THEN: 
*                   CLEAR ERR/LGL COUNT.
*               INITIATE UCP REPLY. 
*               RETURN. 
# 
  
# 
****  PROC RTNSMSG - XREF LIST BEGIN. 
# 
      XREF
        BEGIN 
        PROC FREE;                 # FREE QUEUE ENTRY # 
        PROC DEQUEUE;              # DEQUEUE #
        PROC UCPRPLY;              # INITIATE UCP REPLY # 
        END 
  
# 
****  PROC RTNSMSG - XREF LIST END. 
# 
  
  
  
      ITEM QUEUEADR     I;           # QUEUE REQUEST ADDRESS #
      ITEM REQTLMAX     I;           # REQUEST TLMAX #
      ITEM BLKHDR       I;           # BLOCK HEADER # 
      ITEM HA           I;           # HEADER ADDRESS # 
      ITEM TA           I;           # TEXT ADDRESS # 
      ITEM UCPA         I;           # UCP REQUEST ADDRESS #
      ITEM CHARGE       I;           # CHARGE # 
  
CONTROL EJECT;
  
      QUEUEADR = P<QU$ADDRESS>; 
      REQTLMAX = QU$TLMAX;
      P<QU$ADDRESS> = APL$MSGQ; 
      IF QU$HDRTLC GR REQTLMAX
      THEN
        BEGIN  # TEXT AREA IS TOO SMALL FOR MESSAGE # 
        BLKHDR = QU$BLKHDR; 
        P<QU$ADDRESS> = QUEUEADR; 
        QU$BLKHDR = BLKHDR; 
        QU$HDRIBU = TRUE; 
        QU$HA = QU$UCPHA; 
        QU$ERRLGL = FALSE;
        QU$TYPE = QT$UCPMSGR; 
        END 
  
      ELSE
        BEGIN  # RETURN SUPERVISORY MESSAGE # 
        P<QU$ADDRESS> = QUEUEADR; 
        HA = QU$UCPHA;
        TA = QU$UCPTA;
        UCPA = QU$UCPA; 
        CHARGE = QU$CHARGE; 
        FREE; 
        DEQUEUE(LOC(APL$MSGQ)); 
        APL$MSGCNT = APL$MSGCNT - 1;
        IF APL$MSGCNT EQ 0
          AND APL$ERRLGL NE 0 
        THEN
          BEGIN 
          APL$ERRLGL = 0; 
          END 
        QU$HA = HA; 
        QU$TA = TA; 
        QU$UCPA = UCPA; 
        QU$CHARGE = CHARGE; 
        END 
  
      UCPRPLY;
      RETURN; 
      END  # RTNSMSG #
  
      TERM
