*DECK UCM 
USETEXT IP$COM
USETEXT MISC$ 
USETEXT TCH$COM 
USETEXT TSB$COM 
USETEXT ABH$COM 
USETEXT ACN$COM 
USETEXT GLOBALI 
USETEXT SMDEF 
USETEXT SMAPPFC 
USETEXT SMPFC 
USETEXT PRU$COM 
USETEXT SM$COM
USETEXT SYS$PAR 
USETEXT TCB$COM 
USETEXT UCB$COM 
      PROC UCM; 
      BEGIN                                      # UCM                 #
*IF DEF,IMS 
 #
*1DC  UCM 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        UCM                 SEYUNG OH           JAN 15,1980
* 
*     2. FUNCTIONAL DESCRIPTION.
*        UCM IS THE UPLINE CONTROL MODULE FOR RBF AND IS RESPONSIBLE
*        FOR CONTROLING THE INPUT STREAM. 
* 
* 
*     3. METHOD USED. 
*        UCM IS TABLE DRIVEN PROGRAM THAT EXECUTES ONLY IF THERE IS A 
*        STIMULOUS FROM THE OUTSIDE.
* 
*        INITIALLY UCM IS IN THE STOP STATE UNTIL TERMINAL OPERATOR 
*        TYPES IN GO COMMAND OR RESTRICTED INTERACTIVE CAPABILITY FLAG
*        WAS SET ON CON/REQ. UCM WILL CHANGE STATE TO IDLE AND WAITS FOR
*        VERIFY JOB CARD SUPERVISORY MESSAGE. IFC/JOB SUPERVISORY 
*        MESSAGE CAUSE UCM TO CALL PP PROGRAM, VEJ, TO VERIFY JOB CARD
*        AND ASSIGN A FILE NAME TABLE FOR THE INPUT JOB. WHILE VEJ CALL 
*        IS OUTSTANDING UCM IS IN WAIT FOR VEJ RESPONSE STATE AND WILL
*        NOT HONOR ANY OTHER INPUT. 
*        THE NORMAL RESPONSE FROM THE VEJ WILL CHANGE UCM STATE TO GO 
*        STATE AND SEND JOB CARD VERIFIED NORMAL SUPERVISORY MESSAGE
*        TO THE NAM. THE BAD JOB CARD RESPONSE FROM VEJ CAUSE UCM TO
*        CHANGE STATE TO ABORT BY-PASS STATE AND SEND JOB CARD VERIFIED 
*        ABNORMAL SUPERVISORY MESSAGE TO NAM. THIS SUPERVISORY MESSAGE
*        WILL TRIGGER NAM TO REQUEST OPERATING SYSTEM TO TRANSFER INPUT 
*        FILE FROM RBF TO NAM.
*        WHILE UCM IS IN GO STATE, END OF JOB SUPERVISORY MESSAGE 
*        INDICATES CURRENT INPUT IS ENDED AND JOB FILE IS TRANSFERED
*        BACK TO RBF. AT THIS POINT UCM CAN DISPOSE JOB TO THE INPUT
*        QUEUE BY CALLING PP PROGRAM, DSP. UCM CHANGE STATE TO IDLE 
*        AND WAITS FOR FURTHER INPUT. 
* 
* 
* 
* 
* 
*     S T A T E   T A B L E 
* 
************************************************************************
** STATE* 1    * 2    * 3    * 4    * 5    * 6    * 7    * 8    *      *
*  ***  * IDLE * WTVEJ* GO   * WTID * WTGO * STOP * ABTBY* ABTIM*      *
*INPUT **      *      *      *      *      *      *      *      *      *
************************************************************************
* 1     * 1    *      * 3    * 1    * 3    * 1    * 7    * 8    *      *
* GO    *      * ERR  *      *      *      *      *      *      *      *
*       * A1   *      * A1   * A4   * A4   * A2   * A1   * A1   *      *
************************************************************************
* 2     * 1    *      * 3    * 1    * 3    * 6    * 7    * 8    *      *
* STOP, *      * ERR  *      *      *      *      *      *      *      *
* END   * A3   *      * A3   * A9   * A9   * A22  * A3   * A3   *      *
************************************************************************
* 3     * 1    *      * 3    * 4    * 5    * 6    * 7    * 8    *      *
* RESUME*      * ERR  *      *      *      *      *      *      *      *
*       * A1   *      * A1   * A0   * A0   * A0   * A1   * A0   *      *
************************************************************************
* 4     * 1    *      * 7    * 8    * 8    * 6    * 8    * 8    *      *
* ABORT *      * ERR  *      *      *      *      *      *      *      *
*       * A22  *      * A6   * A7   * A7   * A22  * A7   * A0   *      *
************************************************************************
* 5     * 2    *      *      *      *      *      * 7    * 8    *      *
* VERIFY*      * ERR  * ERR  * ERR  * ERR  * ERR  *      *      *      *
* JOB   * A8   *      *      *      *      *      * A0   * A0   *      *
************************************************************************
* 6     * 6    *      *      *      *      *      * 6    * 6    *      *
* END OF*      * ERR  * ERR  * ERR  * ERR  * ERR  *      *      *      *
* STREAM* A13  *      *      *      *      *      * A13  * A17  *      *
************************************************************************
* 7     * 4    *      * 5    *      *      *      * 8    * 8    *      *
* CR    *      * ERR  *      * ERR  * ERR  * ERR  *      *      *      *
* EMPTY * A16  *      * A16  *      *      *      * A7   * A0   *      *
************************************************************************
* 8     *      *      * 7    *      *      *      * 7    * 8    *      *
* DISK  * ERR  * ERR  *      * ERR  * ERR  * ERR  *      *      *      *
* ERROR *      *      * A20  *      *      *      * A0   * A0   *      *
************************************************************************
* 9     * 8    *      * 8    *      *      *      * 8    * 8    *      *
* CR    *      * ERR  *      * ERR  * ERR  * ERR  *      *      *      *
* ERROR * A21  *      * A21  *      *      *      * A7   * A0   *      *
************************************************************************
* 10    *      *      *      *      *      *      * 1    * 8    *      *
* BY    * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *      *      *
* PASSED*      *      *      *      *      *      * A10  * A10  *      *
************************************************************************
* 11    *      *      * 1    *      *      *      * 7    * 8    *      *
* END OF* ERR  * ERR  *      * ERR  * ERR  * ERR  *      *      *      *
* JOB   *      *      * A11  *      *      *      * A11  * A11  *      *
************************************************************************
* 12    *      *      *      *      *      *      *      * 6    *      *
* INPUT * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *      *
* ABTED *      *      *      *      *      *      *      * A17  *      *
************************************************************************
* 13    *      * 7    *      *      *      *      *      *      *      *
* JOB   * ERR  *      * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *
* ERROR *      * A12  *      *      *      *      *      *      *      *
************************************************************************
* 14    *      * 3    *      *      *      *      *      *      *      *
* JOB   * ERR  *      * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *
* OK    *      * A15  *      *      *      *      *      *      *      *
************************************************************************
* 15    * 1    *      * 3    * 4    * 5    * 6    * 7    * 8    *      *
* BATCH *      * ERR  *      *      *      *      *      *      *      *
* INTRPT* A14  *      * A14  * A14  * A14  * A14  * A14  * A14  *      *
************************************************************************
* 16    * 8    *      * 8    * 8    * 8    * 8    * 8    * 8    *      *
* ENDCON*      * ERR  *      *      *      *      *      *      *      *
*       * A19  *      * A19  * A19  * A19  * A19  * A19  * A0   *      *
************************************************************************
* 17    * 0    *      * 0    * 0    * 0    * 0    * 0    * 0    *      *
* CONCB *      * ERR  *      *      *      *      *      *      *      *
*       * A18  *      * A18  * A18  * A18  * A18  * A18  * A18  *      *
************************************************************************
* 18    *      * 7    *      *      *      *      *      *      *      *
* QUEUE * ERR  *      * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *
* FULL  *      * A6   *      *      *      *      *      *      *      *
************************************************************************
  
