*DECK DCM 
USETEXT IP$COM
USETEXT MISC$ 
USETEXT QAC$COM 
USETEXT TCH$COM 
USETEXT TSB$COM 
USETEXT ABH$COM 
USETEXT ACN$COM 
USETEXT DCB$COM 
USETEXT GLOBALI 
USETEXT CYBRDEF 
USETEXT SMDEF 
USETEXT SMAPPFC 
USETEXT SMPFC 
USETEXT PRU$COM 
USETEXT QAB$COM 
USETEXT RBF$COM 
USETEXT SM$COM
USETEXT SYS$PAR 
USETEXT TCB$COM 
      PROC DCM; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM                 SEYUNG OH           OCT 25,1979
* 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        DCM IS THE MAIN PROCEDURE FOR THE PROCESSING OF PRINT, PUNCH 
*        AND PLOT FILES. THE BASIC LOOP IS GET A -DCB-, SEE IF THERE ARE
*        ANY FILES TO PROCESS (QAC), -PROCESS- THE FILE -REPEAT- TIMES, 
*        DO THE ACCOUNTING, PURGE THE FILE, RELEASE THE -DCB- AND LOOP. 
* 
*     3. METHOD USED
*        DCM IS A STATE TABLE DRIVEN PROGRAM WHICH RESIDE IN SECONDARY
*        OVERLAY AREA OF RBF. A SMALL PORTION OF DCM WHICH IS CALLED
*        ACKED, RESIDE IN THE PRIMARY OVERLAY AREA AND EXECUTED 
*        PERIODICALLY OR WHEN A SITUATION ARISES. THE MAIN FUNCTION OF
*        ACKED ROUTINE IS TO FIND SOMETHINGS TO DO AND SETS UP FLAGS
*        SOTHAT DCM OVERLAY CAN BE LOADED AND EXECUTED. 
*        ONCE DCM IS LOADED, DCM WILL DETERMINE WHAT ACTION TO BE 
*        TAKEN BY LOOKING UP THE STATE TABLE. CURRENT INPUT ABTAINED
*        FROM ACKED ROUTINE TELLS WHICH ROW AND CURRENT STATE TELLS 
*        WHICH COLUMN OF STATE TABLE. THE FIRST LAYER OF INPUT AND
*        STATE INTERSECTION CONTAINS NEXT STATE AND SECOND LAYER
*        CONTAINS WHICH ACTIONS TO TAKE.
* 
* 
*        INITIALLY, DCM IS IN THE STOP STATE UNTIL TERMINAL OPERATOR
*        TYPES IN A GO COMMAND OR RESTRICTED INTERACTIVE CAPABILITY 
*        FLAG WAS SET ON THE CONNECTION REQUEST SUPERVISORY MESSAGE.
*        THE DCM WILL CHANGE STATE TO IDLE AND SEARCHES SYSTEM"S OUTPUT 
*        QUEUE PERIODICALLY BY CALLING THE PP ROUTINE, QAC. THE OUTPUT
*        QUEUE IS THE COLLECTIVE NAME FOR PRINT, PUNCH, AND PLOT QUEUE. 
*        DCM WILL DECIDE WHICH QUEUE TO SEARCH BY ASSOCIATING DEVICE
*        TYPE LINE PRINTER, CARD PUNCH AND PLOTTER WITH THE QUEUE TYPE
*        PRINT, PUNCH AND PLOT RESPECTIVELY.
*        ONCE THE QUEUE TYPE IS DECIDED, DCM SELECTS OUTPUT FILE BASED
*        ON LOGGED IN CONSOLE FAMILY AND USER NAME, FORMS CODE, TRAIN 
*        TYPE AND HIGHEST QUEUE PRIORITY. 
*        IF QAC FINDS RIGHT OUTPUT FILE, THEN DCM WILL GENERATE BANNER
*        PAGE BY CALLING PP ROUTINE QAP. BANNER PAGES ARE TRANSMITTED 
*        TO THE OUTPUT DEVICE VIA BATCH DATA(OFC/DATA) SUPERVISORY
*        MESSAGES. SOON AS ALL THE BANNER PAGES ARE TRANSMITTED, THE
*        DCM WILL GIVE UP CONTROL OF OUTPUT FILE TO NAM BY TRANSMITTING 
*        A START OUTPUT(OFC/START) SUPERVISORY MESSAGE. WHILE NAM HAS 
*        THE CONTROL OF OUTPUT FILE, OUTPUT IS TRANSMITTED TO THE OUTPUT
*        DEVICE BY PRU INTERFACE DRIVER(PART OF PIP) AND ALL UNUSUAL
*        CONDITIONS ARE REPORTED TO THE DCM. ALL UNUSUAL CONDITIONS ARE 
*        REPORTED TO THE USER VIA UNSOLICITED CONSOLE MESSAGE AND IN
*        THE DEVICE DISPLAY UPON REQUEST. 
*        WHEN ALL THE DATA IS TRANSMITTED, NAM TRANSFERS CONTROL OF 
*        OUTPUT FILE BACK TO THE DCM VIA END OF OUTPUT(OFC/EOO) 
*        SUPERVISORY MESSAGE ALONG WITH ACCOUNTING INFORMATION. THE 
*        ACCOUNTING INFORMATION CONSISTS OF NUMBER OF LINES PRINTED OR
*        CARDS PUNCHED OR PLOT-UNIT(PAGE WIDTH) PLOTTED.
*        PPU ROUTINE QAP WILL BE CALLED TO RECORD ACCOUNTING INFORMATION
*        TO SYSTEM ACCOUNTING DAYFILE. WHEN A QAP RETURNS ACCOUNTING
*        DAYFILE MESSAGE, IT IS TRANSMITTED TO OUTPUT DEVICE IN A BATCH 
*        DATA(OFC/DATA) SUPERVISORY MESSAGE WITH END OF JOB FLAG SET. 
*        SOON AS DCM RECEIVES RESPONSE TO OFC/DATA, OUTPUT FILE IS
*        PURGED AND OUTPUT QUEUE WILL BE SEARCHED AGAIN FOR NEXT FILE.
* 
*     S T A T E   T A B L E 
* 
************************************************************************
** STATE* 1    * 2    * 3    * 4    * 5    * 6    * 7    * 8    * 9    *
*  ***  * IDLE * GO   * GOBAN* GOEOF* WAIT1* WAIT2* WTBAN* WTEOF* STOP *
*INPUT **      *      *      *      *      *      *      *      *      *
************************************************************************
* 1     * 1    * 2    * 3    * 4    * 5    * 2    * 3    * 4    * 1    *
* GO    *      *      *      *      *      *      *      *      *      *
*       * A1   * A6   * A6   * A6   * A30  * A6   * A28  * A34  * A1   *
************************************************************************
* 2     * 9    * 5    * 7    * 4    * 5    * 6    * 7    * 8    * 9    *
* STOP  *      *      *      *      *      *      *      *      *      *
*       * A20  * A3   * A20  * A7   * A20  * A20  * A20  * A20  * A20  *
************************************************************************
* 3     * 1    * 2    * 3    * 4    * 5    * 6    * 7    * 8    * 9    *
* RESUME*      *      *      *      *      *      *      *      *      *
*       * A1   * A2   * A2   * A2   * A20  * A20  * A20  * A20  * A20  *
************************************************************************
* 4 SET * 1    * 2    * 3    * 4    * 5    * 6    * 7    * 8    * 9    *
*   SUP *      *      *      *      *      *      *      *      *      *
*   RES * A1   * A35  * A2   * A2   * A35  * A35  * A20  * A20  * A20  *
************************************************************************
* 5     * 9    * 2    * 3    * 4    * 5    * 2    * 3    * 4    * 9    *
* STOP, *      *      *      *      *      *      *      *      *      *
* END   * A20  * A7   * A7   * A7   * A8   * A7   * A7   * A7   * A27  *
************************************************************************
* 6     * 1    * 10   * 2    * 4    * 10   * 2    * 2    * 8    * 9    *
* SKIP  *      *      *      *      *      *      *      *      *      *
*       * A27  * A11  * A29  * A27  * A0   * A12  * A29  * A27  * A27  *
************************************************************************
* 7     * 1    * 11   * 11   * 4    * 11   * 11   * 11   * 8    * 9    *
* SKIP, *      *      *      *      *      *      *      *      *      *
* END   * A27  * A10  * A10  * A27  * A10  * A10  * A10  * A27  * A27  *
************************************************************************
* 8     * 1    * 10   * 3    * 4    * 10   * 2    * 3    * 8    * 9    *
* REWIND*      *      *      *      *      *      *      *      *      *
*       * A27  * A11  * A19  * A27  * A0   * A12  * A19  * A27  * A27  *
************************************************************************
* 9     * 1    * 12   * 13   * 14   * 12   * 12   * 13   * 14   * 9    *
* ABORT *      *      *      *      *      *      *      *      *      *
*       * A27  * A10  * A10  * A10  * A10  * A10  * A10  * A10  * A27  *
************************************************************************
* 10    * 1    * 15   * 16   * 17   * 15   * 15   * 16   * 17   * 9    *
* RETURN*      *      *      *      *      *      *      *      *      *
*       * A27  * A10  * A10  * A10  * A10  * A10  * A10  * A10  * A27  *
************************************************************************
* 11    *      * 4    *      * 1    * 8    *      *      *      *      *
* END OF* ERR  *      * ERR  *      *      * ERR  * ERR  * ERR  * ERR  *
* OUTPUT*      * A24  *      * A21  * A23  *      *      *      *      *
************************************************************************
* 12    * 1    * 4    * 4    * 4    * 4    * 4    * 4    * 8    * 9    *
* OUTPUT*      *      *      *      *      *      *      *      *      *
* ABORTD* A0   * A26  * A26  * A0   * A26  * A26  * A26  * A0   * A0   *
************************************************************************
* 13    * 1    * 2    * 3    * 4    * 5    * 6    * 7    * 8    * 9    *
* BATCH *      *      *      *      *      *      *      *      *      *
* INTERR* A31  * A31  * A31  * A31  * A31  * A31  * A31  * A31  * A31  *
************************************************************************
* 14    *      * 6    * 7    *      * 6    * 6    * 7    *      *      *
* PM    * ERR  *      *      * ERR  *      *      *      * ERR  * ERR  *
* INTERR*      * A15  * A15  *      * A15  * A15  * A15  *      *      *
************************************************************************
* 15    *      * 12   * 13   *      * 12   * 12   * 13   *      *      *
* FILE  * ERR  *      *      * ERR  *      *      *      * ERR  * ERR  *
* LIMIT *      * A16  * A16  *      * A16  * A16  * A16  *      *      *
************************************************************************
* 16    *      * 6    * 7    * 8    * 6    * 6    *      *      *      *
* NOT   * ERR  *      *      *      *      *      * ERR  * ERR  * ERR  *
* READY *      * A14  * A14  * A14  * A14  * A14  *      *      *      *
************************************************************************
* 17    *      * 6    *      *      * 6    *      *      *      *      *
* DISK  * ERR  *      * ERR  * ERR  *      * ERR  * ERR  * ERR  * ERR  *
* ERROR *      * A17  *      *      * A17  *      *      *      *      *
************************************************************************
* 18    *      * 2    *      * 4    * 6    * 6    *      * 8    *      *
* TEMP  * ERR  *      * ERR  *      *      *      * ERR  *      * ERR  *
* STOP  *      * A0   *      * A0   * A0   * A0   *      * A0   *      *
************************************************************************
* 19    *      * 2    * 3    * 1    * 5    * 6    * 7    *      *      *
* BATCH *ERR   *      *      *      *      *      *      * ERR  * ERR  *
* DATA  *      * A0   * A5   * A21  * A0   * A0   * A0   *      *      *
************************************************************************
* 20    * 3    *      *      *      *      *      *      *      *      *
* FILE  *      * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *
* FOUND * A4   *      *      *      *      *      *      *      *      *
************************************************************************
* 21    *      *      * 2    *      *      *      *      *      *      *
* BANNER* ERR  * ERR  *      * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *
* COMPLE*      *      * A29  *      *      *      *      *      *      *
************************************************************************
* 22    * 9    * 15   * 16   * 4    * 15   * 15   * 16   * 17   * 9    *
* ENDCON*      *      *      *      *      *      *      *      *      *
*       * A0   * A10  * A10  * A0   * A10  * A10  * A10  * A10  * A0   *
************************************************************************
* 23    * 0    * 0    * 0    * 0    * 0    * 0    * 0    * 0    * 0    *
* CONCB *      *      *      *      *      *      *      *      *      *
*       * A9   * A9   * A9   * A9   * A9   * A9   * A9   * A9   * A9   *
************************************************************************
* 24    *      * 15   * 16   * 17   * 15   * 15   * 16   * 17   *      *
* DCP   * ERR  *      *      *      *      *      *      *      * ERR  *
* NLOAD *      * A36  * A36  * A36  * A36  * A36  * A36  * A36  *      *
************************************************************************
  
* 
* 
* 
  
