*DECK NS$XPD
USETEXT COM$NS
USETEXT DEF$NS
USETEXT DTSB$NS
USETEXT ERR$NS
USETEXT NAT$NS
USETEXT NDCB$NS
USETEXT NPT$NS
USETEXT NST$NS
USETEXT PFC$NS
USETEXT PIC$NS
USETEXT SMB$NS
USETEXT SMD$NS
USETEXT STC$NS
PROC NS$XPD(ERRCODE); # PROCESS DUMP/LOAD PROCEDURE DIRECTIVES #
# TITLE NS$XPD - PROCESS DUMP/LOAD PROCEDURE DIRECTIVES. #
BEGIN # NS$XPD #
#
** NS$XPD - PROCESS DUMP/LOAD PROCEDURE DIRECTIVES.
*
* J.C. LEE 1981
*
* THIS ROUTINE PROCESSES DUMP/LOAD PROCEDURE DIRECTIVES.
*
* PROC NS$XPD(ERRCODE)
*
* ENTRY:
* NONE.
*
* EXIT:
* ERRCODE.
*
* METHOD:
* CLEAR ERRCODE.
* LOCATE PICB.
* SET DONE TO FALSE.
* SET I TO 0.
* WHILE NOT DONE
* AND ERRCODE EQ 0
* AND LQ NAT$PENDI:
* DO
* INCREMENT INDEX TO NEXT DIRECTIVE.
* UPDATE PICB DIRECTIVE INDEX.
* CLEAR SECONDARY STATE.
* STORE DIRECTIVE IN NAT.
* CASE ON PRIMARY STATE TO DETERMINE IF DIRECTIVE IS
* VALID FOR THE PROCEDURE CONTROL BLOCK IN PROCESS:
* 1) ILLEGAL STATE:
* DAYFILE MESSAGE AND ABORT.
* 2) SAM-LOAD:
* CASE ON XPCB DIRECTIVE CODE.
* (ILLEGAL, LOAD, START, ILLEGAL, ILLEGAL,
* ILLEGAL, ILLEGAL)
* 3) NPU-DUMP:
* CASE ON XPCB DIRECTIVE CODE.
* (DUMP, LOAD, START, ILLEGAL, ILLEGAL,
* ILLEGAL, SAVE-DUMP, ILLEGAL)
* 4) NPU-LOAD:
* CASE ON XPCB DIRECTIVE.
* (DUMP, LOAD, START, ILLEGAL, START-C,
* LOAD-NCB, ILLEGAL, ILLEGAL)
* EXECUTE XPCB DIRECTIVE.
* ENDWHILE
*
#
ITEM ERRCODE U; # ERROR CODE #
$BEGIN
XREF
BEGIN
PROC NS$DBG; # TRACE PROCEDURE CALLS #
END
$END
XREF
BEGIN
PROC MOVEOK; # ALLOW TSB TO MOVE #
PROC NETPUT; # NETPUT #
PROC NS$FBH; # FORMAT ABH FOR NETWORK SM #
FUNC NS$FEC U; # FORMAT ERROR CODE #
PROC NS$FLN; # SEND NPU/DT/R(LOAD NDCB) #
PROC NS$FLR; # FIND LOAD MODULE RECORD #
PROC NS$GNW; # GET NPU WORD #
PROC NS$INL; # INITIATE NPU LOAD #
PROC NS$MSG; # DISPATCH MESSAGE #
PROC NS$SDB; # SEND DUMP BATCH #
PROC NS$SLB; # SEND LOAD BATCH #
PROC NS$SLT; # START RESPONSE TIMER #
PROC NS$TNA; # TERMINATE NPU ACTIVITY #
PROC RECALL; # MACREL RECALL #
PROC RETERN; # MACREL RETURN #
PROC RETTSB; # RELEASE TSB #
PROC TSBINFO; # LOCATE TSB #
PROC WRITEF; # MACREL WRITEF #
END
STATUS XPCBCODE # CASES FOR XPCB DIRECTIVE PROCESSING #
DUMP, # DUMP SPECIFIED AREA #
LOAD, # LOAD SPECIFIED MODULE #
START, # START NPU, WAIT FOR RESPONSE #
STARTC, # RESTORE NDCB, START NPU #
LOADNCB, # LOAD NDCB #
SAVENDF, # SAVE NPU DUMP FILE #
ENDSPCB, # END OF SPCB #
ENDDPCB, # END OF DPCB #
ENDLPCB, # END OF LPCB #
ILLEGAL, # ILLEGAL XPCB DIRECTIVE #
;
ITEM CODE U; # DIRECTIVE CODE #
ITEM DONE B; # CURRENT DIRECTIVE PROCESSED #
ITEM K I; # TEMPORARY, PICB INDEX #
ITEM I I; # INDUCTION VARIABLE #
ITEM LMNAME C(6); # LOAD MODULE NAME #
ITEM PICBTSBN U; # TSB NO OF PICB TSB #
ITEM RI U; # RANDOM INDEX OF FIRST MODULE RECORD #
ITEM SS U; # TEMPORARY VARIABLE #
ITEM TSBFWA U; # TSB FWA #
ITEM TSBSIZE U; # TSB SIZE #
ARRAY VDIRTAB [0:DIRCODE"ENDPCB"] S(1);
BEGIN # VALID DIRECTIVE TABLE FOR XPCB #
ITEM LSAMCODE S:XPCBCODE(00,06,18) = [ # VALID SPCB DIRECTIVE #
S"ILLEGAL",
S"LOAD",
S"ILLEGAL",
S"ILLEGAL",
S"STARTC",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ENDSPCB",
];
ITEM DNPUCODE S:XPCBCODE(00,24,18) = [ # VALID DPCB DIRECTIVE #
S"DUMP",
S"LOAD",
S"START",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"SAVENDF",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ENDDPCB",
];
ITEM LNPUCODE S:XPCBCODE(00,42,18) = [ # VALID LPCB DIRECTIVE #
S"DUMP",
S"LOAD",
S"START",
S"ILLEGAL",
S"STARTC",
S"LOADNCB",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ILLEGAL",
S"ENDLPCB",
];
END
DEF L$EM30 # 3 #;
DEF DM$EM30 # DM$LOCAL+DM$EVENT+DM$NAMLOG #; # ROUTING OPT #
ARRAY MSG$EM30 [0:0] S(L$EM30);
BEGIN
ITEM EM27$TEXT C(0,0,27) = # EVENT MESSAGE TEXT #
["NPUNAME, LOADING (XXXXXX). "];
ITEM EM30$NPNAM C(0,00,7); # NPU NAME #
ITEM EM30$LMNAM C(01,48,06); # LOAD MODULE NAME #
ITEM EM30$END U(02,42,18) = [0]; # END OF TEXT #
END
$BEGIN
DEF L$EM60 # 4 #;
DEF DM$EM60 # DM$LOCAL+DM$NAMLOG #; # ROUTING OPT #
ARRAY MSG$EM60 [0:0] S(L$EM60);
BEGIN
ITEM EM60$TEXT C(0,0,32) = # MESSAGE TEXT #
["NPUNAME, ILLEGAL PICB DIRECTIVE."];
ITEM EM60$NPNAM C(0,00,7); # NPU NAME #
ITEM EM60$END U(3,12,48) = [0]; # END OF TEXT #
END
$END
DEF L$EM11 # 3 #;
DEF DM$EM11 # DM$LOCAL+DM$EVENT+DM$NAMLOG #; # ROUTING OPT #
ARRAY MSG$EM11 [0:0] S(L$EM11);
BEGIN
ITEM EM11$TEXT C(0,0,28) = # EVENT MESSAGE TEXT #
["NPUNAME, SAM LOAD COMPLETED."];
ITEM EM11$NPNAM C(0,00,7); # NPU NAME #
ITEM EM11$END U(02,48,12) = [0]; # END OF TEXT #
END
DEF L$EM22 # 4 #;
DEF DM$EM22 # DM$LOCAL+DM$EVENT+DM$NAMLOG #; # ROUTING OPT #
ARRAY MSG$EM22 [0:0] S(L$EM22);
BEGIN
ITEM EM22$TEXT C(0,0,32) = # EVENT MESSAGE TEXT #
["NPUNAME, DUMP XXXXXXX COMPLETED."];
ITEM EM22$NPNAM C(0,00,7); # NPU NAME #
ITEM EM22$NDPFN C(1,24,7); # NPU DUMP FILE PFN #
ITEM EM22$END U(3,12,48) = [0]; # END OF TEXT #
END
DEF L$EM31 # 3 #;
DEF DM$EM31 # DM$LOCAL+DM$EVENT+DM$NAMLOG #; # ROUTING OPT #
ARRAY MSG$EM31 [0:0] S(L$EM31);
BEGIN
ITEM EM31$TEXT C(0,0,24) = # EVENT MESSAGE TEXT #
["NPUNAME, LOAD COMPLETED."];
ITEM EM31$NPNAM C(0,00,7); # NPU NAME #
ITEM EM31$END U(2,24,36) = [0]; # END OF TEXT #
END
DEF L$XPDABT # 2 #;
DEF DM$XPDABT # DM$LOCAL+DM$ABORT #; # ROUTING OPTIONS #
ARRAY MSG$XPDABT [0:0] S(L$XPDABT);
BEGIN
ITEM XPDA$TEXT C(0,0,18) = # MESSAGE TEXT #
["INVALID NPU STATE."];
ITEM XPDA$END U(01,48,12) = [0]; # END OF TEXT #
END
SWITCH XPCBCASE:XPCBCODE # STATUS SWITCH FOR DIRECTIVE PROCESSING#
C$DUMP:DUMP, # DUMP DIRECTIVE #
C$LOAD:LOAD, # LOAD DIRECTIVE #
C$START:START, # START DIRECTIVE #
C$STARTC:STARTC, # STARTC DIRECTIVE #
C$LOADNCB:LOADNCB, # LOAD NCB DIRECTIVE #
C$SAVENDF:SAVENDF, # SAVE NDF DIRECTIVE #
C$ENDSPCB:ENDSPCB, # END DIRECTIVE IN SPCB #
C$ENDDPCB:ENDDPCB, # END DIRECTIVE IN DPCB #
C$ENDLPCB:ENDLPCB, # END DIRECTIVE IN LPCB #
C$ILLEGAL:ILLEGAL; # ILLEGAL DIRECTIVE #
SWITCH NPSCASE:PRISTATE # STATUS SWITCH FOR NPU PRIMARY STATE #
NPS0:NPS$NONO, # IDLE STATE #
NPS1:NPS$LSAM, # LOADING SAM #
NPS2:NPS$DNPU, # DUMPING NPU #
NPS3:NPS$LNPU, # LOADING NPU #
NPS0:NPS$DNDCB; # DUMPING NDCB #
CONTROL EJECT;
$BEGIN
NS$DBG("XPD");
$END
ERRCODE = 0;
DONE = FALSE;
I = 0;
PICBTSBN = NAT$PITSBN[0]; # TSB NUMBER OF PICB TSB #
TSBINFO(TSBSIZE,TSBFWA,PICBTSBN); # LOCATE PICB #
P<PICB> = TSBFWA
; # FWA OF PICB #
FOR K = 0 WHILE NOT DONE
AND ERRCODE EQ 0
AND I LQ NAT$PENDI[0]
DO # PROCESS NEXT XPCB DIRECTIVE #
BEGIN
I = NAT$PDIRI[0] + 1; # INCREMENT INDEX TO NEXT DIRECTIVE #
NAT$PDIRI[0] = I; # UPDATE PICB DIRECTIVE INDEX #
NAT$SSTATE[0] = 0; # CLEAR SECONDARY STATE #
NAT$PCBDIR[0] = PICB$ENTRY[I]; # STORE DIRECTIVE IN NAT #
CODE = NAT$CODE[0]; # DIRECTIVE CODE #
#
CASE ON PRIMARY STATE TO DETERMINE IF DIRECTIVE IS VALID
FOR THE PROCEDURE CONTROL BLOCK CURRENTLY BEING PROCESSED
#
SS = NAT$PSTATE[0]; # PRIMARY STATE #
GOTO NPSCASE[SS];
NPS0: # ILLEGAL STATE, ABORT NS #
BEGIN
NS$MSG(MSG$XPDABT,L$XPDABT,DM$XPDABT);
END
NPS1: # LOADING SAM #
CODE = LSAMCODE[CODE];
GOTO NPSXPCB;
NPS2: # DUMPING NPU #
CODE = DNPUCODE[CODE];
GOTO NPSXPCB;
NPS3: # LOADING NPU #
CODE = LNPUCODE[CODE];
GOTO NPSXPCB;
NPSXPCB: # SWITCH ON XPCB DIRECTIVE CODE #
GOTO XPCBCASE[CODE];
C$DUMP: # PROCESS DUMP DIRECTIVE #
NS$SDB; # SEND DUMP BATCH #
NAT$SSTATE[0] = S"NSS$WDUMP"; # WAITING FOR DUMP RESPONSE #
NS$SLT; # START RESPONSE TIMER #
GOTO EXITXPCB; # EXIT DIRECTIVE PROCESSING #
C$LOAD: # PROCESS LOAD DIRECTIVE #
LMNAME = NAT$LMNAME[0]; # NAME OF LOAD MODULE #
NS$FLR(LMNAME,RI,SS,ERRCODE); # FIND LOAD MODULE ON NLF #
SENDLB:
IF ERRCODE EQ 0
THEN # LOAD MODULE FOUND #
BEGIN
NS$SLB(LMNAME,RI,ERRCODE); # SEND LOAD BATCH #
IF ERRCODE EQ 0
THEN # LOAD BATCH SENT #
BEGIN
NS$SLT; # START RESPONSE TIMER #
NAT$SSTATE[0] = S"NSS$WLOAD"; # WAITING FOR LOAD RESPONSE #
EM30$NPNAM[0] = NPNAM; # NPU NAME #
EM30$LMNAM[0] = LMNAME; # LOAD MODULE NAME #
NS$MSG(MSG$EM30,L$EM30,DM$EM30); # DISPATCH EVENT MSG #
END
END
GOTO EXITXPCB; # EXIT DIRECTIVE PROCESSING #
C$START: # PROCESS START DIRECTIVE #
NS$FBH(LNPUDTSR,TRUE); # FORMAT ABH FOR NETWORK SM #
PFCSFC[0] = NPUDT; # FORMAT NPU/DT/R(START) #
NPUPO[0] = NAT$PN[0]; # SET PORT NUMBER #
NPUSP[0] = NAT$SPN[0]; # SET SUBPORT NUMBER #
NPULS[0] = NAT$LSN[0]; # SET LOAD SEQUENCE NO #
NPUCC[0] = CMDCODE"CC$STRTR"; # SET COMMAND CODE #
NETPUT(ABH$WORD,SMB$BUFFER); # SEND NPU/DT/R(START) #
NAT$SSTATE[0] = S"NSS$WSTART"; # WAITING FOR START RESPONSE #
NS$SLT; # START RESPONSE TIMER #
GOTO EXITXPCB; # EXIT DIRECTIVE PROCESSING #
C$STARTC: # PROCESS STARTC DIRECTIVE #
IF NAT$PSTATE[0] EQ S"NPS$LSAM"
THEN # LOADING SAM #
BEGIN # SEND NPU/DT/R(STARTC) #
NS$FBH(LNPUDTSC,TRUE); # FORMAT ABH FOR NETWORK SM #
PFCSFC[0] = NPUDT;
NPUPO[0] = NAT$PN[0]; # SET PORT NUMBER #
NPUSP[0] = NAT$SPN[0]; # SET SUBPORT NUMBER #
NPULS[0] = NAT$LSN[0]; # SET LOAD SEQUENCE NUMBER #
NPUCC[0] = CMDCODE"CC$STRTC";# SET COMMAND CODE #
NETPUT(ABH$WORD,SMB$BUFFER); # SEND STARTC REQUEST #
GOTO NEXTDIR; # PROCESS NEXT SPCB DIRECTIVE #
END
NS$FLN(FALSE); # SEND NPU/DT/R (LOAD NDCB) #
NAT$SSTATE[0] = S"NSS$WNDCB"; # WAITING FOR LOAD NDCB RESPONSE#
NS$SLT; # START RESPONSE TIMER #
GOTO EXITXPCB; # EXIT DIRECTIVE PROCESSING #
C$LOADNCB: # PROCESS LOAD NCB DIRECTIVE #
IF NPT$NCBSZ[NTORD] LQ NAT$NCBSZ[0]
THEN # NCB SIZE WITHIN ALLOWED LIMIT #
BEGIN # LOAD NCB INTO NPU #
LMNAME = "NCB"; # LOAD MODULE IS NCB #
RI = NPT$NCBRI[NTORD]; # RANDOM INDEX OF NCB ON NCF #
NAT$NCBFWA[0] = NAT$DIRP2[0]; # NCB FWA #
NAT$LMNAME[0] = LMNAME; # SAVE LOAD MODULE NAME #
END
ELSE # NCB SIZE EXCEEDS ALLOWED LIMIT#
BEGIN
ERRCODE = NS$FEC(EC"ERR$FILE",FEC"ERR$NCBSIZ");
END
GOTO SENDLB; # SEND LOAD BATCH #
C$SAVENDF:
NAT$F$SNDF[0] = TRUE; # SET SAVE NPU DUMP FLAG #
GOTO NEXTDIR; # CONTINUE WITH NEXT DIRECTIVE #
C$ILLEGAL: # PROCESS ILLEGAL XPCB DIRECTIVE #
$BEGIN
EM60$NPNAM[0] = NPNAM; # NPU NAME #
NS$MSG(MSG$EM60,L$EM60,DM$EM60); # DISPATCH MESSAGE #
$END
NAT$DEC[0] = NAT$DEC[0] + 1; # INCREMENT DIRECTIVE ERROR CNT #
IF NAT$DEC[0] GR MAX$DEC
THEN # ILLEGAL DIRECTIVE IN PICB #
BEGIN
ERRCODE = NS$FEC(EC"ERR$FILE",FEC"ERR$PICBD");
END
GOTO NEXTDIR; # CONTINUE WITH NEXT DIRECTIVE #
C$ENDSPCB: # PROCESS END OF SAM LOAD PROCEDURE #
STC$SAML = STC$SAML + 1; # INCREMENT NO OF SAM LOADS #
EM11$NPNAM[0] = NPNAM; # NPU NAME #
NS$MSG(MSG$EM11,L$EM11,DM$EM11); # DISPATCH MESSAGE #
TSBINFO(TSBSIZE,TSBFWA,NPT$NSTTSB[NTORD]); # LOCATE NST #
P<NST> = TSBFWA;
NST$SAMSPC[0] = 0; # CLEAR CONSECUTIVE SAM PREEMPT COUNT #
MOVEOK(NPT$NSTTSB[NTORD]); # ALLOW NST TO MOVE #
NS$TNA; # TERMINATE NPU ACTIVITY #
GOTO EXITXPCB; # EXIT DIRECTIVE PROCESSING #
C$ENDDPCB: # PROCESS END OF NPU DUMP PROCEDURE #
TSBINFO(TSBSIZE,TSBFWA,NAT$NDTSBN[0]); # LOCATE DUMP TSB #
P<DTSB$HDR> = TSBFWA;
P<DTSB$FET> = TSBFWA + L$DTSBHDR; # FWA OF DUMP FET #
WRITEF(DTSB$FET); # WRITE END OF FILE TO NPXXXYY #
EM22$NPNAM[0] = NPNAM; # SET NPU NAME #
EM22$NDPFN[0] = DFET$LFN[0]; # SET PFN OF NPU DUMP FILE #
NS$MSG(MSG$EM22,L$EM22,DM$EM22); # DISPATCH MESSAGE #
STC$DUMPS = STC$DUMPS + 1; # INCREMENTS DUMPS GENERATED #
TSBINFO(TSBSIZE,TSBFWA,NPT$NSTTSB[NTORD]); # LOCATE NST TSB #
P<NST> = TSBFWA; # FWA OF NST #
TSBINFO(TSBSIZE,TSBFWA,NAT$SMTSBN[0]); # LOCATE DUMP NDCB RESP #
P<NDCB> = TSBFWA; # FWA OF DUMP NDCB RESPONSE #
NST$DPDATE[0] = DTSB$PDATE[0]; # MOST RECENT DUMP DATE/TIME #
NST$NDFPFN[0] = DFET$LFN[0]; # MOST RECENT DUMP FILE PFN #
NS$GNW(NDCB,LNPUDTDN,NDCBINDEX"NDCB$HALTC",SS);
NST$NHC[0] = SS; # SET NPU HALT CODE #
NS$GNW(NDCB,LNPUDTDN,NDCBINDEX"NDCB$PREG",SS);
NST$NPR[0] = SS; # RESET NPU P-REGISTER CONTENT #
MOVEOK(NPT$NSTTSB[NTORD]); # ALLOW NST TO MOVE #
MOVEOK(NAT$SMTSBN[0]); # ALLOW NDCB DUMP RESP TO MOVE #
RECALL(DTSB$FET); # WAIT UNTIL WRITEF COMPLETES #
RETERN(DTSB$FET); # RETURN NPU DUMP FILE #
RECALL(DTSB$FET); # WAIT UNTIL RECALL COMPLETES #
RETTSB(NAT$NDTSBN[0]); # RELEASE DUMP TSB #
NAT$NDTSBN[0] = 0; # CLEAR DUMP TSB NUMBER #
NAT$F$SNDF[0] = FALSE; # CLEAR SAVE NDF FLAG #
NS$INL(ERRCODE); # INITIATE NPU LOAD #
GOTO NEXTDIR; # CONTINUE WITH NEXT DIRECTIVE #
C$ENDLPCB: # PROCESS END OF NPU LOAD PROCEDURE #
EM31$NPNAM[0] = NPNAM; # SET NPU NAME #
NS$MSG(MSG$EM31,L$EM31,DM$EM31); # DISPATCH EVENT MESSAGE #
TSBINFO(TSBSIZE,TSBFWA,NPT$NSTTSB[NTORD]); # LOCATE NST #
P<NST> = TSBFWA; # UPDATE NST #
NST$LPDATE[0] = NAT$LPDATE[0]; # SET MOST RECENT LOAD DATE/TIME#
NST$LC[0] = NST$LC[0] + 1; # INCREMENT LOAD COUNT #
NST$SLFC[0] = 0; # CLEAR SUCCESSIVE LOAD FAILURE COUNT #
IF CURTIME LS NST$DTIMER[0]
THEN # ANOTHER LOAD BEFORE DTIMER EXPIRES #
BEGIN # INCREMENT LOAD COUNT WITHIN DTIMER #
NST$LCOUNT[0] = NST$LCOUNT[0] + 1;
END
ELSE # DTIMER ALREADY TIMES OUT #
BEGIN
NST$DTIMER[0] = CURTIME + DTIMER; # RESTART DTIMER #
NST$LCOUNT[0] = 1; # RESET LOAD COUNT WITHIN DTIMER TO 1 #
END
MOVEOK(NPT$NSTTSB[NTORD]); # ALLOW NST TO MOVE #
IF NAT$F$RMTL[0]
THEN # LOADING REMOTE NPU #
BEGIN
STC$REML = STC$REML + 1; # INCREMENT REMOTE LOAD COUNT #
NS$FBH(LNPUIN,TRUE); # FORMAT ABH FOR NPU/IN/N #
PFCSFC[0] = NPUINN;
NPUPO[0] = NAT$PN[0]; # SET PORT NUMBER #
NPUSP[0] = NAT$SPN[0]; # SET SUBPORT NUMBER #
NPULT[0] = LOADTYPE"LT$REMOT"; # SET REMOTE LOAD TYPE #
NETPUT(ABH$WORD,SMB$BUFFER); # SEND NPU/IN/N #
END
ELSE # LOADING LOCAL NPU #
STC$LOCL = STC$LOCL + 1; # INCREMENT NO OF LOCAL LOADS #
NS$TNA; # TERMINATE NPU ACTIVITY #
GOTO EXITXPCB; # EXIT DIRECTIVE PROCESSING #
EXITXPCB: # DIRECTIVE DONE, EXIT XPCB PROCESSING #
DONE = TRUE;
NEXTDIR:
END
MOVEOK(PICBTSBN); # ALLOW PICB TO MOVE #
RETURN;
END # NS$XPD #
TERM