.TITLE	SEE.MAC
	.SBTTL	IDENT, DESCRIPTION, AND THE HELP MESSAGE
	.IDENT	/100980/
;+-------------------------------------------------------
;
;	REAL TIME CORE DISPLAY FOR RSX11M, VT-52
;	BY	JACK HARVEY, VICE PRESIDENT
;		NATIONAL DATA SYSTEMS
;		299 MARKET STREET
;		SADDLEBROOK, NJ  07662
;		TELEPHONE 201 843-5300
;
;--------------------------------------------------------
	.MCALL	WSIG$S,MRKT$,EXIT$S,WTSE$S,ASTX$S,QIO$,QIOW$,DIR$
	.MCALL	ALUN$S,QIO$S,QIOW$S
	.MCALL	SVTK$S,GTIM$S,DSAR$S,ENAR$S
	.MCALL	FSRSZ$ GCMLB$ GCML$
	.SBTTL	LOCAL MACROS AND MESSAGES

	.MACRO	MESSAGE TAG
	CALL	MSGOUT
	.WORD	TAG
	.ENDM	MESSAGE

	.MACRO	MSG TXT
	.NCHR	N,<TXT>
	.WORD	N+1			;SIZE OF MESSAGE TEXT
	.BYTE	33			;ESCAPE CHARACTER
	.ASCII	/TXT/
	.EVEN
	.ENDM	MSG
;
	FSRSZ$	1
	.PSECT	SEE
;MESSAGE TEXTS
CLEAR:	.WORD	4			;CLEAR SCREEN
	.BYTE	33,'H,33,'J		;HOME, CLEAR TO END OF SCREEN
ID:	MSG	<Y  CORE DISPLAY, V100980   HIT  H  FOR HELP>
	.NLIST	BEX
CURARE:	MSG	<Y KCURRENT AREA=0>
HELP:	.WORD	10$-.-2
	.BYTE	33,'Y,42,40,33,'J	;CLEAR SCREEN FROM LINE 2 DOWN
	.BYTE	33,'Y,42,40		;REPOSITION THE CURSOR
	.ASCII	!COMMAND SUMMARY:!<12><15>
	.ASCII	!S - SIZE OF CORE BLOCK IN BYTES TO BE DISPLAYED!<12><15>
	.ASCII	!P - PARTITION ADDRESS, USE PAR COMMAND, OMIT LAST TWO ZEROS!<12><15>
	.ASCII	!L - LOCATION OF MODULE WITHIN PARTITION OR TASK - SEE TASKBUILD MAP!<12><15>
	.ASCII	!R - ASSEMBLY LISTING ADDRESS WITHIN A MODULE OR PSECT!<12><15>
	.ASCII	!I - INCREMENT BETWEEN BYTES IN DISPLAY (DEFAULT=2)!<12><15>
	.ASCII	!B - SELECT BYTE MODE DISPLAY!<12><15>
	.ASCII	!C - SELECT CHARACTER MODE DISPLAY (CTRL CHARS BECOME ...)!<12><15>
	.ASCII	!W - RESTORE WORD MODE DISPLAY (DEFAULT)!<12><15>
	.ASCII	!A - SELECT ANOTHER AREA 0 THRU 7!<12><15>
	.ASCII	!DELETE - RUBOUT LAST DIGIT!<12><15>
	.ASCII	!CTRL Z - EXIT!<12><15>
	.ASCII	!G - RESUME CORE DISPLAY AFTER AN 'H' DISPLAYS THIS TEXT!<12><15>
	.ASCII	!  THIS VERSION ADDS THE I COMMAND AND ODD ADDRESSES!<12><15>
	.ASCII	!   READ [66,6]SEE.RNO FOR ADDITIONAL HELP!
10$:	
	.EVEN
DATA:	.WORD	ENDATA-.-2
	.BYTE	33,'Y
