*DECK NS$HCP
USETEXT COM$NS
USETEXT DEF$NS
USETEXT ERR$NS
USETEXT HOC$NS
USETEXT KDS$NS
USETEXT LIN$NS
USETEXT SMB$NS
PROC NS$HCP(CMDTEXT,(CC),ERRCODE,KC); # HOP COMMAND PREPROCESSOR #
# TITLE NS$HCP - HOP COMMAND PROCESSOR. #
BEGIN # NS$HCP #
#
** NS$HCP - HOP COMMAND PROCESSOR.
*
* J.C. LEE 1981
*
* THIS ROUTINE PROCESS ALL HOP COMMANDS.
*
* PROC NS$HCP(CMDTEXT,(CC),ERRCODE,KC)
*
* ENTRY:
* CMDTEXT = HOP COMMAND TEXT
* CC = CHARACTER COUNT OF TEXT.
*
* EXIT:
* ERRCODE = ERROR CODE VALUE.
* KC = HOP COMMAND ERROR REASON CODE.
*
* METHOD:
* SAVE HOP COMMAND TEXT IN LOCAL ARRAY AND ZERO FILLED LAST
* WORD OF COMMAND TEXT.
* IF K-DISPLAY NOT ASSIGNED, FLAG ERROR AND EXIT.
* DISCARD LINES CURRENTLY QUEUED IN PAGE-WAIT BUFFER.
* ECHO HOP COMMAND BACK TO K-DISPLAY.
* TOKENIZE HOP COMMAND AND PERFORM SYNTAX CHECKING.
* IF PASSED SYNTAX CHECKING, PROCEED TO RECOGNIZE THE COMMAND.
* IF VALID COMMAND VERB FOUND, PROCEED TO VALIDATE HOP COMMAND
* PARAMETERS.
* IF PASSED ALL CHECKINGS, PUT PARAMETERIZED COMMAND IN
* COMMON BLOCK.
* IN ALL CASES, IF ERROR DETECTED, FLAG ERRCODE AND KC,
* AND EXIT.
*
#
ARRAY CMDTEXT; # HOP COMMAND TEXT #
BEGIN
ITEM CMDTXTWORD U(00,00,60);
END
ITEM CC U; # COMMAND TEXT DISPLAY CODE CHAR COUNT #
ITEM ERRCODE U; # ERROR CODE VALUE #
ITEM KC U; # HOP COMMAND ERROR REASON CODE #
$BEGIN
XREF
BEGIN
PROC NS$DBG; # TRACE CALL #
END
$END
XREF
BEGIN
PROC EXREDUC; # REDUCE TSB SIZE #
PROC MOVEI; # MOVE DATA #
PROC MOVEOK; # ALLOW TSB TO MOVE #
FUNC NS$FEC U; # FORMAT ERROR CODE #
PROC NS$MSG; # DISPATCH MESSAGE #
PROC NS$TKD; # TRANSFER DATA TO K DISPLAY BUFFER #
PROC TSBINFO; # LOCATE TSB #
END
DEF CHAR$A # O"01" #; # ALPHA A #
DEF CHAR$9 # O"44" #; # NUMERAL 9 #
DEF CHAR$COMMA # O"56" #; # COMMA #
DEF CHAR$EQUAL # O"54" #; # EQUAL #
DEF CHAR$TERM # O"57" #; # PERIOD #
ITEM BLANK C(7) = " ";
ITEM CHAR U; # HOP COMMAND TEXT CHARACTER #
ITEM CMDORDINAL U; # HOP COMMAND ORDINAL #
ITEM CNT U; # TOKEN COUNT #
ITEM COUNT U; # TOKEN CHARACTER COUNT #
ITEM DONE B; # DONE FLAG #
ITEM I I; # LOOP VARIABLE #
ITEM INDEX U; # INDEX #
ITEM J I; # LOOP VARIABLE #
ITEM K I; # TEMPORARY #
ITEM M I; # TEMPORARY #
ITEM PWBTSBN U; # PAGE WAIT BUFFER TSB NUMBER #
ITEM TEMP U; # TEMPORARY #
ITEM TLC U; # TEXT LENGTH IN CHARACTERS #
ITEM TLW U; # TEXT LENGTH IN WORDS #
ITEM TSBFWA U; # TSB FWA #
ITEM TSBSIZE U; # TSB SIZE #
DEF MAX$CMDKEY # 8 #; # MAX HOP COMMAND VERBS ALLOWED #
ARRAY HOPCMDVERB[1:MAX$CMDKEY]S(1);
BEGIN # VALID HOP COMMAND VERB TABLE #
ITEM HC$KEYWORD C(0,0,8) = [ # VALID COMMAND VERB #
"STATUS",
"ST",
"HISTORY",
"HI",
"FILE",
"FI",
"NOFILE",
"NO",
];
ITEM HC$ORDINAL S:HCT(0,48,12) = [ #CORR CMD ORDINAL #
S"CMD$STATUS",
S"CMD$STATUS",
S"CMD$HIST",
S"CMD$HIST",
S"CMD$FILE",
S"CMD$FILE",
S"CMD$NOFILE",
S"CMD$NOFILE",
];
END
DEF MAX$CMDPRM # 9 #; # MAX HOP COMMAND PARAMETERS ALLOWED #
ARRAY HOPCMDPARM[1:MAX$CMDPRM]S(1);
BEGIN # VALID HOP COMMAND PARAMETER TABLE #
ITEM HCP$PARAM C(0,0,8) = [ # VALID HOP CMD PARAMETERS #
"NPU =",
"NP =",
"ALL",
"NLF =",
"NL =",
"UN =",
"PW =",
"NPUS",
"NPS",
];
ITEM HCP$SEPAR C(0,42,1); # SEPARATOR CHARACTER #
ITEM HCP$PARORD U(0,48,12) = [ # CORR PARAMETER ORD #
PAR$NPU,
PAR$NPU,
PAR$ALL,
PAR$NLF,
PAR$NLF,
PAR$UN,
PAR$PW,
PAR$NPUS,
PAR$NPUS,
];
END
DEF L$TOKENTAB # 10 #; # SIZE OF TOKEN TABLE #
ARRAY TOKENTAB[0:L$TOKENTAB]S(1);
BEGIN # TABLE OF HOP COMMAND TOKENS/SEPARATORS #
ITEM TT$WORD C(0,0,10); # WHOLE WORD #
ITEM TT$TCOUNT U(0,0,60); # TOKEN COUNT #
ITEM TT$TOKEN C(0,0,8); # TOKEN PLUS SEPARATOR #
ITEM TT$ATOKEN C(0,0,7); # TOKEN #
ITEM TT$SEP C(0,42,1); # SEPARATOR #
END
ARRAY VALIDPARAM [HCT"CMD$STATUS":HCT"CMD$NOFILE"] S(1);
BEGIN # MAP OF VALID PARAMETER FOR EACH HOP COMMAND #
#
A TRUE SETTING INDICATES THE CORRESPONDING PARAMETER IS VALID
FOR THE COMMAND,
VALIDPARAM[1] IS FOR STATUS COMMAND
VALIDPARAM[2] IS FOR HISTORY COMMAND
VALIDPARAM[3] IS FOR FILE COMMMAND
VALIDPARAM[4] IS FOR NOFILE COMMAND
#
ITEM PARM$NPU U(00,01,01) = [1,0,1,0]; # NPU= PARAMETER #
ITEM PARM$ALL U(00,02,01) = [0,1,0,0]; # ALL PARAMETER #
ITEM PARM$NLF U(00,03,01) = [0,0,1,0]; # NLF PARAMETER #
ITEM PARM$UN U(00,04,01) = [0,0,1,0]; # UN PARAMETER #
ITEM PARM$PW U(00,05,01) = [0,0,1,0]; # PW PARAMETER #
ITEM PARM$NPUS U(00,06,01) = [1,0,0,0]; # NPUS PARAMETER #
ITEM PARM$WORD U(00,00,60); # WHOLE WORD #
END
ARRAY LINHEADER [0:0] S(LIN$HDRL);
BEGIN # HOP COMMAND LINE HEADER #
ITEM LINE$ID U(00,00,24);
ITEM LINE$SIZE U(00,42,18);
END
DEF MAX$CMDTLC # 50 #; # MAX COMMAND TEXT DISPLAY CODE CHARACTERS#
DEF MAX$CMDTLW # 05 #; # MAX COMMAND TEXT LENGTH IN WORDS #
ARRAY HCMDTEXT [0:MAX$CMDTLW] S(1);
BEGIN # HOP COMMAND TEXT #
ITEM HCMD$WORD U(00,00,60) = [MAX$CMDTLW(0)];
END
CONTROL EJECT;
$BEGIN
NS$DBG("HCP"); # TRACE CALL #
$END
ERRCODE = 0;
KC = 0;
#
SAVE HOP COMMAND TEXT IN LOCAL ARRAY
#
IF MAX$CMDTLC LS CC
THEN # COMMAND TEXT CHARACTER COUNT EXCEEEDS LIMIT #
CC = MAX$CMDTLC; # SET CHARACTER COUNT TO LIMIT ALLOWED #
TLW = (CC+9)/10; # TEXT LENGTH IN CM WORDS #
IF TLW EQ 0
THEN # RECEIVED NO HOP COMMAND TEXT #
TLW = 1; # SET TEXT LENGTH TO 1 TO GENERATE SYNTAX ERROR #
ELSE # RECEIVED HOP COMMAND TEXT #
MOVEI(TLW,LOC(CMDTEXT),LOC(HCMDTEXT)); # MOVE TEXT #
K = (TLW*10) - CC;
IF K NQ 0
THEN # ZERO-FILLED LAST WORD OF COMMAND TEXT #
B<(10-K)*6,K*6>HCMD$WORD[TLW-1] = 0;
IF K LS 2
THEN # ASSURE LINE TERMINATOR 6-66 BITS OF BINARY ZEROES #
BEGIN
HCMD$WORD[TLW] = 0;
TLW = TLW + 1;
END
IF DCW$F$ASS[0] # K DISPLAY IS ASSIGNED #
AND DCW$F$IA[0] # AND INPUT IS ALLOWED #
THEN
BEGIN
#
DISCARD LINES CURRENTLY QUEUED IN PAGE WAIT BUFFER
#
PWBTSBN = DCW$PWBTSB[0]; # PAGE WAIT BUFFER TSB NUMBER #
TSBINFO(TSBSIZE,TSBFWA,PWBTSBN); # LOCATE PWB FWA #
IF PWB$LC[TSBFWA] NQ 0
THEN # LINES QUEUED IN PAGE WAIT BUFFER #
BEGIN # DISCARD ALL LINES QUEUED #
EXREDUC(PWB$WC[TSBFWA]-PWB$HDRL,PWBTSBN,FALSE,TSBFWA);
PWB$LC[TSBFWA] = 0; # RESET LINE COUNT #
PWB$WC[TSBFWA] = PWB$HDRL; # RESET WORD COUNT #
END
MOVEOK(PWBTSBN); # ALLOW PAGE WAIT BUFFER TO MOVE #
#
ECHO HOP COMMAND BACK TO K DISPLAY
#
DCW$F$IA[0] = FALSE; # SET INPUT NOT ALLOWED #
DCW$LC[0] =0; # RESET NAM K-DISPLAY LINE COUNT #
P<LIN$HEADER> = LOC(LINHEADER); # FWA OF LINE HEADER #
LIN$HDRWD[0] = 0;
LIN$ID[0] = LIN$IDENT; # LINE IDENTIFIER #
LIN$LNSIZE[0] = TLW + LIN$HDRL; # SET LINE SIZE OF HOP COMMAND #
NS$TKD(LINHEADER,TLW+LIN$HDRL,1); # ECHO HOP COMMAND TO K DIS #
#
TOKENIZE HOP COMMAND
#
COUNT = 0; # INITIALIZE CHARACTER COUNT OF TOKEN #
CNT =0; # INITIALIZE TOKEN COUNT #
INDEX = 0; # INITIALIZE WORD INDEX OF HOP COMMAND TEXT #
FOR I=0 STEP 1 UNTIL L$TOKENTAB
DO # REINITIALIZE TOKEN TABLE #
TT$WORD[I] = " ";
FOR I=0 STEP 1 WHILE I LS CC
AND KC EQ 0 # NO ERROR OCCURRED #
DO # UNPACK HOP COMMAND TEXT INTO TOKENS/SEPARATORS #
BEGIN
J = I - (INDEX * 10); # BIT POSITION OF WORD #
IF J GQ 10
THEN # GO TO NEXT WORD OF HOP COMMAND TEXT #
BEGIN
INDEX = INDEX + 1;
J = 0; # RESET BIT POSITION OF WORD #
END
CHAR = C<J,1>HCMD$WORD[INDEX]; # CURRENT CHARACTER #
IF CHAR GQ CHAR$A
AND CHAR LQ CHAR$9
THEN # CHARACTER IS ALPHANUMERIC #
BEGIN # ASSEMBLE TOKEN #
IF CNT LS L$TOKENTAB # TOKEN COUNT WITHIN LIMIT #
AND COUNT LS 7 # TOKEN CHARACTER COUNT OK #
THEN
BEGIN # ASSEMBLE CHARACTER INTO TOKEN #
C<COUNT,1>TT$WORD[CNT+1] = CHAR;
COUNT = COUNT + 1; # INCREMENT TOKEN CHARACTER COUNT #
END
ELSE # BAD TOKEN, SYNTAX ERROR #
KC = HOPCMDERR"SYNTAX";
END
ELSE # CHARACTER IS NON-ALPHANUMERIC #
BEGIN
IF CHAR EQ CHAR$COMMA
OR CHAR EQ CHAR$EQUAL
THEN # CHARACTER IS A LEGAL SEPARATOR #
BEGIN
IF TT$WORD[CNT+1] NQ BLANK
THEN # TOKEN EXISTS #
BEGIN
IF CHAR EQ CHAR$EQUAL
THEN
TT$SEP[CNT+1] = CHAR$EQUAL; # STORE EQUAL ONLY #
CNT = CNT + 1; # INCREMENT TOKEN COUNT #
COUNT = 0; # RESET TOKEN CHARACTER COUNT #
END
ELSE # TWO SEPARATORS IN A ROW #
KC = HOPCMDERR"SYNTAX"; # HOP COMMAND SYNTAX ERROR #
END
ELSE # CHARACTER NOT A SEPARATOR #
BEGIN
IF CHAR EQ CHAR$TERM
THEN # ITS A PERIOD #
I = CC; # TERMINATE UNPACKING COMMAND #
ELSE # ILLEGAL CHARACTER IN HOP COMMAND #
KC = HOPCMDERR"SYNTAX";
END
END
END # END I FOR LOOP #
IF KC EQ 0
THEN
BEGIN
IF TT$WORD[CNT+1] NQ BLANK
THEN # LAST TOKEN EXISTS #
TT$TCOUNT[0] = CNT + 1; # SET TOKEN COUNT #
ELSE # HOP COMMAND NOT PROPERLY TERMINATED #
KC = HOPCMDERR"SYNTAX";
END
#
RECOGNIZE HOP COMMAND
#
IF KC EQ 0
THEN
BEGIN
FOR I=0 STEP 1 UNTIL PAR$NPUS
DO # CLEAR HOP COMMAND ARRAY IN COMMON #
BEGIN
CMD$WORD[I] = 0;
END
DONE = FALSE;
FOR I=1 STEP 1 WHILE I LQ MAX$CMDKEY
AND NOT DONE
DO # CHECK IF COMMAND VERB IS A VALID ONE #
BEGIN
IF HC$KEYWORD[I] EQ TT$TOKEN[1]
THEN # MATCH WITH A VALID COMMAND VERB #
BEGIN
CMDORDINAL = HC$ORDINAL[I];
CMD$ORD[0] = CMDORDINAL;
DONE = TRUE;
END
END # END FOR LOOP #
IF DONE
THEN # VALID COMMAND VERB FOUND, PROCEED #
BEGIN # VALIDATE HOP COMMAND PARAMETERS #
COUNT = TT$TCOUNT[0]; # TOKEN COUNT #
FOR I=2 STEP M+1 WHILE I LQ COUNT
AND DONE
DO
BEGIN
M = 0;
DONE = FALSE;
FOR J=1 STEP 1 WHILE J LQ MAX$CMDPRM
AND NOT DONE
DO
BEGIN # SCAN VALID PARAMETER LIST #
IF TT$TOKEN[I] EQ HCP$PARAM[J]
THEN # PARAMETER MATCH #
BEGIN # STORE VALID PARAMETER IN COMMON #
K = HCP$PARORD[J]; # PARAMETER ORDINAL/BIT POSITION #
IF B<K,1>PARM$WORD[CMDORDINAL] NQ 0
THEN # SIGN BIT SET #
BEGIN # PARAMETER VALID FOR THIS COMMAND #
IF HCP$SEPAR[J] EQ CHAR$EQUAL
THEN # NEXT TOKEN IS AN EQUATE VALUE #
BEGIN # STORE VALUE IN HOPCOMMAND ARRAY #
CMD$WORD[K] = TT$WORD[I+1];
M =1; # INCREMENT STEP COUNT #
END
ELSE
CMD$WORD[K] = 1; # INDICATE PARAMETER SPECIFIED #
DONE = TRUE;
END
END
END # END J FOR LOOP #
END # END I FOR LOOP #
IF NOT DONE
THEN # ERROR DETECTED IN HOP COMMAND PARAMETER #
KC = HOPCMDERR"PARAMETER";
END
ELSE # ERROR DETECTED IN COMMAND VERB #
KC = HOPCMDERR"CMDVERB";
END
IF KC EQ 0
THEN # NO ERRORS DETECTED IN HOP COMMAND #
BEGIN # LOG VALID COMMAND IN NETWORK LOG FILE #
NS$MSG(HCMDTEXT, TLW, DM$NAMLOG+DM$HOPCMD+DM$LOCAL);
END
END
ELSE # NAM ERROR, HOP/CMD NOT ALLOWED #
ERRCODE = NS$FEC(EC"ERR$SM",SMEC"HSM$HOPSM");
RETURN;
END # NS$HCP #
TERM