Retro1.org codex

PRGM SSALTER;
# TITLE SSALTER - INITIALIZES *SSALTER* UTILITY.                      #
 
      BEGIN  # SSALTER #
 
#
***   SSALTER - INITIALIZES *SSALTER* UTILITY.
*
*     THIS PROGRAM INITIALIZES *SSALTER* UTILITY BY
*     CALLING THE FIRST *SSALTER* *K* DISPLAY AND
*     PROVIDING THE INTERFACE BETWEEN THE CONSOLE
*     OPERATOR AND *SSEXEC* IN MAINTAINING THE
*     M860 HARDWARE CONFIGURATION.
*
*
*     COPYRIGHT CONTROL DATA SYSTEMS INC.  1992.
#
 
#
****  PRGM SSALTER - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # CALLS *ABORT* MACRO #
        PROC ALTKINP;                # DIGEST KEYBOARD INPUT #
        PROC ALTKINT;                # *SSALTER* *K* DISPLAY
                                       INITIALIZER #
        PROC BZFILL;                 # BLANK OR ZERO FILLS A BUFFER #
        PROC GETFAM;                 # GET DEFAULT FAMILY #
        PROC GETPFP;                 # GET USER INDEX AND FAMILY #
        PROC GETSPS;                 # GET SYSTEM ORIGIN STATUS #
        PROC MESSAGE;                # DISPLAYS A MESSAGE #
        PROC RECALL;                 # PUT PROGRAM INTO RECALL #
        PROC RESTPFP;                # RESTORE USER-S *PFP* AND ABORT
                                       OR RETURN #
        PROC SETPFP;                 # SET FAMILY AND USER INDEX #
        PROC SETQP;                 # SET QUEUE PRIORITY #
        PROC SETPR;                  # SET CPU PRIORITY #
        PROC UCPREQ;                 # ISSUE TYPE 1 OR 5 UCP REQUEST #
        PROC XARG;                   # USED TO SATISFY SSJ= EXTERNAL #
        END
 
#
****  PRGM SSALTER - XREF LIST END.
#
 
#
*     DAYFILE MESSAGES.
#
 
      DEF MSG1       #" SSALTER - SYNTAX ERROR."#;
      DEF MSG2       #" SSALTER COMPLETE."#;
      DEF MSG3       #" SSALTER - MUST BE SYSTEM ORIGIN."#;
      DEF MSG4       #" SSALTER - CANNOT CONNECT TO SSEXEC."#;
      DEF MSG5       #" SSALTER - INCORRECT RESPONSE FROM SSEXEC."#;
 
#
*     MISCELLAEOUS DEFINITIONS
#
 
      DEF RSLEN      #1#;            # RETURN STATUS WORD LENGTH #
      DEF LISTCON    #0#;            # DO NOT LIST COMDECKS #
 
                                               CONTROL PRESET;
*CALL COMBFAS
*CALL COMBBZF
*CALL COMBCPR
*CALL COMBPFP
*CALL COMBTDM
*CALL COMBUCR
*CALL COMSPFM
*CALL COMTALT
 
      ITEM ARGLIST    I;             # ADDRESS OF ARGUMENT TABLE #
      ITEM DEFORD     I;             # DEFAULT FAMILY ORDINAL #
      ITEM FLAG       I;             # ERROR STATUS #
      ITEM I          I;             # LOOP COUNTER #
      ITEM INDX       I;             # INDEX VARIABLE #
      ITEM INITIALIZE B;             # STATUS OF *SSEXEC* CALL #
      ITEM KBCUEST    C(3);          # EST ORDINAL OF REQUESTED CU #
      ITEM LINK       I;             # LINKED FAMILY ORDINAL #
      ITEM LOOPC      B;             # LOOP CONTROL #
      ITEM NUM        I;             # NUMBER OF FAMILIES #
      ITEM OPTION     I;             # OPTION TO SKIP PROGRAM NAME #
      ITEM RESPCODE   I;             # RESPONSE FROM EXEC #
 
      ARRAY CALL$SS [0:0] P(CPRLEN);;  # CALLSS PARAMETER BLOCK #
      ARRAY ALMSG[0:0] P(4);
        BEGIN
        ITEM ALMSG$LN    C(00,00,39);  # MESSAGE LINE #
        ITEM ALMSG$TERM  U(03,48,12) = [0];  # ZERO TERMINATOR #
        END
 
      ARRAY SPSSTAT [0:0] S(RSLEN);
        BEGIN
        ITEM SPS$STATUS U(00,48,12);  # RETURN STATUS #
        END
 
                                               CONTROL EJECT;
 
#
*     CALL *XARG* TO ALLOW SSJ= ENTRY POINT TO BE SATISFIED.
#
 
      XARG(ARGLIST,OPTION,FLAG);
 
#
*     GET SPECIAL SYSTEM PRIVELEDGES
#
 
      GETSPS ( SPSSTAT );
      IF SPS$STATUS NQ 0
      THEN
        BEGIN
        ALMSG$LN[0] = MSG3;
        MESSAGE(ALMSG[0],SYSUDF1);
        ABORT;
        END
 
 
#
*     GET SUBSYSTEM QUEUE PRIORITY.
#
 
      SETQP( -1 );
 
#
*     GET THE SAME CPU PRIORITY AS *SSEXEC*.
#
 
      SETPR;
 
#
*     SAVE THE USER-S CURRENT FAMILY AND USER INDEX IN COMMON.
#
 
      GETPFP(PFP[0]);
      USER$FAM[0] = PFP$FAM[0];
      USER$UI[0] = PFP$UI[0];
 
#
*     SET UP DEFAULT FAMILY AND SUBSYSTEM ID
#
 
      SSID$AL = ATAS;
      GETFAM(FAMT,NUM,LINK,DEFORD,SSID$AL);
 
#
*     SET REQUESTOR ID TO *SSALTER*
#
 
      REQID$AL = REQNAME"RQIALTER";
 
#
*      ESTABLISH LONG-TERM CONNECT WITH *SSEXEC*
#
 
      P<CPR> = LOC(CALL$SS[0]);
      UCPREQ ( TYP"TYP1", REQTYP1"CONNECT", RESPCODE );
      IF RESPCODE NQ RESPTYP1"OK1"
      THEN                           # CONNECT NOT DONE #
        BEGIN
        ALTMSG$LN[0] = MSG4;
        MESSAGE(ALTMSG[0],SYSUDF1);
        RESTPFP(PFP$ABORT);          # RESTORE USER-S *PFP* AND ABORT #
        END
 
      UCPREQ(TYP"TYP5",REQTYP5"SSA$PUDT",RESPCODE);
      IF ( RESPCODE NQ RESPTYP5"OK5" )  ##
        AND ( RESPCODE NQ RESPTYP5"SSA$OK" )
      THEN
        BEGIN  # PROCESS INCORRECT RESPONSE #
        UCPREQ ( TYP"TYP1", REQTYP1"DISCONNECT", RESPCODE );
        ALTMSG$LN[0] = MSG5;
        MESSAGE (ALTMSG[0],SYSUDF1);
        RESTPFP(PFP$ABORT);
        END  # PROCESS INCORRECT RESPONSE #
 
 
#
*     SET UP INITIALIZATION STATUS
#
 
      INITIALIZE = RESPCODE EQ RESPTYP5"SSA$OK";
 
#
*     INITIALIZE *K* DISPLAY
#
 
      ALTKINT ( INITIALIZE );
 
#
*     WAIT FOR OPERATOR INPUT
#
 
COMMAND:
 
      LOOPC = FALSE;
      SLOWFOR I = 0 WHILE ( NOT LOOPC )
      DO
        BEGIN  # ISSUE RECALL REQUESTS #
 
        RECALL(0);
 
        IF KB$AL$CLEAR[0] NQ 0
        THEN
          BEGIN
          LOOPC = TRUE;
          KREQCLEARAL = TRUE;
          MESSAGE ( BZEROES$AL, LINE2 );
          KL$AL$SUBL1[LF$AL$KBREJ] = " ";
          TEST I;
          END
 
        TEST I;
        END  # ISSUE RECALL REQUESTS #
 
#
*     PROCESS KEYBOARD INPUTS.
*     CHECK FOR *STOP*, *END*, *CU*, OR *SM*.
#
 
      IF ( C<0,3>KB$AL$SCAN[0] EQ ALTK$END )  ##
        OR ( C<0,4>KB$AL$SCAN[0] EQ ALTK$STOP )
      THEN
        BEGIN
        GOTO FINISHED;
        END
 
      IF ( C<0,2>KB$AL$SCAN[0] NQ ALTK$SM )  ##
        AND ( C<0,2>KB$AL$SCAN[0] NQ ALTK$CU )
      THEN
        BEGIN
        KL$AL$SUBL1[LF$AL$KBREJ] = "*** REJECT ***";
        KB$AL$CLEAR[0] = 0;
        GOTO COMMAND;                # WAIT FOR NEW OPERATOR INPUT #
        END
 
      KL$AL$SUBL1[LF$AL$KBREJ] = " ";  # CLEAR REJECT LINE #
 
#
*      SET UP COMMAND INDEX
#
 
      IF C<0,2>KB$AL$SCAN[0] EQ ALTK$SM
      THEN
        BEGIN
        INDX = 1;
        END
 
      IF C<0,2>KB$AL$SCAN[0] EQ ALTK$CU
      THEN
        BEGIN
        INDX = 2;
        KBCUEST = C<2,3>KB$AL$SCAN[0];
        END
 
      KB$AL$CLEAR = 0;
 
 
      ALTKINP( INDX, KBCUEST, INITIALIZE );
 
      KB$AL$CLEAR[0] = 0;
 
      ALTKINT ( INITIALIZE );
 
      GOTO COMMAND;
 
FINISHED:
 
#
*     DISCONNECT FROM *SSEXEC*
#
 
      UCPREQ ( TYP"TYP1", REQTYP1"DISCONNECT", RESPCODE );
 
      ALTMSG$LN[0] = MSG2;           # STOP WITH DAYFILE MESSAGE #
      MESSAGE(ALTMSG[0],UDFL1);
      RESTPFP(PFP$END);              # RESTORE USER-S *PFP* #
 
      END  # SSALTER #
 
    TERM
PROC ALTKINP( INDEX, ORDINAL, INITIALIZE );
 
# TITLE ALTKINP - KEYBOARD INPUT.                                      #
 
      BEGIN  # ALTKINP #
 
#
**    ALTKINP - KEYBOARD INPUT.
*
*     *ALTKINP* PROCESSES THE OPERATOR RESPONSES OR COMMANDS.
*
*     PROC ALTKINP.
*
*     ENTRY     INITIALIZE - BOOLEAN ( TRUE IMPLIES INITIALIZE )
*               INDEX - AN INDEX DESCRIBING WHICH DISPLAY TO DISPLAY.
*               ORDINAL EST ORDINAL FOR REQUESTED M862.
*
*     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 INVALID 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 KBINPUTAL - KEYBOARD BUFFER CLEARED.
*
#
 
      ITEM INITIALIZE   B;           # INPUT VARIABLE #
      ITEM INDEX      I;             # INPUT VARIABLE #
      ITEM ORDINAL    C(3);          # INPUT VARIABLE #
 
#
****  PROC ALTKINP - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        FUNC XCDD;
        PROC CHKMODE;                # CHECK MODE OF PATH/NODE #
        PROC CUCOMM;                 # CRACK *CU* COMMAND PARAMETERS #
        PROC DISPCU;                 # GENERATE *CU* DISPLAY #
        PROC DISPSM;                 # GENERATE *SM* DISPLAY #
        PROC KCLR;                   # CLEAR CURRENT REQUEST #
        PROC MESSAGE;                # DISPLAYS A MESSAGE #
        PROC POKEDIS;                # WRITE TO *K* DISPLAY #
        PROC RECALL;                 # PUT PROGRAM INTO RECALL #
        PROC UCPREQ;                 # ISSUE UCP CALL TO *SSEXEC* #
        FUNC XDXB I;                 # CONVERT DISPLAY CODE TO INTEGER
                                     #
        END
 