PLINE:	.ASCII	/  PARTITION @/
PLOC:	.ASCII	/      00 MODULE @/	;PARTITION ADDRESS INSERTED
MLOC:	.ASCII	/       SIZE=/		;MODULE LOCATION INSERTED
SLOC:	.ASCII	/       INC=/		;AREA SIZE INSERTED
ILOC:	.ASCII	/       AREA /		;INCREMENT INSERTED
ALOC:	.ASCII	/   /			;AREA INSERTED
ENDATA=	.
	.EVEN
	.SBTTL	LUN ASSIGNMENTS, MACRO CALLS AND QIO DPB'S
MAXARE=	7				;MAXIMUM AREA NUMBER
CMDLUN=	1				;COMMAND FILE
TILUN=	2				;ERROR MESSAGES, DISPLAY
UISAR0=	177640				;USER PAGE ADDRESS REGISTER 0
CMLCB:	GCMLB$	4,SEE,CMLBUF,CMDLUN
	.EVEN
CMLBUF:	.BLKW	41.

CMDERR:	MSG	<   --COMMAND FILE ERROR>
CMDFLG:	.WORD	0			;NON-ZERO = COMMAND FILE INPUT MODE
ERRCNT:	.WORD	0			;COUNT OF ERRORS IN COMMAND FILE

START:	
	GCML$	#CMLCB
	BCC	10$			;BR IF INPUT OKAY
	CMPB	#GE.EOF,G.ERR(R0)	;CTRL Z?
	BNE	5$			;BR IF NOT
	TST	CMDFLG			;HAVE WE RECEIVED COMMANDS?
	BNE	50$			;BR IF COMMANDS LOADED
3$:	EXIT$S				;NOTHING BUT CTRL Z
5$:	INC	CMDFLG			;SWITCH ON ERROR PRINTING
	MESSAGE	CMDERR			;COMMAND FILE ERROR
	CLR	CMDFLG			;RESTORE TO INITIAL CONDITION
	BR	START			;AND TRY AGAIN
10$:	MOV	G.CMLD(R0),R1		;ANY INPUT?
	BEQ	50$			;BR IF NO FURTHER INPUT
	CMPB	@G.CMLD+2(R0),#'G	;HAVE INPUT, IS IT A GO?
	BEQ	50$			;BR IF GO
	INC	CMDFLG			;RECEIVING COMMAND INPUT
	ADD	G.CMLD+2(R0),R1		;POINT AFTER LAST CHARACTER
	CLRB	(R1)			;INSURE ENDING CHARACTER
	CMP	#"TT,F.DVNM(R0)		;INPUT FROM KEYBOARD?
	BNE	15$			;BR IF A COMMAND FILE
	CLR	ERRCNT			;KEYBOARD INPUT, CLEAR PREVIOUS ERRORS
	BR	20$
15$:	QIOW$S	#IO.WLB,#TILUN,#TILUN,,,,<G.CMLD+2(R0),G.CMLD(R0),#40>;ECHO COMMAND FILE
20$:	MOV	G.CMLD+2(R0),R0		;SETUP R0 FOR PARSE
	CALL	PARSE
	BR	START			;AND GET MORE INPUT
50$:	TST	ERRCNT			;ANY ERRORS?
	BNE	3$			;EXIT ON COMMAND FILE ERROR
	CLR	CMDFLG			;FLAG NOW IN CURSOR CONTROL MODE
	MOV	#AREA0,R5
	SVTK$S	#SSTAB,#1		;SET UP THE NON-EXISTENT MEMORY TRAP
	CALL	SETUP			;SETUP INITIAL SCREEN
	QIO$S	#IO.ATA,#TILUN,,,,,<#TRMAST>;ATTACH TERMINAL FOR INPUT
	DIR$	#TIMER			;START THE MARK TIME
	WTSE$S	#6
SETUP:	
	TST	CMDFLG			;COMMAND INPUT MODE?
	BNE	50$			;SKIP SETUP OF READING COMMAND FILE
	MESSAGE	CLEAR			;CLEAR SCREEN
	MESSAGE	ID			;IDENTIFY THE VERSION
	MESSAGE	CURARE			;DISPLAY INPUT AREA
	MOVB	#40,COLUMN		;SETUP OCTAL OUTPUT MESSAGE
	MOVB	#44,PLINE		;FIRST LINE FOR FIRST AREA DISPALY
	CLRB	LINE			;FOR FIRST PASS THRU LOOP
	MOV	#AREA0,R5		;POINT TO THE FIRST AREA
	MOVB	#'0,ALOC		;FIRST AREA CHARACTER
