*DECK WAITACN 
USETEXT COMCBEG 
USETEXT COMRAPL 
USETEXT COMRMEM 
USETEXT COMRNET 
USETEXT COMRNDR 
USETEXT COMRQUE 
PROC WAITACN; 
# TITLE WAITACN - WAIT FOR ACN QUIET. # 
  
      BEGIN  # WAITACN #
  
# 
**    WAITACN - WAIT FOR ACN QUIET. 
* 
*     WAIT FOR NDR TO COMPLETE PROCESSING ON ACN. 
* 
*     PROC WAITACN. 
* 
*     ENTRY   - APL$HEADER IS BASED ARRAY CONTAINING APPLICATION TABLE. 
*               CONNECTION IS BASED ARRAY CONTAINING CONNECTION ENTRY.
* 
*     EXIT    - NO ACK MESSAGES OR OUTGOING CONTROL MESSAGES ARE
*               ON THE LOCAL NAD QUEUE. 
*               NO REQUESTS FOR THIS ACN ARE BEING PROCESSED BY NDR.
* 
*     PROCESS - SET QUIET TO FALSE. 
*               WHILE NOT QUIET 
*               THEN: 
*                 SET QUIET TO TRUE.
*                 POINT TO LOCAL NAD QUEUE. 
*                 FOR EACH ENTRY ON LOCAL NAD QUEUE:  
*                   IF ACK MESSAGE OR OUTGOING CONTROL MESSAGE
*                     FOR THIS ACN
*                   THEN: 
*                     SET QUIET TO FALSE. 
*                 FOR EACH NDR COMMUNICATION AREA:  
*                   IF SEND CONTROL MESSAGE FOR THIS ACN
*                   THEN: 
*                     SET QUIET TO FALSE. 
*                 IF NOT QUIET
*                 THEN: 
*                   SAVE BASED ARRAY POINTERS.
*                   PERFORM RECALL. 
*                   INITIATE EVENT SCANNER. 
*                   RESTORE BASED ARRAY POINTERS. 
*               RETURN. 
* 
* 
# 
  
# 
****  PROC WAITACN - XREF LIST BEGIN. 
# 
      XREF
        BEGIN 
        PROC EVNTSCN;                # INITIATE EVENT SCANNER # 
        PROC CALLSYS;                # MAKE RA+1 CALL # 
        PROC QUEUE;                  # QUEUE #
        PROC DEQUEUE;                # DEQUEUE #
        ITEM NDRCOM  I;              # NDR COMMUNICATION AREA # 
        ITEM NADTBL  I;              # LOCAL NAD TABLE ADDRESS #
        ITEM MAXNDRS I;              # MAXIMUM NDRS # 
        END 
  
# 
****  PROC WAITACN - XREF LIST END. 
# 
  
  
      ITEM APLADR I;                 # PRESERVES APPLICATION BASED ARRY#
      ITEM CONADR I;                 # PRESERVES CONNECTION BASED ARRAY#
      ITEM NADADR I;                 # PRESERVES NAD ENTRY BASED ARRAY #
      ITEM NETADR I;                 # PRESERVES NET HEADER BASED ARRAY#
      ITEM PTHADR I;                 # PRESERVES PATH ENTRY BASED ARRAY#
      ITEM QUEADR I;                 # PRESERVES QUADDRESS BASED ARRAY #
      ITEM RMTADR I;                 # PRESERVES REMOTE NAD BASED ARRAY#
      ITEM QUIET B;                  # QUIET FLAG # 
      ITEM I I;                      # I IS A LOOP VARIABLE # 
      ITEM TEMPQ I;                  # TEMPORARY QUEUE POINTER #
      ITEM ACN I;                    # ACN #
  
      ARRAY [0:0] S(1); 
        BEGIN 
        ITEM RCLCALL    U(00,00,60) = [0];
        ITEM RCL        C(00,00,03) = ["RCL"];
        ITEM RCLTIME    U(00,48,12) = [0];
        END 
CONTROL EJECT;
  
      QUEADR = P<QU$ADDRESS>; 
      NETADR = P<NET$HEADER>; 
      PTHADR = P<PTH$ENTRY>;
      NADADR = P<NAD$ENTRY>;
      RMTADR = P<RMT$ENTRY>;
      ACN = (P<CONNECTION> - P<APL$HEADER> - APL$LENGTH)
            / CON$LENGTH + APL$MINACN;
      QUIET = FALSE;
      ASLONGAS NOT QUIET
      DO
        BEGIN  # WAIT FOR ACN QUIET # 
        QUIET = TRUE; 
        P<NAD$ENTRY> = CON$NADORD * NAD$LENGTH + NADTBL;
        TEMPQ = NAD$Q;
        NAD$Q = 0;
        ASLONGAS TEMPQ NE 0 
        DO
          BEGIN 
          DEQUEUE(LOC(TEMPQ));
          IF (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 
            QUIET = FALSE;
            END 
  
          QUEUE(LOC(NAD$Q));
          END 
  
        FASTFOR I=0 STEP NDR$LENGTH WHILE I LS MAXNDRS*NDR$LENGTH 
        DO
          BEGIN 
          P<NDR$COMMUN> = NDRCOM + I; 
          IF NDR$FUNC EQ NF$SNDCTL
            AND NDR$NADORD EQ CON$NADORD
            AND NDR$PATHID EQ CON$PATHID
          THEN
            BEGIN 
            QUIET = FALSE;
            END 
  
          END 
  
        IF NOT QUIET
        THEN
          BEGIN  # WAIT FOR AWHILE #
          CONADR = P<CONNECTION>; 
          APLADR = P<APL$HEADER>; 
          CALLSYS(RCLCALL); 
          RECALLS = RECALLS + 1;
          EVNTSCN;
          P<CONNECTION> = CONADR; 
          P<APL$HEADER> = APLADR; 
          END 
  
        END 
  
      P<QU$ADDRESS> = QUEADR; 
      P<NET$HEADER> = NETADR; 
      P<PTH$ENTRY> = PTHADR;
      P<NAD$ENTRY> = NADADR;
      P<RMT$ENTRY> = RMTADR;
      RETURN; 
      END  # WAITACN #
  
      TERM