#
****  PROC ALTKINP - XREF LIST END.
#
 
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMBCPR
*CALL COMBPFP
*CALL COMBUCR
*CALL COMBUDT
*CALL COMTALT
 
      ITEM BITNUM     I;             # BIT NUMBER FOR UCP CALL #
      ITEM CH         I;             # CHARACTER INDEX #
      ITEM CH1        C(1);          # CHARACTER #
      ITEM CH2        C(2);          # 2 CHARACTERS #
      ITEM CHAR       C(1);          # CHARACTER #
      ITEM CHAR2      C(2);          # 2 CHARACTERS #
      ITEM CHAR3      C(3);          # 3-CHARACTER SCRATCH VARIABLE #
      ITEM COLUMN     I;             # COLUMN NUMBER IN DISPLAY #
      ITEM COUNT      I;             # NUMBER OF CHARACTERS #
      ITEM CUINDEX    I;             # *CU* INDEX IN UDT #
      ITEM CU0        U;             # SM/DRD STATUS TO CU 0 #
      ITEM CU1        U;             # SM/DRD STATUS TO CU 1 #
      ITEM COMMAND    C(10);         # OPERATOR COMMAND #
      ITEM FLAG       B;             # OUTPUT FROM CHKMODE #
      ITEM INDX       I;             # LOOP INDEX #
      ITEM J          I;             # SCRATCH INTEGER #
      ITEM K          I;             # SCRATCH INTEGER #
      ITEM LINE       I;             # *K* DISPLAY LINE NUMBER #
      ITEM LOOPC      B;             # LOOP CONTROL VARIABLE #
      ITEM NCHAR      I;             # NEXT CHARACTER COUNTER #
      ITEM ORD        I;             # ORDINAL #
      ITEM ESTORD     I;             # EST ORDINAL #
      ITEM MSG        C(80);         # MESSAGE #
      ITEM REJECT     B;             # REJECT RESPONSE FLAG #
      ITEM RESPCODE   I;             # RESPONSE FROM SSEXEC #
      ITEM SMINDEX    I;             # *SM* INDEX IN UDT #
      ITEM STAT       I;             # INTEGER STATUS #
      ITEM STATE      B;             # PATH STATUS #
      ITEM TEMP       I;             # TEMPORARY INTEGER #
 
      ARRAY CALL$SS[0:0]P(CPRLEN);;  # CALLSS PARAMETER BLOCK #
 
                                               CONTROL EJECT;
 
#
*     SET INITIAL CONDITIONS
#
 
      P<UDT$WORD> = LOC( UDT$HDR);
      P<CPR> = LOC( CALL$SS[0] );
      CUINDEX = 0;
      SMINDEX = 0;
 
      KL$AL$LINE[LF$AL$KBREJ] = " ";  # CLEAR REJECT LINE #
 
      KL$AL$SUBL1[LF$AL$KBECHO] = KB$AL$SCAN[0];  # SET ECHO LINE #
 
#
*     CRACK THE KEYBOARD INPUT.  DETERMINE IF INPUT IS -
*       . CU - INDICATING A REQUEST TO DISPLAY THE *CU* DISPLAY
*       . SM - INDICATING A REQUEST TO DISPLAY THE *SM* DISPLAY
#
 
CU$DISP:
 
      IF INDEX EQ 2
      THEN
        BEGIN  # PROCESS *CU* COMMAND #
 
#
*     LOCATE CORRECT UDT ENTRY
#
 
        LOOPC = FALSE;
        SLOWFOR INDX = 0 STEP 1 WHILE NOT LOOPC
        DO
          BEGIN
          P< UDT$CN > = LOC ( UDT$M862[INDX] );
          STAT = XDXB(ORDINAL,0,ESTORD);  # ASSUME 3 CHARACTERS #
          IF STAT NQ 0
          THEN
            BEGIN
            STAT = XDXB(C<0,2>ORDINAL,0,ORD);  # ASSUME 2 CHARACTERS #
            IF STAT NQ 0
            THEN                     # BAD EST ORDINAL #
              BEGIN  # EXIT #
              GOTO REJECTORD;
              END  # EXIT #
 
            END
 
          IF ESTORD EQ 0
          THEN
            BEGIN
            GOTO REJECTORD;          # BLANK IS ILLEGAL #
            END
 
          IF ESTORD NQ UD$ESTO[1]
          THEN
            BEGIN
            IF INDX GQ UDT$LINE$CUN[0]
            THEN
              BEGIN
              GOTO REJECTORD;        # REJECT IF BAD ORDINAL #
              END
 
            TEST INDX;
            END
 
          ELSE
            LOOPC = TRUE;
          TEST INDX;
          END
 
 
        CUINDEX = INDX;
 
        DISPCU ( CUINDEX, ESTORD );
 
CU$DISP1:
 
#
*     WAIT FOR OPERATOR INPUT
#
 
        LOOPC = FALSE;
        SLOWFOR J = 0 STEP 1 WHILE ( NOT LOOPC )
        DO
          BEGIN  # ISSUE RECALL UNTIL INPUT #
 
          RECALL ( 0 );
 
          IF KB$AL$CLEAR NQ 0
          THEN
            BEGIN
            LOOPC = TRUE;
            KL$AL$LINE[LF$AL$KBECHO] = KB$AL$SCAN[0];  # ECHO THE
                                                         REQUEST #
            CPR$CUORD[0] = CUINDEX;
 
#
*     SEND ALL OPERATOR COMMANDS TO THE SYSTEM DAYFILE.
#
 
            MESSAGE ( KB$AL$SCAN[0], SYSUDF1 );
 
            TEST J;
            END
 
          END  # ISSUE RECALL REQUESTS UNTIL INPUT #
 
        IF C<0,3>KB$AL$SCAN[0] EQ ALTK$END
        THEN
          BEGIN
          P<SM$SCREEN> = LOC(KLEFTSCRNAL);
          SLOWFOR J = 4 STEP 1 UNTIL LF$AL$KBECHO
          DO
            BEGIN
            CU$LN[J] = ALTK$BL;
            CU$EOL[J] = 0;
            END
 
          RETURN;                    # RETURN IF *END* #
          END
        ELSE
          BEGIN
          GOTO REJECTCOM;
          END
 
 
        END  # PROCESS *CU* COMMAND #
 
SM$DISP:
 
      IF INDEX EQ 1
      THEN
        BEGIN  # PROCESS *SM* COMMANDS #
 
        DISPSM( SMINDEX , INITIALIZE );
 
SM$DISP1:
 
#
*     WAIT FOR OPERATOR INPUT
#
 
        LOOPC = FALSE;
        SLOWFOR J = 0 STEP 1 WHILE ( NOT LOOPC )
        DO
          BEGIN  # ISSUE RECALL UNTIL INPUT #
 
          RECALL ( 0 );
 
          IF KB$AL$CLEAR NQ 0
          THEN
            BEGIN
            LOOPC = TRUE;
            KL$AL$LINE[LF$AL$KBECHO] = KB$AL$SCAN[0];  # ECHO THE
                                                         REQUEST #
 
#
*     SEND ALL OPERATOR COMMANDS TO THE SYSTEM DAYFILE.
#
 
            MESSAGE ( KB$AL$SCAN[0], SYSUDF1 );
 
            TEST J;
            END
 
          END  # ISSUE RECALL REQUESTS UNTIL INPUT #
 
        IF ( C<0,2>KB$AL$SCAN[0] NQ ALTK$SM )  ##
          AND ( C<0,3>KB$AL$SCAN[0] NQ ALTK$END )  ##
          AND ( C<0,1>KB$AL$SCAN[0] NQ ALTK$PLUS )
        THEN
          BEGIN  # REJECT RESPONSE #
          GOTO REJECTCOM;
          END  # REJECT RESPONSE #
 
        KL$AL$SUBL1[LF$AL$KBREJ] = " ";  # CLEAR REJECT LINE #
        IF C<0,1>KB$AL$SCAN[0] EQ ALTK$PLUS
        THEN
          BEGIN  # PROCESS K.+ #
          SMINDEX = SMINDEX + 1;
          IF SMINDEX GQ UDT$LINE$SMN[0]
          THEN
            BEGIN  # NO SUCH DISPLAY AVAILABLE #
            SMINDEX = SMINDEX - 1;
            GOTO REJECTCOM;
            END  # NO SUCH DISPLAY AVAILABLE #
 
          ELSE
            BEGIN  # "+" IS OK, DISPLAY NEXT PAGE #
            KB$AL$CLEAR[0] = 0;
            KL$AL$LINE[LF$AL$KBECHO] = " ";
            GOTO SM$DISP;
            END  # "+" IS OK, DISPLAY NEXT PAGE #
 
          END  # PROCESS PLUS #
 
 
        IF C<0,2>KB$AL$SCAN[0] NQ ALTK$SM
        THEN
          BEGIN
 
#
*     BLANK THE SCREEN
#
 
          P<SM$SCREEN> = LOC(KLEFTSCRNAL);
          SLOWFOR J = LF$AL$BODY STEP 1 UNTIL LF$AL$KBECHO
          DO
            BEGIN
            SM$LN[J] = ALTK$BL;
            SM$EOL[J] = 0;
            END
 
          RETURN;                    # RETURN IF *END* OR *STOP* #
          END
 
        P<UDT$SMA> = LOC(UDT$M861[SMINDEX]);
        IF C<2,1>KB$AL$SCAN[0] NQ SM$ID[1]  # NOT THE SM ON CONSOLE #
          OR C<3,1>KB$AL$SCAN[0] NQ COMMA
        THEN
          BEGIN  # REJECT RESPONSE #
          GOTO REJECTCOM;
          END  # REJECT RESPONSE #
 
        CHAR2 = C<4,2>KB$AL$SCAN[0];
        IF ( CHAR2 NQ NM$KEY2[2] )   ##
          AND C<4,3>KB$AL$SCAN[0] NQ NM$KEY3[8]
        THEN
          BEGIN  # REJECT RESPONSE #
          GOTO REJECTCOM;
          END  # REJECT RESPONSE #
 
        IF C<4,3>KB$AL$SCAN[0] EQ NM$KEY3[8]
        THEN
          BEGIN  # PRE-PROCESS DRD STATUS CHANGE #
          STAT = XDXB(C<7,2>KB$AL$SCAN[0],1,J);  # ASSUME 2 CHARS #
          NCHAR = 9;
          IF STAT NQ 0
          THEN
            BEGIN  # ONE #
            STAT = XDXB(C<7,1>KB$AL$SCAN[0],1,J);  # ASSUME 1 CHAR #
            NCHAR = 8;
            IF STAT NQ 0
            THEN                     # BAD DRD ORDINAL #
              BEGIN  # REJECT #
              GOTO REJECTCOM;
              END  # REJECT #
 
            END  # ONE #
 
          IF C<NCHAR,1>KB$AL$SCAN[0] NQ COMMA
          THEN                       # BAD SYNTAX #
            BEGIN  # EXIT #
            GOTO REJECTCOM;
            END  # EXIT #
 
          NCHAR = NCHAR + 1;
          IF C<NCHAR,2>KB$AL$SCAN[0] NQ "CU"
          THEN                       # BAD SYNTAX #
            BEGIN  # EXIT #
            GOTO REJECTCOM;
            END  # EXIT #
 
          NCHAR = NCHAR + 2;
 
          IF (J LS 0) OR (J GR MAX$DRDDA)
          THEN
            BEGIN  # REJECT BAD DEVICE ADDRESS #
            GOTO REJECTCOM;
            END  # REJECT BAD DEVICE ADDRESS #
 
          IF (J NQ D0$SUN[1]) AND (J NQ D1$SUN[1])
          THEN
            BEGIN  # REJECT BAD DEVICE ADDRESS #
            GOTO REJECTCOM;
            END  # REJECT BAD DEVICE ADDRESS #
 
          CHAR3 = C<NCHAR,3>KB$AL$SCAN[0];
          STAT = XDXB(CHAR3,0,K);    # ASSUME 3 CHARS #
          IF STAT NQ 0
          THEN
            BEGIN
            CHAR2 = C<NCHAR,2>KB$AL$SCAN[0];
            STAT = XDXB(CHAR2,0,K);  # ASSUME 2 #
            NCHAR = NCHAR + 2;
            IF STAT NQ 0
            THEN                     # BAD CONTROLLER ORDINAL #
              BEGIN  # EXIT #
              GOTO REJECTCOM;
              END  # EXIT #
 
            END
 
          ELSE                       # BUMP POSITION COUNTER #
            BEGIN  # BUMP #
            NCHAR = NCHAR + 3;
            END  # BUMP #
 
          IF ( K LS 0 ) OR ( K GR MAXEST )
          THEN
            BEGIN
            GOTO REJECTCOM;
            END
 
          END  # PREPROCESS DRD STATUS CHANGE #
 
        CHAR2 = C<4,2>KB$AL$SCAN[0];
        IF CHAR2 EQ NM$KEY2[2]
        THEN
          BEGIN  # PREPROCESS ACCESSOR CHANGE REQUEST #
          STAT = XDXB(C<6,3>KB$AL$SCAN[0],0,J);  # ASSUME 3 CHARS #
          NCHAR = 9;
          IF STAT NQ 0
          THEN
            BEGIN
            STAT = XDXB(C<6,2>KB$AL$SCAN[0],0,J);  # ASSUME 2 CHARS #
            NCHAR = 8;
            IF STAT NQ 0
            THEN                     # BAD CONTROLLER ORDINAL #
              BEGIN  # EXIT #
              GOTO REJECTCOM;
              END  # EXIT #
 
            END
 
          IF ( J LS 0 ) OR ( J GR MAXEST )
          THEN
            BEGIN
            GOTO REJECTCOM;
            END
 
          END  # PREPROCESS ACCESSOR CHANGE REQUEST #
 
