mirror of
https://github.com/PDP-10/its.git
synced 2026-01-28 12:59:20 +00:00
Added SRCCOM program and documentation.
SRCCOM is a source/binary comparison program. SRCCOM also support source merges.
This commit is contained in:
Eric Swenson
committed by
Lars Brinkhoff
Lars Brinkhoff
parent
f97c1e6ae8
commit
7ed0d1d8ce
787
src/syseng/rubout.3
Normal file
787
src/syseng/rubout.3
Normal file
@@ -0,0 +1,787 @@
|
||||
|
||||
.BEGIN RUBOUT ;Rubout processor routine for -*-MIDAS-*- programs.
|
||||
|
||||
.AUXIL ;Don't mention all my symbols in crefs of programs that use me.
|
||||
|
||||
;PRINT VERSION NUMBER
|
||||
.TYO6 .IFNM1
|
||||
.TYO 40
|
||||
.TYO6 .IFNM2
|
||||
PRINTX/ INCLUDED IN THIS ASSEMBLY.
|
||||
/
|
||||
|
||||
;The main entry points of the RUBOUT package are INIT and READ.
|
||||
;Each time you want to start reading one object, you should call INIT.
|
||||
;After that, you call READ one or more times until you have enough
|
||||
;input to act on. When you wish to start reading a "new" object -- and not
|
||||
;allow the old one to be rubbed out any longer -- call INIT again.
|
||||
|
||||
;There are also subsidiary entry points called character service routines.
|
||||
;These handle the display updating for one input character. The
|
||||
;rubout-processing significance of all characters is determined by
|
||||
;a routine which you supply, called DISPATCH, which examines the
|
||||
;character and goes to the appropriate service routines.
|
||||
;We supply a default definition of DISPATCH for you to use as
|
||||
;all or part of your dispatch routine, and also as a guide to what
|
||||
;dispatch routines should do.
|
||||
|
||||
|
||||
;Calling Conventions:
|
||||
|
||||
;All subroutines herein are called by PUSHJ P,. They normally do NOT skip-return.
|
||||
;Character service routines skip, with a return code in A,
|
||||
;to tell READ to return with that code.
|
||||
|
||||
;Arguments are passed in ACs A,B,C and D. D must be C+1.
|
||||
;Subroutines may alter A-D as documented with each routine.
|
||||
|
||||
|
||||
;These switches may be set by the caller to request optional features.
|
||||
;They may be defined local to the block RUBOUT.
|
||||
|
||||
IFNDEF $$MULTI,$$MULTI==0 ;Be efficient for CRs, BSs and TABs in the text.
|
||||
;$$MULTI==1 makes the code larger but makes
|
||||
;rubbing out these characters do less display.
|
||||
IFNDEF $$FCI,$$FCI==1 ;Handle full char set input
|
||||
;(distinguish Alpha from C-B).
|
||||
;$$FCI==1 works for ASCII input streams too.
|
||||
IFNDEF $$PROMPT,$$PROMPT==0 ;1 => call PROMPT to type a prompt string when needed.
|
||||
IFNDEF $$HELP,$$HELP==0 ;1 => call HELP when the user types Top-H.
|
||||
IFNDEF $$CTLBRK,$$CTLBRK==0 ;1 => the default dispatch routine
|
||||
;makes all random control characters break.
|
||||
IFNDEF $$CTLECH,$$CTLECH==1 ;1 => control chars that perform editing functions
|
||||
;also echo, and must be erased. Doesn't include Rubout.
|
||||
IFNDEF $$BRKINS,$$BRKINS==1 ;1 => break characters insert themselves first,
|
||||
;in the default dispatch routine.
|
||||
IFNDEF $$FFCLR,$$FFCLR==1 ;1 => ^L echoes as clear screen.
|
||||
;0 => it echoes as uparrow-L, and we re-use the same lines.
|
||||
|
||||
;These exits must be defined by the user. They may be defined local
|
||||
;to the block RUBOUT:
|
||||
|
||||
;INCHR reads a character, returning it in A.
|
||||
;OUTCHR outputs the character in A. --MORE-- should, for
|
||||
; most applications, be inhibited
|
||||
; by having %TJMOR set in the channel used for output,
|
||||
; if it is a terminal. If you want to do --MORE--,
|
||||
; you should make sure that when the --MORE-- is proceeded
|
||||
; its line is re-used so that the screen is as if
|
||||
; the --MORE-- had never been.
|
||||
;DISPLAY outputs the character in A in display mode (%TJDIS).
|
||||
; It can be any stream that knows the meaning of ^P.
|
||||
; If outputting to a terminal, set %TJMOR.
|
||||
;PROMPT types a prompt-string. Called at appropriate times.
|
||||
; Needed only if $$PROMPT==1. Not called when READ is
|
||||
; entered; if you want that, do it yourself.
|
||||
;HELP types a help-string when the user typed Top-H.
|
||||
; Needed only if $$HELP==1. On displays,
|
||||
; HELP may wish to wait for input to be available
|
||||
; and then jump to REDISP without reading it.
|
||||
;DISPATCH takes a character in A, and jumps off to the service
|
||||
; routine for it, which may be one of those provided
|
||||
; by RUBOUT (such as RUBOUT, INSERT, BREAK, etc.).
|
||||
; A sample dispatch routine is called RB$DSP.
|
||||
; You can use it, if it is right, by doing
|
||||
; RUBOUT"DISPATCH==RUBOUT"RB$DSP
|
||||
; after the .INSRT SYSENG;RUBOUT, or your dispatch
|
||||
; can jump off to it, after handling a few cases specially.
|
||||
|
||||
;Service routines provided in this file include
|
||||
;INSERT, BREAK, BRKCR, BRKINS, INSCR, QUOTE, QUIT, CANCEL, RUBOUT,
|
||||
;IGNORE, REDISP, CLRLIN, CTLU.
|
||||
|
||||
|
||||
;Each call to the rubout processor must give the address of an argument
|
||||
;block, called the rubout processor block, in B.
|
||||
;This block enables you to carry on several transactions with
|
||||
;RUBOUT at the same time (or one inside another). If you wish,
|
||||
;you can make your DISPATCH, OUTCHR, etc. entries jump through
|
||||
;extra words at the end of the rubout processor block (words which
|
||||
;normally are not used), and thus have different routines for
|
||||
;each transaction.
|
||||
|
||||
;These are the words in the rubout processor argument block
|
||||
;that are used by this package:
|
||||
|
||||
RB.==777777 ;Bit typeout mode prefix.
|
||||
RB.POS==0 ;Vpos,,Hpos of 1st character in buffer.
|
||||
RB.WID==1 ;Width of line on terminal.
|
||||
RB.TYP==2 ;TTY characteristics.
|
||||
;positive => printing terminal.
|
||||
RB%FIL==2 ; bit 3.2 => not even that, just reading from a file.
|
||||
;0 => glass teletype (character erase only, no move up).
|
||||
;negative => full display.
|
||||
RB%CID==1 ; bit 3.1 => can insert/delete as well.
|
||||
RB%SAI==2 ; BIT 3.2 => SAIL mode on, ctl chars echo as one pos.
|
||||
RB.BEG==3 ;B.P. to ILDB start of buffer.
|
||||
RB.END==4 ;B.P. to ILDB 1st character after end buffer.
|
||||
;Actually, you should leave space for two characters
|
||||
;to be stored past RB.END.
|
||||
RB.PTR==5 ;B.P. for storing into buffer.
|
||||
RB.PRS==6 ;B.P. to last character parsed at next level up.
|
||||
RB.STAT==7 ;Word of flags indicating temporary state of editing
|
||||
|
||||
RB.LEN==10 ;Number of words in the rubout block
|
||||
|
||||
;The caller should set up RB.BEG and RB.END, then call INIT which will
|
||||
;initialize RB.TYP, RB.WID, and RB.POS and RB.PTR.
|
||||
|
||||
;The use of RB.PRS:
|
||||
;Complicated break-conditions do not need to be expressed in the DISPATCH routine.
|
||||
;If you use $$BRKINS==1 (Insert break characters in the buffer), then
|
||||
;if the higher level parser decides it needs more characters it can just call
|
||||
;READ again to get more. It could then re-parse the whole input string.
|
||||
;To save time, it can put in RB.PRS the pointer to the last character that
|
||||
;it actually parsed. On return from READ, if RB.PRS is unchanged, all
|
||||
;characters up to that point were not changed (ie, not rubbed out)
|
||||
;and the parser can continue from where it left off.
|
||||
;Otherwise, RB.PRS will be zero, to indicate that the parser must
|
||||
;rescan the entire string as returned by READ.
|
||||
;If you like, you can keep the parser's fetch-pointer in RB.PRS,
|
||||
;calling READ when it reaches RB.PTR, and noticing when it is zeroed.
|
||||
|
||||
DEFINE SYSCAL NAME,ARGS
|
||||
.CALL [SETZ ? SIXBIT/NAME/ ? ARGS ((SETZ))]
|
||||
TERMIN
|
||||
|
||||
;Get a character's graphic type. Takes character in A, returns type in A.
|
||||
|
||||
;Type codes are:
|
||||
;0 - 1-POSITION CHARACTER.
|
||||
;1 - ORDINARY CTL CHAR - USUALLY 2-POSITION, BUT 1-POSITION IN SAIL MODE.
|
||||
;2 - BACKSPACE.
|
||||
;3 - CR
|
||||
;4 - LF
|
||||
;5 - TAB.
|
||||
;6 - SPECIAL CTL CHARACTER - 2-POSITION EVEN IN SAIL MODE.
|
||||
;7 - ^G
|
||||
|
||||
CHRTYP:
|
||||
IFN $$FCI,[
|
||||
PUSH P,C ;If storing 9-bit bytes in the buffer,
|
||||
LDB C,[300600,,RB.PTR(B)]
|
||||
CAIN C,7
|
||||
JRST CHRTY1
|
||||
CAIGE A,177 ;assume that anything
|
||||
JRST [ SETZ A, ;below 177 is either an ASCII graphic or a SAIL graphic.
|
||||
JRST POPCJ]
|
||||
CHRTY1: PUSHJ P,CHRASC ;Other things were echoed by converting them to ASCII.
|
||||
POP P,C
|
||||
];IFN $$FCI
|
||||
CAIN A,177
|
||||
JRST [ MOVEI A,6 ;Assume rubout is a 2-position character,
|
||||
POPJ P,] ;even though we shouldn't be echoing them.
|
||||
PUSH P,C
|
||||
PUSH P,D
|
||||
MOVE C,A
|
||||
IDIVI C,6
|
||||
CAIL A,40
|
||||
TDZA A,A
|
||||
LDB A,RRCHBP(D)
|
||||
JRST POPDCJ
|
||||
|
||||
;TABLES USED BY CHRTYP THE ENTRY FOR EACH
|
||||
;CHARACTER IS AN INDEX INTO RRFORT OR RRBACT.
|
||||
|
||||
RRCHBP: REPEAT 6,<360600-<6*.RPCNT>_12.>,,RRCHTB(C)
|
||||
|
||||
RRCHTB: .BYTE 6
|
||||
6 ;^@
|
||||
1 ;^A
|
||||
1 ;^B
|
||||
1 ;^C
|
||||
1 ;^D
|
||||
1 ;^E
|
||||
1 ;^F
|
||||
7 ;^G
|
||||
2 ;^H
|
||||
5 ;^I
|
||||
4 ;^J
|
||||
1 ;^K
|
||||
1 ;^L
|
||||
3 ;^M
|
||||
1 ;^N
|
||||
1 ;^O
|
||||
1 ;^P
|
||||
1 ;^Q
|
||||
1 ;^R
|
||||
1 ;^S
|
||||
1 ;^T
|
||||
1 ;^U
|
||||
1 ;^V
|
||||
1 ;^W
|
||||
1 ;^X
|
||||
1 ;^Y
|
||||
1 ;^Z
|
||||
0 ;ALTMODE, 1 POSITION.
|
||||
1 ;^^
|
||||
1 ;[ ;^]
|
||||
1 ;^\
|
||||
1 ;^_
|
||||
.BYTE
|
||||
|
||||
;INIT empties the buffer and also tells RUBOUT about
|
||||
;the characteristics of the output stream used
|
||||
;for echoing of output during rubout processing.
|
||||
;If it is a terminal, the capabilities of it are also remembered for use
|
||||
;in chosing display strategies. If it is not a terminal, or if -1 is
|
||||
;passed as the channel number, we assume that no echoing of input or rubbed
|
||||
;out characters is desired.
|
||||
|
||||
;INIT takes the output channel in A and the rubout processing block address in B.
|
||||
;It sets RB.TYP, RB.WID and RB.POS. It also initializes the buffer to be empty.
|
||||
|
||||
INIT: PUSHJ P,INITB
|
||||
|
||||
;Learn about a new output source, without marking the buffer empty.
|
||||
INITO: PUSH P,C
|
||||
PUSH P,D
|
||||
SYSCAL CNSGET,[A ? MOVEM D ? MOVEM RB.WID(B) ;Read tty width into RB.WID.
|
||||
REPEAT 3,[ ? MOVEM D]] ;Read TTYOPT of TTY into D.
|
||||
JRST INIT1 ;Jump if not really a TTY.
|
||||
SETZ C, ;First assume it's a glass TTY.
|
||||
TLNN D,%TOMVU
|
||||
TLNE D,%TOOVR ;If it isn't one, try a printing TTY.
|
||||
MOVSI C,200000 ;RB.TYP should be positive.
|
||||
TLNE D,%TOERS
|
||||
MOVSI C,600000 ;For erasable display, it should be negative.
|
||||
TLNE D,%TOCID
|
||||
TLO C,RB%CID ;If we can insert/delete chars, remember that.
|
||||
MOVEM C,RB.TYP(B)
|
||||
SYSCAL RCPOS,[A ? MOVEM RB.POS(B)]
|
||||
.LOSE %LSFIL
|
||||
POPDCJ: POP P,D
|
||||
POPCJ: POP P,C
|
||||
CPOPJ: POPJ P,
|
||||
|
||||
INIT1: MOVSI C,200000+RB%FIL
|
||||
MOVEM C,RB.TYP(B)
|
||||
JRST POPDCJ
|
||||
|
||||
;Set up to do some rubout processing. Takes the Rubout processing block addr in B
|
||||
;and marks the buffer empty.
|
||||
INITB: PUSH P,C
|
||||
MOVE C,RB.BEG(B)
|
||||
MOVEM C,RB.PTR(B)
|
||||
JRST POPCJ
|
||||
|
||||
IFN $$FCI,[
|
||||
;Normalize a 9-bit character so we can do comparisons on it.
|
||||
CHRNRM: ;ANDCMI A,%TXSFT+%TXSFL
|
||||
TRNE A,%TXCTL+%TXMTA ;Convert lower case controls/metas to upper case,
|
||||
TRNN A,100
|
||||
JRST CHRNR1
|
||||
TRC A,177
|
||||
TRCN A,177 ;but don't turn Control-Rubout into Control-_.
|
||||
TRZ A,40
|
||||
CHRNR1: TRNE A,%TXTOP+%TXCTL+140 ;ASCII control chars must be turned into %TXCTL+char.
|
||||
POPJ P,
|
||||
CAIE A,33 ;except for altmode.
|
||||
ADDI A,%TXCTL+100
|
||||
POPJ P,
|
||||
|
||||
;Convert a 9-bit character in A to ASCII, if necessary for insertion in the buffer
|
||||
;(that is, if the buffer is 7-bit).
|
||||
CHRASI: PUSH P,C
|
||||
LDB C,[300600,,RB.PTR(B)]
|
||||
CAIE C,7
|
||||
JRST POPCJ
|
||||
POP P,C
|
||||
;Convert a 9-bit character in A to ASCII.
|
||||
CHRASC: ANDI A,%TXCTL+%TXASC
|
||||
TRZN A,%TXCTL
|
||||
POPJ P,
|
||||
CAIN A,177
|
||||
POPJ P,
|
||||
CAIE A,40
|
||||
CAIL A,140
|
||||
SUBI A,40
|
||||
ANDCMI A,100
|
||||
POPJ P,
|
||||
];IFN $$FCI
|
||||
|
||||
SUBTTL Main rubout processing routine
|
||||
|
||||
;The main function of the rubout package is READ.
|
||||
;It takes the pointer to a rubout processor argument block in B.
|
||||
;It reads characters and processes them until either a break character
|
||||
;is read, the buffer becomes full, or an attempt is made to rub out
|
||||
;past the beginning of the buffer.
|
||||
;On return, A contains -1 if the buffer is full; -2, in case of
|
||||
;over-rubout; otherwise, it contains the break character that caused
|
||||
;the exit. No other accumulator is clobbered.
|
||||
|
||||
READ: PUSH P,C
|
||||
PUSH P,D
|
||||
RBLOOP: PUSHJ P,INCHR ;Read next character into A.
|
||||
SKIPLE RB.TYP(B) ;After a CR coming form a file, flush the LF.
|
||||
CAIE A,^M
|
||||
JRST RBLOO2
|
||||
PUSHJ P,INCHR
|
||||
MOVEI A,^M
|
||||
RBLOO2:
|
||||
IFN $$HELP,[
|
||||
CAIN A,%TXTOP+"H ;If user supplied a HELP routine, call it for Top-H.
|
||||
JRST [ PUSHJ P,HELP ;Must check for Top-H before the CHRNRM, which makes it H.
|
||||
JRST RBLOOP]
|
||||
];IFN $$HELP
|
||||
IFN $$FCI,PUSHJ P,CHRNRM
|
||||
PUSHJ P,DISPATCH ;Let user decide what to do with the character.
|
||||
JRST RBLOO1
|
||||
JRST POPDCJ ;His routine skips => it wants to exit.
|
||||
;It should have put the return code in A.
|
||||
|
||||
RBLOO1: MOVE C,RB.PTR(B) ;User didn't ask to return,
|
||||
CAME C,RB.END(B) ;but return anyway if the buffer has become full.
|
||||
JRST RBLOOP
|
||||
MOVNI A,1
|
||||
JRST POPDCJ
|
||||
|
||||
IFE $$FCI,[
|
||||
;Here is the default RB.DSP character dispatch routine which we provide.
|
||||
RB$DSP: CAIN A,177
|
||||
JRST RUBOUT
|
||||
CAIN A,^U
|
||||
JRST CTLU
|
||||
CAIN A,^D
|
||||
JRST CANCEL
|
||||
CAIN A,^G
|
||||
JRST QUIT
|
||||
CAIN A,^M
|
||||
IFN $$BRKINS, JRST BRKCR
|
||||
IFE $$BRKINS, JRST BREAK
|
||||
CAIE A,^_
|
||||
CAIN A,^C
|
||||
IFN $$BRKINS, JRST BRKINS
|
||||
IFE $$BRKINS, JRST BREAK
|
||||
CAIN A,^Q
|
||||
JRST QUOTE
|
||||
CAIN A,^L
|
||||
JRST REDISP
|
||||
IFN $$CTLBRK,[
|
||||
CAIGE A,40
|
||||
IFN $$BRKINS, JRST BRKINS
|
||||
IFE $$BRKINS, JRST BREAK
|
||||
]
|
||||
JRST INSECH
|
||||
];IFE $$FCI
|
||||
|
||||
IFN $$FCI,[
|
||||
;Default dispatch for 9-bit characters.
|
||||
RB$DSP: CAIN A,177
|
||||
JRST RUBOUT
|
||||
CAIN A,%TXCTL+"U
|
||||
JRST CTLU
|
||||
CAIN A,%TXCTL+"D
|
||||
JRST CANCEL
|
||||
CAIN A,%TXCTL+"G
|
||||
JRST QUIT
|
||||
CAIN A,%TXCTL+"M
|
||||
IFN $$BRKINS, JRST BRKCR
|
||||
IFE $$BRKINS, JRST BREAK
|
||||
CAIE A,%TXCTL+"_
|
||||
CAIN A,%TXCTL+"C
|
||||
IFN $$BRKINS, JRST BRKINS
|
||||
IFE $$BRKINS, JRST BREAK
|
||||
CAIN A,%TXCTL+"Q
|
||||
JRST QUOTE
|
||||
CAIN A,%TXCTL+"L
|
||||
JRST REDISP
|
||||
IFN $$CTLBRK,[
|
||||
TRNE A,%TXCTL+%TXMTA
|
||||
IFN $$BRKINS, JRST BRKINS
|
||||
IFE $$BRKINS, JRST BREAK
|
||||
]
|
||||
JRST INSECH
|
||||
];IFN $$FCI
|
||||
|
||||
SUBTTL Various action routines for input characters.
|
||||
|
||||
;Dispatch here for a character that quotes the next one (eg, ^Q).
|
||||
;The quoting character goes in the buffer so that it can quote
|
||||
;the next character at the next level of parsing.
|
||||
QUOTE:
|
||||
IFE $$CTLECH,PUSHJ P,OUTECH
|
||||
IFN $$FCI,PUSHJ P,CHRASI
|
||||
IDPB A,RB.PTR(B) ;Store the ^Q.
|
||||
PUSHJ P,INCHR ;Read the quoted character.
|
||||
|
||||
;Insert a character, echoing it if it was a non-echoed control-character.
|
||||
INSECH: CAIE A,177
|
||||
IFN $$CTLECH,CAIA
|
||||
.ELSE [
|
||||
IFN $$FCI, TRNE A,%TXCTL
|
||||
.ELSE CAIGE A,40
|
||||
]
|
||||
PUSHJ P,OUTECH
|
||||
JRST INSERT
|
||||
|
||||
;Insert char followed by a LF. For CR, when it isn't a break.
|
||||
INSCR: MOVEI A,^M
|
||||
IDPB A,RB.PTR(B)
|
||||
MOVEI A,^J
|
||||
MOVE C,RB.END(B) ;Note that the buffer may become full
|
||||
CAMN C,RB.PTR(B) ;after just the CR.
|
||||
JRST [ MOVEI B,1
|
||||
AOS (P)
|
||||
POPJ P,]
|
||||
|
||||
;Dispatch here for an ordinary character, that should just be inserted,
|
||||
;and has already been echoed.
|
||||
INSERT:
|
||||
IFN $$FCI,PUSHJ P,CHRASI ;If char is 9-bit and buffer is 7-bit, convert.
|
||||
IDPB A,RB.PTR(B)
|
||||
POPJ P,
|
||||
|
||||
;Insert char and a LF, then break.
|
||||
BRKCR: PUSH P,A
|
||||
MOVEI A,^M
|
||||
IDPB A,RB.PTR(B)
|
||||
MOVEI A,^J
|
||||
IDPB A,RB.PTR(B)
|
||||
POP P,A
|
||||
JRST BREAK
|
||||
|
||||
;Dispatch here for a break character. We store it and a null,
|
||||
;then signal READ to return the break character.
|
||||
;If the character is a control char which didn't echo, we echo it.
|
||||
BRKINS: PUSH P,A
|
||||
PUSHJ P,INSECH ;Insert, maybe echoing or converting 9-bit to 7-bit.
|
||||
POP P,A
|
||||
|
||||
;Dispatch here for a break character that should not be stored
|
||||
;in the buffer.
|
||||
BREAK: SETZ C, ;Store a 0 to make it ASCIZ,
|
||||
MOVE D,RB.PTR(B) ;but don't make RB.PTR point after it.
|
||||
IDPB C,D
|
||||
AOS (P)
|
||||
POPJ P,
|
||||
|
||||
;Here to "quit". Acts like too many rubouts, flushing any amount of input.
|
||||
QUIT: MOVE C,RB.BEG(B) ;Mark the buffer empty.
|
||||
MOVEM C,RB.PTR(B)
|
||||
SETZM RB.PRS(B) ;Tell user his old parsing work is no use.
|
||||
MOVNI A,2 ;Make READ return -2.
|
||||
AOS (P)
|
||||
POPJ P,
|
||||
|
||||
;Empty the entire buffer. The same as exactly enough rubouts
|
||||
;but types out differently.
|
||||
CANCEL: SETZM RB.PRS(B) ;Tell user his old parsing is no longer any use.
|
||||
SKIPGE D,RB.TYP(B) ;On a display, clear the display window first,
|
||||
JRST CANCE1 ;while we can still tell how long it is.
|
||||
MOVE C,RB.BEG(B) ;Empty the buffer.
|
||||
MOVEM C,RB.PTR(B)
|
||||
TLNE D,RB%FIL
|
||||
POPJ P, ;If reading from file, don't type anything.
|
||||
MOVEI A,40 ;Printing terminal, type "XXX?" and CRLF.
|
||||
PUSHJ P,OUTCHR
|
||||
MOVEI A,"X
|
||||
PUSHJ P,OUTCHR
|
||||
PUSHJ P,OUTCHR
|
||||
PUSHJ P,OUTCHR
|
||||
MOVEI A,"?
|
||||
PUSHJ P,OUTCHR
|
||||
JRST WCLEAR ;CRLF, and prompt if appropriate.
|
||||
|
||||
CANCE1: PUSHJ P,WCLEAR ;Clear out the display window.
|
||||
MOVE C,RB.BEG(B) ;Empty the buffer.
|
||||
MOVEM C,RB.PTR(B)
|
||||
POPJ P,
|
||||
|
||||
CTLU:
|
||||
IFN $$CTLECH,PUSHJ P,IGNORE ; If the ^U echoed, must erase it too.
|
||||
;Delete one line backwards. Deletes at least one character.
|
||||
CLRLIN: PUSHJ P,RUBOUT ; DELETE AT LEAST ONE CHAR, STOPPING ONLY AT LINE BEG.
|
||||
CAIA
|
||||
JRST POPJ1 ; Beginning of buffer => propagate the skip.
|
||||
MOVE C,RB.PTR(B)
|
||||
CAMN C,RB.BEG(B) ; Else stop rubbing if now at start of line.
|
||||
POPJ P,
|
||||
LDB A,C
|
||||
CAIE A,^J
|
||||
JRST CLRLIN
|
||||
POPJ P,
|
||||
|
||||
;Dispatch here to ignore a character. On a display, erase it if it echoed.
|
||||
IGNORE:
|
||||
IFE $$CTLECH,[
|
||||
IFE $$FCI,CAIGE A,40
|
||||
IFN $$FCI,TRNE A,%TXCTL
|
||||
POPJ P,
|
||||
]
|
||||
SKIPL RB.TYP(B)
|
||||
POPJ P,
|
||||
JRST RUBOU1
|
||||
|
||||
SUBTTL Various display operations
|
||||
|
||||
;Here to retype the entire contents of the buffer.
|
||||
REDISP:
|
||||
IFN $$FFCLR,IFN $$PROMPT, PUSHJ P,PROMPT ;If ^L clears the screen, just re-prompt.
|
||||
IFE $$FFCLR,PUSHJ P,WCLEAR ;Else, erase all the lines that are in use
|
||||
;and put cursor after the previous prompt.
|
||||
MOVE C,RB.BEG(B)
|
||||
REDIS1: CAMN C,RB.PTR(B)
|
||||
POPJ P,
|
||||
ILDB A,C
|
||||
PUSHJ P,OUTECH
|
||||
JRST REDIS1
|
||||
|
||||
;Clear the display window. On printing terminal, just CRLF and prompt.
|
||||
WCLEAR: SKIPL RB.TYP(B)
|
||||
JRST [ PUSHJ P,CRLF
|
||||
IFN $$PROMPT, PUSHJ P,PROMPT
|
||||
POPJ P,]
|
||||
;Here for clearing buffer on a display.
|
||||
IFN $$MULTI,[
|
||||
PUSHJ P,RESYNCH ;Compute vpos,,hpos of end of buffer in D.
|
||||
PUSH P,D
|
||||
PUSHJ P,CRSHOME ;Move cursor to beginning of rubout processor area.
|
||||
MOVEI A,"L
|
||||
PUSHJ P,DISP2 ;Clear rest of that line.
|
||||
HLRZS (P)
|
||||
POP P,D ;Then CRLF down thru the lines that were occupied.
|
||||
HLRZ C,RB.POS(B)
|
||||
CAMN C,D
|
||||
POPJ P,
|
||||
WCLEA1: CAMN C,D
|
||||
JRST CRSHOM ;Then move cursor to beginning of area again.
|
||||
MOVEI A,"D
|
||||
PUSHJ P,DISP2 ;Move down one line
|
||||
MOVEI A,"L
|
||||
PUSHJ P,DISP2 ;and clear the one we get to.
|
||||
AOJA C,WCLEA1
|
||||
];IFN $$MULTI
|
||||
.ELSE [
|
||||
PUSHJ P,CRSHOME ;Move cursor to beginning of rubout processor area.
|
||||
MOVEI A,"L
|
||||
JRST DISP2 ;Clear rest of that line.
|
||||
];IFN $$MULTI
|
||||
|
||||
;On a display only, move the cursor to the beginning of the window area.
|
||||
CRSHOM: MOVEI A,"V
|
||||
PUSHJ P,DISP2
|
||||
HLRZ A,RB.POS(B)
|
||||
ADDI A,10
|
||||
PUSHJ P,DISPLAY
|
||||
MOVEI A,"H
|
||||
PUSHJ P,DISP2
|
||||
HRRZ A,RB.POS(B)
|
||||
ADDI A,10
|
||||
PUSHJ P,DISPLAY
|
||||
POPJ P,
|
||||
|
||||
;Output a ^P followed by the character in A, using DISPLAY supplied by user.
|
||||
DISP2:
|
||||
PUSH P,A
|
||||
MOVEI A,^P
|
||||
PUSHJ P,DISPLAY
|
||||
POP P,A
|
||||
PUSHJ P,DISPLAY
|
||||
POPJ P,
|
||||
|
||||
;Output the character in A as it should be echoed, preserving A.
|
||||
OUTECH: PUSH P,A
|
||||
PUSHJ P,OUTEC1
|
||||
POP P,A
|
||||
POPJ P,
|
||||
|
||||
OUTEC1: CAIGE A,177
|
||||
JRST OUTPUT
|
||||
IFN $$FCI,PUSHJ P,CHRASC
|
||||
CAIN A,177
|
||||
JRST OUTRUB
|
||||
CAIN A,^M
|
||||
JRST CRLF
|
||||
JRST OUTPUT
|
||||
|
||||
OUTRUB: MOVEI A,"^
|
||||
PUSHJ P,OUTPUT
|
||||
MOVEI A,"?
|
||||
JRST OUTPUT
|
||||
|
||||
;Type a CRLF via the output 1 character instruction.
|
||||
CRLF: MOVEI A,^M
|
||||
PUSHJ P,OUTCHR
|
||||
MOVEI A,^J
|
||||
PUSHJ P,OUTCHR
|
||||
POPJ P,
|
||||
|
||||
SUBTTL The operation of rubbing out one character
|
||||
|
||||
;This is the character action routine for Rubout, which we assume
|
||||
;was not echoed.
|
||||
RUBOUT: PUSHJ P,DBPPTR ;Back up RB.PTR one byte.
|
||||
JRST QUIT ;It was at beginning => return -2 ("overrrubout") from READ.
|
||||
MOVE A,C
|
||||
ILDB A,A ;What character are we rubbing out?
|
||||
LDB D,C
|
||||
CAIN A,^J ;If rubbing out a ^J which follows a ^M,
|
||||
CAIE D,^M
|
||||
JRST RUBOU3
|
||||
CAMN C,RB.BEG(B)
|
||||
JRST RUBOU3
|
||||
SKIPG RB.TYP(B) ;Rub out the ^M too.
|
||||
JRST RUBOU4 ;On display, just call rubout again after this call is done.
|
||||
PUSHJ P,DBPPTR ;On printing TTY, type a CRLF and flush both characters.
|
||||
JRST CRLF
|
||||
|
||||
RUBOU4: PUSH P,[RUBOUT]
|
||||
RUBOU3: SKIPLE RB.TYP(B) ;Printing terminal?
|
||||
OUTPUT: JRST OUTCHR ;on printing terminal, just echo the character.
|
||||
|
||||
;Here to rub the character in A out on a display screen.
|
||||
RUBOU1: PUSHJ P,CHRTYP
|
||||
XCT RUBTAB(A)
|
||||
RUBOU2: MOVEI A,"X
|
||||
JRST DISP2
|
||||
|
||||
RUBTAB: JFCL ;Normal character; fall through to RUBOU2 and send ^PX.
|
||||
JRST RUBCTL ;Control char may be one position or two.
|
||||
JRST RUBBS ;Backspace rubs out by moving forward.
|
||||
JRST RUBCR ;CR rubs out requiring redisplay.
|
||||
JRST RUBLF ;LF is simple, but maybe also rub preceding CR
|
||||
JRST RUBHT ;Tab is hard to rub out.
|
||||
PUSHJ P,RUBOU2 ;Rubout and ^@ take two positions always.
|
||||
JRST OUTPUT ;^G takes no positions; echo it to rub it out.
|
||||
|
||||
RUBCTL: MOVSI D,RB%SAI ;Control chars are one pos or two according to sail mode.
|
||||
TDNN D,RB.TYP(B)
|
||||
PUSHJ P,RUBOU2
|
||||
JRST RUBOU2
|
||||
|
||||
RUBBS: RUBCR: RUBHT:
|
||||
IFN $$MULTI,[
|
||||
PUSHJ P,RESYNCH ;Compute current vpos,,hpos in D.
|
||||
MOVEI A,"H
|
||||
PUSHJ P,DISP2 ;Move cursor to that position.
|
||||
MOVEI A,10(D)
|
||||
PUSHJ P,DISPLAY
|
||||
POPJ P,
|
||||
]
|
||||
.ELSE JRST REDISP
|
||||
|
||||
RUBLF: MOVEI A,"U ;Rubbing out LF: move up one line.
|
||||
JRST DISP2
|
||||
|
||||
;Decrement RB.PTR by one byte, updating RB.PRS as necessary.
|
||||
;Skips unless RB.PTR was pointing at the beginning of the buffer,
|
||||
;in which case it was not changed. RB.PTR is left in C, either way.
|
||||
DBPPTR: MOVE C,RB.PTR(B)
|
||||
CAMN C,RB.BEG(B)
|
||||
POPJ P,
|
||||
CAMN C,RB.PRS(B)
|
||||
SETZM RB.PRS(B)
|
||||
PUSHJ P,DBPC
|
||||
MOVEM C,RB.PTR(B)
|
||||
POPJ1: AOS (P)
|
||||
POPJ P,
|
||||
|
||||
;Decrement the byte pointer in C. If $$FCI, we handle 7-bit and 9-bit byte pointers.
|
||||
;Otherwise, we handle only 7-bit byte pointers.
|
||||
DBPC:
|
||||
IFN $$FCI,[
|
||||
LDB D,[300600,,C]
|
||||
CAIE D,7
|
||||
JRST DBP9
|
||||
]
|
||||
ADD C,[070000,,]
|
||||
SKIPGE C
|
||||
SUB C,[430000,,1] ;Decrement byte pointer.
|
||||
POPJ P,
|
||||
|
||||
IFN $$FCI,[
|
||||
DBP9: ADD C,[110000,,]
|
||||
SKIPGE C
|
||||
SUB C,[440000,,1]
|
||||
POPJ P,
|
||||
]
|
||||
|
||||
IFN $$MULTI,[
|
||||
|
||||
;Compute current Vpos,,hpos at RB.PTR and return it in D,
|
||||
;by assuming that RB.POS is valid for beginning of buffer
|
||||
;and scanning through the buffer, seeing what the characters do to the cursor.
|
||||
;Clobbers A and C.
|
||||
RESYNCH:
|
||||
HRRZI C,1(P) ;C points to 3-word block on stack.
|
||||
MOVE D,RB.BEG(B) ;(C) holds b.p. to scan with.
|
||||
PUSH P,D
|
||||
HRRZ D,RB.POS(B) ;1(C) holds HPOS.
|
||||
PUSH P,D
|
||||
HLRZ D,RB.POS(B) ;2(C) holds VPOS.
|
||||
PUSH P,D
|
||||
RBCRS1: MOVE D,(C)
|
||||
CAMN D,RB.PTR(B) ;Scan till reach end of occupied region.
|
||||
JRST RBCRS2
|
||||
PUSHJ P,RBFORW
|
||||
JRST RBCRS1
|
||||
|
||||
RBCRS2: HRRZ D,1(C) ;D gets the new Vpos,,Hpos.
|
||||
HRL D,2(C) ;Flush the block of temporary variables.
|
||||
SUB P,[3,,3]
|
||||
POPJ P,
|
||||
|
||||
;Cursor position calculating routines.
|
||||
|
||||
;Move pointer in (C) one character forward, adjusting VPOS in 2(C)
|
||||
;and HPOS in 1(C) for the character moved over.
|
||||
RBFORW: ILDB A,(C)
|
||||
PUSHJ P,CHRTYP ;Get the character's "type code".
|
||||
XCT RRFORT(A) ;DISPATCH ON TYPE OF CHAR.
|
||||
RRFOR1: AOS A,1(C)
|
||||
RRFOR3: CAMGE A,RB.WID(B) ;HAVE WE MOVED PAST RIGHT MARGIN?
|
||||
POPJ P,
|
||||
CAMN A,RB.WID(B) ;CHECK FOR JUST REACHING THE RIGHT MARGIN.
|
||||
JRST RRCNTN
|
||||
RRCNT1: SUB A,RB.WID(B)
|
||||
MOVEM A,1(C)
|
||||
RRFORV: AOS 2(C)
|
||||
POPJ P,
|
||||
|
||||
RRCNTN: MOVE D,(C)
|
||||
ILDB D,D
|
||||
CAIN D,^M
|
||||
POPJ P,
|
||||
JRST RRCNT1
|
||||
|
||||
RRFORT: AOSA A,1(C) ;ORDINARY CHAR, MOVE FWD 1 POS.
|
||||
JRST RRFORC ;NON-FORMATTING CONTROLS.
|
||||
JRST RRFORH ;MOVE FWD OVER ^H - CHECK ^HPRINT FLAG.
|
||||
JRST RRFWCR ;^M, SPECIAL.
|
||||
JRST RRFORL ;^J, DOWN 1 LINE.
|
||||
JRST RRFOTB ;^I
|
||||
JRST RRFOR2 ;2-POS CTL CHRS NOT AFFECTED BY FS SAIL (Rubout and ^@)
|
||||
POPJ P, ;^G takes up no space.
|
||||
|
||||
RRFOTB: MOVE D,1(C)
|
||||
MOVEI A,10(D)
|
||||
ANDCMI A,7 ;A HAS NEXT TAB STOP'S POSITION.
|
||||
CAMLE A,RB.WID(B) ;BUT IF THAT'S OFF THE SCREEN, TAB STOP IS RIGHT MARGIN,
|
||||
CAMN D,RB.WID(B) ;UNLESS WE'RE ALREADY AT THE MARGIN, IN WHICH CASE
|
||||
CAIA ;WE CAN TAB 8 SPACES INTO NEXT LINE VIA CONTINUATION.
|
||||
MOVE A,RB.WID(B)
|
||||
MOVEM A,1(C)
|
||||
JRST RRFOR3
|
||||
|
||||
RRFORL: AOS 2(C)
|
||||
POPJ P,
|
||||
|
||||
RRFWCR: SETZM 1(C)
|
||||
POPJ P,
|
||||
|
||||
RRFORH: SKIPN 1(C)
|
||||
JRST RRFOR2
|
||||
SOS 1(C)
|
||||
POPJ P,
|
||||
|
||||
;NON-FORMATTING CONTROLS, CHECK FS SAIL FLAG.
|
||||
RRFORC: MOVE D,RB.TYP(B)
|
||||
TLNN D,RB%SAI ;SAIL mode => it is a one-position character.
|
||||
RRFOR2: AOS 1(C) ;Else treat as 2-pos ctl char.
|
||||
JRST RRFOR1
|
||||
|
||||
] ;IFN $$MULTI
|
||||
|
||||
.END RUBOUT
|
||||
Reference in New Issue
Block a user