* 
*     U C M    S T A T E
* 
*     IDLE    DEVICE IS WAITING FOR VERIFY JOB CARD SUPERVISORY MESSAGE 
* 
* 
*     WTVEJ   DEVICE IS WAITING FOR VEJ TO VERIFY JOB CARDS 
* 
*     GO      NAM IS ACCEPTING CARD INPUT FROM THE CCP
* 
* 
*     WTID    CARD READER STOPPED SUPERVISORY MESSAGE RECEIVED WHILE
*             DEVICE IS IN IDLE STATE 
* 
* 
*     WTGO    CARD READER STOPPED SUPERVISORY MESSAGE RECEIVED WHILE
*             DEVICE IS IN GO STATE 
* 
* 
*     STOP    INPUT STREAM CLOSED 
* 
* 
*     ABTBY   INPUT JOB IS ABORTING BY BY-PASSING DATA
* 
* 
*     ABTIM   INPUT JOB IS ABORTING BY TERMINATING INPUT STREAM 
* 
* 
  
  
  
* 
*     U C M   A C T I O N 
* 
  
************************************************************************
* 
*     A0      DO NOTHING
* 
* 
*     A1      IF INTERRUPTED
*             THEN  RESUME INPUT SM (IFC/RSM) 
* 
* 
*     A2      SEND START INPUT SM (IFC/START) 
* 
* 
*     A3      DO  A1
*             DO  A5
* 
* 
*     A4      SEND RESUME INPUT SM (IFC/RSM)
* 
* 
*     A5      SET STOP,END FLAG 
* 
* 
*     A6      DO  A1
*             SEND BY-PASS ABORT INPUT SM (IFC/END) 
* 
* 
*     A7      SEND ABORT INPUT IMMEDIATELY SM (IFC/ABORT) 
* 
* 
*     A8      CALL VEJ TO VERIFY JOB CARDS, RETURNS FOLLOWING CASES 
*               CASE 1  -  JOB CARDS OK 
*               CASE 2  -  INVALID JOB CARDS
*               CASE 3  -  INPUT QUEUE FULL 
* 
* 
*     A9      DO  A4
*             DO  A5
* 
* 
*     A10     IF FILE ACTIVE
*             THEN  PURGE INPUT FILE ( CALL DSP WITH ABORT FLAG ) 
* 
* 
*     A11     DISPOSE A FILE TO INPUT QUEUE ( CALL DSP )
* 
* 
*     A12     SEND JOB CARD INVALID SM (IFC/JOB/RC = 2) 
* 
* 
*     A13     IF  (NOT MODE 4A TERMINAL  AND  NOT STOP,END FLAG)
*             OR  AUTO-GO FLAG
*             THEN  SIMULATE GO COMMAND 
* 
* 
*     A14     SET INTERRUPT FLAGS 
* 
* 
*     A15     SEND JOB CARD VERIFIED SM (IFC/JOB/RC=1)
* 
* 
*     A16     PROCESS CARD READER NOTREADY
* 
* 
*     A17     DO  A10 
*             DO  A13 
* 
* 
*     A18     LINK TO CON$END MODULE
* 
* 
*     A19     CONSOLE ACTIVITY ENDED BY END COMMAND ( MODE 4A ONLY )
*             DO  A7
* 
* 
*     A20     PROCESS MASS STORAGE ERRORS 
* 
* 
*     A21     PROCESS CARD READER ERROR 
*             DO  A7
* 
* 
*     A22     SEND INAPPROPRIATE COMMAND MESSAGE TO THE CONSOLE 
* 
* 
************************************************************************
  
  
  
* 
*      EXAMPLE OF INPUT PROCESSING
* 
*STEP CURRENT STATE     INPUT               NEXT STATE     ACTION 
* 1   STOP              GO                  IDLE           A2 
* 2   IDLE              IFC/JOB             WTVEJ          A8 
* 3   WTVEJ             JOB CARDS OK        GO             A15
* 4   GO                END OF JOB          IDLE           A11
* 5   IDLE            ......WAITS INPUT...... 
* 
* 
*     4. ENTRY PARAMETERS 
*        NO PARAMETERS REQUIRED, HOWEVER, THE POINTER TO THE UCB AND
*        TCB$DEVICE MUST BE CORRECT WHEN UCM IS CALLED. 
* 
*     5. EXIT PARAMETERS
*        NONE.
* 
*     6. COMDECKS CALLED. 
* 
*        SM$COM 
*        RBF$COM
*        TSBMDEFS 
*        TSBMBASE 
*        ABH$COM
*        TCB$COM
*        UCB$COM
* 
*     7. EXTERNAL ROUTINES CALLED 
*        ABORT
*        ACKED
*        CHGSIZE
*        CIODONE
*        CONSOLE
*        CON$END
*        EVENT
*        LINK 
*        MOVEOK 
*        BUFINFO
*        RETTSB 
*        SETACN 
*        SYSTEM 
*        MESSAGE
* 
*     8. DAYFILE MESSAGES.
*        UCM ERROR BAD PP CALL - DSP
*        UCM ERROR BAD PP CALL - VEJ
*        UCM ERROR BAD PP CALL - CIO
*        UCM STATE TABLE ERROR - X/ X 
* 
 #
*ENDIF
# 
      EXTERNAL REFERENCES 
# 
      XREF
        BEGIN 
        PROC ABORT;          # ABORTS RBF                              #
        PROC ACKED;          # WAIT ON AN INPUT                        #
        FUNC BUFINFO;        # OBTAINS THE ADDRESS OF A BUFFER         #
        FUNC GETBUF U;       # ACQUIRE A BUFFER     # 
        PROC CHGSIZE;        # CHANGE BUFFER SIZE                      #
        PROC CIODONE;        # TEST CIO, VEJ OR DSP DONE               #
        PROC CONSOLE;        # CHAIN A MESSAGE ON THE CONSOLE          #
        PROC CON$END;        # ENDS THE CONNECTION                     #
        PROC EVENT;          # WAIT UNTIL EVENT HAPPENS                #
        PROC LINK;           # LINK TO A MODULE                        #
        LABEL CALLRTN;
        FUNC XSFW C(10);               #SPACE FILL RIGHT JUSTIFIED ZERO#
        PROC MESSAGE;        # DAYFILE MESSAGE                         #
        PROC MOVEOK;         # OK TO MOVE BUFFER                       #
        PROC NETPUT;         # SEND MESSAGE BLOCK TO NAM               #
        PROC RETTSB;         # RELEASE BUFFER SPACE                    #
        PROC SETUPACN;      # SET POINTERS TO TCB AND UCB BUFFER    # 
        PROC SYSCALL;        # ISSUE SYSTEM CALL                       #
        FUNC UINPTYPE;
        END 
# 
      UCM CONSOLE MESSAGE 
# 
      STATUS UMSG    NULL,
                     JOBERR,           # JOB CARD ERROR MESSAGE        #
                     USRERR,           # USER CARD ERROR MESSAGE       #
                     ACKMSG,           # ACKNOWLEDGE MESSAGE           #
                     QFULL,            # INPUT QUEUE FULL MESSAGE      #
                     CRERR,            # CARD READER ERROR MESSAGE     #
                     DSKFUL,           # DISK FULL MESSAGE             #
                     DSKPAR,           # DISK PARITY ERROR MESSAGE     #
                     NOTRDY,           # CARD READER NOTREADY MESSAGE  #
                     ABTED,            # ABORTED MESSAGE               #
                     INAPPR,           # INAPPROPRIATE COMMAND MESSAGE #
                     LAST;
