*DECK,SMP 
USETEXT IP$COM
USETEXT MISC$ 
USETEXT RBF$LEV 
USETEXT TCH$COM 
USETEXT TSB$COM 
USETEXT ABH$COM 
USETEXT ACN$COM 
USETEXT SMDEF 
USETEXT SMAPPFC 
USETEXT SMPFC 
USETEXT DCB$COM 
USETEXT GLOBALI 
USETEXT PRU$COM 
USETEXT RBF$COM 
USETEXT SM$COM
USETEXT TCB$COM 
USETEXT UCB$COM 
      PROC SMP; 
      BEGIN # SMP # 
*IF DEF,IMS 
 #
*1DC  SMP 
* 
*     1. PROC NAME           AUTHOR              DATE 
         SMP                 SEYUNG OH           DEC 4,1979 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        PROCESS ALL SUPERVISORY MESSAGES RECEIVED ON CONNECTION ZERO.
* 
*     3. METHOD USED. 
*        SMP (SUPERVISORY MESSAGE PROCESSOR) PROCESSES EACH OF THE
*        FOLLOWING SUPERVISORY MESSAGE -
* 
*        SM -       PROCESSED BY- 
*        BI/MARK    BI$MARK 
*        CON/CB     CON$CB
*        CON/END/N  CON$END 
*        CON/REQ    CON$REQ 
*        FC/ACK     PF$ACK
*        FC/BRK     FC$BRK
*        FC/INACT   FC$INACT
*        FC/INIT    FC$INIT 
*        FC/NAK     FC$NAK
*        FC/STP     FC$STP
*        SHUT/INSD  SHUT$DOWN 
*        TCH/TCHAR  TCH$TCHAR 
*        INTR/USR   INTR$USR
*        IFC/ABORT  IFC$ABT 
*        IFC/JOB    IFC$JOB 
*        IFC/STPD   IFC$STPD
*        IFC/EOJ    IFC$EOJ 
*        IFC/END    IFC$END 
*        OFC/STP    OFC$STP 
*        OFC/STPD   OFC$STPD
*        OFC/ABORT  OFC$ABT 
*        OFC/EOO    OFC$EOO 
*        OFC/DATA   OFC$DATA
*        PRU/ON     PRU$ON
*        ERR/LGL    ERR$LGL 
*        PRU/ON/N   PRU$ON$N
*        PRU/ON/A   PRU$ON$A
* 
*        SMP IS CALLED BY GETDATA WITH THE BUFFER CONTAINING THE
*        SUPERVISORY MESSAGE. SMP DETERMINES WHICH SM IS RECEIVED 
*        BY PFC/SFC AND CALLS THE APPROPRIATE MODULE DETAILED BELOW.
*        IF THE PFC/SFC IS NOT ONE LISTED ABOVE A DAYFILE MESSAGE 
*        IS ISSUED LISTING THE SM. UPON EXIT THE SM BUFFER IS 
*        RELEASE EXCEPT IN THE CASE OF A CON/REQ WHICH IS TO BE 
*        SUBSEQUENTLY PROCESSED BY THE MODULE NEW. SMP RETURNS TO 
*        GETDATA. 
* 
*        BREAK INDICATION MARKER - BI/MARK
*        BI$MARK  IF RECEIVED ON A BATCH DEVICE CONNECTION, 
*                 A SM ERROR MESSAGE IS ISSUED TO THE DAYFILE.
* 
*                 IF RECEIVED ON A CONSOLE CONNECTION, INDICATES THE
*                 POINT IN THE INPUT DATA STREAM WHERE A USER BREAK 
*                 WAS PREVIOUSLY ENTERED.  A RO/MARK IS SENT ON THE 
*                 DATA CONNECTION.
* 
*        CONNECTION BROKEN SM - CON/CB
*        CON$CB   IF THE CONNECTION IS IN CONNECTED OR PRE-CONNECTED
*                 STATE THE CONNECTION IS LINKED TO CON$END MODULE
*                 (THIS IS NOT CON$END IN SMP). 
*                 IF THE CONNECTION IS NOT EXISTENT, A DAYFILE ERROR
*                 MESSAGE IS ISSUED. (SEE SM$ERR BELOW) 
*                 IF THE CONNECTION IS A CONSOLE ITS END FLAG IS SET
*                 AND THE END FLAG AND FAILURE FLAG OF ITS ASSOCIATED 
*                 BATCH DEVICES ARE SET.
*                 IF THE CONNECTION IS A BATCH DEVICE, IT"S END AND 
*                 FAILURE FLAG ARE SET. 
* 
*        CONNECTION END NORMAL RESPONSE - CON/END/N 
*        CON$END  IF THE CONNECTION IS IN END-CONNECTION STATE IT"S 
*                 END FLAG IS CLEARED. IF IN ANY OTHER STATE A
*                 DAYFILE ERROR MESSAGE IS ISSUED.
* 
*                 NOTE - A CONNECTION SHOULD BE LINKED TO EITHER
*                        FIN$CON OR FIN$DEV WAITING FOR ITS END 
*                        FLAG TO BE CLEARED.
* 
*        CONNECTION REQUEST SM - CON/REQ
*        CON$REQ  IF THE ACN SPECIFIED IS ALREADY ASSIGN OR 
*                 IDLE SHUTDOWN IS IN PROGRESS A ABNORMAL 
*                 RESPONSE IS SENT. FOR DUPLICATE ACN A DAYFILE 
*                 MESSAGE IS ISSUED. (SEE SM$ERR BELOW) 
*                 THE ORDINAL OF THE SM BUFFER IS PUT IN THE
*                 ACN TABLE FOR THE GIVEN ACN AND THE ACN LINKED
*                 TO MODULE NEW.
*                 IF A BATCH DEVICE CONNECTION, THE CONTROL BLOCK OF
*                 THE MINIMUM SIZE IS REQUEST AND ITS ORDINAL PLACED
*                 IN THE ACN TABLE ENTRY. THE SUPERVISORY MESSAGE 
*                 BLOCK SIZE HAD BEEN REDUCED FROM LTHE LARGEST BLK SIZE
*                 TO THE SIZE SPECIFIED IN THE SM"S HEADER THEREBY
*                 GUARANTEEING ENOUGH SPACE FOR THE BATCH DEVICE"S
*                 CONTROL BLOCK 
*                 THE FLAG TO RELEASE THE SM"S BLOCK AT THE END OF
*                 SMP PROCESSING IS SET FALSE.
* 
*        LOGICAL ERROR SM - ERR/LGL/SM
*        SM$ERR   A SUPERVISORY MESSAGE ERROR MESSAGE 
*                 TO THE DAYFILE IS ISSUED (SEE SM$ERR BELOW).
* 
*        FLOW CONTROL ACKNOWLEDGEMENT SM - FC/ACK SM
*        FC$ACK   IF ACK RECEIVED ON AN INACTIVE CONNECTION A SM ERROR
*                 MESSAGE IS ISSUED TO THE DAYFILE. 
*                 IF ACK IS RECEIVED ON AN ACTIVE CONNECTION THE
*                 ACK OUTSTANDING ITEM (EITHER TCB$NXTACKSN FOR A 
*                 CONSOLE CONNECTION OR TCB$DEVACK FOR A BATCH
*                 CONNECTION IS INCREMENTED UNLESS IT WOULD EXCEED
*                 THE MAXIMUM BSN (MAXBSN) IN WHICH CASE IT IS SET TO 
*                 1. FOR BATCH CONNECTION THE ACK RECEIVED FLAG IS SET. 
*                 IF THE ACK BSN IS NOT EQUAL TO THE EXPECT VALUE 
*                 A SM ERROR MESSAGE IS ISSUED TO THE DAYFILE.
* 
*        FLOW CONTROL BREAK RECEIVED SM- FC/BRK/SM
*        FC$BRK   IF A USER BREAK IS ISSUED ON THE CONSOLE CONNECTION 
*                 THEN TCB$DIS IS SET TO ZERO TO DISCONTINUE A REFRESH
*                 DISPLAY, IF ANY, AND A READY MESSAGE IS QUEUED UP TO
*                 BE SENT TO THE CONSOLE. 
* 
*                 IF A NOT READY IS RECEIVED ON AN OUTPUT DEVICE
*                 NOT READY FLAG IS SET IN TCB$DEVICE AND RESET 
*                 IS SET TO ACK IF NOT PREVIOUSLY SET AND NOT 
*                 CLEARED. TCB$DEVACK, NEXT ACK EXPECTED, IS SET
*                 TO TCB$DEVBSN TO SHOW NO OUTSTANDING BLOCKS.
* 
*                 IF BAD DATA HAS BEEN SENT ON AN OUTPUT CONNECTION 
*                 IT IS HANDLE AS NOT READY BUT THE BAD DATA FLAG IS SET
*                 INSTEAD OF THE NOT READY. 
* 
*                 IF NONE OF THE ABOVE CASES THEN A SM ERROR IS ISSUED
*                 TO THE DAYFILE. 
* 
*                 A FC/RST IS SENT ON THE CONNECTION. 
* 
*        FLOW CONTROL INACTIVE CONNECTION - FC/INACT
*        FC$INACT THIS SM IS IGNORED. 
* 
*        FLOW CONTROL CONNECTION INITIALIZED - FC/INIT
*        FC$INIT  IF THE ACN"S STATE IS ANYTHING BUT CONNECTED
*                 A DAYFILE SM ERROR MESSAGE IS ISSUED. 
* 
*                 IF THIS IS A CONSOLE CONNECTION THE ACN IS LINKED 
*                 TO IDLE, IF A CARD READER IT IS LINKED TO UCM,
*                 IF A OUTPUT DEVICE IT IS LINKED TO DCM. 
* 
*                 THE END CONNECTION FLAG IS SET TO BE THE SAME AS
*                 IDLESHUTDOWN. 
* 
*                 A RESPONSE FC/INIT IS ISSUED. 
* 
*        FLOW CONTROL NOT ACKNOWLEDGEMENT - FC/NAK
*        FC$NAK   IF THE ACN BEING NAK"ED IS NOT IN AN ACTIVE STATE 
*                 A SM ERROR MESSAGE IS ISSUED TO THE DAYFILE.
* 
*                 A NAK ON A CONSOLE CONNECTION SETS THE ERROR FLAG IN
*                 THE TCB.
* 
*                 A NAK ON A BATCH DEVICE SETS THE TERMINAL FAILURE 
*                 FLAG AND END CONNECTION FLAG. 
* 
*        FLOW CONTROL STOP - FC/STP 
*        FC$STP   FOR BATCH CONNECTIONS 
* 
*                   IF A STOP IS ISSUED BECAUSE OF A TERMINAL FAILURE 
*                   THE TERMINAL FAILURE AND END CONNECTION FLAGS ARE 
*                   SET.
* 
*                   IF A STOP IS ISSUED BECAUSE THE TERMINAL IS 
*                   IN INTERACTIVE MODE OR AN OUTPUT DEVICE IS
*                   BUSY, THE DEVICE"S TERMINAL BUSY FLAG IS SET. 
* 
*                   IF A TERMINAL BUSY STOP IS ISSUED ON A CARD 
*                   READER CONNECTION A SM ERROR IS SENT TO THE 
*                   DAYFILE.
* 
*                   IF NONE OF THE ABOVE THEN A SM ERROR MESSAGE
*                   IS SENT TO THE DAYFILE. 
* 
*                 FOR CONSOLE CONNECTIONS 
* 
*                   IF THE CONSOLE CONNECTION IS IN GO STATE AND A
*                   FC/STP IS RECEIVED WITH A TERMINAL FAILURE
*                   ITS END CONNECTION FLAG IS SET, THE NEXT APPLICATION
*                   NAME IS ZEROED OUT, THE ERROR AND STOP FLAGS ARE
*                   SET, ANY ACCUMULATED OUTPUT IS RELEASED 
*                   AND ALL ASSOCIATED BATCH DEVICE"S END CONNECTION
*                   FLAG IS SET.
* 
*                   IF NOT A CONSOLE TERMINAL FAILURE THEN A SM ERROR 
*                   MESSAGE IS ISSUED TO THE DAYFILE. 
* 
*        FLOW CONTROL START - FC/STR
*        FC$STR   IF A FC/STR IS RECEIVED ON A CONNECTION NOT YET 
*                 OPERATIONAL THEN A SM ERROR MESSAGE IS ISSUED TO THE
*                 DAYFILE.
* 
*                 A FC/RST IS ISSUED AND CONNECTION"S OUTSTANDING 
*                 BLOCKS" ACK ARE RESET 
* 
*                 BATCH DEVICE CONNECTION RECEIVING A FC/STR ADDITIONAL-
*                 LY CLEARS THE TERMINAL BUSY AND SETS RESET FLAG.
* 
*       SHUT DOWN - SHUT/INSD 
*       SHUT$DOWN IF FORCED SHUTDOWN FLAG SET RBF NETS OFF, ISSUED
*                 A FORCED SHUTDOWN MESSAGE TO THE DAYFILE, SETS
*                 NETTEDON FLAG FALSE, AND SETS ERROR AND END CONNECTION
*                 FLAGS FOR ALL CONNECTIONS, AND LINKS PSEUDO 
*                 SMP CONNECTION TO WRAPUP MODULE.
* 
*                 IF A IDLE SHUTDOWN, THE IDLESHUTDOWN FLAG IS SET AND
*                 THE PSEUDO SMP CONNECTION IS LINKED TO WRAPUP MODULE. 
* 
*       CHANGE TERMINAL CHARACTERISTICS - TCH/TCHAR 
*       TCH$TCHAR IF RECEIVED ON A BATCH DEVICE CONNECTION A SM ERROR 
*                 MESSAGE IS ISSUED TO THE DAYFILE. 
* 
*                 IF RECEIVED ON A CONSOLE CONNECTION TERMINAL CLASS, 
*                 PAGE WIDTH AND PAGE LENGTH ITEMS OF THE TCB ARE 
*                 REPLACED WITH THE VALUES PASSED IN THE TCH SM.
* 
*       USER INTERRUPT - INTR/USR 
*       INTR$USR  WHEN CONSOLE RECEIVES THE USER INTERRUPT, IT DISCARDS 
*       ALL QUEUED UNPROCESSED COMMANDS.
* 
* 
*        INPUT ABORTED - IFC/ABORT/N
*        IFC$ABT   THIS SUPERVISORY MESSAGE INFORMS APPLICATION THAT
*                  ALL THE INPUT DATA ON THIS CONNECTION HAS BEEN 
*                  DISCARDED AND THERE WILL BE NO MORE INPUT TRAFFIC
*                  UNTIL IFC/START SM 
* 
*        VALIDATE JOB/USER CARDS - IFC/JOB/R
*        IFC$JOB   THE REQUEST VALIDATE JOB/USER CARDS SUPERVISORY
*                  MESSAGE IS SENT TO         RBF         TO VERIFY THE 
*                  JOB CARDS RECEIVED FROM A BATCH INPUT DEVICE.
*                  RBF WILL CALL VEJ TO VERIFY JOB CARDS AND ASSIGN 
*                  INPUT FILE.
*        INPUT STOPPED - IFC/STPD/R 
*        IFC$STPD  THE INPUT STOPPED SM IS SENT BY NAM TO ADVISE THE
*                  RBF OF CONDITIONS STOPPING INPUT TRANSMISSION
*                  CONDITIONS 
*                  * 200 USER TERMINAL CARD READER WAS INTERRUPTED BY 
*                    HIGHER PRIORITY INTERACTIVE CONSOLE ACTIVITY.
*                  * CARD READER ERROR OCCURRED 
*                  * END OF INPUT STREAM WAS DETECTED 
*                  * CARD READER NOT READY
*                  * A MASS STORAGE ERROR WAS DETECTED BY NAM WHEN IT 
*                    PERFORMED THE DISK I/O 
* 
*        END OF JOB - IFC/EOJ/R 
*        IFC$EOJ   A COMPLETE JOB WAS READ IN AND RBF WILL DISPOSE THE
*                  JOB TO THE SYSTEM INPUT QUEUE
* 
*        INPUT ENDED - IFC/END/N
*        IFC$END   THE INPUT ENDED SUPERVISORY MESSAGE INFORMS RBF THAT 
*                  CURRENT INPUT JOB WAS DISCARDED
* 
*        OUTPUT TEMPORARY STOPPED - OFC/STP/N 
*        OFC$STP   CURRENT OUTPUT STREAM IS TEMPORARILY STOPPED.
*                  SEND RESTART OUTPUT SM TO UNDO TEMPORARY STOP
* 
*        OUTPUT STOPPED - OFC/STPD/R
*        OFC$STPD  OUTPUT DATA TRANSMISSION IS STOPPED DUE TO FOLLOWING 
*                  CONDITIONS.
*                  * 200 UT LINE PRINTER WAS INTERRUPTED BY HIGHER
*                    PRIORITY INTERACTIVE CONSOLE ACTIVITY. 
* 
*                  * PRINTER OUTPUT WAS INTERRUPTED BY A "PM" 
*                  * OUTPUT FILE LIMIT HAS BEEN REACHED 
*                  * OUTPUT DEVICE NOT-READY
*                  * MASS STORAGE ERROR DURING THE DISK I/O 
* 
*        OUTPUT ABORTED - OFC/ABORT/N 
*        OFC$ABT   THIS SUPERVISORY MESSAGE INFORMS RBF THAT CURRENT
*                  OUTPUT DATA ON THE CONNECTION HAS BEEN CLEARED 
* 
*        END OF OUTPUT - OFC/EOO/R
*        OFC$EOO   THIS SUPERVISORY MESSAGE INFORMS RBF THAT ALL THE
*                  OUTPUT DATA ON THE CONNECTION HAS BEEN TRANSMITTED 
* 
*        BATCH DATA SENT - OFC/DATA/N 
*        OFC$DATA  THIS SUPERVISORY MESSAGE INFORMS RBF THAT BATCH DATA 
*                  SENT FROM THE RBF HAS BEEN SENT TO THE TERMINAL. 
* 
*        PRU INTERFACE ENABLED - PRU/ON/N 
*        PRU$ON    THIS SUPERVISORY MESSAGE INFORMS RBF THAT PERMISSION 
*                  TO USE PRU INTERFACE FACILITIES HAS BEEN GRANTED 
* 
* 
*     4. ENTRY PARAMETERS.
* 
         NONE.
* 
*     5. EXIT PARAMETERS. NONE. 
* 
*     6. COMDECKS USED. 
* 
*        TSBMDEFS 
*        TSBMBASE 
*        RBF$COM
*        SM$COM 
*        FC$COM 
*        CON$COM
*        CTRL$COM 
*        ERR$SMCOM
*        SHUT$COM 
*        TCH$SMCOM
*        ABH$COM
*        TCB$COM
*        LSTDEF 
*        LST
* 
*     7. ROUTINES CALLED. 
* 
*        RETTSB, LINK, SETACN, NETPUT, NETOFF, CHGSIZE, MESSAGE 
*        RDYMSG 
* 
*     8. DAYFILE MESSGAES.
* 
*        FORCED SHUTDOWN REQUESTED. 
*        SUPERVISORY MESSAGE ERROR  (FOLLOWED BY TEXT OF ERRONEOUS MSG) 
* 
 #
*ENDIF
  
      XREF PROC SYSCALL;     # MAKES SYSTEM CALLS                      #
      XREF PROC CONSOLE ;    # STORES CONSOLE MESSAGES                 #
*IF DEF,DEBUG 
      XREF PROC ABORT;
*ENDIF
      XREF PROC RETTSB;      # FREE BUFFER SPACE                       #
      XREF PROC ENDRBF;      #TERMINATE RBF RUNNING                    #
      XREF PROC EVENT;        #                                        #
      XREF FUNC GETBUF U;    # ACQUIRE A BUFFER                        #
      XREF PROC CHGSIZE;     # CHANGE SIZE OF A BUFFER                 #
      XREF PROC MESSAGE;     # ISSUE DAYFILE MESSAGE                   #
      XREF PROC MOVEBLK;     # BLOCK-MOVE ROUTINE                      #
      XREF PROC NETPUT;      # SENDS DATA TO THE NETWORK               #
      XREF PROC LINK;        # LINK MODULE TO ACN                      #
      XREF PROC SETUPACN;    # SET UP CONTROL BLOCKS FOR CONNECTIONS  # 
      XREF PROC ACKED;       # ACK EVENT PROCESSOR                     #
      XREF PROC RDYMSG;      # ISSUE READY MESSAGE                     #
      XREF PROC LINKBLOCK;                       # LINK DATA BLOCKS    #
      XREF PROC WAITSM; 
      XREF LABEL CALLRTN; # RETURN TO PROCESS ROUTINE # 
      COMMON CONVTBL; 
      BEGIN 
      ARRAY TABLE S(13);
        BEGIN 
        ITEM TB8T6 C (0,0,127); 
        END 
      END 
      XREF ITEM SMCOUNT I;                       # NUMBER OF SM RECVED #
      ITEM RELEASE B;        # RELEASE SMBUFFER UPON EXIT FLAG         #
      ITEM SMBUFFER I;       # ORDINAL OF SUPERVISORY MESSAGE BUFFER   #
      ITEM MSGTM C(10);      # TEMP. STORAGE FOR DATE AND TIME         #
  
      DEF SYSDATE # O"1 00 000000"#;
      DEF SYSTIME # O"2 00 000000"#;
      DEF NUMSUP # 27 #;                         # NO OF SUPV MSGS    # 
*IF DEF,DEBUG 
      DEF BUSY # 0 #;                            # CONNECTION BUSY     #
      DEF ERRX # 1 #;                            # SM ERROR            #
      DEF URGENT #2#;                            # URGENT SM ERROR     #
*ENDIF
      ARRAY SUPV [0:NUMSUP] S(1); 
      ITEM
        PSVALUE    U(0)     =[FCACK, FCSTP, FCSTA, FCINIT, FCBRK, 
                              FCNAK, FCINA, CONREQ, CONENDN,
                              CONCB, SHUINS, TCHTCH,
                              INTRUSR, BIMARK,
                              IFCABTN, IFCJOB, IFCSTPD, 
                              IFCEOJ, IFCENDN, OFCSTPN, 
                              OFCSTPD, OFCABTN, OFCEOO, 
                              OFCDATN, ERRLGL, PRUONN, PRUONA]; 
      SWITCH SMPSW FC$ACK, FC$STP, FC$STR, FC$INIT, FC$BRK, FC$NAK, 
                   SMPND, CON$REQ, CON$END, CON$CB, LINS, TCH$TCHAR,
                   INTR$USR, BI$MARK, 
                   IFC$ABT, IFC$JOB, IFC$STPD, IFC$EOJ, IFC$END,
                   OFC$STP, OFC$STPD, OFC$ABT, OFC$EOO, OFC$DATA, 
                   ERR$LGL, PRU$ON$N, PRU$ON$A; 
  
  
      STATUS ISTOPRC    NULL,                    # INPUT DEVICE        #
                        INTRPT,                  # BATCH INTERRUPT     #
                        CRERR,                   # CARD READER ERROR   #
                        EOS,                     # END OF STREAM       #
                        NREADY,                  # CARD READER EMPTY   #
                        DSKERR;                  # DISK I/O ERROR      #
  
      SWITCH IFCSTPRC  : ISTOPRC
             IFC$INTRPT: INTRPT,                 # PROCESS INTERRUPT   #
             IFC$CRERR : CRERR ,                 # PROCESS CR ERROR    #
             IFC$EOS   : EOS,                    # PROCESS EOS         #
             IFC$NREADY: NREADY,                 # PROCESS CR EMPTY    #
             IFC$DSKERR: DSKERR;                 # PROCESS DISK ERROR  #
  
      STATUS OSTOPRC    NULL,                    # OUTPUT DEVICE       #
                        INTERPT,                 # BATCH INTERRUPT     #
                        PMINT,                   # PM INTERRUPT        #
                        LIMIT,                   # ACCOUNT LIMIT       #
                        NREADY,                  # NOT READY           #
                        DSKERR,                  # DISK I/O ERROR      #
                        DCPNL;       # DEVICE CONFIG PROC NOT LOADABLE #
  
      SWITCH OFCSTPRC   : OSTOPRC 
             OFC$INTRPT : INTERPT,
             OFC$PMINT  : PMINT,                 # PROCESS PM          #
             OFC$LIMIT  : LIMIT,                 # PROCESS ACC LIMIT   #
             OFC$NREADY : NREADY, 
             OFC$DSKERR : DSKERR,                # PROCESS DISK ERROR  #
             OFC$DCPNL  : DCPNL;     # PROCESS DEV CONFG PROC NOT LOAD #
  
  
      ITEM I I; 
      ITEM K I; 
      ITEM IX I;
      ITEM FOUND B; 
      ITEM SMINPUT U;                            # TCB$INPUT LOCATION  #
                                                 # OF SMPACN           #
      ITEM TEMP U;
      ARRAY FORCEDSHUTDN S(4);
        ITEM FORCEDMSG C(0,0,30) = ["FORCED SHUT DOWN REQUESTED    "],
             FORCEDEND U(3,0,60) = [ 0 ]; 
      ARRAY STARTEDMSG S(5);
        ITEM STARTEDMSG0 C(0,0,1) = [" "],
             STARTEDMSG1 C(0,6,13) = [RBFVER],
             STARTEDMSG2 C(1,24,7) = ["STARTED"], 
             DATEMSG C(2,6,10), 
             TIMEMSG C(3,6,10), 
             STARTMSG C(0,0,50);
      ARRAY DCPNL$MSG S(5); 
        ITEM DCPNLMSG0 C(0,00,25) = ["      DEVICE NOT READY OR"],
             DCPNLMSG1 C(2,36,25) = [" DEVICE PROC NOT LOADABLE"];
      CONTROL EJECT;
      PROC CONVERT (ORDX);
      BEGIN 
      ITEM ASCIIPM B;          # TRUE WHEN PM TEXT IS 8/12 ASCII FORMAT#
      ITEM FRCNT6, FRCNT12;    # 6 AND 12 BIT FRAME COUNTERS           #
      ITEM INDEX U;            # RIGHTMOST 7 BITS OF A 12 BIT FRAME    #
      ITEM ORDX I;             # TSB ORDINAL OF THE OFC/STPD SM        #
      ITEM WDCNT6, WDCNT12;    # 6 AND 12 BIT FRAME WORD COUNTERS      #
      ITEM I;                  # TEMPORARY INDUCTION VARIABLE          #
  
      BASED ARRAY PM$6  [0:0] S(1); # THIS ARRAY IS USED AS A TEMPLATE #
        BEGIN                       # FOR INSERTING 6 BIT FRAMES.      #
        ITEM PM$TX6    U(00,00,60); 
        END 
  
      BASED ARRAY PM$12 [0:0] S(1); # THIS ARRAY IS USED AS A TEMPLATE #
        BEGIN                       # FOR EXTRACTING 12 BIT FRAMES.    #
        ITEM PM$TX12   U(00,00,60); 
        END 
# 
      THIS SUBROUTINE CONVERTS PM MESSAGE TEXT FOUND IN WORD 3 OF A 
      OFC/STPD SM (RC = PM INTERRUPT) TO DISPLAY CODE PACKED IN 6 BIT 
      FRAMES (IE. A FORM SUITABLE FOR CONSOLE OUTPUT).  THE TEXT IN THE 
      SM IS IN 12 BIT FRAMES IN EITHER ASCII (8/12 FORMAT) OR DISPLAY 
      CODE (6/12 FORMAT).  ASCII TO DISPLAY CODE CONVERSION IS DONE IF
      NECESSARY.
# 
      P<PM$6 > = ADDRESS[ORDX];     # INSERT 6 BIT FRAMES STARTING AT  #
                                    # THE ABH OF THE ORIGINAL -PM- SM. #
      P<PM$12> = ADDRESS[ORDX] + 3; # STARTING ADDRESS OF THE 12 BIT   #
                                    # FRAMES IN THE ORIGINAL -PM- SM.  #
      IF B<0,24>PRUSMH2 EQ O"00200015"
      THEN
        BEGIN 
        ASCIIPM = FALSE;       # PM TEXT IS DISPLAY CODE (6/12 FORMAT) #
        END 
      ELSE
        BEGIN 
        ASCIIPM = TRUE;        # PM TEXT IS ASCII (8/12 FORMAT)        #
        END 
      C<0,8>PM$TX6[0] = " ";   # 1ST 8 CHARS OF PM TEXT WILL BE FILLED #
                               # IN BY DCM (-PM-, DEVICE TYPE, ORDINAL)#
      FRCNT6 = 8;              # CURRENT 6 BIT FRAME AND WORD POSITION,#
      WDCNT6 = 0;              # 1ST 8 CHARS HAVE BEEN BLANK FILLED.   #
      FRCNT12 = 2;             # CURRENT 12 BIT FRAME, WORD POSITION,  #
      WDCNT12 = 0;             # THE -PM- IS SKIPPED (NOT CONVERTED).  #
      FOR I = 1 STEP 1 UNTIL DCB$PMSIZE - 8 
      DO
        BEGIN                  # CONVERT THE REMAINING 12 BIT FRAMES   #
        INDEX = B<(( FRCNT12 * 12 )+ 5 ), 7>PM$TX12 [ WDCNT12 ];
        IF ASCIIPM
        THEN
          BEGIN 
          C< FRCNT6, 1>PM$TX6 [ WDCNT6 ] = C< INDEX, 1>TB8T6; 
          END 
        ELSE
          BEGIN 
          C< FRCNT6, 1>PM$TX6 [ WDCNT6 ] = C< 9, 1>INDEX; 
          END 
        FRCNT6  = FRCNT6  + 1;
        FRCNT12 = FRCNT12 + 1;
        IF FRCNT6 EQ 10 
        THEN                   # END OF THE CURRENT 6 BIT FRAME WORD,  #
          BEGIN                # RESET FRAME COUNT, INCRMT WORD COUNT. #
          FRCNT6 = 0; 
          WDCNT6 = WDCNT6 + 1;
          END 
        IF FRCNT12 EQ 5 
        THEN                   # END OF THE CURRENT 12 BIT FRAME WORD, #
          BEGIN                # RESET FRAME COUNT, INCRMT WORD COUNT. #
          FRCNT12 = 0;
          WDCNT12 = WDCNT12 + 1;
          END 
        END                    # CONVERT THE REMAINING 12 BIT FRAMES   #
      RETURN; 
      END 
*IF DEF,DEBUG 
      CONTROL EJECT;
      PROC SM$ERR (ERRC); 
      BEGIN # SM$ERR #
      ITEM ERRC I;                               # ERROR REASON CODE   #
      ARRAY SUPMSGERR S(4); 
        ITEM SUPMSGERRMSG C (0,0,30)=["SUPERVISORY MESSAGE DISCARDED"], 
             SUPMSGERREND U (3,0,12)=[O"0000"]; 
      ARRAY SUPMSGTXT S(3); 
        ITEM SUPMSGTEXT    C ( 0,0,20), 
             SUPMSGTXTEND  U (2,0,60) = [0];
      ARRAY CONBUSY S(3); 
        BEGIN 
        ITEM CONBUSYMSG C (0,0,24) = ["*CONNECTION BUSY, ACN - "],
             CONBUSYACN U (2,24,12),
             CONBUSYEOL U (2,48,12) = [0];
        END 
#                                                                      #
#     PRINT OUT TO THE DAYFILE THE ERRONEOUS SUPERVISORY MESSAGE       #
#                                                                      #
      IF ERRC NQ ZERO 
      THEN
      BEGIN 
      MESSAGE (SUPMSGERR,DFLOPT); 
      FOR I = 0 STEP 1 UNTIL ABH$TLC - 1 DO 
        BEGIN # CONVERT ONE WORD AND OUTPUT IT TO THE DAYFILE # 
        FOR K = 0 STEP 1 UNTIL 19 DO
          BEGIN # CONVERT EACH OCTAL DIGIT TO DISPLAY CODE #
          B<K*6,6>SUPMSGTEXT = B<K*3,3>ABH$TEXT [I] + O"33";
          C<K>SUPMSGTEXT = B<K*3,3>ABH$TEXT [I] + O"33";
          END   # CONVERT EACH OCTAL DIGIT TO DISPLAY CODE #
        MESSAGE (SUPMSGTXT,DFLOPT); 
        END   # CONVERT ONE WORD AND OUTPUT IT TO THE DAYFILE # 
      IF ERRC EQ URGENT 
      THEN
        BEGIN                                    # BAD SUPERVISORY MSG #
        ABORT;
        END 
      END 
      ELSE
      BEGIN                                      # CONNECTION BUSY     #
      CONBUSYACN = ACN; 
      MESSAGE (CONBUSY, DFLOPT);
      END 
      RETURN; 
      END   # SM$ERR #
*ENDIF
      CONTROL EJECT;
# 
************************************************************************
      SMP PROCESSING
  
************************************************************************
# 
  
STARTSMP: 
  
      TEMP = SMCOUNT;                            # NUMBER OF SUP MSG   #
      SMCOUNT = 0;
      SMINPUT = LOC (TCB$INPUT);
      FOR IX = TEMP STEP -1 UNTIL 1 DO
        BEGIN                                    # SMP LOOP            #
        P<TCB> = ADDRESS [ACN$CB [SMPACN]];      # GET TCB FOR ACNSMP  #
        P<ABH> = ADDRESS [TCB$INPUT]; 
        P<SM$> = P<ABH> + 1;
        SMBUFFER = TCB$INPUT;                    # GET SUPERVISORY MSG #
        TCB$INPUT = ABH$ABN;                     # NEXT INPUT          #
        RELEASE = TRUE; 
        IF ABH$ADR EQ 0 
        THEN
          BEGIN   # ASYNC SUPV MSG #
          ACN = SUPACN; 
          END     # ASYNC SUPV MSG #
        ELSE
          BEGIN   # SYNC SUPV MSG # 
          ACN = ABH$ADR;
          END     # SYNC SUPV MSG # 
          IF PFC EQ IFC OR PFC EQ OFC 
          THEN
            BEGIN                                # PRU SM              #
            P<PRUX> = P<SM$>; 
            IF ACN$STATE [ACN] NQ S"ACTIVE" 
               AND
               ACN$STATE [ACN] NQ S"IDLE$DOWN"
            THEN
              BEGIN                              #CONNECTION NOT ACTIVE#
*IF DEF,DEBUG 
              SM$ERR (ERRX);
*ENDIF
              GOTO SMPND; 
              END                                #CONNECTION NOT ACTIVE#
            ELSE
              BEGIN                              # CONNECTION ACTIVE   #
              SETUPACN (ACN); 
              IF PFC EQ IFC AND ACN$DEVTYPE [ACN] NQ S"CARD$READER" 
              THEN
                BEGIN                            # INPUT FLOW CONTROL  #
*IF DEF,DEBUG 
                SM$ERR (ERRX);
*ENDIF
                GOTO SMPND;                      # SM ON OUTPUT DEVICE #
                END 
              ELSE
                BEGIN 
                IF ACN$DEVTYPE [ACN] LS S"LINE$PRINTER" 
                   AND
                   PFC EQ OFC 
                THEN
                  BEGIN                          # OUTPUT FLOW CONTROL #
*IF DEF,DEBUG 
                  SM$ERR(ERRX); 
*ENDIF
                  GOTO SMPND;                    # SM ON INPUT DEVICE  #
                  END 
                END 
              P<CCBHDR> = ADDRESS [ACN$CB [ACN]]; 
              P<DCB> = P<CCBHDR>;                # DCB BASED ARRAY     #
              IF CCB$INPTYPE NQ ZERO
                OR (ACN$DEVTYPE[ACN] GQ S"LINE$PRINTER"  # OUTPUT DEV  #
                    AND (ACN$MODE[ACN] EQ DCMSTATE"DCM$IDLE"
                         OR ACN$MODE[ACN] EQ DCMSTATE"DCM$GOBAN") 
                    AND (NOT DCB$PROCESSD))      # CONNECTION BUSY     #
              THEN
                BEGIN 
                SMCOUNT = SMCOUNT + 1;
                LINKBLOCK (SMINPUT, SMBUFFER);
                RELEASE = FALSE;
                GOTO SMPND; 
                END 
              END                                # CONNECTION ACTIVE   #
            END                                  # PRU SM              #
      FOR TEMP = 0 STEP 1 UNTIL NUMSUP - 1
      DO
        IF PFCSFC EQ PSVALUE[TEMP]
        THEN
          GOTO SMPSW[TEMP]; 
        ELSE
          IF PFC EQ HOP OR PFCSFC EQ CTRCHRN      # HOP OR CTRL/CHAR/N #
          THEN
            GOTO SMPND; 
*IF DEF,DEBUG 
      SM$ERR (ERRX);
*ENDIF
SMPND:  
      IF RELEASE
      THEN
        BEGIN                                    # RELEASE SUPERVISORY #
        RETTSB (SMBUFFER);                       # MESSAGE BUFFER SPACE#
        END 
      TEST IX;
      CONTROL EJECT;
CON$CB: 
#     BEGIN CON/CB PROCESSING                                          #
      IF ACN$STATE [ACN] GQ S"CONNECTED"
      THEN
        BEGIN                                    # OPERATIONAL ACN     #
        SETUPACN (ACN); 
        IF ACN$DEVTYPE [ACN] EQ S"CONSOLE"
        THEN
          BEGIN                                  # CONSOLE ACN         #
          TCB$INPTYPE = CONINPUT"CONBROKENX"; 
          TCB$ENDFLAG = FALSE;
          IF ACN$MODE [ACN] LQ CONSOLESTATE"CON$ACTIVE" 
          THEN
          FOR I=1 STEP 1 UNTIL TCB$NDEVICE DO 
            BEGIN                                # END BATCH DEVICE    #
            TCB$ENDCON [I] = TRUE;               # NO-OP FOR HASP DEV  #
            END                                  # END BATCH DEVICE    #
          END                                    # CONSOLE ACN         #
        ELSE
          BEGIN                                  # BATCH ACN           #
          IF ACN$DEVTYPE [ACN] EQ S"CARD$READER"
          THEN
            BEGIN                                # INPUT CONNECTIONS   #
            UCB$INPTYPE = UCMINPUT"CONCBUCM"; 
            END 
          ELSE
            BEGIN                                # OUTPUT CONNECTIONS  #
            DCB$INPTYPE = DCMINPUT"CONCBDCM"; 
            END 
          END                                    # BATCH ACN           #
        END 
      IF ACN$STATE [ACN] EQ S"CONNECTED"
      THEN
        BEGIN                                    # CONNECTION BROKEN   #
        ACN$STATE [ACN] = S"END$CONNECT";        # AFTER FC/INIT       #
        LINK (CHAINS"CON$END",NOEVENT); 
        END 
*IF DEF,DEBUG 
      IF ACN$STATE [ACN] LS S"CONNECTED"
      THEN
        BEGIN 
        SM$ERR (ERRX);
        END 
*ENDIF
        GOTO SMPND; 
      CONTROL EJECT;
CON$END:  
#     BEGIN CON/END PROCESSING                                         #
      IF ACN$STATE [ACN] EQ S"END$CONNECT"
      THEN
        BEGIN # END CONNECTION STATE #
        SETUPACN (CONACN);
        IF ACN$DEVTYPE [ACN] EQ S"CONSOLE"
        THEN
          BEGIN 
          LINK(CHAINS"FIN$CON",NOEVENT);
          END 
        ELSE
          BEGIN 
          LINK(CHAINS"FIN$DEV",NOEVENT);
          END 
        END   # END CONNECTION STATE #
*IF DEF,DEBUG 
      ELSE
        SM$ERR (ERRX);
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
CON$REQ:  
#     BEGIN CON/REQ PROCESSING                                         #
#                                                                      #
      IF ACN$WORD [ACN] NQ 0 OR IDLESHUTDOWN
      THEN
        BEGIN # ACN ALREADY IN USE OR IDLE DOWN IN PROGRESS # 
        IF ACN$STATE [ACN] EQ S"END$CONNECT"
        THEN
          BEGIN                                  # CON/REQ/SM RECEIVED #
          SMCOUNT = SMCOUNT + 1;                 # BEFORE RBF PROCESS  #
          LINKBLOCK (SMINPUT, SMBUFFER);         # CON/END/N           #
          RELEASE = FALSE;
*IF DEF,DEBUG 
          SM$ERR (BUSY);
*ENDIF
          END 
*IF DEF,DEBUG 
        ELSE
          BEGIN 
          SM$ERR (ERRX);
          END 
*ENDIF
        IF IDLESHUTDOWN 
        THEN
          BEGIN                                  #IDLE DOWN IN PROGRESS#
          EB = TRUE;
          ABH$TLC = LCORQR; 
          NETPUT (ABH,SM$); 
          END                                    #IDLE DOWN IN PROGRESS#
        END   # ACN ALREADY IN USE OR IDLE DOWN IN PROGRESS # 
      ELSE
        BEGIN # CALL NEW #
        ACN$CTLR [ACN] = SMBUFFER;
        LINK (CHAINS"NEW$",NOEVENT);
        IF COND NQ DEVICETYPE"CONSOLE"
        THEN
          BEGIN 
          ACN$CB [ACN] = GETBUF (DEV$MINSIZE,MOVEABLE); 
          IF ACN$CB [ACN] EQ ZERO 
          THEN
            BEGIN 
            SMCOUNT = SMCOUNT + 1;
            LINKBLOCK (SMINPUT, SMBUFFER);
            END 
          END 
        RELEASE = FALSE;
        END   # CALL NEW #
      GOTO SMPND; 
      CONTROL EJECT;
FC$ACK: 
#     FC/ACK PROCESSING                                                #
      XREF ITEM ACKS; 
      IF ACN$CB [ACN] NQ 0
      THEN
          BEGIN # ACK MESSAGE ON ACTIVE CONNECTION #
          SETUPACN (ACN); 
          IF ACN$DEVTYPE [ACN] EQ S"CONSOLE"
          THEN
            BEGIN # ACK CONSOLE MESSAGE # 
            IF TCB$NXTACKSN EQ FCABN
            THEN
              BEGIN # ACK # 
              TCB$WAITACK = FALSE;               # ACK RECEIVED        #
              TCB$NXTACKSN = TCB$NXTACKSN + 1;
              IF TCB$NXTACKSN GR MAXBSN 
              THEN
                TCB$NXTACKSN = 1; 
              END   # ACK # 
*IF DEF,DEBUG 
            ELSE
              BEGIN # BAD ACK # 
              SM$ERR (ERRX);
              END   # BAD ACK # 
*ENDIF
            END   # ACK CONSOLE MESSAGE # 
          END   # ACK MESSAGE ON ACTIVE CONNECTION #
*IF DEF,DEBUG 
        ELSE
        BEGIN                                    # CONSOLE CONNECTION  #
          SM$ERR (ERRX);
          END 
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
FC$BRK: 
#     FC/BRK PROCESSING                                                #
      SETUPACN (ACN); 
*ENDIF
#                                                                      #
#     SEND FC/RST SUPERVISORY MESSAGE                                  #
#                                                                      #
      P<SM$> = P<ABH> + 1;
      PFCSFC = FCRST; 
      RC = 0; 
      NETPUT (ABH,SM$); 
      GOTO SMPND; 
      CONTROL EJECT;
FC$INIT:  
#     FC/INIT PROCESSING                                               #
      IF ACN$STATE [ACN] EQ S"CONNECTED"
      THEN
        BEGIN                                    # CONNECT STATE       #
        SETUPACN (ACN); 
        IF ACN$DEVTYPE [ACN] EQ S"CONSOLE"
        THEN
          BEGIN                                  # CONSOLE CONNECTION  #
          ACN$STATE [ACN] = S"ACTIVE";
          LINK (CHAINS"EXT$CMD", NOEVENT);
          SYSCALL("TIMP",SYSDATE + LOC (MSGTM));
          DATEMSG = MSGTM;
          SYSCALL("TIMP",SYSTIME + LOC (MSGTM));
          TIMEMSG = MSGTM;
          CONSOLE (STARTMSG,CRITICAL,41); 
          RDYMSG (FALSE); 
          IF (TCB$AUTOGO) OR           # RESTRICTED INTERACTIVE CONSOLE#
             (TCB$CDCNT )              # CDCNET TERMINAL               #
          THEN
            FOR I = 1 STEP 1 UNTIL TCB$NDEVICE
            DO
              BEGIN 
              IF ACN$STATE[ TCB$DEVACN[I] ] EQ CONNECTSTATE"ACTIVE" 
              THEN
                IF ACN$DEVTYPE[ TCB$DEVACN[I] ] EQ S"CARD$READER" 
                THEN
                  BEGIN   # CARD READER # 
                  IF TCB$CDCNT
                  THEN
                    BEGIN   # CDCNET #
                    P<UCB> = ADDRESS [ACN$CB[TCB$DEVACN[I]]]; 
                    IF UCB$AUTOGO 
                    THEN
                      TCB$CMDTY[I] = UCMINPUT"GOUCM"; 
                    END     # CDCNET #
                  ELSE
                    TCB$CMDTY[I] = UCMINPUT"GOUCM"; 
                  END     # CARD READER # 
                ELSE
                  BEGIN   # OUTPUT DEVICE # 
                  IF TCB$CDCNT
                  THEN
                    BEGIN   # CDCNET #
                    P<DCB> = ADDRESS [ACN$CB[TCB$DEVACN[I]]]; 
                    IF DCB$AUTOGO 
                    THEN
                      TCB$CMDTY[I] = DCMINPUT"GODCM"; 
                    END     # CDCNET #
                  ELSE
                    TCB$CMDTY[I] = DCMINPUT"GODCM"; 
                  END     # OUTPUT DEVICE # 
              END 
          END                                    # CONSOLE CONNECTION  #
        P<ABH> = ADDRESS [SMBUFFER];
        P<SM$> = P<ABH> + 1;
        RB = TRUE;
        NETPUT (ABH,SM$);                        # SEND FC/INIT/N      #
        IF ACN$DEVTYPE [ACN] NQ S"CONSOLE" AND NOT IDLESHUTDOWN 
        THEN
          BEGIN                                  # SEND PRU/ON SM      #
          ABH$WORD = ZERO;
          PFCSFC = PRUON; 
          SUPACN = ACN; 
        P<PRUX> = P<SM$>; 
        P<TCB$DEVICE> = P<TCB> + ACN$DEVINDEX[ACN]; 
        IF ACN$DEVTYPE[ACN] EQ S"CARD$READER" 
        THEN
          BEGIN 
          PRUUPS = TCB$DEVUPS;
          TCB$DEVUPS = 0; 
          END 
        ELSE
          BEGIN 
          PRUDPS = TCB$DEVDPS;
          TCB$DEVDPS = 0; 
          END 
          ABH$TLC = LPRU; 
          ABH$ABT = BLOCKTYPE"SM";
          ABH$ACT = ACT"SIXTYBITS"; 
          NETPUT (ABH,SM$); 
          END                                    # SEND PRU/ON SM      #
        END                                      # CONNECT STATE       #
*IF DEF,DEBUG 
      ELSE
        BEGIN 
        SM$ERR (ERRX);
        END 
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
FC$NAK: 
#     FC/NAK PROCESSING                                                #
      IF ACN$STATE [ACN] EQ S"ACTIVE" AND ACN$DEVTYPE[ACN] EQ S"CONSOLE"
      THEN
        BEGIN                                    # OPERATIONAL ACN     #
        SETUPACN (ACN); 
        TCB$INPTYPE = CONINPUT"TERMFAILX";
        IF ACN$MODE [ACN] LQ CONSOLESTATE"CON$ACTIVE" 
        THEN
          BEGIN 
          FOR I=1 STEP 1 UNTIL TCB$NDEVICE DO 
            BEGIN 
            TCB$ENDCON [I] = TRUE;
            END 
          END 
        END                                      # OPERATIONAL ACN     #
*IF DEF,DEBUG 
      SM$ERR (URGENT);
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
FC$STP: 
#     BEGIN FC/STP PROCESSING                                          #
#                                                                      #
      IF ACN$STATE [ACN] EQ S"ACTIVE" 
      AND ACN$DEVTYPE [ACN] EQ S"CONSOLE" 
      THEN
        BEGIN 
        SETUPACN (ACN); 
        IF FCRBR EQ RFCST"TF" 
        THEN
          BEGIN                                  # TERMINAL FAILURE    #
          TCB$INPTYPE = CONINPUT"TERMFAILX";
          IF ACN$MODE [ACN] LQ CONSOLESTATE"CON$ACTIVE" 
          THEN
          FOR I=1 STEP 1 UNTIL TCB$NDEVICE DO 
            BEGIN 
            TCB$ENDCON [I] = TRUE;
            END 
          END                                    # TERMINAL FAILURE    #
        ELSE
          BEGIN                                  # TERMINAL BUSY       #
          TCB$STPFLAG = TRUE; 
          END                                    # TERMINAL BUSY       #
        END 
*IF DEF,DEBUG 
      SM$ERR (ERRX);
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
FC$STR: 
#     SENT FC/RST SUPERVISORY MESSAGE                                  #
#                                                                      #
  
      IF ACN$STATE [ACN] EQ S"ACTIVE" AND ACN$DEVTYPE[ACN] EQ S"CONSOLE"
      THEN
        BEGIN                                    # OPERATIONAL ACN     #
        SETUPACN (ACN); 
        PFCSFC = FCRST; 
        RC = 0; 
        NETPUT (ABH,SM$);                        # SEND RESET SM       #
        TCB$STPFLAG = FALSE;
        TCB$NXTACKSN = TCB$NEXTBSN;              # SKIP OVER LOST DATA #
        END                                      # OPERATIONAL ACN     #
*IF DEF,DEBUG 
      ELSE
        BEGIN 
        SM$ERR (ERRX);
        END 
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
LINS: 
      IF SHUTF
      THEN
        BEGIN                                    # FORCE SHUT DOWN     #
        MESSAGE (FORCEDSHUTDN,DFLOPT);
        ENDRBF; 
        END                                      # FORCE SHUT DOWN     #
      ELSE
        BEGIN 
        IDLESHUTDOWN = TRUE;                     # IDLE DOWN RBF       #
        END 
      GOTO SMPND; 
      CONTROL EJECT;
TCH$TCHAR:  
#     TCH/TCHAR PROCESSING                                             #
#                                                                      #
#     IF THIS TCH SUPERVISORY MESSAGE IS FOR A CONSOLE CONNECTION      #
#     THEN MOVE THE VALUES FOR TERMINAL CLASS, PAGE WIDTH AND PAGE     #
#     LENGTH INTO THE TCB.                                             #
#                                                                      #
      ACN = TCHACN; 
      IF ACN$DEVTYPE [ACN] EQ S"CONSOLE"
      THEN
        BEGIN # CONSOLE CONNECTION #
        SETUPACN (ACN); 
        TCB$TC = TCHTCL;
        TCB$PW = TCHPW; 
        TCB$PL = TCHPL; 
        END   # CONSOLE CONNECTION #
*IF DEF,DEBUG 
# 
      IGNORE TCH/TCHAR SUP MSG ON A BATCH DEVICE CONNECTION 
# 
*ENDIF
      GOTO SMPND; 
      CONTROL EJECT;
# 
      USER INTERRUPT (INTR/USR) 
# 
INTR$USR: 
      IF ACN$STATE [ACN] EQ S"ACTIVE" 
         AND
         ACN$DEVTYPE [ACN] EQ S"CONSOLE"
      THEN
        BEGIN 
        SETUPACN (ACN); 
        TCB$INPTYPE = CONINPUT"USRINTRX"; 
        IF INTRCHR EQ RIR"UB1" OR INTRCHR EQ RIR"UB2" 
        THEN
          BEGIN   # USER BREAK 1 OR USER BREAK 2 #
          TCB$DIS = 0;
          TCB$REFRESH = FALSE;
          END     # USER BREAK 1 OR USER BREAK 2 #
        END 
      PFCSFC = INTRRSP; 
      RC = ZERO;
      NETPUT (ABH, SM$);
      GOTO SMPND; 
      CONTROL EJECT;
# 
*     BREAK INDICATION MARKER (BI/MARK) 
# 
BI$MARK:  
      IF ACN$DEVTYPE [ACN] EQ S"CONSOLE"
      THEN
        BEGIN   # CONSOLE DEVICE #
        IF ACN$STATE [ACN] EQ S"ACTIVE" 
        THEN
          BEGIN   # ACTIVE CONSOLE #
          SETUPACN (ACN); 
          PFCSFC = ROMARK;
          LINKBLOCK (LOC(TCB$OUTPUT),SMBUFFER); 
          RELEASE = FALSE;
          END     # ACTIVE CONSOLE #
        END     # CONSOLE DEVICE #
      ELSE
        BEGIN   # NOT CONSOLE DEVICE #
        SM$ERR (ERRX);
        END     # NOT CONSOLE DEVICE #
      GOTO SMPND; 
      CONTROL EJECT;
# 
      PRU INTERFACE SUPERVISORY MESSAGE 
# 
IFC$ABT:  
# 
      PROCESS IFC/ABORT 
# 
      TEMP = UCMINPUT"IFCABTUCM";                # INPUT ABORTED       #
      GOTO IFCOMMON;
  
# 
      PROCESS IFC/EOJ 
# 
IFC$EOJ:  
      TEMP = UCMINPUT"IFCEOJUCM"; 
      GOTO IFCOMMON;
  
# 
      PROCESS IFC/END 
# 
IFC$END:  
      TEMP = UCMINPUT"IFCENDUCM";                # JOB BY PASSED       #
  
IFCOMMON: 
      IF UCB$INPTYPE EQ ZERO
      THEN
        BEGIN 
        UCB$INPTYPE = TEMP;                      # SET SM TYPE         #
        IF PRUFNT NQ ZERO 
        THEN
          BEGIN 
          UCB$DSPCARDS = PACNT;   # NUMBER OF CARDS READ    # 
          UCB$FILEACT = TRUE;                    # FILE ACTIVE         #
          IF  UCB$FETLFN  NQ  PRULFN
          THEN
            BEGIN 
*IF DEF,DEBUG 
            SM$ERR (URGENT);
*ENDIF
            UCB$FETLFN = PRULFN;
            UCB$FETFNT = PRUFNT;
            END 
          ELSE
            UCB$FETFNT = PRUFNT;
          END 
        END 
      GOTO SMPND; 
      CONTROL EJECT;
IFC$JOB:  
# 
      PROCESS IFC/JOB 
# 
      IF UCB$INPTYPE EQ ZERO
      THEN
        BEGIN                                    # SET SM TYPE         #
        UCB$INPTYPE = UCMINPUT"IFCJOBUCM";
        UCB$BUFFER = SMBUFFER;
        RELEASE = FALSE;
        END                                      # SET SM TYPE         #
      GOTO SMPND; 
      CONTROL EJECT;
IFC$STPD: 
# 
      PROCESS IFC/STPD SUPERVISORY MESSAGE
# 
      IF UCB$INPTYPE EQ ZERO
      THEN
        BEGIN                                    # SET SM TYPE         #
        GOTO IFCSTPRC [PRURC];
# 
        PROCESS REASON CODE FOR IFC/STPD
# 
IFC$INTRPT:                                      # BATCH INTERRUPT     #
        UCB$INPTYPE = UCMINPUT"INTRPTUCM";
        TCB$RESUME = TRUE;
        GOTO SMPND; 
IFC$CRERR:                                       # CARD READER ERROR   #
        UCB$INPTYPE = UCMINPUT"CRERRUCM"; 
        GOTO SMPND; 
IFC$EOS:                                         # END OF INPUT STREAM #
        UCB$INPTYPE = UCMINPUT"EOSUCM"; 
        GOTO SMPND; 
IFC$NREADY: 
        UCB$INPTYPE = UCMINPUT"CREMTUCM";        # CARD READER EMPTY   #
        GOTO SMPND; 
IFC$DSKERR:                                      # DISK I/O ERROR      #
        UCB$INPTYPE = UCMINPUT"DSKERRUCM";
      UCB$DISKERR = IFCMSEC;
        GOTO SMPND; 
        END                                      # SET SM TYPE         #
      GOTO SMPND; 
      CONTROL EJECT;
OFC$STP:  
# 
      PROCESS OFC/STP SUPERVISORY MESSAGE 
# 
      IF DCB$INPTYPE EQ ZERO
      THEN
        BEGIN                  # SET SM TYPE                           #
        DCB$INPTYPE = DCMINPUT"OFCSTPDCM";
        IF DCB$FILEACT         # DONT SET THE CURPRU FIELD (IN WORD 5) #
        THEN                   # IF THE DCB IS SMALL (3 WORDS).        #
          BEGIN 
          DCB$CURPRU = CURPRU;
          END 
        END                    # SET SM TYPE                           #
      GOTO SMPND; 
      CONTROL EJECT;
OFC$STPD: 
# 
      PROCESS  OFC/STPD SUPERVISORY MESSAGE 
# 
      IF DCB$INPTYPE EQ ZERO
      THEN
        BEGIN                                    # SET SM TYPE         #
        IF DCB$FILEACT         # DONT SET THE CURPRU FIELD (IN WORD 5) #
          AND CURPRU NQ 0      # ZERO MEANS PIP DOES NOT HAVE FILE     #
        THEN                   # IF THE DCB IS SMALL (3 WORDS).        #
          BEGIN 
          DCB$CURPRU = CURPRU;
          END 
        GOTO OFCSTPRC [PRURC];
# 
        PROCESS REASON CODE FOR OFC/STPD
# 
OFC$INTRPT:                                      # BATCH INTERRUPT     #
        DCB$INPTYPE = DCMINPUT"INTRPTDCM";
        DCB$DEVSTOP = TRUE; 
        TCB$RESUME =TRUE; 
        GOTO SMPND; 
  
OFC$PMINT:                                       # PM INTERRUPT        #
        DCB$INPTYPE = DCMINPUT"PMDCM";
        DCB$DEVSTOP = TRUE; 
        DCB$PMTXT = SMBUFFER; 
        DCB$PMSIZE = OFCPMCC + 6; # EXTRA CHARS NEEDED BY DCM TO INSERT#
        CONVERT(SMBUFFER);     # PM, DEV TYPE, ORDINAL INTO PM MESSAGE.#
        RELEASE = FALSE;
        GOTO SMPND; 
  
OFC$LIMIT:                                       # FILE LIMIT EXCEEDED #
        DCB$INPTYPE = DCMINPUT"LIMITDCM"; 
        DCB$DEVSTOP = TRUE; 
        GOTO SMPND; 
  
OFC$NREADY:                                      # DEVICE NOT READY    #
        DCB$INPTYPE = DCMINPUT"NOTRDYDCM";
        DCB$DEVSTOP = TRUE; 
        GOTO SMPND; 
  
OFC$DSKERR:                                      # DISK I/O ERROR      #
        DCB$INPTYPE = DCMINPUT"DSKERRDCM";
        DCB$DISKERR = OFCMSEC;
        GOTO SMPND; 
  
OFC$DCPNL:                           # DEVICE CONFIG PROC NOT LOADABLE #
        DCB$INPTYPE = DCMINPUT"DCPNLDCM"; 
        DCB$DEVSTOP = TRUE; 
        DCB$PMTXT = GETBUF (5,MOVEABLE);
        IF DCB$PMTXT EQ ZERO
        THEN
          BEGIN 
          SMCOUNT = SMCOUNT+1;
          LINKBLOCK (SMINPUT,SMBUFFER); 
          RELEASE = FALSE;
          GOTO SMPND; 
          END 
        P<TXT> = ADDRESS [DCB$PMTXT]; 
        MOVEBLK (5,DCPNL$MSG,TXT);
        DCB$PMSIZE = 50;
        GOTO SMPND; 
  
        END 
      GOTO SMPND; 
      CONTROL EJECT;
  
# 
      PROCESS OFC/ABORT 
# 
OFC$ABT:  
      TEMP = DCMINPUT"OFCABTDCM";                # OUTPUT ABORTED      #
      GOTO OFCOMMON;
  
# 
      PROCESS OFC/EOO 
# 
OFC$EOO:    
      TEMP = DCMINPUT"OFCEOODCM";                # END OF OUTPUT       #
  
OFCOMMON: 
      IF DCB$INPTYPE EQ ZERO
      THEN
        BEGIN 
        DCB$INPTYPE = TEMP;                      # DCM PRU SM TYPE     #
        IF PRUFNT NQ ZERO 
        THEN
          BEGIN 
          DCB$ACCOUNT = PACNT;     # NUMBER OF LINES OUTPUTED      #
          DCB$FILEACT = TRUE;                    # FILE ACTIVE         #
          IF DCB$FETLFN NQ PRULFN                # MISMATCHED FILE     #
          THEN
            BEGIN 
*IF DEF,DEBUG 
            SM$ERR (URGENT);
*ENDIF
            DCB$FETLFN = PRULFN;
            DCB$FNTORD = PRUFNT;
            END 
          ELSE
            DCB$FNTORD = PRUFNT;
          END 
        END 
      GOTO SMPND; 
      CONTROL EJECT;
OFC$DATA: 
# 
      PROCESS OFC/DATA SUPERVISORY MESSAGE
# 
      IF DCB$INPTYPE EQ ZERO
      THEN
        BEGIN                                    # SET SM TYPE         #
        DCB$INPTYPE = DCMINPUT"OFCDATDCM";
        END                                      # SET SM TYPE         #
      GOTO SMPND; 
      CONTROL EJECT;
ERR$LGL:  
# 
      PROCESS ERR/LGL SUPERVISORY MESSAGE 
# 
*IF DEF,DEBUG 
      SM$ERR (URGENT);
*ENDIF
      GOTO SMPND;                                # SMP LOOP            #
        END 
      ACN=SMPACN; 
      IF SMCOUNT NQ ZERO
      THEN
        BEGIN 
        EVENT (CHAINS"BACKGROUND"); 
        GOTO STARTSMP;
        END 
      LINK (CHAINS"SMP$",LOC (WAITSM)); 
      GOTO CALLRTN; 
      CONTROL EJECT;
PRU$ON$N: 
# 
   PROCESS PRU/ON/N RESPONSE SUPERVISORY MESSAGE
# 
      IF ACN$STATE [ACN] EQ CONNECTSTATE"CONNECTED" 
      THEN
        BEGIN 
        SETUPACN (ACN); 
        ACN$STATE [ACN] = CONNECTSTATE"ACTIVE"; 
        IF ACN$DEVTYPE [ACN] EQ S"CARD$READER"
        THEN
          BEGIN 
          LINK (CHAINS"UCM$", LOC(ACKED));
          IF (TCB$AUTOGO) OR           # RESTRICTED INTERACTIVE CONSOLE#
             (TCB$CDCNT )              # CDCNET TERMINAL               #
          THEN
            BEGIN 
            IF TCB$CDCNT
            THEN
              BEGIN   # CDCNET #
              IF UCB$AUTOGO 
              THEN
                TCB$CMDTY = UCMINPUT"GOUCM";
              END     # CDCNET #
            ELSE
              TCB$CMDTY = UCMINPUT"GOUCM";
            END 
          END 
        ELSE
          BEGIN 
          LINK (CHAINS"DCM$", LOC(ACKED));
          IF (TCB$AUTOGO) OR           # RESTRICTED INTERACTIVE CONSOLE#
             (TCB$CDCNT )              # CDCNET TERMINAL               #
          THEN
            BEGIN 
            IF TCB$CDCNT
            THEN
              BEGIN   # CDCNET #
              IF DCB$AUTOGO 
              THEN
                TCB$CMDTY = DCMINPUT"GODCM";
              END     # CDCNET #
            ELSE
              TCB$CMDTY = DCMINPUT"GODCM";
            END 
          END 
        END 
*IF,DEF,DEBUG 
      ELSE
        SM$ERR (ERRX);
*ENDIF
        GOTO SMPND; 
  
  
PRU$ON$A: 
# 
    PROCESS PRU/ON/A RESPONSE SUPERVISORY MESSAGE 
# 
      ACN$STATE [ACN] = CONNECTSTATE"END$CONNECT";
      LINK (CHAINS"CON$END", NOEVENT);
      GOTO SMPND; 
      END  # SMP #
      TERM
