*DECK NS$CRA USETEXT CYB$NS USETEXT COM$NS USETEXT DEF$NS PROC NS$CRA; # CONTROL CARD CRACKER # # TITLE NS$CRA - CONTROL CARD CRACKER. # BEGIN # NS$CRA # # ** NS$CRA - CONTROL CARD CRACKER. * * J.C. LEE 1981 * * THIS ROUTINE IS PART OF THE INITIALIZATIN PROCESS FOR NS. * ITS FUNCTION IS TO CRACK THE NS CONTROL CARD, SAVE VALID * VALUES, AND FLAG ERRORS IF FOUND. * * PROC NS$CRA * * ENTRY: * ARGUMENT LIST IN COMMUNICATION AREA. * * EXIT: * 1. NIN, NDFCT, NSM, MC, AND RT VALUES * 2. ERROR MESSAGE(S) SENT IF FOUND. * * METHOD: * LOOP THROUGH THE ARGUMENT LIST. FOR EACH OPTION, SEARCH THE * PARAMETER TABLE FOR VALID OPTION. IF FOUND, JUMP TO THE * APPROPRIATE PARAGRAPH TO CONVERT AND SAVE VALUE, ELSE FLAG * AS ILLEGAL OPTION. * # XREF BEGIN # RA COMMUNICATION AREA # ARRAY ARG[1:22] S(1); BEGIN # RA.ARGR # ITEM ARG$SYMBO U(00,00,NL); # ARGUMENT VALUE # ITEM ARG$SEPAR U(00,NL,AL); # ARGUMENT SEPARATOR # ITEM ARG$WORD U(00,00,WL); END ARRAY ACT[0:0] S(1); BEGIN ITEM ACT$COUNT U(00,NL,AL); # ARGUMENT COUNT # END END XREF BEGIN PROC ABORT; # ABORT NS # PROC NS$MSG; # DISPATCH MESSAGE # PROC NS$CVD; # CONVERT DECIMAL DC TO BINARY # PROC NS$CVH; # CONVERT HEX DC TO BINARY # END # DEFINITIONS FOR PARAMETER INDEXES # DEF PAR$COUNT #05#; # NUMBER OF VALID NS PARAMETERS # DEF PAR$NIN #01#; # NIN INDEX # DEF PAR$NDFCT #02#; # NDFCT INDEX # DEF PAR$FDP #03#; # NSM INDEX # DEF PAR$MC #04#; # MC INDEX # DEF PAR$RT #05#; # RT INDEX # # MISCELLANEOUS DEFINITIONS # DEF COMMA # O"56" #; DEF EQUAL # O"54" #; DEF PERIOD # O"57" #; DEF YES #O"31052300000000"#; DEF NO #O"16170000000000"#; DEF CT$P #O"20000000000000"#; # FILE CATEGORY = PRIVATE # DEF CT$S #O"23000000000000"#; # FILE CATEGORY = SEMIPRIVATE# DEF CT$PU #O"20250000000000"#; # FILE CATEGORY = PUBLIC # # REASON CODES FOR CONTROL CARD ERRORS # DEF RC$PARILL #01#; # ILLEGAL PARAMETER # DEF RC$PARFMT #02#; # PARAMETER FORMAT ERROR # DEF RC$PARVAL #03#; # BAD PARAMETER VALUE # DEF RC$PARDUP #04#; # DUPLICATE PARAMETER # DEF RC$PARMIS #05#; # MISSING REQUIRED PARAMETER # # LOCAL VARIABLES # ITEM ARGPTR I = 0; # ARGUMENT POINTER # ITEM ERR B; # ERROR INDICATOR # ITEM ERRCODE I = 0; # ERROR CODE # ITEM I I; # TEMPORARY VARIABLE # ITEM J U; # TEMPORARY VARIABLE # ITEM K U; # TEMPORARY VARIABLE # ITEM MATCH B; # FOUND VALID PARAMETER FLAG # ITEM NARGS U; # NO OF ARGUMENTS # ARRAY PAR [1:PAR$COUNT] S(1); BEGIN # VALID PARAMETER LIST # ITEM PAR$KEY U(00,00,42) = [ # KEYWORDS # O"16111600000000", # NIN # O"16040603240000", # NDFCT # O"06042000000000", # FDP # O"15030000000000", # MC # O"22240000000000", # RT # ]; ITEM PAR$NCV U(00,42,12) = [ # CHARS ALLOWED FOR PARAM VALUE# 3, # UP TO 3 DEC CHARS FOR NIN # 2, # UP TO 2 CHARS FOR NDFCT # 3, # UP TO 3 CHARS FOR FDP # 7, # UP TO 7 DEC CHARS FOR MC # 3, # UP TO 3 CHARS FOR RT # ]; ITEM PAR$PRC B(00,54,06) = [ # PARAMETER PROCESSED FLAG # FALSE, FALSE, FALSE, FALSE, FALSE, ]; END DEF L$PARERR # 5 #; DEF DM$PARERR # DM$SYSLOC+DM$ABORT #; ARRAY MSG$PARERR [RC$PARILL:RC$PARMIS] S(L$PARERR); BEGIN # CONTROL CARD ERROR DIAGNOSTICS # ITEM PEM$TEXT C(00,00,40) = [ # MESSAGE TEXT # "NS/UNRECOGNIZED CONTROL CARD PARAMETER.", "NS/CONTROL CARD PARAMETER SYNTAX ERROR.", "NS/ILLEGAL CONTROL CARD PARAMETER VALUE.", "NS/DUPLICATE CONTROL CARD PARAMETER.", "NS/NIN IS NOT SPECIFIED.", ]; ITEM PEM$END U(04,00,60) = [ RC$PARMIS(0) ]; END BASED ARRAY DUMMY [1:PAR$COUNT] S(1); BEGIN ITEM PARAMWORD U(00,00,60); END SWITCH PARTYPE , # SWITCHES FOR PARAMETERS # TYPE$NIN, TYPE$NDFCT, TYPE$FDP, TYPE$MC, TYPE$RT; CONTROL EJECT; # LOOP TO PROCESS ALL SPECIFIED PARAMETERS # NARGS = ACT$COUNT[0]; # NO OF ARGUMENTS # FOR ARGPTR=ARGPTR WHILE ARGPTR LS NARGS AND ERRCODE EQ 0 DO # SCAN RA+2 THRU RA+22 FOR ARGUMENTS # BEGIN ARGPTR = ARGPTR + 1; # MOVE POINTER TO NEXT ARGUMENT # MATCH = FALSE; FOR I=1 STEP 1 WHILE I LQ PAR$COUNT AND NOT MATCH DO BEGIN IF ARG$SYMBO[ARGPTR] EQ PAR$KEY[I] THEN # FOUND VALID KEYWORD # BEGIN MATCH = TRUE; K = I; # SET TO KEYWORD INDEX # END END IF MATCH THEN # FOUND VALID PARAMETER # BEGIN I = ARGPTR + 1; # POINTER TO PARAMETER VALUE # IF (ARG$SEPAR[ARGPTR] EQ EQUAL) AND (I LQ NARGS) THEN # PARAMETER FORMAT OK # BEGIN ARGPTR = I; # UPDATE POINTER TO NEXT ARG # J = PAR$NCV[K]; # CHARS ALLOWED FOR VALUE # IF J EQ NC OR CARG$SYMBO[ARGPTR] EQ 0 THEN # PARAMETER VALUE NOT EXCEEDING # BEGIN # MAX NUMBER OF CHARS ALLOWED # # SWITCH TO PARAMETER PROCESSING CASES # GOTO PARTYPE[K]; TYPE$NIN: I = PAR$NIN; NS$CVD(ARG$WORD[ARGPTR],K,J,ERR); # CONVERT DEC TO BIN # ZDMBID$NIN[0] = K; # SET NETWORK INVOCATION NUMBER # B<0,18>K = J + O"333333";# SET TO DISPLAY-CODED DEC # GOTO ENDPRC; TYPE$NDFCT: I = PAR$NDFCT; IF ARG$SYMBO[ARGPTR] EQ CT$P THEN # FILE CATEGORY IS PRIVATE # K = 0; ELSE BEGIN IF ARG$SYMBO[ARGPTR] EQ CT$S THEN # FILE CATEGORY IS SEMIPRIVATE # K = 1; ELSE BEGIN IF ARG$SYMBO[ARGPTR] EQ CT$PU THEN # FILE CATEGORY IS PUBLIC # K = 2; ELSE # UNRECOGNIZED PARAMETER VALUE # ERR = TRUE; END END GOTO ENDPRC; TYPE$FDP: I = PAR$FDP; GOTO CHECKYN; TYPE$MC: I = PAR$MC; NS$CVD(ARG$WORD[ARGPTR],K,J,ERR) ; # CONVERT DEC TO BIN # GOTO ENDPRC; TYPE$RT: I = PAR$RT; CHECKYN: IF ARG$SYMBO[ARGPTR] EQ YES THEN K = ASC$YY; # PARAMETER VALUE IS -YES- # ELSE BEGIN IF ARG$SYMBO[ARGPTR] EQ NO THEN K = ASC$NN; # PARAMETER VALUE IS -NO- # ELSE ERR = TRUE; # BAD PARAMETER VALUE # END ENDPRC: IF NOT ERR THEN # NO ERROR FOUND # BEGIN IF NOT PAR$PRC[I] THEN # PARAMETER NOT PROCESSED # BEGIN PAR$PRC[I] = TRUE; # SET PARAMETER PROCESSED FLAG # P = LOC(NIN); PARAMWORD[I] = K; # STORE PARAM VALUE IN COMMON # END ELSE # DUPLICATE PARAMETER # ERRCODE = RC$PARDUP; END ELSE # BAD PARAMETER VALUE # ERRCODE = RC$PARVAL; END ELSE # CHARS EXCEED ALLOWED VALUE # ERRCODE = RC$PARVAL; END ELSE # PARAMETER FORMAT ERROR # ERRCODE = RC$PARFMT; END ELSE # ILLEGAL PARAMETER # ERRCODE = RC$PARILL; END IF ERRCODE EQ 0 AND NOT PAR$PRC[PAR$NIN] THEN # NIN MUST BE SPECIFIED # ERRCODE = RC$PARMIS; IF ERRCODE NQ 0 THEN # ERROR FOUND # NS$MSG(MSG$PARERR[ERRCODE],L$PARERR,DM$PARERR); RETURN; END TERM