************************************************************************
** STATE* 10   * 11   * 12   * 13   * 14   * 15   * 16   * 17   *      *
*  ***  * SKIP * SKIP,* ABORT* ABORT* ABORT*RETURN*RETURN*RETURN*      *
*INPUT  *      * END  *      * BAN  * EOF  *      * BAN  * EOF  *      *
************************************************************************
* 1     *      *      *      *      *      *      *      *      *      *
* GO    *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 2     *      *      *      *      *      *      *      *      *      *
* STOP  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 3     *      *      *      *      *      *      *      *      *      *
* RESUME*   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 4 SET *      *      *      *      *      *      *      *      *      *
*   SUP *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*   RES *      *      *      *      *      *      *      *      *      *
************************************************************************
* 5     *      *      *      *      *      *      *      *      *      *
* STOP, *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
* END   *      *      *      *      *      *      *      *      *      *
************************************************************************
* 6     *      *      *      *      *      *      *      *      *      *
* SKIP  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 7     *      *      *      *      *      *      *      *      *      *
* SKIP, *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
* END   *      *      *      *      *      *      *      *      *      *
************************************************************************
* 8     *      *      *      *      *      *      *      *      *      *
* REWIND*   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 9     *      *      *      *      *      *      *      *      *      *
* ABORT *   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 10    *      *      *      *      *      *      *      *      *      *
* RETURN*   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 11    * 4    * 11   * 12   *      * 14   * 15   *      * 17   *      *
* END OF*      *      *      * ERR  *      *      * ERR  *      *      *
* OUTPUT* A24  * A0   * A0   *      * A0   * A0   *      * A0   *      *
************************************************************************
* 12    *      * 4    * 4    * 4    * 4    * 4    * 4    * 4    *      *
* OUTPUT* ERR  *      *      *      *      *      *      *      *      *
* ABORTD*      * A24  * A25  * A25  * A33  * A26  * A26  * A32  *      *
************************************************************************
* 13    * 10   * 11   * 12   * 13   * 14   * 15   * 16   * 17   *      *
* BATCH *      *      *      *      *      *      *      *      *      *
* INTERR* A31  * A31  * A31  * A31  * A31  * A31  * A31  * A31  *      *
************************************************************************
* 14    * 2    * 11   * 12   * 13   *      * 15   * 16   *      *      *
* PM    *      *      *      *      * ERR  *      *      * ERR  *      *
* INTERR* A12  * A18  * A18  * A18  *      * A13  * A18  *      *      *
************************************************************************
* 15    * 12   * 12   * 12   * 13   *      * 12   * 16   *      *      *
* FILE  *      *      *      *      * ERR  *      *      * ERR  *      *
* LIMIT * A16  * A22  * A13  * A13  *      * A13  * A13  *      *      *
************************************************************************
* 16    *      * 11   * 12   * 13   * 14   * 15   * 16   * 17   *      *
* NOT   * ERR  *      *      *      *      *      *      *      *      *
* READY *      * A13  * A13  * A13  * A13  * A13  * A13  * A13  *      *
************************************************************************
* 17    * 2    * 11   * 12   *      *      * 15   *      *      *      *
* DISK  *      *      *      * ERR  * ERR  *      * ERR  * ERR  *      *
* ERROR * A12  * A13  * A13  *      *      * A13  *      *      *      *
************************************************************************
* 18    * 2    * 11   * 12   *      *      * 15   *      *      *      *
* TEMP  *      *      *      * ERR  * ERR  *      * ERR  * ERR  *      *
* STOP  * A12  * A0   * A0   *      *      * A0   *      *      *      *
************************************************************************
* 19    * 10   * 11   * 12   * 13   * 14   * 15   * 16   *      *      *
* BATCH *      *      *      *      *      *      *      * ERR  *      *
* DATA  * A0   * A0   * A0   * A0   * A0   * A0   * A0   *      *      *
************************************************************************
* 20    *      *      *      *      *      *      *      *      *      *
* FILE  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *
* FOUND *      *      *      *      *      *      *      *      *      *
************************************************************************
* 21    *      *      *      *      *      *      *      *      *      *
* BANNER* ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *
* COMPLE*      *      *      *      *      *      *      *      *      *
************************************************************************
* 22    *      *      *      *      *      *      *      *      *      *
* ENDCON*   X  *   X  *   X  *   X  *   X  *   X  *   X  *   X  *      *
*       *      *      *      *      *      *      *      *      *      *
************************************************************************
* 23    * 0    * 0    * 0    * 0    * 0    * 0    * 0    * 0    *      *
* CONCB *      *      *      *      *      *      *      *      *      *
*       * A9   * A9   * A9   * A9   * A9   * A9   * A9   * A9   *      *
************************************************************************
* 24    *      *      *      *      *      *      *      *      *      *
* DCP   * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  * ERR  *      *
* NLOAD *      *      *      *      *      *      *      *      *      *
************************************************************************
**    ********
*     *      *
*     *   X  *  CANNOT PROCESS INPUT
*     *      *  DO ACTION A$30, REMAIN IN THE SAME STATE. 
**    ********
* 
*     D C M    S T A T E
* 
* 
*     0        NO STATE, CONNECTION NO LONGGER LINK TO THE DCM
* 
* 
*     IDLE    RBF IS SEARCHING OUTPUT QUEUE FOR A FILE. 
*             DEVICE STATE WILL CHANGE TO "GOBAN" WHEN OUTPUT FILE IS 
*             LOCATED, OTHERWISE DEVICE WILL STAY IN "IDLE" STATE AND 
*             SEARCH OUTPUT QUEUE PERIODICALLY. 
* 
* 
*     GO      COMPLETED BANNER PAGE TRANSMISSION AND NAM IS TRANSMITTING
*             OUTPUT DATA UNLESS DATA TRANSMISSION IS INTERRUPTED BY
*             BATCH INTERRUPT.
* 
* 
*     GOBAN   RBF IS TRANSMITTING BANNER PAGES. 
*             DEVICE STATE WILL CHANGE TO "GO" WHEN ALL THE BANNER
*             PAGES WERE TRANSMITTED AND OFC/START SM WAS SENT
* 
* 
*     GOEOF   RBF IS WAITING FOR ACCOUNTING DAYFILE MESSAGE PRINTED 
*             RESPONSE FROM NAM.
*             OFC/EOO OR OFC/DATA SM WILL CHANGE DEVICE STATE TO "IDLE" 
* 
* 
*     WAIT1   DEVICE IS WAITING FOR OFC/STP RESPONSE FROM NAM.
*             DEVICE STATE WILL CHANGE TO "WAIT2" WHEN NAM RESPONDS 
*             TO THE COMMAND. 
* 
* 
*     WTBAN   BANNER PAGE TRANSMISSION IS STOPPED.
* 
* 
*     WTEOF   RBF CANNOT PRINT OR DID NOT TRANSMIT ACCOUNTING DAYFILE 
*             MESSAGE DUE TO PREEXISTING CONDITIONS.
* 
* 
*     STOP    DO NOT SEARCH OUTPUT QUEUE FOR A NEW FILE UNTIL TERMINAL
*             OPERATOR TYPE IN GO COMMAND.
* 
* 
*     SKIP    RBF IS SKIPPING OUTPUT FILE TO CURRENT PRU POSITION PLUS
*             SKIP COMMAND VALUE
* 
* 
*     SKPEND  RBF IS SKIPPING TO END OF FILE POSITION 
* 
* 
*     ABORT   RBF IS ABORTING THE CURRENT OUTPUT FILE.
*             WHEN ABORT PROCESSING HAS BEEN COMPLETED, DEVICE STATE
*             WILL GO TO "GOEOF"
* 
* 
*     ABTBAN  RBF IS ABORTING CURRENT OUTPUT FILE WHILE TRANSMITTING
*             BANNER PAGE.
* 
* 
*     ABTEOF  RBF IS ABORTING CURRENT OUTPUT FILE WHILE TRANSMITTING
*             ACCOUNT DAYFILE MESSAGE 
* 
* 
*     RETURN  RBF IS RETURNING CURRENT OUTPUT FILE BACK TO THE OUTPUT 
*             QUEUE 
* 
* 
*     RETBAN  RBF IS RETURNING CURRENT OUTPUT FILE BACK TO THE OUTPUT 
*             QUEUE WHILE TRANSMITTING BANNER PAGE. 
* 
* 
*     RETEOF  RBF IS RETURNING CURRENT OUTPUT FILE BACK TO THE OUTPUT 
*             QUEUE WHILE TRANSMITTING ACCOUNT DAYFILE
* 
* 
  
* 
*     D C M   A C T I O N 
* 
************************************************************************
* 
*     A0      DO NOTHING
* 
* 
*     A1      SEARCH OUTPUT QUEUE 
* 
* 
*     A3      IF INTERRUPTED
*             THEN  CURRENT STATE IS WAIT2. 
*             ELSE  SEND TEMPORARY STOP SM(OFC/STP) 
* 
* 
*     A2      IF INTERRUPTED
*             THEN  SEND RESTART DEVICE SM(OFC/RSTRT) 
* 
* 
*     A4      SEND SET DEVICE SM (SET/DEV)
*             IF BANNER FLAG SET
*             THEN  SEND SET FILE SM(SET/FILE) FOR BANNER PAGE
*                   GENERATE BANNER PAGE
* 
* 
*     A5      GENERATE MORE BANNER BLOCKS 
* 
* 
*     A6      CLEAR STOP,END FLAG 
              DO A7 
* 
* 
*     A7      IF DEVICE STOPPED 
*             THEN  SEND RESTART DEVICE SM(OFC/RSTRT) 
*             ELSE  SEND RESUME OUTPUT SM(OFC/RSM)
*             SET STOP,END FLAG 
* 
* 
*     A8      SET STOP,END FLAG 
* 
* 
*     A9      EXIT FROM DCM 
*             LINK TO CON$END MODULE
* 
* 
*     A10     SEND ABORT OUTPUT SM(OFC/ABORT) 
* 
* 
*     A11     IF INTERRUPTED
*             THEN  SIMULATE TEMPORARY STOP 
*             ELSE  SEND TEMPORARY STOP OUTPUT SM(OFC/STP)
* 
* 
*     A12     ADD SKIP VALUE TO THE CURRENT PRU POSITION
*             IF DEVICE STOPPED 
*             THEN  RESTART DEVICE SM(OFC/RSTRT)
*             ELSE  RESUME OUTPUT SM(OFC/RSM) 
* 
* 
*     A13     CLEAR DEVICE STOPPED FLAG 
* 
* 
*     A14     OUTPUT "DEVICE NOTREADY" TO CONSOLE 
* 
* 
*     A15     PROCESS PM INTERRUPT
* 
* 
*     A16     SET FILE LIMIT EXCEEDED FLAG
*             SEND ABORT OUTPUT SM(OFC/ABORT) 
* 
* 
*     A17     OUTPUT DISK ERROR MESSAGE TO CONSOLE
* 
* 
*     A18     CLEAR PM INTERRUPT
* 
* 
*     A19     SET FILE FOUND FLAG 
* 
* 
*     A20     SET CANNOT RESUME BATCH ACTIVITY FLAG 
* 
* 
*     A21     IF REPEAT COUNT IS GREATER THAN EQUAL TO ZERO 
*             THEN  IF RETURN BIT SET OR IDLE SHUT DOWN 
*                   THEN  DISPOSE OUTPUT TO QUEUE 
*                   ELSE  GO TO A4
*             ELSE  PURGE OUTPUT FILE 
*             IF STOP,END FLAG
*             THEN CURRENT STATE = STOP 
* 
* 
*     A22     SET FILE LIMIT EXCEEDED FLAG
* 
* 
*     A23     REPEAT = REPEAT - 1 
*             DO ACCOUNTING 
* 
* 
      A24     REPEAT = REPEAT - 1 
*             DO ACCOUNTING 
*             NETPUT ACCOUNTING MESSAGE 
* 
* 
*     A25     REPEAT = -1 
*             DO ACCOUNTING 
*             IF LIMIT EXCEEDED 
*             THEN  OUTPUT LIMIT EXCEEDED MESSAGE 
*             ELSE  OUTPUT ABORTED BY TERMINAL OPERATOR MESSAGE 
* 
* 
*     A26     REPEAT = ZERO 
*             SET RETURN FLAG 
*             OUTPUT NULL BLOCK WITH EOJ FLAG SET 
* 
* 
*     A27     OUTPUT INAPPROPRIATE COMMAND MESSAGE
* 
* 
*     A28     DO A2 
*             DO A4 
* 
* 
*     A29     SEND SET FILE SM(SET/FILE) FOR OUTPUT FILE
*             SEND START OUTPUT SM(OFC/START) 
* 
* 
*     A30     DO NOT PROCESS INPUT
*             WAIT 2 SECOND 
* 
* 
*     A31     SET BATCH INTERRUPT FLAG
* 
* 
*     A32     SET RETURN FLAG 
*             OUTPUT BATCH DATA SM(OFC/DATA) WITH EOJ FLAG SET
* 
* 
*     A33     OUTPUT BATCH DATA SM(OFC/DATA) WITH EOJ FLAG SET
* 
* 
*     A34     OUTPUT LAST BLOCK 
*             DO A6 
* 
* 
*     A35     CHANGE FORMAT EFFECTOR AND RESUME OUTPUT IF CURRENT 
*             STATE IS GO 
* 
* 
*     A36     PROCESS DEVICE CONFIGURATION PROCEDURE NOT LOADABLE 
* 
* 
************************************************************************
  
  
* 
*     EXAMPLE OF OUTPUT PROCESSING
* 
* 
*STEP CURRENT STATE     INPUT               NEXT STATE     ACTION 
* 
* 1   STOP              GO                  IDLE           A1 
* 2   IDLE              FINE FOUND          GOBAN          A4 
* 3   GOBAN             OFC/DATA            GOBAN          A5 
* 4   GOBAN             BANNER COMPLETED    GO             A29
* 5   GO                OFC/END             GOEOF          A24
* 6   GOEOF             OFC/END             IDLE           A21
* 
* 
*     4. ENTRY PARAMETERS 
*        TCB
* 
*     5. EXIT PARAMETERS
*        NONE 
* 
*     6. COMDECKS CALLED
*        TSBMDEFS 
*        TSBMBASE 
*        RBF$COM
*        ABH$COM
*        QAB$COM
*        SM$COM 
*        PRU$COM
*        DCB$COM
*        TCB$COM
* 
*     7. ROUTINES CALLED
*        ACKED               WAIT FOR SOMETHING TO DO 
*        BUFINFO             FREEZE BUFFER SPACE
*        CHGSIZE             CHANGE BUFFER SIZE 
*        CIODONE             WAIT FOR PP TO COMPLETE THE REQUEST
*        CONSOLE             CHAIN CONSOLE MESSAGE TO TCB 
*        DINPTYPE            CHECK FOR DCM INPUT TYPE 
*        DONE                WAIT FOR QCM TO COMPLETE 
*        EVENT               LINK TO EVENT PROCESSOR
*        GETBUF              GET BUFFER SPACE 
*        LINK                LINK TO NON-EVENT PROCESSOR
*        MESSAGE             WRITE DAYFILE MESSAGE
*        MOVEOK              MAKE BUFFER SPACE MOVEABLE 
*        NETPUT              OUTPUTS NETWORK BLOCKS TO NAM
*        QCMCALL             LINK QAC PARAMETER BLOCKS TO QCB 
*        RETTSB              RELEASE BUFFER SPACE 
*        SETACN              SET BASED ARRAY POINTERS TO
*        SYSCALL             MAKE SYSTEM REQUEST
*        XCDD                CONVERT INTEGER TO DECIMAL DISPLAY 
* 
*     8. CONSOLE MESSAGES 
*        NOT READY
*        INAPPROPRIATE COMMAND
*        DISK PARITY ERROR JOB =  XXXXXXX 
*        PLN LIMIT EXCEEDED 
* 
 #
*ENDIF
      CONTROL EJECT;
# 
  M I S C   C O N S T A N T S 
# 
      DEF CIOLONGSKIP # O"777777 000000" #; 
      DEF CIOREQUEST # "CIO" #; 
      DEF CIORETURN  # O"070" #;
      DEF CIOSKIPEI  # O"74 0 240"#;
      DEF CIOREWIND # O"050" #; 
      DEF DSPREQUEST # "DSP" #; 
      DEF NUMBANNERS # 2 #;                # NUMBER OF BANNERS TO PRINT#
      DEF QAPACCOUNT # O"530" #;           #QAP ACCOUNT - COMPLETE BIT #
      DEF QAPBANNER  # O"500" #;           #QAP PRINT BANNER - COMP BIT#
      DEF QAPHEADER  # O"510" #;           #QAP PUNCH HEADER - COMP BIT#
      DEF QAPREQUEST # "QAP" #; 
      DEF LOW$PRIOR  #100#;   #DEFAULT OUTPUT QUEUE PRIORITY# 
# 
  X R E F S 
# 
#     DEBUG CODE.                                                      #
*IF,DEF,DEBUG 
      XREF PROC ABORT;
*ENDIF
#     END OF DEBUG CODE.                                               #
      XREF PROC ACKED;
      XREF FUNC BUFINFO;
      XREF LABEL CALLRTN; 
      XREF PROC CHGSIZE;
      XREF PROC CIODONE;
      XREF PROC CONSOLE;
      XREF FUNC DINPTYPE U;                      # GET INPUT FOR DCM   #
      XREF PROC MESSAGE;
      XREF PROC DONE; 
      XREF PROC EVENT;
      XREF PROC RETTSB; 
      XREF FUNC GETBUF; 
      XREF PROC LINK; 
      XREF PROC MOVEOK; 
      XREF PROC NETPUT; 
      XREF PROC QCMCALL;
      XREF FUNC XCDD C(10);  # CONVERT INTEGER TO DECIMAL DISPLAY      #
      XREF PROC SETUPACN; 
      XREF PROC SYSCALL;
# 
  I T E M S AND A R R A Y S 
# 
      BASED ARRAY ACCT [1:1] S(1);         #-QAP- ACCOUNTING BLOCK     #
        ITEM
            ACT$WORD0        U (0), 
            ACT$DT           U (0,12,12),  #DT (PR, PU, PL ETC.)       #
            ACT$COUNT        U (0,36,24),  #UNIT RECORD COUNT          #
            ACT$TERMNAME     C (1,0,7),    #TERMINAL NAME TO BE CHARGED#
            ACT$WORD1        U (1); 