#
*     ADVANCE TO STATUS CHARACTER.
#
 
        IF C<NCHAR,1>KB$AL$SCAN[0] NQ "="
        THEN                         # BAD SYNTAX #
          BEGIN  # EXIT #
          GOTO REJECTCOM;
          END  # EXIT #
 
        NCHAR = NCHAR + 1;
 
#
*     ADJUST DRD DEVICE ADDRESS
#
 
        IF C<4,3>KB$AL$SCAN[0] EQ "DRD"
        THEN
          BEGIN
          J = J - ((J/2)*2);
          END
 
 
#
*     J GQ 8 IMPLIES K.SM"ID",CUNN=X. COMMAND
*     J EQ 0 OR 1 IMPLIES K.SM"ID",DRDN,CUNN=X. COMMAND.
#
 
        CHAR = C<NCHAR,1>KB$AL$SCAN;
        IF ( CHAR NQ ALTK$MAINT )    ##
          AND ( CHAR NQ ALTK$ONLINE )  ##
          AND ( CHAR NQ ALTK$OFFLINE )
        THEN
          BEGIN  # REJECT INVALID STATUS #
          GOTO REJECTCOM;
          END  # REJECT INVALID STATUS #
 
        IF ( CHAR EQ ALTK$MAINT ) AND INITIALIZE
        THEN
          BEGIN
          GOTO REJECTCOM;            # INITIALIZE PROHIBITS MAINTENANCE
                                       MODE #
          END
 
        IF J GQ 8
        THEN
          BEGIN
          P<UDT$LOC> = LOC(SM$WD0[1]);
          CU0 = SMST0;               # SAVE CU STATUS INDEXES #
          CU1 = SMST1;
          END
 
        IF J EQ 0
        THEN
          BEGIN
          P<UDT$LOC> = LOC(D0$WD0[1]);
          TEMP = D0$WD0[1];
          CU0 = DRST0;               # SAVE CU STATUS INDEXES #
          CU1 = DRST1;
          END
 
        IF J EQ 1
        THEN
          BEGIN
          P<UDT$LOC> = LOC(D1$WD0[1]);
          TEMP = D1$WD0[1];
          CU0 = DRST0;               # SAVE CU STATUS INDEXES #
          CU1 = DRST1;
          END
 
#
*     CHECK PATH/NODE CURRENT CONDITION
#
 
        IF J LQ 1
        THEN
          BEGIN
          P<UDT$CN> = LOC(UDT$M862[SM$CUO0[1]-1]);
          IF K EQ UD$ESTO[1]
          THEN
            BEGIN  # CHECK FIRST CONTROLLER #
            IF B<12+PATH$DF"U$EXISTS",1>TEMP EQ 0
            THEN
              BEGIN
              GOTO REJECTCOM;
              END
 
            CHKMODE ( UDT$LOC, 2, CHAR, FLAG, BITNUM );
            CPR$CUORD[0] = SM$CUO0[1];  # IDENTIFY CONTROLLER #
            END  # CHECK FIRST CONTROLLER #
 
          IF K NQ UD$ESTO[1]
          THEN
            BEGIN  # CHECK SECOND CU TABLE #
            P<UDT$CN> = LOC(UDT$M862[SM$CUO1[1]-1]);
            IF K NQ UD$ESTO[1]
            THEN
              BEGIN  # CU ORDINAL NOT FOUND #
              GOTO REJECTCOM;
              END  # CU ORDINAL NOT FOUND #
 
            IF B<18+PATH$DF"U$EXISTS",1>TEMP EQ 0
            THEN
              BEGIN
              GOTO REJECTCOM;
              END
 
            CHKMODE ( UDT$LOC, 3, CHAR, FLAG, BITNUM );
            CPR$CUORD[0] = SM$CUO1[1];  # IDENTIFY CONTROLLER #
            END  # CHECK SECOND CU TABLE #
 
          END
 
        ELSE
          BEGIN  # CHECK ACCESSOR STATUS #
          P<UDT$CN> = LOC(UDT$M862[SM$CUO0[1]-1]);
          IF J NQ UD$ESTO[1]
          THEN
            BEGIN  # CHECK SECOND CU TABLE #
            P<UDT$CN> = LOC(UDT$M862[SM$CUO1[1]-1]);
            IF J NQ UD$ESTO[1]
            THEN
              BEGIN  # CU ORDINAL NOT FOUND #
              GOTO REJECTCOM;
              END  # CU ORDINAL NOT FOUND #
 
            P<UDT$CN> = LOC(UDT$M862[SM$CUO1[1]-1]);
            CPR$CUORD[0] = SM$CUO1[1];
            END  # CHECK SECOND CU TABLE #
 
          P<UDT$CN> = LOC(UDT$M862[SM$CUO0[1]-1]);
          IF J EQ UD$ESTO[1]
          THEN
            BEGIN
            CPR$CUORD[0] = SM$CUO0[1];
            CHKMODE ( UDT$LOC, 2, CHAR, FLAG, BITNUM );
            END
 
          ELSE
            BEGIN
            CHKMODE ( UDT$LOC, 4, CHAR, FLAG, BITNUM );
            END
 
          END  # CHECK ACCESSOR STATUS #
 
#
*     FLAG EQ TRUE IMPLIES PATH/NODE ALREADY IN REQUESTED STATE
#
 
        IF FLAG
        THEN
          BEGIN
          GOTO GOODCOM;              # COMMAND WAS ACCEPTED #
          END
 
        IF ( J LQ 1 )                ##
          AND ( CHAR EQ ALTK$ONLINE )  ##
          AND ( NOT SM$ON[1] )       ##
          AND ( NOT INITIALIZE )
        THEN
          BEGIN
          GOTO REJECTSMCHG;
          END
 
        IF J GQ 8
        THEN
          BEGIN
          CPR$UDTQ = LOC(UDT$M861[SMINDEX])+BIAS$EN0-LOC(UDT$HDR);
          END
 
        IF J EQ 0
        THEN
          BEGIN
          CPR$UDTQ = LOC(UDT$M861[SMINDEX])+BIAS$EN3-LOC(UDT$HDR);
          END
 
        IF J EQ 1
        THEN
          BEGIN
          CPR$UDTQ = LOC(UDT$M861[SMINDEX])+BIAS$EN20-LOC(UDT$HDR);
          END
 
        CPR$BYNR = BITNUM;
        IF ( CHAR EQ ALTK$ONLINE )   ##
          OR ( CHAR EQ ALTK$MAINT )
        THEN
          BEGIN
          CPR$PMMR = TRUE;
          END
 
        ELSE
          BEGIN
          CPR$PMMR = FALSE;
          END
 
#
*      UPDATE *K* DISPLAY REQUEST BITS WHILE WAITING ON *SSEXEC*.
#
 
        IF J LQ 1
        THEN
          BEGIN
          TEMP = 8 + J*2;
          END
 
        IF J GQ 8
        THEN
          BEGIN
          TEMP = 6;
          END
 
        COLUMN = 37;
        IF ( C<COLUMN,1>SM$LN[TEMP] EQ " " )  ##
          OR ( ( C<COLUMN,1>SM$LN[TEMP] EQ ALTK$ONLINE )  ##
          AND ( CHAR EQ ALTK$MAINT ) )  ##
          OR ( ( C<COLUMN,1>SM$LN[TEMP] EQ ALTK$MAINT )  ##
          AND ( CHAR EQ ALTK$ONLINE ) )
        THEN
          BEGIN
          GOTO REJECTCOM;            # NON-EXISTENT ELEMENT OR ILLEGAL
                                       SWITCH #
          END
 
        TEMP = TEMP - 1;             # POSITION LINE FOR ASTERISK
                                       DISPLAY #
        CHAR = ALTK$AST;
        COUNT = 1;
 
        POKEDIS ( TEMP, COLUMN, COUNT, CHAR );
 
        UCPREQ ( TYP"TYP5", REQTYP5"SSA$UUDT", RESPCODE );
 
        UCPREQ ( TYP"TYP5", REQTYP5"SSA$PUDT", RESPCODE );
 
#
*     SET GLOBAL FLAGS IF SSEXEC IS INITIALIZING.
*     SSEXEC WILL DO SO ONCE IT IS INITIALIZED.
#
 
      IF INITIALIZE
      THEN                           # SET GLOBAL FLAGS #
            BEGIN  # DISPLAY CONSOLIDATED STATUS #
        P<PTHSTAT> = P<UDT$LOC>;
        IF PATHBIT(CU0,PATH$DF"U$ON") EQ 1  ##
          OR PATHBIT(CU1,PATH$DF"U$ON") EQ 1
            THEN
              BEGIN
              CPR$PMMR = TRUE;
              CPR$BYNR = PATH$DF"U$ON";
 
              UCPREQ ( TYP"TYP5", REQTYP5"SSA$UUDT", RESPCODE );
 
              UCPREQ ( TYP"TYP5", REQTYP5"SSA$PUDT", RESPCODE );
 
              END
 
        IF PATHBIT(CU0,PATH$DF"U$RQ$DIAG") EQ 1  ##
          OR PATHBIT(CU1,PATH$DF"U$RQ$DIAG") EQ 1
            THEN
              BEGIN
              CPR$PMMR = TRUE;
              CPR$BYNR = PATH$DF"U$RQ$DIAG";
 
              UCPREQ ( TYP"TYP5", REQTYP5"SSA$UUDT", RESPCODE );
 
              UCPREQ ( TYP"TYP5", REQTYP5"SSA$PUDT", RESPCODE );
 
              END
 
        IF PATHBIT(CU0,PATH$DF"U$ON") EQ 0  ##
          AND PATHBIT(CU1,PATH$DF"U$ON") EQ 0
            THEN
              BEGIN
              CPR$PMMR = FALSE;
              CPR$BYNR = PATH$DF"U$ON";
 
              UCPREQ ( TYP"TYP5", REQTYP5"SSA$UUDT", RESPCODE );
 
              UCPREQ ( TYP"TYP5", REQTYP5"SSA$PUDT", RESPCODE );
 
              END
 
            END  # DISPLAY CONSOLIDATED STATUS #
 
        GOTO GOODCOM;
 
        END  # PROCESS *SM* COMMANDS #
 
#
*     REJECT REQUEST
#
 
REJECTSMCHG:
 
      KL$AL$SUBL1[LF$AL$KBREJ] = "*** SM STATUS PROHIBITS CHANGE ***";
      KB$AL$CLEAR[0] = 0;
      GOTO SM$DISP1;
 
REJECTCOM:
 
      KL$AL$SUBL1[LF$AL$KBREJ] = "*** REJECT ***";
      KB$AL$CLEAR[0] = 0;
      IF INDEX EQ 1
      THEN
        BEGIN
        GOTO SM$DISP1;               # GET NEXT COMMAND #
        END
 
      ELSE
        BEGIN
        GOTO CU$DISP1;               # GET NEXT COMMAND #
        END
 
REJECTORD:
 
      KL$AL$SUBL1[LF$AL$KBREJ] = " *** REJECT CU ORD *** ";
      KB$AL$CLEAR[0] = 0;
      P<SM$SCREEN> = LOC(KLEFTSCRNAL);
      SLOWFOR J = LF$AL$BODY STEP 1 UNTIL LF$AL$KBREJ-1
      DO
        BEGIN
        CU$EOL[J] = 0;
        END
 
      RETURN;                        # RETURN TO MAIN PROGRAM #
 
 
 
#
*     RESPONSE WAS GOOD. CLEAR ECHO.
#
 
GOODCOM:
 
      KL$AL$LINE[LF$AL$KBECHO] = " ";  # CLEAR ECHO #
      KB$AL$CLEAR[0] = 0;
 
      IF INDEX EQ 1
      THEN
        BEGIN
        GOTO SM$DISP;                # GET NEXT COMMAND #
        END
 
      ELSE
        BEGIN
        GOTO CU$DISP1;               # GET NEXT COMMAND #
        END
 
 
      END  # ALTKINP #
 
    TERM
 
PROC ALTKINT ( INITIALIZE );
 
# TITLE ALTKINT - *K* DISPLAY INITIALIZATION.                         #
 
      BEGIN  # ALTKINT #
 
#
**    ALTKINT - *K* DISPLAY INTIALIZATION.
*
*     *ALTKINT* ISSUES THE *CONSOLE* MACRO TO ACTIVATE THE
*     *K* DISPLAY AND INITIALIZES THE *K* DISPLAY BUFFERS.
*
*     PROC ALTKINT.
*
*     ENTRY      INITIALIZE - BOOLEAN ( TRUE IMPLIES INITIALIZE )
*
*     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).
*
#
 
      ITEM INITIALIZE  B;            # INPUT VARIABLE #
