*DECK DUMPNM
USETEXT COMCBEG 
USETEXT COMMCOM 
USETEXT COMRNET 
USETEXT COMRRTN 
    PROC DUMPNM;
      BEGIN  # DUMPNM # 
#  TITLE  DUMPNM  - DUMP NAD MEMORY # 
  
# 
**    DUMPNM  - DUMP NAD MEMORY 
* 
*     ENTRY    - DLRMTNAD  = TRUE, IF DUMPING REMOTE NAD. 
*                          = FALSE, IF DUMPING LOCAL NAD. 
*                DLSTATE = 03 (DUMP IN-PROGRESS). 
*                <FET> = ADDR OF DUMP FILE FET. 
* 
*     EXIT     - DLSTATE = 02 (NAD READY FOR LOAD)
*                        = 03 (DUMP IN-PROGRESS). 
*                DLRETRY = 03 (WAITING FOR CVL ACCESS 
*                        = 00 (CVL ERROR) 
*                DLCVLR  = TRUE, IF NAD RESERVED BY CVL.
* 
*     PROCESS    SET VARIABLES IN DUMP HEADER.
*                CALL CVL TO OBTAIN MAINTENANCE ACCESS TO NAD.
*                IF ACCESS OBTAINED:  
*                  CALL CMM TO OBTAIN CM BUFFER FOR NAD DUMP
*                  SKIP TO END OF DUMP FILE 
*                  COPY DUMP HEADER TO NLD BUFFER.
*                  CALL NLD AND CIO TO COPY NAD MEMORY TO DUMP FILE 
*                  IF DUMP COMPLETED: 
*                    SET DLSTATE = LOAD-REQUIRED
*                  ELSE: (DUMP ERROR) 
*                    SET DLRETRY = 0 (DISABLE NAD)
# 
  
  
# 
****  PROC DUMPNM  - XREF BEGINS. 
# 
      XREF
        BEGIN 
        PROC CALLCVL;              # CALL CVL FOR MAINTENANCE ACCESS #
        PROC CALLNLD;              # CALL NLD TO DUMP NAD # 
        PROC CALLSYS;              # CALL SYSTEM VIA RA+1 # 
        FUNC CLOCK      C(10);     # TIME (HH.MM.SS. ) #
        FUNC DATE       C(10);     # DATE (MM/DD/YY  ) #
        PROC DBGNAME;              # DEBUG - DAYFILE MESSAGE #
        FUNC DECCHF     C(10);     # BINARY TO DECIMAL DISPLAY #
        PROC ERRNLD;               # PROCESS NLD ERROR #
        FUNC HEXCHF     C(10);     # BINARY TO HEX DISPLAY #
        FUNC MEMCMM     U;         # GET/RELEASE CMM BUFFER # 
        ITEM MHFLVL     C(10);     # MHF LEVEL #
        PROC MOVEI;                # MOVE WORDS INDIRECT #
        FUNC OCTCHF     C(10);     # BINARY TO OCTAL DISPLAY #
        FUNC XSFW       C(10);     # BINARY ZERO TO BLANK # 
        END 
# 
****  PROC DUMPNM  - XREF ENDS. 
# 
  
      DEF CMNTLEN   # 6 #;         # LENGTH OF HEADER COMMENT # 
  
      DEF DHDRLEN   # 15 #;         # DUMP HEADER LENGTH #
      DEF DRECTYPE  # "NADDUMP" #;  # RECORD TYPE # 
  
      ARRAY DHDR [0:0] S(DHDRLEN);
        BEGIN 
        ITEM DHDR$WD0   U(00,00,60) = [O"77000016000000000000"];
        ITEM DHDR$WD1   U(01,00,60) = [0];  # WORD 1 #
        ITEM DHDR$RNAM  C(01,00,07);  # DUMP RECORD NAME #
        ITEM DHDR$WD2   U(02,00,60);  # WORD 2 (DATE) # 
        ITEM DHDR$DATE  C(02,00,10);  # DATE #
        ITEM DHDR$WD3   U(03,00,60);  # WORD 3 (TIME) # 
        ITEM DHDR$TIME  C(03,00,10);  # TIME #
        ITEM DHDR$OSID  C(04,00,10) = [OSID];  # O/S IDENT #
        ITEM DHDR$MHFV  C(05,00,10) = [MHFVER];  # MHF VERSION #
        ITEM DHDR$MODL  C(06,00,10);  # MOD LEVEL (J-DATE) #
        ITEM DHDR$TXTT  C(07,00,10) = ["T"];  # TYPE (TEXT) # 
        ITEM DHDR$RTYP  C(08,00,10) = [DRECTYPE];  # RECORD TYPE #
        ITEM DHDR$WD9   U(09,00,60);  # WORDS 9-14 (COMMENT) #
        ITEM DHDR$CMNT  C(09,00,40) = 
             [" LOCAL  NAD DUMP,   CHANNEL = XX.       "];
        ITEM DHDR$CMNT1 C(09,06,06);  # "LOCAL"/"REMOTE" #
        ITEM DHDR$CMNT3 C(11,00,07);  # "CHANNEL"/"ADDRESS" # 
        ITEM DHDR$CHADR C(12,00,02);  # CHANNEL/ADDRESS # 
        ITEM DHDR$CMNT5 C(13,00,10) = ["          "]; 
        ITEM DHDR$CMNT6 C(14,00,10) = ["          "]; 
        END 
  
      ARRAY [0:2] S(4); 
        BEGIN 
        ITEM DUMPNMSG   C(00,00,38) = 
             [" MHF, NAD DUMP RECORD NAME  = NDMPXXX ", 
              " MHF, RECORD NO.0000   TIME = HH.MM.SS", 
              " MHF, FILE = NDF       DATE = MM/DD/YY"];
        ITEM DUMPNMSGF  C(01,18,06);  # FILE NAME # 
        ITEM DUMPNMSGN  C(01,36,04);  # RECORD NUMBER # 
        ITEM DUMPNMSGR  C(03,00,08);  # RECORD NAME/TIME/DATE # 
        ITEM DUMPNMSGZ  U(03,48,12) = [3(0)];  # ZERO FILL #
        END 
  
      ITEM I          I;           # SCRATCH #
      ITEM NDBUF      I = 0;       # FWA OF NAD MEMORY BUFFER # 
      ITEM NDLEN      I;           # LENGTH OF BUFFER  #
  
CONTROL EJECT;
  
      $BEGIN
      DBGNAME ("DUMPNM");          # DEBUG MESSAGE #
      $END
# 
*     SET VARIABLES IN DAYFILE MESSAGE. 
# 
      DUMPNMSGR[0] = XSFW(NDNAMC);  # RECORD NAME # 
      DUMPNMSGR[1] = CLOCK(I);      # TIME #
      DUMPNMSGR[2] = DATE(I);       # DATE #
      DUMPNMSGF[2] = XSFW(NDFNAMC); # DUMP FILE NAME #
# 
*     SET VARIABLES IN DUMP RECORD HEADER.
# 
      DHDR$RNAM = NDNAMC;          # DUMP RECORD NAME # 
      DHDR$DATE = DUMPNMSGR[2];    # DATE # 
      DHDR$TIME = DUMPNMSGR[1];    # TIME # 
      DHDR$MODL = MHFLVL;          # MOD LEVEL #
  
      IF DLRMTNAD                  # IF DUMPING REMOTE NAD #
      THEN
        BEGIN 
        DHDR$CMNT1 = "REMOTE";     # SET COMMENT FOR DUMP HEADER #
        DHDR$CMNT3 = "ADDRESS"; 
        DHDR$CHADR = HEXCHF (RMT$NAD,2);  # REMOTE NAD ADDR # 
        END 
  
      ELSE
        BEGIN 
        DHDR$CMNT1 = " LOCAL";     # SET COMMENT FOR DUMP HEADER #
        DHDR$CMNT3 = "CHANNEL"; 
        DHDR$CHADR = OCTCHF (NAD$CHAN,2);  # LOCAL NAD CHANNEL #
        END 
# 
*     SET VARIABLES IN DUMP RECORD HEADER.
# 
      DHDR$RNAM = NDNAMC;          # DUMP RECORD NAME # 
      DHDR$DATE = DATE(I);         # DATE # 
      DHDR$TIME = CLOCK(I);        # TIME # 
      DHDR$MODL = MHFLVL;          # MOD LEVEL #
  
      CALLCVL (I);                 # GET MAINTENANCE ACCESS # 
  
      IF DLCVLR                    # IF ACCESS OBTAINED # 
      THEN
        BEGIN 
        NDLEN = ONEPRU * 10 + 1;   # 10-PRU BUFFER #
        NDBUF = MEMCMM (NDBUF,NDLEN);  # GET BUFFER FROM CMM #
  
        FET$FIRST = NDBUF;         # SET UP FET # 
        FET$IN    = FET$FIRST;
        FET$OUT   = FET$FIRST;
        FET$LIMIT = FET$FIRST + NDLEN;
  
        CIOFETADDR = P<FET>;
  
        FET$CODES = CIORQ$REW;
        CALLSYS (CIOCALL);         # REWIND # 
  
        I = 0;                     # RECORD COUNT # 
  
        ASLONGAS FET$LEVEL EQ 0 
        DO
          BEGIN 
          FET$CODES = CIORQ$SKPF; 
          CALLSYS (CIOCALL);       # SKIP TO END OF FILE #
          I = I + 1;
          END 
  
        DUMPNMSGN[1] = DECCHF (I,4);  # SAVE RECORD COUNT # 
  
        PB$FIRST = FET$FIRST;      # SET UP NLD PARAMETER BLOCK # 
        PB$IN = PB$FIRST + DHDRLEN;  # SET NLD IN POINTER # 
        PB$OUT   = PB$FIRST;
        PB$LIMIT = FET$LIMIT; 
  
        MOVEI(DHDRLEN,LOC(DHDR$WD0),PB$FIRST);  # COPY HEADER # 
  
        NLD$RCL = FALSE;           # NO AUTO-RECALL # 
        NLD$FC = NLD$FCDUMP;       # NAD DUMP # 
  
        CALLNLD (DLRMTNAD);        # CALL NLD TO DUMP NAD # 
  
        FET$CODES = 1;             # CLEAR FET C/S, SET COMPLETE #
  
        ASLONGAS NOT PB$CMPLT 
          AND FET$ERRCOD EQ 0 
        DO
          BEGIN 
          I = PB$IN - PB$OUT;      # AMOUNT OF NEW DATA # 
          IF I LT 0 
          THEN
            BEGIN 
            I = NDLEN + I;
            END 
  
          IF I GT NDLEN/2          # IF ENOUGH DATA AVAILABLE # 
            AND FET$CMPLT          # AND FILE NOT BUSY #
            AND NOT PB$CMPLT       # AND NLD NOT DONE # 
          THEN
            BEGIN 
            FET$CODES = CIORQ$WRIT;  # WRITE-DATA FUNCTION #
            FET$IN = PB$IN;        # RESET FET POINTER #
            CALLSYS (CIOCALL);     # WRITE DATA TO FILE # 
            PB$OUT = FET$OUT;      # RESET NLD BUFFER POINTER # 
            END 
          END 
  
        IF NOT FET$CMPLT           # IF FILE BUSY # 
        THEN
          BEGIN 
          RCLPARAMAD = LOC(FET$CMPLT);  # FET ADDR #
          CALLSYS (RCLCALL);           # WAIT WHILE FILE BUSY # 
          END 
  
        FET$IN = PB$IN;            # RESET FET POINTER #
        FET$CODES = CIORQ$WRTR;    # WRITE-RECORD FUNCTION #
        CALLSYS (CIOCALL);         # WRITE RECORD TO FILE # 
  
        IF PB$RC EQ 0              # IF NO ERRORS # 
          AND FET$ERRCOD EQ 0 
        THEN
          BEGIN 
          DLSTATE = NS$LDREQ;      # STATE = LOAD REQUIRED #
  
          SLOWFOR I = 0 STEP 1 UNTIL 2  # SEND DAYFILE MESSAGES # 
          DO
            BEGIN 
            MSG$BUFADR = LOC(DUMPNMSG[I]);
            MSG$STATUS = 0; 
            CALLSYS (MSGCALL);
            END 
          END 
  
        ELSE
          BEGIN 
  
          IF PB$RC NE 0 
          THEN
            BEGIN 
            ERRNLD;                # PROCESS NLD ERROR #
            END 
          END 
  
  
        NLD$RCL = TRUE;            # RESET AUTO-RECALL #
        NDLEN = 0;
        NDBUF = MEMCMM (NDBUF,NDLEN);  # RELEASE BUFFER # 
        END 
  
      END  # DUMPNM # 
  
    TERM