# # 
# # 
# # 
         #THE FOLLOWING ARRAY PARALLELS -DEVICETYPE-. IT HAS SYMBOLS   #
         #FOR DCM MESSAGES, QAC CALLS, QAP CALLS ETC.                  #
      ARRAY DT$SYMBOLS [0:4] S(1);
        ITEM
            DT$DT            C (0,0,3) = ["1  ", "1CR", "1LP", "1CP", 
                                          "1PL"], 
            DT$QAPDT         U (0,18,6) = [0, 2, 0, 1, 3],
      DT$QACDT               U (0,24,6) = [0, QAC$INQUEUE, QAC$PRQUEUE, 
                                          QAC$PUQUEUE, QAC$SPQUEUE],
            DT$DBREQ         U (0,30,6) = [0, 0, 0, O"05", O"35"],
            DT$DIVMASK       U (0,36,6) = [0, 0, O"01", O"02", O"04"],
            DT$NUMBAN        U (0,42,3) = [0, 0, NUMBANNERS, 1, 0] ,
            DT$BANREQ        U (0,45,9) = [0, 0, QAPBANNER, QAPHEADER,
                                           0],
            DT$WORD0         U (0); 
# # 
# 
      DCM ACTION STATUS 
# 
      STATUS DCMACT DCM$A0, 
                    DCM$A1, 
                    DCM$A2, 
                    DCM$A3, 
                    DCM$A4, 
                    DCM$A5, 
                    DCM$A6, 
                    DCM$A7, 
                    DCM$A8, 
                    DCM$A9, 
                    DCM$A10,
                    DCM$A11,
                    DCM$A12,
                    DCM$A13,
                    DCM$A14,
                    DCM$A15,
                    DCM$A16,
                    DCM$A17,
                    DCM$A18,
                    DCM$A19,
                    DCM$A20,
                    DCM$A21,
                    DCM$A22,
                    DCM$A23,
                    DCM$A24,
                    DCM$A25,
                    DCM$A26,
                    DCM$A27,
                    DCM$A28,
                    DCM$A29,
                    DCM$A30,
                    DCM$A31,
                    DCM$A32,
                    DCM$A33,
                    DCM$A34,
                    DCM$A35,
                    DCM$A36,
                    DCM$AER;
      SWITCH DCM$ACTION  : DCMACT 
             DCM$AZERO   : DCM$A0,
             DCM$AONE    : DCM$A1,
             DCM$ATWO    : DCM$A2,
             DCM$ATHREE  : DCM$A3,
             DCM$AFOUR   : DCM$A4,
             DCM$AFIVE   : DCM$A5,
             DCM$ASIX    : DCM$A6,
             DCM$ASEVEN  : DCM$A7,
             DCM$AEIGHT  : DCM$A8,
             DCM$ANINE   : DCM$A9,
             DCM$1ZERO   : DCM$A10, 
             DCM$1ONE    : DCM$A11, 
             DCM$1TWO    : DCM$A12, 
             DCM$1THREE  : DCM$A13, 
             DCM$1FOUR   : DCM$A14, 
             DCM$1FIVE   : DCM$A15, 
             DCM$1SIX    : DCM$A16, 
             DCM$1SEVEN  : DCM$A17, 
             DCM$1EIGHT  : DCM$A18, 
             DCM$1NINE   : DCM$A19, 
             DCM$2ZERO   : DCM$A20, 
             DCM$2ONE    : DCM$A21, 
             DCM$2TWO    : DCM$A22, 
             DCM$2THREE  : DCM$A23, 
             DCM$2FOUR   : DCM$A24, 
             DCM$2FIVE   : DCM$A25, 
             DCM$2SIX    : DCM$A26, 
             DCM$2SEVEN  : DCM$A27, 
             DCM$2EIGHT  : DCM$A28, 
             DCM$2NINE   : DCM$A29, 
             DCM$3ZERO   : DCM$A30, 
             DCM$3ONE    : DCM$A31, 
             DCM$3TWO    : DCM$A32, 
             DCM$3THREE  : DCM$A33, 
             DCM$3FOUR   : DCM$A34, 
             DCM$3FIVE   : DCM$A35, 
             DCM$3SIX    : DCM$A36, 
             DCM$AERROR  : DCM$AER; 
  
  
      ARRAY DCM$STATE [1:24] S(4);
        BEGIN 
        ITEM DCB$SIDLE       S:DCMSTATE (0,0,6) = 
                             [S"DCM$IDLE",S"DCM$STOP",2(S"DCM$IDLE"), 
                              S"DCM$STOP",5(S"DCM$IDLE"), 
                              S"DCM$ERROR",2(S"DCM$IDLE"),
                              6(S"DCM$ERROR"),
                              S"DCM$GOBAN",S"DCM$ERROR",S"DCM$STOP",
                              S"NULL",S"DCM$ERROR"],
             DCB$SGO         S:DCMSTATE (0,6,6) = 
                             [S"DCM$GO",S"DCM$WAIT1",3(S"DCM$GO"),
                              S"DCM$SKIP",S"DCM$SKPEND",S"DCM$SKIP",
                              S"DCM$ABORT", 
                              S"DCM$RETURN",S"DCM$GOEOF",S"DCM$GOEOF",
                              S"DCM$GO",S"DCM$WAIT2",S"DCM$ABORT",
                              2(S"DCM$WAIT2"),2(S"DCM$GO"), 
                              2(S"DCM$ERROR"),S"DCM$RETURN",S"NULL",
                              S"DCM$RETURN"], 
             DCB$SGOBAN      S:DCMSTATE (0,12,6) =
                             [S"DCM$GOBAN",S"DCM$WTBAN",3(S"DCM$GOBAN"),
                              S"DCM$GO",S"DCM$SKPEND",S"DCM$GOBAN", 
                              S"DCM$ABTBAN",S"DCM$RETBAN",S"DCM$ERROR", 
                              S"DCM$GOEOF", 
                              S"DCM$GOBAN",S"DCM$WTBAN",S"DCM$ABTBAN",
                              S"DCM$WTBAN",2(S"DCM$ERROR"),S"DCM$GOBAN",
                              S"DCM$ERROR",S"DCM$GO",S"DCM$RETBAN", 
                              S"NULL",S"DCM$RETBAN"], 
             DCB$SGOEOF      S:DCMSTATE (0,18,6) =
                             [8(S"DCM$GOEOF"),S"DCM$ABTEOF",
                              S"DCM$RETEOF",S"DCM$IDLE",S"DCM$GOEOF", 
                              S"DCM$GOEOF",S"DCM$ERROR",S"DCM$IDLE",
                              S"DCM$WTEOF", 
                              S"DCM$ERROR",S"DCM$GOEOF",S"DCM$IDLE",
                              2(S"DCM$ERROR"),S"DCM$GOEOF",S"NULL", 
                              S"DCM$RETEOF"], 
             DCB$SWAIT1      S:DCMSTATE (0,24,6) =
                             [5(S"DCM$WAIT1"),S"DCM$SKIP",S"DCM$SKPEND",
                               S"DCM$SKIP", 
                              S"DCM$ABORT",S"DCM$RETURN",S"DCM$WTEOF",
                              S"DCM$GOEOF",S"DCM$WAIT1",S"DCM$WAIT2", 
                              S"DCM$ABORT",3(S"DCM$WAIT2"),S"DCM$WAIT1",
                              2(S"DCM$ERROR"),S"DCM$RETURN",S"NULL",
                              S"DCM$RETURN"], 
             DCB$SWAIT2      S:DCMSTATE (0,30,6) =
                             [S"DCM$GO",3(S"DCM$WAIT2"),2(S"DCM$GO"), 
                              S"DCM$SKPEND",S"DCM$GO",S"DCM$ABORT", 
                              S"DCM$RETURN",S"DCM$ERROR",S"DCM$GOEOF",
                              2(S"DCM$WAIT2"),S"DCM$ABORT",S"DCM$WAIT2",
                              S"DCM$ERROR",S"DCM$WAIT2",S"DCM$WAIT2", 
                              2(S"DCM$ERROR"),S"DCM$RETURN",S"NULL",
                              S"DCM$RETURN"], 
             DCB$SWTBAN      S:DCMSTATE (0,36,6) =
                             [S"DCM$GOBAN",3(S"DCM$WTBAN"),S"DCM$GOBAN",
                              S"DCM$GO",S"DCM$SKPEND",S"DCM$GOBAN", 
                              S"DCM$ABTBAN",S"DCM$RETBAN",
                              S"DCM$ERROR",S"DCM$GOEOF",2(S"DCM$WTBAN"),
                              S"DCM$ABTBAN",3(S"DCM$ERROR"),
                              S"DCM$WTBAN",2(S"DCM$ERROR"), 
                              S"DCM$RETBAN",S"NULL",S"DCM$RETBAN"], 
             DCB$SWTEOF      S:DCMSTATE (0,42,6) =
                             [S"DCM$GOEOF",3(S"DCM$WTEOF"),S"DCM$GOEOF",
                              3(S"DCM$WTEOF"),S"DCM$ABTEOF",
                              S"DCM$RETEOF",S"DCM$ERROR",S"DCM$WTEOF",
                              S"DCM$WTEOF",4(S"DCM$ERROR"),S"DCM$WTEOF",
                              3(S"DCM$ERROR"),
                              S"DCM$RETEOF",S"NULL",S"DCM$RETEOF"], 
             DCB$SSTOP       S:DCMSTATE (0,48,6) =
                             [S"DCM$IDLE",9(S"DCM$STOP"),S"DCM$ERROR",
                              2(S"DCM$STOP"),8(S"DCM$ERROR"), 
                              S"DCM$STOP",S"NULL",S"DCM$ERROR"],
             DCB$SSKIP       S:DCMSTATE (0,54,6) =
                             [10(S"DCM$SKIP"),S"DCM$GOEOF",S"DCM$ERROR",
                              S"DCM$SKIP",S"DCM$GO",S"DCM$ABORT", 
                              S"DCM$ERROR",2(S"DCM$GO"),S"DCM$SKIP",
                              2(S"DCM$ERROR"),
                              S"DCM$SKIP",S"NULL",S"DCM$ERROR"];
        ITEM DCB$NEXTST1     U (0,0,60);
        ITEM DCB$AIDLE       S:DCMACT (1,0,6) = 
                             [S"DCM$A1",S"DCM$A20",2(S"DCM$A1"),
                              S"DCM$A20",5(S"DCM$A27"), 
                              S"DCM$AER",S"DCM$A0", 
                              S"DCM$A31", 
                              6(S"DCM$AER"),S"DCM$A4",S"DCM$AER", 
                              S"DCM$A0",S"DCM$A9",S"DCM$AER"],
             DCB$AGO         S:DCMACT (1,6,6) = 
                             [S"DCM$A6",S"DCM$A3",S"DCM$A2",S"DCM$A35", 
                              S"DCM$A7",S"DCM$A11",S"DCM$A10",
                              S"DCM$A11",2(S"DCM$A10"),S"DCM$A24",
                              S"DCM$A26",S"DCM$A31",S"DCM$A15", 
                              S"DCM$A16",S"DCM$A14",S"DCM$A17", 
                              2(S"DCM$A0"),2(S"DCM$AER"),S"DCM$A10",
                              S"DCM$A9",S"DCM$A36"],
             DCB$AGOBAN      S:DCMACT (1,12,6) =
                             [S"DCM$A6",S"DCM$A20",2(S"DCM$A2"),
                              S"DCM$A7",S"DCM$A29",S"DCM$A10",S"DCM$A19"
                             ,2(S"DCM$A10"),S"DCM$AER",S"DCM$A26",
                              S"DCM$A31", 
                              S"DCM$A15",S"DCM$A16",S"DCM$A14", 
                              2(S"DCM$AER"),S"DCM$A5",S"DCM$AER", 
                              S"DCM$A29",S"DCM$A10",S"DCM$A9",
                              S"DCM$A36"],
             DCB$AGOEOF      S:DCMACT (1,18,6) =
                             [S"DCM$A6",S"DCM$A7",2(S"DCM$A2"), 
                              S"DCM$A7",
                              3(S"DCM$A27"),2(S"DCM$A10"),S"DCM$A21", 
                              S"DCM$A0",S"DCM$A31",S"DCM$AER",
                              S"DCM$A21", 
                              S"DCM$A14",S"DCM$AER",S"DCM$A0",
                              S"DCM$A21", 
                              2(S"DCM$AER"),S"DCM$A0",S"DCM$A9",
                              S"DCM$A36"],
             DCB$AWAIT1      S:DCMACT (1,24,6) =
                             [S"DCM$A30",2(S"DCM$A20"), 
                              S"DCM$A35", 
                              S"DCM$A8",S"DCM$A0",S"DCM$A10",S"DCM$A0", 
                              2(S"DCM$A10"),S"DCM$A23",S"DCM$A26",
                              S"DCM$A31",S"DCM$A15",S"DCM$A16", 
                              S"DCM$A14",S"DCM$A17",2(S"DCM$A0"), 
                              2(S"DCM$AER"),S"DCM$A10",S"DCM$A9", 
                              S"DCM$A36"],
             DCB$AWAIT2      S:DCMACT (1,30,6) =
                             [S"DCM$A6",2(S"DCM$A20"),
                              S"DCM$A35", 
                              S"DCM$A7",S"DCM$A12",S"DCM$A10",
                              S"DCM$A12",S"DCM$A10",S"DCM$A10", 
                              S"DCM$AER",S"DCM$A26",S"DCM$A31", 
                              S"DCM$A15", 
                              S"DCM$A16",S"DCM$A14",S"DCM$AER", 
                              2(S"DCM$A0"),2(S"DCM$AER"),S"DCM$A10",
                              S"DCM$A9",S"DCM$A36"],
             DCB$AWTBAN      S:DCMACT (1,36,6) =
                             [S"DCM$A28",3(S"DCM$A20"), 
                              S"DCM$A7",S"DCM$A29",S"DCM$A10",
                              S"DCM$A19",2(S"DCM$A10"),S"DCM$AER",
                              S"DCM$A26", 
                              S"DCM$A31",S"DCM$A15",S"DCM$A16", 
                              3(S"DCM$AER"),S"DCM$A0",2(S"DCM$AER"),
                              S"DCM$A10",S"DCM$A9",S"DCM$A36"], 
             DCB$AWTEOF      S:DCMACT (1,42,6) =
                             [S"DCM$A34",3(S"DCM$A20"), 
                              S"DCM$A7",3(S"DCM$A27"),2(S"DCM$A10"),
                              S"DCM$AER",S"DCM$A0",S"DCM$A31",
                              4(S"DCM$AER"),S"DCM$A0",3(S"DCM$AER"),
                              S"DCM$A10",S"DCM$A9",S"DCM$A36"], 
             DCB$ASTOP       S:DCMACT (1,48,6) =
                             [S"DCM$A1",3(S"DCM$A20"),
                              6(S"DCM$A27"),S"DCM$AER",S"DCM$A0", 
                              S"DCM$A31",8(S"DCM$AER"),S"DCM$A0", 
                              S"DCM$A9",S"DCM$AER"],
             DCB$ASKIP       S:DCMACT (1,54,6) =
                             [10(S"DCM$A30"),S"DCM$A24",S"DCM$AER", 
                              S"DCM$A31",S"DCM$A12",S"DCM$A16", 
                              S"DCM$AER",S"DCM$A12",S"DCM$A12", 
                              S"DCM$A0",
                              2(S"DCM$AER"),S"DCM$A30",S"DCM$A9", 
                              S"DCM$AER"];
        ITEM DCB$ACTION1     U (1,0,60);
        ITEM DCB$SSKPEND     S:DCMSTATE (2,0,6) = 
                             [10(S"DCM$SKPEND"),S"DCM$SKPEND",
                              S"DCM$GOEOF",S"DCM$SKPEND",S"DCM$GO", 
                              S"DCM$ABORT",S"DCM$ERROR",2(S"DCM$GO"), 
                              S"DCM$SKPEND",
                              2(S"DCM$ERROR"),S"DCM$SKPEND",S"NULL",
                              S"DCM$ERROR"],
             DCB$SABORT      S:DCMSTATE (2,6,6) = 
                             [10(S"DCM$ABORT"),S"DCM$ABORT",
                              S"DCM$GOEOF", 
                              7(S"DCM$ABORT"),2(S"DCM$ERROR"),
                              S"DCM$ABORT",S"NULL",S"DCM$ERROR"], 
             DCB$SABTBAN     S:DCMSTATE (2,12,6) =
                             [10(S"DCM$ABTBAN"),S"DCM$ERROR", 
                              S"DCM$GOEOF",4(S"DCM$ABTBAN"),
                              2(S"DCM$ERROR"),S"DCM$ABTBAN",
                              2(S"DCM$ERROR"),S"DCM$ABTBAN",S"NULL",
                              S"DCM$ERROR"],
             DCB$SABTEOF     S:DCMSTATE (2,18,6) =
                             [10(S"DCM$ABTEOF"),S"DCM$ABTEOF",
                              S"DCM$GOEOF", 
                              S"DCM$ABTEOF",2(S"DCM$ERROR"),
                              S"DCM$ABTEOF",2(S"DCM$ERROR"),
                              S"DCM$ABTEOF",2(S"DCM$ERROR"),
                              S"DCM$ABTEOF",S"NULL",S"DCM$ERROR"],
             DCB$SRETURN     S:DCMSTATE (2,24,6) =
                             [10(S"DCM$RETURN"),S"DCM$RETURN",
                              S"DCM$GOEOF", 
                              S"DCM$RETURN",S"DCM$RETURN",S"DCM$ABORT", 
                              4(S"DCM$RETURN"),2(S"DCM$ERROR"), 
                              S"DCM$RETURN",S"NULL",S"DCM$ERROR"],
             DCB$SRETBAN     S:DCMSTATE (2,30,6) =
                             [10(S"DCM$RETBAN"),S"DCM$ERROR", 
                              S"DCM$GOEOF",4(S"DCM$RETBAN"),
                              2(S"DCM$ERROR"),S"DCM$RETBAN",
                              2(S"DCM$ERROR"),S"DCM$RETBAN",S"NULL",
                              S"DCM$ERROR"],
             DCB$RETEOF      S:DCMSTATE (2,36,6) =
                             [10(S"DCM$RETEOF"),S"DCM$RETEOF",
                              S"DCM$GOEOF",S"DCM$RETEOF",2(S"DCM$ERROR")
                             ,S"DCM$RETEOF",5(S"DCM$ERROR"),
                              S"DCM$RETEOF",S"NULL",S"DCM$ERROR"];
        ITEM DCB$NEXTST2     U (2,0,60);
        ITEM DCB$ASKPEND     S:DCMACT (3,0,6) = 
                             [10(S"DCM$A30"),S"DCM$A0",S"DCM$A24",
                              S"DCM$A31",S"DCM$A18",S"DCM$A22", 
                              2(S"DCM$A13"),2(S"DCM$A0"),2(S"DCM$AER"), 
                              S"DCM$A30",S"DCM$A9",S"DCM$AER"], 
             DCB$AABORT      S:DCMACT (3,6,6) = 
                             [10(S"DCM$A30"),S"DCM$A0",S"DCM$A25",
                              S"DCM$A31", 
                              S"DCM$A18",3(S"DCM$A13"),2(S"DCM$A0"),
                              2(S"DCM$AER"),S"DCM$A30",S"DCM$A9", 
                              S"DCM$AER"],
             DCB$AABTBAN     S:DCMACT (3,12,6) =
                             [10(S"DCM$A30"),S"DCM$AER",S"DCM$A25", 
                              S"DCM$A31",S"DCM$A18",2(S"DCM$A13"),
                              2(S"DCM$AER"),S"DCM$A0",2(S"DCM$AER"),
                              S"DCM$A30",S"DCM$A9",S"DCM$AER"], 
             DCB$AABTEOF     S:DCMACT (3,18,6) =
                             [10(S"DCM$A30"),S"DCM$A0",S"DCM$A33",
                              S"DCM$A31",2(S"DCM$AER"),S"DCM$A13",
                              2(S"DCM$AER"),S"DCM$A0",2(S"DCM$AER"),
                              S"DCM$A30",S"DCM$A9",S"DCM$AER"], 
             DCB$ARETURN     S:DCMACT (3,24,6) =
                             [10(S"DCM$A30"),S"DCM$A0",S"DCM$A26",
                              S"DCM$A31", 
                              4(S"DCM$AER"),2(S"DCM$A0"),2(S"DCM$AER"), 
                              S"DCM$A30",S"DCM$A9",S"DCM$AER"], 
             DCB$ARETBAN     S:DCMACT (3,30,6) =
                             [10(S"DCM$A30"),S"DCM$AER",S"DCM$A26", 
                              S"DCM$A31",S"DCM$A18",2(S"DCM$A13"),
                              2(S"DCM$AER"),S"DCM$A0",2(S"DCM$AER"),
                              S"DCM$A30",S"DCM$A9",S"DCM$AER"], 
             DCB$ARETEOF     S:DCMACT (3,36,6) =
                             [10(S"DCM$A30"),S"DCM$A0",S"DCM$A32",
                              S"DCM$A31",2(S"DCM$AER"),S"DCM$A13",
                              5(S"DCM$AER"),S"DCM$A30",S"DCM$A9", 
                              S"DCM$AER"];
        ITEM DCB$ACTION2     U (3,0,60);
        END 
  
  