#
****  PROC ALTKINT - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC CONSOLE;                # ISSUE *CONSOLE* MACRO #
        PROC MESSAGE;                # ISSUE *MESSAGE* MACRO #
        END
 
#
****  PROC ALTKINT - XREF LIST END.
#
 
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
*CALL COMBFAS
*CALL COMTALT
 
      ITEM ALTHDR1 C(58) =
        "     VALID DISPLAYS ARE";
      ITEM ALTHDR2 C(58) =
        "              K.SM";
      ITEM ALTHDR3 C(58) =
        "              K.CUNN - NN = EST ORDINAL OF M862";
      ITEM I        I;               # LOOP COUNTER #
                                               CONTROL EJECT;
 
#
*     SET UP AND ISSUE THE CONSOLE MACRO.
#
 
      CP$KBADDR[0] = LOC(KBINPUTAL[0]);
      CP$KLADDR[0] = LOC(KLEFTSCRNAL[0]);
      CONSOLE(CPARAM[0]);
 
#
*     REQUEST *K* DISPLAY ON *B* DISPLAY.
#
 
      MESSAGE("$ REQUEST *K* DISPLAY  ",LINE2);
      KL$AL$COMP[0] = FALSE;         # SET TOGGLE OFF #
      KREQCLEARAL = FALSE;
      KB$AL$CLEAR[0] = 0;
 
#
*     SET UP TITLE LINE IN LEFT SCREEN BUFFER.
#
 
      KL$AL$LINE[LF$AL$TITLE] = TITLELINE$AL;
      KL$AL$LINE[LF$AL$TITLE+1] = TITLEBOX$AL;
      IF INITIALIZE
      THEN
        BEGIN  # DISPLAY INITIALIZATION MESSAGE #
        KL$AL$LINE[LF$AL$TITLE+2] = TITLELINE$MD;
        END  # DISPLAY INITIALIZATION MESSAGE #
 
 
#
*     DISPLAY VALID COMMANDS.
#
 
      P<SM$SCREEN> = LOC(KLEFTSCRNAL);
      SLOWFOR I = LF$AL$BODY STEP 1 UNTIL LF$AL$KBECHO + 1
      DO
        BEGIN
        SM$EOL[0] = 0;
        END
 
      SM$LN[8] = ALTHDR1;
      SM$LN[10] = ALTHDR2;
      SM$LN[11] = ALTHDR3;
      END  # ALTKINT #
 
    TERM
PROC CHKMODE ( WORD, FIELD, MODE, FLAG, BITNUM );
 
# TITLE BITNUM - CHECK EXISTING MODE OF PATH/NODE IN M860             #
 
      BEGIN  # CHKMODE #
 
#
**** CHKMODE - CHECK EXISTING MODE OF PATH/NODE IN M860
*
*     *CHKMODE* EXAMINES THE EXISTING STATUS OF THE REQUESTED
*     PATH/NODE. IF IT IS THE SAME AS THE STATUS BEING REQUESTED,
*     *CHKMODE* RETURNS WITH FLAG = TRUE. IF NOT, FLAG IS RETURNED
*     AS FALSE. ALSO, BITNUM IS RETURNED AS THE BIT NUMBER THAT
*     WAS CHECKED SO A SUBSEQUENT UCPCALL CAN BE MADE TO *SSEXEC*
*     IF DESIRED.
*
*     ENTRY
*        WORD = WORD IN UDT TO BE CHECKED.
*        FIELD = ORDINAL OF 6 BIT FIELD TO CHECK IN WORD.
*        MODE = MODE OF PATH/NODE TO CHECK FOR.
*
*     EXIT
*        FLAG = TRUE IF REQUESTED MODE IS THE SAME AS EXISTING MODE.
*        BITNUM = BIT NUMBER IN WORD OF THE BIT THAT WAS CHECKED.
#
 
      ITEM BITNUM     I;             # OUTPUT VARIABLE #
      ITEM FIELD      I;             # INPUT VARIABLE #
      ITEM FLAG       B;             # OUTPUT VARIABLE #
      ITEM MODE       C(1);          # INPUT VARIABLE #
      ARRAY WORD[0:0] S(1);
        BEGIN
        ITEM UDTWORD    I (00,00,60);  # INPUT WORD ADDRESS #
        END
 
#
****  PROC CHKMODE - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC MESSAGE;                # ISSUE DAYFILE MESSAGE #
        PROC RESTPFP;                # RESTORE USER-S PFP AND ABORT #
        END
 
#
****  PROC CHKMODE - XREF LIST END.
#
 
                                               CONTROL PRESET;
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
*CALL,COMBFAS
*CALL,COMBUDT
*CALL,COMTALT
 
      ITEM I          I;             # INTEGER VARIABLE #
      ITEM MODEB      B;             # STATUS DESCRIPTOR #
                                               CONTROL EJECT;
 
#
*     DETERMINE MODE BEING SEARCHED FOR
#
 
      MODEB = FALSE;
      IF ( MODE EQ ALTK$MAINT )      ##
        OR ( MODE EQ ALTK$ONLINE )
      THEN
        BEGIN
        MODEB = TRUE;
        END
 
      I = 0;
      IF ( MODE EQ ALTK$MAINT )
      THEN
        BEGIN
        I = PATH$DF"U$RQ$DIAG";
        END
 
      IF ( MODE EQ ALTK$ONLINE )     ##
        OR ( MODE EQ ALTK$OFFLINE )
      THEN
        BEGIN
        I = PATH$DF"U$ON";
        END
 
      IF ( I NQ 1 ) AND ( I NQ 3 )
      THEN
        BEGIN
        ALTMSG$LN[0] = " CHKMODE - ILLEGAL MODE REQUESTED.";
        MESSAGE ( ALTMSG[0],SYSUDF1 );
        RESTPFP ( PFP$ABORT );
        END
 
#
*     DETERMINE BIT NUMBER
#
 
      BITNUM = FIELD*6 + I;
      IF ( ( B<BITNUM,1>UDTWORD EQ 1) AND ( MODEB ) )  ##
        OR ( ( B<BITNUM,1>UDTWORD EQ 0 )  ##
        AND ( NOT MODEB )  ##
        AND ( B<FIELD*6 + PATH$DF"U$RQ$DIAG",1>UDTWORD EQ 0 ) )  ##
      THEN
        BEGIN
        FLAG = TRUE;
        END
 
      ELSE
        BEGIN
        FLAG = FALSE;
        IF NOT MODEB AND B<FIELD*6 + PATH$DF"U$RQ$DIAG",1>UDTWORD EQ 1
        THEN
          BEGIN
          BITNUM = BITNUM + PATH$DF"U$RQ$DIAG" - PATH$DF"U$ON";
          END
 
        END
 
      END  # CHKMODE #
 
    TERM
PROC DISPCU ( INDEX, ORDINAL );
 
# TITLE DISPCU - DISPLAY *SM* DISPLAY                                 #
 
      BEGIN  # DISPCU #
 
#
***   DISPCU - DISPLAY *CU* DISPLAY
*
*     *DISPCU* GENERATES AND DISPLAYS THE *CU* DISPLAY
*     FOR *SSALTER*
*
*     ENTRY         INDEX = CU TO BE DISPLAYED.
*
*
*     EXIT       DISPLAY SHOWN ON LEFT SCREEN.
#
 
      ITEM INDEX      I;             # INPUT VARIABLE #
      ITEM ORDINAL    I;             # INPUT VARIABLE #
 
#
****  PROC DISPCU - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC KDISCIF;                # DISPLAY CIF CONFIGURATION #
        PROC MESSAGE;                # ISSUE A DAYFILE MESSAGE #
        PROC POKEDIS;                # UPDATE *K* DISPLAY #
        PROC RESTPFP;                # RESTORE USER-S PFP AND ABORT OR
                                       RETURN #
        PROC UCPREQ;                 # ISSUE UCP REQUEST TO SSEXEC #
        FUNC XCOD C(10);             # CONVERT INTEGER TO OCTAL DISPLAY
                                     #
        FUNC XDXB;                   # CONVERT DISPLAY CODE TO INTEGER
                                     #
        END
 
#
****  PROC DISPCU - XREF LIST END.
#
 
#
*     DAYFILE MESSAGES.
#
 
      DEF MSG1   #" DISPCU - INCORRECT RESPONSE FROM SSEXEC."#;
      DEF BLANK      #" "#;
 
 
      DEF LISTCON    #0#;            # DO NOT LIST COMMON DECKS #
 
*CALL,COMBFAS
*CALL,COMBCPR
*CALL,COMBUDT
*CALL,COMTALT
 
      ARRAY CHAR10[0:0] S(1);        # CHARACTER MANIPULATION #
        BEGIN
        ITEM CHAR$10    C(00,00,10);
        ITEM CHAR$R1    C(00,54,01);
        ITEM CHAR$R2    C(00,48,02);
        ITEM CHAR$R3    C(00,42,03);
        END
 
      ITEM CH1        C(1);          # ONE CHARACTER #
      ITEM CH2        C(2);          # TWO CHARACTERS #
      ITEM COLUMN     I;             # *K* DISPLAY COLUMN NUMBER #
      ITEM FIRSTAC    I;             # FIRST AC TO SCAN IN AIF GROUP #
      ITEM I          I;             # LOOP INDEX #
      ITEM J          I;             # LOOP INDEX #
      ITEM JINDEX     I;             # PARAMETER FOR *KDISCIF* #
      ITEM LINE       I;             # *K* DISPLAY LINE NUMBER #
      ITEM LOOPC      B;             # LOOP CONTROL #
      ITEM NCH        I;             # LOOP COUNTER #
      ITEM ORD        I;             # TEMPORARY STORAGE #
      ITEM RESPCODE   I;             # RESPONSE FROM *SSEXEC* #
      ITEM STAT       I;             # STATUS FROM *XDXB* #
      ITEM TEMP       I;             # TEMPORARY CELL #
                                               CONTROL EJECT;
      ITEM CUBLANK C(58) =
        "                                                          ";
      ITEM CUHDR1 C(58) =
        "                            CU";
      ITEM CUHDR2 C(58) =
        "                     ORD    ST";
      ITEM CUHDR3 C(58) =
        "                    CUNN    ST";
      ITEM CUHDR4 C(58) =
        "    CIFU   CIFV   DTI0   DTO0   DIF0   DRC0   DRC1   AIF0";
      ITEM CUHDR5 C(58) =
        "    ----   ----   ----   ----   ----   ----   ----   ----";
      ITEM CUHDR7 C(58) =
        "    DTI0X  DTI0X  DIF0X  DIF0X  DRC0X  DRD0X  DRD0X  SMA0X";
      ITEM CUHDR8 C(58) =
        "    DTI1X  DTI1X  DIF1X  DIF1X  DRC1X  DRD1X  DRD1X  SMA1X";
      ITEM CUHDR9 C(58) =
        "    DTO0X  DTO0X                DRC2X  DRD2X  DRD2X  SMA2X";
      ITEM CUHDR10 C(58) =
        "    DTO1X  DTO1X  DTI1   DTO1   DRC3X  DRD3X  DRD3X  SMA3X";
      ITEM CUHDR11 C(58) =
        "                  ----   ----          DRD4X  DRD4X";
      ITEM CUHDR12 C(58) =
        "                  DIF0X  DIF0X  DIF1   DRD5X  DRD5X  AIF1";
      ITEM CUHDR13 C(58) =
        "        CH        DIF1X  DIF1X  ----   DRD6X  DRD6X  ----";
      ITEM CUHDR14 C(58) =
        "    CH  ST  CIF                 DRC0X  DRD7X  DRD7X  SMA0X";
      ITEM CUHDR15 C(58) =
        "    NN  ST   U                  DRC1X                SMA1X";
      ITEM CUHDR16 C(58) =
        "    MM  ST   V                  DRC2X                SMA2X";
      ITEM CUHDR17 C(58) =
        "                                DRC3X                SMA3X";
                                               CONTROL EJECT;
 
#
*     BLANK THE *K* DISPLAY
#
 
      P<CU$SCREEN> = LOC(KLEFTSCRNAL);
      P<SM$SCREEN> = LOC(KLEFTSCRNAL);
      SLOWFOR I = LF$AL$BODY STEP 1 UNTIL LF$AL$KBECHO-1
      DO
        BEGIN
        CU$LN[I] = CUBLANK;
        CU$EOL[I] = 0;
        END
 
 
