SXKD
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<KLBODY> = 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<KWORD> =  CURRKW; 
        REPEAT WHILE CURRKW NQ 0 AND KW$ACT[0]
        DO
          BEGIN 
          CURRKW = KW$LINK[0];
          P<KWORD> = 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<KLBODY> = 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<KWORD> = 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<UDT$MSG> = 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<UDT$MSG> = 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<LLRQ> = 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<HLRQ> = LLR$UCPRA;
            P<TDAM> = LOC(HLR$TDAM);
            P<FETSET> = 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<FETSET> 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<LLRQ> = 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<HLRQ> = LLR$UCPRA;
            P<TDAM> = LOC(HLR$TDAM);
            P<FETSET> = 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<FETSET> 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 = C<CH,1>KB$SCAN[0];  # PRESET WITH FIRST CHAR #
      SLOWFOR I = 1 STEP 1 WHILE I LQ 9  ## 
        AND C<I+CH,1>KB$SCAN[0] GQ "A"  # VALID CHARACTER FOUND # 
        AND C<I+CH,1>KB$SCAN[0] LQ "9"
      DO
        BEGIN 
        C<I,1>COMMAND = C<I+CH,1>KB$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<KWORD> = 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<KWORD> = 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<KWORD>,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<DISPOS> = 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<TDAM> = LINK + 1; 
              RTDADR = LINK;
              P<LINKWRD> = 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<PARTABLE> = LOC(KPAR);       # TABLE OF DEFINED PARAMETERS #
      P<PARAMETER> = 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 = C<FR,1>TEXT;          # GET CHARACTER #
        IF CHAR NQ "*"
        THEN                         # MOVE CHARACTER INTO TEXT # 
          BEGIN 
          C<TO,1>TCOPY = CHAR;
          TO = TO + 1;               # ADVANCE *TO* # 
          FR = FR + 1;               # ADVANCE *FROM* # 
          TEST DUMMY; 
          END 
  
        PCODE = C<FR+1,2>TEXT;       # 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] = B<PAR$FBIT[PI],PAR$FLEN[PI]>PARAM$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. 
# 
  
          C<TO,PAR$TSIZ[PI]>TCOPY =  ## 
            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<DISPOS>  = 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<KWORD> = 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<KWORD> = KWADDR;
        KW$KCTL[0] = 0;              # CLEAR K-CONTROLLED AREA #
        KW$LINK[0] = 0;              # SET LINK AT END #
  
# 
*     LINK *KWORD* TO END OF QUEUE. 
# 
  
        P<KWORD> = 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<KWORD> = 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<KWORD> = KWADDR;
        KW$COMP[0] = TRUE;
        DRVRRECALL = TRUE;           # SET TO RECALL THE DRIVER # 
  
# 
*     DELINK IT FROM QUEUE. 
# 
  
        CURRKW = KW$LINK[0];         # NEXT IN QUEUE #
        P<KWORD> = 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