# # 
      ARRAY TEMPX S(3); 
        BEGIN 
        ITEM TEMPC C (0,0,30);
        ITEM TEMP1 U (0,0,60);
        ITEM TEMP2 U (1,0,60);
        ITEM TEMP3 U (2,0,60);
        END 
      ITEM I  I;
      ITEM J  I;
      ITEM L I; 
      ITEM INPUT I;          # CURRENT INPUT TO DCM STATE TABLE        #
      ITEM STATE I;          # CURRENT STATE OF DCM                    #
      ITEM NEXTSTATE I;      # NEXT STATE FOR DCM AFTER PROCESSING     #
                             # CURRENT INPUT                           #
      ITEM ACTION I;         # CURRENT ACTION DCM WILL TAKE DUE TO THE #
                             # INPUT AND CURRENT STATE                 #
      ITEM PRUTEMP I;        # CURRENT PRU POSITION                    #
  
# # 
# # 
# # 
      DEF   SYSTIME # O"2 00 000000"#;
  
      ARRAY OPENED           S(4);
        ITEM
            OP$HDR           C(0,00,01) = [" "],
            OP$TIME          C(0,06,09),
            OP$FILA          C(1,00,01) = [" "],
            OP$DEVDT         C(1,06,02),
            OP$ORD           C(1,18,01),
            OP$TEXT          C(1,24,10) = [" JOB NAME "], 
            OP$JOBNAME       C(2,24,04);
  
      ARRAY PRUXFER          S(2);
        ITEM
            PR$HDR           C(0,00,01) = [" "],
            PR$PRS           C(0,06,10) = ["**********"], 
            PR$TEXT          C(1,06,06) = [" PRU-S"]; 
  
      ARRAY ENDED            S(1);
        ITEM
            EN$HDR           C(0,00,01) = [" "],
            EN$TEXT          C(0,06,04) = ["END "], 
            EN$DEVDT         C(0,30,02),
            EN$ORD           C(0,42,01);
  
      ARRAY TERMNOTREADY S(3);
        ITEM
            TNR$DEVDT        C (0,0,3) = ["1XX"] ,
            TNR$ORD          C (0,18,1),
            TNR$TEXT         C (0,24,17) = [" - NOT READY     "]; 
  
      ARRAY INAPPRO [0:0] S(3); 
        BEGIN 
        ITEM
            MESS$DEVDT       C (0,0,3) = ["0XX"], 
            MESS$ORD         C (0,18,1),
            MESS$TXT         C (0,24,24) =
                             [" - INAPPROPRIATE COMMAND"],
            MESS$US          U (2,48,12) = [0]; 
        END 
      ARRAY DISK$ERR         S(4);
      ITEM
            DISK$DEVDT       C (0,0,3) = ["1XX"], 
            DISK$ORD         C (0,18,1),
            DISK$TXT         C (0,24,29) =
                             [" - DISK PARITY ERROR  JOB =  "], 
            DISK$FNT         C (3,6,7); 
  
      DEF DISK$ERR$LEN#40#; 
  
      ARRAY USR$ABT S(5); 
      ITEM
            ABT$TXTA         C (0,0,5) = [" JOB "], 
            ABT$FNT          C(0,30,4), 
            ABT$TXTB         C(0,54,39)=
                             [" ABORTED BY TERMINAL OPERATOR"], 
            ABT$ZERO         U(4,48,12) = [0],
            ABT$MSG0         U(0),
            ABT$MSG1         U(1),
            ABT$MSG2         U(2),
            ABT$MSG3         U(3),
            ABT$MSG4         U(4);
  
# 
      PP ERROR MESSAGE
# 
      ARRAY PPERROR S(3); 
        BEGIN 
        ITEM DCMPPMSG   C (0,0,25) = [" DCM ERROR BAD PP CALL - "], 
             DCMPPWHO   C (0,30,3), 
             DCMPPEOL   U (2,48,12)= [0]; 
             END
  
      # FILE LIMIT MESSAGE   #
      ARRAY FLIMIT S(3);
        BEGIN 
        ITEM
        LIMITMS C (0,0,28) = ["-**LINE LIMIT EXCEEDED.**"], 
        LIMIT1  U (0,0,60), 
        LIMIT2  U (1,0,60), 
        LIMIT3  U (2,0,60), 
        LIMITUS U (2,48,12) = [0];
        END 
  
      ARRAY STBLERR S(3); 
        BEGIN 
        ITEM STBLMSG    C (0,0,24) = ["DCM STATE TABLE ERROR - "],
             STBLINP    U (2,24,6), 
             STBLSLS    C (2,30,2) = ["/ "],
             STBLSTA    U (2,42,6), 
             STBLEOL    U (2,48,12)= [0]; 
        END 
  
      LABEL POSTACCT,                  # RETURN ADDRESS FOR DCM$ACCT   #
            POSTDSP,                   # RETURN ADDRESS FOR DCM$DSP    #
            POSTPURGE,                 # RETURN ADDRESS FOR DCM$PURGE  #
            POSTQACCALL,               # RETURN ADDRESS FOR DCM$QACCALL#
            POSTQAP;                   # RETURN ADDRESS FOR DCM$QAP    #
  
      CONTROL EJECT;
      PROC DCM$ACCT;
      BEGIN 
*IF DEF,IMS 
 #
*1DC DCM$ACCT 
*     1. PROC NAME           AUTHOR              DATE 
         DCM$ACCT            SEYUNG OH           DEC 20,1979
* 
*     2. FUNCTIONAL DESCRIPTION 
*        DCM$ACCT CALLS -QAP- TO TELL THE ACCOUNTING SYSTEM HOW MANY
*        UNITS WERE PRINTED, PUNCHED OR PLOTTED. -QAP- RETURNS A
*        FORMATTED -LINES PRINTED- MESSAGE THAT IS ADDED TO THE OUTPUT
*        FILE BY DCM$CIONET.
* 
*     3. METHOD USED
*        THE -QAP- PARAMETER BLOCK IS BUILT IN THE FET DATA AREA. THE 
*        FET IN THE DCB IS USED TO CALL -QAP-.
* 
*     4. ENTRY PARAMETERS 
*        DCB, TCB 
* 
*     5. EXIT PARAMETERS
*        DCB
* 
*     6. COMDECKS CALLED
*        SEE DCM
* 
*     7. ROUTINES CALLED
*        DCM$NEWFET 
*        EVENT
*        QAP
*        SYSTEM 
* 
*     8. CONSOLE MESSAGES 
*        NONE 
* 
 #
*ENDIF
# DO THE ACCOUNTING FOR THE LINES PRINTED OR CARDS PUNCHED #
#      TRACE CODE.                                                     #
#     END OF TRACE CODE.                                               #
      P<ACCT> = DCB$FETIN;
      DCB$FETIN = DCB$FETOUT + 2;          #WE WILL PUT IN 2 WORDS     #
      ACT$WORD0 = 0;                       #CLEAN OUT CIO DATA         #
      ACT$WORD1 = 0;
      ACT$TERMNAME = DCB$TERMNAME;
      DCB$FETFNT   = DCB$FNTORD;
        DCB$FETIOQT = DCB$IOQTORD ; 
      ACT$DT = DT$QAPDT [TCB$DEVDT];       #DEVICE TYPE (PR, PU, ETC.) #
      ACT$COUNT    = DCB$ACCOUNT; 
      DCB$FETSTAT = QAPACCOUNT; 
      DCB$ORIGIN = RBFORIGIN ;
      SYSCALL(QAPREQUEST, LOC (DCB$FET0));
      SYSACT = TRUE;                   # PP CALL OUTSTANDING           #
      EVENT (LOC (CIODONE));
      GOTO POSTACCT;
      END  # DCM$ACCT # 
      CONTROL EJECT;
      PROC DCM$BANGEN;
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM$BANGEN
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$BANGEN          SEYUNG OH           DEC 20,1979
* 
*     2. FUNCTIONAL DESCRIPTION 
*        THIS ROUTIME WILL GENERATE THE SECOND CARD OF PUNCH FILE 
* 
* 
*     3. METHOD USED
*        IF PUNCH FILE
*        THEN 
*          USING THE FILE NAME, EACH CHARACTER IN THE NAME IS REPEATED
*          TEN TIMES
* 
*     4. ENTRY PARAMETERS 
*        NONE.
* 
*     5. EXIT PARAMETERS
*        NONE.
* 
*     6. COMDECKS CALLED
*        NONE.
* 
*     7. ROUTINES CALLED
*        NONE.
* 
*     8. CONSOLE MESSAGE
*        NONE.
* 
 #
*ENDIF
      IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PUNCH" 
      THEN
        BEGIN                                    # PUNCH FILE          #
        DCM$NEWFET (DCBSIZE);                    # SET FET POINTERS    #
        FOR J=0 STEP 1 UNTIL 3 DO 
          BEGIN 
          P<TXT> = DCB$FETIN; 
          FOR L=0 STEP 1 UNTIL 9 DO 
            BEGIN                                # REPEAT A CHARACTER  #
            C<L,1>TXTWORD = C<J,1>DCB$FETLFN;    # TEN TIMES           #
            END 
          DCB$FETIN = DCB$FETIN + 1;
          END 
            DCB$FETIN = DCB$FETIN+1;
        MOVEOK (ACN$CB [ACN]);
        DCM$NETPUT; 
        END                                      # PUNCH FILE          #
      DCB$INPTYPE = DCMINPUT"BANCOMPDCM";        # BANNER COMPLETE     #
      RETURN; 
      END 
      CONTROL EJECT;
      PROC DCM$DSP; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM$DSP 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$DSP             SEYUNG OH           JAN 9,1980 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        THIS ROUTINE WILL ROUTE OUTPUT FILE TO OUTPUT QUEUE
