.LIST	TTM ; V4A Edit #294 17-Jun-85 Autor: -tf-  File: CLE.MAC
;
	.NLIST	MEB,BEX,SYM,BIN
	.ENABLE	LC
	.SBTTL	CLE - Installation
;
	.TITLE	CLE	MCR-Command-Editor
;
;	First Idea:	D. Sponza (YU)  06-OCT-81
;	Modifications:	-tf-            Nov-81 ... Dec-82 (MCE  RSX V3.2)
;					Jan-83            (CLE  RSX V4.0)
;					Jun-85 Angleichung an VMS RT SHARE
;
;
;			Eidg. Techn. Hochschule
;			Hybridrechenzentrum AIE
;			F. Kuster, dipl. El'Ing.
;			Gloriastr. 35,  ETZ J96
;			CH-8092  Z u e r i c h
;
;                       Tel. 01 - 256 5336 or 5312 or 5325
;
;
;
; INSTALLATION
; ------------
;
; see CLE.HLP
;
; If you change program-code please add some suffix to the
; version-number (e.g. V2D-b)
;
;

	.SBTTL CLE - "fixed commands", Macros, Konstanten, Variablen
;
;   ";*" denotes optional statements
;
;
CLISUP=0	;* CLI support
;CLISUP=-1	;* no CLI support, or RSX V3.2
;
;=============================================================================
;
; Fixed Commands  (DO NOT forget to >PIP all:[*,*]CLECOMTAB.DAT;*/DElete !!)
; --------------  (Please update CLE.HLP)
;
EXECUT=0	; EXECUTE IMMEDIATE
EDIT=1		; EV. EDIT FIRST
;
CTLV:	.ASCIZ	<EXECUT>\MUNG LB:[17,1]VITE\	; START YOUR FAVORITE EDITOR
;*CTLW:	.ASCIZ	<EDIT>\SHOW \			; SHOW
CTLY:	.ASCIZ	<EDIT>\PIP *.*/PU:2\		; PURGE
CTLTIM:	.ASCIZ	<EXECUT>\SET TERM:TI:/MCR\	; <CTRL/~> CHANGE CLI
CTLTID:	.ASCIZ	<EXECUT>\SET /DCL=TI:\		; <CTRL/~> CHANGE CLI
CTLQM:	.ASCIZ	<EXECUT>\SRD /SV/SM\		; <CTRL/?> DIRECTORY
CTLBLK:	.ASCIZ	<EDIT>\MCR \			; BLANK as first char
;
;=============================================================================
;
CTLA:	.ASCIZ	<EXECUT>\HELP /CLE\	; DO NOT CHANGE THIS COMMAND (DOKU ^A)
.EVEN
;=============================================================================
;
;
;
;
	.MCALL	QIO$S,QIOW$S,EXIT$S,SPWN$S,STSE$S,FCSMC$
.IF	EQ,CLISUP
.NLIST	LOC,SEQ
.MCALL GCII$S ; if undefined there is no CLI support, set CLISUP to -1
.LIST	LOC,SEQ
.ENDC
;
	BUFSIZ=75.	; do not change !!!!!!!!!!!!!!!!!!!!!!
	BELL=7
	BKSP=10
	LF=12
	CR=15
	ESC=33
	BLNK=40
	DEL=177
	CTLT='T&37
	CTW='W&37
;
;

BUFADR:	B0,B1,B2,B3,B4,B5,B6,B7,B8,B9
;+++++++++++++++++++++++++++++++++++++++++++++++; Begin of CLECOMTAB.DAT;1
;+++++++++++++++++++++++++++++++;
BUFFER:	.ASCII	<CR><LF>/0: /	;
B0:	.ASCIZ	\; this is a comment\ 	;
	.REPT	BUFSIZ+2-.+B0	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/1: /	;
B1:	.ASCIZ	\EDT \		;
	.REPT	BUFSIZ+2-.+B1	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/2: /	;
B2:	.ASCIZ	\PAS x,x=x\	;
	.REPT	BUFSIZ+2-.+B2	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/3: /	;
B3:	.ASCIZ	\MAC x,x/-SP=x\	;
	.REPT	BUFSIZ+2-.+B3	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/4: /	;
B4:	.ASCIZ	\TKB x=x,LB:[1,1]PASLIB/LB\ ;
	.REPT	BUFSIZ+2-.+B4	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/5: /	;
B5:	.ASCIZ	\PIP *.*/PU:2\	;
	.REPT	BUFSIZ+2-.+B5	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/6: /	;
B6:	.ASCIZ	\PIP x.x;*/SD\	;
	.REPT	BUFSIZ+2-.+B6	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/7: /	;
B7:	.ASCIZ	\FLX DY:/RT/LI\	;
	.REPT	BUFSIZ+2-.+B7	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/8: /	;
B8:	.ASCIZ	\SRD *.*\	;
	.REPT	BUFSIZ+2-.+B8	;
	.ASCII	<BLNK>		;
	.ENDR			;
	.ASCII	<CR><LF>/9: /	;
B9:	.ASCIZ	\F77 x,x/-SP=x\	;
	.REPT	BUFSIZ+2-.+B9	;
	.ASCII	<BLNK>		; the File SY:CLECOMTAB.DAT;1 contains also
	.ENDR			; the following Variables;
;-------------------------------;
.EVEN

OLD:	.REPT	BUFSIZ+2 ; (SAVED)
	.ASCII	<BLNK>
	.ENDR
	.BYTE	0	; DELIMITER FOR "GETFIFO"