10$:	CALL	SETDSP			;SETUP THE AREA
	INCB	ALOC			;ADVANCE CHARACTER
	ADD	#ARSIZE,R5		;ADVANCE TO NEXT AREA
	CMP	R5,#ENDARE		;AT END OF AREAS?
	BLO	10$			;BR IF NOT
	MOV	#HOLES,R0
	MOV	#MAXSIZE,R1
40$:	CLR	(R0)+			;CLEAR THE NON-EXISTENT MEMORY FLAGS
	SOB	R1,40$
	INC	NEWSET			;FLAG TIMAST TO COMPLETELY RESET DISPLAY
50$:	RETURN

SETDSP:	CLR	SIZE(R5)		;SIZE WILL BE RECOMPUTED
	TST	BASE(R5)		;CHECK FOR ACTIVE AREA
	BNE	5$			;BR IF ACTIVE
	TST	PSECT(R5)		;ANY ITEM NON-ZERO MEANS AREA ACTIVE
	BNE	5$
	TST	RELADR(R5)
	BNE	5$
	TST	DSIZE(R5)		;DESIRED SIZE?
	BEQ	50$			;IF ALL ZERO, INACTIVE, IGNORE
5$:	CMPB	LINE,#40+23.		;DO WE HAVE ROOM FOR THIS AREA ON SCREEN?
	BHI	50$			;BR IF NOT
	MOV	#PLOC,R0
	MOV	BASE(R5),R1
	CALL	$CBOMG			;SHOW THE PARTITION ADDRESS
	MOV	#MLOC,R0
	MOV	PSECT(R5),R1
	CALL	$CBOMG			;SHOW THE LOCATION OF THE MODULE
	MOV	#SLOC,R0
	MOV	DSIZE(R5),R1
	CALL	$CBOMG			;INSERT THE DESIRED SIZE OF THE DISPLAY
	MOV	#ILOC,R0
	MOV	BINC(R5),R1
	BNE	8$
	MOV	#2,R1			;SET DEFAULT TO TWO BYTE INCREMENT
	MOV	R1,BINC(R5)
8$:	CALL	$CBOMG			;INSERT DISPLAY INCREMENT
	MESSAGE	DATA			;SHOW WHAT WE ARE DISPLAYING
	INCB	PLINE			;ADVANCE LINE POINTER
	MOV	DSIZE(R5),R3		;DSIZE OF AREA TO DISPLAY
	BEQ	50$			;IF NO SIZE, IGNORE
	MOVB	PLINE,LINE		;COPY TO OCTAL ADDRESS LOCATION
	MOVB	PLINE,LINE1(R5)		;FIRST LINE FOR OCTAL DATA
	MOV	DSIZE(R5),SIZE(R5)	;TRY FOR DESIRED SIZE
	MOV	RELADR(R5),R4
10$:	MOV	R4,R1
	CMPB	LINE,#40+23.		;OFF BOTTOM OF SCREEN?
	BLOS	15$			;BR IF ROOM FOR THIS LINE
	SUB	R3,SIZE(R5)		;DESIRED SIZE TOO BIG, CORRECT ACTUAL
	BR	20$			;DONE WITH THIS AREA
15$:	CALL	CONVRT			;OUTPUT ADDRESS AT LEFT OF SCREEN
	INCB	LINE			;ADVANCE TO NEXT LINE
	MOV	BINC(R5),R1		;GET THE INCREMENT BETWEEN WORDS
	ASH	#3,R1			;TIMES 8
	ADD	R1,R4			;ADVANCE TO NEXT LINE ADDRESS VALUE
	SUB	#16.,R3			;FINISHED AREA YET?
	BGT	10$			;BR IF NOT