* 
*     3. METHOD USED. 
*        CALL PP ROUTINE DSP
* 
*     4. ENTRY PARAMETERS.
*        NONE.
* 
*     5. EXIT PARAMETER.
*        NONE.
* 
*     6. COMDECKS CALLED. 
*        SEE DCM
* 
*     7. ROUTINES CALLED. 
*        BUFINFO             MAKE BUFFER NONMOVABLE 
*        SYSTEM 
*        EVENT
*        DSP (PP) 
* 
*     8. DAYFILE MESSAGE. 
*        DCM ERROR BAD PP CALL - DSP
* 
 #
      P<DCB> = BUFINFO(ACN$CB[ACN]);            # MAKE DCB NONMOVABLE # 
*ENDIF
      DCB$FETSTAT = ZERO; 
      DCB$RETURN = FALSE; 
      FOR J=2 STEP 1 UNTIL 7 DO 
        BEGIN 
        DCB$FET0[J] = ZERO; 
        END 
      IF DCB$RETFLAG                    # RETURN COMMAND ENTERED #
      THEN
        BEGIN 
        DCM$NEWFET (DCBSIZE);               # RESET FET POINTERS #
        DCB$FETCODE = CIOREWIND;
        SYSCALL(CIOREQUEST,LOC(DCB$FET0));
        SYSACT = TRUE;
        EVENT(LOC(CIODONE));
        DCB$RETFLAG = FALSE;
        DCB$FETSTAT = ZERO; 
        FOR J=2 STEP 1 UNTIL 7 DO 
          BEGIN 
          DCB$FET0[J] = ZERO; 
          END 
        END 
      DCB$DSPFNT = DCB$FNTORD;
      DCB$DSPPFL = TRUE;
      DCB$DSPPRB = TRUE;
      DCB$DSPPR = TCB$PRIORITY; 
      IF DCB$FILEEC EQ ECTYPE"A9" 
      THEN
        BEGIN 
        DCB$DSPA9 = TRUE; 
        END 
      DCB$DSPNDM = TRUE;
      DCB$DSPREP = TRUE;
      DCB$DSPRC = TCB$REPEAT; 
      SYSCALL(DSPREQUEST, LOC (DCB$FET0));
      SYSACT = TRUE;
      EVENT (LOC (CIODONE));
      TCB$PRIORITY = ZERO;
      TCB$REPEAT = ZERO;
      IF DCB$DSPERR NQ ZERO 
      THEN
        BEGIN 
        DCMPPWHO = "DSP"; 
        MESSAGE ( PPERROR, DFLOPT );
        END 
      DCB$FNTORD = ZERO;                         # CLEAR FNT ORDINAL   #
        DCB$IOQTORD = 0 ; 
      DCB$FET0 = ZERO;                           # CLEAR FILE NAME     #
      DCB$FILEACT = FALSE;                       # FILE NOT ACTIVE     #
      MOVEOK (ACN$CB [ACN]);                     # DCB MOVEABLE        #
      GOTO POSTDSP; 
      END 
      CONTROL EJECT;
      PROC DCM$NETPUT;
      BEGIN                                      # DCM$NETPUT          #
*IF DEF,IMS 
 #
*1DC  DCM$NETPUT
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$NETPUT          SEYUNG OH           JAN 2,1980 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        ROUTINE IS CALLED TO GENERATE APPLICATION BLOCK HEADER WORD
*        AND TEXT WORDS FOR OFC/DATA SUPERVISORY MESSAGE. THEN NETPUT 
*        ROUTINE IS CALLED TO TRANSFER BATCH DATA BLOCK.
* 
*     3. METHOD USED
*        BUILD ABH AND FIRST WORD OF TEXT AREA THEN CALL NETPUT.
*        ABH IS LOCATED IN DCB$DATAAREA AND STARTING LOCATION OF TEXT 
*        AREA WILL BE DCB$FETOUT - 1. 
*        PFCSFC = ODATA 
*        TLC = DCB$FETIN - DCB$FETOUT + 1 
*        ACT = S"SIXTYBITS" 
*        ABT = SUPERVISORY MESSAGE
* 
*     4. ENTRY PARAMETERS.
*        DCB, TCB, ACN
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS CALLED. 
*        SEE DCM
* 
*     7. ROUTINES CALLED. 
*        NETPUT 
* 
*     8. CONSOLE MESSAGE. 
*        NONE.
* 
 #
*ENDIF
      P<ABH> = LOC (DCB$ABH); 
      P<PRUX> = DCB$FETOUT - 1; 
      P<SM$> = DCB$FETOUT - 1;
      ABH$WORD = ZERO;
      PRUSMH0 = ZERO; 
      ABH$ABT = BLOCKTYPE"SM";
      ABH$ACT = ACT"SIXTYBITS"; 
      RBFBSN = RBFBSN + 1;
      ABH$ABN = RBFBSN;                          # SET BSN OF OFC/DATA #
      ABH$TLC = DCB$FETIN - DCB$FETOUT + 1; 
      PFCSFC = OFCDTA;
      PRUACN = ACN; 
      IF DCB$EOJ
      THEN
        BEGIN 
        EOJFLAG = TRUE; 
        DCB$EOJ = FALSE;
        END 
      NETPUT (ABH,PRUX);
      RETURN; 
      END                                        # DCM$NETPUT          #
      CONTROL EJECT;
      PROC DCM$NEWFET (DSIZE);
      BEGIN                                      # DCM$NEWFET BEGIN    #
*IF DEF,IMS 
 #
*1DC  DCM$NEWFET
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$NEWFET          SEYUNG OH           DEC 19,1979
* 
*     2. FUNCTIONAL DESCRIPTION.
*        DCM$NEWFET BUILDS FIRST, IN, OUT,AND LIMIT POINTER FOR FET 
*        FIELDS TO RUN CIO AND QAP. 
* 
*     3. METHOD USED. 
*        DCM$NEWFET IS CALLED WITH BUFFER SIZE. 
*        VALUE OF FIRST, IN, AND OUT POINTER IS EQUAL TO LAST WORD OF 
*        FET + 1 AND LIMIT IS EQUAL TO LAST WORD OF FET + 1 + DSIZE.
* 
*     4. ENTRY PARAMETERS.
*        DSIZE - BUFFER SIZE
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS CALLED. 
*        NONE.
* 
*     7. ROUTINES CALLED. 
*        BUFINFO
* 
*     8. CONSOLE MESSAGE
*        NONE.
* 
 #
*ENDIF
      ITEM DSIZE I;                              # BUFFER SIZE         #
# 
      DCM$NEWFET
# 
      P<DCB> = BUFINFO (ACN$CB [ACN]); # DCB NOT MOVEABLE  #
      DCB$FETFIRST = LOC (DCB$DATA)    +1;       # SET FET FIRST PTR   #
      DCB$FETIN = DCB$FETFIRST;                  # SET FET IN POINTER  #
      DCB$FETOUT = DCB$FETIN;                    # SET FET OUT POINTER #
      DCB$FETLIMIT = DCB$FETOUT + DSIZE;         # SET FET LIMIT PTR   #
      IF (TCB$TC EQ TERMINALCLAS"$HASP$PRE") OR 
        (TCB$TC EQ TERMINALCLAS"$HASP$PST") OR
        (TCB$TC EQ TERMINALCLAS"$3780") 
      THEN                   # TERMINAL SUPPORTS SKIP TO BOTTOM-OF-FORM#
        DCB$NBF = 0;
      ELSE                   # SKIP TO BOTTOM-OF-FORM NOT SUPPORTED    #
        BEGIN 
        DCB$NBF = 1;
        DCB$PL = DCB$PLTEMP-BANRADJ;         # ADJUSTED LP PAGE LENGTH #
        END 
      RETURN; 
      END                                        # DCM$NEWFET END      #
      CONTROL EJECT;
      PROC DCM$PURGE; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM$PURGE 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$PURGE           SEYUNG OH           JAN 9,1980 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        THIS ROUTINE CALLS CIO TO PURGE OUTPUT FILE
* 
*     3. METHOD USED. 
*        CALL PP ROUTINE CIO. 
* 
*     4. ENTRY PARAMETERS.
*        NONE.
* 
*     5. EXIT PARAMETERS. 
*        NONE.
* 
*     6. COMDECKS CALLED
*        SEE DCM
* 
*     7. ROUTINES CALLED. 
*        BUFINFO             MAKE BUFFER NONMOVABLE 
*        SYSTEM 
*        EVENT
*        CIO
* 
*     8. DAYFILE MESSAGE. 
*        DCM ERROR BAD PP CALL - CIO
* 
 #
      P<DCB> = BUFINFO(ACN$CB[ACN]);            # MAKE DCB NONMOVABLE # 
*ENDIF
      DCB$FETIN = DCB$FETFIRST; 
      DCB$FETOUT= DCB$FETFIRST; 
      DCB$FETSTAT = CIORETURN;
      SYSCALL(CIOREQUEST, LOC (DCB$FET0));
      SYSACT = TRUE;
      EVENT (LOC (CIODONE));
      IF DCB$FETERR NQ ZERO 
      THEN
        BEGIN 
        DCMPPWHO = "CIO"; 
        MESSAGE ( PPERROR, DFLOPT );
*IF DEF,DEBUG 
        ABORT;
*ENDIF
        END 
      DCB$FNTORD = ZERO;                         # CLEAR FNT ORDINAL   #
        DCB$IOQTORD = 0 ; 
      DCB$FET0 = ZERO;                           # CLEAR FILE NAME     #
      DCB$FILEACT = FALSE;                       # FILE NOT ACTIVE     #
      IF TCB$ACKFLAG
      THEN
      BEGIN                                      # ACK OUTPUT FILE NAME#
        EN$DEVDT = C<1,2>DT$DT [TCB$DEVDT];      # DEVICE TYPE         #
        EN$ORD = TCB$ORD + O"33";                # DEVICE ORDINAL      #
        CONSOLE (ENDED,CRITICAL,8); 
        END                                      # ACK OUTPUT FILE NAME#
      MOVEOK (ACN$CB [ACN]);                     # DCB MOVEABLE        #
      GOTO POSTPURGE; 
      END 
      CONTROL EJECT;
      PROC DCM$QAP; 
      BEGIN 
# 
      D C M $ Q A P 
      GENERATES PRINTER BANNER PAGE 
# 
*IF DEF,IMS 
 #
*1DC  DCM$QAP 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$QAP             SEYUNG OH           DEC 20,1979
* 
*     2. FUNCTIONAL DESCRIPTION 
*        GENERATES PRINTER BANNER PAGE BY CALLING QAP 
* 
*     3. METHOD USED
*        WHILE NETPUTING TWO BANNER BLOCKS, DCM$QAP WILL DETERMINE
*        BANNER COMPLETE MARKER 
* 
*     4. ENTRY PARAMETERS 
*        NONE.
* 
*     5. EXIT PARAMETERS
*        NONE.
* 
*     6. COMDECKS CALLED
*        NONE.
* 
*     7. ROUTINES CALLED
*        DCM$NETPUT 
*        SYSTEM 
*        EVENT
* 
*     8. DAYFILE MESSAGE
*        NONE.
* 
 #
*ENDIF
      DCB$BANPUT = NUMPUT;
BANBEGIN: 
      DCM$NEWFET ((PRUSIZE*3)+1);             # BUFFER SIZE = (64*3)+1 #
BANSTART: 
      DCB$FETSTAT = DT$BANREQ [ACN$DEVTYPE [ACN]];
      SYSCALL(QAPREQUEST, LOC (DCB$FET0));       # CALL QAP            #
      SYSACT = TRUE;
      EVENT (LOC (CIODONE));                     # WAIT FOR QAP        #
      IF DCB$FETEOI 
      THEN
        BEGIN                                    # EOI                 #
        DCB$BANNER = DCB$BANNER - 1;
        DCB$CONTROL = 0;
        IF DCB$BANNER EQ ZERO 
        THEN
          BEGIN                                  # BANNER COMPLETED    #
          DCB$INPTYPE = DCMINPUT"BANCOMPDCM"; 
          DCB$BANPUT = 1; 
          END 
        ELSE
          BEGIN 
          IF DCB$FETIN NQ DCB$FETLIMIT - 1
          THEN
            BEGIN                                # BUFFER NOT FULL     #
            GOTO BANSTART;
            END 
          END 
        END 
      DCM$NETPUT;                                # NETPUT BANNER BLOCK #
      DCB$BANPUT = DCB$BANPUT - 1;
      IF DCB$BANPUT NQ ZERO 
      THEN
        BEGIN 
        GOTO BANBEGIN;
        END 
      MOVEOK(ACN$CB [ACN]); 
      GOTO POSTQAP; 
      END 
      CONTROL EJECT;
      PROC DCM$RSM; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM$RSM 
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$RSM             SEYUNG OH           JAN 4,1980 
* 
*     2. FUNCTIONAL DESCRIPTION.
*        RESTARTS STOPPED DEVICE OR PIP 
* 
*     3. METHOD USED. 
*        IF TERMINAL IS STOPPED 
*        THEN SEND RESTART DEVICE SM (OFC/RSTR).
*        IF PIP IS TEMPORARILY STOPPED
*        THEN SEND RESUME OUTPUT SM (OFC/RSM).
*        IF PM TEXT EXISTS
*        THEN RETURN PM TEXT. 
*        CLEAR ALL STOP CONDITIONS. 
* 
*     4. ENTRY PARAMETERS.
*        DCB$DEVSTOP
*        DCB$TEMPSTP
*        DCB$DSKERR 
* 
*     5. EXIT PARAMETERS. 
*        NONE 
* 
*     6. COMDECKS CALLED. 
*        SEE DCM
* 
*     7. ROUTINES CALLED. 
*        DCM$SM 
*        RETTSB 
*        SETACN 
* 
*     8. CONSOLE MESSAGE
*        NONE.
* 
 #
*ENDIF
# 
      DCM$RSM 
# 
      IF DCB$DEVSTOP
      THEN
        BEGIN                                    # RESTART DEVICE SM   #
        DCM$SM (OFCRSM,LOFCRSM,PRUTEMP,TEMPX);
        TCB$INTERRPT = ZERO;
        END 
      ELSE
        BEGIN                                    # RESUME OUTPUT SM    #
        IF DCB$TEMPSTP OR DCB$DSKERR
        THEN
          BEGIN                                  # PIP STOPPED     #
          DCM$SM (OFCRSTR,LOFCRST,PRUTEMP,TEMPX); 
          TCB$INTERRPT = ZERO;
          END                                    # PIP STOPPED   #
        END 
      IF DCB$PMTXT NQ ZERO
      THEN
        BEGIN                                    # CLEAR PM TEXT       #
        RETTSB (DCB$PMTXT); 
        SETUPACN (ACN); 
        DCB$PMTXT = ZERO; 
        TCB$PM = FALSE; 
        END 
      IF DCB$SETFILE
      THEN                                       # SEND SET FILE CMD   #
        BEGIN 
        DCB$SETFILE = FALSE;
        P<FNFV> = LOC(TEMPX); 
        FNFVWD0 = ZERO; 
        FN1 = FNPCC;
        FV1 = NOT  TCB$FMTFLAG; 
        DCM$SM (SETFLE,2,0,TEMPX);
        END 
      DCB$TEMPSTP = FALSE;
      DCB$RSMTM = FALSE;
      DCB$DISKERR = ZERO; 
      DCB$DEVSTOP = FALSE;
      TCB$BATCH = TRUE; 
      RETURN; 
      END 
      CONTROL EJECT;
      FUNC DCM$SKIP U;
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM$SKIP
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$SKIP            SEYUNG OH           JAN 3,1980 
* 
*     2. FUNCTIONAL DESCRIPTION.
* 
*        CALCULATES SKIP POSITION 
* 
*     3. METHOD USED. 
* 
*        SKIP VALUE IS ADDED TO THE CURRENT PRU POSIITON WITH FOLLOWING 
*        CONDITIONS 
* 
* 
*        IF COMMAND IS SKIP TO DAYFILE AND THERE IS DAYFILE 
*        THEN CURRENT PRU POSITION IS DCB$DAYFILE 
*        IF COMMAND IS SKIP TO DAYFILE AND NO DAYFILE 
*        THEN COMMAND IS SKIP TO END AND CURRENT PRU POSITION IS ZERO 
*        IF PREVIOUS PRU POSITION + SKIP VALUE IS LESS THAN EQUAL TO
*           ZERO
*        THEN CURRENT PRU POSITION IS ONE(1)
* 
*        IF PREVIOUS PRU POSITION WAS LESS THAN DAYFILE PRU PSITION 
*           AND THERE IS DAYFILE
*        THEN 
*          IF PREVIOUS PRU POSITION + SKIP VALUE IS GREATER THAN
*             DAYFILE PRU POSITION
*          THEN CURRENT PRU POSITION IS DAYFILE PRU 
*          ELSE CURRENT PRU POSITION IS PREVIOUS PRU POSITION PLUS THE
*               SKIP VALUE
*        ELSE 
*          IF PREVIOUS PRU POSITION + SKIP VALUE IS GREATER THAN EQUAL
*             TO EOI PRU POSITION 
*          THEN COMMAND IS SKIP TO END AND CURRENT PRU POSITION IS ZERO 
*          ELSE CURRENT PRU POSITION IS PREVIOUS PRU POSITION PLUS THE
*               SKIP VALUE
* 
*     4. ENTRY PARAMETERS.
*        DCB$CURPRU 
*        TCB$SKPVAL 
*        TCB$SKPDFL 
* 
*     5. EXIT PARAMETERS. 
*        DCM$SKIP = CURRENT PRU POSITION
* 
*     6. COMDECKS CALLED. 
*        SEE DCM
* 
*     7. ROUTINES CALLED
*        NONE.
* 
*     8. CONSOLE MESSAGE. 
*        NONE.
 #
