*DECK NDLINIT USETEXT NDLDATT USETEXT NDLFETT USETEXT NDLTBLT PROC NDLINIT; BEGIN *IF,DEF,IMS # ** NDLINIT - INITIALIZES NDLP. * * D.K. ENDO 81/10/09 * * THIS PROGRAM CAUSES INITIALIZATION OF NDLP-S FLAGS, VALUES * AND TABLES. * * PROC NDLINIT * * ENTRY NONE. * * EXIT APPROPRIATE INITIALIZING OF FLAGS, VALUES, * AND ARRAYS. * * MESSAGES INVALID CONTROL CARD OPTION. * * METHOD * * INITIALIZE VARIOUS FLAGS. * CALL THE TABLE MANAGER TO INITIALIZE TABLE POINTERS. * CALL THE CONTROL CARD CRACKER. * INITIALIZE OUTPUT FET. * IF THIS IS A CREATION RUN. * INITIALIZE INPUT FET AND READ INTO CIO BUFFER. * INITIALIZE OTHER FETS. * ALLOCATE TABLE SPACE TO DEFINE AND LABEL TABLES. * # *ENDIF # **** PROC NDLINIT - XREF LIST BEGINS. # XREF BEGIN PROC ABORT; PROC SSTATS; # ALLOCATES SPACE TO A GIVEN TABLE # PROC SSTITM; # CALLS MANAGER TO DO ITS INITIALIZATION # PROC MEMORY; # UTILITY FOR REQUESTING MORE MEMORY # PROC MESSAGE; # SENDS MESSAGE TO DAYFILE # PROC READ; # READS INTO BUFFER FROM FILE # PROC RECALL; END # **** # ITEM CC$ERROR B, # CONTROL CARD ERROR STATUS # EXTRA U, # CONTAINS AMOUNT OF BUFFER SPACE FOR TBLS# INFILE C(10), # NAME OF INPUT FILE # MEMSTAT U, # CONTAINS AMOUNT OF MEMORY REQUESTED # OUTFILE C(10), # NAME OF OUTPUT FILE # RQTYPE C(10); # CONTAINS REQUEST TYPE FOR MEMORY # BASED ARRAY RA104[0:0] S(1); ITEM # POINTED TO RANDOM ADDRESS 104(OCTAL) # HHA U(0,42,18); # CONTAINS HIGHEST HIGH ADDRESS FOR NDLP # ARRAY INVCCRD[0:0] S(4); ITEM ICCMESS C(0,0,30) = [" INVALID CONTROL CARD OPTION. "], ICCZBYT U(3,0,60) = [0]; # ZERO FILL MESSAGE # DEF TFL #10000#; # MINIMUM BUFFER SPACE # CONTROL EJECT; PROC CRACKER(ERROR); BEGIN *IF,DEF,IMS # ** CRACKER - INTERPRETS CONTROL CARD OPTIONS * * D.K. ENDO 81/10/09 * * THIS PROCEDURE VALIDATES THE NDLP CONTROL CARD PARAMETERS AND * SETS FLAG AND VALUES ACCORDINGLY. * * PROC CRACK(ERROR) * * ENTRY NONE. * * EXIT ERROR = FLAG SET IF ERROR DETECTED ON CONTROL CARD. * * MESSAGES NONE. * * METHOD * * IF THERE ARE PARAMETERS ON CONTROL CARD * FOR EACH PARAMETER WHILE NOT DONE, * SEARCH TABLE FOR PARAMETER. * IF NOT FOUND, * THEN, * FLAG ERROR. * OTHERWISE, * GOTO TO APPROPRIATE PARAGRAPH TO CHECK PARAMETER. * CHECK IF LEGAL COMBINATION OF PARAMETERS WAS SPECIFIED. * IF NOT SPECIFIED CORRECTLY, * FLAG ERROR. * # *ENDIF ITEM ERROR B; # ERROR STATUS RETURNED TO CALLER # # **** PROC CRACKER - XREF LIST BEGINS. # XREF BEGIN PROC NDLZFIL; # ZERO FILLS GIVEN NAME # END # **** # DEF COMMA # O"1" #; # NUMBER REPRESENTING COMMA FOR PARAM LIST# DEF EQUAL # O"2" #; # NUMBER REPRESENTING EQUAL # DEF TRMNAT # O"17" #; # NUMBER INDICATING TERMINATING OF LIST # DEF ZERO # O"33000000000000" #; # ZERO FILLED VALUE FOR ZERO # # # ITEM DONE B; # COMPLETION FLAG # ITEM FOUND B; # FOUND INDICATOR # ITEM I; # SCRATCH ITEM # ITEM J; # SCRATCH ITEM # ITEM SWTCHVCTR; # SWITCH VECTOR FOR PARAMETER CHECKING # # # BASED ARRAY PARAMS [0:0] S(1); # PARAMETER LIST # BEGIN ITEM PARAM U(00,00,42); # PARAMETER NAME # ITEM PVALUE C(00,00,07); # PARAMETER VALUE # ITEM PCODE U(00,54,06); # DELIMITER CODE # END BASED ARRAY NUM$PRM [0:0] S(1); BEGIN ITEM NUM$PARAM U(00,42,18); END DEF MXPRMS # 5 #; ARRAY PARAM$TABLE [1:MXPRMS] S(1); BEGIN ITEM PRMNAME U(00,00,42) = [O"11000000000000", # I -- NAME # O"14000000000000", # L # O"14060000000000", # LF # O"14170000000000", # LO # O"16060000000000", # NF # ]; ITEM PRMSVCTR U(00,42,18) = [0, # I -- SWITCH VECTOR # 1, # L # 2, # LF # 3, # LO # 4 # NF # ]; END SWITCH LO$JUMP NEXTVAL,# ZERO -- JUMP FOR LIST OPTIONS # ERR$VAL,# A # ERR$VAL,# B # ERR$VAL,# C # D$VAL, # D # ERR$VAL,# E # F$VAL, # F # ERR$VAL,# G # ERR$VAL,# H # ERR$VAL,# I # ERR$VAL,# J # ERR$VAL,# K # ERR$VAL,# L # ERR$VAL,# M # N$VAL, # N # ERR$VAL,# O # ERR$VAL,# P # ERR$VAL,# Q # ERR$VAL,# R # S$VAL, # S # ERR$VAL,# T # ERR$VAL,# U # ERR$VAL,# V # ERR$VAL,# W # ERR$VAL,# X # ERR$VAL,# Y # ERR$VAL,# Z # ERR$VAL,# 0 # ERR$VAL,# 1 # ERR$VAL,# 2 # ERR$VAL,# 3 # ERR$VAL,# 4 # ERR$VAL,# 5 # ERR$VAL,# 6 # ERR$VAL,# 7 # ERR$VAL,# 8 # ERR$VAL;# 9 # SWITCH PRMJUMP I$PARAM,# INPUT FILE NAME -- PARAMETER JUMP # L$PARAM,# OUTPUT FILE NAME # LF$PARM,# LCF FILE NAME # LO$PARM,# LIST OPTIONS # NF$PARM;# NCF FILE NAME # CONTROL EJECT; # # # CRACKER CODE BEGINS HERE # # # P = O"2"; # POINT TO PARAMETER LIST # P = O"64"; # POINT TO PARAMETER COUNT # ERROR = FALSE; # CLEAR ERROR FLAG # DONE = FALSE; # CLEAR TERMINATION FLAG # IF NUM$PARAM[0] NQ 0 # IF THERE WERE PARAMETERS SPECIFIED # THEN BEGIN FOR I=0 STEP 1 WHILE NOT DONE DO # FOR EACH PARAMETER SPECIFIED # BEGIN IF PCODE[I] EQ TRMNAT OR # IF CODE FOR TERMINATION # PCODE[I+1] EQ TRMNAT # DETECTED # THEN BEGIN DONE = TRUE; # SET DONE FLAG # END FOUND = FALSE; # CLEAR FOUND FLAG # FOR J=1 STEP 1 WHILE NOT FOUND AND J LQ MXPRMS DO # SEARCH TABLE FOR PARAMETER # BEGIN IF PARAM[I] EQ PRMNAME[J] # IF PARAMETER IS FOUND # THEN BEGIN FOUND = TRUE; # SET FOUND FLAG # SWTCHVCTR = PRMSVCTR[J]; # SAVE SWITCH VECTOR FOR PARAM # END END IF NOT FOUND # IF PARAM NOT FOUND IN TABLE # THEN BEGIN ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # TEST I; END ELSE # PARAMETER IS LEGAL # BEGIN GOTO PRMJUMP[SWTCHVCTR]; # GOTO APPROPRIATE PARAGRAPH # I$PARAM: CRERUN = TRUE; # SET CREATION RUN FLAG # IF PCODE[I] EQ EQUAL # IF DELIMITER IS EQUAL # THEN BEGIN I = I + 1; # POINT TO VALUE # INFILE = PVALUE[I]; # SAVE INPUT FILE NAME # END ELSE # DELIMITER NOT EQUAL # BEGIN IF PCODE[I] EQ COMMA OR # IF DELIMITER IS COMMA OR # PCODE[I] EQ TRMNAT # TERMINATOR # THEN BEGIN INFILE = "COMPILE"; # DEFAULT INPUT FILE NAME # END ELSE # ILLEGAL DELIMITER # BEGIN ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # END END TEST I; L$PARAM: IF PCODE[I] EQ EQUAL # IF DELIMITER IS EQUAL # THEN BEGIN I = I + 1; # POINT TO VALUE # IF PVALUE[I] EQ ZERO # IF VALUE IS ZERO, NO OUTPUT # THEN # LISTING DESIRED # BEGIN LISTFLG = FALSE; # CLEAR LISTING FLAG # END ELSE # VALUE IS NOT ZERO # BEGIN OUTFILE = PVALUE[I]; # SAVE OUTPUT FILE NAME # END END ELSE # DELIMITER IS NOT EQUAL # BEGIN ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # END TEST I; LF$PARM: IF PCODE[I] EQ EQUAL # IF DELIMITER IS EQUAL # THEN BEGIN SUMRUN = TRUE; # SET SUMMARY RUN FLAG # LISTLF = TRUE; # SET LCF SUMMARY FLAG # I = I + 1; # POINT TO VALUE # LFFILE = PVALUE[I]; # SAVE LCF FILE NAME # NDLZFIL(LFFILE); # ZERO FILL NAME # END ELSE # DELIMITER IS NOT ZERO # BEGIN ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # END TEST I; LO$PARM: IF PCODE[I] EQ EQUAL # IF DELIMITER IS EQUAL # THEN BEGIN I = I + 1; # POINT TO VALUE # CRERUN = TRUE; # SET CREATION RUN FLAG # LISTN = FALSE; # CLEAR NORMAL SOURCE LIST FLAG # LISTD = FALSE; # CLEAR DEFINE LISTING FLAG # FOR J=0 STEP 1 UNTIL 7 DO # FOR EACH CHARACTER IN VALUE # BEGIN # GOTO APPROPRIATE PARAGRAPH # GOTO LO$JUMP[CPVALUE[I]]; N$VAL: LISTN = TRUE; # SET NORMAL SOURCE LISTING FLAG# TEST J; D$VAL: LISTD = TRUE; # SET DEFINE LISTING FLAG # TEST J; S$VAL: LISTS = TRUE; # SET EXPANDED SOURCE LIST FLAG # TEST J; F$VAL: LISTF = TRUE; # SET FILE SUMMARY FLAG # TEST J; ERR$VAL: ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # NEXTVAL: TEST J; END END ELSE # DELIMITER IS NOT EQUAL # BEGIN ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # END TEST I; NF$PARM: IF PCODE[I] EQ EQUAL # IF DELIMITER IS EQUAL # THEN BEGIN SUMRUN = TRUE; # SET SUMMARY RUN FLAG # LISTNF = TRUE; # SET NCF SUMMARY LIST FLAG # I = I + 1; # POINT TO VALUE # NFFILE = PVALUE[I]; # SAVE NCF FILE NAME # NDLZFIL(NFFILE); # ZERO FILL NAME # END ELSE # DELIMITER IS NOT EQUAL # BEGIN ERROR = TRUE; # SET ERROR FLAG # DONE = TRUE; # SET DONE FLAG # END TEST I; END END END ELSE # NO PARAMETER SPECIFIED # BEGIN CRERUN = TRUE; # SET CREATION RUN FLAG # SUMRUN = FALSE; # CLEAR SUMMARY RUN FLAG # END NDLZFIL(OUTFILE); # ZERO FILL OUTPUT FILE NAME # NDLZFIL(INFILE); # ZERO FILL INPUT FILE NAME # IF CRERUN AND # IF BOTH CREATION RUN AND SUMMARY RUN # SUMRUN # PARAMETERS SPECIFIED # THEN BEGIN ERROR = TRUE; # SET ERROR FLAG # END IF NOT CRERUN AND # IF BOTH FLAG ARE NOT SET, THEN ONLY THE # NOT SUMRUN # -L- PARAMETER WAS SPECIFIED # THEN BEGIN CRERUN = TRUE; # SET CREATION RUN FLAG # SUMRUN = FALSE; # CLEAR SUMMARY RUN FLAG # END RETURN; # **** RETURN **** # END # CRACKER # CONTROL EJECT; # # # NDLINIT CODE BEGINS HERE # # # # INITIALIZE FLAGS AND FILE NAMES # LISTLF = FALSE; LISTNF = FALSE; LISTN = TRUE; LISTD = TRUE; LISTS = FALSE; LISTF = FALSE; INFILE = "INPUT"; OUTFILE = "OUTPUT"; LISTFLG = TRUE; CRERUN = FALSE; SUMRUN = FALSE; EOINP = FALSE; # INITIALIZE TABLE MANAGER # RQTYPE = "CM"; # SET REQUEST TYPE # MEMSTAT = 0; P = O"104"; # POINT BASED ARRAY TO REL ADDR 104 # MEMORY(RQTYPE,MEMSTAT);# FIND SIZE OF FIELD LENGTH # MEML = HHA[0]; #SAVE POINTER TO BEGINNING OF MANAGED AREA# SSTITM(MEML,P,LOC(MEML)); # INITIALIZE MANAGER # # CRACK CONTROL CARD # CRACKER(CC$ERROR); IF CC$ERROR # IF CONTROL CARD ERROR DETECTED # THEN BEGIN MESSAGE(INVCCRD,0); # SEND DAYFILE MESSAGE # ABORT; # **** ABORT RUN **** # END # OPEN FILES # OUTLFN[0] = OUTFILE; OUTFIRST[0] = LOC(OUTWB); OUTIN[0] = LOC(OUTWB); OUTOUT[0] = LOC(OUTWB); OUTLIMIT[0] = LOC(OUTWB) + PRULNGTH + 1; IF CRERUN THEN BEGIN INLFN[0] = INFILE; INFIRST[0] = LOC(INWB); ININ[0] = LOC(INWB); INOUT[0] = LOC(INWB); INLIMIT[0] = LOC(INWB) + PRULNGTH + 1; READ(INFET); RECALL(INFET); SECFIRST[0] = LOC(SECWB); SECIN[0] = LOC(SECWB); SECOUT[0] = LOC(SECWB); SECLIMIT[0] = LOC(SECWB) + PRULNGTH + 1; ESIFIRST[0] = LOC(ESIWB); ESIIN[0] = LOC(ESIWB); ESIOUT[0] = LOC(ESIWB); ESILIMIT[0] = LOC(ESIWB) + PRULNGTH + 1; STFIRST[0] = LOC(STWB); STIN[0] = LOC(STWB); STOUT[0] = LOC(STWB); STLIMIT[0] = LOC(STWB) + PRULNGTH + 1; E1FIRST[0] = LOC(E1WB); E1IN[0] = LOC(E1WB); E1OUT[0] = LOC(E1WB); E1LIMIT[0] = LOC(E1WB) + PRULNGTH + 1; E2FIRST[0] = LOC(E2WB); E2IN[0] = LOC(E2WB); E2OUT[0] = LOC(E2WB); E2LIMIT[0] = LOC(E2WB) + PRULNGTH + 1; # ALLOCATE TABLE SPACE FOR LABELS AND DEFINES # SSTATS(P,MAXDT); # GET SPACE FOR DEFINE TABLE # SSTATS(P,MAXLT); # GET SPACE FOR LABEL TABLE # SSTATS(P,MXSTBL); # GET SPACE FOR STMT TABLE # SSTATS(P,MXTBUFF);# GET SPACE FOR TERM STMT BUFFER# END RETURN; END # NDLINIT # TERM