*DECK NS$FLN
USETEXT CYB$NS
USETEXT DEF$NS
USETEXT NAT$NS
USETEXT NDCB$NS
USETEXT NPT$NS
USETEXT NST$NS
USETEXT PFC$NS
USETEXT SMB$NS
USETEXT SMD$NS
PROC NS$FLN(F$RELOAD); # SEND NPU/DT/R (LOAD NDCB) #
# TITLE NS$FLN - SEND NPU/DT/R (LOAD NDCB). #
BEGIN # NS$FLN #
#
** NS$FLN - SEND NPU/DT/R (LOAD NDCB).
*
* J.C. LEE 1981
*
* THIS ROUTINE SENDS AN NPU/DT/R (LOAD NDCB).
*
* PROC NS$FLN(F$RELOAD)
*
* ENTRY:
* F$RELOAD - NDCB RELOAD INDICATOR.
*
* EXIT:
* NONE.
*
* METHOD:
* FORMAT ABH.
* FORMAT NDCB IN NPU/DT/R (LOAD NDCB).
* IF F$RELOAD NOT SET, SWITCH TO FORMAT NDCB CASES.
* ELSE, LOCATE NDCB FIRST AND GOTO PACKSM.
* PACKSM: PACKS NPU WORD INTO SM BUFFER.
* COMPUTE CHECKSUM OF NDCB DATA.
* FORMAT NPU/DT/R AND NETPUT IT.
*
#
ITEM F$RELOAD B; # RELOAD NDCB INDICATOR #
$BEGIN
XREF
BEGIN
PROC NS$DBG; # TRACE PROCEDURE CALLS #
END
$END
XREF
BEGIN
FUNC EDATE; # CONVERT PACKED DATE TO DISPLAY CODE #
FUNC ETIME; # CONVERT PACKED TIME TO DISPLAY CODE #
PROC LFGCKSM; # COMPUTE CHECKSUM OF NPU DATA #
PROC MOVEOK; # ALLOW TSB TO MOVE #
PROC NETPUT; # NETPUT #
FUNC NS$CDA U; # DISPLAY-CODE TO ASCII CONVERSION #
PROC NS$FBH; # FORMAT ABH FOR NETWORK SM #
PROC NS$GNW; # GET NPU WORDS #
PROC PDATE; # GET DATE/TIME IN PACKED BINARY FORMAT #
PROC TSBINFO; # LOCATE TSB #
END
ITEM ASCCHAR U; # ASCII CHARACTER #
ITEM BITCOUNT I; # BIT COUNT #
ITEM DISCHAR U; # DISPLAY CODE CHARACTER #
ITEM I I; # LOOP VARIABLE #
ITEM J I; # TEMPORARY #
ITEM K I; # TEMPORARY #
ITEM L I; # TEMPORARY #
ITEM NDCBFWA U; # NDCB FWA #
ITEM NPUWORD U; # NPU WORD WITH 16-BIT DATA #
ITEM TEMP U; # TEMPORARY #
ITEM TSBFWA U; # TSB FWA #
ITEM TSBN U; # TSB NUMBER #
ITEM TSBSIZE U; # TSB SIZE #
SWITCH NDCBCASE:NDCBINDEX # STATUS SWITCH FOR FORMATTING NDCB #
RDF:NDCB$RDF, # RELOAD DUMP FLAG #
LTDF:NDCB$LTDF, # LONG TERM DUMP FLAG #
LPATH:NDCB$LPATH, # MOST RECENT LOAD PATH #
LDATE1:NDCB$DATE1, # MOST RECENT LOAD DATE #
LDATE2:NDCB$DATE2,
LDATE3:NDCB$DATE3,
LTIME1:NDCB$TIME1, # MOST RECENT LOAD TIME #
LTIME2:NDCB$TIME2,
LTIME3:NDCB$TIME3,
NHC:NDCB$HALTC, # NPU HALT CODE #
NPR:NDCB$PREG; # NPU P-REGISTER DATA #
CONTROL EJECT;
$BEGIN
NS$DBG("FLN");
$END
NS$FBH(LNPUDTLR+NDCB$SIZE*2,TRUE); # FORMAT ABH #
P<SMB> = LOC(SMB$BUFFER); # FWA OF SM BUFFER #
FOR I = NDCBINDEX"NDCB$RDF" STEP 1 UNTIL NDCBINDEX"NDCB$PREG"
DO # FORMAT NDCB IN NPU/DT/R (LOAD NDCB) #
BEGIN
NPUWORD = 0;
IF NOT F$RELOAD
THEN # FORMAT AND LOAD NDCB #
GOTO NDCBCASE[I]; # SWITCH TO FORMAT NDCB CASES #
ELSE # RELOAD NDCB RECEIVED FROM NPU #
BEGIN
IF I EQ NDCBINDEX"NDCB$RDF"
THEN # LOCATE NDCB FIRST #
BEGIN
TSBN = NAT$SMTSBN[0]; # NDCB DUMP RESPONSE TSB #
TSBINFO(TSBSIZE,TSBFWA,TSBN);
P<NDCB> = TSBFWA; # FWA OF NDCB DUMP RESPONSE #
END
NS$GNW(NDCB,LNPUDTDN,I,NPUWORD);
GOTO PACKSM;
END
RDF: # CLEAR RELOAD DUMP FLAG #
NHC: # CLEAR NPU HALT CODE #
NPR: # CLEAR NPU P-REGISTER #
TEST I;
LTDF: # SET LONG TERM DUMP FLAG #
IF NPT$F$LTDF[NTORD]
THEN # LONG TERM DUMP FLAG = DUMP #
NPUWORD = ASC$YY; # SET TO ASCII YY #
ELSE # LONG TERM DUMP FLAG = NO DUMP #
NPUWORD = ASC$NN; # SET TO ASCII NN #
GOTO PACKSM;
LPATH: # SET LOAD PATH #
NPUWORD = NAT$LPATH[0];
GOTO PACKSM;
LDATE1: # SET LOAD DATE YY #
PDATE(TEMP); # GET PACKED BINARY DATE/TIME #
NAT$LPDATE[0] = TEMP; # SAVE IN NAT #
TEMP = EDATE(NAT$LDATE[0]); # DISPLAY-CODED DATE YY/MM/DD #
GOTO DATETIME;
LTIME1: # SET LOAD TIME HH #
TEMP = ETIME(NAT$LTIME[0]); # DISPLAY-CODED TIME HH.MM.SS #
DATETIME:
LDATE2: # SET LOAD DATE MM #
LDATE3: # SET LOAD DATE DD #
LTIME2: # SET LOAD TIME MM #
LTIME3: # SET LOAD TIME SS #
TEMP = TEMP * LSHIFT6; # LEFT-SHIFT 6 SPACES #
FOR J = 0 STEP 1 UNTIL 1
DO # CONVERT NEXT TWO DISPLAY-CODED CHARACTERS TO ASCII #
BEGIN
DISCHAR = B<J*DCSIZE,DCSIZE>TEMP; # DISPLAY-CODED CHARACTER #
ASCCHAR = NS$CDA(DISCHAR); # CONVERT TO ASCII #
B<WL-NPWSIZE+J*ASCSIZE,ASCSIZE>NPUWORD = ASCCHAR;
END
TEMP = TEMP * LSHIFT12; # LEFT-SHIFT 12 SPACES #
PACKSM: # PACK NPU WORD INTO SM BUFFER #
BITCOUNT = LNPUDTLR*ASCSIZE + I*NPWSIZE; # BIT COUNT #
K = BITCOUNT / WL; # WORD INDEX #
L = BITCOUNT - K*WL; # BIT INDEX #
J = L + NPWSIZE - WL; # BITS IN NEXT CM WORD #
IF J GR 0
THEN # NPU WORD CROSSES CM WORD #
BEGIN
B<L,WL-L>SMBWORD[K] = B<WL-NPWSIZE,NPWSIZE-J>NPUWORD;
B<0,J>SMBWORD[K+1] = B<WL-J,J>NPUWORD;
END
ELSE # NPU WORD FITS IN CM WORD #
B<L,NPWSIZE>SMBWORD[K] = NPUWORD;
END # END FOR LOOP #
#
COMPUTE CHECKSUM OF NDCB DATA
#
BITCOUNT = LNPUDTLR * ASCSIZE; # BIT COUNT TO NDCB DATA #
K = BITCOUNT / WL; # WORD INDEX #
NDCBFWA = P<SMB> + K; # FWA OF NDCB DATA #
L = BITCOUNT - K*WL; # SYMPL FIRST BIT POSITION #
J = WL - 1 - L; # COMPASS FIRST BIT POSITION #
LFGCKSM(NDCBFWA,J,NDCB$SIZE,TEMP); # GET CKECKSUM OF NDCB DATA #
#
FORMAT NPU/DT/R (LOAD NDCB)
#
TSBN = NPT$NSTTSB[NTORD]; # NST TSB NUMBER #
TSBINFO(TSBSIZE,TSBFWA,TSBN); # LOCATE NST #
P<NST> = TSBFWA; # FWA OF NST #
PFCSFC[0] = NPUDT; # PFC/SFC CODE #
NPUPO[0] = NAT$PN[0]; # PORT NUMBER #
NPUSP[0] = NAT$SPN[0]; # SUBPORT NUMBER #
NPUCC[0] = CMDCODE"CC$LOAD"; # COMMAND CODE #
NPULS[0] = NAT$LSN[0]; # LOAD SEQUENCE NUMBER #
NPUBA1[0] = NAT$NDCBA1[0]; # SET NDCB FWA #
NPUBA2[0] = NAT$NDCBA2[0];
NPUBC[0] = 1; # SET BATCH COUNT #
NPUCK[0] = TEMP; # SET LOAD DATA CHECKSUM #
MOVEOK(TSBN); # ALLOW NST TO MOVE #
NETPUT(ABH$WORD,SMB$BUFFER); # SEND NPU/DT/R (LOAD NDCB) #
RETURN;
END # NS$FLN #
TERM