IDENT 1TM,FWA TITLE 1TM - RDF TWO-PORT MULTIPLEXER DRIVER. PERIPH BASE MIXED SST SSCP *COMMENT 1TM - TWO-PORT MULTIPLEXER DRIVER. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. ITM SPACE 4,10 *** 1TM - TWO-PORT MULTIPLEXER DRIVER. * * P. D. FARRELL 81/11/18. ITM SPACE 4,10 *** *1TM* PROVIDES THE PPU INTERFACE BETWEEN THE * REMOTE DIAGNOSTIC FACILITY, *RDF*, AND THE * CYBER 170-8X5 TWO-PORT MULTIPLEXER. * * *1TM* COMMUNICATES WITH THE TWO-PORT MULTIPLEXER * AND WITH THE *RDF* CPU INTERFACE, EITHER *RDF* * OR *IAF*. ITM SPACE 4,10 *** PROGRAM CALL - * *T IR 18/*1TM*, 6/0, 12/RCC, 12/RTS, 12/CTL WD PTR * * RCC = RECALL CONTROL. * = 0, IF NOT PP RECALL AND NOT *2TM* CALL. * = 10/EQ, 1/S, 1/P, IF PP RECALL OR *2TM* CALL. * EQ = RESERVED EQUIPMENT NUMBER. * S = 1, IF PORT CURRENTLY IS RESERVED FOR * *1TM*. * P = PORT NUMBER. * * RTS = REAL-TIME CLOCK (SECONDS) AT START * OF DRIVER INACTIVITY TIME-OUT. * = 0 ON INITIAL CALL OR ON EXECUTIVE * RECALL. * * CTL WD PTR = POINTER TO DRIVER CONTROL WORD * IN CM EXECUTIVE TABLE *VDRL*. * * * (DRIVER CONTROL WORD) = ON INITIAL DRIVER CALL - * *T, 12/0, 24/ DRIVER NAME (*1TM*), 24/0 * * (DRIVER CONTROL WORD) = ON DRIVER RECALL OR ON * EXECUTIVE RECALL - * *T, 12/IL, 24/SA, 12/TC, 12/TN. * * IL = DRIVER INTERLOCK. * SA = DRIVER STACK ADDRESS. * TC = DRIVER TERMINAL COUNT. * TN = TERMINAL NUMBER OF DRIVER PORT. * * AFTER INITIALIZATION, *1TM* WILL WAIT FOR FOUR SECONDS * FOR TERMINAL LOGIN. IF THE TERMINAL DOES NOT ATTEMPT * TO LOGIN WITHIN FOUR SECONDS, *1TM* WILL DROP FROM * THE PPU AND RETURN VIA PPU RECALL AFTER 5 SECONDS. * * IF THE USER HAS NOT ATTEMPTED TO LOGIN WITHIN 15 * MINUTES, *1TM* WILL DROP FROM THE PPU WITHOUT RE- * CALLING ITSELF UNLESS THE *DEDICATED RDF* FLAG IS * SET. IF THE *DEDICATED RDF* FLAG IS SET, *1TM* WILL * CONTINUE TO LOOK FOR LOGIN FOR 4 SECONDS AND DROP * FOR 5 SECONDS. * * ONCE *1TM* HAS DROPPED FROM THE PPU AFTER 15 MINUTES * OF NO TERMINAL ACTIVITY, *1TM* MUST BE REACTIVATED * BY ENTERING THE *DSD* CONSOLE COMMAND TO REQUEST * THAT *RDF* RESTART *1TM* (EXECUTIVE RECALL). SPACE 4,15 *** OPERATOR TERMINAL CONTROL. * * * EXCEPT FOR THE TOGGLE FUNCTION OF THE *F7* KEY OF A CDC * 721 TERMINAL (SEE ITEM 7 BELOW), *1TM* TERMINAL PROTOCOL * IS IDENTICAL TO IAF STIMULATOR PROTOCOL. IN GENERAL, ALL * INPUT AND OUTPUT IS PROCESSED ON A LINE-BY-LINE BASIS AND * THE UNIT OF INPUT IS THE LOGICAL LINE. * * (1) TO LOGIN, POWER UP THE TERMINAL IF HARDWIRED * OR DIAL-IN IF DIAL UP LINE, THEN ENTER THE * CHARACTER *B* IF BLOCK-EDIT TERMINAL OR *CR* * IF NOT. IF THE CENTRAL SITE DOES NOT REPLY * IMMEDIATELY WITH THE LOGIN MESSAGE, WAIT ONE * OR TWO SECONDS AND TRY AGAIN. * * (2) TO COMPLETE AN INPUT LINE, DEPRESS THE *RETURN* * KEY. IT IS NOT NECESSARY TO ENTER A *LINE * FEED* SINCE THE DRIVER WILL SUPPLY ONE. * * (3) TO DELETE OR IGNORE AN INPUT LINE, ENTER * *ESC*. THE DRIVER WILL DISCARD THE LINE * AND WILL REPLY WITH THE MESSAGE *DEL*. * * (4) TO DELETE A PREVIOUSLY ENTERED CHARACTER, * DEPRESS THE *BACKSPACE* CHARACTER (LEFT * ARROW ON SOME KEYBOARDS). * * (5) TO TERMINATE OUTPUT, DEPRESS THE *BREAK* KEY * OR THE *S* KEY. * * (6) TO INTERRUPT OUTPUT, DEPRESS THE *I* KEY. * OUTPUT MAY BE RESUMED BY ENTERING *P* * FOLLOWED BY *RETURN*. * * (7) TO TOGGLE TO ANOTHER TWO PORT MUX DRIVER (*MDD* * OR *SCD*) WHICH HAS ALREADY BEEN BROUGHT UP ON * THE PORT USED BY *1TM*, DEPRESS THE *F7* KEY * ON A CDC 721 TERMINAL. NOTE THAT THIS SHARING * CAPABILITY DOES NOT EXIST ON A CYBER 170-865/875. SPACE 4,15 *** DAYFILE MESSAGES - * * * * 1TM - RDF TIME-OUT.* * THIS MESSAGE INDICATES THAT NO TERMINAL ACTIVITY * HAS OCCURRED FOR 15 MINUTES (ASSEMBLY PARAMETER) * AND THAT *RDF* IS NOT IN *DEDICATED* MODE. *1TM* * HAS DROPPED FROM THE PPU WITHOUT RECALL AND HAS * SIGNALLED DRIVER-DROP TO *RDF*. * * * 1TM - NO TPM RESPONSE.* * THE TWO-PORT MULTIPLEXER FAILED TO RESPOND * TO A STATUS REQUEST FUNCTION. * * * 1TM - RDF CANNOT BE RUN ON MAINFRAME.* * THE MAINFRAME DOES NOT HAVE THE NECESSARY HARDWARE * TO SUPPORT USAGE OF *RDF*. * * * 1TM - NO TPM AVAILABLE.* * EITHER THERE IS NO TWO-PORT MULTIPLEXER AVAILABLE * IN THE EQUIPMENT STATUS TABLE OR THE MULTIPLEXER * CHANNEL IS NOT AVAILABLE. * * * 1TM - RMEEE CXX PNN FYYYY REJECT.* * TWO-PORT MULTIPLEXER, EST ORDINAL *EEE*, * CHANNEL NUMBER *XX*, PORT NUMBER *NN*, HAS * REJECTED FUNCTION *YYYY. * * * 1TM - RDF TERMINATED.* * *RDF* IS NOT ENABLED. *1TM* WILL ISSUE THIS * MESSAGE, THEN DROP AFTER SIGNALLING DRIVER DROP * TO *RDF*. *1TM* MAY BE RESTARTED BY ENABLING * *RDF* AND BY ENTERING THE CONSOLE COMMAND TO * RESTART *1TM*. ITM SPACE 4,15 *** ERROR LOG MESSAGES - * * * * RMEEE CXX PNN FYYYY REJECT.* * TWO-PORT MULTIPLEXER, EST ORDINAL *EEE*, * CHANNEL NUMBER *XX*, PORT NUMBER *NN*, HAS * REJECTED FUNCTION *YYYY. * * * RDF CARRIER LOST.* * INDICATES THAT THE CARRIER HAS DROPPED ON AN * ACTIVE TERMINAL. THE TERMINAL IS IMMEDIATELY * LOGGED OUT WHEN THIS OCCURS. * * * RDF INITIATED.* * ISSUED WHEN TERMINAL INITATES LOGIN. * * * RDF TERMINATED.* * *RDF* IS NOT ENABLED. *1TM* WILL ISSUE THIS * MESSAGE, THEN DROP AFTER SIGNALLING DRIVER DROP * TO *RDF*. *1TM* MAY BE RESTARTED BY ENABLING * *RDF* AND BY ENTERING THE CONSOLE COMMAND TO * RESTART *1TM*. * * * RDF TIME-OUT.* * THIS MESSAGE ACCOMPANIES THE * 1TM - RDF * TIME-OUT.* DAYFILE MESSAGE AND INDICATES THAT NO * TEMINAL ACTIVITY HAS OCCURRED FOR 15 MINUTES * (ASSEMBLY PARAMETER) AND THAT *RDF* IS IS NOT IN * DEDICATED MODE. *1TM* HAS DROPPED FROM THE PPU * WITHOUT RECALL AND HAS SIGNALLED DRIVER-DROP TO * *RDF*. ITM TITLE INTERNAL DOCUMENTATION. ITM SPACE 4,40 ** TWO-PORT MULTIPLEXER FUNCTION CODES. * * THE FOLLOWING IS A DESCIPTION OF TWO-PORT MULTIPLEXER * STATUS AND DATA FORMATS. * * * TWO-PORT MULTIPLEXER STATUS CODES- * * BIT DESCRIPTION * --- ----------- * * 11-5 NOT USED. * 4 OUTPUT BUFFER READY (NOT FULL). * 3 INPUT READY. * 2 CARRIER ON. * 1 DATA SET READY. * 0 RING INDICATOR. * * * TWO-PORT MULTIPLEXER MODE SELECTION FUNCTION CODES- * * BIT DESCRIPTION * --- ----------- * * 11-6 NOT USED. * 5 ENABLE LOOP-BACK. * 4 DISABLE PARITY. * 3 NUMBER OF STOP BITS- * 0 = 1 STOP BIT. * 1 = 2 STOP BITS. * 2-1 DATA BITS PER CHARACTER- * 00 = 5 BITS. * 01 = 6 BITS. * 10 = 7 BITS. * 11 = 8 BITS. * 0 PARITY- * 0 = ODD PARITY. * 1 = EVEN PARITY. * * * INPUT DATA BYTE FORMAT- * * BIT DESCRIPTION * --- ----------- * * 11 DATA SET READY. * 10 DATA SET READY .AND. CARRIER ON. * 9 LOST DATA. * 8 FRAMING ERROR OR PARITY ERROR. * 7-0 DATA BITS. * * * OUTPUT DATA BYTE FORMAT- * * BIT DESCRIPTION * --- ----------- * * 11-8 NOT USED. * 7 DATA PARITY. * 6-0 DATA BITS (LEAST SIGNIFICANT DATA BIT * IN BIT POSITION 0). ITM SPACE 4,25 ** TWO-PORT MULTIPLEXER EST ENTRY. * * THE FORMAT OF THE TWO-PORT MULTIPLEXER EQUIPMENT STATUS * TABLE ENTRY IS AS SHOWN BELOW. * *T EST 12/0, 12/CH, 12/0, 12/RM, 11/0, 1/N * * CH = CHANNEL NUMBER. * * RM = MNEMONIC *RM*. * * N = PORT NUMBER, 0 OR 1. * * * THE FORMAT OF THE *EQPDECK* ENTRY FOR THE TWO-PORT * MULTIPLEXER IS AS SHOWN BELOW. * * EQXXX=RM,ST=ON/OFF,CH=NN,PT=N. * * *EQ* = MNEMONIC *EQ*. * * *RM* = MNEMONIC *RM*. * * ST = STATUS, *ON* OR *OFF*. * * PN = PORT NUMBER, *0* OR *1*. * * CH = CHANNEL NUMBER. * * EXAMPLE - * * EQ765=RM,ST=ON,CH=15,PT=0. * * THE ABOVE ENTRY DEFINES EST ORDINAL 765 AS PORT 0 OF * THE TWO-PORT MULTIPLEXER, LOGICALLY *ON* IN THE EST. ITM TITLE TERMINAL TABLE USAGE. ITM SPACE 4,25 ** *1TM* TERMINAL TABLE USAGE. * * *1TM* USES THE *RDF* TERMINAL TABLE IN THE SAME * MANNER AS DOES THE 6671/6676 MULTIPLEXER DRIVER, * *1TD*, WITH THE EXCEPTION THAT TERMINAL TYPES * ARE NOT SIGNIFICANT (SINCE ONLY ONE TERMINAL TYPE * AND ONE TRANSLATION TABLE ARE SUPPORTED). VFST SPACE 4,15 ** TERMINAL TABLE WORD *VFST*. * * NOTE - ONLY THOSE FIELDS REFERENCED BY *1TM* * ARE DESCRIBED. * *T 12/FS, 12/FS+1, 12/FS+2, 12/FS+3, 12/FS+4 * * FS = 12/ UPPER 12 BITS OF JSN. * * FS+1 = 12/ LOWER 12 BITS OF JSN. VROT SPACE 4,15 ** TERMINAL TABLE WORD *VROT*. * * NOTE - ONLY THOSE FIELDS REFERENCED BY *1TM* * ARE DESCRIBED. * *T 12/RO, 12/RO+1, 12/RO+2, 12/RO+3, 12/RO+4 * * RO+4 = JOB STATUS BITS - * * BIT DESCRIPTION * --- ----------- * 6 LIST IN PROGRESS. * 4 OUTPUT ON MASS STORAGE. * 0 JOB BUSY IF ZERO. VDPT SPACE 4,15 ** TERMINAL TABLE WORD *VDPT*. * *T 12/DP, 12/DP+1, 12/DP+2, 12/DP+3, 12/DP+4 * * DP = 12/ FIRST POT OF LINE. * * DP+1 = 12/ CURRENT POT OF LINE. * * DP+2 = 3/ FIRST WORD OF LINE IN FIRST POT. * 1/ INPUT INITIATED IF SET. * 1/ NEXT POT REQUESTED IF SET. * 3/ CURRENT WORD OF LINE IN CURRENT POT. * 4/ CURRENT CHARACTER OF LINE. * * DP+3 = FLAG BITS - * * BIT DESCRIPTION * --- ----------- * 11-8 NOT USED. * 7 TERMINAL MODE- * 0 = *TTY*. * 1 = *BLKEDIT*. * 6 FULL DUPLEX. * 5-4 NOT USED. * 3 BINARY INPUT. * 2 TRANSPARENT INPUT MODE. * 1 EXTENDED MODE. * 0 ODD PARITY. * * DP+4 = 12/ CURRENT REENTRY ADDRESS. VCHT SPACE 4,15 ** TERMINAL TABLE WORD *VCHT*. * *T 12/CH, 12/CH+1, 12/CH+2, 12/CH+3, 12/CH+4 * * CH = IF INPUT - * 12/ UPPER CHARACTER OF INPUT BYTE. * = IF OUTPUT - * 12/ STACK FOR ROUTINE ADDRESS. * * CH+1 = IF INPUT - * 12/ CHARACTER COUNT OF LINE. * = IF OUTPUT - * 12/ SCRATCH. * * CH+2 = IF INPUT - * 12/SCRATCH. * = IF OUTPUT - * 12/ PARTIALLY PROCESSED CONTROL BYTE. * * CH+3 = 12/ INPUT CHARACTER COUNT ACCUMULATOR. * * CH+4 = 12/ OUTPUT CHARACTER COUNT ACCUMULATOR. * * *VCHT* IS WRITTEN BY *IAF*/*RDF* DURING JOB RECOVERY AFTER * SUSPENDING *1TM*. *1TM* WAITS FOR INTERRUPT ACKNOWLEDGE * BEFORE WRITING *VCHT*. VDCT SPACE 4,15 ** TERMINAL TABLE WORD *VDCT*. * * NOTE - ONLY THOSE BITS AND FIELDS DIRECTLY USED BY *1TM* * ARE DESCRIBED. * *T 12/DC, 12/DC+1, 12/DC+2, 12/DC+3, 12/DC+4 * * DC = FLAG BITS - * * BIT DESCRIPTION * --- ----------- * 11 DRIVER REQUEST IN BYTE 4. * 10 INTERRUPT ACKNOWLEDGE. * 9 LOGGED IN. * 6 READ DATA. * 3 EXTENDED (ASCII 6/12) MODE. * 2 TEXT MODE. * 1 AUTO MODE. * 0 TAPE MODE. * * DC+1 = CONTROL FIELDS - * * BIT DESCRIPTION * --- ----------- * 7-3 USER DELAY COUNT. * 2-0 FWA IN OUTPUT POT. * * DC+3 = ACCESS CONTROL - * * BIT DESCRIPTION * --- ----------- * 10 NO TIME-OUT. * * DC+4 = INTERLOCK BYTE. IF NONZERO, ONLY *1TM* * MAY MODIFY *VDCT*. IF ZERO, ONLY *RDF* * MAY MODIFY *VDCT*. * = 12/ DRIVER REQUEST IF BIT 2**11 OF BYTE * 0 IS SET, * = 12/ OUTPUT POT IF BIT 2**11 OF BYTE * 0 IS NOT SET. VSTT SPACE 4,15 ** TERMINAL TABLE WORD *VSTT*. * * NOTE - ONLY THOSE FIELDS REFERENCED BY *1TM* * ARE DESCRIBED. * *T 12/ST, 12/ST+1, 12/ST+2, 12/ST+3, 12/ST+4 * * ST = FLAG BITS - * * BIT DESCRIPTION * --- ----------- * 8 DETACH IN PROGRESS. * 0 LOGOUT IN PROGRESS. TITLE DEFINITION COMMON DECKS. ITM SPACE 4,10 ** DEFINE *QUAL* BLOCK ORDER. QUAL CTL CONTROL BLOCK QUAL RDM READ MODE QUAL WTM WRITE MODE QUAL TRN TRANSLATION TABLES QUAL TLX DRIVER-TO-EXECUTIVE FUNCTIONS QUAL 1TD EXECUTIVE-TO-DRIVER FUNCTIONS QUAL MACRO$ MACRO CALLS QUAL ITM SPACE 4,10 ** DEFINITION COMMON DECKS. *CALL COMPMAC *CALL COMPMRM *CALL COMSCPS *CALL COMSIOU *CALL COMSPIM *CALL COMSREM *CALL COMSSSD *CALL COMSTCM LIST X *CALL COMSTDR LIST * TITLE MACRO DEFINITIONS. ADCM SPACE 4,10 ** ADCM - GENERATE ADD CONSTANT MACRO. * * ADCM OPC,TBL * * ENTRY *OPC* = MACRO NAME TO BE GENERATED. * *TBL* = TABLE NAME OF ADDRESSES OF MACRO CALLS. * * MACROS MACREF. ADCM MACRO OPC,TBL,INST OPC MACRO CNST LOCAL A MACREF OPC QUAL IFC EQ,$INST$$ A ADC CNST ELSE 1 A INST CNST ENDIF QUAL * TBL RMT CON A TBL RMT OPC ENDM ADCM ENDM * DEFINE MACROS. ADCM ADCRA,TRAA ADCM LDCRA,TRAA,LDC ADCM ADCTR,TTRA ADCM ADCPT,TPTA ADCM ADCPL,TPLA ADCM LDCDQ,TDQA,LDC ADCM LMCDQ,TDQA,LMC ADCM ADCBM,TBMA ADCM LDCTN,TTNA,LDC ASCO SPACE 4,10 ** ASCO - GENERATE MULTIPLEXER OUTPUT FOR *ASCII* CODE. * *NAME ASCO CH,EQU * * ENTRY *NAME* = NAME FOR ASSIGNMENT OF CODE. * *CH* = *ASCII* CHARACTER VALUE IN HEXIDECIMAL. * *EQU* = ASSIGNMENT PSEUDO OP. * * MACROS PAR. MACRO ASCO,A,C,D NOREF .1 PAR 0#_C,0 A D 4000+0#_C+.1*200 ASCO ENDM INASC SPACE 4,10 ** INASC - GENERATE *ASCII* INPUT TRANSLATION. * *CH INASC DPC,PROC * * ENTRY *CH* = *ASCII* CHARACTER VALUE IN HEXIDECIMAL. * *DPC* = DISPLAY CODE VALUE. * *PROC* = SPECIAL PROCESSOR CODE. MACRO INASC,A,C,D NOREF .2,.3 IFC NE,*C** .2 SET D .3 SET C/100 IFNE .3,0,2 .2 SET D CES .3 SET .3/2-74/2 VFD 5/.2,1/.3,6/C-C/100*100 ELSE 2 .2 SET D NLI VFD 5/.2,7/0 INASC ENDM JMP SPACE 4,15 ** JMP - GENERATE THREADED JUMP. * * JMP ADDR * * ENTRY *ADDR* = BRANCH ADDRESS. * * MACROS UJP. JMP MACRO A NOREF ._A .1 IF DEF,._A .2 IFLE *-._A,37B UJN ._A ._A SET *-1 .2 ELSE ._A SET * LJM A .2 ENDIF .1 ELSE ._A SET * UJP A .1 ENDIF JMP ENDM OTASC SPACE 4,10 ** OTASC - GENERATE *ASCII* OUTPUT TRANSLATION. * *DPC OTASC CH,PROC * * ENTRY *CH* = *ASCII* CHARACTER VALUE IN HEXIDECIMAL. * *DPC* = DISPLAY CODE VALUE. * *PROC* = SPECIAL PROCESSOR CODE. * * MACROS ASCO. MACRO OTASC,A,C,D NOREF .2 IFC NE,*C** .2 ASCO C,SET CON .2 ELSE 1 CON D NLO OTASC ENDM PAR SPACE 4,10 ** PAR - GENERATE CHARACTER PARITY BIT. * * PAR CH,OE * * ENTRY *CH* = CHARACTER VALUE. * *OE* = ODD/EVEN (0=EVEN, 1=ODD) * * EXIT *.1* = PARITY. PAR MACRO A,B NOREF .1 P MICRO A+1,1, 011010011001011010010110011010011001011001101001011010011 ,00101101001011001101001011010011001011001101001100101101001011001101001 .1 SET "P"&;B PAR ENDM RETURN SPACE 4,10 ** RETURN - RETURN TO MANAGER TO ADVANCE TERMINAL PROCESSING. * * RETURN ADDR * * ENTRY *ADDR* = NEXT PROCESSSING ADDRESS. IF NULL * OR IF "*", RETURN TO NEXT PROGRAM * ADDRESS. * * MACROS JMP, MACREF. PURGMAC RETURN RETURN MACRO A MACREF RETURN .1 IFC EQ,$A$$ RJM MGR$ .1 ELSE .2 IFC EQ,$A$*$ RJM MGR$ .2 ELSE LDC A JMP MGR= .2 ENDIF .1 ENDIF RETURN ENDM TTADD SPACE 4,10 ** TTADD - GENERATE TERMINAL TABLE ADDRESS. * *TAG TTADD NAM,OPR,TNUM * * ENTRY *NAM* = DESIRED WORD OF TERMINAL TABLE ENTRY. * *OPR* = OPERAND TO LOAD A. (IF NULL *LDD*) * *TNUM* = TAG NAME OF TERMINAL NUMBER. (IF NULL *TN*) * * EXIT (A) = DESIRED ADDRESS. MACRO TTADD,TAG,NAM,OPR,TNUM LOCAL A MACREF TTADD TAG TTAP OPR,TNUM QUAL A ADC NAM QUAL * TTTA RMT CON A TTTA RMT TTADD ENDM TITLE SYMBOLIC EQUIVALENCES. SPACE 4,10 **** DIRECT LOCATION ASSIGNMENTS. DI EQU 16 MULTIPLEXER INPUT DATA DO EQU 17 MULTIPLEXER OUTPUT DATA DP EQU 20 - 24 TERMINAL TABLE WORD *VDPT* * 12/ FIRST POT OF CURRENT LINE * 12/ CURRENT POT OF CURRENT LINE * 12/ CURRENT WORD AND BYTE OF CURRENT POT * 12/ TERMINAL MODE FLAGS * 12/ DRIVER CONTROL ADDRESS CH EQU 25 - 31 TERMINAL TABLE WORD *VCHT* * 12/ TEMPORARY STORAGE * 12/ LINE CHARACTER COUNT * 12/ PARTIALLY PROCESSED CONTROL BYTE * 12/ INPUT CHARACTER COUNT * 12/ OUTPUT CHARACTER COUNT DC EQU 32 - 36 TERMINAL TABLE WORD *VDCT* RN EQU 37 REGISTER NUMBER LF EQU 40 LINE ACTIVITY FLAG F7 EQU 41 START OF *F7* SEQUENCE/NO TIME-OUT = 1 IN EQU 42 - 46 CIRCULAR QUEUE *IN* POINTER PN EQU 47 PORT NUMBER - 0 OR 1 PY EQU 57 PARITY - BIT 2**7 SET IF ODD PARITY RQ EQU 60 - 64 *RDF* REQUEST WORD TN EQU 64 TERMINAL NUMBER EQ EQU 65 EST ORDINAL HS EQU 66 HALF-SECOND FLAG - SET TO 1 FOR ONE DRIVER CYCLE EACH HALF-SECOND IT EQU 67 HALF-SECOND INTERVAL TIMER - DECREMENTED BY 1 EACH HALF-SECOND IF NONZERO ITM SPACE 4,10 ** TIME-OUT VALUES. COTIO EQU 2*2 *CARRIER ON* TIME-OUT (1/2 SECONDS) DSRTIO EQU 2*2 *DATA SET READY* TIME-OUT (1/2 SECONDS) HUPTIO EQU 3*2 HANG-UP-PHONE DELAY (1/2 SECONDS) INATIO EQU 15D*60D INACTIVITY TIME-OUT (SECONDS) LINTIO EQU 5*2 LOGIN TIME-OUT (1/2 SECONDS) NTIO EQU 10D*60D*2 NORMAL TIME-OUT (1/2 SECONDS) RINGTIO EQU 4*2 RING INDICATOR TIME-OUT (1/2 SECONDS) RPATIO EQU 2*2 REGAIN PORT ACCESS TIME-OUT (1/2 SECONDS) UTIO EQU 30D*2 USER NUMBER TIME-OUT (1/2 SECONDS) PRTO EQU 3*60D*10D INITIAL PORT RESERVATION TIME-OUT ITM SPACE 4,10 ** PROGRAM EQUIVALENCES. BDRATE EQU 9600D MAXIMUM BAUD RATE CHRATE EQU BDRATE/10D CHARACTER RATE/SEC LODS EQU 10 OPERATOR DISPLAY BUFFER LENGTH MNCT EQU 1000D/CHRATE MINIMUM CYCLE TIME (MSECS) OMBUFL EQU 37D OPERATOR MESSAGE BUFFER LENGTH RCLDLY EQU 2 PP RECALL DELAY (SECONDS) NRPR EQU 77 DELAY FOR REGAINING PORT ACCESS SPACE 4,10 ** CHARACTER EQUIVALENCES. * INTERNAL CODES. .ICR EQU 210 CARRIAGE RETURN .ILF EQU 211 LINE FEED .INL EQU 212 NEW LINE (CR/LF) .ECP EQU 770001 END OF CURRENT POT * CARRIAGE CONTROL MICROS. CR MICRO 1,, @H CARRIAGE RETURN LF MICRO 1,, @I LINE FEED NL MICRO 1,, @J NEW LINE (CR/LF) * ASCII CHARACTER (7 DATA BITS). .ABRK EQU 0#00 (BRK) BREAK .ACLN EQU 0#3A (CLN) COLON .AESC EQU 0#1B (ESC) ESCAPE .APCT EQU 0#25 (PCT) PERCENT .ASP EQU 0#20 (CR) SPACE * *ASCII* TERMINAL CONTROL CHARACTERS. .CCAN ASCO 18,EQU (CAN) CANCEL (CTL-X) .CCLN ASCO 3A,EQU (CLN) COLON .CCR ASCO 0D,EQU (CR) CARRIAGE RETURN .CDC1 ASCO 11,EQU (DC1) DEVICE CONTOL 1 .CDC4 ASCO 14,EQU (DC4) DEVICE CONTROL 4 .CDEL ASCO 7F,EQU (DEL) DELETE .CLF ASCO 0A,EQU (LF) LINE FEED .CNUL ASCO 00,EQU (NUL) NULL .CPCT ASCO 25,EQU (PCT) PERCENT .CRS ASCO 1E,EQU (RS) RECORD SEPARATOR ITM SPACE 4,10 ** TWO-PORT MULTIPLEXER PORT OPERATING MODE. * * DISABLE PARITY = NOT SELECTED. * NUMBER OF STOP BITS = 1. * NUMBER OF DATA BITS = 7. * PARITY = EVEN. TPMODE EQU 5 SELECT OPERATING MODE **** ITM TITLE GLOBAL DATA STORAGE. FWA SPACE 4,15 ** FWA - DRIVER ENTRY POINT. ORG PPFW FWA UJN FWA1 EXECUTE PRESET ON INITIAL LOAD BSS 1 * SUBR (*2TM* CALL OF *1TM*) FWA1 LJM PRS EXECUTE PRESET * UJN ITM ENTER DRIVER MAIN PROGRAM FWAE EQU * LWA+1 OF ENTRY CODE ITM SPACE 4,10 ** 1TM - GLOBAL DATA STORAGE. ORG FWA OMCC BSS 1 OPERATOR MESSAGE CHARACTER COUNT RDAT BSS 1 REPEATED DATA GLBSE EQU * LWA+1 OF GLOBAL DATA STORAGE ITM SPACE 4,10 CTL MAX FWAE,GLBSE LWA+1 OF ENTRY CODE AND GLOBAL DATA ITM TITLE MAIN CONTROL LOOP. QUAL CTL ORG CTL ITM SPACE 4,20 ** ITM - TWO-PORT MULTIPLEXER DRIVER MAIN CONTROL LOOP. * * SEQUENTIALLY EXECUTES THE MAIN PROCESSES OF THE * MULTIPLEXER DRIVER. * * ENTRY FROM *PRS* - * EQUIPMENT AND CHANNEL RESERVED. * MULTIPLEXER AND PORT SELECTED. * (IR+3) = REAL-TIME CLOCK (SECONDS) AT START * OF DRIVER INACTIVITY TIME-OUT. * (SSMX) = PORT STATUS. * (LF) = SET *ON* FOR INITIAL CONNECT ATTEMPT. * * EXIT TO *RCL* TO RECALL PPU IF NO MULTIPLEXER ACTIVITY. * TO *IMT* TO DROP PPU IF TIMED-OUT. * * CALLS AVT, CAR, CCQ, CEF, CIT, CMF, MGR., RPI, SVM, *3TM*. * * MACROS EXECUTE. ITM BSS 0 DRIVER ENTRY EXECUTE 3TM ITM1 RJM CEF CHECK ERROR FLAG RJM CMF CHECK *RDF* STATUS RJM AVT ADVANCE TIMERS RJM SVM SERVICE MULTIPLEXER RJM MGR. PROCESS TERMINALS RJM CAR CHECK FOR REQUEST OF PORT AND RELEASE NJN ITM2 IF PORT WAS NOT RELEASED STD F7 CLEAR POSSIBLE START OF *F7* SEQUENCE RJM RPI INITIALIZE FOR REGAINING PORT ITM2 RJM CCQ CHECK CIRCULAR QUEUE LDD LF CHECK LINE ACTIVITY FLAG NJN ITM1 IF LINE ACTIVITY * EXIT MAIN CONTROL LOOP. RJM CIT CHECK INACTIVITY TIME-OUT NJN ITM3 IF TIMED-OUT LJM RCL RECALL PPU * THE DRIVER HAS TIMED OUT BECAUSE OF NO LINE * ACTIVITY. ERROR LOG AND DAYFILE MESSAGES WILL BE * ISSUED AND THE PP WILL BE DROPPED WITHOUT RECALL. ITM3 LDN MTIO+40 * RDF TIME-OUT.* JMP IMT ISSUE MESSAGES AND TERMINATE MGR TITLE MGR - TERMINAL MANAGER. MGR SPACE 4,20 ** MGR - TERMINAL MANAGER. * * THE TERMINAL MANAGER PERFORMS THE STATUS CHECKS UPON THE * PORT AND EXECUTES THE REENTRANT PROCESSOR FOR THE LINE. * * ENTRY (DP+4) = REENTRANT PROCESSING ADDRESS. * (SSMX) = PORT STATUS. * (DI) = TERMINAL INPUT. * (DO) = TERMINAL OUTPUT. * * EXIT TO (DP+4) - * (A) = INPUT DATA. * (DI) = INPUT DATA. * (DC - DC+4) = TERMINAL TABLE WORD *VDCT*. * TO *CIS* IF INPUT RECEIVED WHILE IN *WRITE* MODE. * TO *OFL* IF TERMINAL DROPS OFF LINE. * * CALLS STA. MGR. SUBR ENTRY/EXIT LDM SSMX GET PORT STATUS SHN 21-2 MJN MGR1 IF ON-LINE (CARRIER ON) * CHECK STATUS OF OFF-LINE TERMINAL. LDD DP+4 CHECK PROCESSOR ADDRESS SBK LINPE MJN MGR2 IF LINE PROCESSING LJM OFL SET TERMINAL OFF-LINE * PROCESS ON-LINE TERMINAL. MGR1 LDD DI CHECK INPUT DATA NJN MGR3 IF INPUT RECEIVED LDD DO CHECK OUTPUT SHN 21-13 PJN MGR2 IF NO OUTPUT IN BUFFER LDD DP+4 CHECK PROCESSING ADDRESS SBK WTM PJN MGR.X IF IN *WRITE* MODE * ENTER TERMINAL PROCESSING ROUTINE. MGR2 RJM STA SET FWA OF TERMINAL TABLE ADN VDCT READ *VDCT* CRD DC LDD DI GET INPUT DATA LJM 0,DP+4 ENTER PROCESSING ROUTINE * CHECK INPUT RECEIVED. MGR3 LDD DP+4 CHECK PROCESSING ADDRESS SBK WTM MJN MGR2 IF NOT IN *WRITE* MODE LJM CIS CHECK INTERRUPT STATUS MGR SPACE 4,15 ** MGR - RETURNS FROM REENTRY PROCESSORS. MGR SPACE 4,15 ** MGR$ - RETURN FROM *RETURN* MACRO (NULL OR * ADDRESS FIELD). * * ENTRY (MGR$) = REENTRY ADDRESS. MGR$ CON 0 (REENTRY ADDRESS) LDM MGR$ GET REENTRY ADDRESS * UJN MGR= SET REENTRY ADDRESS MGR= SPACE 4,15 ** MGR= - RETURN FROM *RETURN ADDR* MACRO. * * ENTRY (A) = REENTRY ADDRESS. MGR= STD DP+4 SET REENTRY ADDRESS * UJN MGR WRITE TERMINAL TABLE WORDS AND EXIT MGR SPACE 4,15 ** MGR - RETURN WITH NO CHANGE OF REENTRY ADDRESS. * * ENTRY (DP+4) = REENTRY ADDRESS. MGR RJM STA SET FWA OF TERMINAL TABLE ADN VDPT WRITE *VDPT* AND *VCHT* TO CM CWD DP ADK VCHT-VDPT CWD CH UJP MGR.X EXIT FROM MANAGER ITM TITLE CTL - LINE PROCESSING ROUTINES. DIN SPACE 4,25 ** DIN - PROCESS PORT DIALED-IN. * * WAITS FOR TERMINAL OPERATOR TO IDENTIFY TERMINAL, * THEN NOTIFIES *RDF* THAT THE TERMINAL HAS DIALED * IN AND REQUESTS LOGIN PROCESSING. * * ENTRY (A) = INPUT DATA. * (DP+4) = *DIN*. * * EXIT TO *LIN* TO PROCESS LOGIN - * ERROR LOG MESSAGE ISSUED. * *CAN* ISSUED TO CLEAR SCREEN. * (CH - CH+4) = 0. * (DP - DP+2) = 0. * (DP+3) = *BLKEDIT* OR *TTY* SET. * (IR+3) = CURRENT REAL-TIME CLOCK (SECONDS). * TO *MGR* IF TERMINAL FAILS TO INITIATE LOGIN. * (LF) = ZERO TO FORCE DRIVER DROP. * * USES IT, T7. * * CALLS DFM, ERQ. * * MACROS RETURN. DIN BSS 0 ENTRY LDD DC CHECK *VDCT* TERMINAL STATUS NJP MGR IF LAST USER NOT OFF, RETURN RJM SPA RJM CTM CLEAR TERMINAL RJM RMA LDK LINTIO SET LOGIN TIME-OUT STD IT RETURN * REENTER NJN DIN1 IF INPUT RECEIVED LDD IT GET TIMER STD LF SET/CLEAR LINE ACTIVITY FLAG JMP MGR EXIT/REENTER * CHECK INPUT FOR TERMINAL TYPE INDICATOR. * * ENTRY (A) = INPUT DATA. * (DI) = INPUT DATA. DIN1 LPC 177 MASK CHARACTER STD T7 LDN ZERL CLEAR DIRECT CELLS CRD CH CRD DP LDN /TLX/DIN REQUEST DIAL-IN PROCESSING RJM ERQ LDM TINT,T7 TRANSLATE INPUT CHARACTER LPN 77 LMN 1RB NJN DIN2 IF NOT *B* LDC 200 SET *BLKEDIT* TERMINAL TYPE RAD DP+3 DIN2 LDC =C* RDF INITIATED.*+ERLN RJM DFM ISSUE ERROR LOG MESSAGE LDC .CCAN ISSUE *CAN* TO CLEAR SCREEN LMD PY TOGGLE ODD PARITY STD DO RETURN LIN PROCESS LOGIN HUP SPACE 4,25 ** HUP - HANG UP PHONE LINE. * * ISSUES *DC4* TO TERMINATE SESSION IF *PACER* * TERMINAL. DISCONNECTS THE COMMUNICATIONS LINE * TO TERMINATE THE CONNECTION. * * EXIT TO *MGR* TO DROP/RECALL DRIVER - * *DC4* ISSUED IF *PACER* TERMINAL. * MULTIPLEXER CLEARED IF PORT IS NEITHER BEING * REQUESTED NOR RE-REQUESTED. * TERMINAL TABLE CLEANED UP. * (IR+3) = CURRENT REAL-TIME CLOCK (SECONDS). * (DP) = 0. * (LF) = ZERO TO FORCE DROP/RECALL. * * USES IT. * * CALLS AMA, CUT, ERQ, IFN, RPI, RMA, SAT. * * MACROS RETURN. HUP BSS 0 ENTRY * ISSUE *DC4* TO TERMINATE SESSION IF *PACER* TERMINAL. LDC .CDC4 ISSUE *DC4* LMD PY TOGGLE ODD PARITY STD DO * DELAY TO ALLOW OUTPUT BUFFER TO CLEAR. LDK HUPTIO SET DELAY STD IT RETURN * REENTER LDD IT CHECK TIMER ZJN HUP1 IF DELAY COMPLETE JMP MGR REENTER * DISCONNECT COMMUNICATIONS LINE IF IT IS NOT BEING * RE-REQUESTED BY ANOTHER DRIVER. HUP1 RJM CRR CHECK RE-REQUESTED AND REQUESTED STD T7 SAVE STATUS NJN HUP2 IF ANOTHER PROCESSOR NEEDS PORT RJM AMA ACQUIRE MULTIPLEXER ACCESS LDK MXMC CLEAR MULTIPLEXER I/O BUFFERS RJM IFN LDK MXDR CLEAR *DATA TERMINAL READY* RJM IFN LDK MXRTS CLEAR *REQUEST TO SEND* RJM IFN RJM RMA RELEASE MULTIPLEXER ACCESS * DROP POTS AND CLEAN UP TERMINAL TABLE. HUP2 LDD DP CHECK IF POTS ASSIGNED ZJN HUP3 IF NO POTS ASSIGNED STD RQ+3 DROP POTS LDN /TLX/DRT RJM ERQ HUP3 STD DP CLEAR POT POINTER STD LF CLEAR LINE ACTIVITY FLAG RJM CUT CLEAN UP TERMINAL TABLE LDD T7 RE-REQUESTED AND REQUESTED STATUS ZJN HUP4 IF ANOTHER PROCESSOR DOES NOT NEED PORT RJM RTD RELEASE MULTIPLEXER AND DELAY LDC ONL SET REENTRY ADDRESS STD DP+4 RJM RPI INITIALIZE FOR REGAINING PORT ACCESS HUP4 RJM SAT SET ACTIVITY TIMER JMP MGR EXIT TO MANAGER OFL SPACE 4,15 ** OFL - PROCESS USER OFF LINE. * * DROPS ALL POTS ASSOCIATED WITH THE TERMINAL AND NOTIFIES * *RDF* TO LOGICALLY DISCONNECT THE TERMINAL. * * EXIT TO *MGR* FORCE DRIVER DROP/RECALL - * ERROR LOG MESSAGE ISSUED. * (LF) = ZERO TO FORCE DRIVER DROP/RECALL. * (DP) = 0. * * CALLS DFM, ERQ. OFL BSS 0 ENTRY LDC =C* RDF CARRIER LOST.*+ERLN RJM DFM ISSUE ERROR LOG MESSAGE LDD DP SET ASSIGNED POTS TO BE DROPPED STD RQ+3 LDN /TLX/HUP REQUEST HUNG UP PHONE PROCESSING RJM ERQ STD DP CLEAR POT POINTER UJP HUP DISCONNECT LINE ONL SPACE 4,25 ** ONL - WAIT FOR TERMINAL TO COME ON-LINE. * * WAITS FOR INDICATION THAT THE MULTIPLEXER PORT * HAS CONNECTED TO AN ACTIVE LINE, THEN PROCESSES * THE INTERFACE PROTOCOL. *ONL* EXITS TO *DIN* FOR * DIAL-IN WHEN THE CONNECTION HAS BEEN ESTABLISHED * AND WHEN THE TERMINAL OPERATOR ENTERS A CHARACTER * (ANY CHARACTER IS ACCEPTED) TO INITIATE LOGIN. * * ENTRY (LF) = NONZERO FOR INITIAL DRIVER ENTRY. * MULTIPLEXER AND PORT SELECTED. * * EXIT TO *DIN* WHEN PORT IS ON-LINE - * (LF) = NONZERO. * TO *MGR* IF PORT DOES NOT COME ON-LINE - * (LF) = ZERO TO FORCE DRIVER DROP/RECALL. * * USES IT. * * CALLS IFN, RMA, SPA. * * MACROS RETURN. ONL BSS 0 ENTRY LDK RINGTIO SET RING TIME-OUT STD IT RETURN * SET REENTRY * WAIT FOR *RING INDICATOR* (DIAL-UP LINE) OR FOR * *CARRIER ON* AND *DATA SET READY* (HARD-WIRED * LINE). LDM SSMX CHECK PORT STATUS SHN 21-0 CHECK *RING INDICATOR* MJN ONL1 IF SET RJM SPA SET PORT ACCESS LDK MXDR+1 SET *DATA TERMINAL READY* RJM IFN RJM RMA LDK DSRTIO SET *DATA SET READY* TIME-OUT STD IT RETURN * LDM SSMX CHECK PORT STATUS LPN 6 CHECK *CARRIER ON* & *DATA SET READY* LMN 6 NJP ONL3 IF NOT *DATA SET READY* AND *CARRIER ON* * SET *DATA TERMINAL READY* AND WAIT FOR *DATA SET READY*. ONL1 RJM SPA LDK MXDR+1 SET *DATA TERMINAL READY* RJM IFN RJM RMA LDK DSRTIO SET *DATA SET READY* TIME-OUT STD IT RETURN * SET REENTRY LDM SSMX CHECK PORT STATUS LPN 2 ZJN ONL3 IF NOT *DATA SET READY* * SET *REQUEST TO SEND* AND WAIT FOR *CARRIER ON*. RJM SPA LDK MXRTS+1 ISSUE *REQUEST TO SEND* RJM IFN RJM RMA LDK COTIO SET *CARRIER ON* TIME-OUT STD IT RETURN * SET REENTRY LDM SSMX CHECK PORT STATUS LPN 4 ZJN ONL3 IF NOT *CARRIER ON* * TERMINAL IS ON-LINE. EXIT TO DIAL-IN PROCESSOR. RETURN DIN ENTER DIAL-IN PROCESSOR * TERMINAL HAS FAILED TO RESPOND. EXIT TO MANAGER * FOR REENTRY OR DRIVER DROP/RECALL. * * EXIT (LF) = (IT). IF ZERO, THE LINE FUNCTION HAS * TIMED-OUT AND THE DRIVER WILL BE FORCED * TO DROP/RECALL. ONL3 LDD IT SET/CLEAR LINE ACTIVITY STD LF JMP MGR REENTER RPA SPACE 4,15 ** RPA - REGAIN PORT ACCESS. * * ENTRY (NT) = 0, IF TIME-OUT ALLOWED. * = 1, IF NO TIME-OUT. * (IT) = DELAY IF (NT) = 0. * WAIT *DELAY* SECONDS BEFORE PP RECALL OR * TIME-OUT CHECK. * (RPAA) = REENTRY ADDRESS WHEN ACCESS OBTAINED. * * USES F7, LF. * * CALLS CTM, IFN, RMA, STM. RPA BSS 0 ENTRY RPA1 RETURN * SOM RPAC NJN RPA1 IF DELAY PERIOD NOT YET EXPIRED LDK NRPR STM RPAC RESET DELAY PERIOD RJM STM SELECT TERMINAL ON MUX NJN RPA2 IF PORT RESERVED LDD F7 NJN RPA1 IF NO TIME-OUT LDD IT SET/CLEAR LINE ACTIVITY STD LF UJN RPA1 RETURN * INITIALIZE MULTIPLEXER AND TERMINAL. RPA2 LDK MXSM+TPMODE SET PORT OPERATING MODE RJM IFN LDK MXMC CLEAR PORT I/O BUFFERS RJM IFN RJM CTM CLEAR TERMINAL RJM RMA RELEASE MULTIPLEXER ACCESS LDN 77 STD LF LDN 0 SET NO TIME-OUT STD F7 LDC ONL SET NEXT REENTRY ADDRESS RPAA EQU *-1 JMP MGR= SET REENTRY ADDRESS RPAC CON NRPR DELAY PERIOD COUNTER RPI SPACE 4,15 ** RPI - REGAIN PORT ACCESS INITIALIZATION. * * ENTRY (DP+4) = CURRENT REENTRY ADDRESS. * * EXIT (DP+4) = NEW REENTRY ADDRESS. * (IT) = DELAY IF (F7) = 0. * WAIT *DELAY* SECONDS BEFORE PP RECALL OR * TIME-OUT CHECK. * (F7) = 1, IF IN MIDDLE OF RDF SESSION. * (RPAA) = (DP+4) ON ENTRY IF (F7) HAS BEEN SET TO 1, * OTHERWISE, IT IS SET TO /CTL/ONL. * * USES F7, IT. RPI SUBR ENTRY/EXIT LDD DP+4 SBK LINPE MJN RPI3 IF LINE PROCESSING * INITIALIZE *RPA* TO NOT GIVE UP THE PP. RPI1 LDN 1 NO TIME-OUT SELECTED STD F7 LDD DP+4 SAVE CURRENT RE-ENTRY ADDRESS RPI2 STM RPAA LDC RPA NEW REENTRY IS *RPA* STD DP+4 UJN RPIX RETURN * CHECK FOR *HUP* PROCESSING. RPI3 ADC LINPE-HUP MJN RPI4 IF NOT IN *HUP* SBK HUP3-HUP MJN RPI1 IF IN *HUP* * INITIALIZE *RPA* TO TIME-OUT AND RECALL PP. RPI4 LDK RPATIO SET TIME-OUT BEFORE RECALL/DROP STD IT LDC ONL UJN RPI2 SET REENTRY SPACE 4 LINPE BSS 0 END OF LINE PROCESSING ITM TITLE CTL - TERMINAL CONTROL ROUTINES. CIS SPACE 4,25 ** CIS - CHECK INTERRUPT STATUS. * * CIS DETERMINES THE STATUS OF A SUSPECTED INTERRUPT INPUT * CHARACTER. THE CHARACTER *S* IS A LEVEL 0 INTERRUPT TO * *RDF*. AN *INTERRUPT* AND THE CHARACTER *I* ARE LEVEL 1 * INTERRUPTS TO *RDF*. * * ENTRY (A) = INPUT DATA. * (DI) = INPUT DATA. * (DP+4) = PROCESSING ADDRESS. * * EXIT TO *MGR* IF INTERRUPT IGNORED. * TO *INT* IF INTERRUPT - * (A) = *TIET* IF *BREAK* OR *I* KEY. * = *TAET* IF *S* KEY. * TO *AWT* IF TERMINAL MESSAGE IN PROGRESS. * * USES (CH) = BREAK TIMER. * * MACROS RETURN. CIS BSS 0 ENTRY LDD DP+1 CHECK FOR TERMINAL MESSAGE SHN -6 LMN 77 NJN CIS1 IF NOT ISSUING MESSAGE LJM /WTM/AWT CONTINUE TERMINAL OUTPUT CIS1 LDD DC CHECK TERMINAL STATUS SHN 21-11 CHECK *LOGGED IN* BIT PJN CIS5 IF NOT LOGGED IN, IGNORE CHARACTER * PROCESS ASCII *BRK* CHARACTER. LDD DI CHECK INPUT CHARACTER LPC 177 LMK .ABRK NJN CIS4 IF NOT START OF BREAK CIS2 LDK 100D/MNCT+1 START TIMER FOR BREAK STD CH CIS3 RETURN * REENTER NJN CIS2 IF BREAK STILL IN PROGRESS SOD CH DECREMENT TIMER NJN CIS3 IF NOT TIMED-OUT UJN CIS6 PROCESS AS INTERRUPT * PROCESS CHARACTER OTHER THAN ASCII *BRK*. CIS4 STD T7 TRANSLATE INPUT CHARACTER LDM TINT,T7 LPN 77 LMN 1RS ZJP CIS7 IF *S* KEY LMN 1RI&1RS ZJP CIS6 IF *I* KEY CIS5 JMP MGR IGNORE INVALID CHARACTER * PROCESS INTERRUPT CHARACTER. CIS6 LDN TIET&TAET SET *TIET* INTERRUPT CODE CIS7 LMN TAET SET *TAET* INTERRUPT CODE LJM INT ENTER INTERRUPT CTO SPACE 4,20 ** CTO - CHECK TIME-OUT. * * *CTO* IS ENTERED WHEN AN INPUT CHARACTER HAS NOT BEEN * RECEIVED FROM A TERMINAL. THE ELAPSED TIME IS CHECKED, AND * IF EXCEEDED, THE USER IS LOGGED OFF. * * ENTRY (DP+4) = PROCESSING ADDRESS. * * EXIT TO *MGR* IF TIME NOT ELAPSED. * TO *RWC* IF TIMED-OUT - * TIME-OUT LOGOUT REQUEST ENTERED. * SOURCE DUMP FORCED IF READ ACTIVE. * TO *TFR* IF FUNCTION REQUEST FROM EXECUTIVE. * TO *RWC* IF OUTPUT ASSIGNED - * (DP+2) = 0. * * USES DO, CM - CM+4. * * CALLS ERQ, STA. CTO BSS 0 ENTRY LDD DO CHECK OUTPUT BUFFER SHN 21-13 MJN CTO1 IF OUTPUT DATA LDD HS CHECK HALF-SECOND FLAG ZJN CTO1 IF HALF-SECOND NOT ELAPSED RAD DO ADVANCE TIMER LMC NTIO ZJN CTO2 IF NORMAL TIME-OUT ELAPSED RJM STA SET FWA OF TERMINAL TABLE ADN VROT READ *VROT* CRD CM LDD CM+4 CHECK JOB STATUS LPN 1 NJN CTO3 IF JOB NOT ACTIVE STD DO CLEAR TIMER CTO1 JMP MGR EXIT * CHECK FOR *NO TIME-OUT*. CTO2 LDD DC+3 CHECK USER ACCESS SHN 21-12 CHECK NO-TIME-OUT BIT PJN CTO4 IF NOT SET LDN 0 STD DO CLEAR TIMER UJN CTO1 EXIT * PROCESS INACTIVE JOB. CTO3 LDD DC+4 CHECK MESSAGE ASSIGNMENT NJN CTO6 IF MESSAGE ASSIGNED LDD DC CHECK *LOGGED IN* SHN 21-11 MJN CTO1 IF SET LDD DO CHECK TIMER LMC UTIO NJN CTO1 IF LOGIN TIME-OUT NOT ELAPSED * LOG OFF USER. CTO4 LDC CTO5 SET REENTRY ADDRESS UJN CTO8 FORCE SOURCE INPUT DUMP CTO5 LDN /TLX/TOT REQUEST TIME-OUT LOGOUT RJM ERQ STD DP+2 CLEAR READ STATUS JMP RWC ENTER READ/WRITE CONTROL * CHECK FOR FUNCTION REQUEST. CTO6 LDD DC CHECK MESSAGE TYPE SHN 21-13 PJN CTO7 IF NOT FUNCTION REQUEST LJM TFR PROCESS *RDF* FUNCTION REQUEST CTO7 LDC RWC SET REENTRY ADDRESS * FORCE SOURCE DUMP IF READ ACTIVE. * * ENTRY (A) = REENTRY ADDRESS. CTO8 STD DP+4 SET REENTRY ADDRESS LDD DP+2 GET INPUT STATUS SHN 21-10 PJN CTO9 IF INPUT NOT INITIATED LPN 7 SET POT LENGTH LMN 40 SET FORCED DUMP FLAG STD RQ+1 LDD DP SET FIRST, CURRENT POT STD RQ+2 STD RQ+3 LDN /TLX/RIN REQUEST SOURCE INPUT DUMP RJM ERQ STD DP CLEAR POINTERS STD DP+2 CTO9 JMP MGR RETURN TO MANAGER INT SPACE 4,20 ** INT - PROCESS INTERRUPT. * * *INT* REQUESTS *RDF* TO TERMINATE OUTPUT AND THE USER * PROGRAM IN RESPONSE TO AN INTERRUPT FROM THE TERMINAL. * * ENTRY (A) = INTERRUPT CODE- * = *TIET* IF *I* KEY OR *BREAK*. * = *TAET* IF *S* KEY. * * EXIT TO *RWC* IF HANG-UP-PHONE REQUIRED. * TO *SUS* TO SUSPEND TERMINAL AFTER INTERRUPT - * (DP) = 0. * * USES T7, CM - CM+4. * * CALLS ERQ, STA. INT BSS 0 ENTRY STD T7 SAVE INTERRUPT CODE RJM STA SET FWA OF TERMINAL TABLE ADK VSTT READ *VSTT* CRD CM LDD CM CHECK LOGOUT AND DETACH STATUS LPC 0401 NJN INT1 IF LOGOUT OR DETACH IN PROGRESS LDD DC CHECK FOR DRIVER REQUEST SHN 21-13 PJN INT2 IF NO REQUEST LDD DC+4 CHECK REQUEST LMN /1TD/HUP NJN INT2 IF NOT HANG UP PHONE INT1 UJN RWC ENTER READ/WRITE CONTROL INT2 LDD DP SET POTS TO BE DROPPED STD RQ+3 LDD T7 SET INTERRUPT CODE STD RQ+2 LDN /TLX/PUB PROCESS USER BREAK RJM ERQ STD DP CLEAR POT POINTER LJM SUS SUSPEND TERMINAL LIN SPACE 4,15 ** LIN - PROCESS LOGIN. * * EXIT TO *CLI* WHEN *RDF* RESPONDS TO LOGIN REQUEST - * (DP) = POT ASSIGNMENT. * (DP+1) = (DP). * (VDCT) BYTE 4 = 0. * * CALLS WDC. LIN BSS 0 ENTRY LDD DC CHECK TERMINAL STATUS LMD HN ZJN LIN1 IF *RDF* READY JMP MGR EXIT LIN1 LDD DC+4 SET POT ASSIGNMENT STD DP STD DP+1 LDN 0 CLEAR POT ASSIGNMENT STD DC+4 RJM WDC REWRITE VDCT LJM /RDM/CLI PROCESS COMMAND LINE INPUT RWC SPACE 4,20 ** RWC - READ/WRITE CONTROL. * * ENTRY COMPLETION OF READ OR WRITE OPERATION. * * EXIT TO *RDM* IF INPUT RECEIVED FROM TERMINAL. * TO *WTM* IF MESSAGE ASSIGNED BY *RDF* - * (DP) = OUTPUT POT ASSIGNMENT. * (DP+1) = (DP). * (DP+2) = FIRST WORD INDEX. * (VDCT) BYTE 4 = 0. * TO *TFR* IF FUNCTION REQUEST RECEIVED FROM *RDF*. * TO *CTO* IF TERMINAL IDLE. * * CALLS CEM, ERQ, WDC. * * MACROS RETURN. RWC BSS 0 ENTRY RJM CEM CLEAR EXTENDED MODE * ENTRY TO PREVENT TRANSMISSION MODE CHANGE. * CHECK FOR INPUT FROM TERMINAL. RWC1 RETURN * SET REENTRY LDD DI CHECK FOR INPUT DATA ZJN RWC2 IF NO DATA RECEIVED LJM RDM ENTER READ MODE * CHECK FOR MESSAGE ASSIGNMENT OR FUNCTION REQUEST. RWC2 LDD DC+4 CHECK OUTPUT ASSIGNMENT NJN RWC3 IF MESSAGE ASSIGNED LJM CTO CHECK TIME-OUT RWC3 LDD DC CHECK MESSAGE TYPE SHN 21-13 PJN RWC4 IF NOT FUNCTION REQUEST LJM TFR PROCESS *RDF* FUNCTION REQUEST * PREPARE NEW OUTPUT. RWC4 LDD DP CHECK FIRST POT ZJN RWC5 IF NOT ASSIGNED STD RQ+3 SET POT LDN /TLX/DRT REQUEST DROP POT CHAIN RJM ERQ RWC5 LDD DC+4 CURRENT POT = ASSIGNMENT STD DP STD DP+1 LDD DC+1 CURRENT WORD = FIRST WORD OF ASSIGNMENT LPN 7 SHN 4 STD DP+2 LDD DC+1 CLEAR STARTING WORD SCN 7 STD DC+1 LDN 0 CLEAR ASSIGNMENT STD DC+4 RJM WDC REWRITE VDCT JMP WTM ENTER WRITE MODE SUS SPACE 4,15 ** SUS - SUSPEND DRIVER FOR *RDF* INTERRUPT ACKNOWLEDGE. * * WAITS UNTIL *RDF* SETS THE INTERRUPT ACKNOWLEDGE * BIT IN THE TERMINAL TABLE. * * EXIT TO *RWC* AFTER ACKNOWLEDGE SET - * *VDCT* INTERRUPT ACKNOWLEDGE BIT CLEARED. * TO *MGR.* WITHOUT TERMINAL TABLE WRITE UNTIL INTERRUPT * ACKNOWLEDGE SET. *IAF* CAN WRITE *VDCT* AND *VCHT* * UNTIL THIS TIME. * * CALLS ERQ, STA, WDC. SUS BSS 0 ENTRY LDD DC GET TERMINAL STATUS SHN 21-12 CHECK INTERRUPT ACKNOWLEDGE BIT MJN SUS1 IF SET LDC SUS SET REENTRY ADDRESS STD DP+4 RJM STA SET TERMINAL TABLE ADDRESS ADN VDPT WRITE *VDPT* CWD DP LJM MGR. EXIT WITHOUT TERMINAL TABLE WRITE SUS1 SHN 1 CLEAR INTERRUPT ACKNOWLEDGE BIT SCN 1 SHN 12-0 STD DC RJM WDC REWRITE *VDCT* SBN VDCT-VCHT READ *VCHT* FOR CHARACTER COUNT RECOVERY CRD CH LDD DC+4 CHECK FOR DRIVER ASSIGNMENT NJN SUS2 IF PRESENT LDN /TLX/RES REQUEST NEW ASSIGNMENT RJM ERQ SUS2 JMP RWC ENTER READ/WRITE CONTROL TITLE *RDF* FUNCTION REQUEST PROCESSORS. TFR SPACE 4,15 ** TFR - PROCESS *RDF* FUNCTION REQUEST. * * EXIT TO FUNCTION REQUEST PROCESSOR - * (A) = (DP+3)- * (T3) = FUNCTION REQUEST. * (VDCT) = FUNCTION REQUEST CLEARED. * * USES T1, T2, T3. * * CALLS ERQ, WDC. TFR BSS 0 ENTRY LDD DC+4 SAVE REQUEST CODE STD T3 LPN 77 SBN TTFRL MJN TFR1 IF LEGAL FUNCTION LCN TTFRL SET ILLEGAL FUNCTION TFR1 ADN TTFRL STD T1 LDN /TLX/RES REQUEST ADDITIONAL OUTPUT RJM ERQ STD DC+4 CLEAR FUNCTION REQUEST LDD DC CLEAR DRIVER REQUEST BIT LPC 3777 STD DC RJM WDC WRITE VDCT LDM TTFR,T1 SET FUNCTION PROCESSOR ADDRESS STD T2 NJN TFR2 IF A VALID ENTRY JMP MGR EXIT TFR2 LDD DP+3 SET (A) = TERMINAL MODE FLAGS LJM 0,T2 ENTER PROCESSOR TTFR SPACE 4,10 ** TTFR - TABLE OF *RDF* FUNCTION REQUESTS. TTFR INDEX INDEX /1TD/BGI,BGI BEGIN INPUT INDEX /1TD/CFD,CFD CLEAR FULL DUPLEX INDEX /1TD/HUP,HUP HANG UP THE PHONE INDEX /1TD/IIP,IIP ISSUE INPUT PROMPT INDEX /1TD/LGI,LGI PROCESS LOGIN INDEX /1TD/SCE,SCE SET/CLEAR EXTENDED MODE INDEX /1TD/SDU,SUS SUSPEND DRIVER FOR USER BREAK INDEX /1TD/SEP,SEP SET EVEN PARITY INDEX /1TD/SFD,SFD SET FULL DUPLEX INDEX /1TD/SNM,SNM SET NORMAL MODES INDEX /1TD/SOP,SOP SET ODD PARITY INDEX /1TD/STT,STT SET TERMINAL TYPE INDEX /1TD/REQL TTFRL EQU *-TTFR BGI SPACE 4,15 ** BGI - BEGIN INPUT. * * ISSUES *START TAPE READER* CONTROL CODE IF TERMINAL * IS IN *TAPE* MODE. CONTROL IS THEN TRANSFERRED * TO THE *READ* PROCESSOR. * * ENTRY (DC) = BIT 2**0 SET IF *TAPE* MODE. * * EXIT TO *RDM* - * *DC1* ISSUED IF TERMINAL IN *TAPE* MODE. * * MACROS RETURN. BGI BSS 0 ENTRY LDD DC CHECK FOR *TAPE* MODE LPN 1 ZJN BGI1 IF NOT IN *TAPE* MODE LDC .CDC1 ISSUE *DC1* TO START TAPE READER LMD PY TOGGLE ODD PARITY STD DO BGI1 RETURN RDM ENTER *READ* MODE CFD SPACE 4,15 ** CFD - CLEAR *FULL DUPLEX* FLAG. * * ENTRY (A) = (DP+3). * * EXIT TO *MGR* - * (DP+3) = *FULL DUPLEX* CLEARED. CFD BSS 0 ENTRY LPC 7677 CLEAR *FULL DUPLEX* FLAG STD DP+3 JMP MGR EXIT IIP SPACE 4,20 ** IIP - ISSUE INPUT PROMPT. * * ISSUE INPUT PROMPT CHARACTER IF TRANSPARENT, BINARY, * OR AUTO MODE IS NOT SET. * * ENTRY (A) = (DP+3). * * EXIT TO *WTM* TO ISSUE PROMPT MESSAGE - * PROMPT MESSAGE WRITTEN TO POT. * (DP+2) = 0. * (CH+2) = 0. * TO *RWC* IF *TRANSPARENT*, *AUTO*, OR * *BINARY* MODE. * /TLX/RES EXECUTIVE REQUEST ISSUED. * * USES T0 - T4. * * CALLS ERQ, STA, SWA. IIP BSS 0 ENTRY SHN 21-2 CHECK TERMINAL MODE MJN IIP1 IF *TRANSPARENT* MODE LPN 1 NJN IIP2 IF *BINARY* MODE LDD DC LPN 2 NJN IIP2 IF *AUTO* MODE RJM STA SET FWA OF TERMINAL TABLE ADK VSTT READ *VSTT* CRD T0 LDD T0 CHECK FOR NO-PROMPT MODE LPN 40 NJN IIP2 IF NO-PROMPT MODE STD CH+2 CLEAR ESCAPE CONTROL STD DP+2 CLEAR WORD POINTER RJM SWA SET WORD ADDRESS IN OUTPUT POT CWM IIPA,ON WRITE PROMPT TO POT JMP WTM ENTER WRITE MODE IIP1 LDN 0 CLEAR INPUT POINTER STD DP+2 IIP2 LDN /TLX/RES REQUEST NEXT MESSAGE RJM ERQ JMP RWC WAIT FOR *BGI* REQUEST IIPA DATA 4L? "EB" INPUT PROMPT CON 0,0,0 LGI SPACE 4,15 ** LGI - PROCESS USER LOGIN. * * ENTRY (A) = (DP+3). * * EXIT TO *LIN* TO COMPLETE LOGIN - * (DP - DP+2) = 0. * (CH - CH+4) = 0. * * USES T7. * * CALLS ERQ. * * MACROS RETURN. LGI BSS 0 ENTRY LPC 200 RETAIN *BLKEDIT* TERMINAL TYPE STD T7 LDD DP CHECK POT ASSIGNMENT ZJN LGI1 IF NONE STD RQ+3 DROP POTS LDN /TLX/DRT RJM ERQ LGI1 LDN ZERL CLEAR CONTROL WORDS CRD DP CRD CH LDD T7 RESET TERMINAL TYPE STD DP+3 RETURN LIN ENTER LOGIN SCE SPACE 4,15 ** SCE - SET/CLEAR EXTENDED MODE. * * SET/CLEAR EXTENDED TRANSMISSION MODE DEPENDING * UPON MODE IN *VDCT*. * * CALLS CEM. SCE BSS 0 ENTRY RJM CEM JMP MGR EXIT SEP SPACE 4,15 ** SEP - SET *EVEN* PARITY. * * ENTRY (A) = (DP+3). * * EXIT TO *MGR* - * (DP+3) = PARITY RESET TO *EVEN*. * (PY) = PARITY RESET TO *EVEN*. SEP BSS 0 ENTRY SCN 1 CLEAR *ODD* PARITY FLAG STD DP+3 LDN 0 CLEAR *ODD* PARITY BIT STD PY JMP MGR EXIT SFD SPACE 4,15 ** SFD - SET *FULL DUPLEX* FLAG. * * ENTRY (A) = (DP+3). * * EXIT TO *MGR* - * (DP+3) = *FULL DUPLEX* SET SFD BSS 0 ENTRY LPC 7677 SET FULL-DUPLEX FLAG LMD HN STD DP+3 JMP MGR EXIT SNM SPACE 4,15 ** SNM - SET NORMAL MODES. * * CLEARS EXTENDED MODE AND ODD PARITY. * * ENTRY (A) = (DP+3). * * EXIT TO *SEP* - * (A) = (DP+3), *EXTENDED MODE* CLEARED. SNM BSS 0 ENTRY SCN 2 CLEAR *EXTENDED* MODE JMP SEP SET EVEN PARITY SOP SPACE 4,15 ** SOP - SET *ODD* PARITY. * * ENTRY (A) = (DP+3). * * EXIT TO *MGR* - * (DP+3) = PARITY SET TO *ODD*. * (PY) = PARITY SET TO *ODD*. SOP BSS 0 ENTRY SCN 1 SET *ODD* PARITY FLAG LMN 1 STD DP+3 LDC 1S7 SET *ODD* PARITY BIT STD PY JMP MGR EXIT STT SPACE 4,15 ** STT - SET TERMINAL TYPE. * * SET TERMINAL TYPE TO *BLKEDIT* OR TO *TTY*. * * ENTRY (A) = (DP+3). * (T3) = FUNCTION REQUEST - * = 6/TYPE, 6/. * TYPE = 0 IF *TTY* * = 1 IF *BLKEDIT*. * * EXIT TO *MGR* - * (DP+3) = NEW TERMINAL TYPE. STT BSS 0 ENTRY LPC -200 CLEAR CURRENT TERMINAL TYPE STD DP+3 LDD T3 CHECK TYPE REQUESTED SHN -6 ZJN STT1 IF *TTY* LDC 200 SET *BLKEDIT* RAD DP+3 STT1 JMP MGR EXIT SPACE 4,10 QUAL CTO EQU /CTL/CTO LINPE EQU /CTL/LINPE MGR EQU /CTL/MGR MGR$ EQU /CTL/MGR$ MGR= EQU /CTL/MGR= RWC EQU /CTL/RWC RDM TITLE READ MODE. QUAL RDM RDM SPACE 4,30 ** RDM - READ MODE ENTRY PROCESSOR. * * ENTRY (DP+1) = FIRST POT FOR INPUT LINE. * (DP+2) = 3/FIRST WORD OF LINE, * 1/INPUT INITIATED, * 1/POT REQUESTED, * 3/CURRENT WORD OF LINE, * 4/CURRENT CHARACTER OF LINE. * * FOR SPECIAL INPUT PROCESSING - * (DP+3) *TRANSPARENT INPUT* STATUS. * (DP+3) *BINARY INPUT* STATUS. * * (CH) = BINARY INPUT TERMINATION CHARACTER. * (CH+1) = BINARY INPUT TERMINATION COUNT. * * EXIT TO *ARD* IF *ASCII* FORMAT READ - * (A) = INPUT DATA. * (DI) = INPUT DATA. * (DP+4) = *ARD*. * TO *BRD* IF NOS *BINARY* FORMAT READ - * (A) = INPUT DATA. * (DI) = INPUT DATA. * (DP+4) = *BRD*. * TO *TTM* IF NO INPUT POT AVAILABLE FOR DATA. RDM BSS 0 ENTRY LDD DP CHECK FIRST POT ASSIGNED ZJN RDM4 IF NO INPUT POT LDD DP+3 CHECK BINARY TRANSMISSION SHN 21-3 PJN RDM2 IF NOT SET LDD CH+1 CHECK BINARY COUNT NJN RDM1 IF SET LCN 10 RAD DP+3 CLEAR BINARY MODE UJN RDM2 RDM1 LDC BRD SET BINARY READ UJN RDM3 RDM2 LDC ARD SELECT READ PROCESSOR RDM3 STD DP+4 SET PROCESSOR ADDRESS LDD DI SET (A) = INPUT DATA LJM 0,DP+4 ENTER PROCESSOR * PROCESS LACK OF INPUT POT. IF THE INPUT DATA HAS * NO NEED TO BE TRANSLATED AND STORED IT WILL BE IGNORED. * IF THE DATA IS VALID, A DIAGNOSTIC MESSAGE WILL BE * ISSUED TO THE TERMINAL OPERATOR. RDM4 LDD DI GET INPUT CHARACTER LPC 177 STD T7 LDM TINT,T7 TRANSLATE CHARACTER SHN -7 ZJN RDM5 IF NOT SPECIAL CHARACTER LMN /TRN/NLI NJN RDM5 IF NOT NULL INPUT JMP MGR IGNORE CHARACTER RDM5 LDN RILM *RE-ENTER LAST LINE* LJM TTM ISSUE TERMINAL MESSAGE ARD TITLE READ MODE - *ASCII* READ PROCESSOR. ARD SPACE 4,25 ** ARD - *ASCII* TERMINAL READ. * * PROCESSES INPUT DATA FROM *ASCII* MODE TERMINAL. * * ENTRY (A) = INPUT DATA. * (DI) = INPUT DATA. * (DP+4) = *ARD*. * * EXIT TO *EIC* IF INPUT RECEIVED - * (DI) = INPUT DATA. * (T7) = LOWER 7 BITS OF INPUT. * (DO) = 0 IF NOT FULL DUPLEX. * = INPUT DATA IF FULL DUPLEX. * TO *CTO* IF NO INPUT RECEIVED - * (DP+4) = *ARD*. * TO *DLO* IF LOST-DATA CONDITION ON LINE. * TO PROCESSOR IF SPECIAL CHARACTER RECEIVED. * * USES T1, T2. * * CALLS EMD. ARD BSS 0 ENTRY NJN ARD1 IF CHARACTER RECEIVED LJM CTO CHECK TIME-OUT ARD1 SHN 21-11 CHECK CHARACTER STATUS PJN ARD2 IF NOT LOST DATA LJM DLO PROCESS LOST DATA * ISSUE INPUT TO OUTPUT OR CLEAR (DO), DEPENDING * UPON TERMINAL DUPLEX MODE. ARD2 SHN 11-21 EXTRACT CHARACTER LPC 4377 ASSUME ECHOPLEX MODE STD DO LPC 177 EXTRACT DATA BITS STD T7 RJM EMD ENTER OPERATOR MESSAGE DATA LDD DP+3 CHECK ECHOPLEX MODE LPC 100 NJN ARD3 IF SET STD DO CLEAR OUTPUT * TRANSLATE INPUT CHARACTER. ARD3 LDM TINT,T7 READ TRANSLATION TABLE ENTRY STD T7 SAVE TRANSLATION SHN -7 CHECK FOR SPECIAL PROCESSING NJN ARD5 IF SPECIAL PROCESSING REQUIRED LDD F7 NJN ARD7 IF START OF *F7* SEQUENCE DETECTED ARD4 LJM EIC ENTER INPUT CHARACTER * PROCESS SPECIAL READ CHARACTER. ARD5 STD T1 SET PROCESSOR INDEX LMN /TRN/CLW ZJN ARD6 IF LOWER CASE *W* LDD F7 NJN ARD7 IF START OF *F7* SEQUENCE DETECTED ARD6 LDM TRSP-1,T1 SET PROCESSOR ADDRESS STD T2 LDD DP+3 SET (A) = (DP+3) LJM 0,T2 ENTER PROCESSOR * START OF *F7* SEQUENCE DETECTED BUT NOT FINISHED. * THAT IS, FOLLOWING THE 1E (HEX), A 77 (HEX) WAS NOT * RECEIVED. ARD7 SBN 2 ZJN ARD8 IF PREVIOUS CHARACTER IS SET UP LDD DI CURRENT CHARACTER WILL BE NEXT STM SVMA AOD F7 LDK .CRS PROCESS PREVIOUS CHARACTER STD DI UJP ARD1 EXTRACT CHARACTER ARD8 STD F7 CLEAR *F7* FLAG UJN ARD4 ENTER INPUT CHARACTER TRSP SPACE 4,10 ** TRSP - TABLE OF SPECIAL READ CHARACTER PROCESSORS. TRSP BSS 0 QUAL TRN LOC 1 CES CON /RDM/CES CHECK ESCAPE STATUS CLW CON /RDM/CLW CHECK LOWER CASE *W* CRS CON /RDM/CRS CHECK *RS* CRT CON /RDM/CRT CARRIAGE RETURN DEL CON /RDM/DEL DELETE (RUBOUT) DLN CON /RDM/DLN LINE DELETE DPC CON /RDM/DPC DELETE PREVIOUS CHARACTER EOT CON /RDM/EOT END OF TRANSMISSION NLI CON /RDM/NLI NULL INPUT ECI CON /RDM/ECI ESCAPE CHARACTER INPUT CLN CON /RDM/CLN COLON BRK CON /RDM/BRK BREAK ETX CON /RDM/ETX ETX LOC *O NOREF CES,NLI QUAL * RDM TITLE READ MODE - *BINARY* READ PROCESSOR. BRD SPACE 4,15 ** BRD - BINARY READ PROCESSOR. * * ENTRY (A) = INPUT DATA CHARACTER. * (DI) = INPUT DATA CHARACTER. * (CH) = INPUT TERMINATION CHARACTER. * (CH+1) = INPUT LINE CHARACTER COUNT. * (DP+4) = *BRD*. * * EXIT TO *CLI* TO PROCESS COMMAND LINE. * TO *DLO* IF LOST DATA. * TO *SLI* TO PROCESS SOURCE LINE. * * CALLS ERQ, WDC. BRD BSS 0 ENTRY NJN BRD1 IF INPUT RECEIVED LJM CTO CHECK TIME-OUT BRD1 STD T7 SAVE INPUT CHARACTER SHN 21-11 CHECK *LOST DATA* BIT PJN BRD2 IF *LOST DATA* NOT SET LJM DLO PROCESS DATA LOST BRD2 LDD DP+3 CHECK *FULL DUPLEX* LPC 100 ZJN BRD3 IF NOT SET LDD DI ISSUE INPUT CHARACTER TO OUTPUT LPC 4377 BRD3 STD DO SET/CLEAR OUTPUT BUFFER LDD CH SAVE INPUT TERMINATOR CHARACTER STD CH+2 LDD T7 FORMAT INPUT CHARACTER LPC 4300 STD CH SET UPPER HALF FOR *WIC* LDD T7 SET LOWER HALF FOR *WIC* LPN 77 STD T7 AOD DP+2 ADVANCE INPUT BYTE NUMBER RJM WIC WRITE INPUT CHARACTER AOD CH+3 ADVANCE INPUT CHARACTER COUNT SHN -14 ZJN BRD4 IF NO OVERFLOW STD RQ+2 REQUEST ACCOUNTING MESSAGE LDN /TLX/IAM RJM ERQ BRD4 LDD CH+2 RESTORE TERMINATOR STD CH SHN 6 MJN BRD5 IF NO TERMINATOR SPECIFIED SHN -6 LMD T7 LPC 177 ZJN BRD6 IF TERMINATOR RECIEVED BRD5 SOD CH+1 DECREMENT CHARACTER COUNT SBN 1 MJN BRD6 IF END OF BINARY INPUT JMP MGR RETURN TO MANAGER * TERMINATE BINARY READ OPERATION. BRD6 LDN 0 ENTER END-OF-LINE STD CH STD DO CLEAR OUTPUT STD T7 STD CH+1 CLEAR CHARACTER COUNT STD CH+2 CLEAR ESCAPE CONTROL AOD DP+2 WRITE END OF LINE RJM WIC LCN 10 CLEAR BINARY INPUT RAD DP+3 LDD DC CHECK TERMINAL STATUS SHN 21-6 MJN CLI IF *READ DATA* LJM SLI PROCESS SOURCE LINE INPUT TITLE READ MODE - MAIN ROUTINES. CLI SPACE 4,15 ** CLI - PROCESS COMMAND LINE INPUT. * * TRANSMITS THE COMMAND LINE TO *RDF*. * * CALLS ERQ. * * EXIT TO *RWC* - * (DO) = *LF* IF *TAPE* MODE. * INPUT POTS RELEASED TO EXECUTIVE. * (DP) = 0. CLI BSS 0 ENTRY LDD DP SET FIRST POT OF LINE STD RQ+3 LDD DP+2 SET FIRST WORD SHN -11 STD RQ+2 LDN /TLX/CLI REQUEST COMMAND LINE INPUT RJM ERQ STD DP CLEAR FIRST POT STD DP+2 CLEAR POINTERS LDD DC CHECK TERMINAL STATUS LPN 1 ZJN CLI1 IF NOT IN *TAPE* MODE LDK .CLF ISSUE *LF* TO TERMINAL STD DO CLI1 JMP RWC ENTER READ/WRITE CONTROL DLO SPACE 4,15 ** DLO - PROCESS LOST DATA. * * NOTIFY *RDF* THAT A LOST DATA CONDITION OCCURRED ON THE * TERMINAL LINE. * * EXIT TO *NIP* TO PROCESS LOST DATA - * (RQ+2) = 1. DLO BSS 0 ENTRY LDN 1 SET LOST-DATA BIT STD RQ+2 LJM NIP PROCESS LOST DATA EIC SPACE 4,20 ** EIC - ENTER INPUT CHARACTER. * * ENTERS INPUT CHARACTER IN INPUT AND COUNTS CHARACTER. * IF THE LINE CHARACTER COUNT EXCEEDS THE MAXIMUM, AN * OVERFLOW MESSAGE WILL BE ISSUED. * * ENTRY (T7) = CHARACTER TO BE ENTERED. * (DP+4) = *ARD*. * * EXIT TO *MGR* IF NO OVERFLOW - * (CH+1) = LINE CHARACTER COUNT INCREMENTED. * TO *TTM* IF LINE OVERFLOW. * * CALLS WIC. EIC BSS 0 ENTRY RJM WIC WRITE INPUT CHARACTER TO INPUT POT AOD CH+1 INCREMENT LINE CHARACTER COUNT SBK VXLL PJN EIC1 IF LINE OVERFLOW JMP MGR REENTER ASCII READ PROCESSOR * PROCESS INPUT LINE OVERFLOW. EIC1 LDN LOFM SET MESSAGE POINTER LJM TTM ISSUE TERMINAL MESSAGE EIL SPACE 4,15 ** EIL - END OF INPUT LINE. * * TERMINATES INPUT FOR THE CURRENT LINE AND CALLS * THE APPROPRIATE END OF LINE PROCESSOR. * * EXIT (CH+1) = 0. * (CH+2) = 0. * (DP+3) = *TRANSPARENT* MODE CLEARED. * TO *CLI* IF COMMAND LINE INPUT. * TO *RDM* IF OPERATOR MESSAGE ISSUED. * TO *SLI* IF SOURCE LINE INPUT. * * CALLS EOM, ERQ, RPC, WIC. * * MACROS ADCBM. EIL BSS 0 ENTRY RJM EOM ENTER OPERATOR MESSAGE LDD DP+2 CHECK CHARACTER POSITION LPN 1 NJN EIL1 IF LOWER CHARACTER * ENTER *BLANK* AS UPPER CHARACTER IF PREVIOUS CHARACTER * IS A *COLON* (00). LDD CH+1 CHECK LINE CHARACTER COUNT ZJN EIL3 IF START OF LINE LDD MA SAVE POINTER WORD CWD DP RJM RPC READ PRECEDING CHARACTER STD T7 LDD MA RESTORE POINTER WORD CRD DP LDD T7 CHECK PRECEDING CHARACTER NJN EIL3 IF NOT COLON LDN 1R ENTER BLANK STD T7 RJM WIC * ENTER *BLANK* AS LOWER CHARACTER IF NOT IN *TRANSPARENT* * MODE, ELSE ENTER NULL (00). EIL1 LDD DP+3 CHECK FOR TRANSPARENT MODE LPN 4 ZJN EIL2 IF NOT TRANSPARENT MODE LDN 1R EIL2 LMN 1R STD T7 RJM WIC * ENTER NULL (00) AS UPPER CHARACTER TO FORCE END-OF-LINE. EIL3 LDN 0 ENTER END OF LINE STD T7 RJM WIC LDD DP+3 CLEAR *TRANSPARENT* MODE SCN 4 STD DP+3 * COMPLETE END OF LINE PROCESSING. LDD CH+1 ADVANCE INPUT CHARACTER COUNT RAD CH+3 SHN -14 ZJN EIL4 IF NO OVERFLOW STD RQ+2 LDN /TLX/IAM REQUEST ISSUE ACCOUNTING MESSAGE RJM ERQ EIL4 STD CH+1 CLEAR INPUT LINE CHARACTER COUNT STD CH+2 CLEAR ESCAPE CONTROL LDD DC CHECK TERMINAL STATUS SHN 21-6 MJN EIL6 IF *READ DATA*, PROCESS AS COMMAND SHN 6-2 MJN EIL5 IF *TEXT* MODE, PROCESS AS SOURCE LDD DP+2 READ FIRST WORD OF LINE LPC 7000 SHN 6 ADD DP SHN 3 ADCBM CRD CM LDD CM CHECK FIRST CHARACTER SHN -6 SBN 1R0 MJN EIL6 IF NOT DIGIT SBN 1R9+1-1R0 EIL5 MJN SLI IF DIGIT EIL6 LJM CLI PROCESS COMMAND LINE ESC SPACE 4,20 ** ESC - PROCESS ESCAPE CODES. * * ENTERS UPPER AND LOWER HALVES OF ESCAPE * CHARACTER (74XX OR 76XX). * * ENTRY (T7) = ESCAPE CODE CHARACTER. * BIT 2**6 SET IF ESCAPE 1 (76XX). * BIT 2**6 CLEAR IF ESCAPE 2 (74XX). * (DP+4) = *ARD*. * * EXIT ESCAPE CODE WRITTEN TO INPUT POT. * TO *EIC* TO COMPLETE LOWER 6 BITS OF CHARACTER - * (T7) = CHARACTER. * * USES CH+2. * * CALLS WIC. ESC BSS 0 ENTRY LDD T7 SAVE CHARACTER STD CH+2 SHN -5 SET PROPER ESCAPE CODE LPN 2 ADN 74 STD T7 RJM WIC WRITE ESCAPE CODE LDD CH+2 SET DISPLAY CODE LPC 177 PRESERVE ESCAPE BIAS STD T7 JMP EIC ENTER REMAINDER OF CHARACTER NIP SPACE 4,15 ** NIP - NO INPUT POT AVAILABLE. * * NOTIFY *RDF* THAT NO INPUT WAS AVAILABLE AND * ISSUE *RE-ENTER LAST LINE* MESSAGE TO TERMINAL. * * ENTRY (RQ+2) = 0 IF NO INPUT POT AVAILABLE. * = 1 IF DATA LOST ON LINE. * * EXIT TO *TTM* TO ISSUE MESSAGE. * * CALLS ERQ. NIP BSS 0 ENTRY LDN /TLX/DLO REQUEST LOST DATA PROCESSING RJM ERQ LDN RILM SET RE-ENTER LINE MESSAGE LJM TTM ISSUE TERMINAL MESSAGE SLI SPACE 4,15 ** SLI - SOURCE LINE INPUT. * * TRANSMITS FIRST POT OF DATA TO EXECUTIVE AS SOURCE * INPUT IF MORE THAN ONE POT OF SOURCE LINE(S). * * EXIT TO *ARD* TO WAIT FOR ADDITIONAL INPUT - * DATA TRANSMITTED TO EXECUTIVE AS SOURCE INPUT. * * CALLS RIN. * * MACROS RETURN. SLI BSS 0 ENTRY LDD DP+2 SAVE *POT REQUESTED* FLAG LPC 360 LMC 400 SET *INPUT INITIATED* STD DP+2 SHN 5 RAD DP+2 RJM RIN RELEASE INPUT DATA RETURN ARD REENTER READ PROCESSOR TITLE READ MODE - SPECIAL CHARACTER PROCESSORS. BRK SPACE 4,20 ** BRK - PROCESS BREAK. * * (1) IGNORE BREAK IF IN *TAPE* MODE. * (2) INTERRUPT JOB IF ACTIVE. * (3) DELETE LINE IF INPUT ACTIVE AND IF NOT * IN *TRANSPARENT* MODE. * (4) ENTER *BRK* CHARACTER AND TERMINATE LINE * IF IN *TRANSPARENT* MODE. * (5) EXIT FROM *TEXT* MODE IF IN *TEXT* MODE. * * EXIT TO *RDM* IF IN *TAPE* MODE. * TO */CTL/INT* TO INTERRUPT JOB. * TO *TTM* TO ISSUE *DEL* MESSAGE. * TO *EIL* TO TERMINATE INPUT LINE. * TO *ETX2* TO EXIT FROM *TEXT* MODE. * * CALLS STA, WIC. * * MACROS RETURN. BRK BSS 0 ENTRY LDD DC CHECK TERMINAL STATUS LPN 1 ZJN BRK1 IF NOT IN *TAPE* MODE JMP RDM IGNORE CHARACTER BRK1 LDK 100D/MNCT+1 START TIMER FOR BREAK STD DO BRK2 RETURN * REENTER NJN BRK1 IF BREAK STILL IN PROGRESS SOD DO NJN BRK2 IF NOT TIMED-OUT LDD CH+1 CHECK INPUT LINE NJN BRK4 IF LINE NOT EMPTY * PROCESS EMPTY INPUT LINE. LDD DC CHECK TERMINAL STATUS LPN 4 ZJN BRK3 IF NOT *TEXT* MODE LJM ETX2 EXIT *TEXT* MODE * INTERRUPT JOB IF ACTIVE. BRK3 RJM STA SET FWA OF TERMINAL TABLE ADN VROT READ *VROT* CRD CM LDD CM+4 CHECK JOB ACTIVITY LMN 1 ZJN BRK5 IF NO JOB ACTIVITY LDK TIET SET INTERRUPT CODE LJM /CTL/INT INTERRUPT JOB * PROCESS NON-EMPTY INPUT LINE. BRK4 LDD DP+3 CHECK MODE LPN 4 NJN BRK6 IF TRANSPARENT MODE BRK5 LDN DELM SET *DEL* MESSAGE LJM TTM ISSUE TERMINAL MESSAGE * ENTER TRANSPARENT MODE DATA. BRK6 LDN 76 STORE ESCAPE STD T7 RJM WIC LDN 40 STORE DISPLAY CODE STD T7 RJM WIC RETURN EIL ENTER END-OF-LINE PROCESSING CES SPACE 4,20 ** CES - CHECK ESCAPE STATUS. * * DETERMINES WHETHER AN ESCAPE CHARACTER IS TO * BE ENTERED AS AN ESCAPE CHARACTER, AS AN UPPER * CASE CHARACTER, OR IS TO BE IGNORED. * * ENTRY (T7) = TRANSLATED CHARACTER. * (DP+4) = *ARD*. * * EXIT TO *ESC* TO ENTER ESCAPE CHARACTER IF * TERMINAL IS IN EXTENDED MODE. * TO *EIC* TO ENTER UPPER CASE CHARACTER IF NOT * IN EXTENDED MODE AND ALPHA CHARACTER. * CES BSS 0 ENTRY LDD DP+3 CHECK TERMINAL MODE LPN 6 ZJN CES1 IF NOT EXTENDED MODE JMP ESC ENTER ESCAPE CHARACTER CES1 LDD T7 CHECK CHARACTER TRANSLATION SHN 21-6 PJN CES2 IF ESCAPE 2 LDD T7 CHECK LOWER SIX BITS LPN 77 ZJN CES2 IF *7600* SBN 1RZ+1 PJN CES2 IF NOT LOWER CASE ALPHA JMP EIC ENTER AS UPPER CASE ALPHA CES2 JMP MGR IGNORE CHARACTER CLN SPACE 4,20 ** CLN - PROCESS *COLON* INPUT (64 CHARACTER SET). * * ENTERS *COLON* CHARACTER AS *00* IF IN NORMAL INPUT * MODE OR AS *7604* IF IN EXTENDED INPUT MODE. * * ENTRY (A) = (DP+3). * (T7) = CHARACTER. * * EXIT COLON *00* WRITTEN IF NORMAL MODE. * TO *ESC* TO ENTER *7604* IF EXTENDED MODE - * (T7) = 204B. * * CALLS WIC. * * NOTE IF THE SYSTEM IS IN 63 CHARACTER SET MODE, * A COLON WILL BE BE AUTOMATICALLY ENTERED AS * *63* AND THIS ROUTINE WILL NOT BE CALLED. CLN BSS 0 ENTRY LPN 6 CHECK TERMINAL MODE NJN CLN1 IF *ASCII* OR *TRANSPARENT* LDC 200 SET UP *00* CHARACTER STD T7 RJM WIC WRITE INPUT CHARACTER JMP MGR EXIT CLN1 LDC 204 SET UP *7604* CHARACTER STD T7 JMP ESC ENTER ESCAPE CHARACTER CLW SPACE 4,15 ** CLW - CHECK LOWER CASE *W*. * * THE SEQUENCE NORMALLY ISSUED BY THE *F7* KEY ON * A CDC 721 TERMINAL IS *RS*, LOWER CASE W. THIS * ROUTINE DETECTS THE SECOND CHARACTER IN THE SEQUENCE. * * ENTRY (F7) = 0, IF *RS* NOT PREVIOUSLY DETECTED. * .NE. 0 IF *RS* HAS BEEN DETECTED. * * EXIT TO *EIC* IF *F7* SEQUENCE NOT DETECTED. * TO *MGR* IF *F7* SEQUENCE HAS BEEN DETECTED. * * USES DO. * * CALLS RTD, RPI. CLW BSS 0 ENTRY LDD F7 NJN CLW1 IF *F7* JMP EIC ENTER INPUT CHARACTER CLW1 LDN 0 STD DO STD F7 RJM CRR CHECK RE-REQUESTED BIT LPN 20 ZJN CLW2 IF NOT RE-REQUESTED RJM RTD RELEASE AND DELAY RJM /CTL/RPI INITIALIZE FOR REGAINING PORT ACCESS CLW2 JMP MGR RETURN CRS SPACE 4,15 ** CRS - CHECK *RS*. * * THE SEQUENCE NORMALLY ISSUED BY THE *F7* KEY ON * A CDC 721 TERMINAL IS *RS*, LOWER CASE W. THIS * ROUTINE DETECTS THE FIRST CHARACTER IN THE SEQUENCE * AND SETS A FLAG IF IT IS NOT ALREADY SET. * * ENTRY (F7) = 0, IF *RS* NOT PREVIOUSLY DETECTED. * .NE. 0 IF *RS* HAS BEEN DETECTED. * * EXIT TO *EIC* IF *RS* HAS ALREADY BEEN DETECTED. * TO *MGR* IF *RS* WAS NOT DETECTED BEFORE. CRS BSS 0 ENTRY LDD F7 ZJN CRS1 IF *RS* NOT DETECTED JMP EIC ENTER INPUT CHARACTER CRS1 STD DO CLEAR INPUT CHARACTER IN ECHOPLEX MODE AOD F7 SET START OF *F7* SEQUENCE JMP MGR RETURN CRT SPACE 4,15 ** CRT - PROCESS CARRIAGE RETURN. * * ISSUE *LINE FEED* TO TERMINAL AND ENTER END-OF-LINE * PROCESSOR. * * ENTRY (CH+1) = INPUT LINE CHARACTER COUNT. * (DP+4) = *ARD*. * * EXIT ASCII *LF* ISSUED TO TERMINAL IF NOT IN * *TAPE* MODE. * TO *EIL* TO TERMINATE INPUT LINE. * TO *MGR* IF CHARACTER TO BE IGNORED. CRT BSS 0 ENTRY LDD DP+3 CHECK TERMINAL TYPE SHN 21-7 MJN CRT2 IF *BLKEDIT* LDD DC CHECK TERMINAL STATUS LPN 1 ZJN CRT1 IF NOT IN *TAPE* MODE LDD CH+1 CHECK LINE CHARACTER COUNT NJN CRT2 IF NOT EMPTY INPUT LINE JMP MGR IGNORE CHARACTER CRT1 LDC .CLF ISSUE LINE FEED LMD PY TOGGLE ODD PARITY STD DO CRT2 JMP EIL ENTER END-OF-LINE PROCESSOR DEL SPACE 4,15 ** DEL - PROCESS *DEL* CHARACTER. * * PROCESS *DEL* AS ESCAPE CHARACTER IF *BLKEDIT* TERMINAL, * ELSE PROCESS AS NULL INPUT. * * ENTRY (A) = (DP+3). * * EXIT TO *CES* IF *BLKEDIT* TERMINAL. * TO *NLI* IF NOT *BLKEDIT* TERMINAL - * (A) = (DP+3). DEL BSS 0 ENTRY SHN 21-7 CHECK TERMINAL TYPE MJP CES IF *BLKEDIT* LDD DP+3 JMP NLI PROCESS AS NULL INPUT DLN SPACE 4,20 ** DLN - PROCESS DELETE LINE. * * ENTRY (A) = (DP+3). * (CH+1) = INPUT LINE LENGTH. * (DP+4) = *ARD*. * * EXIT TO *CES* IF *BLKEDIT* TERMINAL. * TO *ESC* TO ENTER CHARACTER. * TO *MGR* TO IGNORE CHARACTER. * TO *TTM* TO ISSUE LINE DELETE MESSAGE. DLN BSS 0 ENTRY * PROCESS AS ESCAPE CHARACTER IF *BLKEDIT* TERMINAL. SHN 21-7 CHECK TERMINAL TYPE MJP CES IF *BLKEDIT* * ENTER CHARACTER IF IN *TRANSPARENT* MODE. LDD DP+3 CHECK FOR *TRANSPARENT* MODE LPN 4 ZJN DLN1 IF NOT SET JMP ESC ENTER ESCAPE CHARACTER * IGNORE CHARACTER IF NULL INPUT LINE. DLN1 STD DO SUPPRESS DUPLEX ECHO-BACK LDD CH+1 CHECK INPUT LINE LENGTH NJN DLN2 IF NOT NULL LINE JMP MGR IGNORE CHARACTER * DELETE INPUT LINE. DLN2 LDN DELM *DEL* JMP TTM ISSUE TERMINAL MESSAGE DPC SPACE 4,15 ** DPC - DELETE PRECEEDING CHARACTER. * * DELETE CHARACTER PRECEDING CHARACTER IF NOT *BLKEDIT* * TERMINAL. ENTER CHARACTER IF *BLKEDIT*. * * ENTRY (A) = (DP+3). * * EXIT TO *CES* IF *BLKEDIT* TERMINAL. * TO *MGR* IF CHARACTER DELETED- * (DP+1) = CURRENT POT BACKED UP. * (DP+2) = CURRENT WORD AND CHARACTER BACKED UP. * (CH+1) = CHARACTER COUNT DECREMENTED. * (OMCC) = CHARACTER COUNT DECREMENTED. * * USES T0 - T5. * * CALLS BUP, RPC, SWA. DPC BSS 0 ENTRY SHN 21-7 CHECK TERMINAL TYPE MJP CES IF *BLKEDIT* LDM OMCC DECREMENT OPERATOR MESSAGE CHARACTER COUNT ZJN DPC1 IF ZERO SOM OMCC DPC1 LDD CH+1 CHECK LINE CHARACTER COUNT NJN DPC2 IF NONZERO JMP MGR EXIT DPC2 SOD CH+1 DECREMENT LINE CHARACTER COUNT RJM BUP BACK UP POINTERS LDD DP+2 CHECK CHARACTER NUMBER SHN 21 PJN DPC3 IF UPPER CHARACTER LPN 7 SET BYTE STD T5 RJM SWA SET WORD ADDRESS CRD T0 READ WORD LDI T5 EXTRACT UPPER CHARACTER SCN 77 STD CH LDN 0 CLEAR BYTE STI T5 RJM SWA SET WORD ADDRESS CWD T0 STORE WORD DPC3 LDD DP+3 CHECK *ASCII* MODE LPN 6 ZJN DPC5 IF NOT SET LDD MA SAVE POINTER WORD CWD DP RJM RPC READ PREVIOUS CHARACTER SBN 74 MJN DPC4 IF NOT ESCAPE ZJN DPC6 IF ESCAPE 2 SBN 76-74 ZJN DPC6 IF ESCAPE 1 DPC4 LDD MA RESTORE POINTER WORD CRD DP DPC5 JMP MGR EXIT DPC6 LDD DP+2 CHECK CHARACTER NUMBER SHN 21-0 PJN DPC5 IF UPPER CHARACTER LDI T5 EXTRACT UPPER CHARACTER SCN 77 STD CH LDN 0 CLEAR BYTE STI T5 RJM SWA SET WORD ADDRESS CWD T0 STORE WORD JMP MGR EXIT EOT SPACE 4,15 ** EOT - END OF TRANSMISSION (*BLKEDIT* TERMINAL). * * PROCESS *EOT* TERMINATOR OF INPUT LINE. IF THE * LINE IS NOT NULL, A CARRIAGE RETURN WILL BE TRANS- * MITTED TO THE TERMINAL. IF THE LINE IS EMPTY, THE * LINE WILL BE IGNORED. * * ENTRY (A) = DP+3. * * EXIT TO *CES* IF NOT *BLKEDIT* TERMINAL. * TO *EIL* IF *BLKEDIT* TERMINAL AND NOT NULL * INPUT LINE. * TO *MGR* IF *BLKEDIT* TERMINAL AND NULL INPUT * LINE. * * MACROS RETURN. EOT BSS 0 ENTRY SHN 21-7 CHECK TERMINAL TYPE PJP CES IF NOT *BLKEDIT* LDD CH+1 CHECK LINE LENGTH ZJP MGR IF NULL LDC .CCR ISSUE *CR* LMD PY TOGGLE ODD PARITY STD DO RETURN * REENTER LDC .CLF ISSUE *LF* LMD PY TOGGLE ODD PARITY STD DO RETURN EIL ENTER INPUT LINE ECI SPACE 4,20 ** ECI - ESCAPE CHARACTER INPUT. * * DIRECTS PROCESSING OF *74* AND *76* INPUT CHARACTERS. * IF IN EXTENDED OR TRANSPARENT MODE, THE *74* CODE IS * STORED AS *7401* AND THE *76* CODE IS STORED AS * *7402*. * * ENTRY (A) = (DP+3). * (T7) = CHARACTER. * * EXIT TO *EIC* TO ENTER SINGLE CHARACTER CODE IF * NOT IN EXTENDED MODE. * TO *ESC* TO ENTER ESCAPE CODE (7401 OR 7401) * IF IN EXTENDED MODE. ECI BSS 0 ENTRY LPN 6 CHECK TERMINAL MODE ZJN ECI1 IF NEITHER *ASCII* NOR TRANSPARENT JMP ESC ENTER ESCAPE CODE CHARACTERS ECI1 LDD T7 CONVERT TO SINGLE DISPLAY CODE LPN 3 SHN 1 ADN 72 STD T7 JMP EIC ENTER INPUT CHARACTER ETX SPACE 4,15 ** ETX - END OF TEXT. * * EXIT TO *CES* IF INPUT LINE NOT EMPTY. * TO *CES* IF NOT IN TEXT MODE. * TO *RWC* AFTER EXITTING FROM *TEXT* MODE. * * CALLS ERQ, WDC. ETX BSS 0 ENTRY LDD CH+1 CHECK INPUT LINE CHARACTER COUNT NJN ETX1 IF LINE NOT EMPTY LDD DC CHECK TERMINAL STATUS LPN 4 NJN ETX2 IF *TEXT* MODE ETX1 LDD DP+3 LJM CES CHECK ESCAPE STATUS ETX2 LDD DC CLEAR *INPUT REQUESTED*, *TEXT* MODE LPC 7373 STD DC RJM WDC REWRITE *VDCT* LDD DP+1 GET POT TO BE DUMPED STD RQ+3 LDD DP+2 EXTRACT WORD COUNT OF POT SHN -4 LPN 7 STD RQ+2 LDN /TLX/ETX EXIT TEXT MODE REQUEST RJM ERQ STD DP CLEAR FIRST POT POINTER STD DP+1 CLEAR CURRENT POT POINTER STD DP+2 CLEAR POSITION WITHIN CURRENT POT JMP RWC ENTER READ/WRITE CONTROL NLI SPACE 4,15 ** NLI - PROCESS NULL INPUT. * * ENTRY (A) = (DP+3). * (DP+4) = PROCESSING ADDRESS. * * EXIT TO *MGR* IF CHARACTER TO BE IGNORED. * TO *EIC* IF CHARACTER TO BE ENTERED. * TO *ESC* IF ESCAPE CHARACTER TO BE ENTERED. NLI BSS 0 ENTRY LPN 4 CHECK *TRANSPARENT* MODE ZJN NLI1 IF NOT SET LDD CH+2 LPC 177 ZJN NLI1 IF NO CHARACTER DEFINED STD T7 ENTER CHARACTER SHN 21-6 CHECK FOR ESCAPE 2 MJN NLI2 IF ESCAPE 2 LJM EIC ENTER INPUT CHARACTER NLI1 JMP MGR IGNORE CHARACTER NLI2 LJM ESC ENTER ESCAPE CHARACTER RDM TITLE READ MODE - SUBROUTINES. EMD SPACE 4,25 ** EMD - ENTER OPERATOR MESSAGE DATA. * * ENTERS DATA FOR POSSIBLE OPERATOR MESSAGE INTO * THE OPERATOR MESSAGE BUFFER. IN ORDER FOR THE * INPUT DATA TO BE CONSIDERED A CANDIDATE FOR AN * OPERATOR MESSAGE, THE FIRST CHARACTER OF INPUT * MUST BE AN ASCII *ESC* CHARACTER. RECEIPT OF AN * ADDITIONAL ASCII *ESC* CHARACTER AFTER THE START OF * THE MESSAGE WILL CAUSE THE MESSAGE TO BE NO LONGER * CONSIDERED A CANDIDATE FOR AN OPERATOR MESSAGE. * * ENTRY (T7) = LOWER 7 BITS OF INPUT DATA. * (CH+1) = LINE CHARACTER COUNT. * (F7) = 0 IF START OF *F7* SEQUENCE NOT DETECTED. * (OMCC) = OPERATOR MESSAGE CHARACTER COUNT. * = NONZERO IF POSSIBLE OPERATOR MESSAGE. * * EXIT DATA ENTERED IN OPERATOR MESSAGE BUFFER. * (OMCC) = INCREMENTED IF POSSIBLE MESSAGE * CHARACTER. * = 0 IF *ESC* RECEIVED AFTER START OF * MESSAGE. * * USES T1, T2. EMD SUBR ENTRY/EXIT LDD F7 CHECK FOR START OF *F7* SEQUENCE DETECTED NJN EMDX IF DETECTED LDD CH+1 CHECK LINE CHARACTER COUNT ADM OMCC ADD MESSAGE CHARACTER COUNT NJN EMD2 IF EITHER IS NONZERO * CHECK FIRST INPUT CHARACTER FOR *ESC* CODE. LDD T7 GET INPUT CHARACTER LMK .AESC NJN EMDX IF NOT *ESC* LDC 2L SET BLANK IN BUFFER STM OMBUF EMD1 AOM OMCC INCREMENT MESSAGE CHARACTER COUNT UJN EMDX RETURN * CHECK FOR *ESC* AFTER START OF INPUT. EMD2 SBD CH+1 CHECK VALUE OF *OMCC* ZJN EMDX IF ZERO LDD T7 GET INPUT CHARACTER SBK .AESC NJN EMD3 IF NOT *ESC* STM OMCC CLEAR MESSAGE CHARACTER COUNT UJN EMDX RETURN * TRANSLATE INPUT CHARACTER TO MESSAGE BUFFER. EMD3 ADK .AESC-.ASP CHECK CHARACTER VALUE MJN EMDX IF NOT TRANSLATABLE LDM OMCC CHECK BUFFER LENGTH SBK 68D PJP EMDX IF OVERFLOW, IGNORE CHARACTER LDM TINT,T7 GET TRANSLATION LPN 77 MASK UPPER CASE BITS STD T1 SAVE TRANSLATION * ENTER CHARACTER IN MESSAGE BUFFER. LDM OMCC GET BUFFER CHARACTER COUNT SHN 22-1 SET CURRENT BYTE STD T2 SHN 1 SHIFT CHARACTER POSITION LPN 1 NJN EMD4 IF LOWER CHARACTER LDD T1 STORE AS UPPER CHARACTER SHN 6 STM OMBUF,T2 JMP EMD1 INCREMENT CHARACTER COUNT EMD4 LDD T1 STORE AS LOWER CHARACTER RAM OMBUF,T2 JMP EMD1 INCREMENT CHARACTER COUNT EOM SPACE 4,40 ** EOM - ENTER OPERATOR MESSAGE. * * CHECKS THE CONTENTS OF THE OPERATOR MESSAGE BUFFER * FOR A VALID OPERATOR MESSAGE. IF THE BUFFER CONTENTS * CONSTITUTE AN OPERATOR MESSAGE, THE MESSAGE WILL BE * TRANSMITTED TO THE DSD *A,OPERATOR* DISPLAY BUFFER * AND THE INPUT LINE FROM WHICH THE MESSAGE WAS EX- * TRACTED WILL BE DISCARDED. * * ENTRY (OMCC) = MESSAGE CHARACTER COUNT. * = ZERO IF NO POSSIBLE MESSAGE IN * BUFFER. * (OMBUF) = TRANSLATED MESSAGE. * * EXIT TO CALLER IF NO MESSAGE ISSUED - * (OMCC) = 0. * TO *TTM* IF MESSAGE HAS BEEN ISSUED. * (A) = ADDRESS OF *READY* MESSAGE. * (CH+1) = 0. * * ERROR TO *TTM* TO ISSUE *CONSOLE BUSY* MESSAGE IF * OPERATOR DISPLAY BUFFER BUSY. * * USES T1, T2, CM - CM+4. * * CALLS STA, ZOM. * * MACROS MONITOR. EOM SUBR ENTRY/EXIT LDM OMCC CHECK MESSAGE LENGTH ZJN EOMX IF ZERO SBN 4 MJN EOM1 IF TOO SHORT * VALIDATE MESSAGE FORMAT. LDM OMBUF CHECK FIRST 2 CHARACTERS LMC 2R M NJN EOM1 IF NOT * M* LDM OMBUF+1 CHECK SECOND 2 CHARACTERS LMC 2RS= ZJN EOM2 IF *S=* EOM1 LDN 0 CLEAR MESSAGE LENGTH STM OMCC JMP EOMX RETURN TO CALLER * INTERLOCK OPERATOR DISPLAY BUFFER. EOM2 LDK LDSP READ *L* DISPLAY POINTER CRD CM LDD CM+2 GET *L* DISPLAY BUFFER ADDRESS SHN 14 LMD CM+3 SBK LODS SET FWA OF OPERATOR DISPLAY BUFFER STD CM+4 STM EOMA+1 SHN -14 STD CM+3 ADC LDCI STM EOMA LDN 0 FORMAT INTERLOCK REQUEST STD CM+1 STD CM+2 MONITOR UTEM ISSUE INTERLOCK REQUEST LDD CM+1 ZJN EOM3 IF INTERLOCK GRANTED LDN MBSY * CONSOLE BUSY* LJM TTM ISSUE TERMINAL MESSAGE * FORMAT DISPLAY BUFFER HEADER WORD. EOM3 RJM ZOM ZERO-FILL MESSAGE RJM STA SET FWA OF TERMINAL TABLE ADK VFST READ *VFST* TO GET JSN CRD CM LDD TN SET TERMINAL NUMBER IN HEADER ADC 2R00 STD CM+2 LDN 0 STD CM+3 LDN 1 SET BUFFER BUSY BIT STD CM+4 * COPY BUFFER HEADER AND MESSAGE TO DISPLAY BUFFER. LDN 7 SET MESSAGE DATA LENGTH STD T1 EOMA LDC * WRITE BUFFER HEADER CWD CM ADN 1 WRITE BUFFER MESSAGE DATA CWM OMBUF+2,T1 * SET OPERATOR MESSAGE FLAG IN DISPLAY BUFFER LDN 1 FORMAT *UTEM* REQUEST STD CM+1 LDN 0 STD CM+2 STD CM+3 LDK OPRL STD CM+4 LDD MA WRITE MESSAGE PARAMETERS CWM EOMB,ON MONITOR UTEM ISSUE MONITOR REQUEST * EXIT TO *TTM* TO ISSUE *READY* MESSAGE. * * ENTRY (A) = ZERO (FROM *MONITOR* REQUEST). STD CH+1 CLEAR INPUT CHARACTER COUNT LDN RDYM SET MESSAGE ADDRESS JMP TTM ISSUE TERMINAL MESSAGE EOMB VFD 6/0,6/1,6/59D,42/1 *UTEM* PARAMETER WORD RIN SPACE 4,15 ** RIN - RELEASE INPUT POTS TO EXECUTIVE. * * TRANSMITS FILLED INPUT POTS TO *RDF* EXECUTIVE * VIA *RIN* REQUEST. * * ENTRY (DP) = FIRST POT OF INPUT LINE. * (DP+1) = CURRENT POT OF INPUT. * * EXIT FIRST THROUGH CURRENT POT RELEASED IF * FIRST IS NOT THE CURRENT POT. * (DP) = (DP+1). * * CALLS ERQ. RIN SUBR ENTRY/EXIT LDD DP SET FIRST POT STD RQ+3 LMD DP+1 ZJN RIN1 IF FIRST POT .EQ. CURRENT POT LDD DP+1 SET CURRENT POT STD DP STD RQ+2 LDN /TLX/RIN RELEASE POT RJM ERQ RIN1 STD RQ+3 CLEAR REQUEST UJN RINX RETURN RPC SPACE 4,15 ** RPC - READ PREVIOUS CHARACTER. * * ENTRY NONE. * * EXIT (A) = PREVIOUS CHARACTER. * IF PREVIOUS CHARACTER IS LOWER- * (T0 - T0+4) = DATA WORD. * (T5) = BYTE NUMBER. * (T6) = WORD NUMBER. * * USES T0 - T5. * * CALLS BUP, SWA. RPC1 LDD CH SET CHARACTER SHN -6 RPC SUBR ENTRY/EXIT RJM BUP BACK UP POINTERS LDD DP+2 CHECK CHARACTER NUMBER SHN 21 PJN RPC1 IF UPPER CHARACTER LPN 7 SET BYTE STD T5 RJM SWA SET WORD ADDRESS CRD T0 LDI T5 SET CHARACTER LPN 77 UJN RPCX RETURN WIC SPACE 4,25 ** WIC - WRITE INPUT CHARACTER. * * ENTRY (T7) = CHARACTER. * (CH) = UPPER CHARACTER IF LOWER CHARACTER IS * TO BE STORED. * IF (T7) = 0, AND UPPER CHARACTER IS TO BE PROCESSED, * END OF LINE IS ASSUMED. IN ORDER TO PREVENT * CONFUSION BETWEEN THE DISPLAY CODE COLON *00* AND * END OF LINE, A *00* COLON IS PASSED TO *WIC* AS A * *200* CODE. * * EXIT TO *NIP* IF NO INPUT POT. * * USES T0 - T5. * * CALLS ERQ, RLT, SWA. * * MACROS RETURN. WIC6 LPN 7 SET CURRENT BYTE STD T5 NJN WIC7 IF NOT START OF NEW WORD LDN ZERL UJN WIC8 WIC7 RJM SWA SET CURRENT WORD ADDRESS WIC8 CRD T0 LDD T7 MERGE UPPER AND LOWER CHARACTERS LPN 77 MASK FOR COLON LMD CH STI T5 STORE BYTE RJM SWA WRITE WORD TO CM POT CWD T0 LDI T5 ADD T7 ZJN WIC2 IF END OF LINE AOD DP+2 ADVANCE CHARACTER LPN 17 LMN 12 ZJN WIC2 IF END OF WORD * UJN WICX RETURN * WIC - ENTRY/EXIT. WIC SUBR ENTRY/EXIT WIC1 LDD DP+2 CHECK CHARACTER NUMBER SHN 21 MJN WIC6 IF LOWER * PROCESS UPPER CHARACTER. AOD DP+2 ADVANCE CHARACTER POINTER LDD T7 CHECK CHARACTER SHN 6 STORE UPPER CHARACTER STD CH NJN WICX IF NOT END OF LINE UJN WIC1 FORCE END OF LINE * PROCESS END OF WORD. WIC2 LDD DP+2 CHECK WORD NUMBER SHN -4 LPN 7 LMN 7 ZJN WIC4 IF END OF POT LDD DP+2 ADVANCE WORD NUMBER, RESET CHARACTER SCN 17 ADN 20 STD DP+2 SHN -4 CHECK WORD NUMBER LPN 17 SBN 5 MJN WICX RETURN IF WORD 5 NOT REACHED SBN 3 PJN WICX RETURN IF POT REQUESTED LDC 200 SET *POT REQUESTED* RAD DP+2 RJM RLT READ NEXT POT LINK NJN WIC3 IF POT LINKED LDD DP+1 SET CURRENT POT STD RQ+3 LDN /TLX/LPT REQUEST POT RJM ERQ WIC3 JMP WICX RETURN * PROCESS END OF POT. WIC4 LDD DP+2 RESET WORD AND CHARACTER LPC 7400 STD DP+2 RJM RLT GET NEXT POT LINK ZJN WIC5 IF POT NOT LINKED STD DP+1 SET NEW CURRENT POT LDD DP+3 LPN 10 ZJN WIC3 IF NOT BINARY MODE, RETURN LDD DC CHECK TERMINAL STATUS SHN 21-6 MJN WIC3 IF *READ DATA* SET RJM RIN RELEASE INPUT DATA JMP WICX RETURN WIC5 RETURN NIP PROCESS NO-INPUT-POT ZOM SPACE 4,15 ** ZOM - ZERO-FILL OPERATOR MESSAGE BUFFER. * * ZERO-FILLS THE OPERATOR MESSAGE BUFFER FROM THE LAST * CHARACTER ENTERED INTO THE BUFFER TO THE END OF THE * BUFFER. * * ENTRY (OMCC) = NUMBER OF CHARACTERS IN BUFFER. * * EXIT BUFFER ZERO-FILLED. * * USES T1. ZOM SUBR ENTRY/EXIT LDM OMCC GET BUFFER CHARACTER COUNT SHN 22-1 SET PPU BYTE COUNT STD T1 SHN 1 ADD LAST CHARACTER INDEX LPN 1 RAD T1 ZOM1 SBK 37D CHECK FOR END OF BUFFER PJN ZOMX IF BUFFER COMPLETE LDN 0 CLEAR BUFFER BYTE STM OMBUF,T1 AOD T1 INCREMENT BUFFER INDEX UJN ZOM1 LOOP TO END OF BUFFER SPACE 4,10 QUAL RDM EQU /RDM/RDM WTM TITLE WRITE MODE. QUAL WTM WTM SPACE 4,20 ** WTM - WRITE MODE CONTROL. * * DETERMINES WHETHER A WRITE OPERATION SHOULD BE IN NOS * *BINARY* OR IN *ASCII* FORMAT AND BRANCHES TO THE FORMAT * WRITE PROCESSOR. * * ENTRY (DP+1) = FIRST POT OF OUTPUT. * (DP+2), CURRENT WORD = FIRST WORD OF OUTPUT. * (DP+3) *BINARY TRANSMISSION* STATUS * (CH+2) = ESCAPE CONTROL. * * EXIT TO *AWT* FOR *ASCII* FORMAT WRITE. * TO *BWT* FOR NOS *BINARY* FORMAT WRITE. * * CALLS ERQ, RLT. WTM BSS 0 ENTRY RJM RLT CHECK POT LINK NJN WTM1 IF POT LINKED LDN /TLX/RES REQUEST MORE OUTPUT RJM ERQ WTM1 LDD DP+3 CHECK *BINARY TRANSMISSION* LPN 10 ZJN AWT IF *ASCII* WRITE LJM BWT ENTER *BINARY* WRITE AWT TITLE WRITE MODE - *ASCII* WRITE PROCESSOR. AWT SPACE 4,50 ** AWT - *ASCII* WRITE PROCESSOR. * * ISSUES *ASCII* CHARACTER DATA TO TERMINAL. * * ENTRY (CH+2) = ESCAPE CONTROL. * * EXIT (CH+2) = ESCAPE CONTROL UPDATED. * * ESCAPE CONTROL - * * 4XXX = VALID CHARACTER POINTER XXX. * 0100 = ESCAPE 1. * 0200 = ESCAPE 2. * 0300 = *00* (POSSIBLE EOL) BYTE HAS BEEN * DETECTED. THIS SITUATION WILL OCCUR * WHEN THE LOWER CHARACTER OF AN * OUTPUT BYTE IS FOUND TO BE ZERO. * AT THIS POINT, FURTHER TESTING MUST * BE DONE TO DETERMINE WHETHER OR NOT * THIS ZERO CHARACTER IS PART OF * AN END OF LINE OR IS FOLLOWED BY * DATA. THIS LATTER CONDITION IS A * FALSE END OF LINE AND THE ZERO * CHARACTER MUST BE PROCESSED AS A * COLON. * 04XX = FALSE EOL HAS BEEN DETECTED. * XX = NEXT OUTPUT CHARACTER. * 05XX = SUSPENDED CONTROL PROCESSING. THIS * SITUATION OCCURS WHEN A CONTROL * CHARACTER PROCESSOR IS UNABLE TO * TO DETERMINE WHETHER OR NOT A * SUSPECTED CONTROL CHARACTER IS * FOLLOWED BY AN END OF LINE. * THIS WILL OCCUR WHEN THERE IS * NO FURTHER DATA IN THE CURRENT * OUTPUT POTS AND THE DRIVER MUST * WAIT FOR FURTHER OUTPUT TO BE * ASSIGNED. AWT BSS 0 ENTRY RETURN * REENTER * CHECK ESCAPE CONTROL. LDD CH+2 GET ESCAPE CONTROL SHN -6 ZJN AWT1 IF NULL STD T1 SBN TECPL TEST FOR VALID DATA BIT PJN AWT1 IF VALID DATA SET LDM TECP-1,T1 SET PROCESSOR ADDRESS STD T2 LDD CH+2 SAVE LOWER SIX BITS LPN 77 STD T7 LJM 0,T2 PROCESS ESCAPE CONTROL * GET NEXT OUTPUT CHARACTER. AWT1 RJM ROC GET NEXT CHARACTER PJN AWT3 IF NOT CONTROL BYTE AWT2 LJM SOC PROCESS CONTROL BYTE AWT3 NJN AWT4 IF NON-ZERO LJM AWT11 CHECK POSSIBLE END OF LINE * CHECK OUTPUT CHARACTER. AWT4 SBN 74 CHECK FOR ESCAPE CHARACTER MJN AWT7 IF NOT ESCAPE 1 OR 2 ZJN AWT5 IF ESCAPE 2 SBN 76-74 NJN AWT7 IF NOT ESCAPE 1 LCN 1 * PROCESS ESCAPE CHARACTER. AWT5 ADN 2 SET ESCAPE CHARACTER BIAS SHN 6 STD CH+2 LDD DP+3 LPN 2 ZJN AWT7 IF NOT EXTENDED MODE AWT6 RJM ROC GET NEXT OUTPUT CHARACTER MJN AWT2 IF CONTROL BYTE ADD CH+2 ADD ESCAPE CHARACTER BIAS STD T7 ADC -214 MJN AWT7 IF LEGAL CHARACTER LDN 0 IGNORE INVALID CHARACTER STD CH+2 LJM AWT LOOP FOR NEXT CHARACTER * CLEAR ESCAPE CONTROL. * * (T7) = OUTPUT CHARACTER PLUS ESCAPE BIAS. AWT7 LDN 0 CLEAR ESCAPE CONTROL STD CH+2 * TRANSLATE AND ISSUE OUTPUT CHARACTER. * * (T7) = OUTPUT CHARACTER PLUS ESCAPE BIAS. AWT8 RJM TOC TRANSLATE OUTPUT CHARACTER SHN 6 PJN AWT10 IF SPECIAL PROCESSING REQUIRED AOD CH+1 ADVANCE CHARACTER COUNT/LINE AOD CH+4 ADVANCE OUTPUT CHARACTER COUNT SHN -14 ZJN AWT9 IF NO OVERFLOW (4096 CHARACTERS) LDN /TLX/IAM REQUEST ISSUE ACCOUNTING MESSAGE RJM ERQ * ISSUE TRANSLATED CHARACTER TO OUTPUT. AWT9 LDD T7 GET TRANSLATED CHARACTER STD DO ISSUE CHARACTER TO OUTPUT LJM AWT LOOP FOR NEXT CHARACTER * PERFORM SPECIAL PROCESSING. AWT10 SHN -6 SET SPECIAL PROCESSOR INDEX STD T1 LDM TWSP,T1 GET CHARACTER PROCESSOR ADDRESS LJM MGR= ENTER CHARACTER PROCESSOR * PROCESS POSSIBLE END OF LINE. AWT11 LDC 300 SET OUTPUT CONTROL STD CH+2 AWT12 RJM ROC GET NEXT CHARACTER PJN AWT15 IF NOT CONTROL BYTE LJM SOC * ENTRY FROM CONTROL CHARACTER PROCESSORS. * * (A) = FALSE CONTROL BYTE VALUE. AWT13 STD CM SAVE FALSE CONTROL BYTE LDD CH+2 CHECK OUTPUT CONTROL LMC 300 NJN AWT14 IF NOT SUSPENDED COLON STD CM SOD DP+2 BACK UP CHARACTER AWT14 LDD CM AWT15 ADC 400 SET ESCAPE CONTROL STD CH+2 LDN 00 SET COLON STD T7 LJM AWT8 TRANSLATE AND ISSUE CHARACTER TECP SPACE 4,10 ** TECP - TABLE OF ESCAPE CONTROL PROCESSORS. TECP BSS 0 LOC 1 CON AWT6 *0100* - ESCAPE 1. CON AWT6 *0200* - ESCAPE 2. CON AWT12 *0300* - POSSIBLE *EOL*. CON AWT4 *04XX* - FALSE *EOL*. CON SOC1 *05XX* - SUSPENDED OUTPUT CONTROL. TECPL BSS 0 LOC *O TWSP SPACE 4,10 ** TWSP - TABLE OF SPECIAL WRITE PROCESSORS. TWSP BSS 0 QUAL TRN LOC 0 NLO CON /WTM/AWT NULL CHARACTER (IGNORED) ACR CON /WTM/ACR CARRIAGE RETURN ANL CON /WTM/ANL NEW LINE (CR/LF) LOC *O NOREF NLO QUAL * BWT TITLE WRITE MODE - *BINARY* WRITE PROCESSOR. BWT SPACE 4,15 ** BWT - BINARY WRITE. * * WRITES NOS *BINARY* MODE DATA TO TERMINAL. * * CALLS ROC, ERQ. BWT BSS 0 ENTRY RETURN * REENTER RJM ROC READ OUTPUT CHARACTER MJP SOC IF CONTROL BYTE LDI T5 READ ENTIRE 12-BIT CHARACTER STD DO STORE OUTPUT SHN 21-13 CHECK FORMAT PJN BWT2 IF NOT BINARY FORMAT AOD DP+2 ADVANCE CHARACTER COUNT AOD CH+4 SHN -14 ZJN BWT1 IF NO OVERFLOW LDN /TLX/IAM ISSUE ACCOUNTING MESSAGE RJM ERQ BWT1 JMP MGR REENTER * TERMINATE BINARY MODE OUTPUT. BWT2 LCN 10 CLEAR BINARY MODE BIT RAD DP+3 SOD DP+2 RESET CHARACTER POSITION LDN 0 CLEAR ESCAPE CONTROL STD CH+2 LDN 1 SET CHARACTER COUNT NON-ZERO STD CH+1 JMP AWT ENTER *ASCII* WRITE WTM TITLE WRITE MODE - MAIN ROUTINES. ISN SPACE 4,15 ** ISN - ISSUE ASCII *NUL* CHARACTERS. * * ENTRY (A) = DEFAULT REPEAT COUNT. * * EXIT TO *AWT* TO CONTINUE WRITE OPERATION. * * CALLS DDC, SRC. ISN BSS 0 ENTRY RJM DDC DETERMINE DELAY COUNT SHN 14 ADK .CNUL SET *NUL* CHARACTER LMD PY TOGGLE ODD PARITY RJM SRC SEND REPEATED CHARACTER JMP AWT CONTINUE WRITE SOC SPACE 4,15 ** SOC - SET OUTPUT CONTROL. * * ENTRY (A) = OUTPUT CONTROL BYTE SET BY *ROC*. * (T7) = LOWER 12 BITS OF *ROC* CONTROL BYTE. * * EXIT TO CONTROL BYTE PROCESSOR. * * CALLS ERQ, RLT. SOC4 RJM RLT CHECK POT LINK NJN SOC5 IF LINKED LDC /CTL/RWC1 SET REENTRY ADDRESS STD DP+4 UJN SOC6 * SET NEXT POT. SOC5 STD DP SET POT POINTER LDD DP+1 DROP CURRENT POT STD RQ+3 LDN /TLX/DRP RJM ERQ LDD DP SET CURRENT POT STD DP+1 RJM RLT CHECK THIS POT LINK NJN SOC7 IF POT LINKED * REQUEST ADDITIONAL OUTPUT. SOC6 LDN /TLX/RES REQUEST ADDITIONAL OUTPUT RJM ERQ SOC7 LDN 0 CLEAR LINE POSITION STD DP+2 STD DO CLEAR OUTPUT JMP MGR EXIT * SOC - ENTRY. SOC BSS 0 ENTRY SHN 21-20 CHECK BIT 20 MJN SOC4 IF SET, THEN END OF POT AOD DP+2 ADVANCE CHARACTER POINTER * CHECK CONTROL BYTE. SOC1 LDD T7 CHECK CONTROL BYTE ZJN SOC3 IF END OF LINE LMN 2R"IB" ZJN SOC2 IF INTERNAL END OF BLOCK LDD DP+3 CHECK MODE SHN 21-3 PJN SOC2 IF NOT BINARY SOD DP+2 TERMINATE BINARY MODE LJM BWT2 * EXIT TO CONTROL BYTE PROCESSOR. SOC2 LDN /TLX/RES REQUEST ADDITIONAL OUTPUT RJM ERQ SOC3 LDM TSOC,T7 SET REENTRY ADDRESS LJM MGR= REENTER TTM SPACE 4,25 ** TTM - ISSUE TERMINAL MESSAGE. * * ISSUES MESSAGE TO TERMINAL. * * ENTRY (A) = ADDRESS OF FORMATTED MESSAGE. * * EXIT (CM+2) = 0. * (OMCC) = 0. * TO *RDM* AFTER MESSAGE IS COMPLETE IF THERE * ARE INPUT POTS AVAILABLE - * (DP+1) = CURRENT POT RESET TO START OF LINE. * (DP+2) = CURRENT WORD RESET TO START OF LINE. * TO *RWC* AFTER MESSAGE IS COMPLETE IF THERE * IS NO INPUT POT AVAILABLE. * * USES (DP+1) = MESSAGE ADDRESS POINTER. * (DP+2) = MESSAGE BYTE POINTER. * * CALLS SEM. * * MACROS RETURN. TTM BSS 0 ENTRY ADC 7700 SET MESSAGE PSEUDO-POT-POINTER STD DP+1 LDD DP+2 CLEAR BYTE POINTER LPC 7600 STD DP+2 LDN 0 CLEAR OUTPUT CONTROL STD CH+2 STM OMCC CLEAR OPERATOR MESSAGE RJM SEM SET EXTENDED MODE RETURN AWT ENTER WRITE MODE * ENTERED HERE FROM SUBROUTINE *ROC* TO EXTRACT NEXT * MESSAGE CHARACTER TO BE RETURNED TO WRITE PROCESSOR. TTM1 LDM TTMA-7700,DP+1 GET NEXT CHARACTER STD T7 LDD DP+2 TOGGLE BYTE INDEX LMN 1 STD DP+2 LPN 1 NJN TTM2 IF UPPER CHARACTER AOD DP+1 INCREMENT MESSAGE ADDRESS LDD T7 LPN 77 EXTRACT LOWER CHARACTER UJN TTM3 TTM2 LDD T7 EXTRACT UPPER CHARACTER SHN -6 TTM3 STD T7 SET CHARACTER ZJN TTM5 IF END OF MESSAGE SOD CH+4 PREVENT CHARACTER COUNT ON MESSAGE LDD T7 LJM ROCX ISSUE CHARACTER * RESET LINE POINTERS AND EXIT. TTM5 LDD DP+2 RESET CURRENT WORD SHN -5 LMD DP+2 SCN 17 STD DP+2 LDD DP RESET CURRENT POT STD DP+1 ZJN TTM6 IF NO INPUT POT RJM CEM CLEAR EXTENDED MODE LJM RDM RE-ENTER READ MODE TTM6 LDN /TLX/RES RESTART JOB RJM ERQ JMP RWC ENTER READ/WRITE CONTROL ** TABLE OF TERMINAL MESSAGES. TTMA BSS 0 LOC 0 DELM DATA Z+ *DEL*"NL"+ LOFM DATA Z+"NL" *OVL*"NL"+ MBSY DATA Z+"NL" *CONSOLE BUSY*"NL"+ RDYM DATA Z+"NL" *READY*"NL"+ RILM DATA Z+"NL" *RE-ENTER LAST LINE*"NL"+ LOC *O TITLE WRITE MODE - OUTPUT CONTROL BYTE PROCESSORS. TSOC SPACE 4,10 ** TSOC - TABLE OF OUTPUT CONTROL BYTE PROCESSORS. * INDEXED BY CONTROL CODE. TSOC BSS 0 LOC 0 CON EOL END OF LINE CON EOB END OF BLOCK CON ECB END OF CORRESPONDENCE BLOCK CON ATI AUTO INPUT CON LOF LOG OFF USER CON TPI TRANSPARENT INPUT CON BNI BINARY INPUT CON BNO BEGIN BINARY OUTPUT CON EOL UNUSED - TREAT AS END OF LINE CON BEO BEGIN EXTENDED OUTPUT CON EOL UNUSED - TREAT AS END OF LINE CON EOS END OF STRING CON IEB INTERNAL END OF BLOCK CON ETI EXECUTIVE AUTO MODE INPUT TSOCL BSS 0 LOC *O EOL SPACE 4,15 *** 0000 END OF OUTPUT LINE. * * THIS CONTROL BYTE CAUSES THE TERMINAL TO BE POSITIONED TO * THE BEGINNING OF THE NEXT LINE. THE REMAINDER OF THE WORD * IN WHICH THE *END OF LINE* OCCURS IS DISCARDED. * * EXIT (CH+1) = 0. * (CH+2) = 0. * TO *ANL* IF IN *ASCII* MODE. * TO *AWT* IF IN BINARY MODE. * * CALLS CEM. EOL BSS 0 ENTRY LDN 0 CLEAR LINE CHARACTER COUNT STD CH+1 STD CH+2 CLEAR ESCAPE CONTROL LDD DP+2 CLEAR WORD AND CHARACTER POINTERS SCN 17 LMN 12 STD DP+2 LDD DP+3 CHECK FOR BINARY MODE LPN 10 NJN EOL1 IF BINARY MODE RJM CEM CLEAR/RESET EXTENDED MODE JMP ANL ISSUE *NEW LINE* EOL1 LMD DP+3 CLEAR BINARY MODE STD DP+3 JMP AWT CONTINUE OUTPUT EOB SPACE 4,20 *** 0001 END OF OUTPUT BLOCK. * * THIS CONTROL BYTE IS USED TO TERMINATE OUTPUT BEFORE * THE END OF POT IS REACHED. THE REMAINDER OF THE POT IS * DISCARDED AND THE TERMINAL IS NOT POSITIONED TO THE * START OF THE NEXT LINE. * * THIS CONTROL BYTE MUST BE FOLLOWED BY AN END-OF-LINE. * * EXIT TO *RWC* FOR NEXT OPERATION - * (DP+2) = 0. * (CH+1) = 0. * (CH+2) = 0. * * CALLS CLT. EOB BSS 0 ENTRY LDN 1RA RJM CLT CHECK FOR LINE TERMINATION EOB1 LDN 0 CLEAR CHARACTER POSITION STD DP+2 STD CH+1 RESET CHARACTER COUNT STD CH+2 CLEAR ESCAPE CONTROL JMP RWC ECB SPACE 4,20 *** 0002 END OF CORRESPONDENCE BLOCK. * * SPECIAL END OF BLOCK PROCESSING FOR POSSIBLE * CORRESPONDENCE TERMINALS. * THIS CODE ENABLES INPUT IF CORRESPONDENCE TERMINAL, * OTHERWISE IT IS TREATED AS A *0001* BYTE. * * THIS CONTROL BYTE MUST BE FOLLOWED BY AN END-OF-LINE. * * NOTE THIS CONTROL BYTE IS NOT MEANINGFUL TO THE * THE TWO-PORT MULTIPLEXER DRIVER. * * EXIT TO *EOB1* TO TERMINATE OUTPUT BLOCK. * * CALLS CLT. ECB BSS 0 ENTRY LDN 1RB CHECK FOR LINE TERMINATOR RJM CLT JMP EOB1 PROCESS AS *EOB* ATI SPACE 4,20 *** 0003 INITIATE AUTO-MODE INPUT. * * THIS CONTROL BYTE MUST BE FOLLOWED BY AN END OF LINE * AND TERMINATES OUTPUT. * THE WORD CONTAINING THE AUTO INPUT CONTROL BYTE IS * MOVED TO THE FIRST WORD OF THE POT FOR SUBSEQUENT * INPUT WHICH MUST FOLLOW IMMEDIATELY. * * EXIT TO *RDM* TO READ IN AUTO MODE. * TO *RWC* TO PROCESS DRIVER REQUEST. * * ERROR TO *AWT13* IF INVALID REQUEST. * * CALLS CLT, CKL, ERQ, MDS, RSW, SWA. * * MACROS RETURN. ATI7 LDN 1RC REENTER WRITE MODE * LDN 1RM (CONTROL BYTE 0015B) ATIB EQU *-1 JMP AWT13 CONTINUE WRITE * ATI - ENTRY. ATI BSS 0 ENTRY LDC LDNI+1RC CONTROL BYTE TO REENTER WRITE MODE STM ATIB LDC MDS SET UP CALL TO SUBROUTINE MDS STM ATIA LDN 1RC * ATI1 - ENTRY FROM *ATI* AND *ETI*. * * ENTRY (ATIA) = *MDS* IF CALLED FROM *ATI*. * = *WDS* IF CALLED FROM *ETI*. * (ATIB) = DISPLAY CHARACTER FOR ERROR PROCESSING. ATI1 RJM CLT CHECK FOR LINE TERMINATION RJM CKL CHECK *LIST* STATUS MJN ATI7 IF FILE BEING LISTED LDD DC CHECK TERMINAL STATUS LPN 2 NJN ATI3 IF AUTO INPUT MODE SET LDD DC+4 CHECK VDCT INTERLOCK ZJN ATI2 IF NOT INTERLOCKED LDN 2 SET AUTO INPUT MODE RAD DC RJM WDC WRITE VDCT UJN ATI3 SET WORD/BYTE NUMBER ATI2 LDN /TLX/SAI REQUEST SET AUTO INPUT RJM ERQ ATI3 LDD DP+2 SET BYTE NUMBER SHN -1 LPN 7 STD T5 RJM SWA SET WORD ADDRESS CRD T0 READ DATA WORD LDN 0 CLEAR BYTE STI T5 STD CH+2 CLEAR ESCAPE CONTROL RJM MDS RESTORE WORD AND SET FIRST WORD * RJM RSW (CONTROL BYTE 0015) ATIA EQU *-1 LDD DP+2 SCN 17 SHN 5 LMD DP+2 SBN 2 DECREMENT CHARACTER NUMBER STD DP+2 LPN 17 STD CH+1 SET INPUT LINE CHARACTER COUNT LDD DP+3 CLEAR BINARY AND EXTENDED MODES SCN 12 STD DP+3 * WAIT FOR EXECUTIVE TO SET *AUTO* MODE. ATI4 RETURN * REENTER LDD DC CHECK TERMINAL STATUS SHN 21-1 MJN ATI5 IF AUTO MODE SET LDD DC+4 CHECK FOR DRIVER REQUEST NJP RWC IF DRIVER REQUEST JMP MGR REENTER ATI5 LPN 2 SET NORMAL/EXTENDED MODE BIT RAD DP+3 RETURN RDM ENTER READ MODE LOF SPACE 4,15 *** 0004 LOGOFF TERMINAL USER. * * THIS BYTE LOGS-OFF THE USER. IT MUST BE THE FIRST * BYTE OF OUTPUT AND MUST BE FOLLOWED BY AN END-OF-LINE. * * CALLS ERQ, CKL, CLT. LOF BSS 0 ENTRY RJM CKL CHECK *LIST* STATUS MJN LOF1 IF FILE BEING LISTED LDD CH+1 CHECK LINE CHARACTER COUNT NJN LOF1 IF NOT FIRST BYTE LDN 1RD RJM CLT CHECK FOR LINE TERMINATION LDN 1 SET NORMAL LOGOFF STD RQ+2 LDN /TLX/FLO FORCE LOGOUT RJM ERQ LJM EOB1 LOF1 LDN 1RD JMP AWT13 REENTER WRITE MODE TPI SPACE 4,15 *** 0005 INITIATE TRANSPARENT MODE INPUT. * * THIS CONTROL BYTE SETS TRANSPARENT INPUT FOR THE NEXT INPUT * REQUEST. IT MUST APPEAR IN THE FIRST BYTE OF A WORD * AND BE FOLLOWED BY AN END-OF-LINE. * * TRANSPARENT INPUT ALLOWS ALL CHARACTERS TO BE TRANSMITTED * TO THE CPU PROGRAM. * * CALLS CKL, CLT. TPI BSS 0 ENTRY RJM CKL CHECK *LIST* STATUS MJN TPI1 IF FILE BEING LISTED LDD DP+2 CHECK BYTE LPN 17 LMN 2 NJN TPI1 IF NOT FIRST BYTE LDN 1RE RJM CLT CHECK FOR LINE TERMINATION LDD DP+3 SET TRANSPARENT MODE SCN 14 LMN 4 STD DP+3 JMP EOB1 TERMINATE OUTPUT BLOCK TPI1 LDN 1RE JMP AWT13 REENTER WRITE MODE BNI SPACE 4,25 *** 0006 INITIATE BINARY MODE INPUT. * * THIS CONTROL BYTE SETS BINARY INPUT FOR THE NEXT INPUT * REQUEST. THE CONTROL BYTE MUST BE THE FIRST BYTE OF A WORD. * THE NEXT 2 BYTES ARE THE TERMINATION CONDITIONS AS FOLLOWS - * * THE FIRST BYTE (BYTE 1) IS THE MAXIMUM NUMBER OF CHARACTERS * TO BE RECEIVED BEFORE THE INPUT IS TERMINATED. IF THE * VALUE IS 0, 1 IS ASSUMED. * * THE SECOND CONTROL BYTE (BYTE 2) IS A TERMINATION CODE. * WHEN A CHARACTER IS RECEIVED FROM THE TERMINAL WHICH * MATCHES THE BOTTOM 8 BITS OF THIS BYTE, THE INPUT OPERATION * IS TERMINATED. IF BIT 13 OF THIS BYTE IS SET, NO TERMINATION * CHARACTER IS ASSUMED. * * EXIT (CH) = TERMINATION CHARACTER. * (CH+1) = INPUT LINE CHARACTER COUNT. * * CALLS CKL, SWA. BNI5 LDN 1RF JMP AWT13 CONTINUE WRITE MODE * BNI - ENTRY. BNI BSS 0 ENTRY RJM CKL CHECK *LIST* STATUS MJN BNI5 IF FILE BEING LISTED LDD DP+3 CLEAR BINARY MODE SCN 10 STD DP+3 LDD CH+1 CHECK CHARACTER COUNT NJN BNI5 IF NOT FIRST BYTE RJM SWA SET WORD ADDRESS CRD CM READ DATA WORD LDD CM+3 CHECK FOR TERMINATION ADD CM+4 NJN BNI5 IF NOT TERMINATED LDD CM+1 SET CHARACTER COUNT NJN BNI2 BNI1 LDN 1 BNI2 STD CH+1 ADC -VXLL-1 MJN BNI3 IF NOT MORE THAN INTERACTIVE MAXIMUM LDD DC CHECK TERMINAL STATUS SHN 21-6 MJN BNI1 IF *READ DATA* SET BNI3 LDD CM+2 SET TERMINATION CHARACTER STD CH LDN 2 SET CHARACTER 2 STD DP+2 LDN 10 SET BINARY MODE RAD DP+3 RJM SWA WRITE FIRST WORD CWM BNIA,ON LDN 0 CLEAR START OF *F7* SEQUENCE STD F7 JMP RWC ENTER READ/WRITE CONTROL BNIA DATA 0007,0,0,0,0 BINARY MODE HEADER BNO SPACE 4,15 *** 0007 INITIATE BINARY MODE OUTPUT. * * THIS CONTROL BYTE INITIATES BINARY OUTPUT. IT MUST * APPEAR IN THE FIRST BYTE OF OUTPUT. * * EXIT TO *BWT* IF VALID CONTROL BYTE. * TO *AWT13* IF INVALID CONTROL BYTE. BNO BSS 0 ENTRY LDD DP+3 CLEAR BINARY MODE SCN 10 STD DP+3 LDD CH+1 CHECK CHARACTER COUNT NJN BNO1 IF NOT FIRST BYTE LDN 10 SET BINARY TRANSMISSION RAD DP+3 LJM BWT ENTER BINARY WRITE MODE BNO1 LDN 1RG JMP AWT13 CONTINUE WRITE MODE BEO SPACE 4,15 *** 0011 BEGIN EXENDED OUTPUT. * * THIS CONTROL BYTE INITIATES EXTENDED MODE OUTPUT. * IT MUST APPEAR IN THE FIRST BYTE OF THE OUTPUT LINE. * * EXIT TO *AWT* TO INITIATE EXTENDED OUTPUT. * TO *AWT13* IF INVALID CONTROL BYTE. * * CALLS SEM. BEO BSS 0 ENTRY LDD CH+1 NJN BEO1 IF NOT FIRST BYTE RJM SEM SET EXTENDED MODE JMP AWT INITIATE OUTPUT BEO1 LDN 1RI JMP AWT13 CONTINUE WRITE MODE EOS SPACE 4,15 *** 0013 END OF STRING. * * THIS BYTE ACTS AS A LOGICAL LINE TERMINATOR WHEN * FOLLOWED BY AN END OF LINE. THE TERMINAL CARRIAGE * WILL NOT BE REPOSITIONED AND OUTPUT WILL CONTINUE * WITH THE NEXT LINE OF DATA. * * EXIT (CH+1) = 0. * (CH+2) = 0. * TO *SOC* IF END OF CURRENT POT - * (A) = *.ECP*. * TO *AWT* TO CONTINUE WRITE IF NOT END OF POT. * * CALLS CEM, CLT, ROC. EOS BSS 0 ENTRY LDN 1RK CHECK FOR LINE TERMINATION RJM CLT STD CH+1 CLEAR CHARACTER COUNT STD CH+2 CLEAR CONTROL BYTE RJM ROC FORCE LINE SKIP IF IN BYTE 4 LMC .ECP CHECK IF END OF POT REACHED NJN EOS1 IF NOT END OF CURRENT POT LMC .ECP LJM SOC SET OUTPUT CONTROL EOS1 LDD DP+2 REPOSITION TO READ NEXT WORD SCN 17 LMN 12 STD DP+2 RJM CEM CLEAR EXTENDED MODE JMP AWT CONTINUE OUTPUT IEB SPACE 4,20 *** 0014 INTERNAL END OF BLOCK. * * THIS CONTROL BYTE IS USED INTERNALLY BY *1TO* ONLY TO * TERMINATE OUTPUT BEFORE THE END OF POT IS REACHED. THE * REMAINDER OF THE POT IS DISCARDED, THE TERMINAL IS NOT * REPOSITIONED TO THE BEGINNING OF THE NEXT LINE, AND ANY * SPECIAL MODES (E.G., EXTENDED OR BINARY TRANSMISSION) * WILL REMAIN SET. THIS BYTE MUST APPEAR AS THE FIRST BYTE * OF A WORD, AND MUST BE FOLLOWED BY AN END OF LINE. * * EXIT TO *RWC1* IF VALID CONTROL BYTE. * TO *AWT13* IF INVALID CONTROL BYTE. * * CALLS CLT. * * MACROS RETURN. IEB BSS 0 ENTRY LDD DP+2 CHECK CHARACTER POSITION LPN 17 LMN 2 NJN IEB1 IF NOT FIRST BYTE IN WORD LDN 1RL CHECK FOR LINE TERMINATION RJM CLT STD DP+2 CLEAR CHARACTER POSITION RETURN /CTL/RWC1 ENTER READ/WRITE CONTROL IEB1 LDN 1RL JMP AWT13 REENTER WRITE MODE ETI SPACE 4,15 *** 0015 EXECUTIVE AUTO INPUT. * * THIS CONTROL BYTE IS INTENDED TO BE USED BY *RDF* FOR * AUTO MODE INPUT. THE WORD IN WHICH THE CONTROL BYTE OCCURS * IS USED AS THE FIRST N CHARACTERS OF THE INPUT LINE. * N MUST BE EVEN AND LESS THAN 9. * * THIS CONTROL BYTE MUST BE FOLLOWED BY AN END-OF-LINE. * * EXIT TO *ATI1* TO INITIATE AUTO MODE INPUT - * (A) = 1RM. * (RTIA) = *RSW*. * (RTIB) = *LDNI+1RM*. ETI BSS 0 ENTRY LDC LDNI+1RM SET CONTROL TO REENTER WRITE MODE STM ATIB LDC RSW SET UP CALL TO SUBROUTINE RSW STM ATIA LDN 1RM LJM ATI1 AUTO MODE INPUT PROCESSING TITLE WRITE MODE - SPECIAL CHARACTER PROCESSORS. ACR SPACE 4,15 ** ACR - PROCESS *CARRIAGE RETURN* OUTPUT. * * ISSUES *CARRIAGE RETURN* TO THE TERMINAL, FOLLOWED * BY *NUL* CHARACTERS IF IN KEYBOARD MODE OR BY * *DEL* CHARACTERS IF IN TAPE MODE. * * EXIT TO *AWT* TO CONTINUE WRITE OPERATION. * * USES T7. * * CALLS DDC, SRC. * * MACROS RETURN. ACR BSS 0 ENTRY LDC .CCR ISSUE *CR* TO OUTPUT LMD PY TOGGLE ODD PARITY STD DO RETURN * REENTER LDN 3 SET DEFAULT DELAY COUNT RJM DDC DETERMINE TERMINAL DELAY COUNT STD T7 LDD DC CHECK TERMINAL STATUS LPN 1 ZJN ACR1 IF NOT IN *TAPE* MODE LDK .CDEL SET ASCII *DEL* CODE UJN ACR2 ACR1 LDK .CNUL SET ASCII *NUL* CODE ACR2 SHN 6 ADD DELAY COUNT ADD T7 SHN 14 LMD PY TOGGLE ODD PARITY RJM SRC SEND REPEATED CHARACTERS JMP AWT REENTER WRITE MODE ANL SPACE 4,15 ** ANL - PROCESS *NEW LINE* OUTPUT. * * ISSUES *CARRIAGE RETURN* FOLLOWED BY *LINE FEED* * TO THE TERMINAL, THEN FOLLOWED BY *NULL* CHARACTERS. * * EXIT TO *ISN* TO ISSUE *NULL* CHARACTERS. * * MACROS RETURN. ANL BSS 0 ENTRY LDC .CCR ISSUE *CR* TO OUTPUT LMD PY TOGGLE ODD PARITY STD DO RETURN * REENTER LDC .CLF ISSUE *LF* TO OUTPUT LMD PY TOGGLE ODD PARITY STD DO RETURN * REENTER LDN 2 SET DEFAULT REPEAT COUNT JMP ISN ISSUE *NUL*S WTM TITLE WRITE MODE - SUBROUTINES. CKL SPACE 4,15 ** CKL - CHECK LIST STATUS. * * EXIT (A) = NEGATIVE IF FILE LIST IN PROGRESS. * * USES T1 - T5. * * CALLS STA. CKL SUBR ENTRY/EXIT RJM STA SET FWA OF TERMINAL TABLE ADN VROT READ *VROT* CRD T1 LDD T1+4 LOAD STATUS BYTE SHN 21-6 SHIFT *LIST* STATUS BIT UJN CKLX RETURN CLT SPACE 4,25 ** CLT - CHECK FOR LINE TERMINATION. * * CHECKS CURRENT OUTPUT FOR LINE TERMINATION. * * ENTRY (A) = NEXT OUTPUT CHARACTER IF NOT END OF LINE. * * EXIT TO CALLING ROUTINE IF LINE TERMINATED. * TO WRITE MODE IF LINE NOT TERMINATED. * LINE TERMINATION CAN BE EXPLICIT IN THE CASE OF * A VALID END OF LINE FOLLOWING THE CURRENT LINE * POSITION, OR IT MAY BE IMPLICIT IN THE CASE OF THERE * BEING NO FURTHER DATA, EITHER ASSIGNED OR ON * MASS STORAGE. * IN THE EVENT THAT NO DETERMINATION CAN BE MADE * BECAUSE THE DRIVER IS AT THE END OF THE CURRENT * POT STRING BUT OUTPUT IS WAITING ON MASS STORAGE, * OR IF THE JOB IS CURRENTLY IN EXECUTION, * EXIT IS TO READ/WRITE CONTROL WITH SUSPENDED CONTROL * STATUS SET IN (CH+2). * * USES T0 - T5, CM, CM+1, (MA)-(MA)+5. * * CALLS RLT, ROC, STA. * * MACROS RETURN. CLT SUBR ENTRY/EXIT STD CM SAVE CALLING CODE LDD MA SAVE POINTER WORD CWD DP RJM ROC READ NEXT CHARACTER LMC .ECP ZJN CLT3 IF END OF CURRENT POT LMC .ECP * CHECK NEXT OUTPUT BYTE FOR END OF LINE. CLT1 SHN 1 CHECK FOR END OF LINE LMN 1 STD CM+1 STORE FLAG (ZERO IF END OF LINE) CLT2 LDD MA RESTORE POINTER WORD CRD DP LDD CM+1 CHECK FLAG ZJN CLTX IF END OF LINE LJM CLT6 * ADVANCE TO NEXT POT. CLT3 STD DP+2 CLEAR POINTERS STD CM+1 RJM RLT CHECK POT LINK ZJN CLT4 IF POT NOT LINKED STD DP+1 SET NEXT POT RJM ROC READ NEXT CHARACTER UJN CLT1 * CHECK FOR ADDITIONAL OUTPUT. CLT4 LDD DC CHECK FOR DRIVER REQUEST SHN 21-13 MJN CLT2 IF DRIVER REQUEST LDD DC+4 NJN CLT5 IF OUTPUT ASSIGNED RJM STA SET FWA OF TERMINAL TABLE ADN VROT READ *VROT* CRD T0 LDD T0+4 CHECK JOB STATUS LPN 21 LMN 1 ZJN CLT2 IF NOT EXECUTING AND NO OUTPUT * SUSPEND CONTROL UNTIL FURTHER OUTPUT IS ASSIGNED. CLT5 LDD MA RESET POINTER WORD CRD DP LDD CM SET SUSPENDED CONTROL ADC 600 STD CH+2 RETURN /CTL/RWC1 ENTER READ/WRITE CONTROL * REENTER WRITE MODE IF NO TERMINATOR. CLT6 LDD DP+3 CHECK *BINARY* MODE SHN 21-3 MJN CLT7 IF SET LDD CM SET OUTPUT CHARACTER LJM AWT13 REENTER WRITE MODE CLT7 SOD DP+2 BACK UP CHARACTER LJM BWT2 EXIT BINARY MODE MDS SPACE 4,15 ** MDS - MOVE DATA WORD TO START OF POT. * * MOVE THE WORD CONTAINING THE AUTO INPUT CONTROL BYTE * TO THE FIRST WORD OF THE POT FOR SUBSEQUENT INPUT. * * ENTRY (TO - T4) = DATA WORD. * * CALLS SWA. MDS SUBR ENTRY/EXIT LDD DP+2 CLEAR POT WORD POINTER LPC 0617 STD DP+2 RJM SWA SET WORD ADDRESS CWD T0 WRITE WORD TO POT UJN MDSX RETURN ROC SPACE 4,20 ** ROC - READ OUTPUT CHARACTER. * * EXIT (T5) = OUTPUT BYTE ADDRESS. * (T7) = LOWER 12 BITS OF (A). * (A) = POSITIVE - * (A) = OUTPUT CHARACTER. * = NEGATIVE - * (A) = 400000B + CONTROL BYTE VALUE, OR, * 770001 (END OF POT). * * USES DP+2, T7, T0 - T5. * * CALLS SWA. * * MACROS ADCBM. * PROCESS ODD (LOWER) CHARACTER. ROC9 LPN 7 SET BYTE NUMBER STD T5 AOD DP+2 ADVANCE CHARACTER NUMBER RJM SWA READ DATA WORD CRD T0 LDI T5 EXTRACT LOWER CHARACTER LPN 77 ROC10 STD T7 SET CHARACTER * UJN ROCX * ROC - ENTRY. ROC SUBR ENTRY/EXIT LDD DP+1 CHECK CURRENT POT POINTER SHN -6 LMN 77 NJN ROC1 IF NOT MESSAGE PSEUDO-POT POINTER LJM TTM1 GET MESSAGE CHARACTER ROC1 LDD DP+2 CHECK CHARACTER NUMBER SHN 21 MJN ROC9 IF ODD CHARACTER * PROCESS EVEN (UPPER) CHARACTER. LPN 77 CHECK WORD STATUS LMN 75 NJN ROC2 IF NOT END OF WORD AND END OF POT LDC .ECP UJN ROCX ROC2 LPN 7 NJN ROC3 IF NOT END OF WORD STD T5 SET BYTE 0 LDN 21-12 ADVANCE WORD AND SET ODD CHARACTER RAD DP+2 UJN ROC4 ROC3 LMN 5 SET BYTE NUMBER STD T5 AOD DP+2 ADVANCE CHARACTER ROC4 RJM SWA SET WORD ADDRESS CRD T0 READ WORD LDI T5 EXTRACT UPPER CHARACTER SHN -6 NJN ROC6 IF NOT CONTROL BYTE LDI T5 ZJN ROC7 IF ZERO BYTE SBN TSOCL PJN ROC8 IF NOT CONTROL BYTE ADN TSOCL ROC5 LMC 400000 ROC6 LJM ROC10 * CHECK FOR END OF LINE. ROC7 AOD T5 ADVANCE BYTE POINTER LMN 5 ZJN ROC5 IF END OF WORD LDI T5 ZJN ROC7 IF NO DATA IN NEXT BYTE ROC8 LDN 0 ISSUE COLON UJN ROC6 RSW SPACE 4,15 ** RSW - RESTORE WORD. * * THE WORD IN WHICH THE CONTROL BYTE 0015 OCCURS IS USED * AS THE FIRST N CHARACTERS OF THE INPUT LINE. * * ENTRY (T0 - T4) = DATA WORD. * * CALLS SWA. RSW SUBR ENTRY/EXIT RJM SWA SET WORD ADDRESS CWD T0 WRITE WORD TO POT UJN RSWX RETURN SRC SPACE 4,15 ** SRC - SEND REPEATED CHARACTER. * * ENTRY (A) = 6/REPEAT COUNT, 12/CHARACTER. * * EXIT CHARACTER TRANSMITTED (A) TIMES. * * USES (CH) = RETURN ADDRESS. * (CH+1) = REPEAT COUNT. * * MACROS RETURN. SRC SUBR ENTRY/EXIT LPC -4000 SET OUTPUT CHARACTER BIT LMC 4000 STM RDAT SAVE CHARACTER SHN -14 SET REPEAT COUNT STD CH+1 ZJN SRCX IF ZERO LDM SRC SET RETURN ADDRESS STD CH SRC1 LDM RDAT TRANSMIT OUTPUT STD DO RETURN * REENTER SOD CH+1 DECREMENT REPEAT COUNT NJN SRC1 IF NOT EXHAUSTED LJM 0,CH REENTER CALLING ROUTINE TOC SPACE 4,15 ** TOC - TRANSLATE ASCII OUTPUT CHARACTER. * * TRANSLATES OUTPUT DATA CHARACTER AND SETS THE * PROPER PARITY (EVEN OR ODD) ON THE TRANSLATED * OUTPUT CHARACTER. * * ENTRY (T7) = CHARACTER TO BE TRANSLATED. * * EXIT (A) = 4000B+CHARACTER IF SPECIAL PROCESOR * NOT DEFINED. * = SPECIAL PROCESSOR INDEX IF DEFINED. * (T7) = (A). TOC SUBR ENTRY/EXIT LDM TOTP,T7 READ TRANSLATION TABLE ENTRY STD T7 SHN 21-13 CHECK FOR VALID CHARACTER PJN TOC1 IF IF SPECIAL PROCESSOR LDD T7 TOGGLE PARITY LMD PY TOGGLE ODD PARITY STD T7 TOC1 LDD T7 RETURN (A) = TRANSLATION UJN TOCX RETURN SPACE 4,10 QUAL WTM EQU /WTM/WTM TTM EQU /WTM/TTM DELM EQU /WTM/DELM LOFM EQU /WTM/LOFM MBSY EQU /WTM/MBSY RDYM EQU /WTM/RDYM RILM EQU /WTM/RILM ITM TITLE GENERAL SUBROUTINES. AVT SPACE 4,15 ** AVT - ADVANCE TIMERS. * * EXIT (HS) = NONZERO IF 1/2 SECOND ELAPSED. * = CLEARED BETWEEN 1/2 SECOND CYCLES. * (IT) = DECREMENTED BY ONE EACH 1/2 * SECOND IF NONZERO. * * USES CM - CM+4. * * MACROS DELAY. AVT SUBR ENTRY/EXIT AVT1 LDK RTCL READ REAL-TIME CLOCK CRD CM LDD CM+4 CHECK CYCLE TIME SBM AVTA PJN AVT2 IF NO OVERFLOW ADC 10000 AVT2 SBK MNCT PJN AVT3 IF MINIMUM CYCLE TIME ELAPSED DELAY UJN AVT1 LOOP AVT3 LDD CM+4 UPDATE MSECS BITS 11-0 STM AVTA SHN -11 CHECK INTERVAL SHN 17 LMD CM+3 SHN 3 LPC 7777 SBM AVTB CHECK MSECS BITS 20-9 ZJN AVT4 IF NO CHANGE RAM AVTB UPDATE MSECS BITS 20-9 LDN 1 AVT4 STD HS SET/CLEAR HALF-SECOND FLAG ZJN AVT5 IF NOT 1/2 SECOND INTERVAL LDD IT CHECK 1/2 SECOND TIMER ZJN AVT5 IF ZERO SOD IT DECREMENT TIMER AVT5 UJP AVTX RETURN AVTA CON 0 PREVIOUS REAL-TIME MSECS (BITS 11-0) AVTB CON 0 PREVIOUS REAL-TIME MSECS (BITS 20-9) BUP SPACE 4,15 ** BUP - BACK UP POINTERS. * * BACKS UP THE CURRENT CHARACTER, CURRENT WORD, * AND CURRENT POT POINTERS TO THE IMMEDIATELY * PRECEDING CHARACTER POSITION. * * EXIT (DP+1) = NEW CURRENT POT. * (DP+2) = NEW CURRENT WORD AND CHARACTER. * * USES T5, T6. * * CALLS RLT. BUP5 SOD DP+2 DECREMENT CHARACTER NUMBER BUP SUBR ENTRY/EXIT LDD DP+2 CHECK CHARACTER NUMBER LPN 17 NJN BUP5 IF NOT FIRST CHARACTER OF WORD LDD DP+1 CHECK CURRENT POT LMD DP NJN BUP2 IF NOT FIRST POT LDD DP+2 CHECK WORD NUMBER SHN 5 LMD DP+2 LPC 7000 ZJN BUPX IF FIRST WORD BUP1 LCN 20-11 DECREMENT WORD NUMBER, SET LAST CHARACTER RAD DP+2 UJN BUPX BUP2 LDD DP+2 CHECK CURRENT WORD LPC 160 NJN BUP1 IF NOT FIRST WORD OF POT LDD DP+1 SAVE CURRENT POT STD T6 LDD DP SET FIRST POT BUP3 STD DP+1 RJM RLT READ LINK TABLE LMD T6 ZJN BUP4 IF CURRENT POT REACHED LMD T6 SET NEXT POT UJN BUP3 LOOP BUP4 LDD DP+2 SET LAST WORD, LAST CHARACTER LPC 7000 LMC 371 SET *POT REQUESTED* STD DP+2 LJM BUPX RETURN CCQ SPACE 4,15 ** CCQ - CHECK CIRCULAR REQUEST QUEUE. * * CHECKS THE DRIVER CIRCULAR REQUEST QUEUE FOR * AMOUNT OF FREE SPACE REMAINING AND RECALLS THE * CPU IF THE QUEUE IS MORE THAN HALF FULL. * * USES CM - CM+4. * * MACROS LDCDQ, MONITOR. CCQ SUBR ENTRY/EXIT LDCDQ 3 READ CIRCULAR QUEUE *OUT* POINTER CRD CM LDD IN+3 CHECK *IN* - *OUT* SBD CM+3 SHN 14 ADD IN+4 SBD CM+4 PJN CCQ1 IF *IN* .GE. *OUT* ADK VDSL CCQ1 SBK VDSL/2 MJN CCQX IF QUEUE .LE. HALF FULL MONITOR RCLM RECALL CPU UJN CCQX RETURN CEF SPACE 4,15 ** CEF - CHECK ERROR FLAG. * * CHECKS CPU ERROR FLAG. IF SET, DROPS EQUIPMENT * AND CHANNEL AND DROPS THE PPU. * * EXIT TO *DPP* IF ERROR FLAG SET. * * USES CM - CM+4. CEF SUBR ENTRY/EXIT LDD CP READ CP STATUS WORD ADK STSW CRD CM LDD CM+1 CHECK ERROR FLAG ZJN CEFX IF NO ERROR FLAG LJM DPP DROP PPU CEM SPACE 4,15 ** CEM - CLEAR EXTENDED TRANSMISSION MODE. * * SET/RESET EXTENDED TRANSMISSION MODE DEPENDING * UPON MODE IN *VDCT*. * * EXIT (A) = (DP+3). * (DP+3) = EXTENDED MODE CLEARED OR SET. CEM SUBR ENTRY/EXIT LDD DP+3 CLEAR EXTENDED MODE SCN 2 STD DP+3 LDD DC GET TERMINAL STATUS SHN 1-3 SET EXTENDED/NORMAL MODE LPN 2 RAD DP+3 UJN CEMX RETURN CIT SPACE 4,15 ** CIT - CHECK FOR INACTIVITY TIME-OUT. * * ENTRY (IR+3) = REAL-TIME CLOCK (SECONDS) AT START * OF DRIVER INACTIVITY TIME-OUT. * * EXIT (A) = NONZERO IF DRIVER TIMED-OUT. * = ZERO IF NOT TIMED-OUT. * * USES CM - CM+4. CIT SUBR ENTRY/EXIT LDK SSTL READ SUBSYSTEM CONTROL WORD CRD CM LDD CM+3 CHECK *RDF* STATUS SHN 21-10 PJN CIT2 IF *RDF* IN DEDICATED STATUS LDK RTCL READ REAL-TIME CLOCK CRD CM LDD CM+1 CHECK ELAPSED TIME SBD IR+3 PJN CIT1 IF NO ROLLOVER ADC 10000 CIT1 SBK INATIO SUBTRACT TIME-OUT INTERVAL MJN CIT2 IF INTERVAL NOT EXCEEDED LDN 77 (A) STATUS = TIMED-OUT UJN CITX RETURN CIT2 LDN 0 (A) STATUS = NOT TIMED-OUT UJN CITX RETURN CMF SPACE 4,15 ** CMF - CHECK *RDF* STATUS. * * CHECKS TO SEE THAT *RDF* IS ENABLED. IF NOT, * ISSUE ERROR LOG MESSAGE AND EXIT TO *ERR*. * * EXIT RETURN TO CALLER IF *RDF* ENABLED. * TO *ERR* IF *RDF* DISABLED - * ERROR LOG MESSAGE ISSUED. * (A) = ADDRESS OF DAYFILE MESSAGE. * * USES T1, CM - CM+4. * * CALLS DFM. CMF SUBR ENTRY/EXIT LDK SSSL READ SUBSYSTEM STATUS CRD CM LDM CMFB+1 SET MASK STM CMFC LDM CMFB GET *SSSL* BYTE NUMBER STD T1 LDM CM,T1 READ BYTE LPC ** CMFC EQU *-1 (*RDF* MASK BIT) ZJN CMFX IF *RDF* NOT DISABLED LDN MTER * RDF TERMINATED.* JMP IMT ISSUE MESSAGE AND TERMINATE * CALCULATE *SSSL* BYTE AND MASK FOR *RDF*. .1 SET MXSI-RDSI .2 SET .1/12D .3 SET 4-.2 .4 DECMIC .1-12D*.2 .5 SET 1S".4" CMFB CON .3 *SSSL* BYTE NUMBER CON .5 *SSSL* MASK CUT SPACE 4,15 ** CUT - CLEAN UP TERMINAL TABLE. * * CLEARS ALL INFORMATION FROM THE TERMINAL TABLE OF THE * LOGGED OUT USER, LEAVING VROT SET COMPLETE. * * EXIT TERMINAL TABLE WORDS ZEROED OUT. (VROT), BIT * ZERO, SET. * * USES T0 - T5. * * CALLS STA. CUT SUBR ENTRY/EXIT LDN ZERL CRD T0 LDN 0 STD T5 CUT1 RJM STA SET FWA OF TERMINAL TABLE ADD T5 CWD T0 CLEAR OUT TERMINAL TABLE AOD T5 SBN VTTL NJN CUT1 IF MORE WORDS TO CLEAR AOD T4 SET COMPLETE BIT IN VROT RJM STA SET FWA OF TERMINAL TABLE ADN VROT WRITE *VROT* CWD T0 UJN CUTX EXIT CWA SPACE 4,15 ** CWA - SET DRIVER CONTROL WORD ADDRESS. * * RETURNS THE ABSOLUTE CM ADDRESS OF THE DRIVER CONTROL * WORD WITHIN *RDF* FIELD LENGTH. * * ENTRY (IR+4) = DRIVER CONTROL WORD POINTER. * * EXIT (A) = CM ADDRESS OF DRIVER CONTROL WORD. CWA SUBR ENTRY/EXIT LDD RA SET CM ADDRESS SHN 6 ADD IR+4 ADD DRIVER CONTROL WORD POINTER UJN CWAX RETURN DCE SPACE 4,15 ** DCE - DROP CHANNEL AND EQUIPMENT. * * ENTRY (EQ) = BIT 2**9 SET IF EQUIPMENT RESERVED. * * EXIT CHANNEL AND EQUIPMENT DROPPED. * (EQ) = BIT 2**9 RESET. * * USES CM - CM+4. * * CALLS CLR, RTM. * * MACROS DCHAN, MONITOR. DCE SUBR ENTRY/EXIT LDD EQ CHECK EQUIPMENT SBD TH MJN DCEX IF NOT RESERVED STD EQ CLEAR BIT 2**9 STD CM+1 DROP EQUIPMENT MONITOR DEQM LDN MX DROP MULTIPLEXER CHANNEL DCHAN RJM RTM RELEASE TERMINAL ON MULTIPLEXER RJM CLR CLEAR LAST REQUEST UJN DCEX RETURN DDC SPACE 4,20 ** DDC - DETERMINE DELAY COUNT. * * DETERMINES THE TERMINAL NULL CHARACTER (*NUL* OR * *DEL*) COUNT BASED UPON THE DELAY COUNT IN THE * USER'S TERMINAL TABLE AND UPON THE DEFAULT COUNT * PRESENTED TO THE ROUTINE. IF THERE IS NO COUNT * DEFINED IN THE TERMINAL TABLE, THE DEFAULT COUNT * WILL BE USED. * * ENTRY (A) = DEFAULT COUNT. * * EXIT (A) = DELAY COUNT. DDC SUBR ENTRY/EXIT STD T0 SAVE DEFAULT COUNT LDD DC+1 GET USER DELAY COUNT SHN -3 LPN 37 ZJN DDC1 IF NO USER DELAY COUNT DEFINED STD T0 DDC1 LDD T0 GET DELAY COUNT UJN DDCX RETURN DPP SPACE 4,15 ** DPP - DROP PPU. * * DROPS CHANNEL AND EQUIPMENT, SIGNALS DRIVER SHUTDOWN * TO *RDF*, AND DROPS THE PPU. * * EXIT TO *PPR*. * * CALLS DCE, SDS. * * MACROS MONITOR. DPP BSS 0 ENTRY RJM DCE DISCONNECT CHANNEL AND EQUIPMENT RJM SDS SIGNAL DRIVER SHUTDOWN MONITOR DPPM DROP PPU LJM PPR EXIT TO PPU RESIDENT ERQ SPACE 4,20 ** ERQ - ENTER CIRCULAR REQUEST QUEUE. * * ERQ IS USED TO PLACE AN ENTRY IN THE DRIVER CIRCULAR REQUEST * QUEUE FOR *RDF* TO PROCESS. * * ENTRY (A) = REQUEST CODE. * (RQ+1 - RQ+3) = PARAMETERS. * (TN) = TERMINAL NUMBER. * * EXIT IN UPDATED. * (A) = 0. * (RQ+1 - RQ+3) = 0. * * USES IN+3, IN+4, RQ - RQ+3. * * MACROS LDCDQ, LMCDQ. ERQ1 AOD IN+4 ADVANCE IN SHN -14 RAD IN+3 ADD OVERFLOW ERQ2 LDCDQ 2 UPDATE IN CWD IN LDN 0 EXIT ERQ WITH A=0 STD RQ+1 CLEAR REQUEST BUFFER STD RQ+2 STD RQ+3 * ERQ - ENTRY. ERQ SUBR ENTRY/EXIT ADC 2000 ADD FUNCTION BIAS STD RQ LDD IN+3 ENTER REQUEST SHN 6 ADD RA SHN 6 ADD IN+4 CWD RQ LMCDQ 4+VDSL NJN ERQ1 IF *IN* NOT EQUAL TO LIMIT-1 LDCDQ 1 RESET IN = FIRST CRD IN UJN ERQ2 FTER SPACE 4,10 ** FTER - FUNCTION TIME-OUT ERROR PROCESSOR. * * ENTRY (A) = FUNCTION CODE. * * EXIT (A) = 1/ERROR LOG FLAG, 5/MESSAGE NUMBER. FTER BSS 0 ENTRY STM IMTB SAVE FUNCTION CODE LDN MFTO+40 * RMEEE CXX PYY FNNNN REJECT.* * JMP IMT ISSUE MESSAGE AND TERMINATE IMT SPACE 4,10 ** IMT - ISSUE MESSAGE AND TERMINATE. * * ENTRY (A) = 1/ERROR LOG FLAG, 5/MESSAGE NUMBER. * * EXIT TO *4TM*. * * MACROS EXECUTE. IMT BSS 0 ENTRY STM IMTA SAVE MESSAGE REQUEST EXECUTE 4TM LJM DPP DROP PP IMTA BSS 1 MESSAGE REQUEST IMTB BSS 1 FUNCTION CODE MRER SPACE 4,10 ** MRER - NORMAL ERROR PROCESSOR FOR *COMPMRA*. * * EXIT (A) = MESSAGE NUMBER. MRER BSS 0 ENTRY LDN MNTA * NO TPM AVAILABLE.* UJN IMT ISSUE MESSAGE AND TERMINATE RCL SPACE 4,15 ** RCL - RECALL PPU. * * REQUESTS PPU RECALL AFTER DEFINED DELAY PERIOD, * THEN EXITS TO PPU RESIDENT. * * ENTRY (IR - IR+4) = PPU INPUT REGISTER. * * EXIT TO *PPR*. * (IR+2) = 10/EQ, 1/S, 1/P. * EQ = RESERVED EQUIPMENT NUMBER. * S = 1, IF PORT CURRENTLY IS RESERVED FOR * *1TM*. * P = PORT NUMBER. * * USES CM - CM+4. * * MACROS DCHAN, MONITOR. RCL BSS 0 ENTRY LDN MX DROP CHANNEL DCHAN LDD EQ SAVE RECALL STATUS INFORMATION SHN 2 LMD PN STD IR+2 LDM SFMX ZJN RCL1 IF PORT NOT ATTACHED LDD IR+2 LMN 2 STD IR+2 RCL1 LDD MA WRITE INPUT REGISTER TO MESSAGE BUFFER CWD IR LDN ZERL CLEAR REQUEST PARAMETERS CRD CM LDK PTMF SET TIMED RECALL REQUEST STD CM+1 LDC RCLDLY*1000D SET RECALL DELAY (MILLISECONDS) STD CM+4 SHN -14 STD CM+3 MONITOR RECM REQUEST PPU RECALL JMP PPR EXIT TO PPU RESIDENT RLT SPACE 4,15 ** RLT - READ LINK TABLE. * * READS THE POT LINK TABLE. * * ENTRY (DP+1) = POT POINTER IN LINK TABLE. * * EXIT (A) = NEXT POT. * * USES T0 - T5. * * MACROS ADCPL. RLT SUBR ENTRY/EXIT LDD DP+1 SET BYTE NUMBER LPN 3 STD T5 LDD DP+1 READ LINK WORD SHN -2 ADCPL CRD T0 LDI T5 RETURN WITH NEXT LINK UJN RLTX SAT SPACE 4,15 ** SAT - SET ACTIVITY TIME. * * SETS THE LOWER 12 BITS OF THE REAL-TIME SECONDS * CLOCK INTO (IR+3). * * EXIT (IR+3) = CURRENT REAL-TIME SECONDS. * * USES CM - CM+4. SAT SUBR ENTRY/EXIT LDK RTCL READ REAL-TIME CLOCK CRD CM LDD CM+1 SET SECONDS STD IR+3 UJN SATX RETURN SDS SPACE 4,15 ** SDS - SIGNAL DRIVER SHUTDOWN. * * SIGNALS DRIVER SHUTDOWN BY SETTING THE DRIVER * SHUTDOWN FLAG IN THE DRIVER CONTROL WORD. * * EXIT DRIVER SHUTDOWN FLAG SET IN DRIVER * CONTROL WORD. * * USES CM - CM+4. * * CALLS CWA. SDS SUBR ENTRY/EXIT RJM CWA SET DRIVER CONTROL WORD ADDRESS CRD CM READ DRIVER CONTROL WORD LDD CM CHECK SHUTDOWN FLAG NJN SDSX IF DRIVER SHUTDOWN ALREADY SET, RETURN LDN 1 SET DRIVER SHUTDOWN FLAG STD CM RJM CWA REWRITE DRIVER CONTROL WORD CWD CM UJN SDSX RETURN SEM SPACE 4,15 ** SEM - SET EXTENDED MODE. * * SETS THE EXTENDED *ASCII* MODE BIT IN DP+3. * * EXIT (DP+3) = EXTENDED (*ASCII*) MODE SET. SEM SUBR ENTRY/EXIT LDD DP+3 SET *ASCII* MODE SCN 2 LMN 2 STD DP+3 UJN SEMX RETURN STA SPACE 4,15 ** STA - SET TERMINAL TABLE ADDRESS. * * SETS THE ABSOLUTE CM FWA OF TERMINAL TABLE. * * ENTRY (TN) = TERMINAL NUMBER. * * EXIT (A) = ABSOLUTE FWA OF TERMINAL TABLE. * * MACROS TTADD. STA SUBR ENTRY/EXIT TTADD 0 SET FWA OF TERMINAL TABLE UJN STAX RETURN SVM SPACE 4,15 ** SVM - SERVICE MULTIPLEXER. * * PERFORMS DATA OUTPUT AND INPUT OPERATIONS ON THE * TWO-PORT MULTIPLEXER. * * ENTRY (DO) = OUTPUT DATA IF BIT 2**11 SET. * * EXIT (DO) = ZERO IF DATA SENT. * = OUTPUT DATA IF OUTPUT BUFFER FULL. * (DI) = INPUT DATA. * = ZERO IF NO INPUT DATA. * * CALLS IFN, RMA, SPA. SVM4 LDN 0 STM SVMA SVM5 RJM RMA RELEASE MULTIPLEXER ACCESS SVM SUBR ENTRY/EXIT LDN 0 CLEAR INPUT DATA STD DI LDM SFMX ZJN SVMX IF PORT NOT SELECTED RJM SPA START PORT ACCESS LPN 6 CHECK *CARRIER ON* AND *DATA SET READY* LMN 6 NJN SVM5 IF NOT *CARRIER ON* AND *DATA SET READY* * WRITE OUTPUT DATA TO MULTIPLEXER PORT. LDM SSMX GET PORT STATUS LPN 20 ZJN SVM1 IF NOT *OUTPUT BUFFER READY* LDD DO CHECK OUTPUT DATA SHN 21-13 PJN SVM1 IF NO OUTPUT DATA LDC MXWT SELECT *WRITE* FUNCTION RJM IFN LDD DO TRANSMIT DATA TO PORT LPC 377 ACN MX OAN MX DCN MX+40 LDN 0 CLEAR OUTPUT DATA POINTER STD DO * READ INPUT DATA FROM MULTIPLEXER PORT. SVM1 LDC ** SVMA EQU *-1 ZJN SVM2 IF NO PREVIOUS CHARACTER STD DI RETURN PREVIOUS CHARACTER UJP SVM4 RELEASE MULTIPLEXER ACCESS SVM2 LDM SSMX CHECK PORT STATUS LPN 10 ZJN SVM3 IF NOT *INPUT DATA READY* LDD HN SELECT *READ* FUNCTION ERRNZ MXRD-100 *MXRD* CHANGED RJM IFN ACN MX IAN MX INPUT DATA FROM PORT DCN MX+40 SVM3 STD DI STORE INPUT DATA UJP SVM5 RELEASE MULTIPLEXER ACCESS SWA SPACE 4,15 ** SWA - SET WORD ADDRESS. * * SET ADDRESS OF CURRENT WORD OF CURRENT POT. * * ENTRY (DP+1) = CURRENT POT. * (DP+2) = WORD POINTER. * * EXIT (A) = CM ADDRESS OF CURRENT WORD (ABSOLUTE). * * MACROS ADCBM. SWA SUBR ENTRY/EXIT LDD DP+2 SET WORD LPC 160 SHN 21-6 LMD DP+1 SET POT POINTER SHN 3 TIMES 10B ADCBM ADD POT BUFFER ADDRESS UJN SWAX WDC SPACE 4,15 ** WDC - WRITE TERMINAL TABLE WORD *VDCT*. * * WRITES TERMINAL TABLE WORD *VDCT* TO CENTRAL MEMORY. * * ENTRY (DC - DC+4) = TERMINAL TABLE WORD *VDCT*. * * EXIT (A) = ADDRESS OF *VDCT* WORD. * * CALLS STA. WDC SUBR ENTRY/EXIT RJM STA SET FWA OF TERMINAL TABLE ADN VDCT WRITE *VDCT* TO CM CWD DC UJN WDCX RETURN SPACE 4,10 ** COMMON DECKS MRA$ EQU 0 LIST X QUAL$ EQU 0 *CALL COMPMRA APA$ EQU 0 PMA$ EQU 0 *CALL COMPTMA LIST -X OMBUF SPACE 4,15 ** OMBUF - OPERATOR MESSAGE BUFFER. OMBUF BSS 0 OPERATOR MESSAGE BUFFER OVLA EQU OMBUF+OMBUFL+5 OVERLAY LOAD ADDRESS PRS TITLE DRIVER PRESET. USE PRESET PRS SPACE 4,30 ** PRS - PRESET DRIVER. * * ENTRY (IR+2) = 0, IF NOT PP RECALL AND NOT *2TM* CALL. * = 10/EQ, 1/S, 1/P, IF PP RECALL OR *2TM* CALL. * EQ = RESERVED EQUIPMENT NUMBER. * S = 1, IF PORT CURRENTLY IS RESERVED FOR * *1TM*. * P = PORT NUMBER. * (IR+3) = REAL-TIME CLOCK (SECONDS) AT START * OF DRIVER INACTIVITY TIME-OUT. * = ZERO ON INITIAL CALL OR EXECUTIVE RECALL. * (IR+4) = DRIVER CONTROL WORD POINTER. * (DRIVER CONTROL WORD) INITIAL CALL = * 12/0, 6/0, 18/DRN, 24/0 * DRN = DRIVER NAME. * (DRIVER CONTROL WORD) PP OR EXECUTIVE RECALL = * 12/3, 24/CSA, 12/TC, 12/TN * CSA = CIRCULAR STACK ADDRESS. * TC = TERMINAL COUNT. * TN = DRIVER TERMINAL NUMBER. * * EXIT TO *ITM*, DRIVER CONTROL LOOP - * CHANNEL AND EQUIPMENT RESERVED. * (EQ) = EST ORDINAL + 2**9. * (LF) = NONZERO FOR INITIAL CONNECTION ATTEMPT. * (PN) = MULTIPLEXER PORT NUMBER - 0 OR 1. * (IR+3) = CURRENT REAL-TIME CLOCK (SECONDS) * IF INITIAL CALL OR EXECUTIVE RECALL. * = INPUT REGISTER CONTENTS IF PP RECALL. * (OMCC) = 0. * (SF7D) = 0. * TRANSLATION TABLES MODIFIED IF SYSTEM IS IN * 63 CHARACTER SET MODE. * * CALLS CEF, CWA, PMA, SAD, SAT, SPN, STA. * * MACROS EXECUTE, LDCDQ, RCHAN. PRS BSS 0 ENTRY RJM PMA PRESET MULTIPLEXER ACCESS LDD IR+2 NJN PRS1 IF RECALL EXECUTE 2TM PRESET NON-RECALL LOAD * PRESET VALUES FROM RECALL. PRS1 LPN 1 STD PN SET PORT NUMBER RJM SPN STD IT CLEAR INTERVAL TIMER LDD IR+2 LPN 2 ZJN PRS2 IF PORT WAS NOT SELECTED LDD PN ADC MXPT STM SFMX PRS2 LDD IR+2 RESTORE EQUIPMENT NUMBER SHN -2 STD EQ LDN MX REQUEST CHANNEL RCHAN LDN 2 SET PORT ACQUIRED BEFORE FLAG STM STMC RJM CEF CHECK ERROR FLAG LDM SFMX NJN PRS3 IF PORT SELECTED LDC /CTL/RPA SET REENTRY ADDRESS TO REGAIN PORT STM PRSA LDN RPATIO SET TIME-OUT STD IT * SET ABSOLUTE ADDRESSES AND SIGNAL INITIALIZATION COMPLETE. PRS3 RJM SAD SET ABSOLUTE CM ADDRESSES RJM CWA READ DRIVER CONTROL WORD CRD DC LDD DC+4 STD TN LDN 0 CLEAR INTERLOCK STD DC RJM CWA REWRITE DRIVER CONTROL WORD CWD DC * PRESET TERMINAL ROUTINE ADDRESS. LDN ZERL CLEAR *VDPT* IMAGE CRD DP CRD CH CLEAR *VCHT* IMAGE LDC /CTL/ONL SET STARTING ADDRESS PRSA EQU *-1 * LDC /CTL/RPA (PP RECALL AND PORT NOT SELECTED) STD DP+4 RJM STA SET FWA OF TERMINAL TABLE ADN VDPT WRITE *VDPT* CWD DP ADN VCHT-VDPT WRITE *VCHT* CWD CH * INITIALIZE MISCELLANEOUS POINTERS. LDN 0 CLEAR INPUT AND OUTPUT DATA STD DI STD DO STD F7 CLEAR START OF *F7* SEQUENCE DETECTED STD HS CLEAR HALF-SECOND FLAG STD PY CLEAR ODD PARITY STM OMCC CLEAR OPERATOR MESSAGE CHARACTER COUNT LDN 77 STD LF LDCDQ 2 SET CIRCULAR QUEUE *IN* CRD IN * SET TIME-OUT IF INITIAL CALL OR EXECUTIVE RECALL. LDD IR+3 CHECK TIME-OUT NJN PRS4 IF DRIVER RECALL RJM SAT SET ACTIVITY TIME-OUT PRS4 LJM /CTL/ITM ENTER DRIVER MAIN LOOP TITLE DRIVER PRESET SUBROUTINES. SAD SPACE 4,15 ** SAD - SET ABSOLUTE ADDRESSES. * * DETERMINES ABSOLUTE CM ADDRESS AND CALLS *SIA* * TO INSERT THEM INTO PP INSTRUCTIONS. * * USES T1, CM - CM+4. * * CALLS CWA, SIA. SAD SUBR ENTRY/EXIT * SET BUFFER MEMORY ADDRESS REFERENCES. LDC TBMA SET INSTRUCTION ADDRESS TABLE POINTER STD T1 LDD RA READ BUFFER MEMORY POINTER SHN 6 ADK VBMP CRD CM LDN CM+3 SET FWA BUFFER MEMORY RJM SIA SET INSTRUCTION ADDRESSES * SET DRIVER REQUEST QUEUE REFERENCES. LDC TDQA SET INSTRUCTION ADDRESS TABLE POINTER STD T1 RJM CWA READ DRIVER CONTROL WORD CRD CM LDN CM+1 SET FWA DRIVER REQUEST QUEUE RJM SIA SET INSTRUCTION ADDRESSES * SET POT LINK TABLE REFERENCES. LDC TPLA SET INSTRUCTION ADDRESS TABLE POINTER STD T1 LDD RA READ POT LINK TABLE POINTER SHN 6 ADK VPLP CRD CM LDN CM+1 SET FWA POT LINK TABLE RJM SIA SET INSTRUCTION ADDRESSES * SET TERMINAL TABLE REFERENCES. LDC TTTA SET INSTRUCTION ADDRESS TABLE POINTER STD T1 LDD RA READ TERMINAL TABLE ADDRESS POINTER SHN 6 ADK VTTP CRD CM LDN CM+1 SET FWA OF TERMINAL TABLES RJM SIA SET INSTRUCTION ADDRESSES UJP SADX RETURN SIA SPACE 4,15 ** SIA - SET INSTRUCTION ADDRESSES. * * SETS ABSOLUTE ADDRESSES IN INSTRUCTION ADDRESS * FIELDS. * * ENTRY (T1) = ADDRESS OF TABLE OF INSTRUCTION * ADDRESSES. * (A) = ADDRESS IN PP OF CM ADDRESS. * * USES T2, T6, T7. SIA SUBR ENTRY/EXIT STD T2 SAVE ADDRESS POINTER LDI T2 GET ABSOLUTE ADDRESS SHN 6 ABSOLUTE RELATIVE ADDRESS ADD RA SHN 6 ADM 1,T2 STD T7 SAVE LOWER 12 BITS SHN -14 STD T6 SIA1 LDI T1 READ INSTRUCTION ADDRESS ZJP SIAX IF END OF ADDRESS TABLE STD T2 LDD T7 SET LOWER 12 BITS RAM 1,T2 SHN -14 ADD T6 ADD OVERFLOW RAI T2 SET UPPER 6 BITS AOD T1 ADVANCE TABLE INDEX UJN SIA1 LOOP TO END OF TABLE SPACE 4,10 QUAL PMA HERE ITM TITLE INITIALIZATION TABLES. ITM SPACE 4,15 ** TABLES OF CENTRAL MEMORY REFERENCE INSTRUCTION * ADDRESSES. TBMA BSS 0 BUFFER MEMORY REFERENCES TBMA HERE CON 0 TDQA BSS 0 DRIVER REQUEST QUEUE REFERENCES TDQA HERE CON 0 TPLA BSS 0 POT LINK TABLE REFERENCES TPLA HERE CON 0 TTTA BSS 0 TERMINAL TABLE REFERENCES TTTA HERE CON 0 SPACE 4,10 USE * QUAL OVERFLOW TTL 1TM/2TM - NON-PP RECALL PRESET. TITLE INITIAL DRIVER PRESET. IDENT 2TM,PREX *COMMENT 1TM - PRESET. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 2TM SPACE 4,10 *** INITIAL DRIVER PRESET. SPACE 4,10 ORG PPFW QUAL PRE PRE SPACE 4,30 ** PRE - PRESET DRIVER. * * (IR+3) = REAL-TIME CLOCK (SECONDS) AT START * OF DRIVER INACTIVITY TIME-OUT. * = ZERO ON INITIAL CALL OR EXECUTIVE RECALL. * (IR+4) = DRIVER CONTROL WORD POINTER. * (DRIVER CONTROL WORD) INITIAL CALL = * 12/0, 6/0, 18/DRN, 24/0 * DRN = DRIVER NAME. * (DRIVER CONTROL WORD) PP OR EXECUTIVE RECALL = * 12/3, 24/CSA, 12/TC, 12/TN * CSA = CIRCULAR STACK ADDRESS. * TC = TERMINAL COUNT. * TN = DRIVER TERMINAL NUMBER. * * EXIT TO *ITM*, PRESET - * EQUIPMENT RESERVED. * MULTIPLEXER AND PORT SELECTED. * (IR+2) = 10/EQ, 1/S, 1/P. * EQ = RESERVED EQUIPMENT NUMBER. * S = 1, IF PORT CURRENTLY IS RESERVED FOR * *1TM*. * P = PORT NUMBER. * (IR+3) = CURRENT REAL-TIME CLOCK (SECONDS) * IF INITIAL CALL OR EXECUTIVE RECALL. * = INPUT REGISTER CONTENTS IF PP RECALL. * TO *MRER* IF NO TPM AVAILABLE. * * CALLS CEF, CEQ, CWA, INI, RCE, SEL. * * MACROS EXECUTE, LDCDQ. PRE SUBR ENTRY LDN 0 STD EQ RJM CEF CHECK ERROR FLAG RJM CWA SET DRIVER CONTROL WORD ADDRESS CRD DC READ DRIVER CONTROL WORD * PROCESS INITIAL DRIVER LOAD. RJM CEQ CHECK EQUIPMENT LDD DC+4 CHECK TERMINAL NUMBER STD TN NJN PRE1 IF DEFINED - DRIVER RECALL RJM INI PROCESS INITIAL DRIVER LOAD * RESERVE TWO-PORT MULITPLEXER AND SELECT PORT. PRE1 LDD EQ CHECK IF EQUIPMENT AVAILABLE NJN PRE2 IF EQUIPMENT AVAILABLE LJM MRER * 1TM - NO TPM AVAILABLE.* PRE2 RJM CMF CHECK RDF STATUS RJM RCE RESERVE CHANNEL AND EQUIPMENT RJM SEL SELECT MULTIPLEXER PORT * LOAD MAIN OVERLAY. LDN MX RELEASE CHANNEL DCHAN LDD EQ SAVE RECALL STATUS INFORMATION SHN 2 LMD PN STD IR+2 LDM SFMX ZJN PRE3 IF PORT NOT ATTACHED LDD IR+2 LMN 2 STD IR+2 PRE3 EXECUTE 1TM QUAL * PREX EQU /PRE/PREX QUAL PRE TITLE DRIVER PRESET SUBROUTINES. CEF SPACE 4,15 ** CEF - CHECK ERROR FLAG. * * CHECKS CPU ERROR FLAG. IF SET, DROPS EQUIPMENT * AND CHANNEL AND DROPS THE PPU. * * EXIT TO *DPP* IF ERROR FLAG SET. * * USES CM - CM+4. CEF SUBR ENTRY/EXIT LDD CP READ CP STATUS WORD ADK STSW CRD CM LDD CM+1 CHECK ERROR FLAG ZJN CEFX IF NO ERROR FLAG LJM DPP DROP PPU CEQ SPACE 4,20 ** CEQ - CHECK EQUIPMENT. * * CHECKS FOR EQUIPMENT TYPE *RM* IN THE EST. * SETS THE EST ORDINAL. * * EXIT (A) = EST ORDINAL IF NONZERO. * = ZERO IF EQUIPMENT NOT FOUND. * (EQ) = EST ORDINAL IF NONZERO. * = ZERO IF EQUIPMENT NOT FOUND. * (PN) = PORT NUMBER IF EQUIPMENT FOUND. * (RCEA) = UPPER ACCESS LEVEL LIMIT FOR TWO-PORT MUX. * * USES CM - CM+4, DP - DP+4, T0 - T0+4. * * MACROS SFA. CEQ SUBR ENTRY/EXIT LDN 0 PRESET NOT FOUND STD EQ LDK ESTP READ EST POINTER CRD DP LDN NOPE-1 INITIALIZE EST ORDINAL FOR SEARCH STD DP CEQ1 AOD DP ADVANCE EST ORDINAL LMD DP+2 ZJN CEQX IF END OF EST SFA EST,DP READ EST ENTRY ADK EQDE CRD CM ADK EQAE-EQDE CRD T0 LDD CM+3 CHECK EQUIPMENT MNEMONIC LMC 2RRM NJN CEQ1 IF NOT EQUIPMENT TYPE *RM* LDD CM LPN 3 NJN CEQ1 IF *RM* EQUIPMENT NOT *ON* LDD T0+3 SAVE UPPER ACCESS LEVEL LIMIT LPN 7 STM RCEA LDD CM+4 SET PORT NUMBER LPN 1 STD PN LDD DP EXIT WITH (A) = (EQ) = EST ORDINAL STD EQ UJP CEQX RETURN CMF SPACE 4,15 ** CMF - CHECK *RDF* STATUS. * * CHECKS TO SEE THAT *RDF* IS ENABLED. IF NOT, * ISSUE ERROR LOG MESSAGE AND EXIT TO *ERR*. * * EXIT RETURN TO CALLER IF *RDF* ENABLED. * TO *ERR* IF *RDF* DISABLED - * ERROR LOG MESSAGE ISSUED. * (A) = ADDRESS OF DAYFILE MESSAGE. * * USES T1, CM - CM+4. * * CALLS DFM. CMF SUBR ENTRY/EXIT LDK SSSL READ SUBSYSTEM STATUS CRD CM LDM CMFB+1 SET MASK STM CMFC LDM CMFB GET *SSSL* BYTE NUMBER STD T1 LDM CM,T1 READ BYTE LPC ** CMFC EQU *-1 (*RDF* MASK BIT) ZJN CMFX IF *RDF* NOT DISABLED LDN MTER * RDF TERMINATED.* LJM IMT ISSUE MESSAGE AND TERMINATE * CALCULATE *SSSL* BYTE AND MASK FOR *RDF*. .1 SET MXSI-RDSI .2 SET .1/12D .3 SET 4-.2 .4 DECMIC .1-12D*.2 .5 SET 1S".4" CMFB CON .3 *SSSL* BYTE NUMBER CON .5 *SSSL* MASK CWA SPACE 4,15 ** CWA - SET DRIVER CONTROL WORD ADDRESS. * * RETURNS THE ABSOLUTE CM ADDRESS OF THE DRIVER CONTROL * WORD WITHIN *RDF* FIELD LENGTH. * * ENTRY (IR+4) = DRIVER CONTROL WORD POINTER. * * EXIT (A) = CM ADDRESS OF DRIVER CONTROL WORD. CWA SUBR ENTRY/EXIT LDD RA SET CM ADDRESS SHN 6 ADD IR+4 ADD DRIVER CONTROL WORD POINTER UJN CWAX RETURN DCE SPACE 4,15 ** DCE - DROP CHANNEL AND EQUIPMENT. * * ENTRY (EQ) = BIT 2**9 SET IF EQUIPMENT RESERVED. * * EXIT CHANNEL AND EQUIPMENT DROPPED. * (EQ) = BIT 2**9 RESET. * * USES CM - CM+4. * * CALLS CLR, RTM. * * MACROS DCHAN, MONITOR. DCE SUBR ENTRY/EXIT LDD EQ CHECK EQUIPMENT SBD TH MJN DCEX IF NOT RESERVED STD EQ CLEAR BIT 2**9 STD CM+1 DROP EQUIPMENT MONITOR DEQM LDN MX DROP MULTIPLEXER CHANNEL DCHAN RJM RTM RELEASE TERMINAL ON MULTIPLEXER RJM CLR CLEAR LAST REQUEST UJN DCEX RETURN DPP SPACE 4,15 ** DPP - DROP PPU. * * DROPS CHANNEL AND EQUIPMENT, SIGNALS DRIVER SHUTDOWN * TO *RDF*, AND DROPS THE PPU. * * EXIT TO *PPR*. * * CALLS DCE, SDS. * * MACROS MONITOR. DPP BSS 0 ENTRY RJM DCE DISCONNECT CHANNEL AND EQUIPMENT RJM SDS SIGNAL DRIVER SHUTDOWN MONITOR DPPM DROP PPU LJM PPR EXIT TO PPU RESIDENT INI SPACE 4,25 ** INI - PROCESS INITIAL LOAD. * * PROCESSES THE INITIAL LOAD OF THE DRIVER DURING * *RDF* INITIALIZATION. * * ENTRY (IR+4) = DRIVER CONTROL WORD POINTER. * (DC - DC+4) = DRIVER CONTROL WORD. * * EXIT *VDRL* DRIVER CONTROL WORD INITIALIZED. * MUX TABLE ENTRY INITIALIZED. * (DC - DC+4) = DRIVER CONTROL WORD. * (TN) = DRIVER TERMINAL NUMBER. * * ERROR TO *ERR* IF NOT CYBER 170-8XX. * (A) = ADDRESS OF ERROR MESSAGE. * * USES CM - CM+4, DC - DC+4. * * CALLS CEF, CWA, TID. INI SUBR ENTRY/EXIT RJM STP SYNCHRONIZE *TSEM* PROCESSING * TRANSMIT PORT COUNT TO EXECUTIVE INITIALIZATION. LDN ZERL CRD CM LDN 1 SET TERMINAL COUNT STD CM+3 STD DC+3 STD DC SET REPLY INTERLOCK NON-ZERO LDN 2 SET TERMINAL ID TABLE LENGTH STD DC+4 LDD RA WRITE MUX TABLE ENTRY SHN 6 ADC MUXP+VMTM CWD CM RJM CWA SET DRIVER CONTROL WORD ADDRESS CWD DC WRITE DRIVER CONTROL WORD * WAIT FOR CP EXECUTIVE INITIALIZATION TO REPLY. INI2 DELAY PAUSE FOR 128 USECS RJM CEF CHECK ERROR FLAG RJM CWA SET DRIVER CONTROL WORD ADDRESS CRD DC READ DRIVER CONTROL WORD LDD DC CHECK FOR EXECUTIVE RESPONSE NJN INI2 IF NO RESPONSE FROM EXECUTIVE * SET TERMINAL NUMBER AND TERMINAL ID TABLE. LDD DC+4 SET ASSIGNED TERMINAL NUMBER STD TN RJM TID SET TERMINAL ID TABLE * DROP PP IF NOT CYBER 170-8XX MAINFRAME. LDK MABL CHECK MAINFRAME TYPE CRD CM LDD CM+1 SHN 21-13 PJP INIX IF CYBER 170-8XX MAINFRAME LDN MCBR * RDF CANNOT BE RUN ON MAINFRAME.* LJM IMT ISSUE MESSAGE AND TERMINATE RCE SPACE 4,15 ** RCE - RESERVE CHANNEL AND EQUIPMENT. * * ENTRY (RCEA) = UPPER ACCESS LEVEL LIMIT OF TPM. * * EXIT EQUIPMENT AND CHANNEL RESERVED. * (EQ) = BIT 2**49 SET TO INDICATE THAT EQUIPMENT * IS RESERVED. * MUX TABLE ENTRY UPDATED WITH CH, PN, AND UAL. * * ERROR TO *MRER* IF EQUIPMENT NOT ASSIGNED. * * USES CM - CM+4. * * MACROS RCHAN, MONITOR. RCE SUBR ENTRY/EXIT LDD EQ CHECK EQUIPMENT STD CM+1 SBD TH PJN RCEX IF ALREADY RESERVED LDK REQS REQUEST ACTIVE EQUIPMENT STD CM+2 MONITOR REQM REQUEST EQUIPMENT LDD CM+1 NJN RCE1 IF EQUIPMENT ASSIGNED LJM MRER * 1TM - NO TPM AVAILABLE.* RCE1 LDN MX REQUEST CHANNEL RCHAN LDD TH SET BIT 2**9 ON EST ORDINAL RAD EQ LDD RA READ MUX TABLE ENTRY SHN 6 ADC MUXP+VMTM CRD CM LDN MX SET CHANNEL SHN 6 LMD PN SET PORT NUMBER STD CM LDC * SET UPPER ACCESS LEVEL LIMIT FOR MUX RCEA EQU *-1 STD CM+2 LDD RA REWRITE MUX TABLE ENTRY SHN 6 ADC MUXP+VMTM CWD CM UJP RCEX RETURN SDS SPACE 4,15 ** SDS - SIGNAL DRIVER SHUTDOWN. * * SIGNALS DRIVER SHUTDOWN BY SETTING THE DRIVER * SHUTDOWN FLAG IN THE DRIVER CONTROL WORD. * * EXIT DRIVER SHUTDOWN FLAG SET IN DRIVER * CONTROL WORD. * * USES CM - CM+4. * * CALLS CWA. SDS SUBR ENTRY/EXIT RJM CWA SET DRIVER CONTROL WORD ADDRESS CRD CM READ DRIVER CONTROL WORD LDD CM CHECK SHUTDOWN FLAG NJN SDSX IF DRIVER SHUTDOWN ALREADY SET, RETURN LDN 1 SET DRIVER SHUTDOWN FLAG STD CM RJM CWA REWRITE DRIVER CONTROL WORD CWD CM UJN SDSX RETURN SEL SPACE 4,15 ** SEL - SELECT MULTIPLEXER PORT. * * CALLS *STM* TO SELECT THE TPM PORT, TO GET * AND STORE THE PORT STATUS AND ISSUES TPM * FUNCTION CODES TO SET THE PORT OPERATING MODE, * SET *DATA TERMINAL READY*, AND *REQUEST TO SEND*. * * ENTRY (PN) = PORT NUMBER. * * EXIT PORT SELECTED. * (SSMX) = PORT STATUS. * TO *MRER* IF PORT NOT RESERVED. * * CALLS IFN, PMA, RMA, STM. SEL SUBR ENTRY/EXIT RJM PMA PRESET MUX ACCESS LDD PN GET PORT NUMBER LDC PRTO SET TIME OUT DELAY STD T2 LDD PN GET PORT NUMBER RJM SPN SET PORT NUMBER SEL1 RJM STM NJN SEL3 IF PORT RESERVED LDN 100D/4 DELAY 100 MILLISECONDS STD T0 SEL2 DELAY RJM CEF CHECK ERROR FLAG RJM CTE PJN SEL2 IF 100 MILLISECONDS NOT EXPIRED SOD T2 NJN SEL1 IF TIME OUT NOT EXPIRED LJM MRER * 1TM - NO TPM AVAILABLE.* SEL3 LDC MXSM+TPMODE SET PORT OPERATING MODE RJM IFN LDK MXDR+1 SET *DATA TERMINAL READY* RJM IFN LDK MXRTS+1 SET *REQUEST TO SEND* RJM IFN LDK MXMC CLEAR PORT I/O BUFFERS RJM IFN RJM RMA RELEASE MULTIPLEXER ACCESS UJP SELX RETURN STP SPACE 4,15 ** STP - SYNCHRONIZE MONITOR *TSEM* PROCESSING. * * ISSUE SPECIAL *TSEM* REQUEST TO ENABLE * *TSEM* REQUEST PROCESSING. * * ENTRY (IR+4) = DRIVER CONTROL WORD POINTER. * * USES CM - CM+4. * * MACROS MONITOR. STP SUBR ENTRY/EXIT LDK ZERL CLEAR ZERO WORD CRD CM LCN 0 SET *TSEM* REQUEST STD CM LDD MA WRITE REQUEST TO MESSAGE BUFFER CWD CM MONITOR TSEM ISSUE *TSEM* REQUEST UJN STPX RETURN TID SPACE 4,15 ** TID - SET TERMINAL ID TABLE. * * WRITES DRIVER TERMINAL ID TABLE TO CM. * * ENTRY (DC - DC+4) = DRIVER CONTROL WORD. * * EXIT DRIVER TERMINAL ID TABLE WRITTEN TO CM. * * USES CM - CM+4. TID SUBR ENTRY/EXIT LDD DC+1 SET DRIVER STACK ADDRESS SHN 6 ADD RA SHN 6 ADD DC+2 ADN 4 READ *LIMIT* POINTER CRD CM LDD CM+3 SET ADDRESS FOR ID TABLE SHN 6 ADD RA SHN 6 ADD CM+4 CWM TIDA,ON WRITE ID TABLE TO CM CWM TIDB,ON UJN TIDX RETURN TIDA VFD 60/3LTPM TPM TERMINAL ID TIDB VFD 60/6LBLKTPM BLKEDIT TPM TERMINAL ID TITLE ERROR PROCESSING ROUTINES. FTER SPACE 4,10 ** FTER - FUNCTION TIME-OUT ERROR PROCESSOR. * * ENTRY (A) = FUNCTION CODE. * * EXIT (A) = 1/ERROR LOG FLAG, 5/MESSAGE NUMBER. FTER BSS 0 ENTRY STM //IMTB SAVE FUNCTION CODE LDN MFTO+40 * RMEEE CXX PYY FNNNN REJECT.* * JMP IMT ISSUE MESSAGE AND TERMINATE IMT SPACE 4,10 ** IMT - ISSUE MESSAGE AND TERMINATE. * * ENTRY (A) = 1/ERROR LOG FLAG, 5/MESSAGE NUMBER. * * EXIT TO *4TM*. * * MACROS EXECUTE. IMT BSS 0 ENTRY STM //IMTA SAVE MESSAGE REQUEST EXECUTE 4TM LJM DPP DROP PP MRER SPACE 4,10 ** MRER - NORMAL ERROR PROCESSOR FOR *COMPMRA*. * * EXIT (A) = MESSAGE NUMBER. MRER BSS 0 ENTRY LDN MNTA * NO TPM AVAILABLE.* UJN IMT ISSUE MESSAGE AND TERMINATE SPACE 4,10 * COMMON DECKS. *CALL COMPMRA *CALL COMPTMA PMA HERE SPACE 4,10 QUAL * SPACE 4,10 OVERFLOW PPFW,IMTA TITLE TTL 1TM/3TM - MODIFY TRANSLATION TABLES. IDENT 3TM,MTTX *COMMENT 1TM - MODIFY TRANSLATION TABLES. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. 3TM SPACE 4,10 *** 3TM - MODIFY TRANSLATION TABLES. SPACE 4,10 ORG OVLA MTT SPACE 4,15 ** MTT - MODIFY TRANSLATION TABLES. * * MODIFIES TRANSLATION TABLES FOR 63 CHARACTER SET. * * EXIT TRANSLATION TABLES MODIFIED IF THE SYSTEM * IS IN 63 CHARACTER SET MODE. * * USES CM - CM+4. MTT SUBR ENTRY/EXIT LDK IPRL CHECK SYSTEM CHARACTER SET MODE CRD CM LDD CM+2 LPN 1 NJN MTTX IF SYSTEM IN 64 CHARACTER SET MODE * MODIFY INPUT CONVERSION TABLE. LDN 63 SET *COLON* STM TINT+.ACLN LDC 204 SET *PERCENT* STM TINT+.APCT * MODIFY OUTPUT CONVERSION TABLE. LDC .CCLN SET *COLON* STM TOTP+63 LDC .CPCT SET *PERCENT* STM TOTP+204 JMP MTTX RETURN TITLE INPUT TRANSLATION TABLE. TTY SPACE 4,15 *** TTY - *ASCII* TERMINAL, 64 CHARACTER SET. * * USA STANDARD CODE FOR INFORMATION INTERCHANGE. * USAS X3.4-1968 REVISION OF X3.4-1967. ** INPUT CONVERSION. * * INDEXED BY *ASCII* CHARACTER VALUE. TINT BSS 0 FWA OF INPUT TRANSLATION TABLE QUAL TRN LOC 0 00 INASC 7640,BRK NUL FIRST CHARACTER OF A BREAK 01 INASC 7641 SOH START OF HEADING 02 INASC 7642 STX START OF TEXT 03 INASC 7643,ETX ETX END OF TEXT 04 INASC 7644,EOT EOT END OF TRANSMISSION 05 INASC 7645 ENQ ENQUIRY 06 INASC 7646 ACK ACKNOWLEDGE 07 INASC 7647 BEL BELL 08 INASC 7650,DPC BS BACKSPACE 09 INASC 7651 HT HORIZONTAL TABULATION 0A INASC 7652,NLI LF LINE FEED 0B INASC 7653 VT VERTICAL TABULATION 0C INASC 7654 FF FORM FEED 0D INASC 7655,CRT CR CARRIAGE RETURN 0E INASC 7656 SO SHIFT OUT 0F INASC 7657 SI SHIFT IN 10 INASC 7660 DLE DATA LINK ESCAPE 11 INASC 7661 DC1 DEVICE CONTROL 1 (X-ON) 12 INASC 7662 DC2 DEVICE CONTROL 2 13 INASC 7663 DC3 DEVICE CONTROL 3 (X-OFF) 14 INASC 7664 DC4 DEVICE CONTROL 4 (STOP) 15 INASC 7665 NAK NEGATIVE ACKNOWLEDGE 16 INASC 7666 SYN SYNCHRONOUS IDLE 17 INASC 7667 ETB END OF TRANSMISSION BLOCK 18 INASC 7670 CAN CANCEL 19 INASC 7671 EM END OF MEDIUM 1A INASC 7672 SUB SUBSTITUTE 1B INASC 7673,DLN ESC ESCAPE 1C INASC 7674 FS FILE SEPARATOR 1D INASC 7675 GS GROUP SEPARATOR 1E INASC 7676,CRS RS RECORD SEPARATOR 1F INASC 7677 US UNIT SEPARATOR 20 INASC 55 SP SPACE 21 INASC 66 EX EXCLAMATION POINT 22 INASC 64 DQ DOUBLE QUOTE (DIARESIS) 23 INASC 60 NM NUMBER SIGN 24 INASC 53 DS DOLLAR SIGN 25 INASC 63 PCT PERCENT * 25 INASC 7404 PCT PERCENT (63 CHARACTER SET) 26 INASC 67 AM AMPERSAND 27 INASC 70 AP APOSTROPHE 28 INASC 51 OP OPENING PARENTHESIS 29 INASC 52 CP CLOSING PARENTHESIS 2A INASC 47 AS ASTERISK 2B INASC 45 PL PLUS 2C INASC 56 CM COMMA (CEDILLA) 2D INASC 46 MI MINUS (HYPHEN) 2E INASC 57 PD PERIOD (DECIMAL POINT) 2F INASC 50 SL SLANT 30 INASC 33 0 31 INASC 34 1 32 INASC 35 2 33 INASC 36 3 34 INASC 37 4 35 INASC 40 5 36 INASC 41 6 37 INASC 42 7 38 INASC 43 8 39 INASC 44 9 3A INASC ,CLN CL COLON * 3A INASC 63 CL COLON (63 CHARACTER SET) 3B INASC 77 SC SEMICOLON 3C INASC 72 LT LESS THAN 3D INASC 54 EQ EQUALS 3E INASC 73 GT GREATER THAN 3F INASC 71 QM QUESTION MARK 40 INASC 7401,ECI AT COMMERCIAL AT 41 INASC 01 A 42 INASC 02 B 43 INASC 03 C 44 INASC 04 D 45 INASC 05 E 46 INASC 06 F 47 INASC 07 G 48 INASC 10 H 49 INASC 11 I 4A INASC 12 J 4B INASC 13 K 4C INASC 14 L 4D INASC 15 M 4E INASC 16 N 4F INASC 17 O 50 INASC 20 P 51 INASC 21 Q 52 INASC 22 R 53 INASC 23 S 54 INASC 24 T 55 INASC 25 U 56 INASC 26 V 57 INASC 27 W 58 INASC 30 X 59 INASC 31 Y 5A INASC 32 Z 5B INASC 61 OB OPENING BRACKET 5C INASC 75 RVS REVERSE SLANT 5D INASC 62 CB CLOSING BRACKET 5E INASC 7402,ECI CF CIRCUMFLEX 5F INASC 65 UL UNDERLINE 60 INASC 7407 GV GRAVE ACCENT 61 INASC 7601 A LC 62 INASC 7602 B LC 63 INASC 7603 C LC 64 INASC 7604 D LC 65 INASC 7605 E LC 66 INASC 7606 F LC 67 INASC 7607 G LC 68 INASC 7610 H LC 69 INASC 7611 I LC 6A INASC 7612 J LC 6B INASC 7613 K LC 6C INASC 7614 L LC 6D INASC 7615 M LC 6E INASC 7616 N LC 6F INASC 7617 O LC 70 INASC 7620 P LC 71 INASC 7621 Q LC 72 INASC 7622 R LC 73 INASC 7623 S LC 74 INASC 7624 T LC 75 INASC 7625 U LC 76 INASC 7626 V LC 77 INASC 7627,CLW W LC 78 INASC 7630 X LC 79 INASC 7631 Y LC 7A INASC 7632 Z LC 7B INASC 7633 LB LEFT BRACE 7C INASC 7634 VL VERTICAL LINE 7D INASC 7635 RB RIGHT BRACE 7E INASC 7636 TL TILDE (OVERLINE) 7F INASC 7637,DEL DEL DELETE (RUBOUT) QUAL * LOC *O TITLE OUTPUT TRANSLATION TABLE. ** OUTPUT CONVERSION. * INDEXED BY DISPLAY CODE VALUE. TOTP BSS 0 FWA OF OUTPUT TRANSLATION TABLE QUAL TRN LOC 0 00 OTASC 3A COLON 01 OTASC 41 A 02 OTASC 42 B 03 OTASC 43 C 04 OTASC 44 D 05 OTASC 45 E 06 OTASC 46 F 07 OTASC 47 G 10 OTASC 48 H 11 OTASC 49 I 12 OTASC 4A J 13 OTASC 4B K 14 OTASC 4C L 15 OTASC 4D M 16 OTASC 4E N 17 OTASC 4F O 20 OTASC 50 P 21 OTASC 51 Q 22 OTASC 52 R 23 OTASC 53 S 24 OTASC 54 T 25 OTASC 55 U 26 OTASC 56 V 27 OTASC 57 W 30 OTASC 58 X 31 OTASC 59 Y 32 OTASC 5A Z 33 OTASC 30 0 34 OTASC 31 1 35 OTASC 32 2 36 OTASC 33 3 37 OTASC 34 4 40 OTASC 35 5 41 OTASC 36 6 42 OTASC 37 7 43 OTASC 38 8 44 OTASC 39 9 45 OTASC 2B PL PLUS 46 OTASC 2D MI MINUS (HYPHEN) 47 OTASC 2A AS ASTERISK 50 OTASC 2F SL SLANT 51 OTASC 28 OP OPENING PARENTHESIS 52 OTASC 29 CP CLOSING PARENTHESIS 53 OTASC 24 DS DOLLAR SIGN 54 OTASC 3D EQ EQUALS 55 OTASC 20 SP SPACE 56 OTASC 2C CM COMMA (CEDILLA) 57 OTASC 2E PD PERIOD (DECIMAL POINT) 60 OTASC 23 NM NUMBER SIGN 61 OTASC 5B OB OPENING BRACKET 62 OTASC 5D CB CLOSING BRACKET 63 OTASC 25 PCT PERCENT * 63 OTASC 30 CLN COLON (63 CHARACTER SET) 64 OTASC 22 DQ DOUBLE QUOTE (DIARESIS) 65 OTASC 5F UL UNDERLINE 66 OTASC 21 EX EXCLAMATION POINT 67 OTASC 26 AM AMPERSAND 70 OTASC 27 AP APOSTROPHE 71 OTASC 3F QM QUESTION MARK 72 OTASC 3C LT LESS THAN 73 OTASC 3E GT GREATER THAN 74 OTASC 40 AT COMMERCIAL AT 75 OTASC 5C RVS REVERSE SLANT 76 OTASC 5E CF CIRCUMFLEX 77 OTASC 3B SC SEMICOLON * EXTENDED CHARACTER SET (ESCAPE 1). 7600 OTASC NULL 7601 OTASC 61 A LC 7602 OTASC 62 B LC 7603 OTASC 63 C LC 7604 OTASC 64 D LC 7605 OTASC 65 E LC 7606 OTASC 66 F LC 7607 OTASC 67 G LC 7610 OTASC 68 H LC 7611 OTASC 69 I LC 7612 OTASC 6A J LC 7613 OTASC 6B K LC 7614 OTASC 6C L LC 7615 OTASC 6D M LC 7616 OTASC 6E N LC 7617 OTASC 6F O LC 7620 OTASC 70 P LC 7621 OTASC 71 Q LC 7622 OTASC 72 R LC 7623 OTASC 73 S LC 7624 OTASC 74 T LC 7625 OTASC 75 U LC 7626 OTASC 76 V LC 7627 OTASC 77 W LC 7630 OTASC 78 X LC 7631 OTASC 79 Y LC 7632 OTASC 7A Z LC 7633 OTASC 7B LB LEFT BRACE 7634 OTASC 7C VL VERTICAL LINE 7635 OTASC 7D RB RIGHT BRACE 7636 OTASC 7E TL TILDE (OVERLINE) 7637 OTASC 7F DEL DELETE 7640 OTASC 00 NUL NULL (MEDIA FILL) 7641 OTASC 01 SOH START OF HEADING 7642 OTASC 02 STX START OF TEXT 7643 OTASC 03 ETX END OF TEXT 7644 OTASC 04 EOT END OF TRANSMISSION 7645 OTASC 05 ENQ ENQUIRY 7646 OTASC 06 ACK ACKOWLEDGE 7647 OTASC 07 BEL BELL 7650 OTASC 08 BS BACKSPACE 7651 OTASC 09 HT HORIZONTAL TABULATION 7652 OTASC 0A LF LINE FEED 7653 OTASC 0B VT VERTICAL TABULATION 7654 OTASC 0C FF FORM FEED 7655 OTASC ,ACR CR CARRIAGE RETURN 7656 OTASC 0E SO SHIFT OUT 7657 OTASC 0F SI SHIFT IN 7660 OTASC 10 DLE DATA LINK ESCAPE 7661 OTASC 11 DC1 DEVICE CONTROL 1 (X-ON) 7662 OTASC 12 DC2 DEVICE CONTROL 2 7663 OTASC 13 DC3 DEVICE CONTROL 3 (X-OFF) 7664 OTASC 14 DC4 DEVICE CONTROL 4 (STOP) 7665 OTASC 15 NAK NEGATIVE ACKNOWLEDGE 7666 OTASC 16 SYN SYNCHRONOUS IDLE 7667 OTASC 17 ETB END OF TRANSMISSION BLOCK 7670 OTASC 18 CAN CANCEL 7671 OTASC 19 EM END OF MEDIUM 7672 OTASC 1A SUB SUBSTITUTE 7673 OTASC 1B ESC ESCAPE 7674 OTASC 1C FS FILE SEPARATOR 7675 OTASC 1D GS GROUP SEPARATOR 7676 OTASC 1E RS RECORD SEPARATOR 7677 OTASC 1F US UNIT SEPARATOR * EXTENDED CHARACTER SET (ESCAPE 2). 7400 OTASC NULL 7401 OTASC 40 AT COMMERCIAL AT 7402 OTASC 5E CF CIRCUMFLEX 7403 OTASC NULL 7404 OTASC 3A CL COLON * 7404 OTASC 25 PCT PERCENT (63 CHARACTER SET) 7405 OTASC 11 DC1 DEVICE CONTROL 1 (X-ON) 7406 OTASC 13 DC3 DEVICE CONTROL 3 (X-OFF) 7407 OTASC 60 GV GRAVE ACCENT 7410 OTASC ,ACR CR CARRIAGE RETURN 7411 OTASC 0A LF LINE FEED 7412 OTASC ,ANL NL NEW LINE (CR/LF) QUAL * LOC *O OVERFLOW OVLA TTL 1TM/4TM - MESSAGE PROCESSOR. TITLE MESSAGE PROCESSOR. IDENT 4TM,MGPX *COMMENT 1TM - MESSAGE PROCESSOR. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. SPACE 4,10 ORG OVLA MGP SPACE 4,15 ** MGP - MESSAGE PROCESSOR. * * ENTRY (A) = 1/E,5/N. * E = 1, IF MESSAGE IS TO GO TO ERROR LOG ALSO. * N = ERROR MESSAGE NUMBER FROM TABLE *TMSG*. * * USES T0, T1, T2. * * CALLS DFM, O2D. * * NOTES WHEN A MESSAGE IS ISSUED TO THE ERROR LOG, THE * FIRST SIX CHARACTERS (* 1TM -*) ARE NOT SENT. MGP SUBR ENTRY/EXIT LDM IMTA MESSAGE REQUEST STD T0 LPN 37 ADC TMSG-1 STD T1 ADDRESS OF ADDRESS OF MESSAGE LDI T1 SAVE MESSAGE ADDRESS STM MGPA LDD T1 LMC TMSG+MFTO-1 ZJN MGP3 IF FUNCTION TIME-OUT MGP1 LDD T0 SHN 21-5 PJN MGP2 IF NOT TO BE ISSUED TO THE ERROR LOG LDI T1 ADC 3+ERLN RJM DFM ISSUE ERROR LOG MESSAGE MGP2 LDC ** MGPA EQU *-1 RJM DFM ISSUE DAYFILE MESSAGE JMP MGPX RETURN * FORMAT EST ORDINAL INTO DAYFILE MESSAGE. MGP3 LDI T1 SET FWA OF MESSAGE STD T2 LDD EQ CONVERT UPPER 3 BITS SHN -6 LPN 7 ADC 2RM0 STM 4,T2 LDD EQ CONVERT LOWER 6 BITS RJM O2D STM 5,T2 * FORMAT CHANNEL AND PORT NUMBERS INTO DAYFILE MESSAGE. LDN MX CONVERT CHANNEL NUMBER RJM O2D STM 7,T2 LDD PN CONVERT PORT NUMBER RJM O2D STM 11,T2 * FORMAT FUNCTION CODE INTO DAYFILE MESSAGE. LDM IMTB CONVERT UPPER TWO DIGITS SHN -6 RJM O2D STM 13,T2 LDM IMTB CONVERT LOWER TWO DIGITS RJM O2D STM 14,T2 UJP MGP1 ISSUE MESSAGES TMSG BSS 0 TABLE OF ERROR MESSAGES LOC 1 MCBR CON =C* 1TM - RDF CANNOT BE RUN ON MAINFRAME.* MFTO CON =C* 1TM - RMEEE CXX PYY FNNNN REJECT.* MNTA CON =C* 1TM - NO TPM AVAILABLE.* MTIO CON =C* 1TM - RDF TIME-OUT.* MTER CON =C* 1TM - RDF TERMINATED.* LOC *O O2D SPACE 4,15 ** O2D - CONVERT TWO DIGITS TO OCTAL DISPLAY CODE. * * ENTRY (A) = TWO OCTAL DIGITS TO BE CONVERTED. * * EXIT (A) = DISPLAY CODE CONVERSION. O2D SUBR ENTRY/EXIT LPN 77 MASK EXTRANEOUS BITS STD T0 SAVE OCTAL VALUE SHN 3 SPLIT UPPER AND LOWER 3-BIT VALUES LMD T0 SCN 70 ADC 2R00 CONVERT DIGITS UJN O2DX RETURN OVERFLOW OVLA TTL 1TM - RDF TWO-PORT MULTIPLEXER DRIVER. ITM SPACE 4 END