Trailing-Edge
-
PDP-10 Archives
-
BB-X140B-BB_1986
-
10,7/703anf/dntty.p11
There are 5 other files named dntty.p11 in the archive. Click here to see a list.
.SBTTL DNTTY - TERMINAL ROUTINES 3 SEP 85
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;
;COPYRIGHT (C) 1976,1977,1978,1979,1980,1981,1982,1983,1984 BY DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
VRTTY=116 ;FILE EDIT NUMBER
.IF NE <FT.CTY+TTYN+RDAN>
;DB.DCS STATUS BITS FOR TTY SERVICE
TS.DFE=1 ;DEFERED ECHO MODE
TS..LC=2 ;TRANSLATE LOWER CASE TO UPPER
TS.FRZ=4 ;OUTPUT HAS BEEN FROZEN BY TYPEIN OF XOF
TS.IMI=10 ;IMAGE MODE INPUT
TS.IMO=20 ;IMAGE MODE OUTPUT
TS.PAG=40 ;TTY PAGE IN EFFECT
TS.TAP=100 ;TTY TAPE FEATURE(IMPLIES SUPPRESS NORMAL CR HANDLING)
TS.TAB=200 ;TTY HAS HDW TAB
TS.FRM=400 ;TTY HAS HDW FORM FEED
TS.TIW=1000 ;JOB IS IN INPUT WAIT FOR TTY
TS.LMD=2000 ;LINE INPUT MODE
TS.CRL=4000 ;NO AUTO CR/LF ON LINE OVERFLOW
TS.DTR=10000 ;DATA TERMINAL READY
TS.RNG=20000 ;RING
TS.CAR=20000 ;CARRIER
TS.DSR=40000 ;DATASET READY
TS.ADL=100000 ;AUTO DIAL LINE (DN11)
TS.RCN=TS..LC!TS.PAG!TS.TAB!TS.FRM!TS.CRL!TS.DTR!TS.RNG!TS.CAR!TS.DSR ;BITS TO PRESERVE ON A RECONNECT
.IIF NDF,ESCF,ESCF=176 ;NOTE, ESCF CANNOT BE > 177
;MACRO TO MAKE DEVICE DEPENDENT PORTION OF DEVICE BLOCK FOR TTY'S
.MACRO SETLCB QLCB
.WORD LCB'QLCB ;DB.LCB
.ENDM
.MACRO DDXGEN DEV,DV,DRQ,XBITS,XZZ
ZZZ=1
.REPT NXTDH&17
ZZZ=ZZZ*2
.ENDR
.WORD ZZZ ;DB.BIT
.BYTE 17&NXTDH ;DB..LN
Z=0
.IF NDF DV'XZZ'XS
.IIF DF DEV'XS,DV'XZZ'XS=DEV'XS
.ENDC
.IF NDF DV'XZZ'XS
Z=LCB.AB ;AUTO BAUD LINE
ZZXS=^D2400 ;SCAN AT 2400 BAUD
.IFF
ZZXS=DV'XZZ'XS
.ENDC
.IF NDF DV'XZZ'RS
.IIF DF DEV'RS,DV'XZZ'RS=DEV'RS
.ENDC
.IIF NDF DV'XZZ'RS,ZZRS=ZZXS
.IIF DF DV'XZZ'RS,ZZRS=DV'XZZ'RS
.MACRO DHSSET LINE
ZZS=0
.IIF DF DV'XZZ'XS,ZZS=1
.IIF DF DV'XZZ'RS,ZZS=1
.IF NE ZZS
SPD ZZXS,ZZRS ;CALCULATE LINE SPEED
DHS'LINE=QQ
.ENDC
.ENDM DHSSET
DHSSET \NXTDH
.IIF DF DV'XZZ'DSL, Z=Z!LCB.DS
.MACRO DHCSET LINE
DHC'LINE=Z
.ENDM DHCSET
.MACRO DHZSET LINE
DHZ'LINE=LCS.VG
.IF EQ Z&LCB.DS
DHZ'LINE=LCS.AB
.IF EQ Z&LCB.AB
DHZ'LINE=LCS.RU
.ENDC
.ENDC
.ENDM
DHCSET \NXTDH
DHZSET \NXTDH
.BYTE 12,12,20,12,12,12 ;DB.FIL
.BYTE 0 ;DB.EPL
SETLCB \NXTDH ;DB.LCB
DHINDX=DHINDX+1
.IF NE FTDN11
Z=0
.IF DF DV'XZZ'801
Z=DV'XZZ'801
.ENDC
.BYTE Z ;DB.DNS (DN11 STATUS)
.BYTE 0 ;DB.DNT (DN11 TIMER)
.ENDC;.IF NE FTDN11
.WORD 0 ;DB.TTS (TTY STATUS WORD)
.BLKB <DB.TSZ-DB.TZR>
.EVEN
.ENDM DDXGEN
NXTDZ=-1 ;
NXTDH=-1 ;LOCATE FIRST TTY LINE
DRESET=0
ASYDEV=ASY.DH ;BUILD DH LINES FIRST
DDBGEN TTY,T,TTYDHN,TTYDRQ,<DS.TTY!DS.OUT> ;MAKE DEVICE BLOCKS FOR TTYS
ASYDEV=ASY.DZ ;NOW DZ LINES
DRESET=1 ;DONT BUILD NEW SYMBOLS
.MACRO DDXGEN DEV,DV,DRQ,XBITS,XZZ
ZZZ=1
.REPT NXTDZ&7
ZZZ=ZZZ*2
.ENDR
.WORD ZZZ ;DB.BIT
.BYTE 7&NXTDZ ;DB..LN
Z=0
.IF NDF DV'XZZ'XS
.IIF DF DEV'XS,DV'XZZ'XS=DEV'XS
.ENDC
.IF NDF DV'XZZ'XS
Z=LCB.AB ;AUTO BAUD LINE
ZZXS=^D2400 ;SCAN AT 2400 BAUD
.IFF
ZZXS=DV'XZZ'XS
.ENDC
.IF NDF DV'XZZ'RS
.IIF DF DEV'RS,DV'XZZ'RS=DEV'RS
.ENDC
.IIF NDF DV'XZZ'RS,ZZRS=ZZXS
.IIF DF DV'XZZ'RS,ZZRS=DV'XZZ'RS
.MACRO DZSSET LINE
ZZS=0
.IIF DF DV'XZZ'XS,ZZS=1
.IIF DF DV'XZZ'RS,ZZS=1
.IF NE ZZS
SPD ZZXS,ZZRS ;CALCULATE LINE SPEED
DZS'LINE=QQ
.ENDC
.ENDM DZSSET
DZSSET \NXTDZ
.IIF DF DV'XZZ'DSL, Z=Z!LCB.DS
.MACRO DZCSET LINE
DZC'LINE=Z
.ENDM DZCSET
.MACRO DZZSET LINE
DZZ'LINE=LCS.VG
.IF EQ Z&LCB.DS
DZZ'LINE=LCS.AB
.IF EQ Z&LCB.AB
DZZ'LINE=LCS.RU
.ENDC
.ENDC
.ENDM
DZCSET \NXTDZ
DZZSET \NXTDZ
.BYTE 12,12,20,12,12,12 ;DB.FIL
.BYTE 0 ;DB.EPL
SETLCB \<NXTDZ+<NDH11*20>> ;DB.LCB
DZINDX=DZINDX+1
.IF NE FTDN11
Z=0
.IF DF DV'XZZ'801
Z=DV'XZZ'801
.ENDC
.BYTE Z ;DB.DNS (DN11 STATUS)
.BYTE 0 ;DB.DNT (DN11 TIMER)
.ENDC;.IF NE FTDN11
.WORD 0 ;DB.TTS (TTY STATUS WORD)
.BLKB <DB.TSZ-DB.TZR>
.EVEN
.ENDM DDXGEN
DDBGEN TTY,T,TTYDZN,TTYDRQ,<DS.TTY!DS.OUT>
.MACRO DDXGEN DEV,DV,DRQ,XBITS,XZZ
ZZZ=1
.REPT NXTDH&17
ZZZ=ZZZ*2
.ENDR
.WORD ZZZ ;DB.BIT
.BYTE 17&NXTDH ;DB..LN
Z=0
.BYTE 12,12,20,12,12,12 ;DB.FIL
.BYTE 0 ;DB.EPL
.WORD CT0LDB ;DUMMY LINE CONTROL BLOCK
.IF NE FTDN11
Z=0
.IF DF DV'XZZ'801
Z=DV'XZZ'801
.ENDC
.BYTE Z ;DB.DNS (DN11 STATUS)
.BYTE 0 ;DB.DNT (DN11 TIMER)
.WORD CT'XZZ'DDB+DB.TSZ ;CTY HAS NO DATASET FUNCTION
.ENDC
.WORD 0 ;DB.TTS (TTY STATUS WORD)
.BLKB <DB.TSZ-DB.TZR>
.EVEN
.ENDM DDXGEN
.IF NE FT.CTY
DRESET=0
NXTDH=0 ;CTY ISN'T A DH DEV SO FAKE IT
.IF NDF CTYRNN
.IIF DF TTYRNN,CTYRNN=TTYRNN ;SAME RESTRICTIONS AS TTYS
.ENDC
DDBGEN CTY,CT,1,TTYDRQ,<DS.OUT!DS.TTY> ;MAKE A DEVICE BLOCK FOR THE CTY
.ENDC
.IF NE FT.RDA ; IF WE HAVE IT, IT IS THE SAME
.MACRO DDXGEN DEV,DV,DRQ,XBITS,XZZ
ZZZ=1
.REPT NXTDH&17
ZZZ=ZZZ*2
.ENDR
.WORD ZZZ ;DB.BIT
.BYTE 17&NXTDH ;DB..LN
Z=0
.IF NDF DV'XZZ'XS
.IIF DF DEV'XS,DV'XZZ'XS=DEV'XS
.ENDC
.IF NDF DV'XZZ'XS
ZZXS=^D2400 ;SCAN AT 2400 BAUD
.IFF
ZZXS=DV'XZZ'XS
.ENDC
.IF NDF DV'XZZ'RS
.IIF DF DEV'RS,DV'XZZ'RS=DEV'RS
.ENDC
.IIF NDF DV'XZZ'RS,ZZRS=ZZXS
.IIF DF DV'XZZ'RS,ZZRS=DV'XZZ'RS
.MACRO DHSSET LINE
ZZS=0
.IIF DF DV'XZZ'XS,ZZS=1
.IIF DF DV'XZZ'RS,ZZS=1
.IF NE ZZS
SPD ZZXS,ZZRS ;CALCULATE LINE SPEED
DHS'LINE=QQ
.ENDC
.ENDM DHSSET
DHSSET \NXTDH
.IIF DF DV'XZZ'DSL, Z=Z!LCB.DS
.MACRO DHCSET LINE
DHC'LINE=Z
.ENDM DHCSET
.MACRO DHZSET LINE
DHZ'LINE=LCS.VG
.IF EQ Z&LCB.DS
DHZ'LINE=LCS.AB
.IF EQ Z&LCB.AB
DHZ'LINE=LCS.RU
.ENDC
.ENDC
.ENDM
DHCSET \NXTDH
DHZSET \NXTDH
.BYTE 0,0,0,0,0,0 ;DB.FIL
.BYTE 0 ;DB.EPL
SETLCB \NXTDH ;DB.LCB
DHINDX=DHINDX+1
.IF NE FTDN11
Z=0
.IF DF DV'XZZ'801
Z=DV'XZZ'801
.ENDC
.BYTE Z ;DB.DNS (DN11 STATUS)
.BYTE 0 ;DB.DNT (DN11 TIMER)
.ENDC
.BLKB <DB.TSZ-DB.TZR>
.EVEN
.ENDM DDXGEN
ASYDEV=ASY.DH
DRESET=0
NXTDH=-1 ; START WITH RIGHT LINE NUMBER
DDBGEN RDA,D,RDADHN,RDADRQ,<DS.OUT>
.MACRO DDXGEN DEV,DV,DRQ,XBITS,XZZ
ZZZ=1
.REPT NXTDZ&7
ZZZ=ZZZ*2
.ENDR
.WORD ZZZ ;DB.BIT
.BYTE 7&NXTDZ ;DB..LN
Z=0
.IF NDF DV'XZZ'XS
.IIF DF DEV'XS,DV'XZZ'XS=DEV'XS
.ENDC
.IF NDF DV'XZZ'XS
ZZXS=^D2400 ;SCAN AT 2400 BAUD
.IFF
ZZXS=DV'XZZ'XS
.ENDC
.IF NDF DV'XZZ'RS
.IIF DF DEV'RS,DV'XZZ'RS=DEV'RS
.ENDC
.IIF NDF DV'XZZ'RS,ZZRS=ZZXS
.IIF DF DV'XZZ'RS,ZZRS=DV'XZZ'RS
.MACRO DZSSET LINE
ZZS=0
.IIF DF DV'XZZ'XS,ZZS=1
.IIF DF DV'XZZ'RS,ZZS=1
.IF NE ZZS
SPD ZZXS,ZZRS ;CALCULATE LINE SPEED
DZS'LINE=QQ
.ENDC
.ENDM DZSSET
DZSSET \NXTDZ
.IIF DF DV'XZZ'DSL, Z=Z!LCB.DS
.MACRO DZCSET LINE
DZC'LINE=Z
.ENDM DZCSET
.MACRO DZZSET LINE
DZZ'LINE=LCS.VG
.IF EQ Z&LCB.DS
DZZ'LINE=LCS.AB
.IF EQ Z&LCB.AB
DZZ'LINE=LCS.RU
.ENDC
.ENDC
.ENDM
DZCSET \NXTDZ
DZZSET \NXTDZ
.BYTE 0,0,0,0,0,0 ;DB.FIL
.BYTE 0 ;DB.EPL
SETLCB \<NXTDZ+<NDH11*20>> ;DB.LCB
DZINDX=DZINDX+1
.IF NE FTDN11
Z=0
.IF DF DV'XZZ'801
Z=DV'XZZ'801
.ENDC
.BYTE Z ;DB.DNS (DN11 STATUS)
.BYTE 0 ;DB.DNT (DN11 TIMER)
.ENDC
.BLKB <DB.TSZ-DB.TZR>
.EVEN
.ENDM DDXGEN
ASYDEV=ASY.DZ
DRESET=1
NXTDZ=-1
DDBGEN RDA,D,RDADZN,RDADRQ,<DS.OUT>
.ENDC; .IF NE FT.RDA
.MACRO DDXGEN DEV,DV,DRQ,XBITS,XZZ ;REDEFINE FOR NEXT DEVICE
.ENDM DDXGEN
.IF NE FT.TSK
.IIF NE FT.CTY, .WORD CTYDDB ;ADDRESS OF DEVICE BLOCK FOR CTY IS ENTRY "-1"
TTYTAB:
.MACRO X ART,ARG,ARX,ARY
.IF EQ D'ART'L'ARG'-1
.WORD T'ARX'DDB
ZTTY=ZTTY+1
.IFF
.IF EQ D'ART'L'ARG'-6
.WORD D'ARY'DDB
ZRDA=ZRDA+1
.IFF
.WORD 0
.ENDC
.ENDC
.ENDM
ZTTY=0 ;START WITH TTY0 DDB
ZRDA=0 ;START WITH RDA0 DDB
Z=0 ;INITIALIZE INDEX FOR DH11
.REPT DHLINE
X H,\Z,\ZTTY,\ZRDA
Z=Z+1
.ENDR
Z=0 ;RESET DZ11 LINE INDEX
.REPT DZLINE
X Z,\Z,\ZTTY,\ZRDA
Z=Z+1
.ENDR
.ENDC ;.IF NE FT.TSK
.IF NE FT.CTY
CT0LDB: .WORD 0 ;LC.CAR DUMMY LDB FOR CTY
.BYTE LCS.RU ;LC.STA LINE IS RUNNING
.BYTE 0 ;LC.MOD
.WORD B.300 ;LC.SPD 300 BAUD
.WORD B.300 ;LC.PSP 300 BAUD
.WORD CT0DDB ;LC.BLK
.WORD CTIINT ;LC.INS
.WORD CTOINT ;LC.OUS
.IF NE NDZ11
.WORD 0 ;LC.CNT
.WORD 0 ;LC.BUF
.ENDC
.ENDC
CTYSER:
TTYSER: CMP #TTYMML,DB.MML(J) ;DID HANDLER GIVE REASONABLE SIZE MSG ?
BPL 10$ ;IF SO USE IT
MOV #TTYMML,DB.MML(J) ;USE OUR SIZE CAUZ IT'S SMALLER
10$: MOVB #DCM.AS,DB.DCM(J) ;SET DATA CODE AND MODE
MOVB DB.TYP(J),R0 ;GET ASYNC CONTROLLER TYPE
ASR R0 ;MAKE INTO DIRECT VALUE (NOT INDEX)
.IF NE FT.CTY
CMP #CT0DDB,J ;IS THIS THE CTY?
BEQ 11$ ;YES,
.ENDC ;.IF NE FT.CTY
INCB R0 ;NO,
11$: INCB R0 ;CTY = 1; DH-11 = 2; DZ-11 = 3
MOVB R0,DB.DVV(J) ;SET CONTROLLER TYPE
JSR PC,DVCCFM ;SEND CONNECT CONFIRM
BIT #DS.CON,@J ;CONNECTED ?
BNE 20$
RTS PC
20$: JSR PC,DVXDRQ ;SEND SOME DATA REQUESTS
TST DB.OBF(J) ;DID 10 SEND DATA ?
BNE TOGMSG
JMP TTYICK
;HERE TO OUTPUT THE "ESCAPE FUNCTION" CHARACTER
TOGESC: JSR PC,QTECHR ;QUEUE TWO OF 'EM SO THAT ONE
BR TOGMSG ;WILL ACTUALLY GET PRINTED
;HERE WHEN WIN A DATA CHAR
TOGCHR: CMP R0,#ESCF ;IS THIS FUNCTION FLAG?
BEQ TOGESC ;YES, SPECIAL PROCESSING
JSR PC,QTYCHR ;QUEUE CHAR TO BE TYPED
TOGMSG: JSR PC,DVGBYT ;GET NEXT BYTE FROM THE NCL MESSAGE
BR TOGCHR ;WON A DATA CHARACTER
BR TOGMS1 ;WON A MESSAGE TYPE
JMP TOGDON ;ALL OUT OF MESSAGE
;START OF SUBMESSAGE, DISPATCH BASED ON MESSAGE TYPE
TOGMS1: TST R0 ;MESSAGE TYPE CAN'T BE NEGATIVE
BLE TOGBAD ;IF IT IS, WE COMPLAIN
CMP R0,#4 ;ALSO CAN'T BE TOO BIG EITHER
BGT TOGBAD ;IF IT IS, WE COMPLAIN
ASL R0 ;WORD INDEX
JMP @10$-2(R0) ;DISPATCH ON MESSAGE TYPE
10$: TOGMSG ;01 - DATA WITHOUT EOM
TOGMSG ;02 - DATA WITH EOM
TOGSTS ;03 - STATUS
TOGCTL ;04 - CONTROL
;HERE ON BAD MESSAGE TYPE OR FORMAT
TOGBAD:
.IF EQ DGUTS
TRAP ;ILLEGAL MSG TYPE
.IFF
CTYMSG NCL
32$: JSR PC,DVGBYT ;GET NEXT BYTE OF MSG
BR 32$ ;EAT BAD MSG
BR TOGMS1 ;TRY AGAIN WITH NEXT MSG
JMP TOGDON ;ALL DONE
.ENDC
;HERE WHEN WE RECEIVE A STATUS MESSAGE
TOGSTS: JSR PC,DVGDBY ;GET CODE IN STATUS MSG
10$: MOV R0,-(P) ;SAVE CODE
JSR PC,DVGEXF ;GET BITS TO SET/CLEAR
ASSERT EQ DB.OCN(J) ;MAKE SURE NOTHING LEFT OVER
MOV (P)+,R1 ;GET CODE AGAIN
MOV DB.DCS(J),-(P) ;SAVE CURRENT STATUS
BIT #TS.DTR,R0 ;IF IT'S DTR
BEQ 40$ ; AND
CMP #2,R1 ;HE WANTS IT CLEAR
BNE 40$ ; SKIP IF NOT "CLEAR"
SAVE <R1> ;GET A TEMP FOR A BIT
BIT #TS.FRZ,R0 ;IS TEN CLEARING XOFF
BEQ 15$ ;NO,ONWARD
SAVE <R0,R2,R3,R4,R5> ;YES,SAVE SOME ACS
JSR PC,BEGXMT ;START OUTPUT
RESTORE <R5,R4,R3,R2,R0> ;RESTORE ACS
15$: MOV DB.LCB(J),R1 ;GET POINTER TO THE LCB
BEQ 35$ ;GET OUT IF NO LCB
ADD #LC.STA,R1 ;POINT TO DATASET STATE BYTE
CMPB #LCS.RC,@R1 ;RUNNING NORMALLY?
.IF NE FTDN11
BEQ 27$ ;YES, -10 WANTS US TO HANG UP
CMPB #LCS.DL,@R1 ;NO, DIALING OUT?
BEQ 27$ ;YES, -10 APPARENTLY WANTS TO ABORT
CMPB #LCS.DS,@R1 ;DIALING OUT SUCCESSFUL?
.ENDC;.IF NE FTDN11
BNE 35$ ;YES, -10 STILL WANTS TO ABORT
27$: MOVB #LCS.HA,@R1 ;FORCE DATASET TO HANG UP
35$: RESTORE <R1> ;GET SET/CLEAR BACK (IT'S CLEAR)
40$: BIC #TS.DTR!TS.CAR,R0 ;IGNORE -10'S OPINION OTHERWISE
42$: BIT #TS.IMO,R0 ;SET OR CLEAR IMAGE OUTPUT?
BEQ 60$ ;NO, ACT NORMALLY
BIC #TS.IMO,R0 ;DON'T ACTUALLY DO IT NOW
SAVE R0 ;SAVE BITS TO SET/CLEAR
MOV R1,R0 ;COPY SET/CLEAR CODE
DEC R0 ;CONVERT TO ESCAPE FUNCTION CODE
JSR PC,QTECHR ;PUT ESCAPE FUNCTION INTO DATA STREAM
RESTOR R0 ;GET BITS TO SET/CLEAR BACK
;CONTINUED ON NEXT PAGE
;CONTINUED FROM PREVIOUS PAGE
;DO "SET" BITS IF REQUESTED
60$: CMP #1,R1 ;DOES HE WANT A SET BITS ?
BNE 70$
BIS R0,DB.DCS(J) ;SET BITS
BR 90$ ;AND NOW DONE
;DO "CLEAR" BITS IF REQUESTED
70$: CMP #2,R1 ;WANT TO CLEAR BITS ?
BNE 80$
BIC R0,DB.DCS(J) ;CLEAR THE BITS LIKE BEFORE
BR 90$ ;NOW DONE
;NOT "SET" OR "CLEAR" BITS
80$:
.IF EQ DGUTS
TRAP
.IFF
TST (P)+ ;GET STACK BACK INTO SYNC
CTYMSG NCL ;LOG BAD NCL MSG ERROR
RTS PC ;AND EXIT
.ENDC ;.IF EQ DGUTS
;SEE IF ANYTHING CHANGED, TELL THE -10 IF NEEDED
90$: TRACE DV
MOV DB.DCS(J),R0 ;COPY OF NEW STATUS
BIC #TS.DTR!TS.CAR,(P) ;IGNORE DTR AND CAR (THIS IS TO AVOID
BIC #TS.DTR!TS.CAR,R0 ; A STATUS MESSAGE WAR WITH THE -10)
CMP R0,(P)+ ;DID DEVICE CONTROL STATUS CHANGE?
BEQ 95$ ;NO, ALL SET
BIS #DS.XDS,@J ;YES, SEND -10 OUR NEW STATUS
95$: BR TOGMSG
;HERE WHEN WE RECEIVE A CONTROL MESSAGE
TOGCTL: JSR PC,DVGDBY ;GET DCT BYTE
52$: TST R0 ;DCT CAN'T BE TOO SMALL
BLT TOGBAD ;OR WE WILL GET UPSET
CMP R0,#4 ;DCT ALSO CAN'T BE TOO BIG
BGT TOGBAD ;OR WE WILL GET UPSET
ASL R0 ;WORD INDEX
JSR PC,@54$(R0) ;DISPATCH ON DCT CODE
BR TOGMSG ;FIRE UP ANOTHER MESSAGE
54$: TOGC00 ;00 - ECHO PIPELINE MARKER
TOGC01 ;01 - CHARACTER GOBBLER
TOGC02 ;02 - TTY CHARACTERISTICS
TOGC03 ;03 - AUTO DIAL
TOGC04 ;04 - XOFF REQUEST
;HERE WHEN RECEIVE AN ECHO-PIPELINE MARKER
TOGC00: JSR PC,DVGDBY ;GO GET MARKER
TST DB.IBF(J) ;MORE STUFF PENDING ?
BNE 99$ ;IF SO CAN'T GO TO LOCAL ECHO
CMPB R0,DB.EPL(J) ;DOES IT MATCH LAST I SENT ?
BNE 99$ ;IF NOT IGNORE IT
BIC #TS.DFE,DB.DCS(J) ;BACK INTO LOCAL ECHO MODE
BIS #DS.XDS,(J) ;SEND NEW STATUS TO HOST
99$: RTS PC ;ALL DONE HERE
;HERE WHEN RECEIVE A DIAL-OUT REQUEST
TOGC03:
.IF NE FTDN11
JSR PC,DNSTRT ;START DIALING
RTS PC ;NOTHING MORE HERE
.IFF
TST (P)+ ;POP RETURN ADDRESS
BR TOGBAD ;BUMMER
.ENDC
;HERE TO SEND AN XOFF MSG ASAP
TOGC04: JSR PC,SNDXOF ;SEND XOFF RIGHT AWAY
BIC #DS.IST,@J ;LET THE -10 GENERATE THE XON
RTS PC ;AND KEEP WORKING
;HERE WHEN RECEIVE A CHARACTER GOBBLER
TOGC01: PIOFF ;DISABLE INTERRUPTS FOR A WHILE
MOV DB.TOB(J),R0 ;GET POINTER TO OUTPUT CHARS
MOV DB.TOB+2(J),R1 ;SAVE END POINTER ALSO
CLR DB.TOC(J) ;ZERO OUTPUT COUNT
CLR DB.TOB(J) ;NO OUTPUT TAKER
CLR DB.TOB+2(J) ;AND NO TAKER
PION ;REENABLE INTERRUPTS
BIC #TS.FRZ,DB.DCS(J) ;START OUTPUT IF STOPPED
MOV R1,-(SP) ;MOVE TO A MORE CONVENIENT PLACE
TST R0
BEQ 40$
10$: CMP R0,(P) ;WAS THAT LAST CHARACTER TO THROW AWAY?
BEQ 30$ ;YES, WE'RE DONE
ADVCNK R0,FREE ;ADVANCE A FREE CHUNK (IF NECESSARY)
MOVB (R0)+,R1 ;GET NEXT CHARACTER
CMP R1,#ESCF ;IS IT FUNCTION ESCAPE CHARACTER?
BNE 10$ ;NO, KEEP FLUSHING
ADVCNK R0,FREE ;ADVANCE CHUCKS, IF NEEDED
MOVB (R0)+,R1 ;GET FUNCTION CODE
JSR PC,DOESCF ;PERFORM FUNCTION
BR 10$ ;AND CONTINUE FLUSHING
30$: DEC R0 ;ENSURE WE HAVEN'T RUN OFF CHUNK
BIC #CNKSIZ-1,R0 ;FREE REST OF LIST
JSR PC,FRECKS ;FRECK IT!
40$: TSTB (P)+ ;CLEAN UP STACK
RTS PC ;BACK FOR MORE MESSAGES
;HERE WHEN RECEIVE A CHARACTERISTICS MESSAGE
TOGC02: MOV J,R2 ;COPY DEVICE BLOCK POINTER
ADD #DB.FIL,R2 ;POINT TO FILLER SECTION
MOV #6,R3 ;COUNTER
66$: JSR PC,DVGEXF ;GET AND EXTENSIBLE FIELD
CLC ;NEED LOGICAL SHIFT (DIVIDE BY 2)
ROR R0 ;GET FILL TIME AS SEC/500
BEQ 67$ ;IF 0 JUST USE IT
ASR R0 ;GET FILL TIME AS SEC/250
ADD #4,R0 ;FOR ROUND OFF
BIT #37000,R0 ;IS TIME TOO LARGE FOR TICK TIMER
BEQ 68$
NEG R0
SWAB R0 ;GET FILL TIME IN SEC
BR 67$
68$: ASR R0 ;GET FILL TIME IN SEC/125
ASR R0 ;GET FILL TIME IN SEC/62.5
67$: MOVB R0,(R2)+ ;SAVE FILLER
SOB R3,66$ ;LOOP BACK FOR REST OF FILLER
;NOW GET SPEED FROM CHARACTERISTICS MESSAGE
JSR PC,DVGEXF ;GET RECEIVE SPEED
.IF NE TTYN
JSR PC,75$ ;CONVERT RECEIVE SPEED TO A DH11 CODE
MOV DB.LCB(J),R2 ;POINT TO LINE CONTROL BLOCK
MOV LC.SPD(R2),R2 ;GET INITIAL GUESS FOR SPEED
MOV R2,-(P)
TST R1 ;CHECK SPEED TABLE INDEX FROM 75$
BLT 72$ ;IF DIDN'T FIND SPEED
BIC #^C377,R2 ;MASK OUT JUNK
SWAB R1 ;POSITION RECEIVE CODE IN "LH"
BIS R1,R2 ;SET NEW RECEIVE SPEED IN OUR COPY
.ENDC
72$: JSR PC,DVGEXF ;GET TRANSMIT SPEED
.IF NE TTYN
JSR PC,75$ ;CONVERT THAT TO A DH11 CODE
TST R1
BLT 74$ ;IF DIDN'T FIND SPEED
BIC #377,R2 ;MASK OUT JUNK
BIS R1,R2 ;PUT NEW SPEED IN OUR COPY
74$: CMP R2,(P)+ ;SAME AS LAST SPEED ?
BEQ TYSR60 ;IF SO IGNORE
PIOFF
MOV R2,-(P) ;SAVE SPEED
MOV DB.LCB(J),R2 ;POINT TO LCB
CMPB #LCS.AB,LC.STA(R2) ; AUTO BAUD ?
BNE 73$ ; NO
MOVB #LCS.RU,LC.STA(R2) ;SET TO RUN STATE
BIC #LCB.TM,LC.CAR(R2) ;CLEAR TIMER
73$: JSR PC,SETSPD ;SET NEW SPEED
TST (P)+ ;POP THE SPEED
PION
BR TYSR60
;HERE TO SEARCH SPEED TABLE FOR DH11 CODE
75$: MOV #SPDLIM-SPDTAB,R1 ;MAKE SPEED TABLE INDEX
76$: CMP R0,SPDTAB(R1) ;CHECK FOR MATCH
BEQ 78$
SUB #2,R1 ;LOWER INDEX TO SPDTAB
BPL 76$
78$: ASR R1 ; FORM TRUE INDEX
RTS PC
.ENDC
TYSR60: JSR PC,DVGEXF ;GET WIDTH
MOVB R0,DB.WID(J)
JSR PC,DVGEXF ;GET AUTO CAR RETURN POSITION
MOVB R0,DB.ACR(J)
JSR PC,DVGEXF ;GET ELEMENT NUMBER
.IF NE FT2741
MOV #BCDXIN-2-ELETAB,R1 ;FIRST INDEX TO TRY
82$: CMP ELETAB(R1),R0 ;HIT OUR BOY ?
BNE 84$ ;IF NOT RIGHT DON'T USE
SWAB R1 ;POITION BITS
ASR R1 ; DITTO
BIC #BCDCOD,DB.BCD(J) ;CLEAR OLD CODE
BPL 86$ ;BRANCH IF NOT 2741
BIS R1,DB.BCD(J) ;SET NEW CODE
84$: DECB R1 ;ON TO NEXT
DECB R1
BPL 82$
.ENDC
86$: JSR PC,DVGEXF ;GET 2741 BITS
.IF NE FT2741
BIC #<BCDTDY!BCDAPL!BCDHDB>,DB.BCD(J)
BIC #^C<BCDTDY!BCDAPL!BCDHDB>,R0
BIS R0,DB.BCD(J)
.ENDC
BIC #TT.APL,DB.TTS(J) ;CLEAR THE APL BIT INITIALLY
BIT #CHRAPL,R0 ;MAKE SURE WE GET THE APL BIT
BEQ 87$ ;NOT SET, LEAVE IT CLEAR
BIS #TT.APL,DB.TTS(J) ;YES, SET IT
87$: ASSERT EQ DB.OCN(J) ;COUNT SHOULD BE 0 NOW
RTS PC ;BACK FOR MORE [SUB]MESSAGES
TOGDON: BIT #DS.XDS,(J) ;SEND STATUS IF REQUIRED
BEQ 20$
JSR PC,DVPDCS
20$:
.IF NE FT.TSK
JSR PC,TK0WAK ;WAKE 'GET PRINTER' TASK IF ANY
MOV J,R3 ;COPY DDB ADDRESS
24$: MOV DB.TSK+6(J),J ;GET ADDRESS OF 'PUT KEYBOARD' TASK
BEQ 26$
JSR PC,TSKWAK
26$: MOV R3,J ;RESTORE DDB ADDRESS
.ENDC
JSR PC,BEGXMT ;START TYPING
;HERE TO CHECK FOR INPUT TO GO TO THE 10
TTYICK: BIT #DS.ACT,@J ;UNLESS ACTIVE
BNE 10$
BIT #DS.DIE!DS.DSC,(J) ;ARE WE DONE WITH THE CONNECTION
BEQ 10$ ;IF NOT, SEE IF THERE IS INPUT
JMP DVCCFM ;NO LONGER CONNECTED. SEND
; DISCONNECT CONFIRM AND CLEAN DDB
10$:
.IF NE DN11N
.IF NE FT.RDA&FT.TSK
TST DB.RDT(J) ; CHECK FOR RDA DEVICE
BEQ 17$ ; NO
JSR PC,DNSTTJ ; CHECK FOR AUTO DIAL ON DEVICE
JSR PC,RDXSTA ; CHECK STATUS
17$:
.ENDC
.ENDC
BIT #DS.IQU,@J ;IS NCL ALREADY SENDING OUR INPUT ?
BEQ 16$
12$:; JMP TYICK9 ;IF SO HOLD REST
RTS PC ;SAVE 2 BYTES
;NOW SHIP THE CHARACTERS
16$: BIT #DS.IST,(J) ;DID WE STOP INPUT?
BEQ 15$ ;NO, BRANCH
JSR PC,SNDXON ;YES, SEND AN XON
BIC #DS.IST,(J) ;AND CLEAR XOFF FLAG
15$:
.IF NE FT.TSK
CMP DB.ICC(J),#TTYMIC ;HOW MANY CHARS IN MSG?
BHIS 18$ ;IF FULL SEND IT
BIT #DS.PAU,(J) ;CHECK WHETHER WE SHOULD HOLD
BNE 12$
.ENDC
18$:
.IF NE FT.RDA
TST DB.RDT(J) ; RDA DEVICE ??
BEQ 19$ ; NO, KEEP GOING
TST DB.IDR(J) ; INPUT DATA REQUESTS ??
BNE 11$ ; SEND DATA
RTS PC ; NO, GO BACK
11$: JMP RDACN0
19$:
.ENDC
BIT #DS.EPL,@J ;NEED TO SEND AN ECHO PIPELINE MARKER ?
BEQ 20$ ;IF NOT DON'T BOTHER
MOV #4,R0 ;CODE THIS IS A CONTROL MSG
JSR PC,DVPBSM ;BEGIN CONTROL SUBMESSAGE
BCS TYICK3 ;IF WE CAN'T SEND MSG,
;PRETEND WE DIDN'T WANT TO
CLR R0 ;CODE IS ECHO-PIPELINE-MARKER
JSR PC,DVPDAT
BCS 20$ ;ERROR RETURN
MOVB DB.EPL(J),R0 ;SERIAL # FOR MARKER
INC R0 ;INCREMENT SERIAL NUMBER
JSR PC,DVPDAT
BCS 20$ ;ERROR RETURN
BIC #DS.EPL,@J ;FLAG WE HAVE DONE IT NOW
INCB DB.EPL(J) ;INCREMENT SERIAL NUMBER FOR REAL
;HERE TO CONSIDER SENDING CHARACTERISTICS
20$: BIT #DS.XCH,@J ;NEED TO SEND CHARACTERISTICS ?
BEQ TYICK3
MOV #4,R0 ;CHARACTERISTICS IS CONTROL SUBMSG
JSR PC,DVPBSM ;BEGIN SUBMESSAGE
BCS TYICK3 ;IF WE CAN'T SEND MSG,
;PRETEND WE DIDN'T WANT TO
MOV #2,R0 ;CODE IS 2 FOR CHARACTERISTICS
JSR PC,DVPDAT
BCS TYICK3 ;ERROR RETURN
MOV #6,R2 ;ESTABLISH COUNTER FOR FILLS
MOV J,R4 ;COPY DEVICE BLOCK ADDRESS
ADD #DB.FIL,R4 ;POINT TO FILLERS
22$: MOVB (R4)+,R0 ;GET NEXT FILLER
BIC #^C377,R0 ;STRIP EXTRA BITS
ASL R0
ASL R0
ASL R0
ASL R0
JSR PC,DVPEXD ;PUT EXTENSIBLE FIELD IN SUBMESSAGE
SOB R2,22$ ;LOOP BACK FOR REST OF FILLERS
.IF NE TTYN
MOV DB.LCB(J),R0 ;POINT TO LINE CONTROL BLOCK
MOV LC.SPD(R0),R0 ;GET SPEED
MOV R0,-(P)
SWAB R0
ASL R0 ;MAKE INTO INDEX
JSR PC,24$
MOV (P)+,R0
ASL R0
JSR PC,24$
BR 26$
24$: BIC #^C76,R0 ;STRIP EXTRA BITS
MOV SPDTAB(R0),R0 ;TRANSLATE TO BAUD
JMP DVPEXD
26$:
.IFF
MOV #^D110,R0 ;DEFAULT IS 110 BAUD
JSR PC,DVPEXD ;PUT INTO SUBMSG
MOV #^D110,R0 ;DEFAULT IS 110 BAUD
JSR PC,DVPEXD
.ENDC
MOVB DB.WID(J),R0 ;WIDTH
JSR PC,DVPEXA
MOVB DB.ACR(J),R0 ;AUTO CRLF POSITION
JSR PC,DVPEXA
.IF NE FT2741
MOV DB.BCD(J),R0 ;GET 2741 STATUS
SWAB R0
BIC #^C7,R0 ;LEAVE ONLY ELEMENT CODE
ROL R0
MOV ELETAB(R0),R0 ;GET ELEMENT NUMBER FOR TTY
.IFF
CLR R0 ;FOR NON 2741 80'S SEND ZIP
.ENDC
JSR PC,DVPEXD
.IF NE FT2741
MOV DB.BCD(J),R0 ;2741 BITS
BIC #^C<BCDTDY!BCDAPL!BCDHDB>,R0 ;STRIP EXTRA BITS
.ENDC
BIT #TT.APL,DB.TTS(J) ;MAKE SURE WE SEND THE APL BIT
BEQ 30$ ;NOT SET, LEAVE IT CLEAR
BIS #CHRAPL,R0 ;YES, SET IT
30$: JSR PC,DVPEXD
BIC #DS.XCH,@J ;HAVE SENT THEM NOW
TYICK3:
;CHECK TO SEE IF WE WANT TO TURN LINE AROUND
.IF NE FT2741
MOV DB.BCD(J),R0 ;GET 2741 STATUS
BPL 20$ ;IF NOT 2741 WE ARE DONE
BIT #BCDPRL,R0 ;IS THE PRINTER LOCKED ?
BNE 20$ ;IF SO WE ARE DDONE
BIT #DS.ACT,@J ;IS TRANSMITTER ACTIVE ?
BNE 20$ ;IF SO CAN'T GIVE IT UP
BIT #TS.TIW,DB.DCS(J) ;DEVICE IN INPUT WAIT ?
BEQ 20$ ;IF NOT WE ARE DONE
MOV #<4*400>+1,DB.TIM(J) ;START CLOCK
BIS #BCDPRL!BCDCDB,DB.BCD(J)
BIS #DS.ACT,@J
.ENDC;.IF NE FT2741
20$:
.IF NE FT.TSK
BIT #DS.Q10,(J) ;ID THERE STUFF IN THIS ?
BEQ 24$
BIC #DS.Q10,(J) ;NOT ANY LONGER
BIC #TS.TIW,DB.DCS(J) ;TEN NO LONGER HUNGRY
BR 26$
.ENDC
24$: BIT #DS.XDS,@J ;NEED TO SEND DEVICE STATUS ?
BEQ 40$
26$:
JSR PC,DVPDCS ;PUT DEVICE STATUS INTO THE MESSAGE
40$:
44$:
RDACN0: MOV DB.IBF(J),R0 ;GET MESSAGE POINTER
BEQ TYICK9 ;IF NO CORE
.IF NE FT.RDA
TST DB.RDT(J) ;RDX DEVICE ?
BEQ 45$ ; NO
BPL 39$ ;NO BREAK SEEN
BIC #RDEBRK,DB.RDT(J) ;CLEAR BREAK SEEN
38$: DECB DB.IDR(J) ;COUNT REQUEST OFF
BR 45$
39$: CMP DB.ICC(J),#TTYMIC ;DO WE HAVE TO SHIP IT ?
BHIS 38$ ; YES
BR TYICK9 ;RETURN TO USER
45$:
.ENDC
TST DB.ICN(J) ;UNFINISHED SUBMESSAGE ?
BEQ 46$
JSR PC,DVPSBM ;CLOSE OFF SUBMESSAGE
46$: MOV J,CN.DDB(R0) ;SAVE DEVICE BLOCK ADDRESS
BIS #DS.IQU,@J ;SO WE DON'T SEND MORE FOR WHILE
CLR DB.ICC(J) ;NO LONGER HOLDING TTY CHARS
JSR PC,NCLIN1 ;GET RID OF MESSAGE
CLR DB.IBF(J) ;FORGET BUFFER
CLR DB.IAD(J) ;FORGET BYTE POINTER
;
; Here after we have cleared our count of input
; characters that gets maintained at interupt level.
; NOTE that we moved the XON code from higher up to down
; here, since we want to make sure all is idle before we
; let the terminal start up again
;
.IF NE FT.RDA
TST DB.RDT(J) ;IS THIS AN RDA
BNE TYICK9 ;YES, SKIP THIS
.ENDC
BIT #DS.IST,(J) ;DID WE STOP INPUT?
BEQ TYICK9 ;NO, BRANCH
JSR PC,SNDXON ;YES, GO SEND AN XON
BIC #DS.IST,(J) ;AND CLEAR XOFF FLAG
TYICK9: RTS PC
SPDTAB: .WORD ^D0
.WORD ^D50
.WORD ^D75
.WORD ^D110
.WORD ^D134
.WORD ^D150
.WORD ^D200
.WORD ^D300
.WORD ^D600
.WORD ^D1200
.WORD ^D1800
.WORD ^D2000
.WORD ^D2400
.WORD ^D3600
.WORD ^D4800
.WORD ^D7200
.WORD ^D9600
.WORD ^D19200
.WORD ^D1
SPDLIM: .WORD ^D2
.MACRO X Q ;MACRO TO MAKE IT EASY TO DEFINE DISPATCH ENTRYS
.IF DF Q
.WORD Q
.IFF
.WORD TRPINT
.ENDC
.ENDM
DEVTYP: ;DISPATCH FOR TYPE OF DEVICE TO TYPE ON
X DHTYPE
X DZTYPE
DEVSPD: ;DISPATCH FOR TYPE OF DEVICE TO SET SPEED ON
X DHSPD
X DZSPD
DEVBKN: ;DISPATCH TO TURN ON XMIT-BREAK
X DHBKON
X DZBKON
DEVBKF: ;DISPATCH TO TURN OFF XMIT-BREAK
X DHBKOF
X DZBKOF
;DEVICE TIMER (USED FOR IRMA CATCHER)
RDATIM:
CTYTIM:
TTYTIM:
JMP @10$(R0) ;DISPATCH ON TIMER CODE
10$: TCLK00 ;(TCLK00) FILLER
.IF NE FT2741
TCLK02 ;(TCLK02)
TCLK04 ;(TCLK04)
TCLK06 ;(TCLK06)
TCLK10 ;(TCLK10)
30$ ;(TCLK12)
.IFF;.IF NE FT2741
30$ ;(TCLK02)
30$ ;(TCLK04)
30$ ;(TCLK06)
30$ ;(TCLK10)
30$ ;(TCLK12)
.ENDC;.IF NE FT2741
30$: RTS PC ;HERE TO JUST RETURN
TCLK00: PIOFF
BIT #DS.ACT,@J ;BE SURE IS ACTIVE
BEQ 90$ ;THIS IS A RACE CONDITION
JSR PC,XMTINT ;FAKE TRANSMIT DONE INTERRUPT
90$: PION
100$: RTS PC
TYPHIA: MOV #HIAMSG,R1 ; GET "HOST IS AVAILABLE"
BR TTYMSG ; AND PRINT IT ON THE TTY
TYPNHA: MOV #NHAMSG,R1 ;GET "NO HOST AVAILABLE"
BR TTYMSG ; AND GIVE IT TO THE USER
TYPWCC: MOV #WCCMSG,R1 ;GET "WAITING FOR CONNECT CONFIRM"
BR TTYMSG
TYPHSD: MOV #HSDMSG,R1 ;GET "HOST SENT DISCONNECT"
BR TTYMSG
TYPHWA: MOV #HWAMSG,R1 ;GET "HOST WENT AWAY"
BR TTYMSG
TYPIBF: MOV #IBFMSG,R1 ;GET "INPUT BUFFER FULL"
; BR TTYMSG
;TTYMSG ROUTINE TO START A TTY TYPING A FIXED STRING. (WON'T
; TYPE STRING IF AN RDA LINE, OR IF ONE IS ALREADY TYPING.)
;ENTER WITH
; R1/ ADDRESS OF STRING TO TYPE
TTYMSG: TST DB.STR(J) ;DON'T FORCE THE MSG IF
BNE 99$ ;ONE IS ALREADY TYPING OUT
.IF NE FT.RDA
TST DB.RDT(J) ;RDA ??
BNE 99$ ;YES, DON'T SEND HIM GARBAGE.
.ENDC
MOV R1,DB.STR(J)
; CLRB DB.TIM(J) ;CLEAR TIMER SO OUTPUT SURE TO START.
; ; (THIS IS NECESSARY BECAUSE IF WE
; ; ARE PRINTING A DISCONNECT MSG,
; ; CLRDDB WILL CLEAR TIMER AND STOP US)
JSR PC,BEGXMT ;START THE TTY TYPING
99$: RTS PC
TYMSG1: RTS PC
;HERE FROM LOOP WITH INPUT CHAR IN R0, DEVICE BLOCK ADR IN J
RECINT: BIT #DS.DIE!DS.DSC,@J ;DID TEN DIE ?
BNE TYMSG1 ;TOSS CHAR AND LET DISCONNECT
; CODE TELL USER WHAT'S GOING ON
.IF NE FTHOST!FT.RDA
BIT #DS.CON,@J ;IS TTY CONNECTED ?
BNE RECIN0
.ENDC
.IF NE FT.RDA
TST DB.RDT(J) ; IS THIS RDA DEV ??
BNE TYMSG1 ; YES, DUMP IT
.ENDC
.IF NE FTHOST
JSR PC,FNDPFH ;TRY TO CONNECT TO HOST
BEQ TYPNHA ;IF NO HOST AVAILABLE, TELL THE USER
JSR PC,SNDCON ;TRY TO CONNECT TO THE HOST
BR TYPWCC ;TELL THE GUY WE SENT A CONNECT FOR HIM
.ENDC
;HERE TO PROCESS THE CHARACTER
RECIN0:
.IF NE FTHOST
TST DB.RLA(J) ;ARE WE HALF WAY THERE
BEQ TYPWCC ;IF SO, SAY "WAITING FOR CONFIRM"
.ENDC
.IF NE FT.TSK
BIT #DS.PAU,(J) ;DID THIS COME FROM A TASK
BEQ 14$ ;NO, INTERUPT LEVEL CHECKS BUFFER FULL
CMP #TTYMIC,DB.ICC(J) ;HOW MANY CHARS ALREADY WAITING ?
BMI TYPIBF ;TELL USER THAT INPUT BUFFER IS FULL
.ENDC
14$: BIC #^C377,R0 ;STRIP EXTRA BITS
MOV R0,R1 ;COPY CHARACTER
BIC #^C177,R1 ;STRIP EXTRA BITS
CMPB R1,#21 ;IS THIS AN "XON"
BNE 15$ ;NO, MOVE ALONG
SAVE <R0,R1> ;SAVE CHARACTER
JSR PC,BEGXMT ;YES, START TYPING
RESTORE <R1,R0> ;GET BACK CHARACTER
15$: BIT #DS.XDS,(J) ;SEND NEW STATUS TO HOST?
BEQ 16$ ;NO, KEEP GOING
SAVE <R0,R1> ;PROTECT OUR CHAR FROM DNDEV
JSR PC,DVPDCS ;SEND STATUS TO THE -10
RESTORE <R1,R0> ;GET THE CHARACTER BACK
16$: BIT #TS.IMI,DB.DCS(J) ;CHECK FOR IMAGE INPUT MODE
BNE RECIN1 ;IN WHICH WHICH CASE NO EDITING
TST R1
BEQ RECINX ;FLUSH NULLS
CMP R1,#40 ;SPACE?
BNE 20$ ;NOPE, DON'T DO AUTO CRLF CHECK
MOVB DB.ACR(J),R2 ;GET ACR POSITION
BEQ 20$ ;0 SAYS WE DON'T DO IT
CMPB R2,DB.COL(J) ;HAVE WE REACHED THAT POINT?
BHI 20$ ;NOT YET, KEEP GOING
MOV #215,R0 ;CHANGE SPACE INTO CR
MOV #15,R1 ;IN BOTH PLACES
20$: BITB #CF..LC,CHRTAB(R1) ;IS CHARACTER LOWER CASE ?
BEQ RECIN1
BIT #TS..LC,DB.DCS(J) ;DO WE WANT TO CONVERT LC TO UPPER ?
BEQ RECIN1
ADD #140,R0 ;CONVERT TO UPPER CASE AND
; COMPLEMENT PARITY
RECIN1:
.IF NE FT.RDA
TST DB.RDT(J) ; RDA ??
BNE 99$ ; YES, CHECK FOR BREAK
.ENDC
42$: BIT #TS.DFE,DB.DCS(J) ;IN DEFERED ECHO MODE ?
BNE 55$ ;SEND IT WITH A NEW ECHOPIPELINE MARKER
BIT #DS.ACT,@J ;IS LINE ALREADY TYPING ?
BNE 50$ ;IF SO GO INTO DEFERRED ECHO MODE
.IF NE FT2741
TST DB.BCD(J) ;IS THIS A 2741 ?
BMI 50$ ;IF SO GO INTO DEFERRED ECHO MODE
.ENDC
BIT #<TS.TAP!TS.IMI>,DB.DCS(J) ;TAPE OR IMAGE MODE?
BNE 43$ ;IF SO, THEN <CR> NOT SPECIAL
CMPB #15,R1 ;IS CHAR A CARRIAGE RETURN ?
BEQ 48$ ;IF SO SPECIAL ACTION
43$: BITB #CHRDEF,CHRTAB(R1) ;DOES THIS CHAR PUT US INTO DEFERRED ECHO MODE ?
BNE 50$
MOV R0,-(P) ;SAVE CHAR
.IF NE FT.TSK
JSR PC,TK0WAK ;WAKE UP THE 'GET PRINTER' TASK
BEQ 46$ ;IF NONE, JUST ECHO
JSR PC,QTYCHR ;USE NCL ENTRY
BR 49$
.ENDC
46$: TSTB DB.HLD(J) ;IF ALREADY HOLDING A CHAR BETTER FORCE IT OUT
BEQ 44$
47$: JSR PC,BEGXMT ;ECHO IT
MOVB (P),DB.HLD(J) ;SAVE CHAR
BR 45$
44$: MOVB R0,DB.HLD(J) ;SAVE CHAR
49$: JSR PC,BEGXMT ;ECHO IT
45$: MOV (P)+,R0 ;GET CHAR BACK
.IF NE FT.HLD ;IF WE ARE HOLDING CHARACTERS
CMP #<TTYMIC/2>,DB.ICC(J) ;DO WE HAVE PLENTY OF CHARACTERS?
BMI 60$ ;YES, SEND THE MESSAGE NOW
TWIDDLE ;FOR THISE WHO WATCH
TWIDDLE DB.ICC(J) ;SEE HOW MANY CHARS IN THE MESSAGE
JSR PC,DVPDAT ;PUT BYTE INTO THE MESSAGE
BR 70$ ;GO RETURN
.IFF
BR 60$ ;PUT CHAR IN INPUT QUEUE
.ENDC;.IF NE FT.HLD ;IF WE ARE HOLDING CHARACTERS
;HERE WHEN USER TYPES A CARRIAGE RETURN WHILE IN LOCAL ECHO MODE
48$:
.IF NE FT.TSK
JSR PC,TK0WAK ;WAKE UP 'GET PRINTER' TASK
BEQ 51$
MOV R0,-(P) ;SAVE CHARACTER <CR>
JSR PC,QTYCHR ;ECHO THE <CR>
MOV #12,R0 ;AND APPEND A <LF>
JSR PC,QTYCHR
MOV (P)+,R0 ;GET THE <CR> BACK
BR 52$ ;NOW SEND THE <CR> TO THE HOST
.ENDC
51$: MOV #CRLMSG,DB.STR(J) ;TYPE A CR/LF
52$: JSR PC,55$ ;PUT CARRIAGE RETURN INTO MSG
BIS #TS.DFE,DB.DCS(J) ;SET DEFERED ECHO MODE
JSR PC,BEGXMT
JMP DVPDCS ;SEND NEW STATUS TO 10
;IF RDA, CHECK FOR BREAK
.IF NE FT.RDA
99$: CMP #RDABRK,R1 ;BREAK ??
BNE 60$ ; NO
BIS #RDEBRK,DB.RDT(J) ;SET IT SEEN
BR 60$
.ENDC
;HERE TO GO INTO DEFERRED ECHO MODE
50$: BIS #TS.DFE,DB.DCS(J) ;SET DEFERED ECHO FLAG
MOV R0,-(P) ;SAVE INPUT CHAR
JSR PC,DVPDCS ;PUT STATUS INTO MESSAGE
MOV (P)+,R0 ;GET CHAR BACK
55$: BIS #DS.EPL,@J ;NEED TO SEND A NEW ECHO PIPELINE MARKER
60$: JSR PC,DVPDAT ;PUT BYTE INTO THE MESSAGE
98$: JSR PC,QUEDEV ;WAKE SERVICE ROUTINE
70$:
.IF NE FT.RDA!FT.TSK
.IF NE FT.RDA
TST DB.RDT(J) ;IS THIS AN RDA DEVICE?
BNE 75$ ;YES, NEED TO COUNT CHAR
.ENDC
.IF NE FT.TSK
BIT #DS.PAU,(J) ;DID THIS COME FROM A TASK?
BEQ RECINX ;NO, DON'T COUNT, INTERUPT LEVEL HAS
.ENDC
75$: INC DB.ICC(J) ;COUNT CHAR INTO THE MESSAGE
.ENDC ; .IF NE FT.RDA!FT.TSK
RECINX: RTS PC
;HERE TO SEND XON
SNDXON: MOVB #21,R0 ;GET XON
BR SNDNOW ;GO SEND IT
;HERE TO SEND XOFF
SNDXOF: MOVB #223,R0 ;GET XOFF
SNDNOW: PIOFF ;INTERUPTS OFF
BIT #DS.ACT,@J ;ARE WE ALREADY OUTPUTING?
BEQ 10$ ;NO, START OUTPUT
MOVB R0,DB.ASP(J) ;YES, WE'LL CATCH IT AT NEXT XMT INT
BR 20$ ;TURN ON INTERRUPTS AND EXIT
10$: BIS #DS.ACT,@J ;SAY WE ARE TYPING
JSR PC,TYPE90 ;GO SEND IT
20$: PION ;INTERUPTS BACK ON
RTS PC ;RETURN
BEGXMT: PIOFF ;DISABLE INTERRUPTS
BIT #DS.ACT,@J ;ARE WE ALREADY TYPING ?
BNE 20$ ;IN CASE ALREAY TYPING
BIS #DS.ACT,@J ;SET ACTIVE FLAG
TSTB DB.TIM(J) ;IF TIMER IS RUNNING,EXIT
BNE 20$
JSR PC,XMTINT
20$: PION ;REENABLE INTERRUPTS
RTS PC
;HERE WHEN NO OUTPUT LEFT AND MAY WANT TO RELEASE OUTPUT CHUNK
XMT.80: TST DB.OBF(J)
BNE XMT.90
DEC R0 ;BACK UP TAKER
BIC #CNKSIZ-1,R0 ;MAKE INTO A CHUNK ADR
JSR PC,FRECNK ;RELEASE CHUNK
CLR DB.TOB(J) ;CLEAR POINTER
CLR DB.TOB+2(J) ;AND PUTTER
;HERE WHEN NOTHING MORE TO TYPE
XMT.90: JSR PC,QUEDEV ;SEND DATA REQUESTS MAYBE
.IF NE FT2741
TSTB DB.TIM+1(J) ;DOING 2741 FUNCTION ?
BNE 20$ ;IF SO DON'T STOP TIMER
.ENDC
BIC #DS.ACT,@J ;CLEAR ACTIVE FLAG
.IF NE FT.TSK
MOV J,-(P) ;SAVE DDB ADR
MOV DB.TSK+4(J),J ;GET TASK BLOCK ADR
BEQ 12$ ;IF NONE WE ARE DONE
JSR PC,TSKWAK ;WAKE UP THE TASK
12$: MOV (P)+,J ;RESTORE DDB ADR
.ENDC
20$: RTS PC
;HERE AT INTERRUPT LEVEL TO SEE IF THERE ARE MORE CHARS TO TYPE
TTDZOU:
TTDHOU:
XMTINT:
.IF NE FT2741
TST DB.BCD(J) ;2741S USE DB.ASP FOR OTHER THAN XOF/XON
BMI 1$ ;SO DON'T CHECK HERE
.ENDC
MOVB DB.ASP(J),R0 ;DO WE WANT TO SEND A CHARACTER FAST?
BEQ 1$ ;NO
CLRB DB.ASP(J) ;YES, CLEAR OUT THE CHAR
JMP TYPE90 ;AND SEND IT
1$: CMP #20,JIFFLG ;IF CLOCK LEVEL HAS RUN RECENTLY
BGE XMT.0 ; THEN IT'S OK TO RUN TERMINALS NOW
MOVB #3,DB.TIM(J) ;IF WE'VE BEEN TYING UP THE MACHINE
BIS #DS.ACT,@J ;FLAG THE LINE AS "ACTIVE"
5$: RTS PC ;BUT OTHERWISE SHUT IT DOWN
; (LETTING IRMA RESTART IT LATER)
XMT.0: CLR DB.TIM(J) ;CLEAR THE TIMER
.IF NE FT.RDA
TST DB.RDT(J) ;RDA DEVICE ??
BNE 33$ ; YES
.ENDC
MOV DB.LCB(J),R1 ;POINT TO LCB OF LINE
BIT #LCB.DS,@R1 ;IS THIS A DATA SET LINE?
BEQ 2$ ; NO, SO GO AHEAD
CMPB #LCS.CD,LC.STA(R1) ;SEE IF WE ARE AUTOBAUDING (OR BOUT TO)
BGT 2$ ; STATE < LCS.CD
CMPB #LCS.AB,LC.STA(R1) ;MAX STATE TO HOLD ON
BLT 2$ ; STATE > LCS.AB
MOVB #-6,DB.TIM(J) ;WAIT FOR LATER TO CHECK FOR OUTPUT
RTS PC
2$:
.IF NE FT2741
TST DB.BCD(J) ;GET 2741 STATUS BITS
BPL 10$ ;BRANCH IF NOT 2741
MOVB DB.ASP(J),R1 ;HOLDING A CHARACTER ?
BEQ 10$
CLRB DB.ASP(J)
BR 38$
.ENDC
10$: MOV DB.FTM(J),DB.TIM(J) ;SET IRMA TIMER WAITING IN WINGS
BEQ 20$ ;IF NONE FIND NEXT CHAR TO TYPE
CLR DB.FTM(J)
RTS PC ;WAIT FOR TIMER TO GO OFF
20$: TST DB.STR(J) ;IS THERE A MESSAGE TO TYPE ?
BEQ 30$
MOVB @DB.STR(J),R1 ;GET NEXT CHAR IN STRING
BNE 22$
CLR DB.STR(J) ;HAVE EXHAUSTED STRING
BR 30$
22$: INC DB.STR(J) ;ADVANCE STRING POINTER
BR 38$
30$: MOVB DB.HLD(J),R1 ;HOLDING A CHARACTER ?
BEQ 32$ ; FROM FREE CR/LF ?
CLRB DB.HLD(J) ;DON'T TYPE IT TWICE
BR 38$ ;BUT GO TYPE IT NOW
32$: BIT #TS.FRZ,DB.DCS(J) ;IS OUTPUT STOPPED WITH XOF ?
BNE XMT.90 ;IF SO STOP TYPING
33$:
.IF NE FT.TSK
MOV DB.PTK(J),R0 ;GET PRINTER TAKER (TASK)
BEQ 50$ ;IF NON, TRY FOR STUFF FROM NCL
DEC DB.PCN(J) ;ADJUST COUNT
ASSERT PL
JSR PC,XMTGET ;POINT TO NEXT CHARACTER IN CHUNKS
MOVB (R0)+,R1 ;GET NEXT BYTE
CMP R0,DB.PPT(J) ;WAS THAT THE LAST
BNE 46$
DEC R0
BIC #CNKSIZ-1,R0 ;RESTORE CHUNK POINTER
JSR PC,FRECNK ;RELEASE CHUNK
CLR DB.PPT(J) ;CLEAR PUTTER
CLR R0
46$: MOV R0,DB.PTK(J) ;SAVE UPDATED PUTTER
BR 38$
50$: TST DB.TSK(J) ;IS THERE A 'GET PRINTER' TASK
BNE XMT.90 ;IF SO STOP THE XMITTER
.ENDC
36$: MOV DB.TOB(J),R0 ;GET POINTER TO OUTPUT CHARS
BEQ XMT.90 ;IF NONE WE ARE DONE
CMP R0,DB.TOB+2(J) ;SAME AS PUTTER ?
BEQ XMT.80
JSR PC,XMTGET ;POINT TO NEXT BYTE
MOVB (R0)+,R1 ;GET NEXT BYTE
MOV R0,DB.TOB(J)
DEC DB.TOC(J) ;COUNT CHAR OUT OF CHUNKS
CMP R1,#ESCF ;IS IT ESCAPE FUNCTION CHARACTER?
BNE 38$ ;NO, CONTINUE NORMALLY
JSR PC,XMTGET ;POINT TO NEXT CHARACTER
MOVB (R0)+,R1 ;GET FUNCTION
MOV R0,DB.TOB(J) ;UPDATE TAKER
DEC DB.TOC(J) ;AND ACCOUNT FOR CHARACTER
CMP R1,#ESCF ;ANOTHER ESCAPE?
BEQ 38$ ;YES, PASS IT ON AS DATA
JSR PC,DOESCF ;NO, DO FUNCTION
BR 36$ ;LOOK FOR ANOTHER CHARACTER
38$: MOVB #-2,DB.TIM(J) ;RESET IRMA CATCHER
BIT #TS.IMO,DB.DCS(J) ;IMAGE MODE?
BEQ 39$ ;NO,
MOV R1,R0 ;YES, COPY CHARACTER
JMP TYPE90 ; NO EDITING
39$: CMPB #211,R1 ;IS THIS A TAB?
BEQ 40$ ; IF SO, GO DO FILL
CMPB #11,R1 ;IS THE OTHER FLAVOR OF TAB ?
BNE TYPEIT
40$: MOVB DB.COL(J),R2 ;GET CURRENT COLUMN
ADD #10,R2 ;WHERE WE WILL BE WHEN DONE
BIC #7,R2
BIT #TS.CRL,DB.DCS(J) ;EVER DO FREE CR/LF
BNE 62$
CMPB R2,DB.WID(J) ;IS THAT INSIDE BOUNDRY ?
BLOS 62$
MOV R1,R0 ;PUT CH WHERE IT IS EXPECTED
JMP TYPE85 ;IF NOT TYPE CR FIRST
62$: BIT #TS.TAB,DB.DCS(J) ;DOES TTY HAVE HARDEWARE TAB ?
BNE XMT.2
INCB DB.COL(J) ;ADVANCE COLUMN POINTER
BITB #7,DB.COL(J) ;WAS THAT LAST ?
BEQ XMT.1
MOVB R1,DB.HLD(J) ;SAVE TAB FOR LATER
XMT.1: MOV #240,R1
DECB DB.COL(J) ;SPACES WILL INC LATER
BR TYPEIT
XMT.2: MOVB R2,DB.COL(J) ;SAVE COLUMN
BR TYPEIT ;GO TYPE CHARACTER
;SUBROUTINE TO ADVANCE CHUNKS AND CAUSE DATA REG UNITS TO BE SENT
;CALL MOV <CHUNK ADDRESS<,R0
XMTGET: BIT #CNKSIZ-1,R0 ;ARE WE PAST END OF CURRENT CHUNK?
BNE 10$ ;NO, NOTHING SPECIAL
JSR PC,QUEDEV ;YES, WAKE SERVICE ROUTINE AT LOOP LEVEL
10$: ADVCNK R0,FREE ;POINT TO NEXT BYTE
RTS PC ;RETURN TO CALLER
;SUBROUTINE TO DO ESCAPE FUNCTION
; CALL MOV <FNC>,R1
; JSR PC,DOESCF ;GET FUNCTION IN REGISTER
DOESCF: CMP R1,#ESCF ;IS IT A SECOND ESCAPE CHARACTER?
BEQ 10$ ;IF SO, RETURN IMMEDIATELY
ASL R1 ;MAKE INDEX INTO ESCTAB
CMP R1,#MAXESC ;CHECK RANGE
ASSERT LE
JSR PC,@ESCTAB(R1) ;DO FUNCTION
10$: RTS PC
ESCTAB: ;ESCAPE FUNCTION TABLE
IMOON ;IMAGE OUT ON
IMOOFF ;IMAGE OUT OFF
MAXESC=.-ESCTAB-2 ;MAXIMUM LEGAL INDEX
IMOON: BIS #TS.IMO,DB.DCS(J)
RTS PC
IMOOFF: BIC #TS.IMO,DB.DCS(J)
RTS PC
;HERE TYPE A CHAR
; CALL JSR PC,TYPEIT ;WITH J SET UP AND CHAR IN R1
TYPEIT:
.IF NE FT2741
MOV DB.BCD(J),R3 ;GET 2741 STATUS BITS
BMI 10$ ;BRANCH IF 2741
JMP TYPE40 ;NOT 2741 SO NO SPECIAL HANDLING
10$: TRACE 27
BIT #BCDPRL,R3 ;TEST FOR PRINTER LOCKED
BEQ TYPE31 ;BRANCH IF NOT LOCKED
BIT #BCDBRK,R3 ;GO ON IF RCVBRK FLAG IS SET
BNE TYPE31
MOVB R1,DB.ASP(J) ;SAVE CHAR FOR LATER
BIT #BCDHDB,R3 ;TEST FOR REVERSE BREAK FEATURE
BEQ 6$ ;BRANCH IF DOESN'T HAVE IT
BIT #BCDCDB,R3 ;CHECK FOR OK TO DODEBREAK
BEQ 6$
BIT #BCDRCR,R3 ;WAS LAST CHAR IN A CR ?
BNE 6$ ;IF SO WE'LL GET CONTROL SOON ANYWAY
JINDEX JSR,DB.TYP(J),R3,DEVBKN ;CALL DRIVER TO SEND BREAK
BIS #BCDKBL!BCDXRB,DB.BCD(J);PRINTER LOCKED, XMT REV BREAK
MOV #<6*400>+^D21,DB.TIM(J) ;TIMER TO STOP BREAK
6$: RTS PC ;AND RETURN TO CALLER
TYPE31: BIC #^C177,R1 ;STRIP PARITY
;BEQ XMTINT ;FLUSH NULLS
;CMP #177,R1 ;TRANSMITTING RUBOUT ?
;BEQ XMTINT ;FLUSH RUBOUTS
;MAKE SPECIAL CHECKS FOR CARRIAGE RETURN
CMP #15,R1 ;IS THIS A CARRIAGE RETURN
BNE 10$ ;BRANCH IF NOT A CR
BIT #BCDOCR,R3 ;2ND CR IN A ROW ?
BNE 11$ ;PROBABLY FILLER - FLUSH IT
MOV #BCDCRL,R0 ;CARRIAGE RETURN CHAR
JMP TYPE37 ;GO TYPE CR
10$: BIT #BCDOCR,R3 ;DID 10 JUST SEND A CR ?
BEQ 12$ ;IF NOT DON'T CHECK FURTHER
BIC #BCDOCR,R3 ;CLEAR THE FLAG
MOV R3,DB.BCD(J) ;IN CASE FOLLOWING IS LF
CMP #12,R1 ;IS THIS A LINE FEED ?
BNE 12$ ;NO, KEEP GOING
11$: JMP XMTINT ;FLUSH LINE FEEDS
12$: MOV R3,R2 ;MAKE A COPY OF THE STATUS WORD
BIC #^CBCDCOD,R2 ;LEAVE CODE ONLY
MOV R2,R0 ;IN CASE IS NOT TIDY
ADD R1,R2
MOVB BCDXOU(R2),R1 ;TRANSLATE CHARACTER
BGE 40$ ;BRANCH IF THIS CHAR ISN'T AFFECTED BY TIDY
BIT #BCDTDY!BCDAPL,R3 ;CHECK FOR APL MODE OR TIDY
BNE 40$ ;IN WHICH CASE NOTHING SPECIAL
BIC #^C177,R2 ;STRIP EXTRA BITS
MOVB R2,DB.ASP(J) ;SAVE CHAR IN CASE WE DON'T TYPE IMMEDIATELY
BIT #BCDCON,R3 ;HAVE WE ALREADY TYPED THE TICK ?
BNE 30$ ;IF SO DONE FOR NOW
MOVB ARROW+BCDXOU(R0),R1 ;IN CASE WE WANTED A ^
TSTB TDYTAB(R2) ;DO WE WANT A ' OR A ^
BGE 23$
MOVB QUOTE+BCDXOU(R0),R1 ;WANTS A ' INSTEAD OF AN ARROW
23$: JSR PC,60$ ;BE SURE CASE SHIFT IS RIGHT
BIS #BCDCON,R3 ;SET HAVE SENT ' OR ^ FLAG
BR TYPE35 ;JUST TYPE IT
30$: MOVB TDYTAB(R2),R2 ;CONVERT THE CHAR
BIC #^C177,R2 ;STRIP EXTRA BITS
ADD R0,R2 ;ADD IN CHARACTER SET
MOVB BCDXOU(R2),R1 ;GET WHAT TO TYPE INSTEAD
JSR PC,60$ ;BE SURE CASE SHIFT IS RIGHT
CLRB DB.ASP(J) ;CLEAR SO WE DON'T TYPE AGAIN
BIC #BCDCON,R3 ;CLEAR FLAG
40$: JSR PC,60$ ;BE SURE CASE SHIFT IS RIGHT
BR TYPE35
;HERE TO BE SURE WE ARE IN RIGHT CASE SHIFT
; CALL JSR PC,60$
; RETURN IF IN RIGHT SHIFT
60$: CMP #BCDSPC,R1 ;TEST FOR CHAR IS A SPACE
BEQ 68$ ;IF SO DON'T CHECK SHIFT
BIT #10,R1 ;CHECK FOR NON-PRINTING CHARS
BEQ 61$ ; WHICH DON'T CARE ABOUT SHIFT CASE
BIT #4,R1 ;DISTINGUISHED BY 14 BITS IN CODE
BNE 68$ ;ONE OF THEM
61$: BIT #100,R1 ;TEST FOR UPPER SHIFT CHAR
BNE 64$ ;BRANCH IF NEED SHIFT
BIT #BCDUPS,R3 ;ARE WE ALREADY IN DOWN SHIFT ?
BEQ 68$ ;BRANCH IF SO
BIC #BCDUPS,R3
MOV #BCDLCS,R0 ;DOWN SHIFT CHAR
BR 66$
64$: BIT #BCDUPS,R3 ;ARE WE ALREADY IN UP SHFIT ?
BNE 68$ ;BRANCH IF SO
BIS #BCDUPS,R3 ;SET UP SHIFT
MOV #BCDUCS,R0
66$: TST (P)+ ;CLEAN OFF STACK
TSTB DB.ASP(J) ;ALREADY HOLDING A CHAR ?
BNE TYPE39 ;TYPE CHAR
MOVB R2,DB.ASP(J) ;SAVE CHAR TO TYPE LATER
BR TYPE39
68$: RTS PC
;HERE TO SET FILLER TIMES FOR 2741
TYPE35: MOV R3,DB.BCD(J) ;UPDATE STATUS
MOV R1,R0 ;COPY CHAR
CMPB #035,R0 ;IS CHAR A BACKSPACE ?
BNE 10$ ;NO
JMP TYPE81
10$: CMPB #057,R0 ;HORIZONTAL TAB?
BNE 22$
20$: MOVB DB.COL(J),R1 ;TAB USES SAME OBSTRUSE FORMULA FOR FILL
BIC #^C377,R1 ;AS LOSER HAS SET HIS TABS TO 8N FLAVOR
MOV R1,-(SP) ;SAVE CURRENT POSITION
BIS #7,R1 ;FIND NEXT MULT OF 8
INC R1
SUB (SP)+,R1 ;GET DELTA
ADD #8.+8.+1,R1 ;TWICE THE CONSTANT + ROUNDER
ASR R1 ;DELTA/2 + 8 (ROUNDED)
MOVB R1,DB.FTM(J) ;SET FILLER
BR TYPE83 ;GO CONSIDER FREE CRLF
22$: CMPB #056,R0 ;IS CHAR A LINE FEED?
BNE 23$
MOVB #5,DB.FTM(J) ;LINE FEED FILL IS ABOUT ONE CHAR TIME
BR TYPE90
23$: CMPB #055,R0 ;IS CHAR A CARRIAGE RETURN ?
BEQ TYPE37
CMPB #075,R0 ;IS CHAR AN IDLE ?
BNE TYPE82 ;NORMAL PRINTING CHAR
BR TYPE90 ;JUST TYPE IT
;HERE WHEN TYPEING CR ON A 2741
TYPE37: BIS #BCDOCR,R3 ;SET SPECIAL FLAG
JSR PC,CRF274
TYPE39: MOV R3,DB.BCD(J)
BR TYPE90
CRF274: MOV R1,-(SP) ;COMPUTE CR FILLER
MOVB DB.COL(J),R1 ;SET FILL TIME=67.5<1.5+INCHES> MS
BIC #^C377,R1 ;FLUSH SIGN EXTENSION AS COL MAY BE > 127
ASR R1 ;USE 5<1.5+COL/10.> JIFFIES
ADD #10,R1 ; =COL/2+8 JIFFIES
CMP R1,#177 ;MAKE SURE RESULT IS POSITIVE BYTE TO GET JIFFIES
BLE 1$
MOV #177,R1
1$: MOVB R1,DB.FTM(J) ;SET CR FILLER
CLRB DB.COL(J) ;NOW BACK AT COLUMN 0
MOV (SP)+,R1
RTS PC
.ENDC
TYPE40: MOV R1,R0 ;COPY CHARACTER
BIT #TS.IMO,DB.DCS(J) ;IMAGE MODE OUTPUT ?
BNE TYPE90 ;IF SO NO EDITING
BIC #^C177,R1 ;STRIP PARITY BIT
MOVB PARTAB(R1),R0 ;PUT PARITY ON CHARACTER
BITB #CHRHMO,CHRTAB(R1) ;IS THIS A NORMAL ASCII CHARACTER ?
BNE TYPE82 ;IF SO JUST ADJUST COUNT
BITB #CHRFLL,CHRTAB(R1) ;DOES CHAR REQUIRE FILLERS ?
BEQ 61$
MOV R1,R2 ;COPY 7 BIT CHAR
ADD #DB.FIL-10,R2
ADD J,R2
MOVB @R2,DB.FTM(J) ;SET FILL TIMER FOR LATER USE
61$: CMPB #10,R1 ;IS CHAR A BACKSPACE ?
BEQ TYPE81 ;BACKUP COLUMN POINTER
CMPB #11,R1 ;IS CHAR HORIZONTAL TAB ?
BEQ TYPE90 ;IF SO DB.COL ALREADY COUNTED
CMPB #15,R1 ;IS THIS A CARRIAGE RETURN ?
BNE TYPE90
CLRB DB.COL(J) ;BACK IN COLUMN 0 !
BR TYPE90
;HERE WHEN TYPING A BACKSPACE
TYPE81: DECB DB.COL(J) ;BACK UP COLUMN COUNTER
BGE TYPE90 ;IF STILL POSITIVE TYPE IT
CLRB DB.COL(J) ;ELSE BACK TO COLUMN ZERO
BR TYPE90 ;THEN TYPE IT
;HERE FOR USUAL PRINTING CHARACTERS
TYPE82: INCB DB.COL(J) ;COUNT COLUMNS
TYPE83: CMPB DB.COL(J),DB.WID(J) ;WAS THIS ALREADY ON RH MARGIN ?
BLOS TYPE90 ;IF OK CONTINUE
BIT #TS.CRL,DB.DCS(J) ;EVER DO FREE CR/LF
BNE TYPE90 ;IF NOT DON'T DO ONE NOW
.IF NE FT2741
TST DB.BCD(J) ;IF WE ARE A 2741, R0 IS BCD NOW
BPL TYPE85
MOV R2,R0 ;R2 STILL HAS ASCII - USE IT
.ENDC
TYPE85: MOVB R0,DB.HLD(J) ;SAVE CHARACTER FOR LATER
MOV #CRLMSG,DB.STR(J) ;DO A CR/LF FIRST
JMP XMTINT ;AND START OVER
;HERE WHEN HAVE SET FILLERS ETC.
TYPE90:
.IF NE TTYN+RDAN+FT.CTY
.IF NE FT.CTY
CMP J,#CTYDDB ;IS THIS FOR THE CTY ?
BNE 33$
JMP CTYTYP ;IF SO DO IT
33$:
.ENDC
MOV DB.LCB(J),R1 ;POINT TO LCB
CMPB #LCS.RU,LC.STA(R1) ;LINE OK?
BGT 95$ ; NO, DONT PRINT IT
CMPB #LCS.RC,LC.STA(R1) ;LINE OK?
BLT 95$ ; NO, DONT PRINT IT
JINDEX JMP,DB.TYP(J),R2,DEVTYP
95$: MOVB #-1,DB.TIM(J) ;SIMULATE 600 BAUD
RTS PC ;IRMA WILL CATCH THIS LATER
.ENDC
.IIF EQ TTYN, BR CTYTYP
.SBTTL TABLES FOR AUTO BAUD UP TO 9600 BAUD (LOW BIT IS MASKED OFF)
HSPMSK=376 ;MASK FOR UNWANTED BITS (HIGH SPEED AUTOBAUD)
HSPCHR=377 ;CHAR TO SWITCH TO HIGH SPEED DETECT
LSPCHR=000 ;CHAR TO SWITCH TO LOW SPEED DETECT
LSPTAB: .BYTE 174 ;110 BAUD ^C
.BYTE 214 ;110 BAUD CR
.BYTE 234 ;110 BAUD CR
.BYTE 346 ;150 BAUD CR
.BYTE 036 ;150 BAUD ^C
.BYTE 215 ;300 BAUD CR
.BYTE 015 ;300 BAUD CR, ODD
.BYTE 003 ;300 BAUD ^C
.BYTE 203 ;300 BAUD ^C, ODD
.BYTE 372 ;600 BAUD CR, EVEN (CAN'T DETECT ^C AT 600)
.BYTE 362 ;600 BAUD CR, ODD
.BYTE 376 ;1200 BAUD ^C, EVEN
LSPEND: ;END OF TABLE
;TABLE OF LOW SPEED INDEX'S
LSP.IG=200 ;THROW AWAY NEXT CHAR AFTER AB CHAR (SIGN BIT)
LSP.SP=017 ;MASK FOR SPEED INDEX
LSPSPD: .BYTE 00 ;110 BAUD ^C
.BYTE LSP.IG!00 ;110 BAUD CR
.BYTE LSP.IG!00 ;110 BAUD CR
.BYTE LSP.IG!01 ;150 BAUD CR
.BYTE 01 ;150 BAUD ^C
.BYTE 02 ;300 BAUD CR
.BYTE 02 ;300 BAUD CR, ODD
.BYTE 02 ;300 BAUD ^C
.BYTE 02 ;300 BAUD ^C, ODD
.BYTE 03 ;600 BAUD CR
.BYTE 03 ;600 BAUD CR
.BYTE 04 ;1200 BAUD ^C, EVEN
.EVEN
;HIGH SPEED TABLE (NOTE THAT HSPMSK MASKS CHARACTERS BEFORE COMPARE)
HSPTAB: .BYTE 200 ;300 BAUD CR OR ^C, ODD OR EVEN
.BYTE 036 ;1200 BAUD ^C, ODD OR EVEN
.BYTE 346 ;1200 BAUD CR, ODD OR EVEN
.BYTE 006 ;1800 BAUD ^C, ODD OR EVEN
.BYTE 072 ;1800 BAUD CR, ODD OR EVEN
.BYTE 002 ;2400 BAUD ^C, EVEN
.BYTE 202 ;2400 BAUD ^C, ODD
.BYTE 214 ;2400 BAUD CR, EVEN
.BYTE 014 ;2400 BAUD CR, ODD
.BYTE 370 ;4800 BAUD ^C, ODD
.BYTE 360 ;4800 BAUD ^C, EVEN
.BYTE 374 ;4800 BAUD ^C, EVEN
.BYTE 362 ;4800 BAUD CR, ODD
.BYTE 372 ;4800 BAUD CR, EVEN
.BYTE 376 ;9600 BAUD ^C OR CR, ODD OR EVEN
HSPEND: ;END OF TABLE
;TABLE OF HIGH SPEED INDEX'S
HSPSPD: .BYTE LSP.IG!2 ;300 BAUD CR OR ^C
.BYTE 04 ;1200 BAUD ^C
.BYTE LSP.IG!04 ;1200 BAUD CR
.BYTE 05 ;1800 BAUD ^C
.BYTE 05 ;1800 BAUD CR
.BYTE 06 ;2400 BAUD ^C
.BYTE 06 ;2400 BAUD ^C
.BYTE 06 ;2400 BAUD CR
.BYTE 06 ;2400 BAUD CR
.BYTE 07 ;4800 BAUD ^C
.BYTE 07 ;4800 BAUD ^C
.BYTE 07 ;4800 BAUD ^C
.BYTE 07 ;4800 BAUD CR
.BYTE 07 ;4800 BAUD CR
.BYTE 10 ;9600 BAUD ^C, CR
.EVEN
;DH11 HARDWARE SPEEDS
SPDPAR: .WORD B.110 ;00
.WORD B.150 ;01
.WORD B.300 ;02
.WORD B.600 ;03
.WORD B.1200 ;04
.WORD B.1800 ;05
.WORD B.2400 ;06
.WORD B.4800 ;07
.WORD B.9600 ;10
.SBTTL TTY INPUT INTERRUPT SERVICE
.IF NE TTYN
ABCHAR: .WORD 0 ;STORE THE AUTOBAUD CHARACTER HERE
;HERE ON A DH11 OR DZ11 CHARACTER INTERUPT
TTDZIN:
TTDHIN:
MOV DB.LCB(J),R2 ;POINT TO LCB
BIT #LCB.IG,LC.CAR(R2) ;ARE WE IGNORING THIS LINE FOR 1 CHAR
BEQ 10$ ;NO
BIC #LCB.IG,LC.CAR(R2) ;YES, SKIP THIS CHAR AND GRAB NEXT
BR 99$
10$: CMPB #LCS.AB,LC.STA(R2) ;AUTO BAUD?
BEQ REC.AB ; YES
CMPB #LCS.RU,LC.STA(R2) ;LINE OK?
BGT LRTS ; IF IT ISN'T, PUNT THE CHAR
CMPB #LCS.RC,LC.STA(R2) ;LINE OK?
BLT LRTS ; IF IT ISN'T, PUNT THE CHAR
BIT #DHRFER,R1 ;CHECK FOR A FRAMMING ERROR
BEQ REC.00 ;BRANCH IF NORMAL CHARACTER
;HERE TO HANDLE A FRAMING ERROR - PROBABLY A BREAK
.IF NE FT2741
TST DB.BCD(J) ;CHECK TO SEE IF LINE IS 2741
BPL 20$ ;IF IT IS SPECIAL HANDLING
JMP RCVBRK ;KROQUE
20$:
.ENDC
BIT #LCB.BK,LC.CAR(R2) ;WAS LAST CHAR A BREAK?
BNE 30$ ;YES, WE HAVE GOTTEN TWO IN A ROW
BIS #LCB.BK,LC.CAR(R2) ;NO, FLAG THIS ONE
BR 99$ ;AND IGNORE IT
30$: BIT #LCB.AB,LC.CAR(R2) ;IF THIS ISN'T AN AUTO-BAUD
BEQ 99$ ;LINE, THEN DON'T RESET SPEED
MOVB #LCS.AB,LC.STA(R2) ;RESET STATE TO AUTO-BAUD
BIS #LCB.TM,LC.CAR(R2) ;GIVE HIM FOREVER TO RESPOND
BIC #LCB.LS,LC.CAR(R2) ;USE HIGH SPEED TABLE
MOV #B.HSPD,-(P) ;PUSH A SPEED OF 2400 BAUD,
JSR PC,SETSPD ;AND SET THE LINE TO IT.
TST (P)+ ;CLEAN UP THE STACK
99$: RTS PC ;AND GO HOME
REC.AB: MOVB R1,ABCHAR ;SAVE CHAR
BIT #LCB.LS,LC.CAR(R2) ;USING LOW SPEED TABLE?
BEQ 15$ ;NO, USE HIGH SPEED
CMPB #HSPCHR,R1 ;IS THIS A HIGH SPEED CHARACTER?
BEQ 60$ ;YES, SET HIGH SPEED AND TRY AGAIN
MOV #LSPTAB,R0 ;GET START OF TABLE
10$: CMP R0,#LSPEND ;AT END OF TABLE
BEQ 60$ ;BRANCH IF END OF TABLE
CMPB R1,(R0)+ ;DOES CHAR MATCH
BNE 10$ ;LOOP IF NOT
MOVB LSPSPD-LSPTAB-1(R0),R0 ;GET CHAR STATUS
BR 30$ ;GO TO COMMON CODE
15$: MOV #HSPTAB,R0 ;GET START OF TABLE
BICB #^C<HSPMSK>,R1 ;STRIP OFF UNWANTED BITS
CMPB #LSPCHR,R1 ;IS THIS A LOW SPEED CHARACTER?
BEQ 20$ ;YES, GO SEARCH LOW SPEEDS
20$: CMP R0,#HSPEND ;AT END OF TABLE
BEQ 50$ ;BRANCH IF END OF TABLE
CMPB R1,(R0)+ ;DOES CHAR MATCH
BNE 20$ ;LOOP IF NOT
MOVB HSPSPD-HSPTAB-1(R0),R0 ;GET CHAR STATUS
30$: BPL 40$ ;BRANCH IF NOT IGNORING NEXT CHAR
BIS #LCB.IG,LC.CAR(R2) ;IGNORE THE NEXT CHAR ON THIS LINE
40$: MOV R0,R2 ;MAKE COPY
BIC #^C<LSP.SP>,R2 ;GET INDEX BITS
ASL R2 ;MAKE IT A WORD
MOV SPDPAR(R2),-(P) ;GET THE DH11 SPEED BITS
JSR PC,SETSPD ;GO SET NEW SPEED
TST (P)+ ;NOW POP OFF USED SPEED BITS
MOV DB.LCB(J),R1 ;GET POINTER TO LCB
MOVB #LCS.RU,LC.STA(R1) ;GO TO RUNNING STATE
BIC #LCB.TM,LC.CAR(R1) ;STOP ANY TIMERS
BIS #DS.XDS,@J ;ALSO TELL THE -10
MOVB #1,DB.TIM(J) ;KICK THE IRMA TIMER
MOV #215,R1 ;A CR
JMP TTYINP ;LOOKS LIKE THE USER TYPED IT
50$: BIS #LCB.IG,LC.CAR(R2) ;IGNORE THE NEXT CHARACTER
MOV #B.LSPD,-(P) ;PUSH A SPEED OF 300 BAUD
BIS #LCB.LS,LC.CAR(R2) ;USE LOW SPEED TABLE
BR 70$ ;GO TO COMMON CODE
60$: MOV #B.HSPD,-(P) ;PUSH A SPEED OF 2400 BAUD,
BIC #LCB.LS,LC.CAR(R2) ;USE HIGH SPEED TABLE
70$: JSR PC,SETSPD ;AND SET THE DETECTION SPEED
TST (P)+ ;CLEAN UP THE STACK
LRTS: RTS PC ;DON'T DO ANYTHING WITH THE CHAR
REC.00:
BIC #LCB.BK,LC.CAR(R2) ;CLEAR BREAK CHAR FLAG
.IF NE FT2741
MOV DB.BCD(J),R3 ;GET 2741 STATUS BITS
BPL REC.60 ;BRANCH IF NOT 2741
BIT #BCDRCR,R3 ;TEST FOR LAST CHAR WAS A CR
BNE RCVEOT ;IF SO TREAT THIS CHAR AS AN EOT
BIC #^C77,R1 ;CLEAR PARITY BIT
CMP #<BCDEOT&77>,R1
BEQ RCVEOT
BIT #BCDKBL,R3 ;IS THE KEYBOARD LOCKED ?
BNE RCVEOA ;IS SO THIS MUST BE AN EOA
CMP #<BCDUCS&77>,R1 ;IS THIS UP SHIFT ?
BEQ BCDRUS ;BRANCH IF WE RECEIVED AN UPSHIFT
CMP #<BCDLCS&77>,R1 ;IS THIS A DOWN SHIFT ?
BEQ BCDRDS ;BRANCH IF WE RECEIVED A DOWN SHIFT
MOV R3,R2 ;MAKE ANOTHER COPY OF DB.BCD
BIC #^C<BCDCOD+BCDUPS>,R2 ;LEAVE ONLY FIELD FOR CODE & SHIFT
ADD R2,R1 ;COMBINE CODSET WITH CHARACTER
MOVB BCDXIN(R1),R1 ;TRANSLATE CHARACTER
BEQ 99$ ;IF NULL THROW CHAR AWAY
BIC #BCDRCR,R3 ;CLEAR CARRIAGE RETURN BIT
CMP #15,R1 ;KEEP TRACK OF CARRIAGE POSITION
BNE 20$
BIS #BCDRCR!BCDKBL,R3
BR 34$
20$: CMP #40,R1 ;CHECK ALL SPACING CHARS
BGT 21$ ;BR IF CONTROL CHAR (MAYBE)
CMP #174,R1
BGE 30$ ;SPACING CHARS = SPACE (40) TO VERT. BAR (174)
21$: CMP #11,R1 ;CHECK TAB
BEQ 29$ ;BR IF SO
CMP #10,R1 ;CKECK BACKSPACE
BNE 34$ ;IF NOT THEN CARRIAGE NOT AFFECTED
DECB DB.COL(J) ;BACKSPACE
BR 34$
29$: BISB #7,DB.COL(J) ;TAB TO NEXT MULTTIPLE OF 8
30$: INCB DB.COL(J) ;ADVANCE CARRIAGE POSITION
34$: BIT #BCDAPL,R3 ;TEST FOR APL MODE
BNE REC.50 ;BRANCH IF NO TRANSLATION
BIT #BCDCON,R3 ;IS THIS THE CHARACTER FOLLOWING AN ARROR ?
BEQ 40$
BIC #BCDCON,R3 ;CLEAR FOLLOWING AN ARROW BIT
CMP R1,#10 ;WAS CHAR A BACKSPACE ?
BEQ BCD.99 ;IF IT WAS JUST STORE STATUS
CMP R1,#40 ;TEST TO SEE IF CHAR MUST BE TRANSLATED
BMI REC.50 ;BRANCH IF NO TRANSLATION
MOVB ARRTAB-40(R1),R1 ;TRANSLATE AGAIN
37$:
BR REC.50
40$: CMP R1,#ARROW ;TEST FOR THIS CHAR IS AN ARROW
BNE REC.50
BIS #BCDCON,DB.BCD(J) ;SET ARROW MODE
99$: RTS PC ;AND DONE
REC.50: MOV R3,DB.BCD(J) ;RESTORE 2741 STATUS
REC.60:
.ENDC
JMP TTYINP ;PASS INPUT TO QUEUE
.IF NE FT2741
;HERE FROM REC.00 WHEN RECEIVE AN EOA
RCVEOA: BIT #BCDPRL,R3 ;IS THE PRINTER ALREADY LOCKED ?
BEQ BCD.98 ;IF NOT THIS MUST BE JUNK
CMP #BCDEOA,R1 ;IS CHARACTER AN EOA ?
BNE BCD.98 ;IF NOT IGNORE
BIC #BCDKBL!BCDUPS,R3 ;KEYBOARD UNLOCKED & LOWER SHIFT
BR BCD.99 ;RESTORE STATUS THEN DISMISS
;HERE WHEN RECEIVE AN EOT FROM A 2741 LINE
RCVEOT: ;BIT #TS.TIW,DB.DCS(J) ;WAITING FOR INPUT ?
;BEQ 10$
BIC #TS.TIW,DB.DCS(J) ;NO LONGER WAITING
BIS #DS.XDS,@J ;NEED TO SEND STATUS TO CONTROLLER
10$: BIS #BCDKBL!BCDPRL,R3 ;SET ALL LOCKED
BIT #BCDXRB,R3 ;TEST FOR WE WERE SENDING REVERSE BREAK
BNE BCD.99 ;IF WE ARE IGNORE THIS EOT
MOV #<2*400+^D10>,DB.TIM(J) ;GIVE IT A TENTH OF A SECOND TO SETTLE
BIT #BCDRCR,R3 ;CHECK FOR CR CASE
BEQ 20$
JSR PC,CRF274 ;YES, CALC. PROPER FILLER
CLRB DB.FTM+1(J) ;MAKE SURE DB.FTM FCN IS FILLER!
20$: BIC #BCDCON!BCDUPS!BCDRCR,R3 ;CLEAR UPPERSHIFT & PRINTER LOCKED
BIS #DS.ACT,@J ;WE WILL SEND A CHARACTER LATER
BIT #BCDRCR,DB.BCD(J) ;TEST AGAINST CORE COPY CUZ CLEARED R3
BNE BCD.99 ;IF FOLLOWED CR WE ARE DONE
BIT #BCDAPL,R3 ;IS LINE IN APL-MODE ?
BEQ BCD.99 ;IF NOT WE ARE DONE
MOV #BELL,R1 ;MAKE A BELL
BR REC.50 ;GIVE THAT GUY A BELL
BCDRDS: BIC #BCDUPS,R3
BR BCD.99
BCDRUS: BIS #BCDUPS,R3 ;SET UPPER SHIFT
BCD.99: MOV R3,DB.BCD(J) ;RESTORE STATUS TO 2741 TABLE
BCD.98: RTS PC
.ENDC
.ENDC
;CTY INPUT INTERRUPT
.IF NE FT.CTY
CTIINT: SAVE <J>
MOV #CTYDDB,J ;GET DEVICE BLOCK FOR CTY
SAVE <R0,R1>
TSTB CTISTS ;CHECK IT WAS DATA INTERRUPT
BGE CTIIN9 ;TRASH INTERRUPT
SPL 7 ;LOCK OUT EVERYTHING ELSE
MOV CTICHR,R1 ;GET KEYBOARD DATA & CLEAR FLAG
.IF NE FT.DDT
CMP #204,R1 ;DID I TYPE A CTRL/D?
BNE CD1 ;NOPE, IGNORE
CD: BR CTIIN9 ;PUT BREAKPOINT HERE
CD1:
.ENDC
JSR PC,TTYINP ;HAVE TTY INPUT
CTIIN9: RESTORE <R1,R0>
RESTORE <J>
RTI ;DISMISS INTERRUPT
;CTY OUTPUT INTERRUPT
CTOINT: SAVE <R0,R1,R2,R3,J>
MOV #CTYDDB,J ;LOAD DEVICE BLOCK ADDRESS
CLR CTOSTS ;DISABLE INTERRUPTS
JSR PC,XMTINT ;GO SEE WHAT WE CAN DO NEXT
RESTORE <J,R3,R2,R1,R0>
RTI
CTYTYP: MOVB R0,CTOCHR ;TYPE NEXT CHAR
MOVB #100,CTOSTS ;ENABLE INTERUPTS
RTS PC
.ENDC
;HERE TO QUEUE A CHAR TO TYPED
; CALL: LOAD J WITH TTY DEVICE BLOCK ADDRESS
; MOV <CHR>,R0
; JSR PC,QTYCHR
QTYCHR: MOV R0,R3 ;COPY BYTE
PIOFF
JSR PC,QTYCH ;QUEUE THE CHARACTER
PION
RTS PC
;SUBROUTINE TO QUEUE ESCAPE CHARACTER + FUNCTION CODE
; CALL MOV <FNC>,R0 ;PUT FUNCTION IN R0
; JSR PC,QTECHR ;ASSUMES J CONTAINS DDB ADDRESS
QTECHR: PIOFF
MOV R0,-(P) ;SAVE FUNCTION CODE
MOV #ESCF,R3 ;GET ESCAPE CHARACTER
JSR PC,QTYCH ;QUEUE IT
MOV (P)+,R3 ;RETRIEVE FUNCTION
JSR PC,QTYCH ;QUEUE IT ALSO
PION
RTS PC
QTYCH: MOV DB.TOB+2(J),R0 ;GET POINTER TO LAST DATA CHAR
BNE 14$
JSR PC,ERSGET ;TAKE FROM EMERGENCY STORE
TST (R0)+ ;SKIP LINK WORD
MOV R0,DB.TOB+2(J) ;SET LIMIT WORD
MOV R0,DB.TOB(J) ;SET 1ST BYTE POINTER
14$: ADVCNK R0 EXTEND ;ADVANCE TO NEXT CHARACTER
; ;ALLOCATING A NEW CHUNK IF REQUIRED
16$: MOVB R3,(R0)+ ;PUT BYTE INTO CHUNK
MOV R0,DB.TOB+2(J) ;RESET LIMIT BYTE POINTER
INC DB.TOC(J) ;COUNT CHAR INTO THE CHUNKS
RTS PC
;HERE TO PASS TTY INPUT CHAR TO TASK OF NCL
; CALL WITH J POINTING TO LINE BLOCK
; AND INPUT CHAR IN R1
TTYINP:
.IF NE FT.TSK
MOV DB.TSK+2(J),R0 ;GET TASK BLOCK THAT WANTS INPUT
BEQ TYPIN0
SAVE <J>
MOV R0,J
JSR PC,TSKWAK ;WAKE THE TASK
RESTORE <J>
MOV DB.KPT(J),R0 ;GET KEYBOARD PUTTER
ADD J,R0 ;MAKE ADR ABSOLUTE
MOV R1,(R0)+ ;PUT CHAR INTO BUFFER
SUB J,R0 ;MAKE ADR RELATIVE AGAIN
CMP R0,#DB.KQU+TQS+TQS ;DID WE HIT END OF QUEUE ?
BNE 20$
MOV #DB.KQU,R0 ;YES SO POINT TO START
20$: CMP R0,DB.KTK(J) ;WOULD THIS OVERTAKE TAKER ?
BEQ 90$ ;IF SO DON'T DO IT
MOV R0,DB.KPT(J) ;NO SO FREEZE IT
90$: RTS PC
.ENDC
TYPIN0: CMP #TTYMIC,DB.ICC(J) ;HOW MANY CHARS ALREADY WAITING ?
BPL 5$ ;STILL OK
JMP TYPIBF ;TELL USER THAT INPUT BUFFER IS FULL
5$: MOV R1,R0 ;COPY THE CHARACTER,
BIC #^C177,R0 ; AND CLEAR PARITY IN THE COPY
BNE 10$ ;IF NOT A NULL, GO CHECK ^S
BIT #TS.IMI,DB.DCS(J) ;IF WE ARE IN IMAGE MODE
BNE 10$ ; THEN KEEP THE NULL
RTS PC ;IF NOT IMAGE MODE, IGNORE NULLS
10$: BIT #TS.PAG,DB.DCS(J) ;ARE WE IN PAGE MODE?
BEQ 20$ ;NO, DON'T CHECK XON/XOFF
CMPB #23,R0 ;WAS THE CHAR ^S (XOFF)?
BNE 12$ ;NO, CHECK ^Q
BIS #TS.FRZ,DB.DCS(J) ;YES, STOP OUTPUT
BR 20$ ;QUEUE THE XOFF
12$: CMPB #21,R0 ;WAS THE CHAR A ^Q (XON)?
BNE 20$ ;NO, NORMAL CHAR
BIC #TS.FRZ,DB.DCS(J) ;YES, START OUTPUT
20$: QUEPUT TI ;PUT THE CHAR IN THE INPUT QUEUE
;
; Stop input from a terminal at interupt level, thereby
; avoiding any problems with loop level begin unable
; to keep up with TTY input.
;
.IF NE FT.RDA
TST DB.RDT(J) ;Is this an RDA device?
BNE 35$ ;Yes, skip this
.ENDC
BIT #DS.IST,(J) ;Have we already sent XOFF
BNE 35$ ;Yes, don't bother with another
INC DB.ICC(J) ;Count this character
CMP #TTYMIC-^D20,DB.ICC(J) ;Are we in danger of overrunning?
BHI 35$ ;No, all is well
JSR PC,SNDXOF ;Yes, ship an XOFF now
BIS #DS.IST,(J) ;Signal that we sent an XOFF
35$: RTS PC ;Let let loop worry about the char.
PARTAB: .BYTE 000,201,202,003,204,005,006,207
.BYTE 210,011,012,213,014,215,216,017
.BYTE 220,021,022,223,024,225,226,027
.BYTE 030,231,232,033,234,035,036,237
.BYTE 240,041,042,243,044,245,246,047
.BYTE 050,251,252,053,254,055,056,257
.BYTE 060,261,262,063,264,065,066,267
.BYTE 270,071,072,273,074,275,276,077
.BYTE 300,101,102,303,104,305,306,107
.BYTE 110,311,312,113,314,115,116,317
.BYTE 120,321,322,123,324,125,126,327
.BYTE 330,131,132,333,134,335,336,137
.BYTE 140,341,342,143,344,145,146,347
.BYTE 350,151,152,353,154,355,356,157
.BYTE 360,161,162,363,164,365,366,167
.BYTE 170,371,372,173,374,175,176,377
; HERE TO SET LINE SPEED
.IF NE TTYN
; CALL: JSR PC,SETSPD ; WITH J SETUP
; RETURN ; USES R0 & R1
SETSPD:
SAVE <R2,R3>
.IF NE FT.CTY
CMP J,#CTYDDB ; IS THIS FOR THE CTY ?
BEQ 99$ ; CAUSE CTY NOT DH11
.ENDC
BIS #DS.XCH,@J ; SO WE SEND CHARACTERISTICS TO 10
MOV @DB.DHB(J),R0 ; GET DH11 HDW ADDRESS
MOV 6(P),R1 ; GET NEW LINE SPEED
.IIF NE FT2741,PIOFF
MOVB DB..LN(J),R2 ; FETCH THE DH11 LINE #
JINDEX JSR,DB.TYP(J),R3,DEVSPD
BCS 98$ ; CARRY SET IS ERROR
MOV DB.LCB(J),R2 ; SUCCESS, GET ADDRESS OF LCB
MOV R1,LC.SPD(R2) ; AND PUT NEW ACTUAL SPEED IN LCB
98$:
.IF NE FT2741
BIC #BCDB27,DB.BCD(J) ; CLEAR 2741 BITS
CMP #B.134,LC.SPD(R2) ; IS IT A 2741
BNE 20$ ; IF NOT, NOTHING SPECIAL
BIS #BCD274!BCDVRG,DB.BCD(J); VIRGIN 2741
BR 21$ ; AND EXIT
20$: CLR DB.BCD(J) ; NO LONGER 2741
21$: PION
.ENDC
99$: RESTORE <R3,R2>
RTS PC
.IFF
SETSPD: RTS PC
.ENDC
.ENDC