*DECK EDITNEL 
USETEXT COMCBEG 
USETEXT COMMCOM 
USETEXT COMRNET 
    PROC EDITNEL(NADWC);
# TITLE  EDITNEL - EDIT NAD ERROR LOG ENTRIES # 
  
      BEGIN  # EDITNEL #
  
# 
**    EDITNEL - EDIT NAD ERROR LOG ENTRIES. 
* 
*     THIS PROCEDURE EDITS THE NAD ERROR LOG ENTRIES, 
*     DELETING PREVIOUSLY-SENT ENTRIES AND SORTING BY SEQUENCE
*     NUMBER IF NECESSARY.
* 
*     PROC EDITNEL. 
* 
*     ENTRY   - <ELB>       = ADDR OF NAD ERROR LOG BUFFER. 
*                NADWC      = NAD WORDS IN ERROR LOG BUFFER.
*               <NST$ENTRY> = NAD STATUS ENTRY. 
* 
*     EXIT    - <ELB>       = EDITED NAD ERROR LOG BUFFER.
*                NADWC      = NAD WORDS IN BUFFER AFTER EDITING.
*                NST$ELORD  = ORDINAL OF LAST ERROR LOG ENTRY.
*                NST$ELTSQ  = TYPE/SEQUENCE NUMBER OF LAST ENTRY. 
*                NST$ELLOG  = TRUE IF NEW NAD ERROR LOG ENTRY.
*                NST$ELDST  = TRUE IF NAD DEVICE STATUS TABLE.
* 
*     PROCESS - IF ANY ERROR LOG ENTRIES IN BUFFER: 
*                 SET NST$ELLOG = TRUE. 
*                 SET NST$ELDST = TRUE. 
*                 UNPACK ENTRIES. 
*                 IF PREVIOUSLY-SENT ENTRY STILL PRESENT: 
*                   CLEAR PREVIOUSLY-SENT ENTRY.
*                   SET NEW LOW SEQ NUMBER/ORDINAL
*                 ELSE: 
*                   FIND LOW SEQ NUMBER/ORDINAL.
*                 IF ANY VALID ENTRY FOUND: 
*                   REPACK ENTRIES IN SEQ-NUMBER ORDER. 
*                   RESET NST$ELORD AND NST$ELTSQ.
*                 SET NADWC = NEW LOG WORD COUNT (INCLUDING DST). 
*               ELSE: 
*                 SET NST$ELLOG = FALSE.
*                 IF DETAILED STATUS TABLE IN BUFFER: 
*                   SET NST$ELDST = TRUE. 
*                   SET NADWC = DST WORD COUNT. 
*                 ELSE: 
*                   SET NST$ELDST = FALSE.
*                   SET NADWC = 0.
# 
  
      ITEM NADWC      I;           # NAD WORDS IN BUFFER #
  
# 
****  PROC EDITNEL - XREF LIST BEGIN
# 
  
      XREF
        BEGIN 
        PROC DBGNAME;              # DEBUG #
        PROC GETNELE;              # GET ERROR LOG ENTRY #
        PROC PUTNELE;              # PUT ERROR LOG ENTRY #
        END 
  
# 
****  PROC EDITNEL - XREF LIST END
# 
  
  
      ARRAY [0:NEL$MAXENT] S(3);      # NAD ERROR LOG ENTRIES # 
        BEGIN 
        ITEM NEL$WORD0  U(00,00,60);  # WORD 0 #
        ITEM NEL$TYPSQ  U(00,00,16);  # IDENTIFIER (TYPE/SEQ) # 
        ITEM NEL$TYP    U(00,00,08);  # TYPE #
        ITEM NEL$SEQ    U(00,08,08);  # SEQUENCE NUMBER # 
        ITEM NEL$WORD1  U(01,00,60);  # WORD 1 #
        ITEM NEL$WORD2  U(02,00,60);  # WORD 2 #
        END 
  
      ITEM BLEN       I;
      ITEM HORD       I;
      ITEM I          I;
      ITEM J          I;
      ITEM K          I;
      ITEM LORD       I;
      ITEM LOSEQ      I;