20$:	MOVB	LINE,PLINE		;NEW LINE NUMBER FOR NEXT AREA HEADER
	MOV	BASE(R5),R1		;SETUP CALCULATION OF 22 BIT ADDRESS
	CLR	R0
	ASHC	#6,R0			;X 100, PARTITION PAGE IN 22 BITS
	ADD	PSECT(R5),R1		;LOCATION OF MODULE WITHIN PARTITION
	ADC	R0			;NOW 22 BIT ADDRESS OF MODULE
	ADD	RELADR(R5),R1		;DATA LOCATION RELATIVE TO PAR
	ADC	R0			;NOW 22 BIT ADDRESS OF AREA TO DISPLAY
	MOV	R1,OFFSET(R5)
	BIC	#177700,OFFSET(R5)	;AREA ADDRESS FROM PAGE ADDRESS REGISTER
	ASHC	#-6,R0			;MOVE BACK TO PAGE ADDRESS FIELD OF PAR
	MOV	R1,PAF(R5)		;FOR LOADING PAGE ADDRESS REGISTER
50$:	RETURN

AREA0:	
BASE=	.-AREA0				;BASE ADDRESS OF PARTITION
	.WORD	0
PSECT=	.-AREA0				;LOCATION WITHIN PARTITION
	.WORD	0
RELADR=	.-AREA0				;LOCATION WITHIN MODULE
	.WORD	0
SIZE=	.-AREA0				;SIZE IN BYTES OF AREA TO DISPLAY
	.WORD	0
BINC=	.-AREA0				;INCREMENT BETWEEN WORDS IN DISPLAY
	.WORD	0
DSIZE=	.-AREA0				;DESIRED SIZE, IF ROOM ON SCREEN
	.WORD	0
LINE1=	.-AREA0				;FIRST LINE OF DATA FOR THIS AREA
	.WORD	0
PAF=	.-AREA0				;PAGE ADDRESS FIELD IN PAR0
	.WORD	0
OFFSET=	.-AREA0				;OFFSET FROM PAR0 TO START OF DATA BLOCK
	.WORD	0
DMODE=	.-AREA0				;0=WORD, 1=BYTE, 2=CHARACTER
	.WORD	0
ARSIZE=	.-AREA0
	.BLKB	ARSIZE*MAXARE		;MAXARE+1 AREAS TOTAL
ENDARE=	.				;END OF THE AREA DESCRIPTORS

SSTAB:	.WORD	SST			;SYNCHRONOUS TRAP TABLE
SST:	MOVB	#1,HOLES-BUFF1(R4)	;NON-EXISTENT MEMORY FLAG
	RTI				;RETURN FROM INTERRUPT

	.SBTTL	TIMER
;+-----------------------------------------------------
;
;
;------------------------------------------------------
TIMAST:	
	TST	HELPER			;IS THE HELP MESSAGE UP?
	BNE	60$			;IF YES, JUST RESTART MARKTIME
	MOV	#BUFF1,R4
	MOV	UISAR0,-(SP)
	MOV	#AREA0,R5		;POINT TO FIRST AREA
10$:	MOV	SIZE(R5),R0		;GET DATA SIZE
	BEQ	15$			;BR IF AREA INACTIVE
	CALL	SCAN			;GET DATA
15$:	ADD	#ARSIZE,R5		;ADVANCE TO NEXT AREA
	CMP	R5,#ENDARE
	BLO	10$			;BR IF NOT AFTER LAST AREA
	MOV	(SP)+,UISAR0		;RESTORE MAPPING
	MOV	#BUFF2,R3		;OLD DATA
	MOV	#BUFF1,R4		;NEW DATA FROM WINDOW
	MOV	#AREA0,R5		;POINT TO FIRST AREA
20$:	CALL	SHOW			;DISPLAY THE CHANGED DATA FOR THIS AREA
	ADD	#ARSIZE,R5		;ADVANCE TO NEXT AREA
	CMP	R5,#ENDARE		;AFTER LAST AREA?
	BLO	20$			;BR IF NOT
60$:	DIR$	#TIMER			;START ANOTHER MARKTIME
	CLR	NEWSET			;IF IT HAS BEEN SET
	TST	(SP)+			;CLEAR EVENT FLAG WORD FROM STACK
	ASTX$S
TIMER:	MRKT$	,6,1,TIMAST
NEWSET:	.WORD	0			;ZERO MEANS SHOW ONLY CHANGES IN DATA