LAST:	.REPT	BUFSIZ+2 ; (SAVED) FIFO
	.BYTE	0
	.ENDR
	.REPT	512.+32. ; FIFO [ this fills the file to exactly 3 blocks ]
	.BYTE	0
	.ENDR
ENDFIF=.
	.EVEN
;
FIFCNT:	0		; ANZ BEFEHLE IN FIFO (INCL OLD)
FIFOEN:	0		; FIFO ENABLE=0, DISABLE=-1
FIFOPO:	0		; POINTER TO FIFO FOR <PF1..3> (BEF-NR; 0 = OLD)
FIPOSA:	0		; SAVE FIFO-PONTER
TFIFOP:	0		; POINTER TO FIFO FOR <CTRL/T>
OLDCNT:	0		; ANZ CHAR IN OLD
LASBUF:	0		; BUFFER NUMBER 0..9  (SAVED PARAMETER)
;
;+++++++++++++++++++++++++++++++;
PROMBE:	.ASCII	<BELL>		; (LAST SAVED PARAMETER)
PROMLF:	.ASCII	<LF>		;
PROMPT:	.ASCII	<CR>\mce>\	;
NEW:	.REPT	BUFSIZ+2	;
	.ASCII	<BLNK>		;
	.ENDR			;
;-------------------------------;
; CLECOMTAB.DAT;1 ends within "NEW" and should include "PROMBE"
; If You change saved variables, delete ALL CLECOMTAB.DAT Files
;-------------------------------------------------------;
.EVEN
;

; LOCAL DATA AREA
;
	FCSMC$
	FSRSZ$ 0			; No record I/O
FDB:   	FDBDF$				; Define FDB
	FDRC$A	FD.RWM			; Record access section: BLOCK I/O
	FDBK$A	BUFFER,1024.+512.	; Block access section
	FDAT$A	,,,2			; File attribute section: 2 BLOECKE
	FDOP$A	1,DSPT			; File open section: LUN 1
;
DSPT:   .WORD	DEVL,DEV		; Dataset descriptor
	.WORD	0,0	; UICL,UIC
	.WORD	FILL,FIL
;
DEV:    .ASCII  \SY:\    		; Device specification
DEVL=.-DEV
;UIC:    .ASCII  \[66,6]\		; UIC specification
;UICL=.-UIC
FIL:    .ASCII  \CLECOMTAB.DAT;1\	; File specification
FILL=.-FIL
;
;
HELPT:	.ASCII <CR><LF><LF>\ CLE - Command Line Editor  V4A    \
	.ASCII	\- Ask for Help-Text with <CTRL/A> \<CR><LF><LF>
IDLEN=.-HELPT
ADTEXT:	.ASCIZ	\Exit !\<CR><LF><LF><BELL>
.EVEN
;

;+++++++++++++++++++++++++++++++++++++++;
ASKBUF:	.ASCII	<CR><LF><LF>		;
GEPU:	.ASCII	\Get Buffer Nr.: \	;
ASKLEN=.-ASKBUF				;
;---------------------------------------;
;
ASKFRT:	.ASCII	<CR><LF><LF>\Exec from to: \
FRTLEN=.-ASKFRT
;
;+++++++++++++++++++++++++++++++++++++++;
EMPTY:	.ASCII	\Buffer empty !\	;
BEL:	.ASCII	<BELL>			;
EMPTYL=.-EMPTY				;
BS:	.REPT	BUFSIZ+2		;
	.ASCII	<BKSP>			;
	.ENDR				;
DOT:	.ASCII	<CR><LF>/    /		;
	.REPT	BUFSIZ+2-6		;
	.BYTE	'.			;
	.ENDR				;
;---------------------------------------;
.EVEN
;
GCLI:	.BLKW	10.	; for GCII$S
IOSTAT:	.BLKW	2
;
.IF EQ,CLISUP
DEFTAS:	.RAD50	\CLI...\ ; current CLI
TASK:	.RAD50	\CLI...\ ; current CLI
.IFF
DEFTAS:	.RAD50	\MCR...\ ; for Systems without CLI-Support
TASK:	.RAD50	\MCR...\ ; for Systems without CLI-Support
.ENDC
;
CODE:	.WORD	0	; QIO-CODE
ADR:	.WORD	0	; BUFFER-ADRESS
LEN:	.WORD	0	; BUFFER-LENGH (TO OUTPUT)
CHAR:	.WORD	0	; INPUT-CHARACTER
;
FIXCMD:	.WORD	-1	; MARK FIXED COMMAND (INHIBIT FIFO)
GOTOLD:	.WORD	-1	; GOT OLD BUFFER FOR "PUT"
SAVSP:	.WORD	0	; FOR RESTART
BYE:	.WORD	-1	; BYE=0
CLIDCL:	.WORD	-1	; DCL=0, MCR=-1, other=+1
LASCMD:	.WORD	0	; LAST COMMAND
TTCHAR:	.BYTE	TC.SCP,0 ; fuer SF.GMC
;

	.SBTTL	CLE - Sprungtabelle