#
*     PAINT NON-CHANGING WORDS ON THE SCREEN
#
 
      CU$LN[4] = CUHDR1;
      CU$LN[5] = CUHDR2;
      CU$LN[6] = CUHDR3;
      CU$LN[8] = CUHDR4;
      CU$LN[9] = CUHDR5;
      CU$LN[10] = CUHDR7;
      CU$LN[11] = CUHDR8;
      CU$LN[12] = CUHDR9;
      CU$LN[13] = CUHDR10;
      CU$LN[14] = CUHDR11;
      CU$LN[15] = CUHDR12;
      CU$LN[16] = CUHDR13;
      CU$LN[17] = CUHDR14;
      CU$LN[18] = CUHDR15;
      CU$LN[19] = CUHDR16;
      CU$LN[20] = CUHDR17;
 
#
*     GET UDT INFORMATION
#
 
      UCPREQ ( TYP"TYP5", REQTYP5"SSA$PUDT", RESPCODE );
 
      IF ( RESPCODE NQ RESPTYP5"OK5" )  ##
        AND ( RESPCODE NQ RESPTYP5"SSA$OK" )
      THEN
        BEGIN  # PROCESS INCORRECT RESPONSE #
        UCPREQ ( TYP"TYP1", REQTYP1"DISCONNECT", RESPCODE );
        ALTMSG$LN[0] = MSG1;
        MESSAGE ( ALTMSG[0],SYSUDF1 );
        RESTPFP ( PFP$ABORT );
        END  # PROCESS INCORRECT RESPONSE #
 
#
*     DISPLAY STATIC INFORMATION
#
 
      CHAR$10[0] = XCOD ( ORDINAL );
      IF ORDINAL LQ O"77"
      THEN                           # ORDINAL HAS 2 CHARACTERS #
        BEGIN  # TWO #
        POKEDIS(6,22,2,CHAR$R2[0]);
        END  # TWO #
 
      ELSE                           # ORDINAL HAS 3 CHARACTERS #
        BEGIN  # THREE #
        POKEDIS(6,22,3,CHAR$R3[0]);
        END  # THREE #
 
#
*     UPDATE STATUSES FROM UDT INFORMATION
#
 
      IF UD$CUON[1]
      THEN
        BEGIN
        CH2 = ALTK$CHON;
        END
 
      ELSE
        BEGIN
        CH2 = ALTK$CHOFF;
        END
 
      POKEDIS ( 6, 28, 2, CH2 );
 
      LOOPC = FALSE;
      SLOWFOR NCH = MAX$CH-2 STEP -1 UNTIL 0
      DO
        BEGIN  # DISPLAY CHANNELS/CIFS #
        IF LOOPC                     # TEST CHANNEL A EXAMINED #
        THEN
          BEGIN
          TEST NCH;
          END
 
        IF NCH EQ 1
        THEN
          BEGIN
          LINE = 18;
          COLUMN = 7;
          END
 
        ELSE
          BEGIN
          LINE = 19;
          COLUMN = 14;
          END
 
        IF ( UD$CHAND[1] NQ 0 ) AND ( NCH EQ MAX$CH-2 )
        THEN
          BEGIN
          CHAR$10[0] = XCOD ( UD$CHAND$C[1] );
 
          POKEDIS ( LINE, 4, 2, CHAR$R2[0] );  # DISPLAY CHANNEL #
 
          IF UD$CHAND$O[1]
          THEN
            BEGIN
            CH2 = ALTK$CHON;
            END
 
          ELSE
            BEGIN
            CH2 = ALTK$CHOFF;
            END
 
          POKEDIS ( LINE, 8, 2, CH2 );  # DISPLAY CHANNEL STATUS #
 
          CH1 = ALTK$CIF3;
 
          POKEDIS ( LINE, 13, 1, CH1 );  # DISPLAY CIF FOR CHANNEL #
 
          POKEDIS ( 8, COLUMN, 1, CH1 );  # DISPLAY CIF #
 
          STAT = XDXB ( ALTK$CIF3, 0, JINDEX );
 
          KDISCIF ( JINDEX, NCH );   # DISPLAY CIF ON OUT #
 
          TEST NCH;
          END
 
        IF ( ( UD$CHANC[1] NQ 0 )    ##
          AND ( NCH EQ MAX$CH-2 )    ##
          AND ( UD$CHAND[1] EQ 0 ) )  ##
          OR ( ( UD$CHANC[1] NQ 0 )  ##
          AND ( NCH EQ 0 )           ##
          AND ( UD$CHAND[1] NQ 0 ) )
        THEN
          BEGIN
          CHAR$10[0] = XCOD ( UD$CHANC$C[1] );
          POKEDIS ( LINE, 4, 2, CHAR$R2[0] );  # DISPLAY CHANNEL #
          IF UD$CHANC$O[1]
          THEN
            BEGIN
            CH2 = ALTK$CHON;
            END
 
          ELSE
            BEGIN
            CH2 = ALTK$CHOFF;
            END
 
          POKEDIS ( LINE, 8, 2, CH2 );  # DISPLAY STATUS #
 
          CH1 = ALTK$CIF2;
 
          POKEDIS ( LINE, 13, 1, CH1 );  # DISPLAY CIF NUMBER #
 
          POKEDIS ( 8, COLUMN, 1, CH1 );  # DISPLAY CIF #
 
          STAT = XDXB ( ALTK$CIF2, 0, JINDEX );
 
          KDISCIF ( JINDEX, NCH );   # DISPLAY CIF ON OUT #
 
          TEST NCH;
          END
 
        IF ( ( UD$CHANB[1] NQ 0 )    ##
          AND ( NCH EQ 1 )           ##
          AND ( UD$CHAND[1] EQ 0 )   ##
          AND ( UD$CHANC[1] EQ 0 ) )  ##
          OR ( ( UD$CHANB[1] NQ 0 )  ##
          AND ( NCH EQ 0 )           ##
          AND ( ( UD$CHAND[1] NQ 0 )  ##
          AND ( UD$CHANC[1] EQ 0)    ##
          OR ( UD$CHAND[1] EQ 0)     ##
          AND ( UD$CHANC[1] NQ 0 ) ) )
        THEN
          BEGIN
          CHAR$10[0]= XCOD ( UD$CHANB$C[1] );
 
          POKEDIS ( LINE, 4, 2, CHAR$R2[0]);  # DISPLAY CHANNEL #
 
          IF UD$CHANB$O[1]
          THEN
            BEGIN
            CH2= ALTK$CHON;
            END
 
          ELSE
            BEGIN
            CH2= ALTK$CHOFF;
            END
 
          POKEDIS ( LINE, 8, 2, CH2 );  # DISPLAY CHANNEL STATUS #
 
          CH1 = ALTK$CIF1;
 
          POKEDIS ( LINE, 13, 1, CH1 );  # DISPLAY CIF NUMBER #
 
          POKEDIS ( 8, COLUMN, 1, CH1 );  # DISPLAY CIF NUMBER #
 
          STAT = XDXB ( ALTK$CIF1, 0, JINDEX );
 
          KDISCIF ( JINDEX, NCH );   # DISPLAY CIF ON OUT #
 
          TEST NCH;
          END
 
        IF ( UD$CHANA[1] NQ 0 )      ##
          OR ( ( UD$CHANA[1] EQ 0 ) AND ( NCH GR 0 ) )
        THEN
          BEGIN
          CHAR$10[0] = XCOD ( UD$CHANA$C[1] );
 
          POKEDIS ( LINE, 4, 2, CHAR$R2[0] );  # DISPLAY CHANNEL #
 
          IF UD$CHANA$O[1]
          THEN
            BEGIN
            CH2 = ALTK$CHON;
            END
 
          ELSE
            BEGIN
            CH2 = ALTK$CHOFF;
            END
 
          POKEDIS ( LINE, 8, 2, CH2 );  # DISPLAY CHANNEL STATUS #
 
          CH1 = ALTK$CIF0;
 
          POKEDIS ( LINE, 13, 1, CH1 );  # DISPLAY CIF NUMBER #
 
          POKEDIS ( 8, COLUMN, 1, CH1 );  # DISPLAY CIF NUMBER #
 
          STAT = XDXB ( ALTK$CIF0, 0, JINDEX );
 
          KDISCIF ( JINDEX, NCH );   # DISPLAY CIF ON OUT #
 
          LOOPC = TRUE;              # FORCE EXIT OF CHANNEL LOOP #
          TEST NCH;
          END
 
        END
 
      IF C<13,1>CU$LN[19] EQ "V"
      THEN
        BEGIN
        C<13,1>CU$LN[19] = " ";
        C<4,10>CU$LN[19] = "          ";
        SLOWFOR I = 0 STEP 1 UNTIL MAX$CIF + 2
        DO
          BEGIN
          LINE = 8 + I;
          C<11,5>CU$LN[LINE] = ALTK$B5;  # CLEAR UNNECESSARY DATA #
          END
 
        END  # DISPLAY CHANNELS/CIFS #
 
 
#
*     UPDATE SM/AIF FIELDS OF *K* DISPLAY.
#
 
      P<PTHSTAT> = LOC(UD$AIF0[1]);  # PRESET TO AIF0 #
      SLOWFOR ORD = 0 STEP 1 UNTIL MAX$AIF
      DO
        BEGIN
        COLUMN = 57;
        TEMP = 10;
        IF ORD EQ 1
        THEN
          BEGIN
          P<PTHSTAT> = LOC(UD$AIF1[1]);  # RESET TO AIF1 #
          TEMP = 17;
          END
 
        FIRSTAC = 0;                 # ASSUME AC-S ARE 0-3 #
        IF B<24,24>PATH$WORD[0] NQ 0
        THEN                         # 2ND SET OF SM-S USED #
          BEGIN  # 2ND #
          FIRSTAC = MAX$AC + 1;      # RESET TO AC-S 4-7 #
          POKEDIS(TEMP,56,1,"4");    # CHANGE SM ORDINALS TO 2ND SET #
          POKEDIS(TEMP+1,56,1,"5");
          POKEDIS(TEMP+2,56,1,"6");
          POKEDIS(TEMP+3,56,1,"7");
          END  # 2ND #
 
        SLOWFOR J = FIRSTAC STEP 1 UNTIL (FIRSTAC + MAX$AC)
        DO                           # LOOP THROUGH AC-S 0-3 OR 4-7 #
          BEGIN
          I = J*6;
          LINE = TEMP + (J - FIRSTAC);
          IF B<I+PATH$DF"U$EXISTS",1>PATH$WORD[0] EQ 0
          THEN
            BEGIN
            POKEDIS ( LINE, 53, 5, ALTK$B5 );  # BLANK THE FIELD #
            TEST J;
            END
 
          IF B<I+PATH$DF"U$ON",1>PATH$WORD[0] NQ 0
          THEN
            BEGIN
            POKEDIS ( LINE, 57, 1, ALTK$ONLINE );  # ONLINE MODE #
            TEST J;
            END
 
          ELSE
            BEGIN
            POKEDIS ( LINE, 57, 1, ALTK$OFFLINE );  # OFFLINE MODE #
            TEST J;
            END
 
          END  # TEST J #
 
        END  # TEST ORD #
 
 
#
*     CLEAR OUT ALL REQUEST BITS
#
 
      END  # DISPCU #
 
    TERM
PROC DISPSM ( INDEX , INITIALIZE );
 
# TITLE DISPSM - DISPLAY *SM* INFORMATION                             #
 
      BEGIN  # DISPSM #
 
#
***   DISPSM - DISPLAY *SM* DISPLAY
*
*     *DISPSM* GENERATES AND DISPLAYS THE *SM* DISPLAY
*     FOR *SSALTER*
*
*     ENTRY         INDEX = SM TO BE DISPLAYED.
*              INITIALIZE = TRUE IF AND ONLY IF *SSEXEC* IS
*                           BEING INITIALIZED.
*
*
*     EXIT       DISPLAY SHOWN ON LEFT SCREEN.
#
 
#
****  PROC DISPSM - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC MESSAGE;                # ISSUE A DAYFILE MESSAGE #
        PROC POKEDIS;                # UPDATE *K* DISPLAY #
        PROC RESTPFP;                # RESTORE USER-S PFP AND ABORT OR
                                       RETURN #
        PROC UCPREQ;                 # ISSUE UCP REQUEST TO SSEXEC #
        FUNC XCDD C(10);             # CONV INT TO DECIMAL DISPLAY #
        FUNC XCOD C(10);             # CONVERT INTEGER TO OCTAL DISPLAY
                                     #
        END
 
#
****  PROC DISPSM - XREF LIST END.
#
 
#
*     DAYFILE MESSAGES.
#
 
      DEF MSG1   #" DISPSM - INCORRECT RESPONSE FROM SSEXEC."#;
      DEF BLANK      #" "#;
 
 
      DEF LISTCON    #0#;            # DO NOT LIST COMMON DECKS #
 
