Google
 

Trailing-Edge - PDP-10 Archives - BB-F494Z-DD_1986 - 10,7/sosxlt.mac
There are 3 other files named sosxlt.mac in the archive. Click here to see a list.
	TITLE	SOSXLT - The ALTER Mode Family (eXtended!)
;		------------------------------
; This file contains for ALTER mode as follows:
;	1. The A command
;	2. Command dispatching
;	3. SETALT - Set up a line for altering
;	4. GNCH1 - Get an alter mode character
;	5. Alter mode command processing
;	6. The extend (X) command
; 
 
 
	SEARCH	SOSTCS
	$INIT

 
	SUBTTL	The X Command

XPAND::	SKIPN	NEWALT##	;NEW ALTER?
	 JRST	$XPAND##	;NO
	SETOM	XCMDF		; Flag we are doing an X command
	JRST	ALTER1		; And do an alter

	SUBTTL	The A Command
 
; Here for the A command - Beginning of Alter Mode
 
ALTER::	SKIPN	NEWALT##	;NEW ALTER?
	 JRST	$ALTER##	;NO
	SETZM	XCMDF		; This is not an extend

; Join here for the X-command

ALTER1:	SETOM	PRVSIZ		; Fix count
	SETZM	SSW		; Clear suppress switch
	SETZM	CSW		; CLEAR COMMAND STRING SWITCH
	PUSHJ	P,GET2SD##	; Get the range
	SKIPN	XCMDF		; If X-command then
	JRST	XCMD4		; NO--CHECK FOR SWITCHES
	CAIN	C,";"		; Check for legal delimiter
	JRST	[PUSHJ P,SCAN	; Get number
		 TRNN FL,NUMF	; Is there a number
		 NERROR ILC	; No, quit
		 MOVE T2,INCR
		 MOVEM T2,TEMINC
		 JRST XCMD1]	; Join processing
	CAIE	C,","		; Is there a switch or new increment
	JRST	ALTER2		; No, check for end of line
	PUSHJ	P,SCAN##	; Get it
	TRNN	FL,NUMF		; Is there a number?
	JRST	XCMD2		; No, look for switch
XCMD1:	CAMN	T1,LNZERO##	; Line zero?
	NERROR	ILC		; Is illegal
	MOVEM	T1,INCR		; Save increment
	PUSHJ	P,SCAN##	; Scan next
XCMD4:	CAIE	C,","		; Still have a switch?
	JRST	ALTER2		; No, so better be the end
	PUSHJ	P,SCAN##	; Scan the switch
XCMD2:	MOVS	T1,ACCUM	;  to T1
	CAIN	T1,'S  '	; SUPPRESS SWITCH?
	  JRST	[SETOM SSW	; YES--NOTE SUPPRESS
		 JRST  XCMD3]	; AND CONTINUE
	CAIN	T1,'C  '	; ALTER COMMAND STRING SWITCH?
	  JRST	[SETOM CSW	; YES--NOTE SPECIAL COMMAND STRING
		 JRST  XCMD3]	; AND CONTINUE
	NERROR	ILC		; it's and error
XCMD3:	PUSHJ	P,SCAN##	; To reach end of line
	CAIN	C,","		; STILL HAVE SWITCH?
	  JRST	XCMD2		; YES--SCAN IT
ALTER2:	PUSHJ	P,CKTRMF##
	SKIPE	CSW		; SPECIAL COMMAND STRING?
	  PUSHJ	P,ACSTR		; YES--READ THE STRING
	PUSHJ	P,FINDLO##	; Get first line of range
	TRZ	FL,LINSN	; Not seen yet
				CONT.
ALT1:	PUSHJ	P,ONMOV##	; Check for in range
	  JRST	ALT2		; No, finish up
	TRO	FL,LINSN	; We did see something
	CAMN	T1,PGMK 	; Check for a page
	JRST	ALT3		; Do not try to change this
	MOVEM	T1,CLN		; Now, in case we said altmode
	MOVE	T1,CPG		; Same for page
	MOVEM	T1,CPGL
	SKIPE	SSW		; If S-switch
	TRO	FL2,SUPN	; Do suppress thing
	MOVEI	T5,CPOPJ	; Assume alter command
	SKIPE	XCMDF		; True?
	MOVEI	T5,ALTELX	; First free command
	PUSHJ	P,ALTLIN	; Do the Alter (or eXtend)
	  PJRST	LEVINS##	; He said altmode
	PUSHJ	P,AINSED	; Go insert
ALT4:	PUSHJ	P,FINDN##	; Get the next line
	JRST	ALT1		; Continue loop

ALT3:	MOVE	T2,CPG		; We are on a later page now
	ADDI	T2,1		; Add fudge factor
	MOVEM	T2,CPGL 	; Save as .
	PUSHJ	P,PGPRN##	; Print him a message
	MOVE	T1,LNZERO##	; Set to first? line
	MOVEM	T1,CLN		; For .
	JRST	ALT4		; Continue past it