;
;JUMP TABLE FOR MRC COMMANDS
;
TAB:	.WORD	INSERT		; SINGLE CHR.
	.WORD	ASK		; CTRL/A
	.WORD	BEGLIN		; CTRL/B
	.WORD	CTRLC		; CTRL/C
	.WORD	CTRLD		; CTRL/D
	.WORD	ENDLIN		; CTRL/E
	.WORD	EXIT		; CTRL/F
	.WORD	GET		; CTRL/G
	.WORD	BACKSP		; BS (CTRL/H)
	.WORD	SKIP		; HT (CTRL/I)
	.WORD	LINFED		; LF (CTRL/J)
	.WORD	CTRLK		; CTRL/K
	.WORD	CTRLL		; CTRL/L
	.WORD	EXEC		; CR (CTRL/M)
	.WORD	CTRLN		; CTRL/N
	.WORD	LOOP		; CTRL/O (STOP OUTPUT TO TI:)
	.WORD	PUT		; CTRL/P
	.WORD	LOOP	; (?)	; CTRL/Q (XON)
	.WORD	CTRLR		; CTRL/R
	.WORD	LOOP	; (?)	; CTRL/S (XOFF)
	.WORD	CTRLT		; CTRL/T
	.WORD	CTRLU		; CTRL/U
	.WORD	CTRLV		; CTRL/V
	.WORD	CTRLW		; CTRL/W
	.WORD	CTRLX		; CTRL/X
	.WORD	CTRLY		; CTRL/Y
	.WORD	CTRLZ		; CTRL/Z
	.WORD	ESCAP		; ESC      ( CTRL/[ )
	.WORD	CLEBUF		; CTRL/\   ( CTRL/| )
	.WORD	CLESTA		; CTRL/]   ( CTRL/} )
	.WORD	CTRLTI		; CTRL/~   ( CTRL/` ) ( CTRL/^ )
	.WORD	CTRLQM		; CTRL/?   ( CTRL/_ )
;
;
; Gebrauch der Register:
;
; R0	Scratch Pointer
; R1	Cursor in NEW
; R2	First free byte in NEW (End of Text)
; R3	Result of READNR
; R4	Scratch
; R5	Scratch Counter
;
;

	.SBTTL	CLE - I/O and other subroutines
;
;SUBROUTINES FOR I/O
;
IO:	QIO$S	CODE,#5,#5,,#IOSTAT,,<ADR,LEN,#0>
	STSE$S	#5
	RTS	PC
;
UPD1:	TSTB	TTCHAR+1	; SCOPE ?
	BEQ	1$
	CALL	UPD2
	BEQ	1$
	MOV	#BS,ADR
	CALL	IO		; CURSOR BACK
1$:	RETURN
;
UPD2:	MOV	#IO.CCO,CODE
	MOV	R1,ADR		; CURSOR
	MOV	R2,LEN
	SUB	R1,LEN
	BEQ	1$
	CALL	IO		; WRITE REST OF LINE
1$:	RETURN
;
PRILF:	MOV	#IO.CCO,CODE
	MOV	#PROMLF,ADR
	MOV	#1,LEN
	CALL	IO
	RETURN
;
SHOW:	MOV	#IO.CCO,CODE	; TYPE ALL 10 BUFFERS
	MOV	#PROMLF,ADR
	MOV	#1,LEN
	CALL	IO
	CLR	R5
2$:	MOV	BUFADR(R5),R0	; BUFFER-ADR
	SUB	#5,R0		; BUFFER-NR
	MOV	R0,ADR
	ADD	#BUFSIZ+5,R0	; POINT TO END 0F BUFFER
1$:	CMPB	-(R0),#BLNK	; TRAILING BLANK ?
	BEQ	1$
	SUB	ADR,R0		; COMPUTE TEXT-LENGTH
	INC	R0
	MOV	R0,LEN
	CALL	IO
	ADD	#2,R5		; NEXT BUFFER
	CMP	R5,#2*10.	; LAST BUFFER ?
	BLT	2$
	RETURN
;	
;
DISPLY:	MOV	#IO.CCO,CODE	; RETYPE EDIT-BUFFER
	MOV	#PROMLF,ADR
	MOV	R2,LEN
	SUB	#PROMLF,LEN
	CALL	IO
	MOV	#BS,ADR
	MOV	R2,LEN
	SUB	R1,LEN
	BEQ	1$
	CALL	IO
1$:	RETURN
;

;
READNR:	MOV	#IO.CCO,CODE	; ASK BUFF-NR
	MOV	#ASKBUF,ADR
	MOV	#ASKLEN,LEN
	CALL	IO
;
	CLR	CHAR
	MOV	#IO.RST,CODE	; ACCEPT ONE CHR. (WITH ECHO)
	MOV	#CHAR,ADR	; NEU: EXTRABUFFER !!
	MOV	#1,LEN
	CALL	IO		; READ 1 CHAR
BUFNR:	MOVB	CHAR,R3
	SUB	#'0,R3		; NUMMERIC ?
	CMPB	R3,#9.
	BHI	1$
	MOV	R3,LASBUF	; SAVE FOR "^T", "^", "v"
	ASL	R3
	MOV	BUFADR(R3),R0	; BUFFER-ADR
	RETURN
;
1$:	MOV	#-1,R3		; ERROR
	RETURN		
;
;
ERRBEP:	MOV	#IO.CCO,CODE	; RING THE BELL
	MOV	#BEL,ADR
	MOV	#1,LEN
	CALL	IO
	RETURN
;
;
GETBUF:	CALL	CLRNEW		; INCL RESET R1 AND R2
	MOV	#BUFSIZ,R5	; BUF. LENGTH->R5
1$:	MOVB	(R0)+,(R1)+	; NEW <-- BUF
	BEQ	3$
	CMPB	-1(R1),#BLNK	; BLANK ?
	BEQ	2$
	MOV	R1,R2		; POINT BEHIND LAST
2$:	DEC	R5		; GO BACK IF NOT THE END
	BNE	1$		; GO BACK IF NOT THE END
4$:	MOV	R2,R1		; BOTH AT THE END
	RETURN
;
3$:	DEC	R1
	MOVB	#BLNK,@R1	; OVERPRINT 000 (.ASCIZ)
	MOV	R1,R2		; BOTH AT THE END
	RETURN
;
CLRNEW:	MOV	#NEW,R1		; ADR. OF THE NEW->R1
	MOV	#BUFSIZ,R5	; BUF. LENGTH->R5
1$:	MOVB	#BLNK,(R1)+	; RESET NEW TO BLANK
	DEC	R5		; GO BACK IF NOT THE END
	BNE	1$		; GO BACK IF NOT THE END
	MOV	#NEW,R1		; ADR. OF THE NEW->R1
	MOV	R1,R2		; NEW IST EMPTY
	RETURN
;

	.SBTTL	CLE - INIT-Code,  Main-Loop
;
CLESTA:	MOV	SAVSP,SP
START:	MOV	SP,SAVSP		; FOR RESTART
	OPEN$R	#FDB,,,,,,INERR		; Open file
	READ$	#FDB,,,,,,,INERR	; Read buffer from the file
	WAIT$	#FDB,,,INERR		; Synchronize I/O
	CLOSE$  #FDB,INERR		; Close file
;
INGOON:	MOV	#IO.CCO,CODE	; WRITE IDENT/HELP-TEXT
	MOV	#HELPT,ADR
	MOV	#IDLEN,LEN
	CALL	IO
;
RESTAR:	MOV	#IO.ATT,CODE	; ATTACH THE TERMINAL
	CALL	IO
	MOV	DEFTAS,TASK	; DEFAULT CLI
	MOV	DEFTAS+2,TASK+2	; DEFAULT CLI
	QIOW$S	#SF.GMC,#5,#5,,,,<#TTCHAR,#2>
;
CTRLC:	CALL	CLRNEW
	MOV	#-1,FIXCMD	; NOT FIXED COMMAND
;
.IF	EQ,CLISUP
	GCII$S	#GCLI,#10.,,,,6$	; only CLI-Name
	BR	5$
;
6$:	MOV	#4$,@SP	; Return-adr (Error-Routine not tested !!)
	MOV	#^RMCR,TASK	; MCR... only
	RETURN
;
5$:	MOV	#GCLI,R0
	CMP	G.CICL(R0),#^RMCR ; RAD50 (CLI)
	BNE	1$
4$:	MOVB	#'m,PROMPT+1
	MOVB	#'c,PROMPT+2
	MOV	#-1,CLIDCL
	BR	3$
;
1$:	CMP	G.CICL(R0),#^RDCL ; RAD50 (CLI)
	BNE	2$
	MOVB	#'d,PROMPT+1
	MOVB	#'c,PROMPT+2
	CLR	CLIDCL
	BR	3$
;
2$:	MOVB	#'c,PROMPT+1
	MOVB	#'l,PROMPT+2
	MOV	#1,CLIDCL
3$:	.ENDC
;
	MOV	#IO.CCO,CODE	; PRINTING OF THE PROMPT
	MOV	#PROMBE,ADR
	MOV	#7,LEN
	CALL	IO
;

	.SBTTL	CLE - Main-Loop
;
LOOP:	MOVB	LASCMD+1,LASCMD	; LAST COMMAND
	BICB	#340,LASCMD
	MOV	#IO.RST!IO.RNE,CODE ; ACCEPT ONE CHR.
;	CLR	CHAR
	MOV	#CHAR,ADR	; EXTRABUFFER !!
	MOV	#1,LEN
	CALL	IO		; READ 1 CHAR
;
	MOVB	IOSTAT+1,R4	; TEST FOR BRANCH TABLE
	BIC	#177600,R4	; 7-BIT-ASCII
	MOVB	R4,LASCMD+1	; SAVE THIS COMMAND
	CMPB	R4,#DEL
	BNE	1$
	JMP	DELET
;
1$:	BIC	#177740,R4	; IO.RST GIBT ALLE CTRL-CHAR IN IOSTAT
	ASL	R4
	JMP	@TAB(R4)	; <== DISPATCH
;
;
;=======================================================================;
;
;
; READY-BEEP
;
CTRLN:	CMPB	PROMBE,#BELL
	BEQ	1$
	MOVB	#BELL,PROMBE
	CALL	ERRBEP
	BR	2$
;
1$:	CLRB	PROMBE
2$:	JMP	LOOP
;

	.SBTTL	CLE - Edit-commands
;
; INSERT ONE CHARACTER
;
INSERT:	CMP	R2,#NEW+BUFSIZ	; NOCH PLATZ ?
	BLO	2$
	CALL	ERRBEP
	JMP	LOOP
;
2$:	CMP	R2,#NEW		; NEW LEER ?
	BNE	3$		; OLD NICHT LOESCHEN
;
; here you could use a dispatch-table for all "non-ctrl and non-alfa"-chars
;
	CALL	BUFNR
	TST	R3		; WAS IT NUMBER ?
	BMI	4$		; NO
	CALL	GETBUF
	CALL	DISPLY
	JMP	LOOP
;
4$:	CMPB	CHAR,#BLNK
	BNE	3$
	JMP	CTRLBL
;
; normal insert
;
3$:	MOV	#IO.CCO,CODE
	MOV	#CHAR,ADR	; ECHO
	MOV	#1,LEN
	CALL	IO
	INC	R2
	MOV	R2,R0
1$:	MOVB	-(R0),1(R0)	; SHIFT STRING
	CMP	R0,R1
	BHI	1$
	MOVB	CHAR,@R1	; INSERT NEW CHARACTER
	INC	R1		; INCREASE CURSOR
	CALL	UPD1
	JMP	LOOP
;
;

; CURSOR RIGHT
;
SKIP:	CMP	R1,R2		; END OF TEXT ?
	BHIS	CURERR
	MOV	#IO.CCO,CODE	; PRINT CHR.
	MOV	R1,ADR		; CURSOR POSITION
	MOV	#1,LEN
	CALL	IO
	INC	R1		; SHIFT CURSOR
	JMP	LOOP
;
;
; CURSOR LEFT
;
BACKSP:	CMP	R1,#NEW		; THE BEGINING OF THE BUF.
	BLOS	CURERR
;
	MOV	#IO.CCO,CODE	; GO ONE CHR. BACK
	MOV	#BS,ADR
	MOV	#1,LEN
	CALL	IO
	DEC	R1		; CURSOR
	JMP	LOOP
;
;
; BEGIN OF LINE
;
BEGLIN:	MOV	#IO.CCO,CODE
	MOV	#PROMPT,ADR
	MOV	#5,LEN		; REPOSITION CURSOR
	CALL	IO
	MOV	#NEW,R1
	JMP	LOOP
;
ENDLIN:	MOV	#IO.CCO,CODE
	MOV	R1,ADR
	MOV	R2,LEN
	SUB	R1,LEN
	BEQ	1$
	CALL	IO
	MOV	R2,R1		; END OF TEXT
1$:	JMP	LOOP
;

; DELETE ONE CHARACTER
;
; DELETE RIGHT
CTRLD:	CMP	R1,R2		; TEST LIMIT
	BHIS	CURERR
	BR	SHILEF
;
; DELETE LEFT
DELET:	CMP	R1,#NEW		; TEST LIMIT
	BLOS	CURERR
	DEC	R1		; CURSOR
;
	MOV	#IO.CCO,CODE	; CURSOR ONE CHR. BACK
	MOV	#BS,ADR
	MOV	#1,LEN
	CALL	IO
;
SHILEF:	MOV	R1,R0
1$:	MOVB	1(R0),(R0)+	; SHIFT STRING LEFT
	CMP	R0,R2
	BLOS	1$
	CALL	UPD1
	DEC	R2		; END OF TEXT
	JMP	LOOP
;
CURERR:	;*	CALL	ERRBEP
	JMP	LOOP
;
;
; DELETE RIGHT
;
CTRLK:	MOV	R1,R0		; CURSOR
2$:	CMP	R0,R2		; END OF TEXT ?
	BHIS	1$		; FERTIG
	MOVB	#BLNK,(R0)+	; DELETE REST
	BR	2$
;
1$:	CALL	UPD1
	MOV	R1,R2
	JMP	LOOP
;
;

; DELETE LEFT
;
CTRLU:	CMP	R1,#NEW
	BLOS	1$		; FERTIG
	MOV	#NEW,R0
2$:	CMP	R1,R2
	BEQ	5$
	MOVB	(R1)+,(R0)+	; SHIFT STRING LEFT
	BR	2$
;
5$:	MOV	R0,R2		; END OF TEXT
4$:	CMP	R0,#NEW+BUFSIZ
	BHIS	3$
	MOVB	#BLNK,(R0)+	; FILL WITH BLANK
	BR	4$
;
3$:	MOV	#IO.CCO,CODE
	MOV	#PROMPT,ADR
	MOV	R1,LEN
	SUB	#PROMPT,LEN
	CALL	IO
	MOV	#5,LEN		; REPOSITION CURSOR
	CALL	IO
	MOV	#NEW,R1
1$:	JMP	LOOP
;
;
;
	.SBTTL	CLE - Buffer Commands
;
; <CTRL/\> CLEAR ALL BUFFERS
;
CLEBUF:	CLR	R0		; BUFFER NUMBER
2$:	MOV	BUFADR(R0),R3	; BUFFER ADR
	MOV	#BUFSIZ+2,R5	; BUFFER LENGTH
1$:	MOVB	#BLNK,(R3)+	; CLEAR BUFFER
	DEC	R5
	BNE	1$
	ADD	#2,R0		; NEXT BUFFER
	CMP	R0,#20.		; ALL DONE
	BNE	2$
	CALL	SHOW
	CALL	DISPLY
	JMP	LOOP
;
CTRLW:	MOV	#IO.CCO,CODE
	MOV	#DOT,ADR	; CURSOR
	MOV	R1,LEN
	SUB	#PROMLF,LEN
	CALL	IO		; WRITE REST OF LINE
;
	CALL	UPD2
	CALL	DISPLY
	TSTB	TTCHAR+1
	BNE	1$
	CALL	PRILF
	CALL	PRILF
1$:	JMP	LOOP
;
;

;
; GET/PUT
;
GET:	CLR	FIFOEN		; Reset FIFO-Pointer
	CALL	SHOW
	MOVB	#'G,GEPU
	MOVB	#'e,GEPU+1
	CALL	READNR
	TST	R3		; BUFF-NR OK ?
	BMI	ILLNUM
	CALL	GETBUF
	CALL	DISPLY
	JMP	LOOP
;
PUT:	MOV	#-1,GOTOLD
	CMP	R2,#NEW		; EMPTY ?
	BNE	2$
	CLR	GOTOLD
	MOV	#OLD,R0		; TAKE LAST COMMAND
	CALL	GETBUF
	CMP	R2,#NEW		; AGAIN EMPTY ?
	BNE	1$
	MOV	#IO.CCO,CODE
	MOV	#EMPTY,ADR
	MOV	#EMPTYL,LEN
	CALL	IO
	CALL	DISPLY
	JMP	LOOP
;
1$:	CALL	DISPLY
2$:	CALL	SHOW
	MOVB	#'P,GEPU
	MOVB	#'u,GEPU+1
	CALL	READNR
	TST	R3		; BUFFER-NR OK ?
	BMI	4$
	MOV	#NEW,R1		; ADR. OF THE NEW->R1
	MOV	#BUFSIZ,R5	; BUF. LENGTH->R5
	CLRB	@R2		; END OF TEXT
3$:	MOVB	(R1)+,(R0)+	; NEW->BUF
	DEC	R5		; GO BACK IF NOT THE END
	BNE	3$		; GO BACK IF NOT THE END
	JMP	CTRLC
;
4$:	TST	GOTOLD		; IF OLD BUFFER..
	BNE	ILLNUM
	CALL	ERRBEP
	JMP	CTRLC		; ..CLEAR ITS COPY
;
ILLNUM:	CALL	ERRBEP
	CALL	DISPLY
	JMP	LOOP
;

.SBTTL	CLE - "fixed commands"
;
; COPY 'fixed commands' resp. 'SECOND LAST' resp. 'LAST GET/PUT' to 'NEW'
;
ASK:	MOV	#CTLA+1,R0	; fixed command ASK HELP
	BR	GDE
;
CTRLV:	MOV	#CTLV+1,R0	; fixed command V
	BR	GDE
;
;CTRLW:	MOV	#CTLW+1,R0	; fixed command W
;	BR	GDE
;
CTRLQM:	MOV	#CTLQM+1,R0	; fixed command '?'
	BR	GDE
;
CTRLTI:	TST	CLIDCL
	BEQ	1$
	MOV	#CTLTID+1,R0	; fixed command '~'
	CLR	CLIDCL
	BR	GDE
;
1$:	MOV	#CTLTIM+1,R0	; fixed command '~'
	MOV	#-1,CLIDCL
	BR	GDE
;
CTRLBL:	MOV	#CTLBLK+1,R0	; fixed command 'blank'
	BR	GDE
;
CTRLY:	MOV	#CTLY+1,R0	; fixed command Y
GDE:	MOV	R0,-(SP)
;*	CLR	FIXCMD		; mark fixed command
	CALL	GETBUF
	CALL	DISPLY
	MOV	(SP)+,R0	; point to fixed command
	TSTB	-1(R0)		; execute or edit ?
	BNE	1$
	CLR	FIXCMD		; mark fixed command
	JMP	EXEC		; execute immediatly
;
1$:	JMP	LOOP		; edit first
;

.SBTTL	CLE - Some FIFO-Commands
;
CTRLL:	MOV	#LAST,R0	; second last command
	MOV	#1,TFIFOP
	BR	RESFIF
;
RESFIF:	CLR	FIFOEN		; Reset FIFO-ENABLE
	BR	GBD
;
;
; COPY 'OLD' TO 'NEW'
;
CTRLR:	MOV	#OLD,R0		; ADR. OF THE OLD->R0
	MOV	#-1,FIFOEN	; SWITCH FUER FIFO: DISABLE
	CLR	TFIFOP
GBD:	CALL	GETBUF
	CALL	DISPLY
	JMP	LOOP
;
;
CTRLT:	CLR	FIFOEN		; Reset FIFO-ENABLE
	CMP	TFIFOP,FIFCNT	; END OF FIFO ?	
	BGE	13$
	CMPB	LASCMD,#CTLT	; FIRST TIME ^T ?
	BNE	12$
	INC	TFIFOP		; OLDER IN FIFO
	BR	12$
;
13$:	CALL	ERRBEP		; END OF FIFO
12$:	MOV	FIFOPO,-(SP)	; THIS IS REALLY A PATCH ..
	MOV	TFIFOP,FIFOPO	; ..TO USE GEFIFO
	CALL	GEFIFO
	MOV	(SP)+,FIFOPO
	JMP	LOOP
;

.SBTTL	CLE - Escape Sequences / FIFO - Commands
;
;
ESCAP:	CALL	IO
	CMPB	CHAR,#'[	; VT100 or VT52
	BEQ	1$
	CMPB	CHAR,#'O	; VT100
	BEQ	1$
	CMPB	IOSTAT+1,#ESC	; esc/esc
	BNE	4$
	MOV	#^RMCR,TASK	; SPAWN TO MCR... DIRECTLY
	JMP	EXEC
;
1$:	CALL	IO		; VT100
4$:	CALL	BUFNR
	TST	R3		; WAS IT NUMBER ?
	BMI	7$		; NO
	CLR	FIFOEN		; RESET FIFO ENABLE SWITCH
	CALL	GETBUF
	CALL	DISPLY
	JMP	LOOP
;
7$:	BICB	#240,CHAR	; UPPER CASE
	CMPB	CHAR,#'A	; ^
	BNE	5$
	CMP	FIFOPO,FIFCNT	; END OF FIFO ?	
	BGE	13$
	INC	FIFOPO		; OLDER IN FIFO
	MOV	FIFOPO,FIPOSA	; save for <pf2>
	BR	12$
;
5$:	CMPB	CHAR,#'B	; v
	BNE	6$
	TST	FIFOPO		; BEGIN OF FIFO ?
	BLE	13$
	DEC	FIFOPO		; NEWER IN FIFO
	MOV	FIFOPO,FIPOSA	; save for <pf2>
	BR	12$
;
13$:	CALL	ERRBEP		; END OF FIFO
	BR	12$
;
6$:	CMPB	CHAR,#'C	; -->
	BNE	2$
	JMP	SKIP
;
2$:	CMPB	CHAR,#'D	; <--
	BNE	3$
	JMP	BACKSP
;
;

.SBTTL	CLE - FIFO - Commands
;
3$:	CMPB	CHAR,#'Q	; <PF2> TAKE SAME FIFO LEVEL
	BNE	8$
12$:	MOV	FIPOSA,FIFOPO
	CALL	GEFIFO
	CLR	FIFOEN		; RESET FIFO ENABLE SWITCH
	BR	11$
;
8$:	CMPB	CHAR,#'R	; <PF3> TAKE NEWEST FIFO LEVEL
	BNE	9$
	CLR	FIFOPO
	MOV	FIFOPO,FIPOSA	; save for <pf2>
	BR	12$
;
9$:	CMPB	CHAR,#'P	; <PF1> TAKE OLDEST FIFO LEVEL
	BNE	10$
	MOV	FIFCNT,FIFOPO
	MOV	FIFOPO,FIPOSA	; save for <pf2>
	BR	12$
;
10$:	CMPB	CHAR,#'S	; <PF4> PRINT WHOLE FIFO
	BNE	11$
	CALL	PRIFIF
11$:	JMP	LOOP
;
;
; FIFO OPERATIONS
;
GEFIFO:	MOV	#OLD,R0		; POINTER TO FIFO
	CLR	R5		; SCRATCH COUNTER
2$:	CMP	FIFOPO,R5	; FOUND ?
	BEQ	3$
;
1$:	TSTB	(R0)+		; DELIMITER ?
	BNE	1$
	INC	R5
	BR	2$
;
3$:	CALL	GETBUF
	CALL	DISPLY
	RETURN
;
PRIFIF:	MOV	FIFOPO,-(SP)
	MOV	FIFCNT,FIFOPO	; FOR GEFIFO
	CMP	R2,#NEW		; NEW EMPTY ?
	BEQ	1$
	CALL	CLRNEW
	CALL	DISPLY
1$:	CALL	GEFIFO		; AND DISPLAY
	DEC	FIFOPO
	BPL	1$
2$:	MOV	(SP)+,FIFOPO
	CALL	CLRNEW
	CALL	DISPLY
	RETURN
;

FIFO:	TST	OLDCNT
	BEQ	6$
	MOV	#ENDFIF,R4	; SCRATCH POINTER
	MOV	#-3,R5		; SCRATCH COUNTER (MIT SICHERHEIT)
1$:	TSTB	-(R4)		; SEARCH END OF FIFO
	BNE	2$
	INC	R5
	BR	1$
;
2$:	CMP	R5,OLDCNT	; GENUG PLATZ ?
	BGE	3$		; OK
;
8$:	CLRB	@R4		; SONST: LETZTEN BEFEHL LOESCHEN
	INC	R5		; LEERE PLAETZE ZAEHLEN
	TSTB	-(R4)
	BNE	8$
	DEC	FIFCNT		; EIN BEFEHL WENIGER
	DEC	R4		; ZEIGT AUF LETZTES ZEICHEN
	BR	2$
;
3$:	ADD	#2,R4
	MOV	R4,R0
	ADD	OLDCNT,R4
	INC	R4
4$:	CMP	R0,#LAST
	BEQ	7$
	MOVB	-(R0),-(R4)	; SHIFT
	BR	4$
;
7$:	MOV	OLDCNT,R3
	MOV	#OLD,R0
	MOV	#LAST,R4
5$:	MOVB	(R0)+,(R4)+	; COPY OLD TO FIFO
	DEC	R3
	BNE	5$	
	CLRB	@R4		; DELIMITER
	INC	FIFCNT		; ANZ BEFEHLE IN FIFO
6$:	RETURN
;
	.SBTTL	CLE - Execute new Command
;
; EXECUTE NEW COMMAND
;
LINFED:
.IF	EQ,CLISUP
	MOV	#^R...,TASK	; SPAWN TO DCL DIRECTLY
	MOV	#^RDCM,TASK+2	; SPAWN TO DCL DIRECTLY
.ENDC
	JMP	EXEC
;
; To use this command, DCL must be installed (again) as
; a multi user task  >INS $DCL/TASK=...DCM
;
; Spawning directly to ...DCL that is installed as CLI does
; not work correctly; the activated task executes at TT0:
; instead of TI:
;
;
CTRLX:	CALL	SHOW
	MOV	#IO.CCO,CODE	; ASK BUFF-NR
	MOV	#ASKFRT,ADR
	MOV	#FRTLEN,LEN
	CALL	IO
;
	MOV	#IO.RST,CODE	; ACCEPT ONE CHR. (WITH ECHO)
	MOV	#CHAR,ADR	; NEU: EXTRABUFFER !!
	MOV	#2,LEN
	CALL	IO		; READ 1 CHAR
;
	MOVB	CHAR,R0
	SUB	#'0,R0		; CONVERT TO NUM
	CMP	R0,#9.		; IN RANGE ?
	BHI	1$		; ILLNUM
	MOVB	R0,CHAR		; CHAR AS TEMP BUF-NR
;
	MOVB	CHAR+1,R0
	SUB	#'0,R0		; CONVERT TO NUM
	CMP	R0,#9.		; IN RANGE ?
	BHI	1$		; ILLNUM
	MOVB	R0,CHAR+1	; CHAR AS TEMP BUF-NR
;
	CMPB	CHAR,CHAR+1	; 'FROM' LOWER THAN 'TO' ?
	BHI	1$		; ILLNUM
	BR	EXLOOP
;
1$:	JMP	ILLNUM
;
EXLOOP:	MOVB	CHAR,R1		; GET BUFFER-NUMBER
	INCB	CHAR		; NEXT BUFFER-NUMBER
	ASL	R1		; WORD-ADR
	MOV	BUFADR(R1),R0	; GET BUFFER-ADR
	CALL	GETBUF
	CALL	DISPLY
	BR	SPW
;

EXEC:	MOV	#1,CHAR		; AS LOOP-TERMINATOR (BOTH BYTES !)
SPW:	MOV	#IO.CCO,CODE	; PRINT <CR><LF>
	MOV	#PROMLF,ADR
	MOV	#2,LEN
	CALL	IO
;
	MOV	#IO.DET,CODE	; DEATT. THE TERMINAL
	CALL	IO
;
	MOV	R2,LEN
	SUB	#NEW,LEN
	BEQ	1$
;
	MOVB	NEW,-(SP)	; TEST FOR 'BYE'
	BICB	#240,@SP	; UPPER-CASE ASCII
	CMPB	(SP)+,#'B
	BNE	4$
	MOVB	NEW+1,-(SP)	; TEST FOR 'BYE'
	BICB	#240,@SP	; UPPER-CASE ASCII
	CMPB	(SP)+,#'Y
	BNE	4$
	MOVB	NEW+2,-(SP)	; TEST FOR 'BYE'
	BICB	#240,@SP	; UPPER-CASE ASCII
	CMPB	(SP)+,#'E
	BEQ	5$
;
4$:	TST	CLIDCL		;* DCL ?
	BEQ	8$		;*
	CMP	TASK+2,#^RDCM	;* DCL ?
	BNE	6$		;* IF NO, DON'T CHECK LOGOUT
8$:	MOVB	NEW,-(SP)	; TEST FOR 'BYE'
	BICB	#240,@SP	; UPPER-CASE ASCII
	CMPB	(SP)+,#'L
	BNE	6$
	MOVB	NEW+1,-(SP)	; TEST FOR 'BYE'
	BICB	#240,@SP	; UPPER-CASE ASCII
	CMPB	(SP)+,#'O
	BNE	6$
;*	MOVB	NEW+2,-(SP)	; TEST FOR 'BYE'
;*	BICB	#240,@SP	; UPPER-CASE ASCII
;*	CMPB	(SP)+,#'G
;*	BNE	6$
5$:	CLR	BYE		; MARK EXIT
	CALL	WRITEF
;

6$:	SPWN$S	#TASK,,,,,#1,,,#NEW,LEN ; EXECUTE COMMAND
;
	TST	BYE
	BEQ	EXIT
	STSE$S	#1		; STOP UNTIL THE MCR RETURN COMMAND
;
	TST	FIXCMD		; WAS IT FIXED COMMAND
	BEQ	1$		; NO FIFO-OPERATION
	TST	FIFOEN		; FIFO ENABLED ?
	BNE	3$
	CALL	FIFO		; FIFO SHIFT
3$:	MOV	#OLD,R0		; ADR. OF THE OLD->R0
	CLR	FIFOEN		; Reset FIFO-Pointer
	MOV	#NEW,R1		; ADR. OF THE NEW->R1
	MOV	#BUFSIZ,R5	; BUF. LENGTH->R5
2$:	MOVB	(R1)+,(R0)+	; NEW->OLD
	DEC	R5		; GO BACK IF NOT THE END
	BNE	2$		; GO BACK IF NOT THE END
	MOV	LEN,OLDCNT	; CALCULATED FOR SPAWN
;
1$:	CMPB	CHAR,CHAR+1	; ALL DONE ?
	BLE	7$
	MOV	#-1,FIFOPO	; reset FIFO-Pointer
	JMP	RESTAR
;
7$:	JMP	EXLOOP		; TAKE NEXT BUFFER
;
;
; FERTIG LUSTIG ....
;
WRITEF:	OPEN$W  #FDB,,,,,,OUTERR	; Open file
	WRITE$	#FDB,,,,,,,OUTERR 	; Write buffer to the file
	WAIT$	#FDB,,,OUTERR		; Synchronize I/O
	CLOSE$  #FDB,OUTERR		; Close file
EXRET:	RETURN
;
CTRLZ:	CALL	WRITEF
EXIT:	MOV	#ADTEXT,R0
	CALL	GETBUF
	CALL	DISPLY
;
	MOV	#IO.DET,CODE	; DEATT. THE TERMINAL
	CALL	IO
;
	EXIT$S				; Exit
;
OUTERR:	MOV	#EXRET,@SP
	RETURN
;
INERR:	MOV	#INGOON,@SP
	RETURN
;
	.END	START