SCAN:	ASR	R0			;CONVERT TO WORD COUNT
	BNE	1$
	INC	R0			;DON'T PERMIT ZERO!!!
1$:	MOV	PAF(R5),UISAR0		;MAP TO THE DATA PAGE
	MOV	OFFSET(R5),R3		;DATA LOCATION IN PAGE
	BIT	#1,R3			;CHECK FOR ODD ADDRESS
	BEQ	10$			;BR IF EVEN
	CALL	SCANB			;ODD ADDRESS, USE TWO MOVB'S
	RETURN
10$:	CALL	SCANW			;EVEN, OKAY TO USE ONE MOV
	RETURN

SCANB:	TST	HOLES-BUFF1(R4)		;SEE IF FIRST PASS FOUND A HOLE
	BNE	7$			;BR IF MEMORY WAS MISSING
	MOVB	(R3),(R4)		;MOVE DATA FROM WINDOW TO BUFF1
	MOVB	1(R3),1(R4)		;PERMITTING ODD ADDRESSING
7$:	ADD	BINC(R5),R3		;ADVANCE BY THE BYTE INCREMENT
	TST	(R4)+
8$:	CMP	R3,#17776		;STILL MAPPED BY APAR 0 ?
	BLOS	9$			;BR IF OKAY
	SUB	#20000,R3		;REDUCE BY 4K
	ADD	#200,UISAR0		;CORRECT MAPPING
	BR	8$
9$:	SOB	R0,SCANB
	RETURN

SCANW:	TST	HOLES-BUFF1(R4)		;SEE IF FIRST PASS FOUND A HOLE
	BNE	7$			;BR IF MEMORY WAS MISSING
	MOV	(R3),(R4)		;MOVE DATA FROM WINDOW TO BUFF1
7$:	ADD	BINC(R5),R3		;ADVANCE BY THE BYTE INCREMENT
	TST	(R4)+
8$:	CMP	R3,#17776		;STILL MAPPED BY APAR 0 ?
	BLOS	9$			;BR IF OKAY
	SUB	#20000,R3		;REDUCE BY 4K
	ADD	#200,UISAR0		;CORRECT MAPPING
	BR	8$
9$:	SOB	R0,SCANW
	RETURN

SHOW:	MOV	SIZE(R5),R0		;LENGTH OF DATA TO DISPLAY
	BEQ	60$			;BR IF EMPTY
	BIT	#1,R0			;ODD BYTE COUNT?
	BEQ	5$			;BR IF EVEN SIZE
	INC	R0			;ROUND UP IF ODD
5$:	ASR	R0			;CONVERT TO WORD COUNT
	MOV	R3,FDATA		;LOCATION OF FIRST DATA, THIS AREA
10$:	TST	NEWSET			;SHOWING EVERYTHING?
	BNE	15$			;BR IS RESETTING DISPLAY
	CMP	(R4),(R3)
	BEQ	20$
15$:	MOV	(R4),(R3)		;CHANGED, UPDATE THE SAVED TABLE
	TST	HOLES-BUFF2(R3)		;IS THERE A HOLE IN MEMORY HERE?
	BNE	20$			;BR IF YES
	MOV	R0,-(SP)
	CALL	OCTOUT
	MOV	(SP)+,R0
20$:	CMP	(R4)+,(R3)+		;ADVANCE TO NEXT WORD
	SOB	R0,10$
60$:	RETURN
FDATA:	.WORD	0			;LOCATION OF FIRST DATA IN BUFFER, CURRENT AREA

MSGOUT:	MOV	@(SP),R1		;GET POINTER TO MESSAGE
	MOV	R3,-(SP)
	MOV	(R1)+,R3		;GET BUFFER SIZE, POINT TO LOCATION
	TST	CMDFLG			;IN COMMAND FILE INPUT MODE?
	BEQ	10$			;BR IF NOT
	ADD	#4,R1			;CORRECT FOR CONTROL CHARACTERS IN MESSAGE
	SUB	#4,R3
	QIOW$S	#IO.WLB,#TILUN,#TILUN,,,,<R1,R3,#40>
	BR	20$