*CALL,COMBFAS
*CALL,COMBCPR
*CALL,COMBUDT
*CALL,COMTALT
 
      ARRAY CHAR10[0:0] S(3);        # CHARACTER MANIPULATION #
        BEGIN
        ITEM CHAR$10    C(00,00,10);
        ITEM CHAR$R3    C(00,42,03);
        ITEM CHAR$R2    C(00,48,02);
        ITEM CHAR$DRD0  C(01,00,10);
        ITEM CHAR$2D0   C(01,48,02);
        ITEM CHAR$D0    C(01,54,01);
        ITEM CHAR$DRD1  C(02,00,10);
        ITEM CHAR$2D1   C(02,48,02);
        ITEM CHAR$D1    C(02,54,01);
        END
 
      ITEM CH         C(2);          # TWO CHARACTERS #
      ITEM I          I;             # LOOP INDEX #
      ITEM EST$ORD    I;             # EST ORDINAL #
      ITEM INDEX      I;             # INPUT PARAMETER #
      ITEM INITIALIZE  B;            # INPUT PARAMETER #
      ITEM ORD        I;             # TEMPORARY STORAGE #
      ITEM RESPCODE   I;             # RESPONSE FROM *SSEXEC* #
      ITEM SMID       C(1);          # STORAGE MODULE ID #
      ITEM TEMP       I;             # SCRATCH #
                                               CONTROL EJECT;
 
      ITEM SMBLANK C(58) =
        "                                                        ";
      ITEM SMHDR1 C(58) =
        "                  PCU      SCU    SM/DRD";
      ITEM SMHDR2 C(58) =
        "                   ST       ST      ST";
      ITEM SM$LINE C(58) =
        "  SM       X        N        N       X";
      ITEM DRD$LINE C(58) =
        "  DRD      N                         X";
      ITEM DASH$LINE C(58) =
        "  ------------------------------------";
      ITEM VALID$COM C(58) =
        "      VALID COMMANDS ARE -";
      ITEM VAL$COM1 C(58) =
        "        K.SMI,CUNN=S.";
      ITEM VAL$COM2 C(58) =
        "        K.SMI,DRDN,CUNN=S.";
      ITEM VAL$COM3 C(58) =
        "        K.+ = DISPLAY NEXT SM";
      ITEM VAL$COM4 C(58) =
        "          I = SM IDENTIFIER";
      ITEM VAL$COM5 C(58) =
        "          N = DRD DEVICE ADDRESS";
      ITEM VAL$COM6 C(58) =
        "          NN = CU EST ORDINAL";
      ITEM VAL$COM7 C(58) =
        "          S = STATUS - U(ON),F(OFF),M(MAINTENANCE)";
      ITEM VAL$COM8 C(58) =
        "          S = STATUS - U(ON),F(OFF)";
      ITEM VAL$COM9 C(59) =
        "          + = DISPLAY NEXT SM";
                                               CONTROL EJECT;
 
#
*     BLANK THE *K* DISPLAY
#
 
      P<SM$SCREEN> = LOC(KLEFTSCRNAL);
      SLOWFOR I = LF$AL$BODY STEP 1 UNTIL LF$AL$KBECHO-1
      DO
        BEGIN
        SM$LN[I] = SMBLANK;
        SM$EOL[I] = 0;
        END
 
#
*     PAINT NON-CHANGING WORDS ON THE SCREEN
#
 
      SM$LN[3] = SMHDR1;
      SM$LN[4] = SMHDR2;
      SM$LN[6] = SM$LINE;
      SM$LN[8] = DRD$LINE;
      SM$LN[10] = DRD$LINE;
      SM$LN[11] = DASH$LINE;
      SM$LN[12] = VALID$COM;
      SM$LN[13] = VAL$COM1;
      SM$LN[14] = VAL$COM2;
      SM$LN[15] = VAL$COM3;
      SM$LN[16] = VAL$COM4;
      SM$LN[17] = VAL$COM5;
      SM$LN[18] = VAL$COM6;
      SM$LN[19] = VAL$COM8;
      IF NOT INITIALIZE
      THEN
        BEGIN
        SM$LN[19] = VAL$COM7;
        END
 
#
*     DISPLAY STATIC INFORMATION
#
 
      P<UDT$SMA> = LOC( UDT$M861[INDEX] );
      CHAR$DRD0[0] = XCDD(D0$SUN[1]);
      CHAR$DRD1[0] = XCDD(D1$SUN[1]);
      TEMP = 6;                     # SM LINE #
      POKEDIS ( TEMP , 11 , 1 , SM$ID[1] );
      ORD = SM$CUO0[1] - 1;
      IF ORD NQ -1
      THEN
        BEGIN
        P<UDT$CN> = LOC( UDT$M862[ORD] );
        EST$ORD = UD$ESTO[1];
        CHAR$10[0] = XCOD(EST$ORD);
        END
 
      ELSE
        BEGIN
        CHAR$10[0] = BLANK;
        END
 
      IF EST$ORD LQ O"77"
      THEN                           # ORDINAL HAS 2 CHARACTERS #
        BEGIN  # TWO #
        POKEDIS(TEMP,19,2,CHAR$R2[0]);
        END  # TWO #
 
      ELSE                           # ORDINAL HAS 3 CHARACTERS #
        BEGIN  # THREE #
        POKEDIS(TEMP,18,3,CHAR$R3[0]);
        END  # THREE #
 
      ORD = SM$CUO1[1] - 1;
      IF ORD NQ -1
      THEN
        BEGIN
        P<UDT$CN> = LOC( UDT$M862[ORD] );
        EST$ORD = UD$ESTO[1];
        CHAR$10[0] = XCOD ( EST$ORD );
        END
 
      ELSE
        BEGIN
        CHAR$10[0] = BLANK;          # BLANK IF NONE PRESENT #
        END
 
      IF EST$ORD LQ O"77"
      THEN                           # ORDINAL HAS 2 CHARACTERS #
        BEGIN  # TWO #
        POKEDIS(TEMP,28,2,CHAR$R2[0]);
        END  # TWO #
 
      ELSE                           # ORDINAL HAS 3 CHARACTERS #
        BEGIN  # THREE #
        POKEDIS(TEMP,27,3,CHAR$R3[0]);
        END  # THREE #
 
#
*     GET UDT INFORMATION
#
 
      UCPREQ ( TYP"TYP5", REQTYP5"SSA$PUDT", RESPCODE );
 
      IF ( RESPCODE NQ RESPTYP5"OK5" )  ##
        AND ( RESPCODE NQ RESPTYP5"SSA$OK" )
      THEN
        BEGIN  # PROCESS INCORRECT RESPONSE #
        UCPREQ ( TYP"TYP1", REQTYP1"DISCONNECT", RESPCODE );
        ALTMSG$LN[0] = MSG1;
        MESSAGE ( ALTMSG[0],SYSUDF1 );
        RESTPFP ( PFP$ABORT );
        END  # PROCESS INCORRECT RESPONSE #
 
#
*     EXTRACT UDT DATA AND UPDATE THE DYNAMIC K-DISPLAY
#
 
 
      IF SM$EXIST[1]
      THEN
        BEGIN
        IF SM$ON[1]
        THEN
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$OFFLINE );
          END
 
        IF SM$DIAG[1]
        THEN
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$MAINT );
          END
 
        IF SM$STS0[1] NQ 0
        THEN
          BEGIN  # DISPLAY ACCESSOR STATUS FROM 1ST CU #
          IF B<PATH$DF"U$ON",1>SM$STS0[1] EQ 1
          THEN
            BEGIN
            POKEDIS ( TEMP , 21 , 1 , ALTK$ONLINE );
            END
 
          ELSE
            BEGIN
            POKEDIS ( TEMP , 21 , 1 , ALTK$OFFLINE );
            END
 
          IF B<PATH$DF"U$RQ$DIAG",1>SM$STS0[1] EQ 1
          THEN
            BEGIN
            POKEDIS ( TEMP , 21 , 1 , ALTK$MAINT );
            END
 
          END  # DISPLAY ACCESSOR STATUS FROM 1ST CU #
 
        IF SM$STS1[1] NQ 0
        THEN
          BEGIN  # DISPLAY ACCESSOR STATUS FROM 2ND CU #
          IF B<PATH$DF"U$ON",1>SM$STS1[1] EQ 1
          THEN
            BEGIN
            POKEDIS ( TEMP ,30 , 1 , ALTK$ONLINE );
            END
 
          ELSE
            BEGIN
            POKEDIS ( TEMP , 30 , 1 , ALTK$OFFLINE );
            END
 
          IF B<PATH$DF"U$RQ$DIAG",1>SM$STS1[1] EQ 1
          THEN
            BEGIN
            POKEDIS ( TEMP , 30 , 1 , ALTK$MAINT );
            END
 
          END  # DISPLAY ACCESSOR STATUS FROM 2ND CU #
 
        IF NOT (SM$ON$ACK[1] OR SM$DAG$ACK[1])
        THEN
          BEGIN
          POKEDIS ( TEMP , 48 , 1 , BLANK );
          END
 
        END
 
      TEMP = 8 ;                     # SET FIRST DRD LINE #
      IF D0$EXIST[1]
      THEN
        BEGIN
        POKEDIS ( TEMP , 11 , 1 , CHAR$D0[0] );
        IF D0$SUN[1] GQ 10
        THEN                         # DRD ORDINAL HAS 2 CHARACTERS #
          BEGIN  # TWO #
          POKEDIS(TEMP,10,2,CHAR$2D0[0]);
          END  # TWO #
 
        IF D0$ON[1]
        THEN
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$OFFLINE );
          END
 
        IF D0$DIAG[1]
        THEN
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$MAINT );
          END
 
        END
 
      IF D0$STSP[1] NQ 0
      THEN
        BEGIN  # DISPLAY DRD STATUS FROM 1ST CU #
        IF B<PATH$DF"U$ON",1>D0$STSP[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 20 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 20 , 1 , ALTK$OFFLINE );
          END
 
        IF B<PATH$DF"U$RQ$DIAG",1>D0$STSP[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 20 , 1 , ALTK$MAINT );
          END
 
        END  # DISPLAY DRD STATUS FROM 1ST CU #
 
      IF D0$STSS[1] NQ 0
      THEN
        BEGIN  # DISPLAY DRD STATUS FROM 2ND CU #
        IF B<PATH$DF"U$ON",1>D0$STSS[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 29 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 29 , 1 , ALTK$OFFLINE );
          END
 
        IF B<PATH$DF"U$RQ$DIAG",1>D0$STSS[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 29 , 1 , ALTK$MAINT );
          END
 
        END  # DISPLAY DRD STATUS FROM 2ND CU #
 
      IF NOT D0$EXIST[1]
      THEN
        BEGIN
        POKEDIS ( TEMP , 2 , 5 , ALTK$B5 );  # BLANK NON-EXISTENT DRD #
        POKEDIS(TEMP,10,2,"  ");
        POKEDIS ( TEMP , 37 , 1 , BLANK );
        POKEDIS ( TEMP , 48 , 1 , BLANK );
        END
 
      TEMP = 10;                     # SET SECOND DRD LINE #
      IF D1$EXIST[1]
      THEN
        BEGIN
        POKEDIS ( TEMP , 11 , 1 , CHAR$D1[0] );
        IF D1$SUN[1] GQ 10
        THEN                         # DRD ORDINAL HAS 2 CHARACTERS #
          BEGIN  # TWO #
          POKEDIS(TEMP,10,2,CHAR$2D1[0]);
          END  # TWO #
 
        IF D1$ON[1]
        THEN
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$OFFLINE );
          END
 
        IF D1$DIAG[1]
        THEN
          BEGIN
          POKEDIS ( TEMP , 37 , 1 , ALTK$MAINT );
          END
 
 
        END
 
      IF D1$STSP[1] NQ 0
      THEN
        BEGIN  # DISPLAY DRD STATUS FROM 1ST CU #
        IF B<PATH$DF"U$ON",1>D1$STSP[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 20 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 20 , 1 , ALTK$OFFLINE );
          END
 
        IF B<PATH$DF"U$RQ$DIAG",1>D1$STSP[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 20 , 1 , ALTK$MAINT );
          END
 
        END  # DISPLAY DRD STATUS FROM 1ST CU #
 
      IF D1$STSS[1] NQ 0
      THEN
        BEGIN  # DISPLAY DRD STATUS FROM 2ND CU #
        IF B<PATH$DF"U$ON",1>D1$STSS[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 29 , 1 , ALTK$ONLINE );
          END
 
        ELSE
          BEGIN
          POKEDIS ( TEMP , 29 , 1 , ALTK$OFFLINE );
          END
 
        IF B<PATH$DF"U$RQ$DIAG",1>D1$STSS[1] EQ 1
        THEN
          BEGIN
          POKEDIS ( TEMP , 29 , 1 , ALTK$MAINT );
          END
 
        END  # DISPLAY DRD STATUS FROM 2ND CU #
 
      IF NOT D1$EXIST[1]
      THEN
        BEGIN
        POKEDIS ( TEMP , 2 , 5 , ALTK$B5 );  # BLANK NON-EXISTENT DRDS #
        POKEDIS(TEMP,10,2,"  ");
        POKEDIS ( TEMP , 37 , 1 , BLANK );
        POKEDIS ( TEMP , 48 , 1 , BLANK );
        END
 
 
      END  # DISPSM #
 
    TERM