# 
      DSP ABORT REASON CODE 
# 
      STATUS DSPABT NULL, 
                    VEJERR,          # JOB/USER CARD ERROR #
                    CRERR,           # CARD READER ERROR #
                    OPREQ,           # ABORTED BY OPERATOR #
                    DSKFUL,          # DISK FULL #
                    DSKPAR,          # DISK PARITY ERROR #
                    LAST; 
  
# 
      UCM ACTION STATUS 
# 
  
      STATUS UCMACT UCM$A0, 
                    UCM$A1, 
                    UCM$A2, 
                    UCM$A3, 
                    UCM$A4, 
                    UCM$A5, 
                    UCM$A6, 
                    UCM$A7, 
                    UCM$A8, 
                    UCM$A9, 
                    UCM$A10,
                    UCM$A11,
                    UCM$A12,
                    UCM$A13,
                    UCM$A14,
                    UCM$A15,
                    UCM$A16,
                    UCM$A17,
                    UCM$A18,
                    UCM$A19,
                    UCM$A20,
                    UCM$A21,
                    UCM$A22,
                    UCM$AER;
      SWITCH UCM$ACTION  : UCMACT 
             UCM$AZERO   : UCM$A0,
             UCM$AONE    : UCM$A1,
             UCM$ATWO    : UCM$A2,
             UCM$ATHREE  : UCM$A3,
             UCM$AFOUR   : UCM$A4,
             UCM$AFIVE   : UCM$A5,
             UCM$ASIX    : UCM$A6,
             UCM$ASEVEN  : UCM$A7,
             UCM$AEIGHT  : UCM$A8,
             UCM$ANINE   : UCM$A9,
             UCM$1ZERO   : UCM$A10, 
             UCM$1ONE    : UCM$A11, 
             UCM$1TWO    : UCM$A12, 
             UCM$1THREE  : UCM$A13, 
             UCM$1FOUR   : UCM$A14, 
             UCM$1FIVE   : UCM$A15, 
             UCM$1SIX    : UCM$A16, 
             UCM$1SEVEN  : UCM$A17, 
             UCM$1EIGHT  : UCM$A18, 
             UCM$1NINE   : UCM$A19, 
             UCM$2ZERO   : UCM$A20, 
             UCM$2ONE    : UCM$A21, 
             UCM$2TWO    : UCM$A22, 
              UCM$AERROR  : UCM$AER;
  
# 
      U C M  S T A T E  T A B L E 