10$:	QIOW$S	#IO.WAL,#TILUN,#TILUN,,,,<R1,R3>;SEND FROM TEXT
20$:	MOV	(SP)+,R3
50$:	ADD	#2,(SP)			;ADVANCE PAST THE ARGUMENT
	RETURN

OCTOUT:	MOV	R3,R0			;R3 POINTS TO A CHANGED WORD IN BUFFER
	SUB	FDATA,R0		;RELATIVE TO FIRST DATA, CURRENT AREA
	ASR	R0			;CONVERT TO INDEX
	MOV	R0,R1
	ASH	#-3,R1			;DIVIDE BY EIGHT FAT COLUMNS
	ADD	LINE1(R5),R1		;LINE NUMBER FOR THIS ITEM
	MOVB	R1,LINE
	BIC	#177770,R0		;R0 IS FAT COLUMN
	CMP	DMODE(R5),#1		;WHICH DISPLAY MODE?
	BLO	25$			;IF WORD
	BHI	22$			;IF CHARACTER
	MUL	#8.,R0			;BYTE MODE
	BR	30$
22$:	MUL	#2,R0			;CHARACTER MODE
	BR	30$
25$:	MUL	#7,R0			;RELATIVE CHARACTER COLUMN
30$:	ADD	#40+9.,R1		;SCREEN COLUMN
	MOVB	R1,COLUMN
	MOV	(R3),R1
	CMP	DMODE(R5),#1		;WHICH MODE?
	BLO	CONVRT			;IF WORD MODE
	BEQ	50$			;IF BYTE MODE
	BIC	#100200,R1		;CLEAR PARITY BITS
	MOV	R1,OCTDIG		;CHARACTER MODE
	CMPB	OCTDIG,#' 		;CHECK FOR CONTROL CHARACTERS
	BHIS	52$			;BR IF DISPLAYABLE
	MOVB	#'.,OCTDIG		;FORCE TO A PERIOD
52$:	CMPB	OCTDIG+1,#' 
	BHIS	53$
	MOVB	#'.,OCTDIG+1		;FORCE TO PERIOD
53$:	DIR$	#CHRQIO			;SHOW TWO CHARACTERS
	RETURN
50$:	CALL	BYTOUT			;OUTPUT TWO BYTES
	RETURN

CONVRT:	MOV	#OCTDIG,R0
	MOV	#1,R2			;INCLUDE LEADING ZEROS
	CALL	$CBOMG			;CONVERT TO ASCII
	DIR$	#OCTQIO
	RETURN

BYTOUT:	MOV	#OCTDIG,R0
	BIC	#177400,R1		;CLEAR HIGH BYTE
	MOV	#1,R2			;LEADING ZEROS
	CALL	$CBTMG			;BYTE CONVERSION
	MOVB	#' ,(R0)+		;SPACE BETWEEN BYTES
	MOVB	1(R3),R1		;HIGH BYTE
	MOV	#1,R2
	CALL	$CBTMG			;CONVERT HIGH BYTE
	DIR$	#BYTQIO			;SHIP TO SCREEN
	RETURN

BYTQIO:	QIOW$	IO.WAL,TILUN,TILUN,,,,<OCTCTL,12.>
CHRQIO:	QIOW$	IO.WAL,TILUN,TILUN,,,,<OCTCTL,6.>
OCTQIO:	QIOW$	IO.WAL,TILUN,TILUN,,,,<OCTCTL,10.>
OCTCTL:	.BYTE	33,'Y
LINE:	.BYTE	40
COLUMN:	.BYTE	40
OCTDIG:	.BLKB	8.			;OCTAL TEXT HERE

MAXSIZE=144.
BUFF1:	.BLKW	MAXSIZE			;NEW DATA COPIED FROM WINDOW
BUFF2:	.BLKW	MAXSIZE			;PREVIOUS DATA
HOLES:	.BLKW	MAXSIZE			;MISSING MEMORY FLAGS (IO PAGE FOR EXAMPLE)

	.SBTTL	UNSOLICITED CONSOLE INPUT MESSAGE SERVICE