PROC KDISCIF ( INDEX, CIFORD );
# TITLE KDISCIF - DISPLAY CIF DATA FROM UDT.                          #
 
      BEGIN  # KDISCIF #
 
#
**    KDIXCIF - DISPLAY CIF DATA FROM UDT.
*
*     PROC KDISCIF ( INDEX, CIFORD )
*
*     ENTRY - INDEX = DEVICE ADDRESS OF CIF TO DISPLAY.
*             CIFORD = INDICATOR DESCRIBING COLUMN TO UPDATE.
*
*     EXIT - *CU* DISPLAY UPDATED FOR CIF COLUMNS.
*
#
 
      ITEM INDEX      I;             # INPUT VARIABLE #
      ITEM CIFORD     I;             # INPUT VARIABLE #
 
#
****  PROC KDISCIF - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC POKEDIS;                # POKE DATA INTO *K* DISPLAY
                                       BUFFER #
        PROC KDISDTX;                # UPDATE DTI/DTO DISPLAY #
        END
 
#
*     KDISCIF - XREF LIST END.
#
 
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
 
*CALL,COMBFAS
*CALL,COMBUDT
*CALL,COMTALT
                                               CONTROL EJECT;
 
      ITEM COLUMN     I;             # COLUMN NUMBER #
      ITEM COLUMNM4   I;             # COLUMN NUMBER MINUS 4 #
      ITEM I          I;             # INTEGER SCRATCH #
      ITEM J          I;             # LOOP VARIABLE #
      ITEM LINE       I;             # LINE IN *K* DISPLAY #
                                               CONTROL EJECT;
      IF CIFORD EQ 0
      THEN
        BEGIN
        COLUMN = 15;
        COLUMNM4 = 11;
        END
 
      ELSE
        BEGIN
        COLUMN = 8;
        COLUMNM4 = 4;
        END
 
 
      IF INDEX GQ 2
      THEN
        BEGIN
        GOTO CIF23;                  # JUMP IF CIF2 OR CIF3 #
        END
 