*ENDIF
      ITEM NEWADDR I;                            # NEW PRU POSITION    #
      IF TCB$SKPDFL AND DCB$DAYFILE NQ ZERO 
      THEN
        BEGIN 
        DCM$SKIP= DCB$DAYFILE;
        END 
      ELSE
        BEGIN 
        IF TCB$SKPDFL 
        THEN
          BEGIN 
          TCB$SKPDFL = FALSE; 
          TCB$CMDTY = DCMINPUT"SKPENDDCM";
          DCM$SKIP= ZERO; 
          END 
        ELSE
          BEGIN 
          NEWADDR = DCB$CURPRU + TCB$SKPVAL;
          IF NEWADDR LQ ZERO
          THEN
            BEGIN 
            DCM$SKIP = 1; 
            END 
          ELSE
            BEGIN 
            IF DCB$CURPRU LS DCB$DAYFILE
               AND
               DCB$DAYFILE NQ ZERO
            THEN
              BEGIN 
              IF NEWADDR GR DCB$DAYFILE 
              THEN
                BEGIN 
                DCM$SKIP = DCB$DAYFILE; 
                END 
              ELSE
                BEGIN 
                DCM$SKIP = NEWADDR; 
                END 
              END 
            ELSE
              BEGIN 
              IF NEWADDR GQ DCB$EOIPRU
              THEN
                BEGIN 
                TCB$CMDTY = DCMINPUT"SKPENDDCM";
                DCM$SKIP = ZERO;
                END 
              ELSE
                BEGIN 
                DCM$SKIP = NEWADDR; 
                END 
              END 
            END 
          END 
        END 
      TCB$SKPVAL = ZERO;
      RETURN; 
      END                                        # DCM$SKIP            #
      CONTROL EJECT;
      PROC DCM$SM (SMCODE,LENGTH,POSITION,STRING);
      BEGIN                                      # DCM$SM BEGIN        #
*IF DEF,IMS 
 #
*1DC  DCM$SM
* 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$SM              SEYUNG OH           DEC 20,1979
* 
*     2. FUNCTIONAL DESCRIPTION.
*        SEND A OUTPUT FLOW CONTROL SUPERVISORY MESSAGE TO NAM. 
* 
*     3. METHOD USED. 
*        DCM$SM BUILD SUPERVISORY MESSAGE FROM THE ENTRY PARAMETERS 
*        AND CALLS NETPUT 
* 
*     4. ENTRY PARAMETERS.
*        SMCODE - PFC/SFC OF SM 
*        LENGTH - LENGTH OF SM
*        POSITION - CURRENT PRU POSITION
*        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;
      ITEM LENGTH U;
      ITEM POSITION U;
      ITEM JK I;
      ARRAY STRING S(3);
        BEGIN 
        ITEM STRING1 U (0,0,60);
        ITEM STRING2 U (1,0,60);
        ITEM STRING3 U (2,0,60);
        END 
      ARRAY SMBUF [0:4] S(1); 
        ITEM SMOFC U (0,0,60);
# 
      INITIALIZE SUPERVISORY MESSAGE AREA 
# 
      FOR JK=0 STEP 1 UNTIL 4 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; 
      CURPRU = POSITION;
      PRUSMH1 = STRING1;
      PRUSMH2 = STRING2;
      PRUSMH3 = STRING3;
# 
      CALL NETPUT 
# 
      NETPUT (ABH,PRUX);
      RETURN; 
      END                                        # DCM$SM END          #
      CONTROL EJECT;
      PROC DCM$QACCALL; 
      BEGIN 
*IF DEF,IMS 
 #
*1DC  DCM$QACCALL 
*     1. PROC NAME           AUTHOR              DATE 
*        DCM$QACCALL         JSF                 77/05/01 
* 
*     2. FUNCTIONAL DESCRIPTION 
*        DCM$QACCALL IS CALLED TO SETUP THE PARAMETERS REQUIRED TO CALL 
*        QAC VIA QCMCALL. DCM$QACCALL ALSO STASHES THE RETURN PARAMETERS
*        THAT ARE RETURNED BY QAC INTO THE DCB. DCM$QACCALL IS A BOOLEAN
*        FUNCTION - A TRUE RETURN INDICATES THAT A FILE WAS FOUND.
* 
*     3. METHOD USED
*        THE QAB REQUIRED BY QCMCALL IS BUILT IN THE FET DATA AREA
*        (LOCATED AFTER THE FET IN THE DCB). AFTER QCMCALL RETURNS, THE 
*        LFN, FNT ORDINAL, DAYFILE ADDRESS ETC. ARE MOVED TO THE DCB
*        FIELDS.
* 
*     4. ENTRY PARAMETERS 
*        DCB, TCB 
* 
*     5. EXIT PARAMETERS
*        DCM$QACCALL IS TRUE IF A FILE WAS FOUND, FALSE IF NONE WAS 
*        FOUND. 
* 
*     6. COMDECKS CALLED
*        SEE DCM
* 
*     7. ROUTINES CALLED
*        QCMCALL
* 
*     8. CONSOLE MESSAGES 
*        NONE 
* 
 #
      ITEM PRUOFFSET  U;
      ITEM MSGTIME C (10);                 # CURRENT TIME              #
*ENDIF
      DEF QACANYPR #O"2022"#; 
      DEF QACANYPT #O"2014"#; 
      DEF QACANYPU #O"2025"#; 
# 
* 
# 
      IF TCB$DIVFLAGS LAN DT$DIVMASK [TCB$DEVDT] NQ 0 THEN RETURN;
      I = GETBUF (QAB$SIZE, NOT$MOVEABLE);
      IF I EQ 0 THEN RETURN;               #RETURN WITHOUT FILE        #
      P<QAB> = BUFINFO (I);                #GET A QAB BUFFER FOR -QAC- #
      DCB$QABBUFO = I; #SAVE OVER QAC CALL# 
      QAC$FUNCTION = QAC$GET; 
      QAC$FORMS = TCB$FORMS;
      QAC$CHGFORMS = TRUE;
      QAC$ORIGIN = RBFORIGIN; 
      QAC$LENQAC = BLOCK$GET - 5;          # QAC LENGTH - 5            #
      QAC$ZEROLFN = 0 ; 
       QAC$ERROR  = 0 ; 
      QAC$DONE = FALSE; 
      QAC$FNTORD = 0 ;
      QAC$ORDINAL = 0 ; 
      QAC$QUEUE   = 0 ; 
      QAC$FAMNAME = TCB$FAMNAME ; 
      QAC$USRNUM  = TCB$USERNUM ; 
      QAC$UI = TCB$USERORD; 
      QAC$PRI = O"7777";
      QAC$CQUEUE = DT$QACDT [TCB$DEVDT] ; 
      QAC$JSN = 0 ;                        # ZEROS JOB SEQUENCE NUMBER #
      IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PLOTTER" 
      THEN                                  # DETAIL INFO FOR PLOT FILE#
        BEGIN 
        QAC$DISP = QACANYPT;
        QAC$EC = TCB$TRAIN + 1;                  # PLOT FILE TYPE      #
        END 
      IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
      THEN
        BEGIN                                    # SELECT OUTPUT FILE  #
        IF TCB$TRAIN EQ TRAINTYPE"ASCII95"
        THEN
          BEGIN 
          QAC$EC = ECTYPE"A9";                   # ASCII 96 PRINT      #
          END 
        IF TCB$TRAIN EQ TRAINTYPE"BCD64"
        THEN
          QAC$EC = ECTYPE"B6";
        IF TCB$TRAIN EQ TRAINTYPE"ASCII64"
        THEN
          BEGIN 
          QAC$EC = ECTYPE"A6";                   # ASCII 64 PRINT      #
          END 
        QAC$DISP = QACANYPR;
        END 
      IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PUNCH" 
      THEN
        BEGIN 
        QAC$DISP = QACANYPU;
        QAC$EC = 6;                    # TO GET ASCII, O26, O29 FILES  #
        END 
      QAC$SELECTA = 0 ; 
      IF SECMOD NQ 0
      THEN
        BEGIN                          # O.S. SECURITY MODE            #
        QAC$SSECU = TRUE ;             # ACCESS LEVEL SELECTION        #
        QAC$ALMIN = SECMIN ;           # EIOT LOWER ACCESS LEVEL       #
        QAC$ALMAX = TCB$AL ;           # LINE UPPER ACCESS LEVEL       #
        END                            # O.S. SECURITY MODE            #
      QAC$SINDUPL = TRUE ;
      QAC$SDEST   = TRUE ;
      QAC$SFORM  = TRUE ; 
      QAC$SHIEREC  = TRUE ; 
      QAC$SECZERO = TRUE ;
      QAC$LINK = 0 ;
      QCMCALL (I);                         #MAKE THE ACTUAL -QAC- CALL #
      SYSACT =TRUE; 
      EVENT (LOC (DONE)); 
      P<QAB> = BUFINFO(DCB$QABBUFO);#REFRESH ADDRESS OF QAC BUFFER# 
      IF QAC$ERROR EQ S"NULL" THEN
        BEGIN                              #WE HAVE A FILE             #
WAITFORBUF: 
        CHGSIZE (ACN$CB [ACN],DCBSIZE + DCBSIZE,0); 
        IF CHGSIZEREJ THEN                 #DID WE GET THE NEW SIZE....#
          BEGIN 
          EVENT (CHAINS"BACKGROUND"); 
          GOTO WAITFORBUF;
          END 
        P<QAB> = BUFINFO(DCB$QABBUFO);    # REFRESH QAC BUFFER ADDRESS #
        DCB$BUFSIZE = DCBSIZE + DCBSIZE;
        DCM$NEWFET(DCBSIZE );                    # SET FET POINTERS    #
        TCB$ALOTIME = 0;                        #CLEAR INACTIVITY TIMER#
        DCB$FILEACT = TRUE; 
        DCB$FILER = TRUE;                     #RBF REALLY OWNS THE FILE#
        DCB$FETLFN = QAC$FILENAME;               # JOB NAME            #
        DCB$FETFNT = QAC$FNTORD;                 # FNT ORDINAL OF JOB  #
        DCB$FETIOQT = QAC$ORDINAL ;              # IOQT ORDINAL        #
        TCB$REPEAT = QAC$RPTCNT;                 # REPEAT COUNTER      #
        DCB$FETRAN = TRUE;                       # RANDOM CIO FLAG     #
        DCB$FETLEN = 2;                          # FET LENGTH          #
        DCB$FETERRP = TRUE;                      # ERROR PROCESSING    #
        DCB$ORIGIN = RBFORIGIN;                  # ORIGIN              #
        DCB$FILEEC = QAC$EC;                     # FILE EC             #
        DCB$FILEIC = QAC$IC;                     # FILE IC             #
        DCB$DAYFILE = QAC$DFADR;                 # DAYFILE PRU         #
        IF QAC$LIMITS GQ 254 # BITS 8-0 ARE NOT USED IN THE SET/FILE   #
        THEN                 # SUPV MESSAGE.  ROUND UP IF NECESSARY.   #
          BEGIN 
          IF QAC$LIMITS[0] EQ O"77777777" 
          THEN               # USER HAS INFINITE LIMIT                # 
            BEGIN 
            DCB$ACCLIMIT = 0;  # ZERO IS INFINITE LIMIT FOR CCP       # 
            END 
          ELSE
            BEGIN 
            DCB$ACCLIMIT = QAC$LIMITS[0];  # USER ACCOUNTING LIMITS    #
            END 
          END 
        ELSE
          BEGIN 
          DCB$ACCLIMIT = QAC$LIMITS + 253;       # ACCOUNTING LIMITS   #
          END 
        IF TCB$CDCNT
        THEN
          BEGIN 
          PRUOFFSET = 16 + TCB$DEVDPS * (DCB$DEVABL + 1); 
          END 
        ELSE
          BEGIN 
          PRUOFFSET = 10 + TCB$DEVDPS * DCB$DEVABL; 
          END 
        IF QAC$INTRADD[0] GR PRUOFFSET
          AND QAC$INTRADD[0] LQ QAC$FILELGTH[0] 
        THEN                 # OUTPUT FILE PREVIOUSLY BEGAN PRINTING   #
          BEGIN 
          DCB$CURPRU = QAC$INTRADD[0] - PRUOFFSET;
          END 
        ELSE                 # OUTPUT FILE NOT PREVIOUSLY PRINTED      #
          BEGIN 
          DCB$CURPRU = 1;   # PRINT FILE FROM BEGINNING                #
          END 
        DCB$EOIPRU = QAC$FILELGTH[0];  # SIZE OF OUTPUT FILE           #
        DCB$FNTORD = DCB$FETFNT;                 # OUTPUT FNT ORDINAL  #
        IF TCB$ACKFLAG
        THEN
          BEGIN                                  # ACK OUTPUT FILE NAME#
          OP$DEVDT = C<1,2>DT$DT [ACN$DEVTYPE [ACN]]; 
          OP$ORD = TCB$ORD + O"33";              # DEVICE ORDINAL      #
          OP$JOBNAME = DCB$FETLFN;               # JOB NAME            #
          SYSCALL("TIMP",SYSTIME + LOC (MSGTIME));
          OP$TIME = C<1,9>MSGTIME;               # CURRENT TIME        #
          CONSOLE (OPENED,CRITICAL,28);          # DISPLAY JOBNAME MSG #
          PR$PRS = XCDD (DCB$EOIPRU);            # CONVERT PRU-S       #
          CONSOLE (PRUXFER,CRITICAL,17);         # DISPLAY PRU MSG     #
          END                                    # ACK OUTPUT FILE NAME#
        DCB$IOQTORD = DCB$FETIOQT ; 
        END 
      ELSE
        BEGIN 
        IF QAC$ERROR EQ S"NOFILE" 
        THEN
          BEGIN                                  # NO FILE FOUND       #
          DCB$FILEACT = FALSE;
          DCB$FILER = FALSE;
          END                                    # NO FILE FOUND       #