TRMAST:	MOV	(SP)+,R3		;GET THE CHARACTER
	CLR	HELPER			;CLEAR HELP DISPLAY ON ANY INPUT AFTER 'H'
	CMPB	R3,#32			;CHECK FOR CONTROL Z
	BEQ	50$			;QUIT
	CMP	R3,#'0
	BHIS	5$			;IGNORE ANY OTHER CONTROL CHARACTERS
	CALL	ERROR			;REPORT AN ERRROR
	BR	45$			;AND IGNORE
5$:	CMP	R3,#141			;LOWER CASE?
	BLO	10$			;BR IF NOT
	BIC	#40,R3			;CONVERT TO LOWER CASE
10$:	TST	TELLCNT			;ANY PREVIOUS TEXT IN?
	BNE	30$
	MESSAGE	CLRLIN
	MOV	#TELLER,TPOINT		;SETUP A POINTER
30$:	MOVB	R3,@TPOINT		;INPUT CHARACTER TO BUFFER
	MOVB	R3,CHAR			;FOR ECHO DISPLAY
	MOV	TELLCNT,R0
	ADD	#40,R0
	MOVB	R0,CLOCAT		;CHARACTER LOCATION
	QIOW$S	#IO.WLB,#TILUN,#TILUN,,,,<#CHARB,#5>;ECHO A SINGLE CHARACTER
	INC	TELLCNT			;COUNT THE TEXT CHARACTER
	INC	TPOINT			;ADVANCE POINTER
	CMPB	R3,#'7			;LOOK FOR CONTROL CHARACTER
	BLOS	45$			;BR IF OCTAL NUMERIC
	MOV	#TELLER,R0		;POINT TO THE INPUT STRING
	CALL	PARSE			;NON-NUMERIC
45$:	ASTX$S
50$:	MESSAGE	CLEAR			;CLEAR SCREEN
	QIO$S	#IO.KIL,#TILUN		;KILL ALL IO
	EXIT$S


HELPER:	.WORD	0			;NON-ZERO WHEN HELP DISPLAY IS ON SCREEN
TPOINT:	.WORD	0			;POINTS TO NEXT LOCATION FOR TEXT
TELLCNT:.WORD	0			;BYTE COUNT OF TEXT
TELLER:	.BLKB	132.			;CONSOLE TEXT BUFFER

CHARB:	.BYTE	33,'Y,42		;SINGLE CHARACTER ECHO
CLOCAT:	.BYTE				;COLUMN IN LINE
CHAR:	.BYTE	0			;CHARACTER TO BE DISPLAYED
	.EVEN
CLIST:	.ASCII	/ARSLPCWBGHI_/		;CONTROL CHARACTERS
LSTSIZ=	.-CLIST
	.EVEN

ERROR:	MESSAGE	INVCHR			;INVALID CHARACTER RECEIVED
	CLR	TELLCNT
	INC	ERRCNT			;COUNT COMMAND ERRORS
	RETURN
INVCHR:	MSG	<Y"0INVALID CHARACTER>

PARSE:	
	CALL	SETR5			;SETUP R5 FOR CURRENT AREA
	CALL	$COTB			;CONVERT ASCII TO BINARY
	MOV	#CLIST,R3		;SETUP FOR CONTROL CHARACTER LIST SCAN
	MOV	#LSTSIZ,R4		;SIZE OF THE LIST
5$:	CMPB	R2,(R3)+
	BEQ	7$			;BR IF FOUND
	SOB	R4,5$
	CALL	ERROR			;INVALID CHARACTER
	BR	100$			;EXIT IF INVALID
7$:	ASL	R4			;CONVERT RESIDUAL COUNT TO WORD INDEX
	ADD	R4,PC			;AND TAKE A BRANCH
	NOP
	BR	80$			;RUBOUT
	BR	77$
	BR	75$			;H
	BR	90$			;G
	BR	70$			;B
	BR	60$			;W
	BR	50$			;C
	BR	40$			;P
	BR	30$			;L
	BR	20$			;S
	BR	10$			;R
	CALL	NEWAREA			;A
	BR	95$