#
*     LOOP FOR EACH DTI/DTO
#
 
      SLOWFOR J = 0 STEP 1 UNTIL MAX$CIF
      DO
        BEGIN  # CIF01 TESTING #
        LINE = J + 10;
        I = J*6;
        IF B< I+(INDEX*24)+PATH$DF"U$EXISTS", 1>UD$CIF01[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK DISPLAY #
          KDISDTX(J);
          TEST J;
          END
 
        KDISDTX ( J );               # DISPLAY DTI/DTO ON OUT #
 
        IF B< I+(INDEX*24)+PATH$DF"U$RQ$DIAG", 1 >UD$CIF01[1] NQ 0
          THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # DIAG MODE #
          TEST J;
          END
 
        IF B< I+(INDEX*24)+PATH$DF"U$ON", 1 >UD$CIF01[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MD #
          END
 
        END  # CIF01 TESTING #
 
      RETURN;
 
CIF23:
 
#
*     LOOP FOR EACH DTI/DTO ON CIF2/CIF3
#
 
      INDEX = INDEX - 2;
      SLOWFOR J = 0 STEP 1 UNTIL MAX$CIF
      DO
        BEGIN  # CIF23 TESTING #
        LINE = J + 10;
        I = J*6;
        IF B< I+(INDEX*24)+PATH$DF"U$EXISTS", 1>UD$CIF23[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK DISPLAY #
          TEST J;
          END
 
        KDISDTX ( J );               # DISPLAY DTI/DTO ON OUT #
 
        IF B< I+(INDEX*24)+PATH$DF"U$RQ$DIAG", 1 >UD$CIF23[1] NQ 0
          THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # DIAG MODE #
          TEST J;
          END
 
        IF B< I+(INDEX*24)+PATH$DF"U$ON", 1 >UD$CIF23[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MD #
          END
 
        END  # CIF23 TESTING #
 
      RETURN;
 
      END  # KDISCIF #
 
    TERM
PROC KDISDIF ( INDEX );
# TITLE KDISDIF - DISPLAY DIF DATA FROM UDT.                          #
 
      BEGIN  # KDISDIF #
 
#
**    KDISDIF - DISPLAY DTI/DTO DATA FROM UDT.
*
*     PROC KDISDIF ( INDEX )
*
*     ENTRY - INDEX = DEVICE ADDRESS OF DIF TO DISPLAY.
*
*     EXIT - *CU* DISPLAY UPDATED FOR DIF COLUMNS.
*
#
 
      ITEM INDEX      I;             # INPUT VARIABLE #
 
#
****  PROC KDISDIF - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC KDISDRC;                # DISPLAY DRC ON OUT #
        PROC POKEDIS;                # POKE DATA INTO *K* DISPLAY
                                       BUFFER #
        END
 
#
*     KDISDIF - XREF LIST END.
#
 
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
*CALL,COMBFAS
*CALL,COMBUDT
*CALL,COMTALT
                                               CONTROL EJECT;
 
      ITEM COLUMN     I;             # *K* DISPLAY COLUMN #
      ITEM COLUMNM4   I;             # *K* DISPLAY COLUMN #
      ITEM I          I;             # INTEGER SCRATCH #
      ITEM J          I;             # LOOP VARIABLE #
      ITEM LINE       I;             # LINE IN *K* DISPLAY #
                                               CONTROL EJECT;
 
      COLUMN = 36;                   # POSITION COLUMN #
      COLUMNM4 = 32;                 # POSITION 5 BLANKS #
      I = INDEX*24;                  # POSITION TO CORRECT FIELD #
 
#
*     LOOP FOR EACH DIF
#
 
      SLOWFOR J = 0 STEP 1 UNTIL MAX$DRC
      DO
        BEGIN  # DIF TESTING #
        LINE = J + 10;
        IF INDEX EQ 1
        THEN
          BEGIN  # ADJUST FOR THE DISPLAY #
          LINE = LINE + 7;
          END  # ADJUST FOR THE DISPLAY #
 
 
        KDISDRC ( J );               # DISPLAY DRC ON OUT #
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1>UD$DIF[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1>UD$DIF[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1>UD$DIF[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MD #
          END
 
        END  # DIF TESTING #
 
      END  # KDISDIF #
 
    TERM
PROC KDISDRC ( INDEX );
# TITLE KDISDRC - DISPLAY DRC DATA FROM UDT.                          #
 
      BEGIN  # KDISDRC #
 
#
**    KDISDRC - DISPLAY DRC DATA FROM UDT.
*
*     PROC KDISDRC ( INDEX )
*
*     ENTRY - INDEX = DEVICE ADDRESS OF DRC TO DISPLAY.
*
*     EXIT - *CU* DISPLAY UPDATED FOR *DRC* COLUMNS.
*
#
 
      ITEM INDEX      I;             # INPUT VARIABLE #
 
#
****  PROC KDISDRC - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC POKEDIS;                # POKE DATA INTO *K* DISPLAY
                                       BUFFER #
        FUNC XCDD C(10);             # CONVERT DECIMAL TO DISP CODE #
        END
 
#
*     KDISDRC - XREF LIST END.
#
 
      DEF LISTCON #0#;               # DO NOT LIST COMMON DECKS #
*CALL,COMBFAS
*CALL,COMBUDT
*CALL,COMTALT
 
#
*      SWITCH STATEMENT
#
 
      SWITCH DRCCOLUMN
        DRC0,
        DRC1,
        DRC2,
        DRC3;
                                               CONTROL EJECT;
 
      ITEM COLUMN     I;             # *K* DISPLAY COLUMN #
      ITEM COLUMNM4   I;             # *K* DISPLAY COLUMN #
      ITEM I          I;             # INTEGER SCRATCH #
      ITEM J          I;             # LOOP VARIABLE #
      ITEM LINE       I;             # LINE IN *K* DISPLAY #
 
#
*     CHARACTER MANIPULATION.
#
 
      ARRAY DRDSCR[0:0] S(1);        # FOR DRD ORDINALS > 7 #
        BEGIN
        ITEM CHAR10     C(00,00,10);
        ITEM CHAR2      C(00,48,02);
        ITEM CHAR       C(00,54,01);
        END
 
                                               CONTROL EJECT;
 
#
*     INITIALIZE *K* DISPLAY COORDINATES.
#
 
      IF (INDEX EQ 0 AND UD$DRCP0[1] EQ 0)  ##
        OR (INDEX EQ 1 AND UD$DRCP1[1] EQ 0)  ##
        OR (INDEX EQ 2 AND UD$DRCP2[1] EQ 0)  ##
        OR (INDEX EQ 3 AND UD$DRCP3[1] EQ 0)
      THEN                           # DRC DOES NOT EXIST ON THIS CU #
        BEGIN  # SKIP #
        RETURN;
        END  # SKIP #
 
      IF INDEX GR 1
      THEN
        BEGIN                        # ADJUST - EXPANDED CONFIGURATION #
        LINE = 8;
        COLUMN = 42 + (INDEX-2)*7;
        IF INDEX EQ 2
        THEN
          BEGIN
          POKEDIS( LINE , COLUMN , 1 , ALTK$DRC2 );  # SET DRC2 #
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE , COLUMN , 1 , ALTK$DRC3 );  # SET DRC3 #
          END
 
        LINE = 10;                   # FIRST LINE OF DRD-S #
        SLOWFOR J = (MAX$DRD + 1) STEP 1 UNTIL MAX$DRDDA
        DO                           # RESET TO SECOND DRD GROUP #
          BEGIN  # RESET #
          IF J LS 10
          THEN                       # DRD IS ONE DIGIT #
            BEGIN  # ONE #
            CHAR10 = XCDD(J);
            POKEDIS(LINE,COLUMN,1,CHAR);
            END  # ONE #
 
          ELSE                       # DRD IS TWO DIGITS #
            BEGIN  # TWO #
            CHAR10 = XCDD(J);
            POKEDIS(LINE,COLUMN,2,CHAR2);
            END  # TWO #
 
          LINE = LINE + 1;
          END  # RESET #
 
        END                          # ADJUST - EXPANDED CONFIGURATION #
 
      IF INDEX EQ 0 ##
        OR INDEX EQ 2
 
      THEN
        BEGIN
        COLUMN = 43;                 # COLUMN FOR DRC0/DRC2 DATA #
        COLUMNM4 = 39;
        END
 
      ELSE
        BEGIN
        COLUMN = 50;                 # COLUMN FOR DRC1/DRC3 DATA #
        COLUMNM4 = 46;
        END
 
      GOTO DRCCOLUMN[INDEX];
 
DRC0:
#
*     LOOP FOR EACH DRD ON DRC0
#
 
      SLOWFOR J = 0 STEP 1 UNTIL MAX$DRD
      DO
        BEGIN  # DRD TESTING #
        LINE = J + 10;
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1>UD$DRCP0[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1>UD$DRCP0[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1>UD$DRCP0[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MODE #
          END
 
        END  # DRD TESTING #
 
      RETURN;
 
DRC1:
 
#
*     LOOP FOR EACH DRD ON DRC1
#
 
      SLOWFOR J = 0 STEP 1 UNTIL MAX$DRD
      DO
        BEGIN  # DRD TESTING FOR DRC1 #
        LINE = J + 10;
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1 >UD$DRCP1[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1 >UD$DRCP1[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1 >UD$DRCP1[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MODE #
          END
 
        END  # DRD TESTING FOR DRC1 #
 
      RETURN;
DRC2:
#
*     LOOP FOR EACH DRD ON DRC2
#
 
      SLOWFOR J = 0 STEP 1 UNTIL 1
      DO
        BEGIN                        #DRD TESTING FOR DRC 2 #
        LINE = J + 10;
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1 >UD$DRCP2[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1 >UD$DRCP2[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1 >UD$DRCP2[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MODE #
          END
 
        END  # DRD TESTING FOR DRC2 #
      COLUMN = COLUMN + 1;
      SLOWFOR J = 2 STEP 1 UNTIL MAX$DRD
      DO
        BEGIN  # DRD TESTING #
        LINE = J + 10;
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1 >UD$DRCP2[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 6, ALTK$B6 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1 >UD$DRCP2[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1 >UD$DRCP2[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MODE #
          END
 
        END  # DRD TESTING FOR DRC2 #
 
      RETURN;
DRC3:
 
#
*     LOOP FOR EACH DRD ON DRC 3
#
 
      SLOWFOR J = 0 STEP 1 UNTIL 1
      DO
      BEGIN  # DRD TESTING #
        LINE = J + 10;
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1 >UD$DRCP3[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1 >UD$DRCP3[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1 >UD$DRCP3[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MODE #
          END
 
        END  # DRD TESTING FOR DRC3 #
 
      COLUMN = COLUMN + 1;           # PRESET FOR 2-DIGIT DRD-S #
      SLOWFOR J = 2 STEP 1 UNTIL MAX$DRD
      DO
        BEGIN  # DRD TESTING #
        LINE = J + 10;
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1 >UD$DRCP3[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 6, ALTK$B6 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1 >UD$DRCP3[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1 >UD$DRCP3[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MODE #
          END
 
        END  # DRD TESTING FOR DRC3 #
      END  # KDSIDRC #
 
    TERM
 
PROC KDISDTX ( INDEX );
# TITLE KDISDTX - DISPLAY DTI/DTO DATA FROM UDT.                      #
 
      BEGIN  # KDISDTX #
 
#
**    KDISDTX - DISPLAY DTI/DTO DATA FROM UDT.
*
*     PROC KDISDTX ( INDEX )
*
*     ENTRY - INDEX = DEVICE ADDRESS OF DTI/DTO TO DISPLAY.
*
*     EXIT - *CU* DISPLAY UPDATED FOR DTI/DTO COLUMNS.
*
#
 
      ITEM INDEX      I;             # INPUT VARIABLE #
 
#
****  PROC KDISDTX - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC POKEDIS;                # POKE DATA INTO *K* DISPLAY
                                       BUFFER #
        PROC KDISDIF;                # DISPLAY DIF STATUS #
        END
 
#
*     KDISDTX - XREF LIST END.
#
 
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
*CALL,COMBFAS
*CALL,COMBUDT
*CALL,COMTALT
                                               CONTROL EJECT;
 
      ITEM COLUMN     I;             # *K* DISPLAY COLUMN #
      ITEM COLUMNM4   I;             # *K* DISPLAY COLUMN #
      ITEM I          I;             # INTEGER SCRATCH #
      ITEM J          I;             # LOOP VARIABLE #
      ITEM LINE       I;             # LINE IN *K* DISPLAY #
                                               CONTROL EJECT;
 
#
*     INITIALIZE *K* DISPLAY COORDINATES.
#
 
      IF INDEX LQ MAX$DTI
      THEN
        BEGIN
        COLUMN = 22;                 # COLUMN FOR *DTI* DATA #
        COLUMNM4 = 18;
        END
 
      ELSE
        BEGIN
        COLUMN = 29;                 # COLUMN FO *DTO* DATA #
        COLUMNM4 = 25;
        GOTO DTO;                    # PROCESS *DTO* REQUEST #
        END
 
      I = INDEX*12;                  # POSITION TO CORRECT FIELD #
 
#
*     LOOP FOR EACH DTI
#
 
      SLOWFOR J = 0 STEP 1 UNTIL MAX$DIF
      DO
        BEGIN  # DTI TESTING #
        LINE = J + 10;
        IF INDEX EQ 1
        THEN
          BEGIN  # ADJUST FOR THE DISPLAY #
          LINE = LINE + 5;
          END  # ADJUST FOR THE DISPLAY #
 
 
        KDISDIF ( J );               # DISPLAY DIF ON OUT #
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1>UD$DTI[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1>UD$DTI[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1>UD$DTI[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MD #
          END
 
        END  # DTI TESTING #
 
      RETURN;
 
DTO:
 
      INDEX = INDEX - 2;
      I = INDEX*12;
      SLOWFOR J = 0 STEP 1 UNTIL MAX$DIF
      DO
        BEGIN  # DTO TESTING #
        LINE = J + 10;
        IF INDEX EQ 1
        THEN
          BEGIN  # ADJUST FOR THE DISPLAY #
          LINE = LINE + 5;
          END  # ADJUST FOR THE DISPLAY #
 
        KDISDIF ( J );               # DISPLAY DIF ON OUT #
 
        IF B< (J*6)+I+PATH$DF"U$EXISTS", 1>UD$DTO[1] EQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMNM4, 5, ALTK$B5 );  # BLANK FIELD #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$RQ$DIAG", 1>UD$DTO[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$MAINT );  # SET DIAG MODE #
          TEST J;
          END
 
        IF B< (J*6)+I+PATH$DF"U$ON", 1>UD$DTO[1] NQ 0
        THEN
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$ONLINE );  # ONLINE MODE #
          TEST J;
          END
 
        ELSE
          BEGIN
          POKEDIS ( LINE, COLUMN, 1, ALTK$OFFLINE );  # OFFLINE MD #
          END
 
        END  # DTO TESTING #
 
      INDEX = INDEX +2;
 
      END  # KDISDTX #
 
    TERM
PROC POKEDIS ( LINE, CHAR, COUNT, VALUE );
 
# TITLE POKEDIS - SET VALUE IN DISPLAY.                               #
 
      BEGIN  # POKEDIS #
 
#
**    POKEDIS - SET CHARACTER VALUE IN DISPLAY.
*
*     *POKEDIS* POKES A CHARACTER  INTO AN EXISTING
*     *SM* OR *CU* DIPLAY. THE CHARACTER INIDICATES THE
*     CURRENT OR REQUESTED STATE OF ONE OF PATHS/NODES
*     IN THE M860 CURRENTLY UNDER INSPECTION BY *SSALTER*.
*
*     ENTRY
*       LINE - ONE OF THE (LF$AL$NLIN) LINES IN THE *K* DISPLAY.
*       CHAR - THE STARTING COLUMN NUMBER TO BE USED.
*       COUNT - THE NUMBER OF CHARACTERS IN THE STRING.
*       VALUE - THE CHARACTER STRING TO BE INSERTED.
*
*
*     EXIT
*
*       CHARACTER(S) POKED INTO THE DISPLAY.
#
 
#
**** PROC POKEDIS - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        END
 
#
**** PROC POKEDIS - XREF LIST END.
#
 
      DEF LISTCON   #0#;             # DO NOT LIST COMMON DECKS #
*CALL,COMBFAS
*CALL,COMTALT
 
      ITEM LINE       I;             # INPUT PARAMETER #
      ITEM CHAR       I;             # INPUT PARAMETER #
      ITEM COUNT      I;             # INPUT PARAMETER #
      ITEM VALUE      C(10);         # INPUT PARAMETER #
                                               CONTROL EJECT;
 
#
*     SET CHARACTER(S) INTO DISPLAY
#
 
      C<CHAR,COUNT>SM$LN[LINE] = VALUE;
      END  # POKEDIS #
 
    TERM
PROC UCPREQ((REQTYPE),(REQCODE),RESPCODE);
# TITLE UCPREQ - ISSUES TYPE 1 OR 5 UCP REQUEST TO EXEC.              #
 
      BEGIN  # UCPREQ #
 
#
**    UCPREQ - ISSUES A TYPE 1 OR 5 UCP REQUEST TO EXEC.
*
*     PROC UCPREQ((REQTYPE),(REQCODE),RESPCODE)
*
*     ENTRY    (REQTYPE)   = REQUEST TYPE.
*              (REQCODE)   = REQUEST CODE.
*              (USER$FAM)  = FAMILY NAME.
*              (REQID$AL)     = REQUESTOR ID.
*              (SSID$AL)      = SUBSYSTEM ID.
*              P<CPR>      = FWA OF CALLSS PARAMETER BLOCK.
*
*     EXIT     (RESPCODE) = RESPONSE FROM EXEC.
*
*     MESSAGES  SSALTER ABNORMAL, UCPREQ.
*
*     NOTES    THE CALLSS PARAMETER REQUEST BLOCK IS SET
*              UP FOR A TYPE 1 OR TYPE 5 UCP REQUEST AND
*              THE REQUEST IS ISSUED TO EXEC.
#
 
      ITEM REQTYPE    I;             # REQUEST TYPE #
      ITEM REQCODE    I;             # REQUEST CODE #
      ITEM RESPCODE   I;             # RESPONSE FROM EXEC #
 
#
****  PROC UCPREQ - XREF LIST BEGIN.
#
 
      XREF
        BEGIN
        PROC ABORT;                  # STOPS PROCESSING #
        PROC CALLSS;                 # ISSUES A UCP/SCP REQUEST #
        PROC MESSAGE;                # DISPLAYS MESSAGES #
        PROC RESTPFP;                # RESTORE USER-S *PFP* AND ABORT
                                       OR RETURN #
        PROC ZFILL;                  # ZERO FILL A BUFFER #
        END
 
#
****  PROC UCPREQ - XREF LIST END.
#
 
      DEF PROCNAME   #"UCPREQ."#;    # PROC NAME #
 
      DEF LISTCON    #0#;            # DO NOT LIST COMDECKS #
*CALL COMBFAS
*CALL COMBCPR
*CALL COMBPFP
*CALL,COMBUDT
*CALL COMSPFM
*CALL COMTALT
 
      ITEM I          I;             # LOOP INDUCTION VARIABLE #
      ITEM LOOPC      B;             # LOOP CONTROL #
      ITEM WORDCOUNT  I;             # WORD COUNT OF UDT #
 
                                               CONTROL EJECT;
 
#
*     ZERO FILL CALLSS PARAMETER BLOCK.
#
 
      ZFILL ( CPR[0], 1 );           # ZERO FIRST WORD #
      ZFILL ( CPR[3], CPRLEN - 3 );  # ZERO WORDS 4 - CPRLEN #
 
      CPR$RQT[0] = REQTYPE;          # SET UP PARAMETER BLOCK #
      CPR$RQC[0] = REQCODE;
      CPR$RQI[0] = REQID$AL;
      CPR$RT[0] = 2;                 # HAVE SYSTEM CONTROL REQUEST #
      CPR$ADDR2 = LOC(UDT$HDR);
      WORDCOUNT = 0;
 
      IF REQTYPE EQ TYP"TYP1"
      THEN                           # TYPE 1 REQUEST #
        BEGIN
        CPR$WC[0] = TYP1$WC;
        END
 
      ELSE
        BEGIN  # TYPE 5 OR ILLEGAL REQUEST #
        IF REQTYPE EQ TYP"TYP5"
        THEN                         # TYPE 5 REQUEST #
          BEGIN
          IF REQCODE EQ REQTYP5"SSA$PUDT"
          THEN
            BEGIN
            CPR$ADDR4 = PRULEN;      # SET COUNT AT *CPUMTR* MAX #
            CPR$ADDR3 = 0;
            END
 
          CPR$WC[0] = TYP5$WC;
          END
 
        ELSE                         # ILLEGAL REQUEST TYPE #
          BEGIN
          ALTMSG$PROC[0] = PROCNAME;
          MESSAGE(ALTMSG[0],SYSUDF1);
          RESTPFP(PFP$ABORT);        # RESTORE USER-S *PFP* AND ABORT #
          END
 
        END  # TYPE 5 OR ILLEGAL REQUEST #
 
      CALLSS(SSID$AL,CPR[0],RCL);
 
      IF CPR$ES[0] EQ 0
      THEN
        BEGIN
        RESPCODE = CPR$RQR[0];       # RETURN RESPONSE FROM EXEC #
        END
 
      ELSE
        BEGIN
        RESPCODE = CPR$ES[0];        # RETURN RESPONSE FROM SYSTEM #
        RETURN;
        END
 
      IF REQTYPE NQ TYP"TYP5"
      THEN
        BEGIN
        RETURN;                      # RETURN IF NOT *SSA$PUDT* REQ #
        END
 
 
      IF REQCODE NQ REQTYP5"SSA$PUDT"
      THEN
        BEGIN
        RETURN;                      # RETURN IF NOT PASS UDT REQUEST #
        END
 
      ELSE
        BEGIN
        P<UDT$WORD> = LOC(UDT$HDR);
        WORDCOUNT = UDT$WORDCNT - PRULEN;
        LOOPC = FALSE;
        SLOWFOR I = 0 STEP PRULEN WHILE ( NOT LOOPC )
        DO
          BEGIN
          CPR$ADDR2 = CPR$ADDR2 + PRULEN;
          CPR$ADDR3 = CPR$ADDR3 + PRULEN;
          IF WORDCOUNT GR PRULEN
          THEN
            BEGIN
            CPR$ADDR4[0] = PRULEN;
            WORDCOUNT = WORDCOUNT - PRULEN;
            END
 
          ELSE
            BEGIN
            CPR$ADDR4[0] = WORDCOUNT;
            LOOPC = TRUE;
            END
 
          CPR$C[0] = FALSE;
          CPR$ES[0] = 0;
          CALLSS ( SSID$AL, CPR[0], RCL );
 
          TEST I;
          END
 
        IF CPR$ES[0] NQ 0
        THEN
          BEGIN
          RESPCODE = CPR$ES[0];
          RETURN;
          END
 
        ELSE
          BEGIN
          RESPCODE = CPR$RQR[0];
          END
 
        END
 
 
      END  # UCPREQ #
 
    TERM