ALT2:	TRNN	FL,LINSN	; Was there anything there?
	JRST	[SKIPE XINSRT##	; Auto insert on X command?
		  SKIPN XCMDF	; X command?
		   NERROR NLN	; No, give error message
		 TRZ FL,CNTF	; Don't handle these here
		 JRST INSGO##]	; Yes, treat as an insertion
	MOVE	T1,CPG		; Get the current page
	MOVEM	T1,CPGL 	; Save as .
	SKIPE	XINSRT##	; Auto insert on X command?
	 SKIPG	XCMDF		; Go back to insert?
	  JRST	COMND## 	; No, next command
	MOVE	T1,CLN		; Current line
	MOVEM	T1,HILN		; Save for INSRTX
	JRST	INSRTX##	; Join insert routine
	SUBTTL	SPECIAL COMMAND STRING HANDLING

; Read in a string to use

ACSTR::	SKIPN	NEWALT##	;NEW ALTER?
	 NERROR	ILC		;NO
	MOVE	T1,[2,,[ASCIZ/A*/]]; Get prompt string
	SKIPN	COMFLF		; Skip if in command file
	PUSHJ	P,PROMPT##	; Prompt
	PUSHJ	P,ACINIT	; Point to beginning of string
	MOVEI	T1,ACLEN	; Get max len
	PUSHJ	P,GNCH##	; Get a char
	CAIE	C,15		; <CR>?
	  JRST	ACSTR3		; No
	PUSHJ	P,GNCH##	; Yes--eat <LF>
	ILDB	C,ACPTR		; Get char from stored string
	JUMPN	C,CPOPJ##	; Return if something there
	NERROR	NSG		; Else error
ACSTR1:	PUSHJ	P,GNCH##	; Get a char
ACSTR3:	CAIN	C,200
	  MOVEI	C,33
	IDPB	C,ACPTR		; Store
	CAIN	C,12		; <lf>?
	  JRST	ACSTR2		; Yes-end
	SOJG	T1,ACSTR1	; Loop for all
	JRST	ER1RTN		; Error return

ACSTR2:	MOVEI	C,0		; Insure null byte
	IDPB	C,ACPTR		; Store
	POPJ	P,		; And return

; Setup byte pointer to string

ACINIT:	MOVE	T1,[POINT 7,ACBUF]; Point to buffer
	MOVEM	T1,ACPTR	; Store
	POPJ	P,		; And return

; Routine to get one char from the string

ACCHR:	ILDB	C,ACPTR		; Get a char
	JUMPN	C,CPOPJ##	; Return if got one
	NERROR	ILC		; Else error

DOBELL:	OUTCHR	[7]		; Bong the gong
	SKIPN	CSW		; In special command mode?
	  POPJ	P,		; No--just return
	MOVE	T1,[POINT 7,[BYTE (7) 15,12,0]]; Yes--point to crlf
	MOVEM	T1,ACPTR	; So next cmd finishes line
	POPJ	P,		; And return
	SUBTTL	AINSED -- Insert Altered line into the buffer

;AINSED -- Insert Altered line into the Buffer
;
;Call with PNTR pointing to unaltered line in buffer and
;altered line in LIBUF.  Checks to see if line was actually changed
;by doing a string compare.  If it was, it inserts the new line in
;the buffer with INSED, and handles the decrement and test on SAVEN
;for auto-save.

AINSED:	MOVE	T1,NCNT		; Get new count
	CAME	T1,OCNT		; Is it the same?
	JRST	AINSD1		; No, must update the line
	MOVN	T1,T1		; Minus count
	MOVSS	T1		; To left half
	HRRI	T1,LIBUF	; Point to Alter buffer
	MOVEI	T2,(PNTR)	; Point to line in edit buffer
	HRLI	T2,(POINT 36,)	; Make a word pointer
AINCMP:	ILDB	T3,T2		; Word from the buffer
	CAME	T3,(T1)		; Compare with Altered line
	JRST	AINSD1		; Different, go update line
	AOBJN	T1,AINCMP	; Loop over whole line
	POPJ	P,		; All same, therefore no changes

AINSD1:	PUSHJ	P,INSED##	; Update line in buffer
	SKIPE	SSAVEN		; Is save activated?
	SOSLE	SAVEN		; Yes, decrement count and check
	POPJ	P,		; No, just return
	PUSH	P,HILN		; Save current hiln
	MOVE	T1,CLN		; Get current line...
	MOVEM	T1,HILN 	; And establish as hiln for auto-save
	PUSHJ	P,ASVCOD##	; Do the auto-save
	POP	P,HILN		; Restore hiln
	POPJ	P,
	SUBTTL	Command Dispatching for ALTER Mode
 
; Here to alter a line
 
ALTLIN::SKIPN	NEWALT##	;NEW ALTER?
	 JRST	$ATLIN##	;NO
	PUSHJ	P,SETMOV	; SET MOVE MODE
	SKIPN	T1,CRLFSW	; If not set
	PJRST	ALTLNX		; Just do the alter
	MOVEM	T1,SVCRLF	; Save, in case of errors
	SETZM	CRLFSW		; Clear
	PUSHJ	P,SETTTY##	; Re-set to zero
	PUSHJ	P,ALTLNX	; Do the alter
	  CAIA
	AOS	(P)		; If skip return
RSCRLF::MOVE	T1,SVCRLF	; Get value back
	SETZM	SVCRLF		; Clear save
	MOVEM	T1,CRLFSW	; Reset
	PJRST	SETTTY##


; Call ALTLNX if a user supplied procedure should be executed
; after SETALT has set things up

ALTLNX:	PUSHJ	P,SETALT	; Set up line for alteration
IFN	%UAHPQ,<
	PUSHJ	P,HPQON##	;[UA WRS]  Use HPQ for ALTER mode
>
	SKIPE	CSW		; SPECIAL COMMAND STRING?
	  PUSHJ	P,ACINIT	; YES--INIT COMMAND ALTER STRING
 	PUSHJ	P,(T5)		; Call user routine
ALTLN1::			; Here if you don't want SETALT called
	SKIPN	NEWALT##	;NEW ALTER?
	 JRST	$ATLN1##	;NO
ALTLP2: TLZ	FL,NEGF 	; Turn off "-" seen flag
	PUSHJ	P,V52TPN	; Type line again
	SETZM	CHGLNF##	; Reset this flag
	SETZB	T2,DELBAK	; Reset 'deleting backward' flag
ALTLP:	TRZ	FL2,SUPN!ALTDUP	; Turn duplexing back off
	PUSHJ	P,GNCH1 	; Get on chr in ddt submode
	TLNE	CS,LETF_16	; Check for letter
	TRZ	C,40		; And convert to upper case
	MOVSI	T1,-ALTLG	; Get length of command table
; 
ALTLP3: HRRZ	T3,ALTAB(T1)	; Fetch an entry
	ANDI	T3,377		; GET JUST THE CHAR
	CAIE	C,(T3)		; Check for character match
	AOBJN	T1,ALTLP3	; No match, look at next
	JUMPGE	T1,ALTBEL	; Ring the bell if not found
	MOVS	T3,ALTAB(T1)	; Re-fetch entry (need flags)
	TRNE	FL,READOF	; Read-only?
	TLNN	T3,XAM		; and command modifies the file?
	CAIA
	JRST	ALTBEL		; Yes, error
	TLNN	T3,XNEGF	; Minus sign permitted?
	TLNN	FL,NEGF 	; No: is it set?
	JRST	ALTDSP		; Ok to execute command
ALTBEL: PUSHJ	P,DOBELL		; Bong a gong
	CLRBFI			; Clear type ahead
	JRST	ALTLP2		; Try again
 
ALTDSP:	TLNE	T3,XOFF		; COMMAND STORE OFFSET?
	  HRRZM	T3,MODE		; YES--STORE IT
	TLNE	T3,XOFF		; COMMAND STORE OFFSET?
	  JRST	ALTLP		; YES--NO DISPATCH
	PUSHJ	P,(T3)		; Execute command
	  JRST	ALTLP2		; Reset repeat count and get new command
	JRST	ALTLP		; Skip return from digits no count reset
 
; Here to ring bell after a command detected error
 
ALTFS2: POP	P,ALTCNT
ERARTN: POP	P,ALTP
ER1RTN: POP	P,(P)		; Clear junk off stack
ERRRTN: PUSHJ	P,DOBELL
	SETO	T2,		; Flag meaning error
	POPJ	P,		; Then return
	SUBTTL	ALTER Mode Commands Table
 
; Flags
 
XNEGF==400000			; Command may take a - sign
XAM==200000			; Command modifies the line
XOFF==100000			; STORE INDEX NOT DISPATCH
 
	DEFINE	ACMNDS,<
I==0
	REPEAT	^D10,<
	X	I+"0",	ALTDG, XNEGF	;; Accumulate a number
I==I+1>
	X	"B", INSBLK, XAM	;; Insert blanks
	X	"D", ALT.D, XNEGF!XAM	;; Delete characters
	X	"C", ALTCN, XNEGF!XAM	;; Change some characters
	X	"E", ALTEX,		;; Exit w/no print
	X	"I", ALTIN, XAM		;; Insert text
	X	"J", AJOIN, XNEGF!XAM	;; Insert CRLF and join
	X	"N", ALTNXL, XNEGF	;; Advance to next line
	X	"O", INSONE, XAM	;; Insert one character
	X	"P", APRINT,		;; Print and save pos
	X	"Q", ALTALT,		;; Quit while ahead
	X	"T", INSTAB, XAM	;; INSERT TABS
	X	"X", ALTEOL,XNEGF!XAM	;; Extend the line
	X	"/", ALTSL, XNEGF!XAM	;; Transpose 2 chars
;;	X	"\", ALTBSL, XNEGF!XAM	;; Transpose previous 2
	X	"-", ALTNEG,		;; Command goes left
	X	"+", INSNXT, XAM	;; Don't ask
	X	73, INSCRF, XAM		;; Break the line
	X	"'", INSQT, XAM		;; Make ^<ch>
	X	12, ALTFN,		;; Done with alter
	X	15, CPOPJ1,		;; Ignore CR's
	X	"R"-100+200, ALTCTR,	;; P up to current only
	X	"U"-100+200, ALTCU,	;; Restore and restart
	X	"W"-100+200, ALTBSW	;; Backspace one word

	X	"K",MODE.K,XOFF!XNEGF!XAM	;; Delete some characters
	X	"R",MODE.R,XOFF!XNEGF!XAM	;; Replace some characters
	X	"V",MODE.V,XOFF!XNEGF!XAM	;; Invert case to EOL
	X	"\",MODE.L,XOFF!XNEGF!XAM	;; LOWER CASE SOME CHARS
	X	"^",MODE.U,XOFF!XNEGF!XAM	;; UPPER CASE SOME CHARS
	X	233,SETMOV,			;;RESET TO MOVE MODE

	X	" ",UNI.SP,XNEGF		;; UNIT = 1 CHAR
	X	"H"-100+200,UNI.BS,XNEGF	;; UNIT = -1CHAR
	X	177,UNI.BS,XNEGF		;; UNIT = -1 CHAR
	X	11,UNI.Z,XNEGF			;; UNIT = TO EOL
	X	"Z",UNI.Z,XNEGF			;; UNIT = TO EOL
	X	"W",UNI.W,XNEGF			;; UNIT = 1 WORD
	X	"S",UNI.S,XNEGF			;; UNIT = TO CHAR
	X	"F",UNI.F,XNEGF			;; UNIT = TO STRING
	X	"G",UNI.G,XNEGF			;; UNIT = PAST STRING
	X	"M",UNI.M,XNEGF			;; UNIT = STRING
	X	"L",UNI.L,XNEGF			;; UNIT = WHOLE LINE
	>
 
; The commands table
 
	DEFINE	X(A,B,C),<XWD	B,A!C>
ALTAB:	ACMNDS
ALTLG==.-ALTAB
 
 
	SUBTTL	SETALT - Set Up a Line for ALTER
 
; Routine to set up a line for altering
 
SETALT:	MOVEI	T1,0		; Be sure TTY TAB is off
	PUSHJ	P,SETTAB##	; (but remember old setting)
	PUSHJ	P,LOADCL##
SALT1:	MOVE	ALTP,[POINT 7,LIBUF+1,13]	; Set up pointer
	SETZM	ALTCNT		; So far we are 0 chrs into line
	HRRZM	T1,OCNT 	; And save it for insed
	OFFECHO 		; Turn off echo
	TRZ	FL2,RUBF!ALTDUP!RUBF2; Clear rubout and echoing flags
	SETZM	ALTFLG		; Nothing inserted so far
	MOVE	T1,LIBUF	; Print line number and tab
	PUSHJ	P,OUTSN##	; Sequence number
	SETOM	PRVSIZ		; Force typeout if on VT52
	POPJ	P,
 
RPSALT=:SALT1
 
; Macros for rubout control
 
DEFINE	OFFRUB<
	PUSHJ	P,.OFFRB
>
.OFFRB:	SKIPE	DPYFLG
	POPJ	P,
	TRZE	FL2,RUBF2
	OUTSTR	[ASCIZ /\\/]
	TRZE	FL2,RUBF
	OUTCHR	["\"]
	POPJ	P,
 
 
DEFINE	ONRUB<
	PUSHJ	P,.ONRUB
>
.ONRUB: SKIPE	DPYFLG
	POPJ	P,
	TRZE	FL2,RUBF2
	OUTSTR	[ASCII /\\/]
	TRON	FL2,RUBF
	OUTCHR	["\"]
	POPJ	P,
	SUBTTL	GNCH1 - Get a Character in ALTER Mode
 
; Routine to get the next alter mode command character
 
; Here to get any character (including altmode)
 
AGNCH1::PUSHJ	P,GNCH1 	; Get a character
	TRZ	C,200		; Clear special flags
	POPJ	P,
 
GNCH1A: SKIPE	CSW		; SPECIAL COMMAND STRING?
	  PJRST	ACCHR		; YES--GET CHR AND RETURN
	SKIPE	COMFLF		; Cmd file?
	JRST	[PUSHJ P,RDCHAR##
		JRST GNCH1C]
	SKIPE	MACLVL##	; MACRO?
	 JRST	[PUSHJ P,CHINM##;YES--GET CHAR
		 JRST  GNCH1C]	;AND CONTINUE
GNCH1D::INCHRW	C
IFN CKPSW,<
	PUSHJ	P,CKPCHR##	; Save in checkpoint file
>
	SKIPN	REFDLY		; Does he have this enabled?
	JRST	GNCH1H		; No, save overhead
	SETO	CS,		; Set to wake this job
	WAKE	CS,		; Wake it so HIBER will return quickly
	  JFCL			;
	SETZ	CS,		; No sleep time, no enable bits
	HIBER	CS,		; This clears the enable conditions
	  JFCL			; ?*%@!
GNCH1H:	ANDI	C,177
	PUSHJ	P,CHKALT##	; Convert altmodes to ESCAPE if needed
IFN	%UAHPQ,<
	CAIN	C,"C"-100	; Check for ^C
	PUSHJ	P,FAKINT##
>
GNCH1C:	CAIE	C,33		; Never duplex esc
	TRNN	FL2,ALTDUP	; And not unless desired
	POPJ	P,
	CAIE	C,12		; Not line feed
	CAIN	C,15		; Or return
	POPJ	P,
	CAIE	C,"U"-100	; Don't echo ^U
	CAIN	C,177		; And finally ignore rubout
	POPJ	P,
	TLNN	FL2,BKSPF	; Is backspace special?
	JRST	.+3
	CAIN	C,"H"-100	; Don't echo backspace if _DPY&_BACKSP
	POPJ	P,
	CAIN	C,"W"-100	; Don't duplex ^W
	POPJ	P,		;
	SKIPE	VT52FL		; VT52?
	CAIE	C,"R"-100	; and ^R
	CAIA
	POPJ	P,		; Return
	OFFRUB			; If we are duplexing then not deleting
	PJRST	FOCHR##
 
GNCH1:: PUSHJ	P,GNCH1A	; Get a chr in ddt mode
	CAIE	C,"R"-100	; If ^R
	CAIN	C,33		; Convert altmode to 200
	TRO	C,200
	TLNE	FL2,BKSPF	; Skip if not in /BAC mode
	CAIE	C,"H"-100	; Skip if /BAC and char is ^H
	CAIN	C,"U"-100	; Skip if not ^U
	TRO	C,200		; Flag as special
	CAIN	C,"W"-100	; ^W?
	TRO	C,200		; Yes, set special bit
	TRNE	C,200		; Check for special
	POPJ	P,		; and return the character
	SKIPE	QMDFLG
	CAIE	C,"'"		; Check for quote
	JRST	GNCH1B		; No, this chr is ok
	PUSHJ	P,GNCH1A	; Get another
	SKIPE	CTBL(C) 	; If 0 hn ctbl, keep it
	MOVS	C,CTBL(C)	; Get alternate code
	ANDI	C,177		; Get rid of extra bits
GNCH1B: MOVE	CS,CTBL(C)	; Load CS
	TLNE	CS,LETF_16	; Check for letter
	TDC	C,CASEBT	; And apply case conversion
	POPJ	P,		; All done
	SUBTTL	UNIT ACTION ROUTINES

ALTZNK:	PUSH	P,MODE		; SAVE MODE
	MOVEI	T1,MODE.K	; GO INTO DELETE MODE
	MOVEM	T1,MODE		; ..
	PUSHJ	P,UNI.W		; DELETE WORD
	POP	P,MODE		; RESTORE MODE
	POPJ	P,		; AND RETURN

ALTBSW:	PUSH	P,MODE		; SAVE MODE
	PUSHJ	P,SETMOV	; GO INTO MOVE MODE
	TLC	FL,NEGF		; GO BACKWARDS
	PUSHJ	P,UNI.W		; BACKSPACE WORD
	POP	P,MODE		; RESTORE MODE
	POPJ	P,		; AND RETURN

ALTTAB::SKIPN	NEWALT##	;NEW ALTER?
	 JRST	$ATTAB##	;NO
	PUSH	P,MODE		; SAVE MODE
	PUSHJ	P,SETMOV	; GO INTO MOVE MODE
	PUSHJ	P,UNI.Z		; DO COMMAND
	POP	P,MODE		; RESTORE MODE
	POPJ	P,		; AND RETURN

UNI.L:	MOVE	T1,MODE		; GET MODE
	CAIE	T1,MODE.M	; MOVE MODE?
	  JRST	[PUSHJ P,ALTLNN	; NO--POSITION TO BL
		 JRST  UNI.Z]	; AND DO EOL CMD
	PJRST	ALTLN		; YES--POSITION AND TYPE LINE

UNI.BS:	TLCA	FL,NEGF		; BACKSPACE = -SPACE
UNI.Z:	  MOVSI	T2,1		; EOL = 10000 SPACE
UNI.SP:	MOVE	T1,MODE		; GET MODE
	PUSHJ	P,@MODDSP(T1)	; DISPATCH
RCHK:	PUSH	P,MODE		; SAVE OLD MODE FOR REPLACE CHECK
	PUSHJ	P,SETMOV	; GET MOVE MODE
	POP	P,T1		; GET MODE BACK
	CAIE	T1,MODE.R	; REPLACE?
	  POPJ	P,		; NO--RETURBN
	PUSHJ	P,V52TYP	; YES--RETYPED LINE
	PJRST	ALTINZ		; GO DO INSERT
SETMOV:	MOVEI	T1,MODE.M	; GET MOVE MODE
	MOVEM	T1,MODE		; SET
	POPJ	P,		; AND RETURN

UNI.W:	MOVE	T1,MODE		;GET MODE
	MOVE	T1,MODDSP(T1)	; GET DISPATCH
	PUSHJ	P,.ALTWD	; DO WORD STUFF
	PJRST	RCHK		; AND CHECK FOR REPLACE

UNI.S:	PUSHJ	P,.ALTSR	; SEARCH FOR CHAR
	JUMPLE	T2,SETMOV	; RETURN IF NOTHING TO DO
	PJRST	UNI.SP		; AND DO IT

UNI.M:	MOVE	T1,MODE		; GET MODE
	MOVE	T1,MODDSP(T1)	; GET DISPATCH
	MOVEM	T1,ALTWPR##	; PASS IT
	MOVEI	T1,ALT.SP	; GET SPACER
	MOVEM	T1,ALTFXT	; PASS IT
	PUSHJ	P,ALTGTS	; DO STRING
	PJRST	RCHK		; AND CHECK FOR REPLACE

UNI.F:	MOVE	T1,MODE		; GET MODE
	MOVE	T1,MODDSP(T1)	; GET DISPATCH
	MOVEM	T1,ALTFXT	; PASS IT
	PUSHJ	P,ALTFS		; GO DO FIND
	PJRST	RCHK		; AND CHECK FOR REPLACE

UNI.G:	MOVE	T1,MODE		; GET MODE
	MOVE	T1,MODDSP(T1)	; GET DISPATCH
	MOVEM	T1,ALTWPR##	; PASS IT
	MOVEM	T1,ALTFXT	; AND FOR FIND
	PUSHJ	P,ALTGTS	; GO DO FIND
	PJRST	RCHK		; AND CHECK FOR REPLACE

MODDSP:	ALT.SP			; 0=CHAR
	ALT.K			; 1=DELETE(KILL)
	ALT.K			; 2=REPLACE
	ALT.V			; 3=INVERT
	ALT.U			; 4=UPPER CASE
	ALT.L			; 5=LOWER CASE

MODE.M=0
MODE.K=1
MODE.R=2
MODE.V=3
MODE.U=4
MODE.L=5

	SUBTTL	The -, Space, Tab, X, ^ and V Commands
 
; The - command
 
ALTNEG: TLO	FL,NEGF
	JRST	CPOPJ1##
 
; Here to accumulate digits
 
ALTDG:	IMULI	T2,^D10 	; Accumulate repeat count
	ADDI	T2,-"0"(C)
	JRST	CPOPJ1		; Skip return so at not to 0 rpt. cnt.
 
; The tab and space commands

ALTBOL:	PUSHJ	P,SAVR##	; Save T3-T5
	PUSHJ	P,CSRPOS	; Compute number of wraps
	PUSHJ	P,FIXWPC	; Account for multiple of LINEW
	PJRST	UPCRSR		; And position

ALTSP::	SKIPN	NEWALT##	;NEW ALTER MODE?
	 JRST	$ALTSP##	;NO
ALT.SP: TLNE	FL,NEGF 	; Check backwards
	PJRST	ALTBS		; Yes: back space
	OFFRUB
	  ; 
ALTSP2: LDB	C,ALTP		; Get the chr we are pointing at
	CAIN	C,15		; If return then as far as can go
	PJRST	FORCE##
	TRNN	FL2,SUPN	; Special hack for xtend
	PUSHJ	P,OCHR##	; Print it
	IBP	ALTP		; Advance pointer
	AOS	ALTCNT		; And count
	SOJG	T2,ALTSP2	; Do correct number of times
	PJRST	FORCE## 	; Dump it
 
ALT.L:	MOVE	T1,[TRO C,40]	; MAKE LOWER CASE
	 JRST	ALTCHG		; AND CHANGE
ALT.U:	SKIPA	T1,[TRZ C,40]	; MAKE UPPER CASE
ALT.V:	  MOVE	T1,[TRC C,40]	; INVERT CASE
ALTCHG:	MOVEM	T1,ALTCXT	; SAVE
	TLNN	FL,NEGF 	; If going forward
	JRST	ALTCG0
	PUSH	P,T2		; Save count
	PUSHJ	P,ALTBS 	; Backspace
	EXCH	T2,(P)		; Restore count
	SUB	T2,(P)		; In case count was too large
ALTCG0: OFFRUB			; Terminate deletes and backspaces
ALTCG1: LDB	C,ALTP		; Get character
	CAIN	C,15		; Test for end of line
	JRST	ALTCG2		;  Yes, done
	MOVE	CS,CTBL(C)	; Get character's flag bits
	TLNE	CS,LETF_16	; Test for a letter
	XCT	ALTCXT		; YES, DO CASE CONVERSION
	DPB	C,ALTP		; Put character back
	PUSHJ	P,OCHR		; Type character
	IBP	ALTP		; Incr byte pointer
	AOS	ALTCNT		;  & character count
	SOJG	T2,ALTCG1	; Decr count & repeat
ALTCG2: TLNE	FL,NEGF 	; If going backward
	POP	P,T2		; Get garbage of the stack
	PJRST	FORCE		; Force typing out
 
; The X command
 
ALTELX:	SETZ	T2,		; Come here initially for the X command
	TLZ	FL,NEGF		; Clear negative flag
ALTEOL:	PUSH	P,T2		; SAVE POSSIBLE INCREMENT
	PUSHJ	P,ALTTAB	; Go to end of line
	POP	P,T2		; Restore increment
	TLZ	FL,NEGF
	PJRST	ALTIN		; And go merge with insert
	SUBTTL	 The R, K and D Commands

ALT.D:				; Here for immediate mode DELETE
ALT.K:	SETOM	CHGLNF		; Note can change print size of line
	TLNE	FL,NEGF 	; Backwards?
	JRST	ALTBDL		; Yes:
	MOVEM	ALTP,SVALTP	; Save current pointer posithon
ALT.K1: LDB	C,ALTP		; Get current chr
	CAIN	C,15		; At end of line?
	JRST	ALT.K5		; Yes, go finish off
	SKIPN	EXPFLG		; Print only if non-expert
	SKIPE	VT52FL		; Or in fancy disply mode
	CAIA
	PUSHJ	P,ALTDPN	; Yes: print char
	IBP	ALTP		; Advance pointer
	SOJG	T2,ALT.K1	; Check count and continue
ALT.K5: SKIPN	VT52FL		; If on a display
	SKIPN	DPYFLG		; Are we on a display?
	JRST	ALT.K6		; No--skip extra blank stuff
	MOVEI	C," "		; Yes--put out one more...
	PUSHJ	P,OCHR		; Blank to delete last character
	MOVE	C,BACCHR##	; Then put out a backspace...
	PUSHJ	P,OCHR		; To puts us back at the right point
ALT.K6: PUSHJ	P,FORCE 	; Force output
ALT.K3: MOVE	T3,SVALTP	; Get back pointer
ALT.K4: LDB	C,ALTP		; Move line down
	DPB	C,T3
	JUMPE	C,ALT.K2	; Done?
	IBP	ALTP		; Advance pointers
	IBP	T3
	JRST	ALT.K4
ALT.K2: MOVE	ALTP,SVALTP	; Restore pointer again
	POPJ	P,
 
; The P and ^R commands
 
ALTCTR:	SKIPN	VT52FL		; Display?
	PJRST	RPRINT		; No standard function
V52RTP:	SETOM	PRVSIZ		; Force retype
	PJRST	V52TPP		; and do it

RPRINT:	PUSH	P,ALTCNT	; Save current count
	PUSHJ	P,ALTLNN	; Restart the line
	PJRST	APRNT1
 
APRINT: SKIPE	VT52FL
	PJRST	V52RTP		; Do special thing for displays
	PUSH	P,ALTCNT	; Save current count
	PUSHJ	P,ALTLN 	; Print rest of line and start over
APRNT1: POP	P,T2		; Get back count
	JUMPN	T2,ALT.SP
	POPJ	P,
 
; Here to print characters as they are deleted
 
ALTDPN: SKIPE	DPYFLG		; On a display?
	JRST	DISDPN		; Do it right then
	PUSH	P,C
	MOVEI	C,"\"
	TRNN	FL2,RUBF2
	PUSHJ	P,OCHR
	TRZE	FL2,RUBF
	PUSHJ	P,OCHR
	TRON	FL2,RUBF2
	PUSHJ	P,OCHR
	POP	P,C
	JRST	OCHR
DISDPN: TLNN	FL,NEGF 	; Going backward?
	JRST	DSDPN2		; No, then go forward
	SETOM	DELBAK		; Set 'deleting backward' flag
	PUSHJ	P,RUBAK 	; Backspace over the character
	PJRST	TYPSTR##	; Type eraser--returned in T1 by RUBAK
; 
DSDPN2: CAIG	C," "		; Use blank to for non-printing chars
	MOVEI	C," "		; Map all special characters into a blank
	PUSHJ	P,OCHR		; Output deleted character
	MOVE	C,BACCHR##	; Code for backspace
	PJRST	OCHR		; Output and return
	SUBTTL	The I Command


;  The I command -- text insertion
 
ALTINZ: TLZ	FL,NEGF 	; Commands join here to terminate with
				; an I command.  R, T, !, H and M.
	SETZ	T2,		; Clear increment
; 
ALTIN:	TRO	FL2,ALTDUP	; Turn on duplexing
	MOVEM	T2,ALTINC	; Save in case he inserts a return
	MOVEI	T1,GNCH1
ALTIN0:	MOVEM	T1,IGNCH##	; Set up routine to get characters
ALTIN1:	PUSHJ	P,@IGNCH##	; Get a character
	CAIN	C,233		; Finish on altmode
	POPJ	P,
	SETOM	CHGLNF		; Can change print size of line
	SETOM	DELBAK		; Like deleting backward
	CAIN	C,15		; Finish on CR
	JRST	ALTFNZ
	CAIN	C,12
	JRST	INSCR		; Go insert a CRLF
	CAIN	C,"U"-100+200	; A ^U?
	JRST	ALTCU		; Abort this disaster
	CAIE	C,"H"-100+200	; Is this a special delete char?
	CAIN	C,177		; Check for backspace
	JRST	ALTIBS		; And delete chr to left
	CAIN	C,"R"-100+200	; Did he type ^R?
	JRST	[PUSHJ	P,RPRINT
		 JRST	ALTIN1] ; Re-echo and loop for more
	CAIN	C,"W"-100+200	; ^W?
	JRST	ALTIWS		; Wordspace backward
	MOVE	T3,ALTP 	; Get set to shift things
	PUSH	P,ALTCNT	; Save this for later
	LDB	T1,T3		; Get chr from line
ALTIN2: DPB	C,T3		; Shift line
	JUMPE	C,ALTIN3	; Done
	AOS	ALTCNT		; Count it
	ILDB	C,T3
	DPB	T1,T3
	JUMPE	T1,ALTIN3	; Done
	AOS	ALTCNT		; Count
	ILDB	T1,T3
	JRST	ALTIN2
ALTIN3: MOVE	T2,ALTCNT	; See if overflow happened
	CAIL	T2,MXWPL*5
	NERROR	LTL		; Yes
	POP	P,ALTCNT	; Restore old count
	IBP	ALTP		; Advance pointer
	AOS	ALTCNT		; And count
ALTIN4:	PUSHJ	P,V52TPI	; Type if in VT52 mode
	JRST	ALTIN1		; Go get more
 
; Here to insert a CRLF (i.e. a new line)
 
INSCR:	OFFRUB
	SETOM	PRVSIZ		; Zap this, new line
	SKIPE	VT52FL		; Vt52?
	XCT	TMFCLN		; Clear to end of line
	OCRLF
	SKIPN	T1,ALTINC	; Did he specify an increment?
	SKIPA	T3,INCR 	; No, use standard
	PUSHJ	P,ASCON##	; Convert to ASCII
	MOVE	T1,T3		; Find the new line number
	MOVE	T2,LIBUF	; Current one
	PUSHJ	P,ASCIAD##	; Add
	PUSH	P,T1		; Save result
	PUSHJ	P,FINDN 	; Get the next one
	POP	P,T2
	CAMG	T2,LIBUF	; Is there a war problem
	JRST	INCBAD		; Yes, we must try to compute one
	JUMPE	T1,INCOK	; End of file, any inc is ok
	CAME	T1,PGMK 	; Also ok if a page mark
	CAMGE	T2,T1		; Or in correct order
	JRST	INCOK
INCBAD: CAME	T1,PGMK
	SKIPN	T1
	MOVE	T1,LNOVER##	; One over the top of the world
	MOVEM	T2,LIBUF2	; Save in case nothing will work
	MOVE	T2,LIBUF	; Get current
	PUSHJ	P,ASCAV##	; Find average
	CAME	T2,LIBUF	; There may have only been a dif of 1
	JRST	INCOK		; All is well
	RERROR	ORDER		; Tell him
	PUSHJ	P,FINDB##	; Get back where we belong
	PUSHJ	P,RPRINT 	; Type out line to current point
	JRST	ALTIN4		; And continue insert

INCOK:	MOVEM	T2,LIBUF2	; Save it
	MOVEM	T2,CLN		; And set as current line
	PUSHJ	P,FINDB 	; Back up to where we belong
	MOVE	T1,[XWD LIBUF+1,LIBUF2+1]
	BLT	T1,LIBUF2+MXWPL+1; Save old buffer
	PUSH	P,ALTP		; Save pointer
	MOVEI	C,15
	DPB	C,ALTP		; And terminate this line
	MOVEI	C,12
	IDPB	C,ALTP
	MOVEI	C,0		; Fill out line with nulls
AINSC2: TLNN	ALTP,760000
	JRST	AINSC3
	IDPB	C,ALTP
	JRST	AINSC2
AINSC3: SUBI	ALTP,LIBUF-1	; Find count
	HRRZM	ALTP,NCNT
	PUSHJ	P,INSED 	; Replace old line
	PUSHJ	P,FINDN 	; Move up to next
	SETZM	OCNT		; This is a new line going in
	MOVE	T1,LIBUF2	; Move line number over
	CAMLE	T1,HILN		; Is it smaller than HILN?
	MOVEM	T1,HILN		; No, make HILN consistent
	MOVEM	T1,LIBUF
	SETZM	LIBUF+1
	MOVE	T1,[XWD LIBUF+1,LIBUF+2]
	BLT	T1,LIBUF+MXWPL+1; Zero out rest
	POP	P,T2		; Restore pointer to rest of line
	MOVE	ALTP,[POINT 7,LIBUF+1]; Dest pointer
	ADD	T2,[XWD 70000,MXWPL+3]; Adjust input pointer
	MOVEI	C,11		; And set up the tab
MOVNEW: IDPB	C,ALTP
	CAIN	C,12
	JRST	DONNEW		; Finished moving rest of line
	ILDB	C,T2		; Pick up one
	JRST	MOVNEW
DONNEW: SUBI	ALTP,LIBUF	; Get count
	MOVEI	ALTP,1(ALTP)	; Used to be - movei ac,1-libuf(ac)
	MOVEM	ALTP,NCNT
	PUSH	P,ALTP		; And save
	PUSHJ	P,INSED 	; Insert
	MOVE	ALTP,[POINT 7,LIBUF+1,13]; Set up for alter
	SETZM	ALTCNT
	POP	P,OCNT		; Set for old count
	MOVE	T1,LIBUF
	PUSHJ	P,OUTSN##
	SETOM	ALTFLG		; We have inserted 
	JRST	ALTIN4		; And continue inserting
	POPJ	P,
 
; Here if he types a rubout in insert mode
 
ALTIBS: MOVEI	T2,0		; Set count to 0
	MOVEM	ALTP,SVALTP	; Save pointer
	PUSHJ	P,ALTBS 	; Do a backspace
	JUMPE	T3,ALTIN1	; If hit beginning of the line
	EXCH	ALTP,SVALTP	; Get back and save current
	PUSHJ	P,ALT.K3	; Delete that chr
	SKIPE	DPYFLG		; On a display?
	PUSHJ	P,TYPSTR##
	JRST	ALTIN4		; Get more
 
; Here on ^W in insert mode

ALTIWS:	MOVEI	T2,0		; Set count to 0
	TLO	FL,NEGF		; Set negative flag
	PUSHJ	P,ALTZNK	; Backup
	TLZ	FL,NEGF		; Clear it now
	JRST	ALTIN4		; Get next
;  THE O COMMAND -- Insert a single character
 
INSONE:	OFFRUB			; Issue pending backslashes
	MOVEI	T1,INSO1	; Next entry when insert want a character
	MOVEM	T2,INOCNT##	; Rep count for insertion
	SETOM	V52SPF
	PJRST	ALTIN0		; Start the insertion
; 
INSO1:	MOVEI	T1,INSO2	; Next entry
	MOVEM	T1,IGNCH	; Save it
	PUSHJ	P,AGNCH1	; Read up next character
	MOVEM	C,INOCHR##
	CAIE	C,15		; Don't duplex carriage return
	CAIN	C,12		; or linefeed
	POPJ	P,
	PJRST	OCHR		; Duplex the character
; 
INSO2:	SOSG	INOCNT		; Count satisfied?
	JRST	INSO3		; Terminate
	MOVE	C,INOCHR	; Restore character to insert
	CAIE	C,12		; Don't print a linefeed
	PJRST	OCHR		; Output it again
	POPJ	P,		; Return to insert routine
; 
INSO3:	MOVEI	C,233		; Termination character
	SETZM	V52SPF
	PJRST	FORCE
 
;  The semicolon command -- insert a <CR> <LF> to break the current line

INSCRF:	MOVEI	C,12
	PJRST	INSCHR

;  THE B COMMAND -- Insert one or more blanks (short for nO<blank>)
 
INSTAB:	SKIPA	C,["	"]	; TAB CHARACTER
INSBLK:	MOVEI	C," "		; Blank character
INSCHR:	MOVEM	C,INOCHR	; Pass it for one character insert code
	SETOM	V52SPF		; Kill typeout by insert for awhile
	SKIPN	T2		; Zero implies one
	MOVEI	T2,1		; Adjust it
	AOS	T2		; Fudge count
	MOVEM	T2,INOCNT	; Set up the count
	MOVEI	T1,INSO2	; Address for character repetition
	PJRST	ALTIN0		; Go insert the characters

; The + command -- duplicate the current character
 
INSNXT:	OFFRUB
	PUSHJ	P,ALTBAK	; Peek at previous character
	JUMPE	T3,CPOPJ##	; If at beginning of line
	MOVE	C,T3		; Character under cursor
	IBP	ALTP		; Reset pointer
	CAIN	C,15		; If a null line
	JRST	ERRRTN		; This is an error
	PJRST	INSCHR		; Else output it
 
; Here for the ' command
 
INSQT:	OFFRUB			; As usual
	PUSHJ	P,AGNCH1	; Go get his character
	CAIG	C,100		; Make sure it will be gt 0
	JRST	ERRRTN		; Nope, bong the gong
	TRZ	C,777640	; Clear parity and convert to UC
	SUBI	C,100		; Make it a control character
	CAIE	C,15		; Bare carriage returns confuse SOS
	CAIN	C, 12		; and so do linefeeds
	JRST	ERRRTN		; Bong the gong
	JRST	INSCHR		; Do, O, + and B thing
 
	SUBTTL	The F Command
 
;  The F command
 
ALTFS:	PUSHJ	P,ALTFG 	; Get search string
; 
ALTFSR: PUSH	P,T2
	PUSH	P,ALTP
	PUSH	P,ALTCNT
	SETZM	INOCNT
; 
ALTFS1: LDB	C,[POINT 7,AFSBUF##,6]; Break character for search
	MOVEI	T2,1
	TLNE	FL,NEGF 	; Skip if going forward
	PUSHJ	P,[PUSH P,ALTP
		   AOS	-1(P)
		   JRST ALTBC1]
	PUSHJ	P,ALTCS 	; Look for instance of initial character
	ADDM	T2,INOCNT
	CAIN	T3,15		; Give up if the search fails
	JRST	ALTFS2
	JUMPE	T3,ALTFS2	; If search fails going backward
	SKIPE	T2		; Don't space if zero
	PUSHJ	P,ALTSSP	; Space over to it
	PUSHJ	P,ALTCMP	; Is it the one we're looking for
	  JRST	ALTFS1		; No, try for another
	POP	P,ALTCNT	; Restore count
	POP	P,ALTP		; And pointer
	SKIPE	T2,INOCNT	; Get count
	PUSHJ	P,@ALTFXT	; PROCESS THOSE CHARS
	POP	P,T2
	SOJG	T2,ALTFSR	; Do search specified number of times
	POPJ	P,
 
	SUBTTL	Subroutine to Read in a Search String
 
ALTFG:	OFFRUB			; Terminate any rubouts or deletes
	MOVEI	T4,^D19 	; Max search string length
	MOVE	T3,[POINT 7,AFSBUF##-1,34]; Pointer to buffer
ALTG1:	PUSHJ	P,GNCH1 	; Get a character for search string
	CAIN	C,15		; Is it <CR>
	JRST	ALTG2		; Denotes string at eol
	CAIN	C,233		; End of search string
	JRST	ALTG3		; Yep
	CAIN	C,"U"-100+200	; Negative acknowlege?
	JRST	ALTFG		; Take it again from the top
	CAIE	C,"H"-100+200	; Yes, do we have a backspace?
	CAIN	C,177		; Rubout?
	JRST	[CAMN	T3,[POINT 7,AFSBUF-1,34]
		 JRST	ALTG1
		 ADD T3,[POINT 0,0,28]
		 TLNE T3,(1B0)
		 SUB T3,[POINT 0,1,0]
		 AOJA T4,ALTG1]
	TRZ	C,200		; Clear special bits for anything else
	CAIL	C,140		; Skip if not lower case
	TDZ	C,AEXACF	; Conditionally convert to upper
	IDPB	C,T3		; Save this character in sstr buffer
	SOJG	T4,ALTG1	; Try for another
; 
	JRST	ER1RTN		; The search string is too long
 
ALTG2:	IDPB	C,T3		; Put <CR> in search string
	PUSHJ	P,GNCH1 	; Swallow the line feed
; 
ALTG3:	SETZ	C,		; End of string marker
	CAIE	T4,^D19 	; If null string, T4 is still 19
	IDPB	C,T3		; Mark it
	POPJ	P,		; Return
 
	SUBTTL	The G Command
 
ALTGTS: PUSHJ	P,ALTFG 	; Get string to search for
	CAIN	T2,0
	MOVEI	T2,1		; Make positive
	TLNN	FL,NEGF 	; Going backward
	JRST	ALTG1A		; If not
	PUSH	P,[ALTG1B]
	PUSH	P,T2
	PUSH	P,ALTP
	PUSH	P,ALTCNT	; Save state in case search fails
	PUSHJ	P,LFSBUF
	MOVEM	T2,INOCNT
	PUSHJ	P,ALTSSP	; Silent space over the string
	JRST	ALTFS1		; Do the search
 
ALTG1A: TLO	FL2,L2.SSI	; Allow G to skip F string
	PUSHJ	P,ALTFSR	; Do the search
ALTG1B: JUMPL	T2,CPOPJ	; If search failed
	PUSHJ	P,LFSBUF	; Get length of search string
	TLZ	FL,NEGF 	; Clear negative flag
	JRST	@ALTWPR##	; Process search string
 
;  Routine to compute length of the search string (Returned in T2)
 
LFSBUF: MOVE	T1,[POINT 7,AFSBUF]; Start of search string
	SETZ	T2,		; Initialize count
; 
LFSBF1: ILDB	C,T1		; Get character from search string
	JUMPE	C,CPOPJ
	AOJA	T2,LFSBF1	; Increment count
	SUBTTL	The Character-Search Commands: S, K, ! and "

.ALTSR: PUSHJ	P,AGNCH1	; Get character to search for
	CAIN	C,15		; Carriage return is end of line
	JRST	.ALTSC		; Fake it
	CAIL	C,140		; Lower case
	TDZ	C,AEXACF	; Map upper/lower if desired
	PUSH	P,ALTP
	PUSH	P,ALTCNT	; Save these
	SETZM	INOCNT		; Clear counter
	MOVEM	C,INOCHR	; Save targent character
; 
.ALTS1: PUSH	P,T2
	MOVE	C,INOCHR	; Restore character
	PUSHJ	P,ALTCS
	CAIE	T3,0		; Off front end - skip
	CAIN	T3,15		; or if reached end of line
	JRST	[PUSHJ P,DOBELL	; Type a bell
		SETZM  (P)	; Clear remaining count
		JRST   .ALTS2]	; And use what we have
	ADDM	T2,INOCNT	; Accumulate repitition count
	PUSHJ	P,ALTSSP	; Space over
.ALTS2: POP	P,T2
	SOJG	T2,.ALTS1
	POP	P,ALTCNT	; Restore counter
	POP	P,ALTP		; and pointer
	MOVE	T2,INOCNT	; Restore count
	TLNE	FL,NEGF 	; Backward?
	SUBI	T2,1		; Go one less
	POPJ	P,
 
 
 
.ALTSC: PUSHJ	P,GNCH1 	; Swallow line feed
	MOVSI	T2,1		; Force end of line with huge count
	POPJ	P,		; And return
 
; Common search routine
 
ALTCS:	MOVEI	T2,1		; Create a repeat count
	TLNE	FL,NEGF 	; Backwards?
	JRST	ALTBCS		; Yes: search backwards
	LDB	T3,ALTP 	; Chec to see if at end of line
	CAIN	T3,15
	POPJ	P,
	MOVE	T1,ALTP 	; Get a copy of the pointer
	TLNE	FL2,L2.SSI	; Suppress?
;**;	TLO	FL2,L2.SSI	; LET S/F FIND CHAR AT CURRENT POSITION
	MOVEI	T2,0		; Yes, clear space count
ALTCS1: TLZN	FL2,L2.SSI	; Suppress incrementing?
	IBP	T1		; No, increment pointer
	LDB	T3,T1		; Get a character
	CAIL	T3,140		; Lower case
	TDZ	T3,AEXACF	; Conditionally convert
	CAIE	T3,15		; Done if end of line
	CAMN	T3,C		; Or a match
	POPJ	P,
	AOJA	T2,ALTCS1	; Else keep count and keep looking
 
ALTCMP: MOVE	T3,[POINT 7,AFSBUF##]; Pointer to alter search buf
	MOVE	T4,ALTP 	; Copy of current pointer
	LDB	C,T4		; Current source character
ALTCM1:	CAIL	C,140
	TDZ	C,AEXACF
	ILDB	T1,T3		; Next target character
	JUMPE	T1,CPOPJ1	; Done, it matched!
	CAIL	T1,140		; Lower case?
	TDZ	T1,AEXACF##	; Conditionally fix
	CAIE	C,(T1)		; Do they match
	POPJ	P,		; No match this time
	ILDB	C,T4		; Get next source character
	JRST	ALTCM1		; And compare it too
 
	SUBTTL	Commands that Exit the Line:  Q, ^U, E, <CR>, <LF> and N


; The Q command
 
ALTALT: OFFRUB
	SKIPE	VT52FL		; On a display?
	PUSHJ	P,[PUSHJ P,ALTBOL ; Position to front of line
		XCT TMFCTE	; Clear rest of screen
		PUSHJ	P,SETALT	; Setup unmodified line
		TLZ	FL,NEGF		; And let ALTTAB go forward
		PJRST	ALTTAB]
	SKIPE	ALTFLG
	PUSHJ	P,FINDN##
	ONECHO
	JRST	T1POPJ##


; The N command--advance to next or previous line

ALTNXL:	PUSH	P,T2		; Save count
	PUSH	P,[0]		; Save a zero as a flag
	TLZE	FL,NEGF		; Clear this before ALTFN
	SETOM	(P)		; Note that command is negative
	PUSHJ	P,[PUSHJ P,ALTFN] ; End this line.  ALTFN prunes PDL.
	  JFCL			; Ignore skip return
	PUSHJ	P,AINSED	; Insert corrected line
	SKIPE	(P)		; Negative argument?
	OUTSTR	[ASCIZ/ 
/]				; Blank line, even if TTY NO BLANKS
ALTNX1:	SKIPN	(P)		; Forward?
	PUSHJ	P,FINDN		; Find next
	SKIPE	(P)		; Backward?
	PUSHJ	P,FINDB		; Find previous
	JUMPE	T1,ALTNLN	; If no next line
	CAMN	T1,PGMK		; Page mark?
	JRST	ALTNPG		; No next line
	PUSHJ	P,SETALT	; Setup next line for alter
	POP	P,T2		; Get negative flag
	SKIPE	T2		; Was NEGF set?
	TLO	FL,NEGF		; Yes, relight it in the flag register
	POP	P,T2		; Restore the count
	MOVE	T1,LIBUF	; New line number
	MOVEM	T1,CLN		; Make this current now
;	MOVEM	T1,HILN		; Redefine top of range
	MOVE	T1,CPG		; Current page
	MOVEM	T1,CPGL		; Make it the current logical page
;	MOVEM	T1,HIPG		; ..and page at top of range
	SOJG	T2,ALTNXL
	POPJ	P,		; Continue with this stuff

ALTNLN:	RERROR	NLN
ALTNL0:	SKIPN	(P)		; Negative
	PUSHJ	P,FINDB		; Backup to previous
	CAME	T1,PGMK		; Is this a page mark?
	JRST	ALTNL1		; No
	MOVE	T2,CPG		; Get the current page
	SKIPE	(P)		; Going backward?
	AOS	T2		; Yes, off by one
	PUSHJ	P,PGPRN##	; Retype
	JRST	ALTNL0		; Go look again

ALTNL1:	ADJSP	P,-1
	POP	P,T2
	PJRST	SETALT
 
ALTNPG:	MOVE	T2,CPG		; Current page
	SKIPN	(P)		; If negative
	AOS	T2		; Do not adjust
	PUSHJ	P,PGPRN##	; Type it so he knows
	JRST	ALTNX1

; The CR command
 
ALTFNZ:	PUSHJ	P,GNCH1
	LDB	C,ALTP		; Current character
	CAIN	C,15		; End of line?
	MOVMS	XCMDF		; Indicate CR end
	PJRST	ALTFN
; 
; Here if <LF> was typed without CR
; 
ALTEX:	SKIPN	VT52FL		; On a display?
	TRO	FL2,SUPN	; No, E means suppress typeout
ALTFN:	PUSHJ	P,V52TFR	; Make sure display is okay.
	SKIPE	VT52FL		; On a display?
	TRO	FL2,SUPN	; Yes, suppress unecessary typeout
	PUSHJ	P,CSRPOS	; Get cursor position
	PUSHJ	P,FIXWPC	; Fix wrap count for wrap waiting
	MOVE	T5,WRPCNT	; Save count of wraps
	PUSHJ	P,ALTTAB	; Space to end of line
	TRZ	FL2,SUPN	; Clear suppress flag
	SKIPN	VT52FL		; VT52?
	JRST	ALTFNX		; No, line was just typed
	PUSHJ	P,PRNTSZ	; Get the print size of the line
	PUSHJ	P,FIXWPC	; Fix wrap count for wrap waiting
	SUB	T5,WRPCNT	; Difference in line position
LFLUP:	JUMPGE	T5,ALTFNX	; If none
	OUTCHR	[12]		; Extra line feed
	AOJA	T5,LFLUP	; Keep checking

ALTFNX:	PUSHJ	P,ALTFNL	; Finish the line
	JRST	T1PPJ1##	; Prune PDL and give skip return

; Routine to finish up line currently being altered and setup NCNT
; for INSED.

ALTFNL:	OCRLF
	ONECHO			; Get out of non-duplex mode
ALTFN1: ILDB	C,ALTP		; Look one chr over
	CAIE	C,12		; This should be the line feed
	NERROR	ILFMT		; Something is wrong
	MOVEI	C,0		; Zero remainder of line
ALTFN2: TLNN	ALTP,760000	; All done?
	JRST	ALTFN3		; Yes
	IDPB	C,ALTP		; No, put in another 0
	JRST	ALTFN2
ALTFN3: SUBI	ALTP,LIBUF-1	; Get size of new line
	HRRZM	ALTP,NCNT	; And save for insed
	POPJ	P,
 
; The ^U command
 
ALTCU:	SKIPE	VT52FL
	JRST	[PUSHJ	P,ALTBOL
		 XCT TMFCTE ; Clear rest of screen
		 SETOM  PRVSIZ	; For retype of whole line
		 PJRST SETALT]
	OFFRUB
	OUTSTR	[ASCIZ /^U
/]
	PJRST	SETALT		; Go restart line and forget edit so far
 
	SUBTTL	The \ and / commands


; THE / COMMAND -- Transpose the next two letters
 
; THE \ COMMAND  (Same as -/)
 
ALTBSL: TLC	FL,NEGF 	; Complement neg flag and do / command
; 
ALTSL:	TLNE	FL,NEGF 	; Backward?
	JRST	ALTSLB		; Backup a couple
ALTSL1: LDB	T1,ALTP 	; Next character in buffer
	MOVE	T2,ALTP 	; Save its position
	ILDB	C,ALTP		; and the next one after that
	CAIE	T1,15		; Is it carriage return?
	CAIN	C,15		; Same
	JRST	ALTSL2		; Command not valid at end of line
	CAIL	C,40		; Special?
	CAIGE	T1,40		; (either one)
	SETOM	CHGLNF		; Yes, line size might change
	OFFRUB
	PUSHJ	P,OCHR		; Output 2nd character
	DPB	C,T2		; And make it the first
	MOVE	C,T1		; Now for the second
	PUSHJ	P,OCHR		; Output it too
	DPB	C,ALTP		; Add first character to buffer
	IBP	ALTP		; And advance pointer
	PUSHJ	P,FORCE 	; Make them visible
	AOS	ALTCNT
	AOS	ALTCNT		; Increment alter count by two
	POPJ	P,		; And return
; 
ALTSLB: MOVEI	T2,2		; Count for backspace
	PUSHJ	P,ALT.SP 	; Space back two
	JRST	ALTSL1		; Join common processing 
; 
ALTSL2: MOVE	ALTP,T2 	; Restore pointer
	ADJSP	P,-1		; Pop junk off the PDL
	JRST	ALTBEL		; Signal error
	SUBTTL	The J command.  Join to Next Line

; The J command
 
AJOIN:	OFFRUB
	SETOM	PRVSIZ		; Zap this, new line configuration
	TLNE	FL,NEGF		; Backward?
	JRST	MJOIN		; This is special
AJOIN0:	PUSH	P,T2
	PUSHJ	P,FINDN 	; Go see if next line is really there
	CAME	T1,PGMK
	SKIPN	T1
	JRST   [RERROR  NNN
		PUSHJ	P,FINDB	; Refind the line
		POP	P,T2
		JRST	RPRINT]
	PUSHJ	P,GETLTH##	; Get line length, make sure it in core
	PUSH	P,T1		; Save length for later
	PUSHJ	P,ALTTAB	; Space to end of line
	MOVEI	T2,1(PNTR)	; Point past line number
	HRLI	T2,(POINT 7,0,6); Point to first character
	MOVEI	T3,MXWPL*5-6	; Maximum length
	SUB	T3,ALTCNT	; Minus what we already have
	PUSH	P,ALTP		; Save pointer to this line
JOIN1:	ILDB	C,T2		; Fetch a character
	DPB	C,ALTP		; Store the character in the line
	IBP	ALTP		; Advance the pointer
	CAIN	C,12		; Line feed?
	JRST	JOIN2		; Yes, end of line
	SOJG	T3,JOIN1	; Loop to end of line
	MOVE	ALTP,(P)	; Restore ALTP
	MOVEI	C,15		; Line feed
	IDPB	C,ALTP		; Store
	MOVEI	C,12		; Line feed
	IDPB	C,ALTP		; Store
	RERROR	LTL		; Line too long
	POP	P,ALTP
	PUSHJ	P,FINDB
JOINER:	POP	P,T1
JOINR1:	POP	P,T2
	PJRST	RPRINT		; Re-type it

JOIN2:	PUSHJ	P,INSTRZ	; Add trailing zeros
	POP	P,ALTP		; Restore ALTP
	PUSHJ	P,FINDB		; And back to old line
	POP	P,T1		; Restore line length
	ADDM	T1,OCNT		; Increase words to delete
	PUSHJ	P,INSJLN	; Insert the joined lines
	POP	P,T2		; Restore remaining count
	SOJG	T2,AJOIN0	; Join as many as he wants
	PJRST	V52TPN		; Then type line on VT52
	SUBTTL	The -J command -- Join to Previous Line

; Here for -J command.

MJOIN:	PUSH	P,T2
	PUSHJ	P,BUFLEN	; Get length of line
	PUSH	P,T1		; Save word count
	PUSHJ	P,FINDB		; Find the previous line
	CAME	T1,PGMK
	SKIPN	T1
	JRST	[RERROR NLN	; No such line
		 CAMN   PNTR,BUFFIR
		 PUSHJ	P,FINDN
		 JRST   JOINER]
	PUSHJ	P,GETLTH	; Get length of this one
	MOVE	T2,T1		; Make a copy
	ADD	T2,(P)		; Compute sum
	POP	P,(P)
	CAILE	T2,MXWPL+1	; See if it will fit
	JRST	[RERROR LTL
		 CAMN	PNTR,BUFFIR
		 PUSHJ	P,FINDN
		 JRST	JOINR1]
	ADDM	T1,OCNT		; Increment count of words to delete
	MOVSI	T1,-MXWPL	; Max line length
	SETZM	LIBUF2(T1)	; Clear a word
	AOBJN	T1,.-1		; Loop over whole buffer
	SKIPE	VT52FL		; On a display?
	PUSHJ	P,ALTBOL	; Go to beginning of the line
	MOVE	T4,[POINT 7,LIBUF2]
	MOVE	T2,[POINT 7,LIBUF+1,6]	; Point to data
; 
MJOIN1:	ILDB	C,T2		; Get a character from current line
	IDPB	C,T4		; Stash in second line buffer
	CAIE	C,12		; End yet?
	JRST	MJOIN1		; No
	PUSHJ	P,LOADCL##	; Load that line
	MOVE	ALTP,[POINT 7,LIBUF+1,6]	; Point to that data
	SETZM	ALTCNT		; Set count at beginning
MJOIN3:	ILDB	C,ALTP		; Get a character
	CAIN	C,15		; Is it end of text line
	JRST	MJOIN4		; Yes
	AOS	T2,ALTCNT	; Increment count
	JRST	MJOIN3		; Loop over whole line

MJOIN4:	MOVE	T3,[POINT 7,LIBUF2]	; Point to old line
MJOIN5:	ILDB	C,T3		; Fetch a character
	DPB	C,ALTP		; Store this one next
	IBP	ALTP		; Then increment the pointer
	CAIE	C,12		; End of line yet?
	JRST	MJOIN5		; No, keep looking
	PUSHJ	P,INSTRZ	; Add trailing zeros
	TLZ	FL,NEGF		; Clear neg-flag
	PUSHJ	P,INSJLN	; Insert the line into the buffer
	PUSHJ	P,RPRINT
	POP	P,T2		; Restore this
	SOJG	T2,MJOIN
	POPJ	P,
	SUBTTL	Support Routines for J and -J Commands


; Subroutine to compute the length of the line in LIBUF
; 
BUFLEN:	MOVE	T2,[POINT 7,LIBUF+1,6]	; First character
	MOVEI	T1,7		; Minimum length
BUFLN1:	ILDB	C,T2		; Character
	CAIE	C,12		; End of line?
	AOJA	T1,BUFLN1	; Increment count and keep looking
	ADDI	T1,4		; Round to whole words
	IDIVI	T1,5		; Compute words required
	POPJ	P,


; Subroutine to install a joined line
; Call
; New line in LIBUF, OCNT setup with length of old lines
; Returns with OCNT set to old value of NCNT, line in buffer
; 
INSJLN:	PUSHJ	P,BUFLEN	; Words in joined line
	MOVEM	T1,NCNT		; Insert that many
	PUSHJ	P,INSED		; Install the new line
	MOVE	T1,NCNT
	MOVEM	T1,OCNT		; Make that the old count
	POPJ	P,


; Routine to add trailing zeros to the last word in the line
; Call with ALTP setup pointing to first character after the LF

INSTRZ:	MOVEI	C,0		; Get a zero
INSTR1:	DPB	C,ALTP		; Add one
	TRNN	ALTP,760000	; At end of word?
	POPJ	P,		; Yes, done
	IBP	ALTP		; No, advance one character
	JRST	INSTR1		; And clear next
	SUBTTL	The W Command -- Space Over by Words

.ALTWD: MOVEM	T1,ALTWPR	; Process to perform for word stuff
	OFFRUB
; 
ALTWD1: PUSH	P,ALTP		; Save pointer
	TLNN	FL,NEGF 	; Going backward
	TDZA	T1,T1		; Set T1 to zero and skip
	SETO	T1,		; Set T1 to -1
	PUSH	P,T1		; Sum of characters seen in word skip
	PUSH	P,T2		; Save count if any
; 
ALTWD2: TLNE	FL,NEGF 	; If forward
	JRST	ALTWD3		; If going backward
; 
	PUSHJ	P,ALTWS 	; Skip over word
	JRST	ALTWD4		; 
; 
ALTWD3: PUSHJ	P,ALTWBS	; Move to beginning of previous word
	AOS	-1(P)		; Fudge factor
; 
ALTWD4: ANDI	T2,-1		; Clr flag in case
	ADDM	T2,-1(P)	; Tally spacing count
	SOSLE	(P)		; Count down number of words
	JRST	ALTWD2		; Loop again if more to do
; 
	POP	P,(P)		; Clear counter from stack
	POP	P,T2		; Get length of words skipped
	POP	P,ALTP
	PJRST	@ALTWPR 	; Do specified operation
 
; Routine to skip over next word
 
ALTWS:	HRROI	T2,0		; Set flg and count
	LDB	T3,ALTP 	; Get current character
	JRST	.+2		; Skip increment
ALTWS1: ILDB	T3,ALTP 	; Get a character
	CAIN	T3,15		; Done if end of line
ALTWS2: POPJ	P,		; Quit
	MOVE	T3,CTBL(T3)	; Fetch character table entry
	JUMPE	T3,ALTWS4	; Skip blanks etc...
	ANDI	T2,-1		; Clr flag
	JUMPG	T3,ALTWS3	; Skip letters & numbers
	TRNN	FL2,QSEPF	; Separators
	TRNN	T3,NSEPF	; Today
	JRST	IPOPJ		; Real break - quit!
ALTWS3: AOJA	T2,ALTWS1	; Keep count and continue
ALTWS4: JUMPL	T2,ALTWS3	; First blnks
	AOS	T2
ALTWS5: ILDB	T3,ALTP
	CAIE	T3,15		; Quit on CR
	SKIPE	CTBL(T3)	; Or first non-blank
	POPJ	P,
	AOJA	T2,ALTWS5
 
IPOPJ:	TRNE	T2,777777	; Test count for zero
	POPJ	P,		; Non-zero:  just return
	IBP	ALTP		; Increment alter pointer
	AOJA	T2,CPOPJ	; Increment count and return
	SUBTTL	The C Command

; The C command
 
ALTCN:	OFFRUB
	TLNN	FL,NEGF 	; Going forward?
	JRST	ALTCN2
	PUSH	P,T2		; Save count
	PUSHJ	P,ALT.SP 	; Backup
	EXCH	T2,(P)
	SUB	T2,(P)
	POP	P,T1
ALTCN2: LDB	C,ALTP		; At end of line?
	CAIN	C,15
	POPJ	P,		; Yes, stop
	CAIGE	C," "		; Normal graphic character?
	SETOM	CHGLNF		; No, line size may change then
ALTCN1: PUSHJ	P,AGNCH1	; Get a character
	CAIE	C,177		; Do not let him insert a rubout
	CAIN	C,12		; Ignore carriage return
	JRST	ALTCN1
	CAIE	C,33		; Stop on altmode and line feed
	CAIN	C,15
	POPJ	P,
	CAIGE	C," "		; Normal graphic character?
	SETOM	CHGLNF		; No, line size may change then
	PUSHJ	P,FOCHR##	; Duplex character
	DPB	C,ALTP		; Replace it
	IBP	ALTP		; Advance pointer
	AOS	ALTCNT		; And count
	PUSHJ	P,V52TPN	; Clean up the line
	SETZM	CHGLNF		; Clear flag if set
	SOJG	T2,ALTCN2	; Continue
	POPJ	P,
	SUBTTL	Spacing Routines 

; Subroutine to move alter pointer without changing display
; Call like ALT.SP
 
ALTSSP: TLNE	FL,NEGF 	; Silent Space backward?
	JRST	ALTSBS		; Do silent back space then
ALTSS1: LDB	C,ALTP		; Fetch a character
	CAIN	C,15		; See if it is a CR
	POPJ	P,		; It is, so stop
	IBP	ALTP		; No, increment pointer
	AOS	ALTCNT		;  and count
	SOJG	T2,ALTSS1	; Loop until space request satisfied
	POPJ	P,		; Then return
 
; Here for silent space backward
 
ALTSBS: PUSHJ	P,ALTBAK	; Backup
	JUMPE	T3,CPOPJ	; Stop if beginning of line
	SOS	ALTCNT		; Decrement counter
	SOJG	T2,ALTSBS	; Loop until request satisfied
	POPJ	P,		; Then return
 
; The backspace command
 
ALTBS:	PUSHJ	P,ALTBAK	; Get previous char
	JUMPE	T3,ALTCBS	; Jump if done
	ONRUB
	SOS	ALTCNT		; Decrease count
	MOVE	C,T3
	SKIPN	DPYFLG		; Non display device?
	PUSHJ	P,OCHR
	SKIPE	DPYFLG		; On a display?
	PUSHJ	P,RUBAK 	; Backspace the real way
	SOJG	T2,ALTBS	; More, more
	PJRST	FORCE

ALTCBS: PUSHJ	P,FORCE 	; Finish buffer
	SKIPN	DPYFLG		; Just return if on display
	JRST	ALTCB1		; Normal mode, output SN.
	SETZ	T1,		; Clear T1 to avoid ill mem ref
	POPJ	P,

PRNTSN: PUSHJ	P,FORCE 	; Finish print line
ALTCB1: OFFRUB			; No more rub
	SKIPN	VT52FL
	OCRLF
	SKIPE	VT52FL
	OUTCHR	[15]
	MOVE	T1,LIBUF	; Also print seq num
	PJRST	OUTSN
 
; The L command
 
ALTLN:	SKIPE	VT52FL		; On a fancy display?
	JRST	[PUSHJ P,ALTBOL	; Position to front
		 JRST ALTLNN]	; Then re-type sequence number
	MOVEI	T2,1000 	; Finish printing the line
	PUSHJ	P,ALT.SP
ALTLNN: MOVE	ALTP,[POINT 7,LIBUF+1,13]; Pointer to start
	SETZM	ALTCNT		; Reset count
	PJRST	PRNTSN		; And reprint line number
 
; Common routines to backup in a line
 
ALTBAK: CAMN	ALTP,[POINT 7,LIBUF+1,13]
	PJRST	ALTRTZ		; Return zero if at beginning
	ADD	ALTP,[POINT 0,0,28]
	TLNE	ALTP,(<1B0>)	; Check word overflow
	SUB	ALTP,[POINT 0,1,0]
	LDB	T3,ALTP 	; Get char
	POPJ	P,
; 
ALTRTZ: MOVEI	T3,0		; Return 0
	POPJ	P,
 
	SUBTTL	Backward Deletion Routine

; Routine to do backwards deletion
 
ALTBDL: MOVEM	ALTP,SVALTP	; Save pntr
ALTBD1: PUSHJ	P,ALTBAK	; Back a char
	JUMPE	T3,ALTBD2	; Done if no more
	SOS	ALTCNT		; Decrement count
	MOVE	C,T3		; For printing
	PUSHJ	P,ALTDPN
	SOJG	T2,ALTBD1
ALTBD2: PUSHJ	P,FORCE 	; Force printing
	PUSH	P,ALTP		; Save new pntr
	MOVE	T3,SVALTP	; Get set to move line
ALTBD3: LDB	C,T3
	DPB	C,ALTP		; Move char
	JUMPE	C,APOPJ		; Done if zero
	IBP	T3		; Advance pntrs
	IBP	ALTP
	JRST	ALTBD3

	SUBTTL	Display Backspace Handler

; Here to perform a terminal cursor backspace
 
RUBAK:: PUSH	P,T2		; Save accumulator T2
	PUSH	P,T4		; and T4
	PUSH	P,C		; Save character argument
	PUSHJ	P,CSRPOS	; Get current position
	POP	P,C		; Character to delete
	PUSH	P,T4		; Save length so far
	JSP	T1,RBC		; Compute length with deleted character
	POP	P,T2		; Get old length
	SKIPE	ALTCNT		; If at start of line
	JUMPE	T2,REITR1	; If will be at end of screen
	JUMPE	T4,REITER	; If at edge of screen
	SUB	T4,T2		; Compute displacement
	SETZ	T1,		; In case length is zero
	JUMPE	T4,RPOPJ	; If net displacement is zero
	MOVEI	T1,[BYTE (7)" ","H"-100,0,0,0]; Normal eraser
	CAIN	T4,2		; Skip if not a control character
	MOVEI	T1,[BYTE (7)" "," ","H"-100,"H"-100,0]; Special eraser
	PUSH	P,T2		; SAVE AN AC
	MOVE	T2,BACCHR##	; GET BACKSPACE CHAR
	CAIN	T2,"H"-100	; BACKSPACE?
	  JRST	TEMP.X		; YES, ALL SET
	MOVEI	T1,[BYTE (7) " ",32,0,0,0]; NO, ASSUME ^\
	CAIN	T4,2		; SKIP IF NOT A CONTROL CHARACTER
	MOVEI	T1,[BYTE (7) " "," ",32,32,0]; SPECIAL ERASER
TEMP.X:	POP	P,T2		; GET BACK THE AC
	MOVE	C,BACCHR##	; Code for backspace
	SKIPG	T4		; If move will be backward
	MOVEI	C," "		; Blank moves cursor forward
	MOVM	T4,T4		; And insure count is positive
	PUSHJ	P,OCHR		; Output a spacer
	SOJG	T4,.-1		; Back over the character
RPOPJ:	POP	P,T4		; restore
T2POPJ::POP	P,T2
	POPJ	P,
; 
; Here to retype the line (wraparound condition)

REITER:	SOS	WRPCNT
REITR1:	PUSHJ	P,UPCRSR	; Move up if wanted
	MOVE	T1,VT52FL
	AND	T1,DELBAK
	SKIPE	T1
	XCT	TMFCTE		; Clear rest of screen
	MOVE	ALTP,[POINT 7,LIBUF+1,13]; Start of buffer
	PUSHJ	P,FORCE 	; Clear any rubouts
	MOVE	T1,LIBUF	; Holds the current line number
	PUSHJ	P,PRNTSN	; Output the line number
	MOVE	T2,ALTCNT	; Number of characters in buffer
	SETZM	ALTCNT		; Reset to zero
	PUSH	P,FL		; Save flags
	TLZ	FL,NEGF 	; NEGF must not be set to do spacing
	PUSHJ	P,ALT.SP 	; Respace the line
	POP	P,FL		; Restore the flags the way the were
	SETZ	T1,0		; Clear eraser
	JRST	RPOPJ		; Return
;CSRPOS -- Routine to return the relative cursor position
;
;Call with
;	PUSHJ	P,CSRPOS
;	<Return here with position in T4, wrap count in WRPCNT>
;Uses T1, T2, T4 and C

CSRPOS:	MOVE	T2,[POINT 7,LIBUF+1,6]; Initialize pointer a line start
	LDB	T4,PMTSZP##	; Get prompt length
	SETZM	WRPCNT##	; Zero the wraparound count
	JSP	T1,.+1		; Set up T1 for later returns
RBK0:	ILDB	C,T2		; Next character from buffer
	CAME	T2,ALTP 	; Up to current position yet
	JRST	RBC##		; Compute length of this character
	POPJ	P,		; Return, size is in T4
 
; Routine to do backwards search
 
ALTBCS: PUSH	P,ALTP		; Save pntr
	ADDI	T2,1		; Advance pointer
	PUSHJ	P,ALTBAK	; Don't look at first character
ALTBC1: PUSHJ	P,ALTBAK	; Prev char
	JUMPE	T3,APOPJ	; End of line
	CAIL	T3,140
	TDZ	T3,AEXACF
	CAME	T3,C		; Match?
	AOJA	T2,ALTBC1	; No: count and continue
	JRST	APOPJ## 	; Restore ALTP and return


; Routine to do a backward word search

ALTWBS:	HRROI	T2,0		; Set flag and count
ALTWB1: PUSHJ	P,ALTBAK	; Get the previous character
	JUMPE	T3,CPOPJ	; and return if at beginning of line
	MOVE	T3,CTBL(T3)	; Look up character in the char table
	JUMPE	T3,ALTWB3	; Skip over spaces and so forth
	ANDI	T2,-1		; and signal that we found something
	JUMPG	T3,ALTWB2	; Skip letters and numbers
	TRNN	FL2,QSEPF	; 
	TRNN	T3,NSEPF	; Seperator flag set?
	POPJ	P,		; Restore ALTP and return
ALTWB2: AOJA	T2,ALTWB1	; Increment character count and loop 
ALTWB3: JUMPGE	T2,CPOPJ	; If not first blanks
	AOJA	T2,ALTWB1	; Continue looking
	SUBTTL	Support Routines for Fancy Display Version of ALTER Mode

; Routine to re-type line after a control-C
; Call with
;	PUSHJ	P,CCRTYP
;	<Return here>

CCRTYP::SKIPN	NEWALT##	;NEW ALTER?
	 JRST	$CRTYP##	;NO
	MOVEI	T1,0		; Be sure tabs are clear
	PUSHJ	P,SETTAB##	; ..
	PUSHJ	P,RPRINT	; Re-type the first part
	SETOM	PRVSIZ		; Force typeout
	PJRST	V52TPN		; Go retype the line without delay

; V52TYP -- Routine to retype the line currently being altered
; 
; This routine checks VT52FL so it can be used even if this flag has
; not been selected.  Ensures that the current screen image matches
; the internal line image.  The refresh is not performed if there
; is a character waiting to be typed, or the specified refresh delay
; has not elapsed. (/REFDLY).
;
; Call V52TPN if the line should be refreshed immediately without
; waiting for REFDLY milliseconds.

V52TPI:	SKIPE	V52SPF##	; Suppressing intermediate typeout?
	POPJ	P,		; Yes, return
	PUSHJ	P,V52TYP	; Type the line again
	SETZM	CHGLNF		; Clear typeout flag
	POPJ	P,		; And return

V52TYP:	SKIPE	T1,REFDLY	; Does he want a delay (slow terminal)
	HIBER	T1,		; Yes wait for time or next character
	  JFCL			; No HIBER or no wait
V52TPN:	SKIPLE	T1,TSPEED	; GET USER TERMINAL SPEED
	 CAML	T1,BAUD		; FAST ENOUGH FOR UPDATE?
	  CAIA			; YES
	   POPJ P,		; NO--DONT DO IT
V52TPP:	SKPINC			; Is he ahead?
	  SKIPN	VT52FL		; Or not on a VT52?
	POPJ	P,		; Yes, skip this stuff then
V52TFR:	TRNE	FL2,SUPN	; Suppressing?
	POPJ	P,		; Yes, no typeout
	LDB	C,ALTP		; Current character
	CAIN	C,15		; End of line
	SKIPN	DELBAK		; and deleting backward
	CAIA
	PJRST	SETPVS		; Yes, line is okay.  Update PRVSIZ.
	PUSH	P,FL		; Save flags
	PUSH	P,T2		; and count
	TLZ	FL,NEGF		; Always type forward
				 CONT.
; 
;  Get the length of the new line it can be compared with the old
; 
	PUSHJ	P,PRNSZC	; Get display length in characters
	MOVE	T4,T1		; Save in T4
	CAME	T4,PRVSIZ##	; Same as last time?
	JRST	V52TP2		; No
	SKIPN	CHGLNF		; Does this command change line size?
	JRST	V52TP4		; No, just return after restoring AC's
; 
;  We must have done a insert, delete or change.  Since the whole
;  line is the same length, there must be a tab taking up the
;  difference.  Type all characters until we find a tab or EOL.
; 
	PUSH	P,ALTP		; Save the pointer
CHKTB1:	LDB	C,ALTP		; Load next character
	PUSHJ	P,OCHR##	; No, type it
	CAIE	C,15		; End of line
	CAIN	C,"I"-100	; or tab
	JRST	CHKTB2		; If yes
	IBP	ALTP		; Increment the pointer
	JRST	CHKTB1		; And type till we find a tab

CHKTB2:	PUSH	P,T4		; Save line size
	PUSHJ	P,CSRPOS	; Get cursor position
	PUSHJ	P,FIXWPC	; Fix line wrap count
	POP	P,T4		; Get T4 back
	POP	P,ALTP		; and the pointer
	JRST	V52TP6		; Go retype the first part of the line
				 CONT.
;  Here if the line size is different than it was last time
; 
V52TP2:	EXCH	T4,PRVSIZ	; Get old size, save new
	JUMPL	T4,V52TP5	; If explicit request to retype the line
	SUB	T4,PRVSIZ	; Compute difference
	JUMPG	T4,V52TP5	; If new size smaller
	LDB	C,ALTP		; Look at current character
	CAIN	C,15		; Is it a carriage return
	JRST	V52TP4		; If line grew at EOL, screen still OK
V52TP5:	PUSH	P,ALTCNT	; Save count
	PUSHJ	P,ALTTAB	; Print rest of the line
	POP	P,ALTCNT	; Restore the alter character count
	MOVEI	C," "		; Blank to use as eraser
	SKIPG	T4		; Line shrank?
	MOVEI	T4,0		; No
	SKIPE	T1,T4		; Save difference
ERSLUP:	PUSHJ	P,OCHR		; Type a blank
	SOJG	T4,ERSLUP	; Over and over till done
	ADD	T1,PRVSIZ	; Get previous size
	SUBI	T1,1		; End of line causes special problems
	IDIV	T1,LINEW	; Compute number of wraps
	MOVEM	T1,WRPCNT	; and set it up
V52TP6:	PUSHJ	P,FORCE##	; Force pending output
	PUSHJ	P,UPCRSR	; Move cursor up if needed
	PUSHJ	P,RPRINT	; Reprint the first part of the line
V52TP4:	POP	P,T2		; Restore the count
	POP	P,FL		; and the flags
	POPJ	P,		; Finally, return
; UPCRSR -- Routine to move the cursor after backspacing through a line
;	   break.
; Called after multiple calls to RBC have setup the line break count
; in WRPCNT.  May be called even if fancy display mode is not selected
; since this routine is a no-op if VT52FL is not set.

UPCRSR::SKIPE	VT52FL		; Not unless desired
	SKIPG	T1,WRPCNT	; or needed
	POPJ	P,
UPLUP:	XCT	TMFCUP		; Up one line
	SOJG	T1,UPLUP
	POPJ	P,		; And return


;SETPVS -- Routine to setup the correct value of PRVSIZ
;Call
;	PUSHJ	P,SETPVS
;	<Return here with character size in T1>
;Uses T1, C

SETPVS::PUSHJ	P,PRNSZC	; Get size of line in characters
	MOVEM	T1,PRVSIZ	; Save as previous size
	POPJ	P,		; Return


;PRNSZC -- Get print size in characters
;
;Call
;	PUSHJ	P,PRNSZC
;	<Return here with character count in T1>
;Uses T1, C

PRNSZC:	PUSHJ	P,SAVR##	; Preserve T3-T5
	PUSH	P,T2		; Save T2
	PUSHJ	P,PRNTSZ	; Measure print size of line
	MOVE	T1,WRPCNT	; Get number of whole lines
	IMUL	T1,LINEW	; Times width of one line
	ADD	T1,T4		; Plus characters on last line
	JRST	T2POPJ		; Restore T2 and return


;PRNTSZ -- Get the print size of the current line
;
;Call
;	PUSHJ	P,PRNTSZ
;	<Size in T4, line count in WRPCNT>
;Uses C, T1, T2, T4

PRNTSZ:	SETZB	T4,WRPCNT	; Size counter
	MOVE	T2,[POINT 7,LIBUF+1,6]
	TLNE	FL2,LNUMF	; Printing line numbers?
	MOVEI	T4,^D8		; If yes, line number is 1 tab stop
CNTLUP:	ILDB	C,T2		; Get a character
	CAIN	C,15		; End of line?
	POPJ	P,
	JSP	T1,RBC##	; Size chacacter, return through T1
	JRST	CNTLUP		; Loop over whole line

;FIXWPC -- Subroutine to adjust for wrap waiting
;
;Needed because the monitor leave the cursor at end of line even though
;it logically is at the beginning of the next line.
;
;Call with T4 and WRPCNT set up by RBC
;	PUSHJ	P,FIXWPC
;	<return here with WRPCNT possible decremented by one>

FIXWPC::SKIPN	T4		; Start of new line?
	SKIPN	WRPCNT		; With non-zero wrap count?
	POPJ	P,		; Not waiting to wraparound
	SOS	WRPCNT		; Account for one wrap short
	POPJ	P,

	XLIST
	LIT
	LIST
	RELOC	0

MODE:	BLOCK	1
ALTCXT:	BLOCK	1
ALTFXT:	BLOCK	1	

ACPTR:	BLOCK	1
ACBUF:	BLOCK	<ACLEN==^D200>/5+1
CSW::	BLOCK	1
	END