*IF DEF,DEBUG 
        ELSE
          BEGIN                                  # QAC ERROR           #
          DCMPPWHO = "QAC"; 
          MESSAGE ( PPERROR, DFLOPT );
          ABORT;
          END                                    # QAC ERROR           #
*ENDIF
        END 
      RETTSB (DCB$QABBUFO);        #RELEASE THE QAB BUFFER# 
      MOVEOK (ACN$CB [ACN]);                     # DCB MOVEABLE        #
      SETUPACN (ACN); 
      DCB$QABBUFO  =  0;
      GOTO POSTQACCALL; 
      END  # DCM$QACCALL #
      CONTROL EJECT;
# 
************************************************************************
*     D C M  MAIN LOOP
************************************************************************
# 
      FOR I=I DO
        BEGIN                                    # MAIN LOOP BEGIN     #
        DCB$PROCESSD = TRUE;                     # INPUT PROCESSED     #
        INPUT = DINPTYPE; 
        IF INPUT EQ ZERO
        THEN
          BEGIN                                  # NOTHING TO DO       #
          EVENT (LOC (ACKED));
          END                                    # NOTHING TO DO       #
        ELSE
          BEGIN                                  # WORK TO DO          #
          DCB$PROCESSD = FALSE;                  # NOT PROCESSED YET   #
          STATE = ACN$MODE [ACN];                # GET CURRENT STATE   #
          IF STATE LQ WC                         # IF CURRENT STATE IS #
          THEN                                   # LESS THAN EQUAL TO  #
            BEGIN                                # 60BITS/6BITS        #
            NEXTSTATE = B<STATE*6-6,6>DCB$NEXTST1 [INPUT];
            ACTION    = B<STATE*6-6,6>DCB$ACTION1 [INPUT];
            END 
          ELSE
            BEGIN 
            J = STATE - WC; # NEW BYTE POSITION # 
            NEXTSTATE = B<J*6-6,6>DCB$NEXTST2 [INPUT];
            ACTION    = B<J*6-6,6>DCB$ACTION2 [INPUT];
            END 
          IF INPUT EQ DCMINPUT"RETURNDCM" 
          THEN
            DCB$RETFLAG = TRUE;     # SET "RETURN" FLAG # 
          IF INPUT LQ DCMINPUT"RETURNDCM" 
          THEN
            BEGIN                                # CLEAR CMD INTERFACE #
            TCB$CMDTY = ZERO;                    # AREA                #
            IF ACN$STATE [ACN] GQ S"IDLE$DOWN"
            THEN
              BEGIN                              # IDLE SHUT DOWN IN   #
              NEXTSTATE = DCMSTATE"DCM$STOP";    # PROGRESS, DO NOTHING#
              ACTION = DCMACT"DCM$A0";
              END 
            END 
          IF INPUT EQ DCMINPUT"ENDCONDCM" 
          THEN
            BEGIN 
            TCB$ENDCON = FALSE; 
            END 
          DCB$TIME = CLOCK;                      # SET DCM TIME        #
          ACN$MODE [ACN] = NEXTSTATE;            # SAVE NEXT STATE     #
          DCB$INPTYPE = ZERO;                    # CLEAR DIRECT INPUT  #
          DCB$CURINPUT = INPUT;                  # SAVE CURRENT INPUT  #
          DCB$CURSTATE = STATE;                  # SAVE CURRENT STATE  #
          DCB$CURACTN = ACTION;                  # SAVE CURRENT ACTION #
# 
      GO TO ACTION ITEM 
# 
          GOTO DCM$ACTION [ACTION]; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 0                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$AZERO:                                       # DO NOTHING          #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 1                                                      *
*                                                                      *
************************************************************************
  
# 
DCM$AONE: 
          DCM$QACCALL;                           # GET OUTPUT FILE     #
POSTQACCALL:  
          TCB$PM = FALSE; 
          IF DCB$FILEACT                         # OUTPUT FILE FOUND   #
          THEN
            BEGIN                                # FILE FOUND          #
            DCB$INPTYPE = DCMINPUT"FILEFNDDCM"; 
            TCB$READY = FALSE;
            TCB$RESUME = FALSE; 
            DCB$RSMTM = FALSE;
            DCM$RSM;
            END                                  # FILE FOUND          #
          ELSE
            BEGIN                                # NO FILE             #
            DCB$RSMTM = TRUE;                    # TIME.               #
            TCB$RESUME = TRUE;                   # DO NOT SEND READY   #
            TCB$READY = TRUE;                    # BATCH PROCESS COMPLT#
            END                                  # NO FILE.            #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 2                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$ATWO: 
          PRUTEMP = ZERO;                        # RESUME OUTPUT       #
          DCM$RSM;
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 3                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$ATHREE: 
          IF DCB$DEVSTOP                         # IF DEVICE IS ALREADY#
          THEN                                   # STOPPED THEN SWITCH #
            BEGIN                                # STATE TO STOP       #
            ACN$MODE [ACN] = DCMSTATE"DCM$WAIT2"; 
            END 
          ELSE
            BEGIN                                # SEND TEMPORARY STOP #
            DCM$SM (OFCSTP,1,0,TEMPX);           # SM TO PP DRIVER     #
            DCB$TEMPSTP = TRUE; 
            END 
          GOTO DCM$2ZERO; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 4                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$AFOUR:  
            P<FNFV> = LOC (TEMPX);
            FNFVWD0 = ZERO;                      # INITIALIZE FNFV AREA#
            FNFVWD1 = ZERO; 
            FN1 = FNPW;                          # SET PAGE WIDTH      #
            FV1 = TCB$CURWIDTH + WID$GLB; 
            FN2 = FNTBS1;                        # SET TRANSMISSION    #
            FV2 = B<0,4>TCB$DEVBSZ;              # BLOCK SIZE          #
            FN3 = FNTBS2; 
            FV3 = B<4,8>TCB$DEVBSZ; 
            IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
            THEN
              BEGIN 
              FN4 = FNPTT;                       # SET TRAIN TYPE      #
              FV4L = TCB$TRAIN; 
              END 
            DCM$SM (SETDEV,3,0,TEMPX);           # SEND SET/DEV SM     #
            FNFVWD0 = ZERO; 
            FN1 = FNLIM1; 
            FN2 = FNLIM2; 
            FV1 = B<0,8>DCB$ACCLIMIT; 
            FV2 = B<8,8>DCB$ACCLIMIT; 
            DCM$SM (SETFLE,2,ZERO,TEMPX); 
          IF TCB$BANFLAG                         # BANNER FLAG SET     #
          THEN
            BEGIN 
            IF ACN$DEVTYPE [ACN] EQ S"LINE$PRINTER" 
            THEN                               # EXPEND DCB FOR  #
              BEGIN                              # PRINT BANNER        #
              CHGSIZE (ACN$CB [ACN], DCBSIZE + PRUSIZE*3 + 2,0);
              END                                # PRINT BANNER        #
            ELSE
              BEGIN                              # PUNCH BANNER        #
              CHGSIZE (ACN$CB [ACN], 2*DCBSIZE + 2,0);
              END                                # PUNCH BANNER        #
            IF CHGSIZEREJ 
            THEN
              BEGIN                              # NO BUFFER SPACE     #
              CHGSIZEREJ = FALSE; 
              EVENT (CHAINS"BACKGROUND"); 
              GOTO DCM$AFOUR; 
              END                                # NO BUFFER SPACE     #
            FNFVWD0 = ZERO; 
            FNFVWD1 = ZERO; 
# 
      SET FILE COMMAND FOR BANNER PAGE
# 
            FN1 = FNTYPE;                  # SET FILE TYPE  # 
            FV1 = FILETYPE"BCDO29";              # BCD PRINT/O29 PUNCH #
            IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PUNCH" 
            THEN
              BEGIN 
              FN2 = FNLACE;                      # SET LACE CARD FLAG  #
              FV2 = FVLACE"RST";
              END 
            ELSE
              BEGIN 
              FN2 = FNPCC;
              FV2 = FVPCC"RST";                  # RESTORE FORMAT      #
              END                                # EFFECTOR            #
            DCM$SM (SETFLE,2,ZERO,TEMPX); 
BANNERBEG:  
# 
      REPRINT BANNER FROM BEGINNING 
# 
            DCB$CONTROL = ZERO; 
            DCB$FETFNT = DCB$FNTORD;
        DCB$FETIOQT = DCB$IOQTORD ; 
            DCB$ORIGIN = RBFORIGIN; 
            DCB$BANNER = DT$NUMBAN [ACN$DEVTYPE [ACN]]; 
BANNERGEN:  
# 
      GENERATE BANNER PAGE
# 
            IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
            THEN
              BEGIN                              # PRINTER BANNER      #
              DCM$QAP;
POSTQAP:  
              END 
            ELSE
              BEGIN                              # PUNCH BANNER        #
              DCM$BANGEN; 
              END 
            END 
          ELSE
            BEGIN                                # BANNER FLAG NOT SET #
            DCB$INPTYPE = DCMINPUT"BANCOMPDCM"; 
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 5                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$AFIVE:                                       # GENERATE MORE       #
          GOTO BANNERGEN;                        # BANNER BLOCKS       #
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 6                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$ASIX: 
          DCB$STPEND = FALSE;                    # CLEAR STOP,END FLAG #
          TCB$ERRORS = ZERO;                     # CLEAR DISPLAY FLAGS #
          PRUTEMP = ZERO; 
          DCM$RSM;                               # RESUME OUTPUT       #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 7                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$ASEVEN: 
          PRUTEMP = ZERO; 
          DCM$RSM;                               # RESUME OUTPUT       #
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 8                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$AEIGHT: 
          DCB$STPEND = TRUE;                     # SET STOP,END FLAG   #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 9                                                      *
*                                                                      *
************************************************************************
# 
  
DCM$ANINE:                                       # CONNECTION BROKEN,  #
                                                 # CLEAN UP DCB        #
          ACN$STATE [ACN] = CONNECTSTATE"END$CONNECT";
          LINK (CHAINS"CON$END",NOEVENT); 
          GOTO CALLRTN;                          # RETURN TO PROCESS   #
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 10                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1ZERO:  
          DCM$SM (OFCABRT,1,ZERO,TEMPX);    # SENT OFC/ABORT SM    #
          DCM$SM (OFCTOM,LOFCTOM,ZERO,TEMPX); 
# 
          CLEAR ALL STOPPED CONDITIONS
# 
          IF DCB$PMTXT NQ ZERO
          THEN
            BEGIN 
            RETTSB (DCB$PMTXT); 
            SETUPACN (ACN); 
            DCB$PMTXT = ZERO; 
            END 
          DCB$DSKERR = FALSE;                    # CLEAR ALL STOPPED   #
          DCB$TEMPSTP = FALSE;
          DCB$RSMTM = FALSE;                     # CLEAR RESUME FLAG   #
          DCB$DISKERR = ZERO; 
          DCB$DEVSTOP = FALSE;
          TCB$BATCH = TRUE;  # SEND READY MSG WHEN PROCESSED ABT     #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 11                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1ONE: 
          IF DCB$DEVSTOP
          THEN
            BEGIN                                # DEVICE ALREADY      #
            DCB$INPTYPE = DCMINPUT"OFCSTPDCM";   # STOPPED             #
            END 
          ELSE
            BEGIN                                # SEND OFC/STP        #
            PRUTEMP = 0;
            DCM$SM (OFCSTP,LOFCST,PRUTEMP,TEMPX); 
            DCB$TEMPSTP = TRUE; 
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 12                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1TWO: 
          PRUTEMP = DCM$SKIP;                    # GET NEW PRU POSITION#
          IF PRUTEMP EQ ZERO                     # SKIP VALUE BEYOND   #
          THEN                                   # EOI OR BOI PRU      #
            BEGIN 
            TEST I; 
            END 
          DCM$RSM;                               # RESUME              #
          TCB$ERRORS = ZERO;                     # CLEAR ERRORS        #
          TCB$SKPDFL = FALSE;      #  CLEAR THE SKIP DAYFILE FLAG    #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 13                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1THREE: 
          DCB$DEVSTOP = FALSE;                   # IGNORE STOP CONDITN #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 14                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1FOUR:  
# 
      OUTPUT DEVICE NOT READY 
# 
          TNR$DEVDT = DT$DT [ACN$DEVTYPE [ACN]];
          TNR$ORD = TCB$ORD + O"33";
          CONSOLE (TERMNOTREADY, NON$CRITICAL,28);
          TCB$NOTRDY = TRUE;
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 15                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1FIVE:  
# 
      OUTPUT DEVICE INTERRUPTED BY PM 
# 
          P<TXT> = ADDRESS [DCB$PMTXT]; 
          C<3,3>TXTWORD = DT$DT [ACN$DEVTYPE [ACN]];# DEVICE TYPE      #
          B<36,6>TXTWORD = TCB$ORD + O"33";      # DEVICE ORDINAL      #
          C<0,4>TXTWORD = "1PM ";                # ADD -PM - TO MESSAGE#
          CONSOLE (TXT,CRITICAL,DCB$PMSIZE);     # OUTPUT PM TEXT      #
          P<TXT> = ADDRESS [DCB$PMTXT]; 
          C<0,8>TXTWORD = "      PM"; # REPLACE THE ORIGINAL PM TO BE  #
                                      # DISPLAYED BY A DIS COMMAND     #
          TCB$PM = TRUE;
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 16                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1SIX: 
          DCB$LIMIT = TRUE;                      # FILE LIMIT REACHED  #
          GOTO DCM$1ZERO;                        # DO DCM$1ZERO        #
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 17                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1SEVEN: 
          IF DCB$DSKCODE EQ DSKPARERR 
          THEN
            BEGIN                                # DISK PARITY ERROR   #
            DISK$DEVDT = DT$DT [ ACN$DEVTYPE [ACN]];
            DISK$ORD   = TCB$ORD + O"33"; 
            DISK$FNT   = DCB$FETLFN;             # FILE NAME           #
            TCB$DISKERR = TRUE; 
            DCB$DSKERR = TRUE;
            CONSOLE (DISK$ERR,CRITICAL,38); 
            IF TCB$AUTOGO 
            THEN
              BEGIN                              # RESTRICTED INTERACTV#
              C<0,3>TEMPC = "1**";
              C<3,18>TEMPC = C<2,18>DISK$TXT; 
              C<21,6>TEMPC = ".**   ";
              B<48,12>TEMP3 = ZERO;              # END OF LINE         #
              DCB$INPTYPE = DCMINPUT"SKPDCM";    # AUTOMATIC SKIP      #
              TCB$SKPVAL = 1 ;                   # ONE PRU POSITION    #
          DCM$SM (OFCDTA,4,ZERO,TEMPX); 
              END                                # PRINT DISK ERROR MSG#
            END                                  # DISK PARITY ERROR   #
*IF DEF,DEBUG 
          ELSE
            BEGIN                                # UN-KNOW DISK ERROR  #
            DCB$FETLFN = "DISKERR"; 
            ABORT;
            END 
*ENDIF
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 18                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1EIGHT: 
          IF DCB$PMTXT NQ ZERO
          THEN
            BEGIN                                # CLEAR PM TXT        #
            RETTSB(DCB$PMTXT);
            SETUPACN (ACN); 
            DCB$PMTXT = ZERO; 
            END 
          DCB$DEVSTOP = FALSE;
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 19                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$1NINE:  
          PRUTEMP = ZERO; 
          DCM$RSM;                               # RESUME OUTPUT       #
          GOTO BANNERBEG;                        # GENERATE BANNER     #
                                                 # PAGES FROM THE BEGIN#
                                                 #NING                 #
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 20                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2ZERO:  
          TCB$LPINTR = TRUE;
          TCB$READY = TRUE;  # SEND READY MESSAGE FOR ACKNOWLEDGEMENT  #
          DCB$RSMTM = FALSE;                     # CLEAR RESUME FLAG   #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 21                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2ONE: 
          IF TCB$REPEAT GQ ZERO 
          THEN
            BEGIN 
            IF DCB$RETURN OR IDLESHUTDOWN 
            THEN
              BEGIN 
              DCM$DSP;                           # RETURN TO QUEUE     #