# 
  
      ARRAY UCM$STATE [1:19] S(2);
        BEGIN 
        ITEM UCB$SIDLE       S:UCMSTATE (0,0,6) = 
                             [S"UCM$IDLE",S"UCM$IDLE",S"UCM$IDLE",
                              S"UCM$IDLE" ,S"UCM$WTVEJ",S"UCM$STOP" , 
                              S"UCM$WTID" ,S"UCM$ERROR",S"UCM$ABTIM", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$IDLE" , 
                              S"UCM$ABTIM",S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ABTIM"],
             UCB$SWTVEJ      S:UCMSTATE (0,6,6) = 
                             [S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ABTBY",S"UCM$GO"   ,S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ABTBY", 
                              S"UCM$ERROR"],
             UCB$SGO         S:UCMSTATE (0,12,6) =
                             [S"UCM$GO"   ,S"UCM$GO"   ,S"UCM$GO"   , 
                              S"UCM$ABTBY",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$WTGO" ,S"UCM$ABTBY",S"UCM$ABTIM", 
                              S"UCM$ERROR",S"UCM$IDLE" ,S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$GO"   , 
                              S"UCM$ABTIM",S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ERROR"],
             UCB$SWTID       S:UCMSTATE (0,18,6) =
                             [S"UCM$IDLE" ,S"UCM$IDLE" ,S"UCM$WTID" , 
                              S"UCM$ABTIM",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$WTID" , 
                              S"UCM$ABTIM",S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ABTIM"],
             UCB$SWTGO       S:UCMSTATE (0,24,6) =
                             [S"UCM$GO"   ,S"UCM$GO"   ,S"UCM$WTGO" , 
                              S"UCM$ABTIM",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$WTGO" , 
                              S"UCM$ABTIM",S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ERROR"],
             UCB$SSTOP       S:UCMSTATE (0,30,6) =
                             [S"UCM$IDLE" ,S"UCM$STOP" ,S"UCM$STOP" , 
                              S"UCM$STOP" ,S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$STOP" , 
                              S"UCM$STOP" ,S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ERROR"],
             UCB$SABTBY      S:UCMSTATE (0,36,6) =
                             [S"UCM$ABTBY",S"UCM$ABTBY",S"UCM$ABTBY", 
                              S"UCM$ABTIM",S"UCM$ABTBY",S"UCM$STOP" , 
                              S"UCM$ABTIM",S"UCM$ABTBY",S"UCM$ABTIM", 
                              S"UCM$IDLE" ,S"UCM$ABTBY",S"UCM$ERROR", 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ABTBY", 
                              S"UCM$ABTIM",S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ERROR"],
             UCB$SABTIM      S:UCMSTATE (0,42,6) =
                             [S"UCM$ABTIM",S"UCM$ABTIM",S"UCM$ABTIM", 
                              S"UCM$ABTIM",S"UCM$ABTIM",S"UCM$STOP" , 
                              S"UCM$ABTIM",S"UCM$ABTIM",S"UCM$ABTIM", 
                              S"UCM$ABTIM",S"UCM$ABTIM",S"UCM$STOP" , 
                              S"UCM$ERROR",S"UCM$ERROR",S"UCM$ABTIM", 
                              S"UCM$ABTIM",S"NULL"     ,S"UCM$ERROR", 
                              S"UCM$ERROR"];
        ITEM UCB$NEXTST      U (0,0,60);
        ITEM UCB$AIDLE       S:UCMACT (1,0,6) = 
                             [S"UCM$A1" ,S"UCM$A3" ,S"UCM$A1" , 
                              S"UCM$A22",S"UCM$A8" ,S"UCM$A13", 
                              S"UCM$A16",S"UCM$AER",S"UCM$A21", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A19",S"UCM$A18",S"UCM$AER", 
                              S"UCM$A7"], 
             UCB$AWTVEJ      S:UCMACT (1,6,6) = 
                             [S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$A12",S"UCM$A15",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A6" , 
                              S"UCM$AER"],
             UCB$AGO         S:UCMACT (1,12,6) =
                             [S"UCM$A1" ,S"UCM$A3" ,S"UCM$A1" , 
                              S"UCM$A6" ,S"UCM$AER",S"UCM$AER", 
                              S"UCM$A16",S"UCM$A20",S"UCM$A21", 
                              S"UCM$AER",S"UCM$A11",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A19",S"UCM$A18",S"UCM$AER", 
                              S"UCM$AER"],
             UCB$AWTID       S:UCMACT (1,18,6) =
                             [S"UCM$A4" ,S"UCM$A9" ,S"UCM$A0" , 
                              S"UCM$A7" ,S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A19",S"UCM$A18",S"UCM$AER", 
                              S"UCM$A7"], 
             UCB$AWTGO       S:UCMACT (1,24,6) =
                             [S"UCM$A4" ,S"UCM$A9" ,S"UCM$A0" , 
                              S"UCM$A7" ,S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A19",S"UCM$A18",S"UCM$AER", 
                              S"UCM$AER"],
             UCB$ASTOP       S:UCMACT (1,30,6) =
                             [S"UCM$A2" ,S"UCM$A22",S"UCM$A0" , 
                              S"UCM$A22",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A19",S"UCM$A18",S"UCM$AER", 
                              S"UCM$AER"],
             UCB$AABTBY      S:UCMACT (1,36,6) =
                             [S"UCM$A1" ,S"UCM$A3" ,S"UCM$A1" , 
                              S"UCM$A7" ,S"UCM$A0" ,S"UCM$A13", 
                              S"UCM$A7" ,S"UCM$A0" ,S"UCM$A7" , 
                              S"UCM$A10",S"UCM$A11",S"UCM$AER", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A19",S"UCM$A18",S"UCM$AER", 
                              S"UCM$AER"],
             UCB$AABTIM      S:UCMACT (1,42,6) =
                             [S"UCM$A1" ,S"UCM$A5" ,S"UCM$A0" , 
                              S"UCM$A0" ,S"UCM$A0" ,S"UCM$A17", 
                              S"UCM$A0" ,S"UCM$A0" ,S"UCM$A0" , 
                              S"UCM$A10",S"UCM$A11",S"UCM$A17", 
                              S"UCM$AER",S"UCM$AER",S"UCM$A14", 
                              S"UCM$A0" ,S"UCM$A18",S"UCM$AER", 
                              S"UCM$AER"];
        ITEM UCB$ACTION      U (1,0,60);
        END 
  
  
  
      ARRAY PPERROR S(3); 
        BEGIN 
        ITEM UCMPPMSG   C (0,0,25) = [" UCM ERROR BAD PP CALL - "], 
             UCMPPWHO   C (2,30,3), 
             UCMPPEOL   U (2,48,12) = [0];
        END 
      ARRAY STBLERR S(3); 
        BEGIN 
        ITEM STBLMSG   C (0,0,24) = ["UCM STATE TABLE ERROR - "], 
             STBLINP   C (2,24,1),
             STBLSLS   C (2,30,2) = ["/ "], 
             STBLSTA   C (2,42,1),
             STBLEOL    U (2,48,12) = [0];
        END 
# 
      LOCAL VERIABLE
# 
      ITEM I I; 
      ITEM INPUT I; 
      ITEM NEXTSTATE I; 
      ITEM ACTION I;
      ITEM STATE I; 
      ITEM RSNCODE U; 
      ITEM TEMP$FILEACT B;
      ITEM TEMP$NOTRDY  B ; 
      ARRAY TEMPX S(2); 
        ITEM TEMP1 U (0,0,60),
             TEMP2 U (1,0,60);
      ITEM K I; 
      ITEM MSGTIME  C (10);     # CURRENT TIME                         #
      DEF  SYSTIME # O"2 00 000000"#; 
# 
      UCM CONSOLE MESSAGE BUFFER
# 
      ARRAY MESSAGES [1:UMSG"INAPPR"] S(7); 
        BEGIN 
        ITEM MSGBLK C (0,0,70) = [
       "1********* CR* JOB NAME **** JOB CARD ERROR", 
       "1********* CR* JOB NAME **** USER CARD ERROR",
       "1********* CR* JOB NAME **** ENTERED INPUT QUEUE",
       "1********* CR* JOB NAME **** ABORTED, INPUT QUEUE FULL",
       "1********* CR* JOB NAME **** ABORTED, CARD READER ERROR ",
       "1********* CR* JOB NAME **** ABORTED, DISK FULL", 
       "1********* CR* JOB NAME **** ABORTED, DISK PAR ERR",
       "1********* CR* NOT READY",
       "1********* CR* JOB NAME **** ABORTED BY TERMINAL OPERATOR", 
       "1********* CR* INAPPROPRIATE COMMAND"]; 
        ITEM MSGJOBCOL U(6,42,16) = [7(24),61,24,61]; 
        ITEM MSGDEVCOL U(6,24,18) = [10(13)]; 
        ITEM MSGLENGTH U(6,12,12) = [43,44,48,54,55,47,50,24,57,36];
        END 
      LABEL POSTDSP,                   # RETURN ADDRESS FOR UCM$DSP    #
            POSTPURGE,                 # RETURN ADDRESS FOR UCM$PURGE  #
            POSTVEJ;                   # RETURN ADDRESS FOR UCM$VEJ    #
      CONTROL EJECT;
      PROC UCM$DSP; 
      BEGIN                                      # BEGIN DSP           #
*IF DEF,IMS 
 #
*1DC  UCM$DSP 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        UCM$DSP             SEYUNG OH           JAN 29,1980
* 
*     2. FUNCTIONAL DESCRIPTION.
*        DISPOSE INPUT JOB TO SYSTEM INPUT QUEUE
* 
*     3. METHOD USED
*        SET UP DSP FET 
*        REQUEST DSP
* 
*     4. ENTRY PARAMETERS.
*        UCB. 
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS CALLED. 
*        SEE UCM
* 
*     7. EXTERNAL ROUTINES CALLED 
*        SYSTEM 
*        DSP
*        EVENT
*        MESSAGE
* 
*     8. DAYFILE MESSAGES 
*        UCM ERROR BAD PP CALL - DSP
* 
 #
*ENDIF
      TEMP1 = BUFINFO (ACN$CB [ACN]);            # FREEZE UCB SPACE    #
      UCB$FETSTAT = ZERO;                        # CLEAR FET           #
      UCB$DSP1    = ZERO; 
      UCB$DSP2    = ZERO; 
      UCB$DSP3    = ZERO; 
      TEMP2 = UCB$FETFNT;                        # SAVE JOB DNT ORDINAL#
      UCB$DSP4    = ZERO; 
      UCB$DSPFNT  = TEMP2;                       # SET UP DSP FET      #
      UCB$DSPINP  = TRUE; 
      UCB$DSPMNE  = "IN"; 
      UCB$DSPACC  = TRUE; 
      UCB$DSPNDM  = TRUE; 
      UCB$DSPDC   = TRUE; 
      UCB$DSPTNAME= UCB$TERMNAME; 
      UCB$TFDISB = TRUE ;                  # NOT TO VALIDATE AGAIN     #
      SYSCALL("DSP", LOC (UCB$DSP0));            # CALL DSP            #
      SYSACT = TRUE;                             # WAIT FOR DSP TO     #
      EVENT (LOC (CIODONE));                     # COMPLETE            #
      IF UCB$DSPERR NQ ZERO 
      THEN
        BEGIN                                    # DSP CALL ERROR      #
        UCMPPWHO = "DSP"; 
        MESSAGE (PPERROR, DFLOPT);               # DAYFILE MESSAGE     #
        ABORT;
        END 
      MOVEOK (ACN$CB [ACN]);
      UCB$FILEACT = FALSE;
      UCB$MESSAGE = ZERO; 
      GOTO POSTDSP; 
      END                                        # END DSP             #
      CONTROL EJECT;
      PROC UCM$MSG; 
      BEGIN                                      # UCM$MSG             #
*IF DEF,IMS 
 #
*1DC  UCM$MSG 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        UCM$MSG             SEYUNG OH           JAN 25,1980
* 
*     2. FUNCTIONAL DESCRIPTION.
*        THIS ROUTINE IS CALLED TO FORMAT THE CONSOLE MESSAGE 
* 
*     3. METHOD USED. 
*        UCB$MESSAGE FIELD IS CHECKED TO DETERMINE WHICH CONSOLE
*        MESSAGE TO FORMAT AND OUTPUT 
* 
*     4. ENTRY PARAMETERS.
*        UCB
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS CALLED
*        SEE UCM
* 
*     7. EXTERNAL ROUTINES CALLED.
*        NONE.
* 
*     8. DAYFILE MESSAGE
*        NONE.
* 
 #
*ENDIF
# 
      LOCAL VARIABLES 
# 
      ITEM CONSOLMSG C (70);                     # MESSAGE BUFFER      #
      ITEM MSGORD I;                             # MESSAGE TYPE        #
      ITEM FORIC B;                              # SEND TO RIC DEVICE  #
      DEF DISPLAY$ZERO #O"33"#; 
  
      MSGORD = UCB$MESSAGE; 
      FORIC = FALSE;
      CONSOLMSG = MSGBLK [MSGORD];
      C<MSGDEVCOL [MSGORD]>CONSOLMSG = TCB$ORD + DISPLAY$ZERO;
      C<MSGJOBCOL[MSGORD],4>CONSOLMSG = UCB$JSN ; 
      SYSCALL("TIMP",SYSTIME + LOC (MSGTIME));
      C<1,09>CONSOLMSG = C<1,09>MSGTIME;
      P<PRUX> = ADDRESS [UCB$BUFFER] + 1; 
        FORIC = TRUE;                            # SEND TO RIC CONSOLE #
      CONSOLE (CONSOLMSG, FORIC, MSGLENGTH [MSGORD]); 
      RETURN; 
      END                                        # UCM$MSG             #
      PROC UCM$PURGE; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC  UCM$PURGE 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        UCM$PURGE           SEYUNG OH           JAN 30,1980
* 
*     2. FUNCTIONAL DESCRIPTION.
*        UCM$PURGE IS CALLED TO DISPOSE A FILE WHICH TO BE ABORTED
*        BY OPERATING SYSTEM SO THAT AN OUTPUT FILE IS PRODUCED.
*        UCM$PURGE IS CALLED WHEN UCM DETECTED FOLLOWING CONDITIONS.
* 
*          A. INVALID JOB CARD
*          B. INVALID USER CARD 
*          C. CARD READER ERROR 
*          D. DISK FULL 
*          E. DISK PARITY ERROR 
*          F. ABORTED BY TERMINAL OPERATOR
* 
*     3. METHOD USED. 
*        SET UP DSP FET 
*        REQUEST DSP
* 
*     4. ENTRY PARAMETERS.
*        UCB
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS CALLED. 
*        SEE UCM
* 
*     7. EXTERNAL ROUTINES CALLED.
*        SYSTEM 
*        DSP
*        EVENT
*        MESSAGE
*        UCM$MSG
* 
*     8. DAYFILE MESSAGES.
*        UCM ERROR BAD PP CALL - DSP
* 
* 
 #
*ENDIF
      TEMP2 = UCB$DSPMSG; 
      TEMP1 = BUFINFO (ACN$CB [ACN]);            # FREEZE UCB SPACE    #
      UCB$FETSTAT = ZERO;                        # CLEAR DSP FET       #
      UCB$DSP1 = ZERO;
      UCB$DSP2 = ZERO;
      UCB$DSP3 = ZERO;
      TEMP1 = UCB$FETFNT;                        # SAVE FNT ORDINAL    #
      UCB$DSP4 = ZERO;
      UCB$DSPMSG = TEMP2;                        # ABORT MESSAGE       #
      UCB$DSPFNT = TEMP1;                        # INPUT FILE FNT      #
      UCB$DSPINP = TRUE;                         # JOB CARDS ERROR     #
      UCB$DSPMNE = "IN";                         # DISPOSE TO INPUT Q  #
      UCB$DSPACC = TRUE;                         # DO ACCOUNTING       #
      UCB$DSPNDM = TRUE;                         # NO DAYFILE MESSAGE  #
      UCB$DSPDC  = TRUE;                         # CHANGE DISPOSITION  #
      UCB$DSPTNAME = UCB$TERMNAME;               # TERMINAL NAME       #
      UCB$DSPABT = TRUE;                         # ABORT INPUT FLAG    #
      SYSCALL("DSP", LOC (UCB$DSP0));            # CALL DSP            #
      SYSACT = TRUE;                             # PP ACTIVE           #
      EVENT (LOC (CIODONE));                     # WAIT FOR PP         #
      IF UCB$DSPERR NQ ZERO 
      THEN
        BEGIN                                    # DSP CALL ERROR      #
        UCMPPWHO = "DSP";                        # SET DFL MESSAGE     #
        MESSAGE (PPERROR,DFLOPT); 
        ABORT;
        END 
      MOVEOK (ACN$CB [ACN]);                     #  UCB MOVEABLE       #
      UCB$FILEACT = FALSE;                       #  UCM NO LONGER OWNS# 
                                                   # INPUT FILE   # 
      GOTO POSTPURGE; 
      END 
      PROC UCM$SM (SMCODE,LENGTH,RCODE,STRING); 
      BEGIN                                      # UCM$SM BEGIN        #
*IF DEF,IMS 
 #
*1DC  UCM$SM
* 
*     1. PROC NAME           AUTHOR              DATE 
*        UCM$SM              SEYUNG OH           JAN 16,1980
* 
*     2. FUNCTIONAL DESCRIPTION.
*        SEND A INPUT FLOW CONTROL SUPERVISORY MESSAGE TO NAM.
* 
*     3. METHOD USED. 
*        LCM$SM BUILD SUPERVISORY MESSAGE FROM THE ENTRY PARAMETERS 
*        AND CALLS NETPUT 
* 
*     4. ENTRY PARAMETERS.
*        SMCODE - PFC/SFC OF SM 
*        LENGTH - LENGTH OF SM
*        RCODE - REASON CODE
*        STRING - SECOND AND THIRD WORD OF SM 
* 
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS USED
*        NONE.
* 
*     7. ROUTINES CALLED. 
*        NETPUT 
* 
*     8. DAYFILE MESSAGE
*        NONE.
* 
 #
*ENDIF
      ITEM SMCODE U;                             # PFCSFC VALUE        #
      ITEM LENGTH U;                             # LENGTH OF SM        #
      ITEM RCODE U;                              # REASON CODE VALUE   #
      ITEM JK I;                                 # INDEX VALUE         #
      ARRAY STRING S(2);
       ITEM STRING1 U (0,0,60),                  # 2ND WORD OF SM      #
            STRING2 U (1,0,60);                  # 3RD WORD OF SM      #
      ARRAY SMBUF [0:3] S(1);                    # SM BUFFER           #
        ITEM SMOFC U (0,0,60);
# 
      INITIALIZE SUPERVISORY MESSAGE AREA 
# 
      FOR JK=0 STEP 1 UNTIL 3 DO
        BEGIN 
        SMOFC [JK] = 0;                          # CLEAR SM BUFFER     #
        END 
# 
      BUILD APPLICATION BLOCK HEADER AND TEXT AREA
# 
      P<ABH> = LOC (SMOFC [0]); 
      ABH$ABT = BLOCKTYPE"SM";
      ABH$TLC = LENGTH; 
      ABH$ACT = ACT"SIXTYBITS"; 
      P<PRUX> = LOC (SMOFC [1]);
      P<SM$> = LOC (SMOFC [1]); 
      PFCSFC = SMCODE;
      PRUACN = ACN; 
      PRURC = RCODE;
      PRUSMH1 = STRING1;
      PRUSMH2 = STRING2;
# 
      CALL NETPUT 
# 
      NETPUT (ABH,SM$); 
      IF SMCODE EQ IFCABRT
      THEN
        BEGIN 
        TCB$CRINTR = TRUE ;                      # ALLOW CONSOLE TO GO #
                                               # INTO INTERACTIVE MODE #
        END 
      ELSE
        BEGIN 
        IF SMCODE NQ IFCJOBN  # DO NOT CLEAR INTERRUPT FLAG IF ONLY    #
        THEN                 # VERIFYING INPUT JOB CARD.               #
          BEGIN 
          TCB$BATCH = TRUE;  # BATCH ACTIVITY STARTED                  #
          TCB$INTERRPT = ZERO;  # CLEAR INTERRUPT FLAGS                #
          END 
        END 
      RETURN; 
      END                                        # DCM$SM END          #
      CONTROL EJECT;
      PROC UCM$VEJ; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC
* 
*     UCM$VEJ 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        UCM$VEJ             SEYUNG OH           JAN 28,1980
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS SUBROUTINE CALLS VEJ TO PROCESS THE FIRST TWO CARDS OF
*        THE NEW JOB. 
* 
*     3. METHOD USED. 
*        UCM$VEJ SETS UP FET AND MAKE RA+1 SYSTEM REQUEST TO VEJ. 
*        AFTER VEJ HAS COMPLETED ITS PROCESSING, UCM$VEJ PROCESSES THE
*        RETURN CODE FROM VEJ.
*        IF SYSTEM ERROR IS RETURNED THEN RBF WILL ABORT
*        IF THE INPUT QUEUE IS FULL, TCB$INPQFULL IS SET FOR THE DISPLAY
*        DRIVER AND THE CONSOLE MESSAGE 
* 
*         HH.MM.SS CRN JOB NAME AAAA ABORTED, INPUT QUEUE FULL
* 
*        WILL BE SENT, WHERE AAAA IS THE THE HOST ASSIGNED JSN. 
*        IF A JOB CARD ERROR OCCURRED, THE CONSOLE MESSAGE
* 
*         HH.MM.SS CRN JOB NAME AAAA JOB CARD ERROR 
* 
*        WILL BE SENT, WHERE AAAA IS THE THE HOST ASSIGNED JSN. 
* 
*        IF A USER CARD ERROR OCCURRED, THE CONSOLE MESSAGE 
* 
*         HH.MM.SS CRN JOB NAME AAAA USER CARD ERROR
* 
*        WILL BE SENT, WHERE AAAA IS THE HOST ASSIGNED JSN. 
* 
*        IF NO ERROR OCCURRED, THEN UCM$VEJ WILL BE SET TO TRUE.
* 
*     4. ENTRY PARAMETERS.
*        UCB. 
* 
*     5. EXIT PARAMETERS. 
*        UCM$VEJ
* 
*     6. COMDECKS CALLED
*        SEE DCM
* 
*     7. EXTERNAL ROUTINES CALLED 
*        SYSTEM 
*        VEJ
*        EVENT
*        CIODONE
*        BUFINFO
*        MESSAGE
* 
*     8. DAYFILE MESSAGE
*        UCM ERROR BAD PP CALL - VEJ
* 
 #
*ENDIF
# 
      UCM$VEJ  SWITCH 
# 
      SWITCH PROCESSVEJ  : VEJERR 
             UCM$VJOBOK  : JOBOK, 
             UCM$VJOBERR : JOBERR,
             UCM$VBADBUF : BADBUF,
             UCM$VACCERR : ACCERR,
             UCM$VINPFUL : INPFUL,
             UCM$VBADTID : BADTID,
             UCM$VLAST   : LAST;
  
  
      TEMP2 = BUFINFO (ACN$CB [ACN]);            # FREEZE UCB          #
      P<ABH> = BUFINFO (UCB$BUFFER);             # FREEZE SM BUFFER    #
      P<PRUX> = P<ABH> + 1; 
      FOR K=1 STEP 1 UNTIL 6 DO 
        BEGIN 
        UCB$VEJ0 [K] = ZERO;
        END 
      UCB$VEJFWA = P<PRUX> + 1;                  # FIRST WORD ADDRESS, #
      UCB$VEJLWA = UCB$VEJFWA + ABH$TLC - 1;     # LAST WORD ADDRESS OF#
      IF ABH$TLC EQ 1 
      THEN
        BEGIN                                    # NULL JOB CARD       #
         RETTSB (UCB$BUFFER); 
         SETUPACN (ACN);                            # FAKE A BLANK JOB #
         UCB$BUFFER = 0;                          # AND USER CARD FOR#
         FOR K=K WHILE UCB$BUFFER EQ 0 DO         # RA+1 CALL - VEJ  #
           BEGIN
           UCB$BUFFER = GETBUF(2,NOT$MOVEABLE); 
           IF UCB$BUFFER EQ 0 
            THEN  EVENT(CHAINS"BACKGROUND");
           END
         P<PRUX> = BUFINFO(UCB$BUFFER); 
         PRUSMH0 = O"55555555555555555555"; 
         PRUSMH1 = O"55555555555555555555"; 
         UCB$VEJFWA = P<PRUX>;
         UCB$VEJLWA = P<PRUX>+1;
        END 
      UCB$VEJFAM = TCB$FAMNAME;                  # JOB CARDS           #
      UCB$VEJUSR = TCB$USERNUM; 
      UCB$VEJTID = -LOC (UCB$VEJFAM);            # TID ADDRESS         #
      IF SECMOD NQ 0
      THEN
        BEGIN                # SECURITY MODE CHECK                     #
        UCB$SP = TRUE ; 
        UCB$AL = TCB$AL ; 
        END 
      SYSCALL("VEJ", LOC (UCB$VEJ0));            # CALL VEJ ****       #
      SYSACT = TRUE;
      EVENT (LOC (CIODONE));                     # WAIT UNTIL DONE     #
      IF UCB$VEJERR GR VEJERR"LAST" 
      THEN
        BEGIN                                    # ILLEGAL REQUEST     #
        GOTO UCM$VLAST; 
        END 
      GOTO PROCESSVEJ [UCB$VEJERR]; 
# 
      NO ERROR
# 
UCM$VJOBOK:                                      # NO ERRORS           #
      UCB$FILEACT = TRUE; 
      TCB$ALOTIME = 0;                          #CLEAR INACTIVITY TIMER#
      GOTO UCM$VEJEXIT; 
# 
      JOB CARD ERROR
# 
UCM$VJOBERR:                                     # JOB CARD ERROR      #
      TCB$JOBERR = TRUE;
      UCB$MESSAGE = UMSG"JOBERR";                # OUTPUT JOB CARD     #
      UCB$FILEACT = TRUE;                        # ERROR MSG TO CONSOLE#
      TCB$ALOTIME = 0;                          #CLEAR INACTIVITY TIMER#
      UCM$MSG;
      GOTO UCM$VEJEXIT; 
# 
      BUFFER ARGUMENT ERROR, INVALID TID, AND ILLEGAL REQUEST 
# 
UCM$VBADBUF:  
UCM$VBADTID:  
UCM$VLAST:  
      UCMPPWHO = "VEJ"; 
      MESSAGE (PPERROR, DFLOPT);
      ABORT;
# 
      USER CARD ERROR 
# 
UCM$VACCERR:  
      TCB$ACCTERR = TRUE; 
      UCB$MESSAGE = UMSG"USRERR";                # OUTPUT USER CARD    #
      UCB$FILEACT = TRUE;                        # ERROR MSG TO CONSOLE#
      UCM$MSG;
      GOTO UCM$VEJEXIT; 
# 
      INPUT QUEUE FULL
# 
UCM$VINPFUL:  
      TCB$INPQFULL = TRUE;
      UCB$MESSAGE = UMSG"QFULL";                 # OUTPUT INPUT Q FULL #
      UCM$MSG;                                   # MSG TO CONSOLE      #
UCM$VEJEXIT:  
      RETTSB (UCB$BUFFER);                       # RETURN SM BUFFER    #
      MOVEOK (ACN$CB [ACN]);                     # UNFREEZE UCB        #
      SETUPACN (ACN); 
      UCB$BUFFER = ZERO;
      GOTO POSTVEJ; 
      END                                        # UCM$VEJ             #
  
# 
************************************************************************
*     U C M   MAIN
************************************************************************
# 
      FOR I=I DO
        BEGIN                                    # MAIN LOOP UCM       #
        INPUT = UINPTYPE;                        # GET INPUT           #
RESTART:  
        IF INPUT EQ ZERO
        THEN
          BEGIN                                  # NOTHING TO DO       #
          EVENT (LOC (ACKED));                   # WAIT FOR INPUT      #
          END 
        ELSE
          BEGIN                                  # SOMETHING TO DO     #
          STATE = ACN$MODE [ACN];                # GET CURRENT INPUT   #
          NEXTSTATE = B<STATE * 6-6,6>UCB$NEXTST [INPUT]; 
          ACTION = B<STATE * 6-6,6>UCB$ACTION [INPUT];
          UCB$INPTYPE = ZERO;                    # CLEAR SM INPUT      #
          IF INPUT LQ UCMINPUT"ABORTUCM"
          THEN
            BEGIN                                # CLEAR COMMAND INPUT #
            TCB$CMDTY = ZERO; 
            END 
          IF INPUT EQ UCMINPUT"ENDCONUCM" 
          THEN
            BEGIN 
            TCB$ENDCON = FALSE; 
            END 
          IF IDLESHUTDOWN                        # IDLE DOWN IN PROGRES#
             AND                                 #S AND UCM IS IN STOP #
             STATE EQ UCMSTATE"UCM$STOP"         #STATE                #
          THEN
            BEGIN 
            NEXTSTATE = UCMSTATE"UCM$STOP";      # STAY IN THE STOP    #
            ACTION = ZERO;                       # DO NO ACTION        #
            END 
          ACN$MODE [ACN] = NEXTSTATE;            # UPDATE UCM STATE    #
          UCB$TIME = CLOCK;                      # UPDATE UCM TIME     #
          UCB$CURINPUT = INPUT;                  # SAVE CURRENT INPUT  #
          UCB$CURSTATE = STATE;                  # SAVE CURRENT STATE  #
          UCB$CURACTN = ACTION;                  # SAVE CURRENT ACTION #
# 
      JUMP TO PROPER ACTION 
# 
          GOTO UCM$ACTION [ACTION]; 
  
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 0                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$AZERO:  
          TEST I;                                # DO NOTHING          #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 1                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$AONE: 
          IF UCB$INTRPT                          # IF BATCH DEVICE WAS #
          THEN                                   # INTERRUPTED         #
            BEGIN 
            UCM$SM (IFCRSM,LIFCRSM,ZERO,ZERO);  # SENT IFC/RSM       #
            UCB$INTRPT = FALSE;                  # CLEAR UCB INTERRUPT #
            END 
          IF UCB$CURINPUT EQ UCMINPUT"GOUCM"     # IF INPUT WAS GO CMD #
          THEN
            BEGIN                                # CLEAR TCB$ERRORS AND#
            GOTO UCM$CLEAR;                      # STOP,END FLAG       #
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 2                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$ATWO: 
          UCM$SM (IFCSTRT,LIFCSTR,ZERO,ZERO);   # SENT IFC/START     #
          GOTO UCM$CLEAR;                        # CLEAR TCB$ERRORS AND#
                                                 # STOP,END FLAG       #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 3                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$ATHREE: 
          UCB$STPEND = TRUE;                     # SET STOP,END FLAG   #
          GOTO UCM$AONE;                         # DO UCM$A1           #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 4                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$AFOUR:  
          UCM$SM (IFCRSM,LIFCRSM,ZERO,ZERO);    # SENT IFC/RSM       #
UCM$CLEAR:  
          TCB$ERRORS = ZERO;                     # CLEAR TCB$ERRORS    #
          UCB$STPEND = FALSE;                    # CLEAR STOP,END FLAG #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 5                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$AFIVE:  
          UCB$STPEND = TRUE;                     # SET STOP,END FLAG   #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 6                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$ASIX: 
          IF UCB$INTRPT 
          THEN
            BEGIN                                # IF BATCH DEVICE IS  #
            UCM$SM (IFCRSM,LIFCRSM,ZERO,ZERO);  # INTERRUPTED TEHEN  #
            UCB$INTRPT = FALSE;                  # RESUME CARD READER  #
            END 
          IF UCB$CURINPUT EQ UCMINPUT"ABORTUCM" 
          THEN
            BEGIN                                # ABORT COMMAND       #
            UCB$MESSAGE = UMSG"ABTED";
            IF UCB$FILEACT
            THEN
              BEGIN 
              UCB$DSPMSG = DSPABT"OPREQ";        # OPERATOR REQUEST ABT#
              END 
            END 
          UCM$SM (IFCEND,LIFCEND,ZERO,ZERO);     # SEND IFC/END SM     #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 7                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$ASEVEN: 
          UCB$INTRPT = FALSE;                    # CLEAR INTERRUPT FLAG#
          UCM$SM (IFCABRT,LIFCABT,ZERO,ZERO);   # SENT IFC/ABORT     #
          IF UCB$CURINPUT EQ UCMINPUT"CREMTUCM" 
          THEN
            BEGIN 
            TEMP$NOTRDY = TRUE ;
            END 
          IF UCB$CURINPUT EQ UCMINPUT"ABORTUCM"  OR 
             UCB$CURINPUT EQ UCMINPUT"ENDCONUCM"
          THEN
            BEGIN                                # SET ABORTED BY TERMI#
            UCB$MESSAGE = UMSG"ABTED";           #NAL OPERATOR FLAG    #
            IF UCB$FILEACT
            THEN
              BEGIN 
              UCB$DSPMSG = DSPABT"OPREQ";        # OPERATOR REQUEST ABT#
              END 
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 8                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$AEIGHT: 
          CHGSIZE (ACN$CB [ACN],UCBSIZE,0);        # INCREASE UCB # 
          IF CHGSIZEREJ 
          THEN
            BEGIN                                # BUFFER SPACE NOT    #
            CHGSIZEREJ = FALSE;                  # AVAILABLE           #
            EVENT (CHAINS"BACKGROUND"); 
            GOTO UCM$AEIGHT;
            END 
          UCB$BUFSIZE = UCBSIZE;                 # UCB$BUFSIZE = 10    #
          UCM$VEJ;
POSTVEJ:  
          IF UCB$VEJERR EQ VEJERR"JOBOK"
          THEN
            BEGIN                                # JOB CARD VERIFIED   #
            INPUT = UCMINPUT"GOODJOBUCM"; 
            END 
          ELSE
            BEGIN 
            IF UCB$VEJERR EQ VEJERR"INPFUL" 
            THEN
              BEGIN                              # INPUT QUEUE FULL    #
              INPUT = UCMINPUT"QFULLUCM"; 
              END 
            ELSE
              BEGIN                              # INVALID JOB CARDS   #
              INPUT = UCMINPUT"BADJOBUCM";
              END 
            END 
          GOTO RESTART; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 9                                                      *
*                                                                      *
************************************************************************
# 
  
UCM$ANINE:  
          UCB$STPEND = TRUE;                     # SET STOP,END FLAG   #
          GOTO UCM$AFOUR;                        # RESUME CARD READING #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 10                                                     *
*     U C M $ A 17                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1ZERO:  
UCM$1SEVEN: 
          TCB$ERRORS = ZERO;
          TEMP$FILEACT = UCB$FILEACT; 
          IF UCB$FILEACT
          THEN
            BEGIN 
            UCM$PURGE;
POSTPURGE:  
            END 
          IF ( UCB$MESSAGE EQ UMSG"ABTED" AND TEMP$FILEACT )
             OR 
             UCB$MESSAGE EQ UMSG"CRERR" 
          THEN
            BEGIN 
            UCM$MSG;
            END 
          ELSE
            BEGIN 
            IF (NOT TEMP$FILEACT) AND 
               UCB$MESSAGE EQ UMSG"ABTED" 
            THEN
              BEGIN 
              UCB$MESSAGE = UMSG"INAPPR"; 
              UCM$MSG;
              END 
            END 
          UCB$MESSAGE = ZERO; 
          IF UCB$BUFFER NQ ZERO 
          THEN
            RETTSB (UCB$BUFFER);
UCM$REDUCE: 
          CHGSIZE (ACN$CB [ACN], DEV$MINSIZE,0);   # REDUCE UCB SIZE #
          UCB$BUFFER = ZERO;
          IF CHGSIZEREJ 
          THEN
            BEGIN                                # BUFFER SPACE NOT    #
            CHGSIZEREJ = FALSE;                  # AVAILABLE           #
            EVENT (CHAINS"BACKGROUND"); 
            GOTO UCM$REDUCE;
            END 
          UCB$BUFSIZE = DEV$MINSIZE;             # UCB$BUFSIZE = 3     #
          IF UCB$CURACTN EQ UCMACT"UCM$A17" 
          THEN
            BEGIN                                # IF UCM IS PROCESSING#
            IF TEMP$NOTRDY
            THEN
              BEGIN 
              UCB$MESSAGE = UMSG"NOTRDY" ;
              UCM$MSG ;      # ISSUE NOT READY MESSAGE                 #
                             # AFTER RECEIVED ABORT NORMAL             #
              TEMP$NOTRDY = FALSE ; 
              END 
            GOTO UCM$1THREE;                     # ACTION 17 THEN DO   #
            END                                  # UCM$1THREE          #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 11                                                     *
*                                                                      *
************************************************************************
# 
  
  
UCM$1ONE: 
# 
          IF USER ABORT, ISSUE ABORT MESSAGE BEFORE DISPOSE INPUT 
          FILE TO INPUT QUEUE FOR ABORTING. 
# 
          IF ( UCB$MESSAGE EQ UMSG"ABTED" AND UCB$FILEACT ) 
             OR UCB$MESSAGE EQ UMSG"CRERR"
          THEN
            BEGIN 
            UCM$MSG ; 
            END 
          IF UCB$FILEACT                       # IF UCM HAS FILE       #
          THEN
            BEGIN 
            UCM$DSP;                           # DISPOSE JOB TO QUEUE  #
            END 
POSTDSP:  
          IF TCB$ACKFLAG
          THEN
            BEGIN                                # SEND   ACKNOWLEDGED #
            UCB$MESSAGE = UMSG"ACKMSG";          # MESSAGE TO THE      #
            UCM$MSG;                             # CONSOLE             #
            END 
          GOTO UCM$REDUCE;                       # REDUCE UCB SIZE     #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 12                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1TWO: 
          RSNCODE = RIJ"BAD";                    # OUTPUT JOB CARD     #
          TEMP1 = ZERO;                          # VERIFIED SM WITH BAD#
          C<0,7>TEMP1 = UCB$FETLFN;              # JOB CARD RESPONSE   #
          B<48,12>TEMP1 = UCB$FETFNT; 
          UCM$SM (IFCJOBN,LIFCJBN,RSNCODE,TEMPX); 
          UCB$DSPMSG = DSPABT"VEJERR";           # JOB/USER CARD ERROR #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 13                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1THREE: 
          IF (NOT TCB$MD4A AND NOT UCB$STPEND)
             OR 
             TCB$AUTOGO 
          THEN
            BEGIN                                # SIMULATE GO COMMAND #
            INPUT = UCMINPUT"GOUCM";
            GOTO RESTART; 
            END 
          IF TCB$MD4A 
          THEN                                   # INFORM CONSOLE      #
            BEGIN                                # DRIVER              #
            TCB$READY = TRUE; 
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 14                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1FOUR:  
          TCB$CRINTR = TRUE;                     # BATCH INTERRUPT     #
          UCB$INTRPT = TRUE;
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 15                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1FIVE:  
          RSNCODE = RIJ"GOOD";                   # OUTPUT IFC/JOB/RC=1 #
          TEMP1 = ZERO; 
          C<0,7>TEMP1 = UCB$FETLFN;              # INSERT JOB NAME     #
          B<48,12>TEMP1 = UCB$FETFNT;            # INSERT JOB FNT      #
          UCM$SM (IFCJOBN,LIFCJBN,RSNCODE,TEMPX);# JOB CARDS OK       # 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 16                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1SIX: 
          TCB$NOTRDY = TRUE;                     # SEND CARD READER NOT#
          UCB$MESSAGE = UMSG"NOTRDY";            # READY MESSAGE       #
          UCM$MSG;
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 18                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1EIGHT: 
          LINK (CHAINS"CON$END",NOEVENT);        # LINK TO CON$END PROC#
          ACN$STATE [ACN] = CONNECTSTATE"END$CONNECT";
          GOTO CALLRTN;                          # RETURN TO PROCESS   #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 19                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$1NINE:  
          TCB$CMDTY = ZERO;                      # IGNORE COMMAND      #
          IF ACN$MODE [ACN] NQ UCMSTATE"UCM$STOP" 
          THEN
            BEGIN 
            GOTO UCM$ASEVEN;                     # ABORT JOB IMMEDIATE #
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 20                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$2ZERO:  
          IF UCB$DSKCODE EQ DSKPARERR 
          THEN
            BEGIN                                # DISK PARITY ERROR   #
            TCB$DISKERR = TRUE; 
            UCB$MESSAGE = UMSG"DSKPAR"; 
            UCB$DSPMSG = DSPABT"DSKPAR";         # DISK PARITY ERROR   #
            END 
          ELSE
            BEGIN 
            IF UCB$DSKCODE EQ DSKFULERR 
            THEN
              BEGIN                              # DISK FULL           #
              TCB$DISKFULL = TRUE;
              UCB$MESSAGE = UMSG"DSKFUL"; 
              UCB$DSPMSG = DSPABT"DSKFUL";       # DISK FULL           #
              END 
            ELSE
              BEGIN                              # FATAL DISK ERROR    #
              UCMPPWHO = "CIO"; 
              MESSAGE (PPERROR,DFLOPT); 
              ABORT;
              END 
            END 
          UCM$MSG;                               # SEND CONSOLE MSG    #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 21                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$2ONE: 
          TCB$CARDERR = TRUE;                    # SEND CARD READER    #
          UCB$MESSAGE = UMSG"CRERR";             # ERROR MSG TO CONSOLE#
          IF UCB$FILEACT                         # UCM HAS FILE        #
          THEN
            BEGIN 
            UCB$DSPMSG = DSPABT"CRERR";          # CARD READER ERROR   #
            END 
          GOTO UCM$ASEVEN;                       # ABORT IMMEDIATELY   #
  
  
# 
************************************************************************
*                                                                      *
*     U C M $ A 22                                                     *
*                                                                      *
************************************************************************
# 
  
UCM$2TWO: 
          UCB$MESSAGE = UMSG"INAPPR"; # SEND INAPPROPRIATE COMMAND MSG.#
          UCM$MSG;          # AND SIMULATE A BATCH INTERRUPT.  THE TIP #
          IF TCB$MD4A       # WILL NOT SEND THE INTERRUPT IF A MODE4A  #
          THEN              # DEVICE WAS NOT STARTED VIA AN IFC/START, #
            BEGIN           # (HENCE THE COMMAND-S INAPPROPRIATENESS). #
            TCB$CRINTR = TRUE;
            END 
          TEST I; 
# 
************************************************************************
*                                                                      *
*    U C M $ A ER                                                      *
*                                                                      *
************************************************************************
# 
UCM$AERROR: 
          STBLINP = UCB$CURINPUT;                # CURRENT INPUT       #
          STBLSTA = UCB$CURSTATE;                # CURRENT STATE       #
          MESSAGE (STBLERR, DFLOPT);
*IF DEF,DEBUG 
          ABORT;
*ENDIF
           ACN$MODE [ACN] = UCB$CURSTATE; 
          END                                    # SOMETHING TO DO     #
        END                                      # MAIN LOOP UCM       #
      END                                        # UCM END             #
      TERM; 