10$:	MOV	R1,RELADR(R5)		;RELATIVE LOCATION IN MODULE
	BR	85$
20$:	CMP	R1,#MAXSIZE*2		;SIZE, CHECK TO TOO LARGE
	BLOS	25$			;BR IF OKAY
	MOV	#MAXSIZE*2,R1		;FORCE TO MAX
25$:	MOV	R1,DSIZE(R5)
	BR	90$
30$:	MOV	R1,PSECT(R5)		;LOCATION OF MODULE IN TASK
	BR	85$
40$:	MOV	R1,BASE(R5)		;PARTITION BASE(R5) ADDRESS/100
	BR	85$
50$:	MOV	#2,DMODE(R5)		;SET DISPLAY MODE TO CHARACTER
	BR	90$
60$:	CLR	DMODE(R5)		;SET DISPLAY MODE TO WORD
	BR	90$
70$:	MOV	#1,DMODE(R5)		;SET DISPLAY MODE TO BYTE
	BR	90$
75$:	MESSAGE	HELP			;PUT UP THE HELP MESSAGE
	INC	HELPER			;STOP THE CORE DISPLAY
	CLR	TELLCNT			;RESET BUFFER
	BR	100$
77$:	MOV	R1,BINC(R5)		;SELECT DISPLAY INCREMENT
	BR	90$
80$:	CALL	RUBOUT			;PROCESS RUBOUT CHARACTER
	BR	100$
85$:	BEQ	90$			;BR IF ITEM WAS BEING CLEARED
	TST	DSIZE(R5)		;SETTING UP AN AREA
	BNE	90$			;BR IF A SIZE ALREADY SELECTED
	MOV	#16.,DSIZE(R5)		;PUT IN A DEFAULT SIZE OF ONE LINE
90$:	CALL	SETUP			;CLEAR SCREEN, SETUP LINE ADDRESSES
95$:	CLR	TELLCNT
100$:	RETURN
CLRLIN:	.WORD	6
	.BYTE	33,'Y,42,40,33,'K	;CLEAR THE INPUT LINE
AREA:	.WORD	0			;CURRENT AREA BEING SETUP
NEWAREA:CMP	R1,#MAXARE		;NEW AREA BEING SELECTED
	BHI	30$			;BR IF TOO BIG
	MOV	R1,AREA
	CALL	SETR5			;SETUP A NEW R5
	MOV	AREA,R0			;CURRENT KEYBOARD AREA
	ADD	#'0,R0			;CONVERT TO ASCII
	MOVB	R0,CURARE+19.		;SETUP THE MESSAGE
	MESSAGE	CURARE			;CURRENT SELECTION
30$:	RETURN


SETR5:	MOV	AREA,R5			;SETUP R5 TO POINT TO CURRENT AREA
	MUL	#ARSIZE,R5
	ADD	#AREA0,R5		;INDEX INTO THE AREA STORAGE
	RETURN

RUBOUT:	CMP	TELLCNT,#1		;ANYTHING IN BUFFER?
	BHI	10$			;BR IF SOMETHING BESIDE THE RUBOUT
	CLR	TELLCNT			;BUFFER WAS EMPTY
	MOV	#TELLER,TPOINT		;RESET
	BR	20$
10$:	SUB	#2,TELLCNT		;CORRECT COUNT FOR RUBOUT TOO
	SUB	#2,TPOINT
20$:	MOV	TELLCNT,R0
	ADD	#40,R0
	MOVB	R0,BKLOC		;COLUMN LOCATION FOR WIPEOUT
	QIOW$S	#IO.WLB,#TILUN,#TILUN,,,,<#BKSPC,#12.>
	QIOW$S	#IO.WLB,#TILUN,#TILUN,,,,<#BKSPC,#4>;BACK UP THE CURSOR

	RETURN
BKSPC:	.BYTE	33,'Y,42		;ESCAPE SEQUENCE TO RUBOUT
BKLOC:	.BYTE	0			;COLUMN LOCATION GOES HERE
	.ASCII	/        /		;TWO SPACES TO WIPE OUT PREVIOUS CHARACTER AND THE RUB
	.EVEN
	.END	START