PROC K; # TITLE K - *K* DISPLAY DOCUMENTATION. # BEGIN # K # # ***** *K* DISPLAY ROUTINES. * * THE *K* DISPLAY ROUTINES ARE TO PROVIDE ACCESS TO THE * *K* DISPLAY FOR THE SSEXEC. THE FUNCTIONS ARE TO * FORMAT THE LEFT SCREEN DISPLAY AND TO PROCESS THE KEYBOARD * RESPONSES FROM THE OPERATOR. *** OVERVIEW OF *K* DISPLAY ROUTINES. * * THE *K* DISPLAY ROUTINES ARE - * * KCLR - CLEAR CURRENT ENTRY ON *K* DISPLAY. * KDISPLY - *K* DISPLAY OVERLAY PROCESSOR. * KDSM - DISPLAY SM INFORMATION. * KFILES - PROCESS *FILES* COMMAND. * KINIT - *K* DISPLAY INITIALIZATION. * KINPUT - KEYBOARD INPUT PROCESSOR. * KPFILL - PARAMETER FILL ROUTINE. * KPROC - *K* DISPLAY PROCESSOR. * KREQ - *K* DISPLAY REQUEST. * KSM - PROCESS *SMI* COMMAND. * * *KINIT* MUST BE CALLED ONCE INITIALLY TO ISSUE THE * *CONSOLE* MACRO. * * *KREQ* PROCESSES REQUESTS TO PLACE A GROUP OF MESSAGES * ON THE LEFT SCREEN OR TO COMPLETE/CLEAR A GROUP OF MESSAGES * FROM THE LEFT SCREEN. * * THE CALLER CAN SPECIFY UP TO THREE MESSAGES IN EACH REQUEST, * INDICATE WHAT OPERATOR RESPONSES ARE VALID, REQUEST THAT THE * MESSAGE(S) BE ISSUED TO THE DAYFILE/ERROR LOG, AND INCLUDE * PARAMETER VALUES TO BE INSERTED INTO THE MESSAGE TEXTS. * * NEW REQUESTS ARE PLACED IN A QUEUE FOR LATER PROCESSING. * THEY REMAIN IN THE QUEUE UNTIL THEY ARE COMPLETED BY * SOME EVENT. THE EVENTS ARE - * . CALL TO *KREQ* TO CLEAR THE MESSAGES (DELINK). * . OPERATOR RESPONSE. * . "IMMEDIATE-COMPLETE" OPTION SET IN THE REQUEST. * * THE QUEUE IS FORMED BY LINKING THRU A FIELD IN THE * REQUEST. THEREFORE, THE REQUEST WORDS MUST REMAIN * AVAILABLE WHILE THE REQUEST IS NOT COMPLETE. * * THE "IMMEDIATE-COMPLETE" OPTION IN THE REQUEST WORDS MEANS * THE *K* PROCESSING WILL SET THE COMPLETE BIT AND DELINK THE * REQUEST FROM THE QUEUE AS SOON AS IT HAS PLACED THE MESSAGES * ON THE LEFT SCREEN. THEN THE ONLY WAY TO CLEAR THOSE * MESSAGES ON THE SCREEN IS BY AN OPERATOR RESPONSE. * * TO REQUEST MESSAGES TO BE PLACED ON THE LEFT SCREEN, * THE CALLER MUST FORMAT THE REQUEST BY USING THE * *KWORD* BASED ARRAY IN *COMBKDD* AND THEN CALL * *KREQ* SPECIFYING THE PROPER PARAMETERS.. * - ADDRESS OF THE *KWORD* ARRAY, AND * - *KLINK*, WHICH ADDS A NEW REQUEST. * THE CALLER MUST SPECIFY IN THE *KWORD* ARRAY * THE CALLER CONTROLLED FLAGS AND THE MESSAGE * ORDINALS FOR LINES 1, 2, 3. ALSO, THE * PARAMETER WORD IN *KWORD* MUST BE SET * IF PARAMETERS ARE USED IN THE MESSAGE TEXT. * * THE MESSAGE ORDINALS ARE DEFINED IN THE *KM* * STATUS LIST IN *COMBKDD* (MESSAGE ORDINAL ZERO * SPECIFIES A BLANK LINE). THE MESSAGE TEXTS * AND PARAMETER DEFINITIONS ARE ALSO DEFINED * IN *COMBKDD*. * * TO CLEAR A REQUEST THAT IS QUEUED WAITING * TO BE DISPLAYED OR IS ALREADY ON THE LEFT SCREEN * DISPLAY, THE PROC *KREQ* CAN BE CALLED * SPECIFYING THE ADDRESS OF THE *KWORD* ARRAY * AND THE VALUE *KDELINK*. * * *KPROC* CONTROLS THE PROCESSING OF THE LEFT SCREEN AND * OPERATOR RESPONSES. IT SHOULD BE CALLED PERIODICALLY. * WHEN IT DETECTS WORK TO BE DONE, IT CALLS THE * OVERLAY *KDISPLY* TO PROCESS THE WORK. *** THE LEFT SCREEN FORMAT IS - * * LINE - * TYPE - DESCRIPTION * ---- - ----------- * * * - -------------------------- * TITLE - - MASS STORAGE SUBSYSTEM - * - -------------------------- * - * - * BODY - 1. LINE 1 OF THE *K* REQUEST 1. * - LINE 2 OF THE *K* REQUEST 1. * - LINE 3 OF THE *K* REQUEST 1. * - * - * - 2. LINE 1 OF THE *K* REQUEST 2. ... * - LINE 2 OF ... * - LINE 3 OF THE *K* REQUEST 2. ... * - * - * - (UP TO 2 ORDINALS) * * REJECT - *** REJECT *** * - * - * ECHO - (KEYBOARD TYPE-IN) * - * * THE BODY CONSISTS OF AN ORDINAL REPRESENTING A SPECIFIC *K* * REQUEST AND THE TEXT AS SPECIFIED IN THAT REQUEST. * A MAXIMUM OF 3 LINES MAY BE SPECIFIED PER REQUEST. *** OPERATOR RESPONSES. * * RESPONSES TO MESSAGES IN THE LEFT SCREEN BODY HAVE THE FORM - * * N.COMMAND. WHERE N IS THE ORDINAL * AND COMMAND = *GO* OR *DROP*. * * OTHER OPERATOR COMMANDS DEFINED ARE - * * FILES,N. WHERE N IS THE AUTHORIZED DATA BUFFER COUNT. * * SMI. WHERE I IS THE SM ORDINAL FOR WHICH * INFORMATION IS DISPLAYED. * * SMI,DRD=ST=N. WHERE I IS THE SM ORDINAL * SMI,DRD=DS=N. AND N IS THE MAXIMUM NUMBER OF DRD-S * PERMITTED FOR STAGING OR DESTAGING FILES. * (ST IF STAGING, DS IF DESTAGING) * * STAGE. TOGGLE OPEN/CLOSE STATUS. * DESTAGE. * # END # K # TERM PROC KCLR((ORD)); # TITLE KCLR - CLEAR CURRENT ENTRY ON *K* DISPLAY. # BEGIN # KCLR # # ** KCLR - CLEAR CURRENT ENTRY ON *K* DISPLAY. * * *KCLR* CLEARS THE LEFT SCREEN AREA FOR THE SPECIFIED * ORDINAL, DECREMENTS THE *KACTCOUNT* AND CLEARS THE * *KCURRENT* ENTRY FOR THE ORDINAL. * * PROC KCLR((ORD)) * * ENTRY (ORD) - ORDINAL OF CURRENT ENTRY TO CLEAR. * * EXIT (KACTCOUNT) - DECREMENTED. * (KCUR$WD) - ENTRY FOR SPECIFIED ORDINAL IS CLEARED. * * LINES IN THE BODY OF LEFT SCREEN FOR THE SPECIFIED * ORDINAL ARE CLEARED. * # ITEM ORD I; # ORDINAL OF CURRENT ENTRY # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL,COMBFAS *CALL COMBKDA ITEM LINES I; # TEMPORARY CELL # CONTROL EJECT; P = LOC(KL$LINE[LF$BODY]); # * CLEAR LEFT SCREEN LINES FOR THE GIVEN ORDINAL, ONLY IF * THE MESSAGE DISPLAY IS ON THE SCREEN. # IF NOT KSMDISP THEN # REMOVE MESSAGES # BEGIN # MSG # FASTFOR LINES = 1 STEP 1 UNTIL 3 DO # CLEAR EACH LINE # BEGIN # BLANK # KLB$LINCLR[LINES,ORD] = " "; END # BLANK # END # MSG # KCUR$WD[ORD] = 0; # CLEAR *KCURRENT* ENTRY # KACTCOUNT = KACTCOUNT - 1; # DECREMENT ACTIVE COUNT # RETURN; END # KCLR # TERM PROC KDISPLY; # TITLE KDISPLY - *K* DISPLAY OVERLAY. # BEGIN # KDISPLY # # ** KDISPLY - *K* DISPLAY OVERLAY. * * *KDISPLY* CALLS *KINPUT* IF THERE IS AN OPERATOR TYPE-IN * IN THE *KBINPUT* BUFFER, BUILDS THE LEFT SCREEN BUFFER * FOR NEW REQUESTS AND CONTAINS THE ARRAY OF DEFINED *K* * MESSAGES. * * PROC KDISPLY. * * ENTRY (KACTCOUNT) - NUMBER OF ACTIVE REQUESTS IN BODY * OF THE LEFT SCREEN. * (KLINKQ) - HEAD OF K-QUEUE. * = 0 IF EMPTY. * ARRAY KBINPUT - KEYBOARD INPUT BUFFER. * ARRAY KCURRENT - CURRENT ENTRIES ON LEFT SCREEN. * = 0 IF ENTRY AVAILABLE. * * EXIT FOR EACH NEW *KWORD* REQUEST THAT IS PROCESSED - * - LINES ARE FORMATTED FOR THE LEFT SCREEN BODY. * - LINES ARE ISSUED TO THE DAYFILE IF SPECIFIED. * - LINES ARE ISSUED TO THE ERROR LOG IF SPECIFIED. * - IF THE *KW$IC* IS SET, THE COMPLETE BIT IS SET AND * THE *KWORD* REQUEST IS DELINKED FROM THE K-QUEUE. * (KW$ACT) - SET IN *KWORD* REQUEST. * (KACTCOUNT) - INCREMENTED FOR REQUESTS PROCESSED. * ARRAY KCURRENT - ENTRIES SET FOR REQUESTS PROCESSED. * KNEWREQ - SET FALSE WHEN NO NEW REQUESTS * ARE FOUND. * * NOTES THE DEFINED MESSAGE SIZE IS 40 CHARACTERS. * # # **** PROC KDISPLY - XREF LIST BEGIN. # XREF BEGIN PROC KDSM; # DISPLAY *SM* INFORMATION # PROC KINPUT; # KEYBOARD INPUT # PROC KPFILL; # *K* PARAMETER FILL # PROC KREQ; # *K* DISPLAY REQUEST # PROC MESSAGE; # ISSUE *MESSAGE* MACRO # FUNC XCOD C(10); # CONVERT INTEGER TO OCTAL DISPLAY CODE # END # **** PROC KDISPLY - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBKDA *CALL COMBKDD ITEM CURRKW I; # *KWORD* ADDRESS # ITEM CURRORD I; # ORDINAL # ITEM I I; # TEMPORARY CELL # ITEM LINE I; # LINE NUMBER # ITEM MSGORD I; # MESSAGE ORDINAL # ITEM TEMP C(10); # TEMPORARY CELL # ITEM DSPLORD C(10) = " N. "; # DISPLAY ORDINAL # # * ARRAY OF MESSAGES DEFINED FOR THE *K* DISPLAY. # ARRAY KMESSAGES [0:KMNUM] S(4); BEGIN ITEM KM$TEXT C(00,00,40) = [ "NO-ONE", KM1, KM2, KM3, KM4, KM5, KM6, KM7, KM8, KM9, KM10, KM11, KM12, KM13, KM14, KM15, KM16, KM17, KM18, KM19, KM20, KM21, KM22, KM23, KM24, KM25, KM26, KM27, KM28, KM29, KM30 ]; END # * ARRAY TO DEVELOP THE MESSAGE TEXT FOR THE *K* LINE. # ARRAY TEXT [0:0] S(7); BEGIN ITEM TEXT$WDS C(00,00,60); ITEM TEXT$ALL C(00,00,40); ITEM TEXT$ZER U(06,00,60) = [0]; END # * ARRAY TO SET UP MESSAGES FOR DAYFILES. # ARRAY DAYTEXT [0:0] S(5); BEGIN ITEM DAYT$ALL C(00,00,40); ITEM DAYT$ZER C(04,00,60) = [0]; END CONTROL EJECT; # * CALL *KINPUT* IF THERE IS A RESPONSE IN THE KEYBOARD BUFFER. # IF KB$CLEAR[0] NQ 0 THEN BEGIN KINPUT; END # * REFRESH *SM* DISPLAY. # IF KSMDISP # SM DISPLAY IN BUFFER # AND KLINKQ EQ 0 # NO MESSAGES TO DISPLAY # THEN # *SM* DISPLAY CAN BE REFRESHED # BEGIN # SM # IF KL$COMP[0] THEN # SM DISPLAY ON SCREEN # BEGIN # UPDATE # KDSM; # REFRESH SM DISPLAY # END # UPDATE # RETURN; # DO NOT DISPLAY MESSAGES # END # SM # # * PROCESS ALL POSSIBLE MESSAGES FOR THE LEFT SCREEN. # IF KSMDISP THEN # SM DISPLAY IN BUFFER # BEGIN # CLEAR # SLOWFOR I = (LF$TITLEDIS+1) STEP 1 UNTIL (LF$VALCMD-1) DO # CLEAR BUFFER FOR MESSAGES # BEGIN # BLANK # KL$LINE[I] = " "; END # BLANK # KSMDISP = FALSE; # NOTE SM DISPLAY NO LONGER UP # END # CLEAR # REPEAT DO BEGIN # PROCESS LEFT SCREEN DISPLAYS # # * RETURN IF THERE IS NO AVAILABLE SPACE ON THE LEFT SCREEN. # IF KACTCOUNT EQ KORD THEN BEGIN RETURN; END # * SEARCH THE K-QUEUE TO FIND A NEW REQUEST. * SETS - *CURRKW* = *KWORD* ADDRESS OR ZERO (IF END OF THE QUEUE). # CURRKW = KLINKQ; P = CURRKW; REPEAT WHILE CURRKW NQ 0 AND KW$ACT[0] DO BEGIN CURRKW = KW$LINK[0]; P = CURRKW; END # * RETURN IF THERE IS NO NEW REQUEST. # IF CURRKW EQ 0 THEN BEGIN KNEWREQ = FALSE; RETURN; # NO NEW REQUEST # END # * LOCATE THE ORDINAL FOR AVAILABLE SPACE ON THE LEFT SCREEN. # FASTFOR I = KORD STEP -1 UNTIL 1 DO BEGIN IF KCUR$WD[I] EQ 0 THEN BEGIN CURRORD = I; END END # * BUILD THE LINES FOR THE LEFT SCREEN BODY. # P = LOC(KL$LINE[LF$BODY]); TEMP = XCOD(CURRORD); C<5,1>DSPLORD = C<9,1>TEMP; KLB$ORD[1,CURRORD] = DSPLORD; FOR LINE = 1 STEP 1 UNTIL 3 DO BEGIN # BUILD DISPLAY LINE # MSGORD = KW$MSGORD(LINE); # GET MESSAGE ORDINAL # IF MSGORD EQ 0 THEN # NO MESSAGE FOR THIS LINE # BEGIN TEST LINE; END TEXT$WDS[0] = KM$TEXT[MSGORD]; # GET MESSAGE TEXT # KPFILL(TEXT[0],LOC(KW$PAR[0])); # SET PARAMETERS # KLB$TEXT[LINE,CURRORD] = TEXT$WDS[0]; # TEXT TO LEFT SCREEN # IF KW$DF[0] THEN # TEXT TO DAYFILE # BEGIN DAYT$ALL[0] = TEXT$ALL[0]; # SEND FEWER CHARACTERS # MESSAGE(DAYTEXT,UDFL1); END IF KW$ELOG[0] THEN # TEXT TO ERROR LOG # BEGIN DAYT$ALL[0] = TEXT$ALL[0]; # SEND FEWER CHARACTERS # MESSAGE(DAYTEXT,ERRLOG); END END # BUILD DISPLAY LINE # # * SET *KWORD* ACTIVE AND SET *KCURRENT* FOR THE ORDINAL. # KW$ACT[0] = TRUE; # ACTIVE FLAG # KCUR$CW[CURRORD] = KW$CW[0]; # CONTROL FLAGS # KCUR$ADDR[CURRORD] = CURRKW; # *KWORD* ADDRESS # KACTCOUNT = KACTCOUNT + 1; # ACTIVE COUNTER # # * IF THE REQUEST SPECIFIED AN *IMMEDIATE-COMPLETE*, SET THE * *KWORD* COMPLETE AND DELINK IT. THE CONTROL FLAGS * REMAIN IN *KCURRENT* TO KEEP THAT ORDINAL MARKED ACTIVE, * AND THE MESSAGES (LINE 1-3) REMAIN UP. # IF KW$IC[0] THEN BEGIN KW$COMP[0] = TRUE; # COMPLETE # KCUR$ADDR[CURRORD] = 0; # CLEAR *KWORD* ADDRESS # KREQ(CURRKW,KDELINK); # DELINK FROM *K* QUEUE # END END # PROCESS LEFT SCREEN DISPLAYS # END # KDISPLY # TERM PROC KDSM; # TITLE KDSM - DISPLAY *SM* INFORMATION ON *K* DISPLAY. # BEGIN # KDSM# # ** KDSM - PAINT *SM* INFORMATION ON K-DISPLAY. * * *KDSM* DISPLAYS STORAGE MODULE INFORMATION FROM THE UDT ON THE * K-DISPLAY IN RESPONSE TO AN *SMI* COMMAND INPUT FROM THE * KEYBOARD. * * PROC KDSM * * ENTRY ARRAY KBINPUT (DEFINED IN *COMBKDD*) CONTAINS THE * IMAGE OF THE *SMI* COMMAND. * * EXIT *SM* PORTION OF *K* DISPLAY HAS BEEN UPDATED. * * MESSAGES * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - * 1 2 3 4 5 6 7 *1234567890123456789012345678901234567890123456789012345678901234567890 * - MSE SUBSYSTEM - 1 * - OPEN STAGE RTRQ= 0 OPEN DESTAGE- 2 * 3 * 4 * SMI STATUS ON 5 * X MAX DRDS FOR STAGING 6 * Y MAX DRDS FOR DESTAGING 7 * 8 * JSN FILE UI PRU-S 9 * DRD0 STAGE - WXYZ FILENAM USRIDX PRUCNT 10 * DRD1 DESTAGE - ABCD FILENAM USRIDX PRUCNT 11 * 12 * 13 * VALID COMMANDS 14 * K.X.GO. CLEARS ORDINAL *X* 15 * K.STAGE OR K.DESTAGE TOGGLES OPEN/CLOSE 16 * K.SMI SELECTS SM *I* INFORMATION 17 * K.SMI,DRD=ST=X SETS MAX *X* STAGE DRDS 18 * K.SMI,DRD=DS=Y SETS MAX *Y* DESTAGE DRDS 19 * * * * # # **** PROC KDSM - XREF LIST BEGIN. # XREF BEGIN PROC KPFILL; # *K* PARAMTER FILL # PROC ZFILL; # ZERO-FILL PARAMETER BLOCK # END # **** PROC KDSM - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMDECKS # *CALL COMBFAS *CALL COMBCPR *CALL COMBFET *CALL COMBHFC *CALL COMBKDA *CALL COMBKDD *CALL COMBLRQ *CALL COMBUCR *CALL COMBTDM *CALL COMBUDT *CALL COMXCTF *CALL COMXHLR *CALL COMXIPR *CALL COMXLTC *CALL COMXMSC ITEM INTSM I; # INTEGER SM ID # # * ARRAY TO HOLD MESSAGE TEXT FOR LEFT SCREEN LINE. # ARRAY TEXT [0:0] S(7); # HOLDS MESSAGE FOR LEFT SCREEN # BEGIN ITEM TEXT$WDS C(00,00,60); ITEM TEXT$ZER C(06,00,60) = [0]; # ZERO-BYTE TERMINATOR # END # * ARRAY TO BUFFER JSN HEADER TO STOP FLICKER. # ARRAY HEADERBUF [0:0] S(6); # HOLDS BLANKS OR HEADER # BEGIN ITEM HB$LINE C(00,00,52); END CONTROL EJECT; ZFILL(KSMPARMS,SMPARMLEN); # CLEAR SM PARAMETER BLOCK # KSMDISP = TRUE; # CONSIDER SM DISPLAY IN BUFFER # # * BUILD *KSM1* MESSAGE LINE (LINE 5 IN K-DISPLAY SHOWN ABOVE) * TO REFLECT THE STATUS OF THE SM. * * THE SM MAY BE ON, OFF, OR IN MAINTENANCE MODE. # P = LOC(KSM$WORD[0]) - 1; # POINT TO PARAMETER BLOCK # KP$SM = KSMID; # SET SM IDENTIFIER # KP$NF = "OFF "; # DEFAULT SM STATUS # KP$MA = " "; # IN CASE "E" FROM "MAINT" # INTSM = KUDTIND; # SET UDT INDEX FOR PROCESSING # IF SM$ON[INTSM] ## AND NOT SM$ON$ACK[INTSM] # NOT CHANGING STATUS # THEN # SM MAY BE ON # BEGIN # CHECK # IF NOT INITIALIZE THEN # SM IS ON AND IDLE # BEGIN # ON # KP$NF = "ON "; END # ON # ELSE # SM MAY NOT YET BE ON # BEGIN # INIT # IF SM$CUO0[INTSM] NQ 0 THEN # FIRST CU CONNECTED TO SM # BEGIN # 1ST # P = LOC(UD$MSG[SM$CUO0[INTSM]]); IF MS$MSG[0] GQ HFC$CHSCIF ## AND MS$MSG[0] LQ HFC$CHSDIO THEN # SM TURNED ON IN INIT # BEGIN # ON # KP$NF = "ON "; END # ON # END # 1ST # IF SM$CUO1[INTSM] NQ 0 THEN # SECOND CU CONNECTED TO SM # BEGIN # 2ND # P = LOC(UD$MSG[SM$CUO1[INTSM]]); IF MS$MSG[0] GQ HFC$CHSCIF ## AND MS$MSG[0] LQ HFC$CHSDIO THEN # SM TURNED ON IN INIT # BEGIN # ON # KP$NF = "ON "; END # ON # END # 2ND # END # INIT # END # CHECK # IF SM$DIAG[INTSM] ## AND NOT SM$DAG$ACK[INTSM] # NOT CHANGING STATUS # THEN # SM IS IN MAINTENANCE MODE # BEGIN # MAINT # KP$NF = "MAINTENANC"; KP$MA = "E"; # REQUIRES 2 PARAMETERS # END # MAINT # TEXT$WDS[0] = KSM1; KPFILL(TEXT[0], LOC(KSM$WORD[0])); KL$LINE[LF$SMINFO] = TEXT$WDS[0]; # MSG --> DISPLAY BUFFER # # * BUILD *KSM2* AND *KSM3* MESSAGES (LINES 6 AND 7 IN K-DISPLAY) # KP$ND = SM$STNUM[INTSM]; TEXT$WDS[0] = KSM2; KPFILL(TEXT[0], LOC(KSM$WORD[0])); KL$LINE[LF$SMINFO+1] = TEXT$WDS[0]; # MSG --> DISPLAY BUFFER# KP$ND = SM$DSNUM[INTSM]; TEXT$WDS[0] = KSM3; KPFILL(TEXT[0], LOC(KSM$WORD[0])); KL$LINE[LF$SMINFO+2] = TEXT$WDS[0]; # MSG --> DISPLAY BUFFER# KL$LINE[LF$SMINFO+3] = " "; # BLANK LINE --> BUFFER # HB$LINE[0] = " "; # ASSUME NO STAGING OR DESTAGING # # * BUILD TEXT LINE TO REFLECT STATUS OF UPPER DRD. * * THE DRD MAY BE OFF, IDLE, ACTIVE WITH A STAGE OR DESTAGE, * IN USE BY A UTILITY, OR IN MAINTENANCE MODE. * * IF ACTIVE, PROCESSING INFORMATION SUCH AS FILE NAME, PRU COUNT, * USER INDEX, AND JOB NAME, IS RETRIEVED FROM THE HLRQ, * TDAM ENTRY, AND DISK FET. # KP$DD = D0$SUN[INTSM]; # SET DRD NUMBER FOR NEXT MESSAGE # IF D0$ON$ACK[INTSM] # DRD CHANGING STATUS # OR D0$LLADR[INTSM] EQ 0 # DRD NOT YET ACCESSED # OR NOT D0$ON[INTSM] THEN # DRD IS OFF OR IN MAINT MODE # BEGIN # NOT ON # IF D0$DIAG[INTSM] ## AND NOT D0$DAG$ACK[INTSM] THEN # DRD IN MAINTENANCE MODE # BEGIN # MAINT # TEXT$WDS[0] = KSM10; END # MAINT # ELSE # DRD IS OFF # BEGIN # OFF # TEXT$WDS[0] = KSM8; END # OFF # END # NOT ON # ELSE BEGIN # DRD0 IS ON # P = D0$LLADR[INTSM]; IF LLR$PRCNME[0] EQ REQTYP4"INITHW" # DRD TURNING ON # OR LLR$RQI[0] EQ REQNAME"RQIAUCP" # ABORTED UCP # OR NOT D0$FULL[INTSM] THEN # DRD NOT IN USE # BEGIN # DRD0 IS IDLE # TEXT$WDS[0] = KSM9; END ELSE BEGIN # DRD0 IS ACTIVE - BUILD STATUS LINE # IF LLR$RQI[0] NQ REQNAME"RQIINT" # NOT STAGE OR DESTAGE # THEN BEGIN # DRD0 PROCESSING UTILITY REQUEST # TEXT$WDS[0] = KSM7; END ELSE # DRD0 PROCESSING STAGE/DESTAGE REQUEST # BEGIN # GET HLRQ AND TDAM VALUES FOR K-DISPLAY# HB$LINE[0] = KSM4; # MOVE HEADER TO BUFFER # P = LLR$UCPRA; P = LOC(HLR$TDAM); P = LLR$DSKFET[0]; KP$FN = TDAMPFN; KP$UI = TDAMUI; IF HLR$HPN EQ HLRPN"STAGE" THEN BEGIN # STAGE MESSAGE NEEDED # TEXT$WDS[0] = KSM5; KP$PU = FET$CRI[0] + HLR$PRU[0]; # STAGING DIFFERENT # KP$JN = TDAMJSN; END ELSE BEGIN # DESTAGE MESSAGE NEEDED # TEXT$WDS[0] = KSM6; KP$PU = FET$CRI[0]; KP$JN = LTC$SFJBSN[DSC$LTCT]; END IF P EQ 0 THEN # GET SAVED PRU COUNT # BEGIN # SAVED # KP$PU = HLR$PRU[0]; END # SAVED # END # GET HLRQ AND TDAM VALUES FOR K-DISPLAY # END # DRD0 IS ACTIVE - BUILD STATUS LINE # END # DRD0 IS ON # KPFILL(TEXT[0],LOC(KSM$WORD[0])); KL$LINE[LF$SMDRD0] = TEXT$WDS[0]; # * BUILD TEXT LINE TO REFLECT STATUS OF LOWER DRD. * # KP$DD = D1$SUN[INTSM]; # SET DRD NUMBER FOR NEXT MESSAGE # IF D1$ON$ACK[INTSM] # DRD CHANGING STATUS # OR D1$LLADR[INTSM] EQ 0 # DRD NOT YET ACCESSED # OR NOT D1$ON[INTSM] THEN # DRD IS OFF OR IN MAINT MODE # BEGIN # NOT ON # IF D1$DIAG[INTSM] ## AND NOT D1$DAG$ACK[INTSM] THEN # DRD IN MAINTENANCE MODE # BEGIN # MAINT # TEXT$WDS[0] = KSM10; END # MAINT # ELSE # DRD IS OFF # BEGIN # OFF # TEXT$WDS[0] = KSM8; END # OFF # END # NOT ON # ELSE BEGIN # DRD1 IS ON # P = D1$LLADR[INTSM]; IF LLR$PRCNME[0] EQ REQTYP4"INITHW" # DRD TURNING ON # OR LLR$RQI[0] EQ REQNAME"RQIAUCP" # ABORTED UCP # OR NOT D1$FULL[INTSM] THEN # DRD NOT IN USE # BEGIN # DRD1 IS IDLE # TEXT$WDS[0] = KSM9; END ELSE BEGIN # DRD1 IS ACTIVE - BUILD STATUS LINE # IF LLR$RQI[0] NQ REQNAME"RQIINT" # NOT STAGE OR DESTAGE # THEN BEGIN # DRD1 PROCESSING UTILITY REQUEST # TEXT$WDS[0] = KSM7; END ELSE # DRD1 PROCESSING STAGE/DESTAGE REQUEST # BEGIN # GET HLRQ AND TDAM VALUES FOR K-DISPLAY# HB$LINE[0] = KSM4; # MOVE HEADER TO BUFFER # P = LLR$UCPRA; P = LOC(HLR$TDAM); P = LLR$DSKFET[0]; KP$FN = TDAMPFN; KP$UI = TDAMUI; IF HLR$HPN EQ HLRPN"STAGE" THEN BEGIN # STAGE MESSAGE NEEDED # TEXT$WDS[0] = KSM5; KP$PU = FET$CRI[0] + HLR$PRU[0]; # STAGING DIFFERENT # KP$JN = TDAMJSN; END ELSE BEGIN # DESTAGE MESSAGE NEEDED # TEXT$WDS[0] = KSM6; KP$PU = FET$CRI[0]; KP$JN = LTC$SFJBSN[DSC$LTCT]; END IF P EQ 0 THEN # GET SAVED PRU COUNT # BEGIN # SAVED # KP$PU = HLR$PRU[0]; END # SAVED # END # GET HLRQ AND TDAM VALUES FOR K-DISPLAY # END # DRD1 IS ACTIVE - BUILD STATUS LINE # END # DRD1 IS ON # KPFILL(TEXT[0],LOC(KSM$WORD[0])); KL$LINE[LF$SMDRD1] = TEXT$WDS[0]; KL$LINE[LF$SMINFO+4] = HB$LINE[0]; # DISPLAY BUFFER CONTENTS # RETURN; END # KDSM # TERM PROC KFILES(REJECT); # TITLE KFILES - PROCESS *K* DISPLAY *FILES* COMMAND. # BEGIN # KFILES # # ** KFILES - PROCESS *K* DISPLAY *FILES* COMMAND. * * *KFILES* PROCESSES THE OPERATOR COMMAND, *FILES,N*, WHERE * *N* IS THE REQUESTED NUMBER OF LARGE STREAMING BUFFERS TO * BE AUTHORIZED. * * PROC KFILES(REJECT) * * ENTRY ARRAY KBINPUT (DEFINED IN *COMBKDA*) CONTAINS THE * IMAGE OF THE *FILES* REQUEST. * * EXIT (REJECT) - REJECT OPERATOR RESPONSE FLAG. * = TRUE, INCORRECT REPONSE OR COMMAND. * = FALSE, VALID RESPONSE OR COMMAND. * * MESSAGES * VALUE OF X USED ON *FILES* COMMAND.*. * (DISPLAYED ON *K* DISPLAY REJECT LINE, IF THE * ORDINAL SPECIFIED WAS OUT OF RANGE AND A VALUE * OF *X* WAS ASSUMED.) # ITEM REJECT B; # REJECT OPERATOR RESPONSE FLAG # # **** PROC KFILES - XREF LIST BEGIN. # XREF BEGIN FUNC XCDD I; # CONVERT TO DECIMAL DISPLAY # FUNC XDXB I; # CONVERT DISPLAY TO INTEGER # END # **** PROC KFILES - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMDECKS # *CALL COMBFAS *CALL COMBKDA *CALL COMBKDD *CALL COMBUDT *CALL COMXBST *CALL COMXCTF ITEM I U; # INDUCTION VARIABLE # ITEM ORDINAL I; # REQUESTED *FILES* ORDINAL # ITEM STAT I; # CONVERSION STATUS VALUE # ARRAY MSG [0:0] S(4); # HOLDS INFORMATIVE MESSAGE # BEGIN ITEM MSG$LINE C(00,00,40) # FULL MESSAGE LINE # = [" VALUE OF X USED ON *FILES* COMMAND."]; ITEM MSG$ORD C(01,00,01); # ORDINAL DISPLAYED # END CONTROL EJECT; # * CHECK FOR VALID NUMERIC ORDINAL. # REJECT = FALSE; STAT = XDXB(KB$FILEORD[0],1,ORDINAL); IF STAT NQ 0 THEN BEGIN REJECT = TRUE; RETURN; END # * CHECK FOR AN OUT OF RANGE ORDINAL. IF THE SPECIFIED ORDINAL * IS LESS THAN 1, ASSUME 1. IF IT IS GREATER THAN THE NUMBER * OF *MASSTOR CONTROLLERS* TIMES CHANNELS ON EACH CONTROLLER, * A VALUE OF *MAX$ACHN* IS USED. # IF ORDINAL LS 1 THEN # USE MINIMUM VALUE # BEGIN ORDINAL = 1; MSG$ORD[0] = "1"; KL$LINE[LF$KBREJ] = MSG$LINE[0]; # INFORMATIVE MESSAGE # END IF ORDINAL GR MAX$ACHN THEN # USE MAXIMUM VALUE # BEGIN ORDINAL = MAX$ACHN; MSG$ORD[0] = XCDD(MAX$ACHN); KL$LINE[LF$KBREJ] = MSG$LINE[0]; # INFORMATIVE MESSAGE # END # * CHANGE THE NUMBER OF AUTHORIZED BUFFERS, AS REQUIRED, SO THAT * *ORDINAL* BUFFERS ARE NOW AUTHORIZED. # FASTFOR I = 1 STEP 1 UNTIL BSTL DO BEGIN BST$AUTH[I] = I LQ ORDINAL; END END # KFILES # TERM PROC KINIT; # TITLE KINIT - *K* DISPLAY INITIALIZATION. # BEGIN # KINIT # # ** KINIT - *K* DISPLAY INTIALIZATION. * * *KINIT* ISSUES THE *CONSOLE* MACRO TO ACTIVATE THE * *K* DISPLAY AND INITIALIZES THE *K* DISPLAY BUFFERS. * * PROC KINIT. * * EXIT THE *CONSOLE* MACRO IS ISSUED. * THE TITLE IS PLACED IN THE LEFT SCREEN BUFFER. * THE *B* DISPLAY LINE 2 IS CLEARED. * * MESSAGES * REQUEST *K* DISPLAY * (FROM *CONSOLE* MACRO). * * NOTES CLEARS LINE 2 OF THE *B* DISPLAY AFTER ISSUING * THE *CONSOLE* MACRO TO ERASE THE "REQUEST *K* DISPLAY" * MESSAGE. THE *KPROC* AND *KREQ* ROUTINES ISSUE THE * REQUEST-K MESSAGE AS NEEDED. # # **** PROC KINIT - XREF LIST BEGIN. # XREF BEGIN PROC CONSOLE; # ISSUE *CONSOLE* MACRO # PROC MESSAGE; # ISSUE *MESSAGE* MACRO # END # **** PROC KINIT - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBKDA *CALL COMBKDD # * CONSOLE MACRO PARAMETER ARRAY. # ARRAY CPARAM [0:0] S(1); # CONSOLE PARAMETER # BEGIN ITEM CP$KBADDR U(00,00,24); # KEYBOARD ADDRESS # ITEM CP$KLADDR U(00,42,18); # LEFT SCREEN ADDRESS # END CONTROL EJECT; # * SET UP AND ISSUE THE CONSOLE MACRO. # CP$KBADDR[0] = LOC(KBINPUT[0]); CP$KLADDR[0] = LOC(KLEFTSCRN[0]); CONSOLE(CPARAM[0]); # * CLEAR REQUEST-K MESSAGE ON *B* DISPLAY. # MESSAGE(BZEROES,LINE2); KL$COMP[0] = FALSE; KREQCLEAR = TRUE; # * SET UP TITLE LINE IN LEFT SCREEN BUFFER. # KL$LINE[LF$TITLE] = TITLELINE; KL$LINE[LF$TITLEDIS] = DISPSIT; # * SET UP *VALID COMMANDS* MENU IN LEFT SCREEN BUFFER. # KL$LINE[LF$VALCMD] = VALIDCMD; KL$LINE[LF$VALCMD+1] = KXGOLINE; KL$LINE[LF$VALCMD+2] = STDSLINE; KL$LINE[LF$VALCMD+3] = SMLINE; KL$LINE[LF$VALCMD+4] = STLINE; KL$LINE[LF$VALCMD+5] = DSLINE; KSMDISP = FALSE; # *SM* DISPLAY NOT ON LEFT SCREEN # KSMID = "A"; # PRESET DEFAULT FOR SM DISPLAY # END # KINIT # TERM PROC KINPUT; # TITLE KINPUT - KEYBOARD INPUT. # BEGIN # KINPUT # # ** KINPUT - KEYBOARD INPUT. * * *KINPUT* PROCESSES THE OPERATOR RESPONSES OR COMMANDS. * * PROC KINPUT. * * ENTRY ARRAY KBINPUT - KEYBOARD BUFFER. * * EXIT FOR A VALID OPERATOR RESPONSE - * THE *KWORD* REQUEST (IF IT IS STILL AVAILABLE) * IS COMPLETED AND DELINKED. * THE LEFT SCREEN AREA FOR THE RESPONSE IS CLEARED. * * FOR A VALID OPERATOR COMMAND - * THE DEFINED PROCESSING IS DONE. * * FOR AN INCORRECT OPERATOR TYPE-IN - * THE TYPE-IN IS DISPLAYED IN THE ECHO LINE OF THE * LEFT SCREEN. * THE *** REJECT *** IS DISPLAYED IN THE REJECT LINE. * * ARRAY KBINPUT - KEYBOARD BUFFER CLEARED. * * NOTES RESPONSES ARE IN THE FORM - N.WORD * WHERE N IS AN ORDINAL ON THE LEFT SCREEN, * AND WORD IS *GO* OR *DROP*. * * COMMANDS ARE - *FILES,NN*. * * A BLANK IS ACCEPTED AND CLEARS ANY OUTSTANDING * REJECT MESSAGE. # # **** PROC KINPUT - XREF LIST BEGIN. # XREF BEGIN PROC ADD$LNK; # ADD ENTRY TO LINK # PROC DEL$LNK; # DELETE ENTRY FROM LINK # PROC KCLR; # CLEAR CURRENT REQUEST # PROC KFILES; # PROCESS *FILES* COMMAND # PROC KREQ; # *K* DISPLAY REQUEST # PROC KSM; # PROCESS *SMI* COMMAND # FUNC XDXB I; # CONVERT DISPLAY CODE TO INTEGER # PROC ZFILL; # ZERO FILL BUFFER # END # **** PROC KINPUT - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBCHN *CALL COMBKDA *CALL COMBKDD *CALL COMBTDM *CALL COMXCTF ITEM CH I; # CHARACTER INDEX # ITEM CHAR C(1); # CHARACTER # ITEM COMMAND C(10); # OPERATOR COMMAND # ITEM I I; # TEMPORARY CELL # ITEM LINK U; # ADDRESS OF NEW CHAIN ENTRY # ITEM ORD I; # ORDINAL # ITEM REJECT B; # REJECT RESPONSE FLAG # ITEM RTDADR U; # *RTRQ* ADDRESS # CONTROL EJECT; KL$LINE[LF$KBREJ] = " "; # CLEAR REJECT LINE # KL$LINE[LF$KBECHO] = " "; # CLEAR ECHO LINE # # * CRACK THE KEYBOARD INPUT. DETERMINE IF INPUT IS - * . AN OPERATOR RESPONSE - N.COMMAND. * . AN OPERATOR COMMAND - COMMAND,PARAMETER. # REJECT = FALSE; # INITIALIZE # COMMAND = " "; CH = 0; CHAR = C<0,1>KB$SCAN[0]; # GET FIRST CHARACTER # I = XDXB(CHAR,0,ORD); IF I EQ 0 AND ORD GQ 1 AND ORD LQ 9 THEN # ORDINAL # BEGIN # CHECK ORDINAL # IF C<1,1>KB$SCAN[0] NQ "." THEN # NO PERIOD FOLLOWS # BEGIN ORD = 0; # REJECT THE ORDINAL # END IF ORD GR KORD THEN # INCORRECT ORDINAL # BEGIN ORD = 0; # REJECT THE ORDINAL # END END # CHECK ORDINAL # IF ORD NQ 0 THEN # ORDINAL DETECTED AND GOOD # BEGIN CH = 2; # ADVANCE SCAN PAST ORDINAL # END # * GET COMMAND ( MAXIMUM OF 10 CHARACTERS ). * SCAN TO FIRST NON-ALPHANUMERIC. # C<0,1>COMMAND = CKB$SCAN[0]; # PRESET WITH FIRST CHAR # SLOWFOR I = 1 STEP 1 WHILE I LQ 9 ## AND CKB$SCAN[0] GQ "A" # VALID CHARACTER FOUND # AND CKB$SCAN[0] LQ "9" DO BEGIN CCOMMAND = CKB$SCAN[0]; END # * PROCESS THE OPERATOR RESPONSE. # IF ORD NQ 0 THEN # FORM IS N.COMMAND # BEGIN # PROCESS OPERATOR RESPONSE # # * GET *KCURRENT* FOR THE ORDINAL. # P = LOC(KCUR$WD[ORD]); # *KCURRENT* ENTRY # IF KCUR$WD[ORD] EQ 0 THEN # NO REQUEST ACTIVE # BEGIN REJECT = TRUE; # REJECT RESPONSE # END IF KCUR$ADDR[ORD] NQ 0 THEN # PLACE REPLY IN *KWORD* OF THE CALLER # BEGIN P = KCUR$ADDR[ORD]; # *KWORD* REQUEST # END # * COMMAND IS "GO" AND GO IS VALID. # IF COMMAND EQ "GO" AND KW$RPGO[0] THEN BEGIN KW$OPGO[0] = TRUE; END # * COMMAND IS "DROP" AND DROP IS VALID. # IF COMMAND EQ "DROP" AND KW$RPDROP[0] THEN BEGIN KW$OPDROP[0] = TRUE; END # * IF NO VALID RESPONSE, REJECT IT. # IF KW$OP[0] EQ 0 THEN BEGIN REJECT = TRUE; # REJECT # END # * IF RESPONSE WAS VALID, CLEAR THE MESSAGES FOR THAT ORDINAL * FROM THE LEFT SCREEN BUFFER AND DELINK THE REQUEST. # IF NOT REJECT THEN BEGIN KCLR(ORD); # CLEAR FROM DISPLAY # KREQ(P,KDELINK); # DELINK FROM QUEUE # END END # PROCESS OPERATOR RESPONSE # # * PROCESS THE OPERATOR COMMAND. # ELSE BEGIN # PROCESS OPERATOR COMMAND # REJECT = TRUE; # ASSUME WRONG # # * COMMAND IS "FILES". # IF COMMAND EQ "FILES" THEN BEGIN KFILES(REJECT); END # * COMMAND IS "SMI" OR * "SMI,DRD=ST=N " OR * "SMI,DRD=DS=N" # IF C<0,2>COMMAND EQ "SM" THEN BEGIN # PROCESS *SMI* COMMAND # KSM(REJECT); END # * COMMAND IS *STAGE* OR *DESTAGE*. * TOGGLE DISPLAY AND SET FLAGS. # P = LOC(KL$LINE[LF$TITLE + 1]); IF COMMAND EQ "STAGE" THEN BEGIN IF GLBSTFL THEN BEGIN GLBSTFL = FALSE; DISPOS$ST[0] = "CLOSE"; LINK = CHN$BOC[LCHN"RTD$ACT"]; REPEAT WHILE LINK NQ 0 DO BEGIN # SEARCH *RTRQ* CHAIN # P = LINK + 1; RTDADR = LINK; P = LINK; LINK = LINK$ADR[0]; IF TDAMFC[0] EQ TDAMFCODE"STAGE" THEN BEGIN # REMOVE STAGE *RTRQ* ENTRY # DEL$LNK(RTDADR,LCHN"RTD$ACT",0); ZFILL(TDAM,TDAMLEN); ADD$LNK(RTDADR,LCHN"RTD$FRSPC",0); END END # SEARCH *RTRQ* CHAIN # RTRQ$CT = 0; END ELSE BEGIN GLBSTFL = TRUE; DISPOS$ST[0] = " OPEN"; END REJECT = FALSE; END IF COMMAND EQ "DESTAGE" THEN BEGIN IF GLBDSFL THEN BEGIN GLBDSFL = FALSE; DISPOS$DT[0] = "CLOSE"; END ELSE BEGIN GLBDSFL = TRUE; DISPOS$DT[0] = " OPEN"; END REJECT = FALSE; END # * COMMAND IS BLANKS. ALLOWED TO CLEAR THE REJECT LINE (CLEAN UP). # IF COMMAND EQ " " THEN # CLEAR # BEGIN REJECT = FALSE; END END # PROCESS OPERATOR COMMAND # # * IF RESPONSE WAS INCORRECT, ISSUE REJECT LINE. # IF REJECT THEN # ISSUE REJECT # BEGIN KL$SUBL1[LF$KBREJ] = "*** REJECT ***"; KL$SUBL1[LF$KBECHO] = KB$SCAN[0]; # ISSUE ECHO # END KB$SCAN[0] = " "; # CLEAR KEYBOARD INPUT # KB$CLEAR[0] = 0; RETURN; END # KINPUT # TERM PROC KPFILL(TEXT,(PADDR)); # TITLE KPFILL - *K* PARAMETER FILL ROUTINE. # BEGIN # KPFILL # # ** KPFILL - PARAMETER FILL ROUTINE. * * *KPFILL* INSERTS DEFINED PARAMETERS INTO THE *K* DISPLAY TEXT. * * PROC KPFILL(TEXT,(PADDR)) * * ENTRY (TEXT) - THE *K* DISPLAY TEXT TO SCAN. * (PADDR) - ADDRESS OF THE PARAMETER VALUES. * * EXIT (TEXT) - THE TEXT WITH PARAMETERS INSERTED. * * NOTES THE MAXIMUM SIZE OF A RESULTANT PARAMETER TO INSERT * IN THE TEXT IS 10 CHARACTERS. * THE MAXIMUM SIZE OF THE SCANNED TEXT IS 60 CHARACTERS. # ITEM TEXT C(60); # TEXT # ITEM PADDR I; # ADDRESS OF PARAMETER # # **** PROC KPFILL - XREF LIST BEGIN. # XREF BEGIN PROC BZFILL; # BLANK OR ZERO FILL # FUNC XCDD C(10); # CONVERT TO DECIMAL DISPLAY # FUNC XCOD C(10); # CONVERT TO OCTAL DISPLAY # END # **** PROC KPFILL - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL,COMBBZF *CALL COMBKDD ITEM CHAR C(1); # CHARACTER FIELD # ITEM FR I; # FROM INDEX # ITEM I I; # TEMPORARY # ITEM PCODE C(2); # PARAMETER CODE # ITEM PI I; # PARAMETER INDEX # ITEM PRESULT C(10); # PARAMETER RESULT # ITEM TCOPY C(60); # COPY OF TEXT # ITEM TO I; # TO INDEX # # * PARAMETER WORK AREA. # ARRAY PARWK [0:0] S(1); BEGIN ITEM PFIELDI I(00,00,60); # PARAMETER DEFINED AS INTEGER # ITEM PFIELDC C(00,00,10); # PARAMETER REDEFINED CHARACTER # END # * TO ACCESS THE CALLERS PARAMETER WORD(S). # BASED ARRAY PARAMETER [0:0] S(1); BEGIN ITEM PARAM$WD U(00,00,60); END # * ARRAY OF DEFINED PARAMETERS FOR *K* DISPLAY MESSAGE TEXTS. * PARAMETERS ARE DEFINED IN *COMBKDD*. # ARRAY KPAR [1:1] S(KPNUM); BEGIN ITEM P1 C(00,00,02) = [ P1C ]; ITEM P1FW U(00,12,06) = [ P1W ]; ITEM P1FB U(00,18,06) = [ P1B ]; ITEM P1FL U(00,24,06) = [ P1L ]; ITEM P1CT U(00,30,06) = [ P1T ]; ITEM P1TS U(00,36,06) = [ P1S ]; ITEM P2 C(01,00,02) = [ P2C ]; ITEM P2FW U(01,12,06) = [ P2W ]; ITEM P2FB U(01,18,06) = [ P2B ]; ITEM P2FL U(01,24,06) = [ P2L ]; ITEM P2CT U(01,30,06) = [ P2T ]; ITEM P2TS U(01,36,06) = [ P2S ]; ITEM P3 C(02,00,02) = [ P3C ]; ITEM P3FW U(02,12,06) = [ P3W ]; ITEM P3FB U(02,18,06) = [ P3B ]; ITEM P3FL U(02,24,06) = [ P3L ]; ITEM P3CT U(02,30,06) = [ P3T ]; ITEM P3TS U(02,36,06) = [ P3S ]; ITEM P4 C(03,00,02) = [ P4C ]; ITEM P4FW U(03,12,06) = [ P4W ]; ITEM P4FB U(03,18,06) = [ P4B ]; ITEM P4FL U(03,24,06) = [ P4L ]; ITEM P4CT U(03,30,06) = [ P4T ]; ITEM P4TS U(03,36,06) = [ P4S ]; ITEM P5 C(04,00,02) = [ P5C ]; ITEM P5FW U(04,12,06) = [ P5W ]; ITEM P5FB U(04,18,06) = [ P5B ]; ITEM P5FL U(04,24,06) = [ P5L ]; ITEM P5CT U(04,30,06) = [ P5T ]; ITEM P5TS U(04,36,06) = [ P5S ]; ITEM P6 C(05,00,02) = [ P6C ]; ITEM P6FW U(05,12,06) = [ P6W ]; ITEM P6FB U(05,18,06) = [ P6B ]; ITEM P6FL U(05,24,06) = [ P6L ]; ITEM P6CT U(05,30,06) = [ P6T ]; ITEM P6TS U(05,36,06) = [ P6S ]; ITEM P7 C(06,00,02) = [ P7C ]; ITEM P7FW U(06,12,06) = [ P7W ]; ITEM P7FB U(06,18,06) = [ P7B ]; ITEM P7FL U(06,24,06) = [ P7L ]; ITEM P7CT U(06,30,06) = [ P7T ]; ITEM P7TS U(06,36,06) = [ P7S ]; ITEM P8 C(07,00,02) = [ P8C ]; ITEM P8FW U(07,12,06) = [ P8W ]; ITEM P8FB U(07,18,06) = [ P8B ]; ITEM P8FL U(07,24,06) = [ P8L ]; ITEM P8CT U(07,30,06) = [ P8T ]; ITEM P8TS U(07,36,06) = [ P8S ]; ITEM P9 C(08,00,02) = [ P9C ]; ITEM P9FW U(08,12,06) = [ P9W ]; ITEM P9FB U(08,18,06) = [ P9B ]; ITEM P9FL U(08,24,06) = [ P9L ]; ITEM P9CT U(08,30,06) = [ P9T ]; ITEM P9TS U(08,36,06) = [ P9S ]; ITEM P10 C(09,00,02) = [ P10C ]; ITEM P10FW U(09,12,06) = [ P10W ]; ITEM P10FB U(09,18,06) = [ P10B ]; ITEM P10FL U(09,24,06) = [ P10L ]; ITEM P10CT U(09,30,06) = [ P10T ]; ITEM P10TS U(09,36,06) = [ P10S ]; ITEM P11 C(10,00,02) = [ P11C ]; ITEM P11FW U(10,12,06) = [ P11W ]; ITEM P11FB U(10,18,06) = [ P11B ]; ITEM P11FL U(10,24,06) = [ P11L ]; ITEM P11CT U(10,30,06) = [ P11T ]; ITEM P11TS U(10,36,06) = [ P11S ]; ITEM P12 C(11,00,02) = [ P12C ]; ITEM P12FW U(11,12,06) = [ P12W ]; ITEM P12FB U(11,18,06) = [ P12B ]; ITEM P12FL U(11,24,06) = [ P12L ]; ITEM P12CT U(11,30,06) = [ P12T ]; ITEM P12TS U(11,36,06) = [ P12S ]; ITEM P13 C(12,00,02) = [ P13C ]; ITEM P13FW U(12,12,06) = [ P13W ]; ITEM P13FB U(12,18,06) = [ P13B ]; ITEM P13FL U(12,24,06) = [ P13L ]; ITEM P13CT U(12,30,06) = [ P13T ]; ITEM P13TS U(12,36,06) = [ P13S ]; ITEM P14 C(13,00,02) = [ P14C ]; ITEM P14FW U(13,12,06) = [ P14W ]; ITEM P14FB U(13,18,06) = [ P14B ]; ITEM P14FL U(13,24,06) = [ P14L ]; ITEM P14CT U(13,30,06) = [ P14T ]; ITEM P14TS U(13,36,06) = [ P14S ]; ITEM P15 C(14,00,02) = [ P15C ]; ITEM P15FW U(14,12,06) = [ P15W ]; ITEM P15FB U(14,18,06) = [ P15B ]; ITEM P15FL U(14,24,06) = [ P15L ]; ITEM P15CT U(14,30,06) = [ P15T ]; ITEM P15TS U(14,36,06) = [ P15S ]; ITEM P16 C(15,00,02) = [ P16C ]; ITEM P16FW U(15,12,06) = [ P16W ]; ITEM P16FB U(15,18,06) = [ P16B ]; ITEM P16FL U(15,24,06) = [ P16L ]; ITEM P16CT U(15,30,06) = [ P16T ]; ITEM P16TS U(15,36,06) = [ P16S ]; ITEM P17 C(16,00,02) = [ P17C ]; ITEM P17FW U(16,12,06) = [ P17W ]; ITEM P17FB U(16,18,06) = [ P17B ]; ITEM P17FL U(16,24,06) = [ P17L ]; ITEM P17CT U(16,30,06) = [ P17T ]; ITEM P17TS U(16,36,06) = [ P17S ]; ITEM P18 C(17,00,02) = [ P18C ]; ITEM P18FW U(17,12,06) = [ P18W ]; ITEM P18FB U(17,18,06) = [ P18B ]; ITEM P18FL U(17,24,06) = [ P18L ]; ITEM P18CT U(17,30,06) = [ P18T ]; ITEM P18TS U(17,36,06) = [ P18S ]; ITEM P19 C(18,00,02) = [ P19C ]; ITEM P19FW U(18,12,06) = [ P19W ]; ITEM P19FB U(18,18,06) = [ P19B ]; ITEM P19FL U(18,24,06) = [ P19L ]; ITEM P19CT U(18,30,06) = [ P19T ]; ITEM P19TS U(18,36,06) = [ P19S ]; ITEM P20 C(19,00,02) = [ P20C ]; ITEM P20FW U(19,12,06) = [ P20W ]; ITEM P20FB U(19,18,06) = [ P20B ]; ITEM P20FL U(19,24,06) = [ P20L ]; ITEM P20CT U(19,30,06) = [ P20T ]; ITEM P20TS U(19,36,06) = [ P20S ]; ITEM P21 C(20,00,02) = [ P21C ]; ITEM P21FW U(20,12,06) = [ P21W ]; ITEM P21FB U(20,18,06) = [ P21B ]; ITEM P21FL U(20,24,06) = [ P21L ]; ITEM P21CT U(20,30,06) = [ P21T ]; ITEM P21TS U(20,36,06) = [ P21S ]; ITEM P22 C(21,00,02) = [ P22C ]; ITEM P22FW U(21,12,06) = [ P22W ]; ITEM P22FB U(21,18,06) = [ P22B ]; ITEM P22FL U(21,24,06) = [ P22L ]; ITEM P22CT U(21,30,06) = [ P22T ]; ITEM P22TS U(21,36,06) = [ P22S ]; ITEM P23 C(22,00,02) = [ P23C ]; ITEM P23FW U(22,12,06) = [ P23W ]; ITEM P23FB U(22,18,06) = [ P23B ]; ITEM P23FL U(22,24,06) = [ P23L ]; ITEM P23CT U(22,30,06) = [ P23T ]; ITEM P23TS U(22,36,06) = [ P23S ]; END # * TO ACCESS THE PARAMETERS DEFINED IN THE ARRAY *KPAR*. # BASED ARRAY PARTABLE [0:0] S(1); # PARAMETER TABLE # BEGIN ITEM PAR$CDE C(00,00,02); # CODE # ITEM PAR$FWD U(00,12,06); # FROM WORD OFFSET # ITEM PAR$FBIT U(00,18,06); # FROM STARTING BIT # ITEM PAR$FLEN U(00,24,06); # FROM LENGTH IN BITS # ITEM PAR$CONV U(00,30,06); # CONVERSION TYPE # ITEM PAR$TSIZ U(00,36,06); # TO SIZE IN CHARACTERS # END CONTROL EJECT; P = LOC(KPAR); # TABLE OF DEFINED PARAMETERS # P = PADDR; # PARAMETER VALUES # TCOPY = " "; # CLEAR TCOPY # TO = 0; # TO INDEX # FR = 0; # FROM INDEX # # * MOVE FROM *TEXT* TO *TCOPY* ONE CHARACTER AT A TIME. IF * A PARAMETER CODE (*CODE*) IS DETECTED, MOVE THE PARAMETER * AS DEFINED IN *PARTABLE* INTO THE *TCOPY*. # REPEAT WHILE TO LS 60 AND FR LS 60 DO BEGIN # TRANSFER *K* DISPLAY TEXT # CHAR = CTEXT; # GET CHARACTER # IF CHAR NQ "*" THEN # MOVE CHARACTER INTO TEXT # BEGIN CTCOPY = CHAR; TO = TO + 1; # ADVANCE *TO* # FR = FR + 1; # ADVANCE *FROM* # TEST DUMMY; END PCODE = CTEXT; # GET PARAMETER CODE # # * SEARCH PARAMETER TABLE FOR MATCH ON PARAMETER CODE. * DO SPECIFIED CONVERSION, IF ANY, AND MOVE * PARAMETER INTO MESSAGE TEXT. # FOR PI = 0 STEP 1 WHILE PI LS KPNUM DO BEGIN # PROCESS PARAMETER # IF PAR$CDE[PI] NQ PCODE THEN BEGIN TEST PI; END # * GET PARAMETER VALUE. # I = PAR$FWD[PI]; # WORD OFFSET # PFIELDI[0] = BPARAM$WD[I]; # * CONVERT TO CHARACTER DISPLAY IF SPECIFIED. # IF PAR$CONV[PI] EQ ALF THEN BEGIN # ALF # PRESULT = PFIELDC[0]; BZFILL(PRESULT,TYPFILL"BFILL",10); # BLANK FILL PARAM # END # ALF # # * CONVERT TO DECIMAL DISPLAY IF SPECIFIED. # IF PAR$CONV[PI] EQ DEC THEN BEGIN PRESULT = XCDD(PFIELDI[0]); END # * CONVERT TO OCTAL DISPLAY IF SPECIFIED. # IF PAR$CONV[PI] EQ OCTL THEN BEGIN PRESULT = XCOD(PFIELDI[0]); END # * MOVE PARAMETER VALUE INTO TEXT. # CTCOPY = ## C<10-PAR$TSIZ[PI],PAR$TSIZ[PI]>PRESULT; TO = TO + PAR$TSIZ[PI]; FR = FR + 3; # ADVANCE PAST PARAMETER CODE # TEST DUMMY; END # PROCESS PARAMETER # END # TRANSFER *K* DISPLAY TEXT # TEXT = TCOPY; # RETURN NEW TEXT # END # KPFILL # TERM PROC KPROC; # TITLE KPROC - *K* DISPLAY PROCESSOR. # BEGIN # KPROC # # ** KPROC - *K* DISPLAY PROCESSOR. * * *KPROC* DETERMINES IF THERE IS ANY WORK TO DO FOR THE * *K* DISPLAY AND IF SO, CALLS THE *K* DISPLAY OVERLAY. * IT ALSO UPDATES THE *B* DISPLAY REQUEST-K MESSAGE * AS NECESSARY. * * PROC KPROC. * * ENTRY (KACTCOUNT) - NUMBER OF REQUESTS CURRENTLY * IN THE BODY OF THE LEFT SCREEN. * (KLINKQ) - HEAD OF K-QUEUE. * = 0 IF EMPTY. * (KNEWREQ) - FLAG INDICATES NEW REQUESTS EXIST. * (KREQCLEAR) - FLAG TO INDICATE THE REQUEST-K * MESSAGE IS NOT ON THE *B* DISPLAY. * ARRAY KBINPUT - KEYBOARD INPUT BUFFER. * ARRAY KLEFTSCRN - LEFT SCREEN BUFFER. * (KL$COMP) - COMPLETE FLAG IN LEFT SCREEN BUFFER. * = 0 IF *DSD* IS NOT PROCESSING *K*. * = 1 IF *DSD* IS PROCESSING *K*. * * EXIT (KREQCLEAR) - REQUEST-K FLAG. * (KTIMER) - COUNTER TO REFRESH REQUEST-K MESSAGE. * * MESSAGES * REQUEST *K* DISPLAY *. * * NOTES CALLS *K* DISPLAY OVERLAY ONLY IF THERE IS * WORK TO PROCESS. * * REFRESHES THE REQUEST-K MESSAGE ON THE *B* DISPLAY * AS NECESSARY. * * CLEARS THE REQUEST-K MESSAGE AS NECESSARY. * * *DSD* SETS THE *KL$COMP* FLAG IN THE LEFT SCREEN * BUFFER WHILE IT IS PROCESSING THE *K* DISPLAY. # # **** PROC KPROC - XREF LIST BEGIN. # XREF BEGIN FUNC XCDD C(10); # BINARY TO DISPLAY (DECIMAL) # PROC SSOVL; # LOAD OVERLAY # PROC MESSAGE; # ISSUE *MESSAGE* MACRO # PROC RTIME; # GET TIME SINCE LAST DEAD START # END # **** PROC KPROC - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMXCTF *CALL COMXIPR *CALL COMBKDA *CALL COMBKDD *CALL COMXMSC *CALL COMBOVL CONTROL EJECT; # * DETERMINE IF THERE IS WORK TO DO. # P = LOC(KL$LINE[LF$TITLE + 1]); CH$10[0] = XCDD(RTRQ$CT); DISPOS$RTRQ[0] = CH$04[0]; IF KB$CLEAR[0] NQ 0 # CONSOLE INPUT # OR (KACTCOUNT LS KORD AND KNEWREQ) # NEW REQUEST # OR (KSMDISP AND KL$COMP[0]) # SM DISPLAY UP # THEN BEGIN SSOVL(LKDISPLY,0); # LOAD *KDISPLAY* OVERLAY # END # * CLEAR REQUEST-K IF NO ACTIVE DISPLAYS. # IF (KACTCOUNT EQ 0 # NO MESSAGES TO DISPLAY # OR KL$COMP[0]) # MESSAGES BEING DISPLAYED # AND NOT KREQCLEAR # *REQUEST-K* MESSAGE UP # THEN # *REQUEST-K* NO LONGER NEEDED # BEGIN MESSAGE(BZEROES,LINE2); KREQCLEAR = TRUE; # FLAG IT IS CLEAR # END # * REFRESH REQUEST-K MESSAGE ON *B* DISPLAY IF THERE ARE * REQUESTS TO PROCESS BUT THE *K* DISPLAY IS NOT ACTIVE. # IF KACTCOUNT NQ 0 THEN BEGIN # REFRESH (REQUEST *K* DISPLAY) MESSAGE # RTIME(RTIMESTAT[0]); KDIS$EXPIR = RTIMSECS[0] + KDIS$INTV; KTIMER = KTIMER - 1; IF KTIMER LS 0 THEN # TIMER EXPIRED # BEGIN IF NOT KL$COMP[0] THEN # *K* DISPLAY MUST NOT BE ACTIVE # BEGIN MESSAGE("$ REQUEST *K* DISPLAY ",LINE2); KREQCLEAR = FALSE; END KTIMER = KRESET; # RESET TIMER # KL$COMP[0] = FALSE; # SET TOGGLE OFF ( ON BY *DSD* ) # END END # REFRESH (REQUEST *K* DISPLAY) MESSAGE # ELSE # DO NOT KEEP EXEC FROM IDLING # BEGIN # IDLE # KDIS$EXPIR = 0; END # IDLE # # * KEEP EXEC ACTIVE TO REFRESH THE SM DISPLAY * IF IT IS ON THE SCREEN. # IF KSMDISP AND KL$COMP[0] # SM DISPLAY ON SCREEN # THEN # KEEP EXEC ACTIVE # BEGIN # ACTIVE # RTIME(RTIMESTAT[0]); KSM$EXPIR = RTIMSECS[0] + KSM$INTV; KL$COMP[0] = FALSE; # DONE PROCESSING SM DISPLAY # KTIMER = KRESET; # RESET *DSD* TIMER # END # ACTIVE # ELSE # NOTHING UP TO REFRESH # BEGIN # TIMEOUT # KTIMER = KTIMER - 1; # TIMEOUT IN CASE *DSD* SLOW # IF KTIMER LS 0 THEN # DSD NOT PROCESSING SM DISPLAY # BEGIN # IDLE # KSM$EXPIR = 0; # DO NOT FORCE EXEC ACTIVE # END # IDLE # END # TIMEOUT # END # KPROC # TERM PROC KREQ((KWADDR),(RTYP)); # TITLE KREQ - *K* DISPLAY REQUEST. # BEGIN # KREQ # # ** KREQ - *K* DISPLAY REQUEST. * * *KREQ* LINKS A NEW REQUEST TO THE *K* DISPLAY QUEUE * OR DELINKS AN OLD REQUEST FROM THE *K* DISPLAY QUEUE. * * PROC KREQ((KWADDR),(RTYP)) * * ENTRY (KWADDR) - ADDRESS OF *KWORD* ARRAY. * (RTYP) - REQUEST TYPE. * = *KLINK* TO ADD THE REQUEST TO THE QUEUE. * = *KDELINK* TO DELINK THE REQUEST FROM * THE QUEUE. * (KLINKQ) - THE HEAD OF THE K-QUEUE. * * EXIT THE *KWORD* HAS BEEN LINKED/DELINKED. * * FOR A *KLINK*, THE REQUEST-K MESSAGE IS ISSUED AND * (KREQCLEAR) = FALSE, REQUEST-K MESSAGE IS UP. * (KNEWREQ) - IS SET TRUE IF A NEW REQUEST * WAS ADDED. * * FOR A *KDELINK*, THE LEFT SCREEN AREA IS BLANKED * IF THE *KWORD* ENTRY IS CURRENTLY ON THE SCREEN. * * MESSAGES * REQUEST *K* DISPLAY * (IF *KLINK* REQUEST). * * NOTES FOR *KLINK* PROCESSING - * . SKIP THE REQUEST IF IT IS ALREADY IN QUEUE. * . ADD TO END OF K-QUEUE. * . ISSUE THE REQUEST-K MESSAGE. * * FOR *KDELINK* PROCESSING - * . SKIP THIS REQUEST IF IT IS NOT IN THE QUEUE. * . CLEAR THE SCREEN LINES FOR THIS REQUEST IF IT IS * CURRENTLY ACTIVE ON THE LEFT SCREEN. * . SET COMPLETE IN *KWORD* ARRAY. * . DELINK THE REQUEST FROM THE QUEUE. # ITEM KWADDR I; # ADDRESS OF *KWORD* ARRAY # ITEM RTYP I; # REQUEST TYPE # # **** PROC KREQ - XREF LIST BEGIN. # XREF BEGIN PROC KCLR; # CLEAR CURRENT ON *K* DISPLAY # PROC MESSAGE; # ISSUE *MESSAGE* MACRO # END # **** PROC KREQ - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBKDA *CALL COMBKDD *CALL COMXCTF ITEM CURRKW I; # CURRENT *KWORD* ADDRESS # ITEM ORD I; # AN ORDINAL # ITEM PREVKW I; # PREVIOUS *KWORD* ADDRESS # CONTROL EJECT; # * SEARCH K-QUEUE UNTIL END (ZERO) OR A MATCH ON *KWADDR*. * SETS - *PREVKW* = ADDRESS OF PREVIOUS *KWORD* IN QUEUE. * - *CURRKW* = ADDRESS OF CURRENT *KWORD* OR ZERO(END). # CURRKW = LOC(KLINKQ); # START AT HEAD # REPEAT WHILE CURRKW NQ 0 AND CURRKW NQ KWADDR DO BEGIN PREVKW = CURRKW; # SET PREVIOUS # P = CURRKW; CURRKW = KW$LINK[0]; # GET NEXT IN QUEUE # END # * PROCESS THE LINK REQUEST. # IF RTYP EQ KLINK THEN # LINK TO QUEUE # BEGIN # LINK # IF CURRKW NQ 0 THEN # FOUND MATCH IN QUEUE # BEGIN RETURN; # IGNORE THIS REQUEST # END # * INITIALIZE *KWORD* ARRAY FIELDS. # P = KWADDR; KW$KCTL[0] = 0; # CLEAR K-CONTROLLED AREA # KW$LINK[0] = 0; # SET LINK AT END # # * LINK *KWORD* TO END OF QUEUE. # P = PREVKW; KW$LINK[0] = KWADDR; # PREVIOUS POINTS TO NEW # KNEWREQ = TRUE; # * ISSUE THE REQUEST-K MESSAGE. # MESSAGE("$ REQUEST *K* DISPLAY ",LINE2); KREQCLEAR = FALSE; RETURN; # EXIT # END # LINK # # * PROCESS THE DELINK REQUEST. # IF RTYP EQ KDELINK THEN # DELINK FROM QUEUE # BEGIN # DELINK # IF CURRKW EQ 0 THEN # NO MATCH IN QUEUE # BEGIN RETURN; # IGNORE THIS REQUEST # END # * IF REQUEST IS CURRENTLY ACTIVE ON *K* DISPLAY, CLEAR IT. # P = CURRKW; IF KW$ACT[0] THEN # CURRENTLY ON *K* # BEGIN # CLEAR K DISPLAY ENTRY # # * LOOK FOR *KWORD* ENTRY IN *KCURRENT*. # FOR ORD = 1 STEP 1 WHILE ORD LQ KORD DO BEGIN IF KCUR$ADDR[ORD] EQ KWADDR THEN # FOUND MATCH # BEGIN KCLR(ORD); # CLEAR FROM *K* DISPLAY # END END END # CLEAR K DISPLAY ENTRY # # * SET COMPLETE ON THIS REQUEST. # P = KWADDR; KW$COMP[0] = TRUE; DRVRRECALL = TRUE; # SET TO RECALL THE DRIVER # # * DELINK IT FROM QUEUE. # CURRKW = KW$LINK[0]; # NEXT IN QUEUE # P = PREVKW; KW$LINK[0] = CURRKW; # LINK PREVIOUS TO NEXT # RETURN; END # DELINK # END # KREQ # TERM PROC KSM(REJECT); # TITLE KSM - PROCESS *SMI* COMMAND. # BEGIN # KSM # # ** KSM - PROCESS *SMI* COMMAND. * * *KSM* PROCESSES BOTH FORMS OF THE *SM* OPERATOR COMMAND. * THE TWO FORMS OF THE COMMAND ARE: * 1. *SMI*, WHERE *I* IS THE SM IDENTIFIER * * THIS FORM OF THE COMMAND CAUSES INFORMATION FOR THE * SPECIFIED *SM* TO BE DISPLAYED. * * 2. *SMI,DRD=XX=N* * WHERE *I* IS THE *SM* IDENTIFIER * *XX* IS THE LITERAL *ST* (STAGE) OR *DS* (DESTAGE) * *N* IS MAXIMUM NUMBER OF DRDS (0, 1, OR 2) * * THIS FORM OF THE COMMAND CAUSES THE MAXIMUM NUMBER OF * DRDS PERMITTED FOR STAGING (*ST*) OR DESTAGING (*DS*) * TO BE REDEFINED WITH THE SPECIFIED VALUE OF *N* (0, 1, * OR 2). * * PROC KSM(REJECT). * * ENTRY ARRAY KBINPUT (DEFINED IN *COMBKDD*) CONTAINS THE * IMAGE OF THE *SMI* COMMAND. * * EXIT *SM* PORTION OF *K* DISPLAY HAS BEEN UPDATED. * * MESSAGES * * * * # # **** PROC KSM - XREF LIST BEGIN. # XREF BEGIN PROC KDSM; # PAINT *SM* PORTION OF K-DISPLAY # FUNC XDXB I; # CONVERT DISPLAY TO INTEGER # END # **** PROC KSM - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMDECKS # *CALL COMBFAS *CALL COMBKDA *CALL COMBKDD *CALL COMBUDT ITEM CHDRD C(1); # CHARACTER VALUE FOR DRDS # ITEM FINDSM B; # STORAGE MODULE FOUND IN UDT # ITEM I I; # INTEGER VALUE FOR DRDS # ITEM NUMDRD I; # NUMBER OF DRDS FOR ST OR DS # ITEM REJECT B; # REJECT OPERATOR RESPONSE FLAG # ITEM TEMPSM C(1); # *SM* ID FROM INPUT COMMAND # CONTROL EJECT; # * CHECK FOR VALID *SM* COMMAND. # REJECT = FALSE; # ASSUME VALID COMMAND # TEMPSM = C<2,1>KB$SCAN[0]; FINDSM = FALSE; # LOCATED SM IN UDT FLAG # SLOWFOR I = 1 STEP 1 UNTIL MAXSMUNIT DO BEGIN # CHECK FOR SM ID IN EACH UDT # IF SM$ID[I] EQ TEMPSM THEN BEGIN # SM LOCATED IN UDT # FINDSM = TRUE; KUDTIND = I; TEST I; END END # CHECK FOR SM ID IN EACH UDT # IF NOT FINDSM # SM NOT DEFINED IN THE UDT # OR TEMPSM EQ 0 ## OR KACTCOUNT NQ 0 # MESSAGE(S) AWAITING "GO" # OR (C<3,1>KB$SCAN[0] NQ " " # NOT VALID POST-CHARACTERS # AND C<3,1>KB$SCAN[0] NQ 0 AND C<3,5>KB$SCAN[0] NQ ",DRD=") THEN BEGIN # INVALID # REJECT = TRUE; RETURN; END # INVALID # IF C<3,5>KB$SCAN[0] EQ ",DRD=" THEN BEGIN # COMMAND FORM *SMI,DRD=.....* # # * COMMAND FORM IS *SMI,DRD=ST=N* * OR *SMI,DRD=DS=N* # CHDRD = C<11,1>KB$SCAN[0]; # NUMBER DRDS FOR ST OR DS # I = XDXB(CHDRD,0,NUMDRD); IF NOT (I EQ 0 AND NUMDRD GQ 0 AND NUMDRD LQ MAX$SMDRD) THEN # INVALID NUMBER OF DRDS SPECIFIED # BEGIN # DO NOT ALTER *UDT* # REJECT = TRUE; RETURN; END # * COMMAND FORM *SMI,DRD=ST=N* OR *SMI,DRD=DS=N* IS VALID. # IF C<8,3>KB$SCAN[0] EQ "ST=" THEN # PARAMETER IS *ST* # BEGIN # SET MAX DRDS FOR STAGING # SM$STNUM[KUDTIND] = NUMDRD; END ELSE BEGIN # PARAM MUST BE *DS* # IF C<8,3>KB$SCAN[0] EQ "DS=" THEN BEGIN # SET MAX DRDS FOR DESTAGING # SM$DSNUM[KUDTIND] = NUMDRD; END ELSE BEGIN # ST/DS PARAMETER IS INVALID # REJECT = TRUE; RETURN; END END # *DS* PARAM # END # COMMAND FORM *SMI,DRD=.....* # # * AT THIS POINT, THE COMMAND HAS BEEN VALIDATED WHETHER IT IS THE * *K.SMI* FORM OR THE *K.SMI,DRD.....* FORM. IF THE LATTER FORM, * THE *UDT* HAS ALREADY BEEN UPDATED TO REFLECT THE NEW MAXIMUM * NUMBER OF DRD-S FOR STAGING (*ST*) OR DESTAGING (*DS*). IT IS * NOW TIME TO REPAINT THE K-DISPLAY TO REFLECT THE *SM* SELECTED. # KSMID = TEMPSM; KDSM; # DISPLAY *SM* INFORMATION # RETURN; END # KSM # TERM