CONTROL EJECT;
  
      $BEGIN
      DBGNAME ("EDITNEL");         # DEBUG MESSAGE #
      $END
  
      BLEN = NADWC - DST$LENBYT - NEL$LENBYT;  # ENTRY WORDS #
  
      IF BLEN GE 0                 # IF AT LEAST ONE ENTRY #
      THEN
        BEGIN 
        NST$ELLOG = TRUE;          # LOG ENTRY AVAILABLE #
        NST$ELDST = TRUE;          # DST AVAILABLE #
        SLOWFOR I = 0 STEP 1 WHILE (I LT NEL$MAXENT AND BLEN GE 0)
        DO
          BEGIN 
          GETNELE (P<ELB>,I,LOC(NEL$WORD0[I]));  # UNPACK ENTRY # 
          BLEN = BLEN - NEL$LENBYT;  # DECREMENT LENGTH OF ENTRIES #
          HORD = I+1;              # ENTRY COUNT #
          NEL$WORD0[HORD] = 0;     # CLEAR NEXT ENTRY # 
          END 
  
        BLEN = 0;                  # RESET NAD WORD COUNT # 
        LORD = -1;                 # NEXT ENTRY ORDINAL # 
  
        IF NST$ELTSQ NE 0          # IF PREVIOUSLY-SENT ENTRY # 
          AND NST$ELORD LT NEL$MAXENT            # IS PRESENT # 
          AND NST$ELTSQ EQ NEL$TYPSQ[NST$ELORD] 
        THEN
          BEGIN 
          I = -1; 
          J = NST$ELORD;           # ORD OF PREVIOUSLY-SENT ENTRY # 
          LORD = J+1;              # NEXT ENTRY ORDINAL # 
          LOSEQ = NST$ELSEQ + 1 LAN X"FF";  # NEXT SEQUENCE NUMBER #
          NEL$WORD0[J] = 0;        # CLEAR PREVIOUSLY-SENT ENTRY #
          END 
  
        ELSE
          BEGIN 
          NST$ELTSQ = 0;           # CLEAR PREVIOUS TYPE/SEQ #
  
          SLOWFOR J = 0 STEP 1 UNTIL (HORD-1) 
          DO
            BEGIN                  # FIND OLDEST ENTRY #
  
            IF NEL$TYPSQ[J] NE 0   # IF VALID ENTRY # 
            THEN
              BEGIN 
              I = NEL$SEQ[J];      # SEQUENCE NUMBER #
  
              IF LORD LT 0         # IF 1ST VALID ENTRY # 
                OR I NE (K + 1 LAN X"FF")  # OR NEW LOW # 
              THEN
                BEGIN 
                LOSEQ = I;         # SAVE LOWEST SEQ NUMBER # 
                LORD = J;          # SAVE ORDINAL # 
                END 
  
              K = I;               # CURRENT SEQ NUMBER # 
              END 
            END 
          END 
  
        IF LORD GE 0               # IF VALID ENTRY FOUND # 
        THEN
          BEGIN 
          K = 1;                   # TYPE/SEQ FLAG #
  
          SLOWFOR J = 0 STEP 1 WHILE (J LT HORD AND K NE 0) 
          DO
            BEGIN                  # REPACK ENTRIES # 
  
            IF LORD GE HORD 
            THEN
              BEGIN 
              LORD = 0;            # RESET ORDINAL #
              END 
  
            K = NEL$TYPSQ[LORD];   # NEXT ENTRY TYPE/SEQ #
  
            IF (K NE 0) AND (NEL$SEQ[LORD] EQ LOSEQ)  # IF NEW ENTRY #
            THEN
              BEGIN 
              PUTNELE (P<ELB>,J,LOC(NEL$WORD0[LORD]));
              I = LORD;            # LAST ORDINAL # 
              BLEN = BLEN + NEL$LENBYT;  # INCREMENT NAD WORD COUNT # 
              LORD = LORD+1;       # NEXT ORDINAL # 
              LOSEQ = LOSEQ + 1 LAN X"FF";  # NEXT SEQ NUMBER # 
              END 
            END 
  
          IF I GE 0                # IF ANY NEW ENTRY # 
          THEN
            BEGIN 
            NST$ELTSQ = NEL$TYPSQ[I];  # SAVE LAST ENTRY IDENT #
            NST$ELORD = I;             # AND LAST ORDINAL # 
            END 
          END 
        END 
  
      ELSE
        BEGIN 
        NST$ELLOG = FALSE;         # NO ERROR LOG ENTRIES # 
        IF NADWC LT DST$LENBYT     # IF NO DETAILED STATUS TABLE #
        THEN
          BEGIN 
          NST$ELDST = FALSE;       # NO DETAILED STATUS TABLE # 
          BLEN = -DST$LENBYT;      # RESET NAD WORD COUNT # 
          END 
  
        ELSE
          BEGIN 
          NST$ELDST = TRUE;        # DST PRESENT #
          BLEN = 0;                # RESET NAD WORD COUNT # 
          END 
        END 
  
      NADWC = BLEN + DST$LENBYT;   # RETURN NAD WORD COUNT  # 
  
      END  # EDITNEL #
    TERM