POSTDSP:  
              END 
            ELSE
              BEGIN 
              DCB$INPTYPE = DCMINPUT"FILEFNDDCM";# REPEAT OUTPUT FILE  #
              TEST I; 
              END 
            END 
          ELSE
            BEGIN 
            DCM$PURGE;                           # PURGE OUTPUT FILE   #
POSTPURGE:  
            END 
          IF DCB$STPEND 
          THEN
            BEGIN                                # GOTO STOP STATE     #
            ACN$MODE [ACN] = DCMSTATE"DCM$STOP";
            DCB$STPEND = FALSE;                  # CLEAR STOP,END FLAG #
            TCB$READY = TRUE;                    # OUTPUT READY MSG    #
            END 
          ELSE
            BEGIN                                # IF IDLE DOWN IS NOT #
            IF NOT IDLESHUTDOWN AND NOT TCB$PM   # IN PROGRESS, SEARCH #
            THEN                                 # OUTPUT QUEUE        #
              BEGIN 
              DCB$INPTYPE = DCMINPUT"RESUMEDCM";
              END 
            END 
        IF TCB$PM 
        THEN
          BEGIN 
          DCB$INPTYPE = DCMINPUT"STOPDCM";
          TCB$ERRORS = ZERO;
          TCB$PM = TRUE;
          END 
        ELSE
          BEGIN 
REDUCE: 
          CHGSIZE (  ACN$CB [ACN], DEV$MINSIZE,0); # REDUCE DCB # 
          IF CHGSIZEREJ                          # MINIMUM SIZE        #
          THEN
            BEGIN 
            CHGSIZEREJ = FALSE; 
            EVENT (CHAINS"BACKGROUND"); 
            GOTO REDUCE;
            END 
          DCB$BUFSIZE = DEV$MINSIZE;
          TCB$ERRORS = ZERO;
          END 
          IF NOT TCB$FMTFLAG
             AND
             ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
          THEN
            BEGIN                                # RESTORE FMT        # 
            TCB$FMTFLAG = TRUE; 
            END 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 22                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2TWO: 
          DCB$LIMIT = TRUE;                      # FILE LIMIT EXCEEDED #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 23                                                     *
*     D C M $ A 24                                                     *
*     D C M $ A 25                                                     *
*     D C M $ A 26                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2THREE: 
DCM$2FOUR:  
DCM$2FIVE:  
DCM$2SIX: 
# 
      RESET DCB$FILER WHEN FILE BACK TO RBF 
# 
          DCB$FILER = TRUE; 
#     INCREASE DCB TO CALL QAP AND DO ACCOUNTING                       #
          CHGSIZE ( ACN$CB [ACN], DCBSIZE * 2 + 2,0); 
          IF CHGSIZEREJ 
          THEN
            BEGIN                                # NOT ENOUGH SPACE    #
            CHGSIZEREJ = FALSE; 
            EVENT (CHAINS"BACKGROUND"); 
            GOTO DCM$2SIX;
            END 
          DCB$BUFSIZE = DCBSIZE * 2 + 2;         # CURRENT DCB SIZE    #
          DCB$TEMPSTP = FALSE;
          TCB$REPEAT = TCB$REPEAT - 1;           # DECREMENT REPEAT CNT#
          IF TCB$REPEAT LS ZERO 
          THEN
            BEGIN                                # END OUTPUT STREAM   #
            DCB$EOJ = TRUE; 
            END 
          ELSE
            BEGIN                                # DO NOT END STREAM   #
            DCB$EOJ = FALSE;
            DCB$CURPRU = 1;             # TRANSMIT FILE FROM BEGINNING #
            END 
          IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
          THEN
            BEGIN                                # CHANGE FILE TYPE FOR#
            P<FNFV> = LOC (TEMPX);               # LAST PRINTER MESSAGE#
            FNFVWD0 = ZERO; 
            FN1 = FNTYPE; 
            FV1 = FILETYPE"BCDO29";              # BCD PRINT           #
            IF DCB$LIMIT       # SUPPRESS FURTHER ACCOUNTING BY NETWORK#
            THEN               # BEFORE SENDING LIMITS EXCEEDED MESSAGE#
              BEGIN 
              FN2 = FNLIM1; 
              FV2 = ZERO; 
              FN3 = FNLIM2; 
              FV3 = ZERO; 
              END 
            DCM$SM (SETFLE,2,ZERO,TEMPX); 
            END 
          DCM$NEWFET (DCBSIZE);                  # SET FET POINTERS    #
          DCM$ACCT;                              # DO ACCOUNTING       #
POSTACCT: 
          IF DCB$CURACTN EQ DCMACT"DCM$A23" 
          THEN
            BEGIN                                # DO NOT SEND LAST BLK#
            TEST I; 
            END                                  # DO NOT SEND LAST BLK#
          MOVEOK(ACN$CB[ACN]);
          IF DCB$CURACTN EQ DCMACT"DCM$A24" 
          THEN
            BEGIN 
            IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
            THEN
              BEGIN                              # OUTPUT ACCOUTING    #
              DCM$NETPUT;                        # MESSAGE TO PRINTER  #
              TEST I; 
              END 
            END 
          DCB$FETIN = DCB$FETFIRST; 
          DCB$FETOUT = DCB$FETFIRST;
          IF DCB$CURACTN EQ DCMACT"DCM$A25" 
          THEN
            BEGIN 
            P<TXT> = DCB$FETIN; 
            TCB$REPEAT = -1;                     # CLEAR REPEAT COUNT  #
            DCB$EOJ = TRUE;                      # TERMINATE STREAM    #
            IF DCB$LIMIT
            THEN
              BEGIN 
              DCB$LIMIT = FALSE;                 # CLEAR LIMIT FLAG    #
              IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
              THEN
                BEGIN                            # OUTPUT LIMIT EXCEED #
                TXTWORDU [0] = LIMIT1;           # MESSAGE TO PRINTER  #
                TXTWORDU [1] = LIMIT2;
                TXTWORDU [2] = LIMIT3;
                DCB$FETIN = DCB$FETIN + 3;
                END 
              IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PUNCH" 
              THEN
                BEGIN                            # PUNCH LIMIT CARD    #
                P<FNFV> = LOC (TEMPX);           # SEND SET/FILE CMD   #
                FNFVWD0 = ZERO; 
                FN1 = FNCPLIM;
                FV1 = 1;
                PRUTEMP = ZERO; 
                DCM$SM (SETFLE,2,PRUTEMP,TEMPX);
                END                              # PUNCH LIMIT CARD    #
              IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PLOTTER" 
              THEN
                BEGIN 
                C<0,3>TEMPC = DT$DT [ACN$DEVTYPE [ACN]];
                C<3,1>TEMPC = TCB$ORD + O"33";
                C<4,16>TEMPC = C<7,15>LIMITMS;
                CONSOLE (TEMPX,CRITICAL,20);
                END 
              END 
            ELSE
              BEGIN 
              IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
              THEN
                BEGIN                            # OUTPUT ABORT MESSAGE#
                ABT$FNT = DCB$FETLFN;            # TO THE PRINTER      #
                TXTWORDU [0] = ABT$MSG0;
                TXTWORDU [1] = ABT$MSG1;
                TXTWORDU [2] = ABT$MSG2;
                TXTWORDU [3] = ABT$MSG3;
                TXTWORDU [4] = ABT$MSG4;
                DCB$FETIN = DCB$FETIN + 5;
                END 
              END 
            END 
          IF DCB$CURACTN EQ DCMACT"DCM$A26" 
          THEN
            BEGIN 
            DCB$RETURN = TRUE;
            DCB$EOJ = TRUE;                      # TERMINATE STREAM   # 
            TCB$REPEAT = TCB$REPEAT + 1;         # DO NOT PURGE FILE   #
            END 
          DCM$NETPUT;                            # OUTPUT OFC/DATA SM  #
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 27                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2SEVEN: 
          MESS$DEVDT = DT$DT [ACN$DEVTYPE [ACN]];# OUTPUT INAPPROPRIATE#
          MESS$ORD = TCB$ORD + O"33";            # COMMAND MESSAGE TO  #
          CONSOLE (INAPPRO, NON$CRITICAL,28);    # CONSOLE             #
          GOTO DCM$2ZERO; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 28                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2EIGHT: 
          TCB$ERRORS = ZERO;                     # CLEAR DISPLAY FLAGS #
          PRUTEMP = ZERO; 
          DCM$RSM;                               # RESUME OUTPUT       #
          GOTO BANNERGEN;                        # GENERATE MORE       #
                                                 # BANNER BLOCKS       #
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 29                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$2NINE:  
          CHGSIZE (ACN$CB [ACN],DCBMINSIZE,0);
          IF CHGSIZEREJ 
          THEN
            BEGIN                                # REDUCE DCB SIZE TO 7#
            CHGSIZEREJ = FALSE; 
            EVENT (CHAINS"BACKGROUND"); 
            GOTO DCM$2NINE; 
            END 
          P<FNFV> = LOC (TEMPX);                 # GENERATE SET/FILE   #
          FNFVWD0 = ZERO; 
          FNFVWD1 = ZERO; 
          IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"LINE$PRINTER"
          THEN
            BEGIN                                # PRINTER DEVICE      #
            FN1 = FNPCC;                         # SET FORMAT EFFECTOR #
            IF NOT TCB$FMTFLAG
            THEN
              BEGIN 
              FV1 = FVPCC"SUP"; 
              END 
            ELSE
              FV1 = FVPCC"RST"; 
            FN2 = FNTYPE;                        # FILE TYPE           #
            FV2 = FILETYPE"BCDO26";              # 6 BIT DISPLAY FILE  #
            IF DCB$FILEIC EQ ICTYPE"ASCII6" 
            THEN
              BEGIN 
              FV2 = FILETYPE"BCDO29";            # 6/12 ASCII FILE     #
              END 
            IF DCB$FILEIC EQ ICTYPE"ASCII"
            THEN
              BEGIN                              # ASCII FILE TYPE     #
              FV2 = FILETYPE"ASCII95";
              END 
            END                                  # PRINTER FILE        #
          ELSE
            BEGIN 
            IF ACN$DEVTYPE [ACN] EQ DEVICETYPE"PUNCH" 
            THEN
              BEGIN                              # PUNCH DEVICE        #
              IF DCB$FILEIC EQ ICTYPE"DIS"
              THEN
                BEGIN 
                FN1= FNTYPE;
                FV1 = FILETYPE"BCDO29";          # DEFAULT - O29 PUNCH #
                IF DCB$FILEEC EQ ECTYPE"B6" 
                THEN
                  BEGIN                          # O26 PUNCH           #
                  FV1 = FILETYPE"BCDO26";        # O26 PUNCH           #
                  END 
                END 
              ELSE
               IF DCB$FILEIC EQ ICTYPE"ASCII" 
                THEN
                 BEGIN
                 FN1= FNTYPE; 
                 FV1 = FILETYPE"ASCII95";        # ASCII FILE TYPE     #
                 END
              END 
            ELSE
              BEGIN                              # PLOT DEVICE         #
              FN1 = FNTYPE;                      # FILE TYPE           #
            IF DCB$FILEEC EQ ECTYPE"T8" 
              THEN
                BEGIN                            # 8-BIT PLOTTER       #
                FV1 = FILETYPE"T8BITS"; 
                END 
              ELSE
                BEGIN                            # 6-BIT PLOTTER       #
                FV1 = FILETYPE"T6BITS"; 
                END 
              END 
            END 
          DCM$SM (SETFLE,2,ZERO,TEMPX); 
          DCM$RSM;                               # RESUME OUTPUT       #
          TEMP1 = ZERO; 
          C<0,7>TEMP1 = DCB$FETLFN;              # JOB NAME            #
          B<48,12>TEMP1 = DCB$FNTORD;            # FNT ORDINAL         #
          DCM$SM(OFCSTRT,2,DCB$CURPRU,TEMPX);  # OUTPUT OFC/START SM   #
# 
      SET DCB$FILER TO FALSE AFTER FILE TRANSFERRED TO NIP
# 
          DCB$FILER = FALSE;          #RBF DOESN'T OWN THE FILE#
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 30                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$3ZERO:  
          TCB$CMDTY = DCB$CURINPUT;              # CANNOT PROCESS CMD  #
          EVENT (CHAINS"BACKGROUND"); 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 31                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$3ONE: 
          DCB$INTRPT = TRUE;                     # STOP BATCH PROCESS  #
          TCB$LPINTR   = TRUE;                   # INTERRUPTTED        #
          DCB$TIME = CLOCK; 
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 32                                                     *
*     D C M $ A 33                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$3TWO: 
          DCB$RETURN = TRUE;                     # SET RETURN FLAG     #
DCM$3THREE: 
          PRUTEMP = 1;                           # SEND OFC/DATA WITH  #
          DCM$SM (OFCDTA,1,PRUTEMP,TEMPX);
                                                 # DATA.               #
          DCB$EOJ = FALSE;                       # CLEAR FOR NEXT FILE.#
          TEST I; 
  
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 34                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$3FOUR:  
          IF DCB$TEMPSTP
          THEN
            BEGIN                                # LAST BLOCK NOT SENT #
            DCM$NETPUT; 
          MOVEOK(ACN$CB[ACN]);
          DCB$TEMPSTP = FALSE;
            END                                  # LAST BLOCK NOT SENT #
          GOTO DCM$ASIX;
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 35                                                     *
*                                                                      *
************************************************************************
# 
DCM$3FIVE:  
          DCB$SETFILE = TRUE; 
          IF DCB$CURSTATE EQ DCMSTATE"DCM$GO" 
          THEN
            BEGIN 
            GOTO DCM$ATWO;
            END 
          ELSE
            GOTO DCM$2ZERO; 
  
# 
************************************************************************
*                                                                      *
*     D C M $ A 36                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$3SIX: 
          P<TXT> = ADDRESS [DCB$PMTXT]; 
          C<1,3>TXTWORD = DT$DT [ACN$DEVTYPE [ACN]];     # DEVICE TYPE #
          B<24,6>TXTWORD = TCB$ORD + O"33";           # DEVICE ORDINAL #
          C<0,2>TXTWORD = "1 "; 
          CONSOLE (TXT,CRITICAL,DCB$PMSIZE);       # OUTPUT DCPNL TEXT #
          DCM$SM (OFCABRT,1,ZERO,TEMPX);           # SEND OFC/ABORT SM #
          DCM$SM (OFCTOM,LOFCTOM,ZERO,TEMPX);        # SEND OFC/TOM SM #
          TCB$PM = TRUE;
          TCB$PRIORITY = O"100";    # DEFAULT PRIORITY FOR OUTPUT FILE #
          TEST I; 
  
# 
************************************************************************
*                                                                      *
*     D C M $ A ER                                                     *
*                                                                      *
************************************************************************
# 
  
DCM$AERROR: 
          STBLINP = DCB$CURINPUT;                # CURRENT INPUT       #
          STBLSTA = DCB$CURSTATE;                # CURRENT STATE       #
          MESSAGE (STBLERR, DFLOPT);
*IF DEF,DEBUG 
          ABORT;
*ENDIF
          ACN$MODE [ACN] = DCB$CURSTATE;
          TEST I; 
          END 
        END 
    END  # D C M #
      TERM; 
