.title	assist09 - mc6809 monitor

	.module	assist09

	.radix	d

	;*  Modification date:  November 23, 1988
	;*
	;*  This program is copyrighted by Motorola Inc.
	;*
	;********************************************************
	;*  miscelaneous	equates
	;********************************************************

dftchp	=	0		; default character pad count
dftnlp	=	0		; default new line pad count
prompt	=	'>		; prompt character
numbkp	=	8		; number of breakpoints

eot	=	0x04		; end of transmission
bell	=	0x07		; bell character
lf	=	0x0a		; line feed
cr	=	0x0d		; carriage return
can	=	0x18		; cancel (ctl-x)

	.page
	.sbttl	SWI Functions

	;********************************************************
	;* assist09 monitor swi functions
	;*
	;*  the following equates define functions provided
	;*  by the assist09 monitor via the swi instruction.
	;********************************************************

inchnp	=	0		; input char in a reg - no parity
outch	=	1		; output char from a reg
pdata1	=	2		; output string
pdata	=	3		; output cr/lf then string
out2hs	=	4		; output two hex and space
out4hs	=	5		; output four hex and space
pcrlf	=	6		; output cr/lf
space	=	7		; output a space
monitr	=	8		; enter assist09 monitor
vctrsw	=	9		; vector examine/switch
brkpt	=	10		; user program breakpoint
pause	=	11		; task pause function
numfun	=	11		; number of available functions

	;* sub-codes for accessing the vector table.
	;* they are equivalent to offsets in the table.
	;* relative positioning must be maintained.

.avtbl	=	0		; address of vector table
.cmdl1	=	2		; first command list
.rsvd	=	4		; reserved hardware vector
.swi3	=	6		; swi3 routine
.swi2	=	8		; swi2 routine
.firq	=	10		; firq routine
.irq	=	12		; irq routine
.swi	=	14		; swi routine
.nmi	=	16		; nmi routine
.reset	=	18		; reset routine
.cion	=	20		; console on
.cidta	=	22		; console input data
.cioff	=	24		; console input off
.coon	=	26		; console output on
.codta	=	28		; console output data
.cooff	=	30		; console output off
.hsdta	=	32		; high speed printdata
.bson	=	34		; punch/load on
.bsdta	=	36		; punch/load data
.bsoff	=	38		; punch/load off
.pause	=	40		; task pause routine
.expan	=	42		; expression analyzer
.cmdl2	=	44		; second command list
.pad	=	46		; character pad and new line pad
.echo	=	48		; echo/load and null bkpt flag

numvtr	=	48/2+1		; number of vectors
hivtr	=	48		; highest vector offset

	.page
	.sbttl	Work Area

	;********************************************************
	;* work area
	;*
	;*  The direct page register during most routine
	;*  operations will point to this work area.  the Stack
	;*  initially starts under the reserved work areas as
	;*  defined herein.
	;********************************************************

	.area	WORKPG	(ABS,OVR)
	.setdp	0

workpg:				; beginning of work aera

.blkb	0d256-(endpg-astack)	; stack space

astack:				; top of assist09 stack
tstack:	.blkb	0d21		; temporary stack hold
delim:	.blkb	1		; expression delimiter/work byte
misflg:	.blkb	1		; load cmd/thru breakpoint flag
swicnt:	.blkb	1		; trace "swi" nest level count
pcnter:	.blkb	2		; last program counter
pstack:	.blkb	2		; command recovery stack
rstack:	.blkb	2		; reset stack pointer
anumber:.blkb	2		; binary build area
basepg:	.blkb	1		; base page value
addr:	.blkb	2		; address pointer value
window:	.blkb	2		; window
bkptop:	.blkb	0x10		; breakpoint opcode table
bkptbl:	.blkb	0x10		; breakpoint table
vectab:	.blkb	0x32		; vector table
bkptct:	.blkb	1		; breakpoint count
swibfl:	.blkb	1		; bypass swi as breakpoint flag
pauser:	.blkb	4		; pause routine
endpg:

	.page
	.sbttl	Assist09 Code

	.area	ASSIST09 (ABS,OVR)

	;********************************************************
	;* bldvtr - build assist09 vector table
	;*
	;*  hardware reset calls this subroutine to build the
	;*  assist09 vector table.
	;*
	;*  input: s->valid stack ram
	;*  output: u->vector table address
	;*         dpr->assist09 work area page
	;*         the vector table and defaults are initialized
	;*
	;*  all registers volatile
	;********************************************************

bldvtr:	leax	vectab,pcr	; address vector table
	tfr	x,d		; obtain base page address
	tfr	a,dp		; setup dpr
	sta	*basepg		; store for quick reference
	leau	,x		; return table to caller
	stu	,x++		; and init vector table address
	ldb	#numvtr-3	; number relocatable vectors
	pshs	b		; store index on stack
	leay	initvt,pcr	; load from addr
1$:	tfr	y,d		; prepare address resolve
	addd	,y++		; to absolute address
	std	,x++		; into vector table
	dec	,s		; count down
	bne	1$		; branch if more to insert
	ldb	#intve-intvs	; static value init length
2$:	lda	,y+		; load next byte
	sta	,x+		; store into position
	decb			; count down
	bne	2$		; loop until done
	puls	pc,b		; return to initializer

	;********************************************************
	;* reset entry point
	;*
	;*  hardware reset enters here if assist09 is enabled
	;*  to receive the mc6809 hardware vectors.  we call
	;*  the bldvtr subroutine to initialize the vector
	;*  table, stack, and then fireup the monitor via swi
	;*  call.
	;********************************************************

reset:	leas	astack,pcr	; setup initial stack
	bsr	bldvtr		; build vector table
1$:	clra			; issue startup message
	tfr	a,dp		; default to page zero
	swi			; perform monitor fireup
	.byte	monitr		; to enter command processing
	bra	1$		; reenter monitor if 'continue'

	.page
	.sbttl	Vector Table

	;********************************************************
	;* initvt - initialize vector table
	;*
	;*  this table is relocated to ram and represents the
	;*  initial state of the vector table. all addresses
	;*  are converted to absolute form.  this table starts
	;*  with the second entry, ends with static constant
	;*  initialization data which carries beyond the table.
	;********************************************************

initvt:	.word	cmdtb1-.	; default first command table
	.word	rsrvdr-.	; default undefined hardware vector
	.word	swi3r-.		; default swi3
	.word	swi2r-.		; default swi2
	.word	firqr-.		; default firq
	.word	irqr-.		; default irq routine
	.word	swir-.		; default swi routine
	.word	nmir-.		; default nmi routine
	.word	reset-.		; restart vector
	.word	cion-.		; default cion
	.word	cidta-.		; default cidta
	.word	cioff-.		; default cioff
	.word	coon-.		; default coon
	.word	codta-.		; default codta
	.word	cooff-.		; default cooff
	.word	hsdta-.		; default hsdta
	.word	bson-.		; default bson
	.word	bsdta-.		; default bsdta
	.word	bsoff-.		; default bsoff
	.word	cpause-.	; default pause routine
	.word	exp1-.		; default expression analyzer
	.word	cmdtb2-.	; default second command table

	;* constants
	;*
intvs:	.byte	dftchp,dftnlp	; default null padds
	.word	0		; default echo
	.byte	0		; initial breakpoint count
	.byte	0		; swi breakpoint level
	rts			; default pause routine
intve	=	.

	.page
	.sbttl	SWI Handler

	;********************************************************
	;* assist09 swi handler
	;*
	;*  the swi handler provides all interfacing necessary
	;*  for a user program.  a function byte is assumed to
	;*  follow the swi instruction.  it is bound checked
	;*  and the proper routine is given control.  this
	;*  invocation may also be a breakpoint interrupt.
	;*  if so, the breakpoint handler is entered.
	;*
	;* input: machine state defined for swi
	;* output: varies according to function called. pc on
	;*
	;*     callers stack incremented by one if valid call.
	;* volatile registers: see functions called
	;*
	;* state: runs disabled unless function clears i flag.
	;********************************************************

	;* swi function vector table

swivtb:	.word	 zinch-swivtb	; inchnp
	.word	zotch1-swivtb	; outch
	.word	zpdta1-swivtb	; pdata1
	.word	zpdata-swivtb	; pdata
	.word	zot2hs-swivtb	; out2hs
	.word	zot4hs-swivtb	; out4hs
	.word	zpcrlf-swivtb	; pcrlf
	.word	zspace-swivtb	; space
	.word	zmontr-swivtb	; monitr
	.word	zvswth-swivtb	; vctrsw
	.word	zbkpnt-swivtb	; breakpoint
	.word	zpause-swivtb	; task pause

swir:	dec	swicnt,pcr	; up "swi" level for trace
	lbsr	lddp		; setup page and verify stack

	;* check for breakpoint trap

	ldu	10,s		; load program counter
	leau	-1,u		; back to swi address
	tst	*swibfl		; this "swi" breakpoint ?
	bne	2$		; no - branch to let through
	lbsr	cbkldr		; obtain breakpoint pointers
	negb			; obtain positive count
1$:	decb			; count down
	bmi	2$		; branch when done
	cmpu	,y++		; ?  was this a breakpoint
	bne	1$		; branch if not
	stu	10,s		; set program counter back
	lbra	zbkpnt		; go do breakpoint

2$:	clr	*swibfl		; clear in case set
	pulu	d		; obtain function byte, up pc
	cmpb	#numfun		; ? too high
	lbhi	error		; yes, do breakpoint
	stu	10,s		; bump program counter past swi
	aslb			; function code times two
	leau	swivtb,pcr	; obtain vector branch address
	ldd	b,u		; load offset
	jmp	d,u		; jump to routine

	.page
	.sbttl	Monitor Entry

	;********************************************************
	;* registers to function routines:
	;*  dp-> work area page
	;*  d,y,u=unreliable           x=as called from user
	;*  s=as from swi interrupt
	;********************************************************

	;********************************************************
	;* [swi function 8]
	;*  monitor entry
	;*
	;*  fireup the assist09 monitor.
	;*  the stack with its values for the direct page
	;*  register and condition code flags are used as is.
	;*   1) initialize console i/o
	;*   2) optionally print signon
	;*   3) enter command processor
	;*
	;* input: a=0 init console and print startup message
	;*        a#0 omit console init and startup message
	;********************************************************

signon:	.ascii	/Assist09 -- 6809 Monitor/	; signon eye-catcher
	.byte	eot

zmontr:	sts	*rstack		; save for bad stack recovery
	tst	1,s		; ? init console and send msg
	bne	1$		; branch if not
	jsr [vectab+.cion,pcr]	; ready console input
	jsr [vectab+.coon,pcr]	; ready console output
	leax	signon,pcr	; ready signon eye-catcher
	swi			; perform
	.byte	pdata		; print string
1$:				; fall through to cmd

	.page
	.sbttl	Command Processor

	;********************************************************
	;* command handler
	;*
	;*  breakpoints are removed at this time.
	;*  prompt for a command, and store all characters
	;*  until a separator on the stack.
	;*  search for first matching command subset,
	;*  call it or give '?' response.
	;*
	;*  during command search:
	;*      b=offset to next entry on x
	;*      u=saved s
	;*      u-1=entry size+2
	;*      u-2=valid number flag (>=0 valid)/compare cnt
	;*      u-3=carriage return flag (0=cr has been done)
	;*      u-4=start of command store
	;*      s+0=end of command store
	;********************************************************

	;********************************************************
	;* commands are entered as a subroutine with:
	;*    dpr->assist09 direct page work area
	;*    z=1 carriage return entered
	;*    z=0 non carriage return delimiter
	;*    s=normal return address
	;*
	;*  the label "cmdbad" may be entered to issue an
	;*  an error flag (?).
	;********************************************************

cmd:	swi			; to new line
	.byte	pcrlf		; function

	;* disarm the breakpoints

cmdnep:	lbsr	cbkldr		; obtain breakpoint pointers
	bpl	2$		; branch if not armed or none
	negb			; make positive
	stb	*bkptct		; flag as disarmed
1$:	decb			; ?  finished
	bmi	2$		; branch if so
	lda	-numbkp*2,y	; load opcode stored
	sta	[,y++]		; store back over "swi"
	bra	1$		; loop until done
2$:	ldx	10,s		; load users program counter
	stx	*pcnter		; save for expression analyzer
	lda	#prompt		; load prompt character
	swi			; send to output handler
	.byte	outch		; function
	leau	,s		; remember stack restore address
	stu	*pstack		; remember stack for error use
	clra			; prepare zero
	clrb			; prepare zero
	std	*anumber	; clear number build area
	std	*misflg		; clear miscel. and swicnt flags
	ldb	#2 		; set d to two
	pshs	d,cc		; place defaults onto stack

	;* check for "quick" commands.

	lbsr	read		; obtain first character
	leax	cmpadp+2,pcr	; ready memory entry point
	cmpa	#'/		; open last used memory ?
	beq	11$		; yes - doit

	;* process next character

3$:	cmpa	#' 		; ? blank or delimiter
	bls	5$		; branch yes, we have it
	pshs	a		; build onto stack
	inc	-1,u		; count this character
	cmpa	#'/		; ? memory command
	beq	12$		; branch if so
	lbsr	bldhxc		; treat as hex value
	beq	4$		; branch if still valid number
	dec	-2,u		; flag as invalid number
4$:	lbsr	read		; obtain next character
	bra	3$		; test next character

	;* got command, now search tables

5$:	suba	#cr		; set zero if carriage return
	sta	-3,u		; setup flag
	ldx	*vectab+.cmdl1	; start with first cmd list
6$:	ldb	,x+		; load entry length
	bpl	7$		; branch if not list end
	ldx	*vectab+.cmdl2	; now to second cmd list
	incb			; ? to continue to default list
	beq	6$		; branch if so
cmdbad=.
	lds	*pstack		; restore stack
	leax	errmsg,pcr	; point to error string
	swi			; send out
	.byte	pdata1		; to console
	bra	cmd		; and try again

	;* search next entry

7$:	decb			; take account of length byte
	cmpb	-1,u		; ? entered longer than entry
	bhs	9$		; branch if not too long
8$:	abx			; skip to next entry
	bra	6$		; and try next
9$:	leay	-3,u		; prepare to compare
	lda	-1,u		; load size+2
	suba	#2		; to actual size entered
	sta	-2,u		; save size for countdown
10$:	decb			; down one byte
	lda	,x+		; next command character
	cmpa	,-y		; ? same as that entered
	bne	8$		; branch to flush  if not
	dec	-2,u		; count down length of entry
	bne	10$		; branch if more to test
	abx			; to next entry
	ldd	-2,x		; load offset
	leax	d,x		; compute routine address+2
11$:	tst	-3,u		; set cc for carriage return test
	leas	,u		; delete stack work area
	jsr	-2,x		; call command
	lbra	2$		; go get next command
12$:	tst	-2,u		; ? valid hex number entered
	bmi	cmdbad		; branch error if not
	leax	cmemn-cmpadp,x	; to different entry
	ldd	*anumber	; load number entered
	bra	11$		; and enter memory command

	.page
	.sbttl	assist09 Command Tables

	;********************************************************
	;* assist09 command tables
	;*
	;*  these are the default command tables.  external
	;*  tables of the same format may extend/replace
	;*  these by using the vector swap function.
	;*
	;* entry format:
	;*     +0...total size of entry (including this byte)
	;*     +1...command string
	;*     +n...two byte offset to command (entryaddr-.)
	;*
	;*  the tables terminate with a one byte -1 or -2.
	;*  the -1 continues the command search with the
	;*         second command table.
	;*  the -2 terminates command searches.
	;********************************************************

	;* this is the default list for the second command
	;* list entry.

cmdtb2:	.byte	-2		; stop command searches

	;* this is the default list for the first command
	;* list entry.

cmdtb1:				; monitor command table
	.byte	4
	.ascii	/B/		; 'breakpoint' command
	.word	cbkpt-.
	.byte	4
	.ascii	/C/		; 'call' command
	.word	ccall-.
	.byte	4
	.ascii	/D/		; 'display' command
	.word	cdi-.
	.byte	4
	.ascii	/E/		; 'encode' command
	.word	cencde-.
	.byte	4
	.ascii	/G/		; 'go' command
	.word	cgo-.
	.byte	4
	.ascii	/L/		; 'load' command
	.word	cload-.
	.byte	4
	.ascii	/M/		; 'memory' command
	.word	cmem-.
	.byte	4
	.ascii	/N/		; 'nulls' command
	.word	cnulls-.
	.byte	4
	.ascii	/O/		; 'offset' command
	.word	coffs-.
	.byte	4
	.ascii	/P/		; 'punch' command
	.word	cpunch-.
	.byte	4
	.ascii	/R/		; 'registers' command
	.word	creg-.
	.byte	4
	.ascii	/V/		; 'verify' command
	.word	cver-.
	.byte	4
	.ascii	/W/		; 'window' command
	.word	cwindo-.
	.byte	-1		; end, continue with the second

	.page
	.sbttl	SWI Functions

	;********************************************************
	;* [swi functions 4 and 5]
	;*
	;*  4 - out2hs - decode byte to hex and add space
	;*  5 - out4hs - decode word to hex and add space
	;*
	;*  input: x->byte or word to decode
	;*  output: characters sent to output handler
	;*         x->next byte or word
	;********************************************************

zout2h:	lda	,x+		; load next byte
	pshs	d		; save - do not reread
	ldb	#16		; shift by 4 bits
	mul			; with multiply
	bsr	zouthx		; send out as hex
	puls	d		; restore bytes
	anda	#0x0f		; isolate right hex
zouthx:	adda	#0x90		; prepare a-f adjust
	daa			; adjust
	adca	#0x40		; prepare character bits
	daa 			; adjust
send:	jmp [vectab+.codta,pcr]	; send to out handler

zot4hs:	bsr	zout2h		; convert first byte
zot2hs:	bsr	zout2h		; convert byte to hex
	stx	4,s		; update users x register

	;* fall into space routine

	;********************************************************
	;* [swi function 7]
	;*  ace - send blank to output handler
	;*
	;*  input: none
	;*  output: blank send to console handler
	;********************************************************

zspace:	lda	#' 		; load blank
	bra	zotch2		; send and return
  	
	;********************************************************
	;* [swi function 9]
	;*  swap vector table entry
	;*
	;*  input:  a=vector table code (offset)
	;*          x=0 or replacement value
	;*  output: x=previous value
	;********************************************************

zvswth:	lda	1,s		; load requesters a
	cmpa	#hivtr		; ? sub-code too high
	bhi	zotch3		; ignore call if so
	ldy	*vectab+.avtbl	; load vector table address
	ldu	a,y		; u=old entry
	stu	4,s		; return old value to callers x
	stx	-2,s		; ? x=0
	beq	zotch3		; yes, do not change entry
	stx	a,y		; replace entry
	bra	zotch3		; return from swi

	.page

	;********************************************************
	;* [swi function 0]
	;*  inchnp - obtain input char in a (no parity)
	;*
	;*  nulls and rubouts are ignored.
	;*  automatic line feed is sent upon recieving a
	;*      carriage return.
	;*  unless we are loading from tape.
	;********************************************************

zinchp:	bsr	xqpaus		; release processor
zinch:	bsr	xqcidt		; call input data appendage
	bcc	zinchp		; loop if none available
	tsta 			; test for null
	beq	zinch		; ignore null
	cmpa	#0x7f		; ? rubout
	beq	zinch		; branch yes to ignore
	sta	1,s		; store into callers a
	tst	*misflg		; ? load in progress
	bne	zotch3		; branch if so to not echo
	cmpa	#cr		; ? carriage return
	bne	1$		; no, test echo byte
	lda	#lf		; load line feed
	bsr	send		; always echo line feed
1$:	tst	*vectab+.echo	; ? echo desired
	bne	zotch3		; no, return

	;* fall through to outch

	;********************************************************
	;* [swi function 1]
	;*  outch - output character from a
	;*
	;*  input:  none
	;*  output: if linefeed is the output character then
	;*           c=0 no ctl-x recieved, c=1 ctl-x recieved
	;********************************************************

zotch1:	lda	1,s		; load character to send
	leax	zpcrls,pcr	; default for line feed
	cmpa	#lf		; ? line feed
	beq	zpdtlp		; branch to check pause if so
zotch2:	bsr	send		; send to output routine
zotch3:	inc	*swicnt		; bump up "swi" trace nest level
	rti			; return from "swi" function

	;********************************************************
	;* [swi function 6]
	;*  pcrlf - send cr/lf to console handler
	;*
	;*  input: none
	;*  output: cr and lf sent to handler
	;*          c=0 no ctl-x, c=1 ctl-x recieved
	;********************************************************

zpcrls:	.byte	eot		; null string

zpcrlf:	leax	zpcrls,pcr	; ready cr,lf string

	;* fall into cr/lf code

	;********************************************************
	;* [swi function 3]
	;*  pdata - output cr/lf and string
	;*
	;*  input: x->string
	;*  output: cr/lf and string sent to output console
	;*         handler.
	;*     c=0 no ctl-x, c=1 ctl-x recieved
	;*
	;*  note: line feed must follow carriage return for
	;*       proper punch data.
	;********************************************************

zpdata:	lda	#cr		; load carriage return
	bsr	send		; send it
	lda	#lf		; load line feed

	;* fall into	pdata1

	;********************************************************
	;* [swi function 2]
	;*  pdata1 - output string till eot (0x04)
	;*
	;*  this routine pauses if an input byte becomes
	;*  available during output transmission until a
	;*  second is recieved.
	;*
	;*  input: x->string
	;*  output: string sent to output console driver
	;*         c=0 no ctl-x, c=1 ctl-x recieved
	;********************************************************

zpdtlp:	bsr	send		; send character to driver
zpdta1:	lda	,x+		; load next character
	cmpa	#eot		; ? eot
	bne	zpdtlp		; loop if not

	;* fall into pause check function

	;********************************************************
	;* [swi function 12]
	;*  pause - return to task dispatching and check
	;*
	;*  for freeze condition or ctl-x break
	;*  this function enters the task pause handler so
	;*  optionally other 6809 processes may gain control.
	;*  upon return, check for a 'freeze' condition
	;*  with a resulting wait loop, or condition code
	;*  return if a control-x is entered from the input
	;*  handler.
	;*
	;*  output: c=1 if ctl-x has entered, c=0 otherwise
	;********************************************************

zpause:	bsr	xqpaus		; release control at every line
	bsr	chkabt		; check for freeze or abort
	tfr	cc,b		; prepare to replace cc
	stb	,s		; overlay old one on stack
	bra	zotch3		; return from "swi"

	;* chkabt - scan for input pause/abort during output
	;* output: c=0 ok, c=1 abort (ctl-x issued)
	;* volatile: u,x,d

chkabt:	bsr	xqcidt		; attempt input
	bcc	2$		; branch no to return
	cmpa	#can		; ? ctl-x for abort
	bne	3$		; branch no to pause
1$:	comb			; set carry
2$:	rts			; return to caller with cc set

3$:	bsr	xqpaus		; pause for a moment
	bsr	xqcidt		; ? key for start
	bcc	3$		; loop until recieved
	cmpa	#can		; ? abort signaled from wait
	beq	1$		; branch yes
	clra			; set c=0 for no abort
	rts			; and return

	;* save memory with jumps

xqpaus:	jmp [vectab+.pause,pcr]	; to pause routine
xqcidt:	jsr [vectab+.cidta,pcr]	; to input routine
	anda	#0x7f		; strip parity
	rts			; return to caller


	;* lddp - setup direct page register, verify stack.
	;* an invalid stack causes a return to the command
	;* handler.
	;* input: fully stacked registers from an interrupt
	;* output: dpr loaded to work page

errmsg:	.byte	'?,bell,0x20,eot ; error response

ldrtn:	rts
lddp:	ldb	basepg,pcr	; load direct page high byte
	tfr	b,dp		; setup direct page register
	cmpa	3,s		; ? is stack valid
	beq	ldrtn		; yes, return
	lds	*rstack		; reset to initial stack pointer
error:	leax	errmsg,pcr	; load error report
	swi			; send out before registers
	.byte	pdata		; on next line

	;* fall into breakpoint handler

	;********************************************************
	;* [swi function 10]
	;*  breakpoint program function
	;*
	;*  print registers and go to command handler
	;********************************************************

zbkpnt:	bsr	zbkstk		; stack an extra word
zbkcmd:	lbra	cmdnep		; now enter command handler
zbkstk:	lbsr	regprt		; print out registers
	rts

	;********************************************************
	;*    irq, reserved, swi2 and swi3 interrupt handlers
	;*  the default handling is to cause a breakpoint.
	;********************************************************

swi2r:				; swi2 entry
swi3r:				; swi3 entry
irqr:				; irq entry
nmir:				; nmi entry
rsrvdr:	bsr	lddp		; set base page, validate stack
	bra	zbkpnt 		; force a breakpoint

	;********************************************************
	;*        firq handler
	;*  just return for the firq interrupt
	;********************************************************

firqr:		rti		; immediate return

	.page
	.sbttl	Read / Verify / Punch Routines

	;* bson - turn on read/verify/punch mechanism

bson:	inc	*misflg		; set load in progress flag
	rts			; return to caller

	;* bsoff - turn off read/verify/punch mechanism
	;* a,x volatile

bsoff:	dec	*misflg		; clear load in progress flag
	rts			; return to caller

	;* bsdta - read/verify/punch handler
	;* input: s+6=code byte, verify(-1),punch(0),load(1)
	;*        s+4=start address
	;*        s+2=stop address
	;*        s+0=return address
	;* output: z=1 normal completion, z=0 invalid load/ver
	;* registers are volatile

bsdta:	ldu	2,s		; u=to address or offset
	tst	6,s		; ? punch
	beq	10$		; branch yes

	;* during read/verify: s+2=msb address save byte
	;*                     s+1=byte counter
	;*                     s+0=checksum
	;*                     u holds offset

	leas	-3,s		; room for work/counter/checksum
1$:	swi			; get next character
	.byte	inchnp		; function
2$:	cmpa	#'S		; ? start of s1/s9
	bne	1$		; branch not
	swi			; get next character
	.byte	inchnp		; function
	cmpa	#'9		; ? have s9
	beq	5$		; yes, return good code
	cmpa	#'1		; ? have new record
	bne	2$		; branch if not
	clr	,s		; clear checksum
	bsr	9$		; obtain byte count
	stb	1,s		; save for decrement

	;* read address

	bsr	9$		; obtain high value
	stb	2,s		; save it
	bsr	9$		; obtain low value
	lda	2,s		; make d=value
	leay	d,u		; y=address+offset

	;* store text

3$:	bsr	9$		; next byte
	beq	6$		; branch if checksum
	tst	9,s		; ? verify only
	bmi	4$		; yes, only compare
	stb	,y		; store into memory
4$:	cmpb	,y+		; ? valid ram
	beq	3$		; yes, continue reading
5$:	puls	pc,x,a		; return with z set proper

6$:	inca			; ? valid checksum
	beq	1$		; branch yes
	bra	5$		; return z=0 invalid

	;* byte builds 8 bit value from two hex digits in

7$:	bsr	9$		; obtain first hex
	ldb	#16		; prepare shift
	mul			; over to a
	bsr	9$		; obtain second hex
	pshs	b		; save high hex
	adda	,s+		; combine both sides
	tfr	a,b		; send back in b
	adda	2,s		; compute new checksum
	sta	2,s		; store back
	dec	3,s		; decrement byte count
8$:	rts			; return to caller

9$:	swi			; get next hex
	.byte	inchnp		; character
	lbsr	cnvhex		; convert to hex
	beq	8$		; return if valid hex
	puls	pc,u,y,x,a	; return to caller with z=0

	;* punch stack use: s+8=to address
	;*                  s+6=return address
	;*                  s+4=saved padding values
	;*                  s+2 from address
	;*                  s+1=frame count/checksum
	;*                  s+0=byte count

10$:	ldu	*vectab+.pad	; load padding values
	ldx	4,s		; x=from address
	pshs	u,x,d		; create stack work area
	ldd	#24		; set a=0, b=24
	stb	*vectab+.pad	; setup 24 character pads
	swi			; send nulls out
	.byte	outch		; function
	ldb	#4		; setup new line pad to 4
	std	*vectab+.pad	; setup punch padding

	;* calculate size

11$:	ldd	8,s		; load to
	subd	2,s		; minus from=length
	cmpd	#24		; ? more than 23
	blo	12$		; no, ok
	ldb	#23		; force to 23 max
12$:	incb			; prepare counter
	stb	,s		; store byte count
	addb	#3		; adjust to frame count
	stb	1,s		; save

	;*punch cr,lf,nuls,s,1

	leax	16$,pcr		; load start record header
	swi			; send out
	.byte	pdata		; function

	;* send frame count

	clrb			; initialize checksum
	leax	1,s		; point to frame count and addr
	bsr	14$		; send frame count

	;*data address

	bsr	14$		; send address hi
	bsr	14$		; send address low

	;*punch data

	ldx	2,s		; load start data address
13$:	bsr	14$		; send out next byte
	dec	,s		; ? final byte
	bne	13$		; loop if not done
	stx	2,s		; update from address value

	;*punch checksum

	comb			; complement
	stb	1,s		; store for sendout
	leax	1,s		; point to it
	bsr	15$		; send out as hex
	ldx	8,s		; load top address
	cmpx	2,s		; ? done
	bhs	11$		; branch not
	leax	17$,pcr		; prepare end of file
	swi			; send out string
	.byte	pdata		; function
	ldd	4,s		; recover pad counts
	std	*vectab+.pad	; restore
	clra			; set z=1 for ok return
	puls	pc,u,x,d	; return with ok code

14$:	addb	,x		; add to checksum
15$:	lbra	zout2h		; send out as hex and return

16$:	.byte	'S,'1,eot 	; cr,lf,nulls,S,1
17$:	.ascii	/S9030000FC/	; eof string
	.byte	cr,lf,eot

	;* hsdta - high  speed print memory
	;* input: s+4=start address
	;*        s+2=stop address
	;*        s+0=return address
	;* x,d volatile
	;*  send title

hsdta:	swi			; send new line
	.byte	pcrlf		; function
	ldb	#6		; prepare 6 spaces
1$:	swi			; send blank
	.byte   space		; function
	decb			; count down
	bne	1$		; loop if more
	clrb			; setup byte count
2$:	tfr	b,a		; prepare for convert
	lbsr	zouthx		; convert to a hex digit
	swi			; send blank
	.byte	space		; function
	swi			; send another
	.byte	space		; blank
	incb			; up another
	cmpb	#0x10		; ? past 'f'
	blo	2$		; loop until so
3$:	swi			; to next line
	.byte	pcrlf		; function
	bcs	8$		; return if user entered ctl-x
	leax	4,s		; point at address to convert
	swi			; print out address
	.byte	out4hs		; function
	ldx	4,s		; load address proper
	ldb	#16		; next sixteen
4$:	swi			; convert byte to hex and send
	.byte	out2hs		; function
	decb			; count down
	bne	4$		; loop if not sixteenth
	swi			; send blank
	.byte	space		; function
	ldx	4,s		; reload from address
	ldb	#16		; count
5$:	lda	,x+		; next byte
	bmi	6$		; too large, to a dot
	cmpa	#' 		; ? lower than a blank
	bhs	7$		; no, branch ok
6$:	lda	#'.		; convert invalid to a blank
7$:	swi			; send character
	.byte	outch		; function
	decb			; ? done
	bne	5$		; branch no
	cpx	2,s		; ? past last address
	bhs	8$		; quit if so
	stx	4,s		; update from address
	lda	5,s		; load low byte address
	asla			; ? to section boundry
	bne	3$		; branch if not
	bra	hsdta		; branch if so
8$:	swi			; send new line
	.byte	pcrlf		; function
	rts			; return to caller

	;********************************************************
	;*     a s s i s t 0 9    c o m m a n d s
	;********************************************************

	;**********   registers - display and change registers

creg:	bsr	regprt		; print registers
	inca			; set for change function
	bsr	regchg		; go change, display registers
	rts			; return to command processor

	;********************************************************
	;*      regprt - print/change registers subroutine
	;*  will abort to 'cmdbad' if overflow detected during
	;*  a change operation.  change displays registers when
	;*  done.
	;*
	;* register mask list consists of:
	;*  a) characters denoting register
	;*  b) zero for one byte, -1 for two
	;*  c) offset on stack to register position
	;*
	;* input:    +4=stacked registers
	;*        a=0 print, a#0 print and change
	;* output: (only for register display)
	;*         c=1 control-x entered, c=0 otherwise
	;*
	;* volatile: d,x (change)
	;*           b,x (display)
	;********************************************************

regmsk:	.byte	'P,'C,-1,19	; pc reg
	.byte	'A,0,10		; a reg
	.byte	'B,0,11		; b reg
	.byte	'X,-1,13	; x reg
	.byte	'Y,-1,15	; y reg
	.byte	'U,-1,17	; u reg
	.byte	'S,-1,1		; s reg
	.byte	'C,'c,0,9	; cc reg
	.byte	'D,'p,0,12	; dp reg
	.byte	0		; end of list

regprt:	clra			; setup print only flag
regchg:	leax	4+12,s		; ready stack value
	pshs	y,x,a		; save on stack with option
	leay	regmsk,pcr	; load register mask
1$:	ldd	,y+		; load next char or <=0
	tsta			; ? end of characters
	ble	2$		; branch not character
	swi			; send to console
	.byte	outch		; function byte
	bra	1$		; check next
2$:	lda	#'-		;  ready '-'
	swi			; send out
	.byte	outch		; with outch
	leax	b,s		; x->register to print
	tst	,s		; ? change option
	bne	5$		; branch yes
	tst	-1,y		; ? one or two bytes
	beq	3$		; branch zero means one
	swi			; perform word hex
	.byte	out4hs		; function
	bra	4$

3$:	swi			; perform byte hex
	.byte	out2hs		; function
4$:	ldd	,y+		; to front of next entry
	tstb			; ? end of entries
	bne	1$		; loop if more
	swi			; force new line
	.byte	pcrlf		; function
	puls	pc,y,x,a	; restore stack and return

5$:	bsr	bldnnb		; input binary number
	beq	7$		; if change then jump
	cmpa	#cr		; ? no more desired
	beq	9$		; branch nope
	ldb	-1,y		; load size flag
	decb			; minus one
	negb			; make positive
	aslb			; times two (=2 or =4)
6$:	swi			; perform spaces
	.byte	space		; function
	decb
	bne	6$		; loop if more
	bra	4$		; continue with next register
7$:	sta	,s		; save delimiter in option

	;*                     (always > 0)

	ldd	*anumber	; obtain binary result
	tst	-1,y		; ? two bytes worth
	bne	8$		; branch yes
	lda	,-x		; setup for two
8$:	std	,x		; store in new value
	lda	,s		; recover delimiter
	cmpa	#cr		; ? end of changes
	bne	4$		; no, keep on truck'n

	;* move stacked data to new stack in case stack
	;* pointer has changed

9$:	leax	tstack,pcr	; load temp area
	ldb	#21		; load count
10$:	puls	a		; next byte
	sta	,x+		; store into temp
	decb			; count down
	bne	10$		; loop if more
	lds	-20,x		; load new stack pointer
	ldb	#21		; load count again
11$:	lda	,-x		; next to store
	pshs	a		; back onto new stack
	decb			; count down
	bne	11$		; loop if more
	puls	pc,y,x,a	; restore stack and return

	;********************************************************
	;*  bldnum - builds binary value from input hex
	;*  the active expression handler is used.
	;*
	;* input: s=return address
	;* output: a=delimiter which terminated value
	;*                            (if delm not zero)
	;*         "number"=word binary result
	;*         z=1 if input recieved, z=0 if no hex recieved
	;*
	;*  registers are transparent
	;********************************************************

	;* execute single or extended rom expression handler
	;*
	;* the flag "delim" is used as follows:
	;*   delim=0  no leading blanks, no forced terminator
	;*   delim=chr  accept leading 'chr's, forced terminator

bldnnb:	clra			; no dynamic delimiter
	sta	*delim		; store as delimiter
	jmp [vectab+.expan,pcr]	; to exp analyzer

	;* build with leading blanks

bldnum:	lda	#' 		; allow leading blanks
	sta	*delim		; store as delimiter
	jmp [vectab+.expan,pcr]	; to exp analyzer
	
	;* this is the default single rom analyzer. we accept:
	;*    1) hex input
	;*    2) 'M' for last memory examine address
	;*    3) 'P' for program counter address
	;*    4) 'W' for window value
	;*    5) '@' for indirect value

exp1:	pshs	x,b		; save registers
1$:	bsr	bldhxi		; clear number, check first char
	beq	3$		; if hex digit continue building

	;* skip blanks if desired

	cmpa	*delim		; ? correct delimiter
	beq	1$		; yes, ignore it

	;* test for m or p

	ldx	*addr		; default for 'm'
	cmpa	#'M		; ? memory examine addr wanted
	beq	5$		; branch if so
	ldx	*pcnter		; default for 'p'
	cmpa	#'P		; ? last program counter wanted
	beq	5$		; branch if so
	ldx	*window		; default to window
	cmpa	#'W		; ? window wanted
	beq	5$
2$:	puls	pc,x,b		; return and restore registers

	;* got hex, now continue building

3$:	bsr	bldhex		; compute next digit
	beq	3$		; continue if more
	bra	6$		; search for +/-

	;* store value and check if need delimiter

4$:	ldx	,x		; indirection desired
5$:	stx	*anumber	; store result
	tst	*delim		; ? to force a delimiter
	beq	2$		; return if not with value
	bsr	read		; obtain next character

	;* test for + or -

6$:	ldx	*anumber	; load last value
	cmpa	#'+		; ? add operator
	bne	8$		; branch not
	bsr	10$		; compute next term
	pshs	a		; save delimiter
	ldd	*anumber	; load new term
7$:	leax	d,x		; add to x
	stx	*anumber	; store as new result
	puls	a		; restore delimiter
	bra	6$		; now test it
8$:	cmpa	#'-		; ? subtract operator
	beq	9$		; branch if so
	cmpa	#'@		; ? indirection desired
	beq	4$		; branch if so
	clrb			; set delimiter return
	bra	2$		; and return to caller
9$:	bsr	10$		; obtain next term
	pshs	a		; save delimiter
	ldd	*anumber	; load up next term
	nega			; negate a
	negb			; negate b
	sbca	#0		; correct for a
	bra	7$		; go add to expresion

	;* compute next expression term
	;* output: x=old value
	;*         'number'=next term

10$:	bsr	bldnum		; obtain next value
	lbne	cmdbad		; abort command if invalid
	rts			; return if valid number

	;********************************************************
	;*  build binary value using input characters.
	;*
	;* input: a=ascii hex value or delimiter
	;*           +0=return address
	;*           +2=16 bit result area
	;* output: z=1 a=binary value
	;*         z=0 if invalid hex character (a unchanged)
	;*
	;* volatile: d
	;********************************************************

bldhxi:	clr	*anumber	; clear number
	clr	*anumber+1	; clear number
bldhex:	bsr	read		; get input character
bldhxc:	bsr	cnvhex		; convert and test character
	bne	cnvrts		; return if not a number
	ldb	#16		; prepare shift
	mul			; by four places
	lda	#4		; rotate binary into value
1$:	aslb			; obtain next bit
	rol	*anumber+1	; into low byte
	rol	*anumber	; into hi byte
	deca			; count down
	bne	1$		; branch if more to do
	bra	cnvok		; set good return code

	;********************************************************
	;* convert ascii character to binary byte
	;*
	;* input: a=ascii
	;* output: z=1 a=binary value
	;*         z=0 if invalid
	;*
	;* all registers transparent
	;* (a unaltered if invalid hex)
	;********************************************************

cnvhex:	cmpa	#'0		; ? lower tigh hex
	blo	cnvrts		; branch not value
	cmpa	#'9		; ? possible a-f
	ble	cnvgot		; branch no to accept
	cmpa	#'A		; ? less than ten
	blo	cnvrts		; return if minus (invalid)
	cmpa	#'F		; ? not too large
	bhi	cnvrts		; no, return too large
	suba	#7		; down to binary
cnvgot:	anda	#0x0f		; clear high byte
cnvok:	orcc	#4		; force zero on for valid hex
cnvrts:	rts			; return to caller

	;* get input char, abort command if control-x (cancel)

read:	swi			; get next character
	.byte	inchnp		; function
	cmpa	#can		; ? abort command
	lbeq	cmdbad		; branch to abort if so
	rts			; return to caller


	;************	console - dumby routines

cidta:	clc			; never a character
codta:				; dumby character out
cion:				; input console initialization
coon:				; output console initialization
cioff:				; console input off
cooff:				; console output off
cirtn:	rts

	;************	pause - process pause routine

cpause:	jmp	pauser		; go to default pause routine


	;************	go - start program execution

cgo:	bsr	goaddr		; build address if needed
	rti			; start executing

	;* find optional new program counter. also arm the
	;* breakpoints.

goaddr:	puls	y,x		; pop return addresses from cmd and cgo
	pshs	x		; restore return from cgo
	beq	1$		; <cr> ? yes - use current pc

	;* obtain new program counter

	lbsr	cdnum		; obtain new program counter
	std	12,s		; store into stack

1$:	ldx	12,s		; load program counter
	lbsr	cbkldr		; obtain table
	neg	*bkptct		; complement to show armed
2$:	decb			; ? done
	bmi	5$		; return when done
	lda	[,y]		; load opcode
	sta	-numbkp*2,y	; store into opcode table
	lda	#0x3f		; ready "swi" opcode
	cmpx	,y		; starting at a breakpoint ?
	bne	4$		; no - go set breakpoint

	cmpa	[,y++]		; ? swi breakpointed
	bne	2$		; no, skip setting of flag
	sta	*swibfl		; show upcomming swi not brkpnt
	bra	2$		; check others

4$:	sta	[,y++]		; store and move up table
	bra	2$		; and continue

5$:	rts

	;************	call - call address as subroutine

ccall:	bsr	goaddr		; fetch address if needed
	puls	u,y,x,dp,d,cc	; restore users registers
	jsr	[,s++]		; call user subroutine
1$:	swi			; perform breakpoint
	.byte	brkpt		; function
	bra	1$		; loop until user changes pc

	;************	memory - display/change memory
	;*	cmem and cmpadp are direct entry points from
	;*	the command handler for quick commands

cmem:	lbsr	cdnum		; obtain address
cmemn:	std	*addr		; store default
1$:	ldx	*addr		; load pointer
	lbsr	zout2h		; send out hex value of byte
	lda	#'-		; load delimiter
	swi			; send out
	.byte	outch		; function
2$:	lbsr	bldnnb		; obtain new byte value
	beq	3$		; branch if number

	;* coma - skip byte

	cmpa	#',		; ? comma
	bne	4$		; branch not
	stx	*addr		; update pointer
	leax	1,x		; to next byte
	bra	2$		; and input it
3$:	ldb	*anumber+1	; load low byte value
	bsr	13$		; go overlay memory byte
	cmpa	#',		; ? continue with no display
	beq	2$		; branch yes

	;* quoted string

4$:	cmpa	#''		; ? quoted string
	bne	6$		; branch no
5$:	bsr	read		; obtain next character
	cmpa	#''		; ? end of quoted string
	beq	7$		; yes, quit string mode
	tfr	a,b		; to b for subroutine
	bsr	13$		; go update byte
	bra	5$		; get next character

	;* blank - next byte

6$:	cmpa	#0x20		; ? blank for next byte
	bne	8$		; branch not
	stx	*addr		; update pointer
7$:	swi			; give space
	.byte	space		; function
	bra	1$

	;* dot - next byte with address

8$:	cmpa	#'.		; ? dot for next byte
	bne	9$		; branch no
	swi			; force new line
	.byte	pcrlf		; function
	stx	*addr		; store next address
	bra	cmpadp		; branch to show

	;* up arrow - previous byte and address

9$:	cmpa	#'^		; ? up arrow for previous byte
	bne	11$		; branch not
	leax	-2,x		; down to previous byte
	stx	*addr		; store new pointer
10$:	swi			; force new line
	.byte	pcrlf		; function
cmpadp=.
	bsr	12$		; go print its value
	bra	1$		; then prompt for input

	;* slash - for current byte with address

11$:	cmpa	#'/		; ? slash for current display
	beq	10$		; yes, send address
	rts			; return from command

	;* print current address

12$:	ldx	*addr		; load pointer value
	pshs	x		; save x on stack
	leax	,s		; point to it for display
	swi			; display pointer in hex
	.byte	out4hs		; function
	puls	pc,x		; recover pointer and return

	;* update byte

13$:	ldx	*addr		; load next byte pointer
	stb	,x+		; store and increment x
	cmpb	-1,x		; ?  successfull store
	bne	14$		; branch for '?'  if not
	stx	*addr		; store new pointer value
	rts			; back to caller

14$:	pshs	a		; save a register
	lda	#'?		; show invalid
	swi			; send out
	.byte	outch		; function
	puls	pc,a		; return to caller

	;************	window  -  set window value

cwindo:	bsr	cdnum		; obtain window value
	std	*window		; store it in
	rts			; end command

	;************	display - high speed display memory

cdi:	bsr	cdnum		; fetch address
	andb	#0xf0		; force to 16 boundry
	tfr	d,y		; save in y
	leax	15,y		; default length
	bcs	1$		; branch if end of input
	bsr	cdnum		; obtain count
	leax	d,y		; assume count, compute end addr
1$:	pshs	y,x		; setup parameters for hsdata
	cmpd	2,s		; ? was it count
	bls	2$		; branch yes
	std	,s		; store high address
2$:	jsr [vectab+.hsdta,pcr]	; call print routine
	puls	pc,u,y		; clean stack and end command

	;* obtain number - abort if none
	;* only delimiters of cr, blank, or '/' are accepted
	;* output: d=value, c=1 if carriage return delmiter,
	;*                                  else c=0
cdnum:	lbsr	bldnum		; obtain number
	lbne	cmdbad		; branch if invalid
	cmpa	#'/		; ? valid delimiter
	lbhi	cmdbad		; branch if not for error
	cmpa	#cr+1		; leave compare for carriage ret
	ldd	*anumber	; load number
	rts

	;************	punch - punch memory in s1-s9 format

cpunch:	bsr	cdnum		; obtain start address
	tfr	d,y		; save in y
	bsr	cdnum		; obtain end address
	clr	,-s		; setup punch function code
	pshs	y,d		; store values on stack
ccalbs:	jsr [vectab+.bson,pcr]	; initialize handler
	jsr [vectab+.bsdta,pcr]	; perform function
	pshs	cc		; save return code
	jsr [vectab+.bsoff,pcr]	; turn off handler
	puls	cc		; obtain condition code saved
	lbne	cmdbad		; branch if error
	puls	pc,y,x,a	; return from command

	;************	load - load memory from s1-s9 format

cload:	bsr	clvofs		; call setup and pass code
	.byte	1		; load function code for packet

clvofs:	leau	[,s++]		; load code in high byte of u
	leau	[,u]		; not changing cc and restore s
	beq	1$		; branch if carriage return next
	bsr	cdnum		; obtain offset
	bra	2$

1$:	clra			; create zero offset
	clrb			; as default
2$:	pshs	u,dp,d		; setup code, null word, offset
	bra	ccalbs		; enter call to bs routines

	;************	verify - compare memory with files

cver:	bsr	clvofs		; compute offset if any
	.byte	-1		; verify fnctn code for packet

	;************	nulls  -  set new line and char padding

cnulls:	bsr	cdnum		; obtain new line pad
	std	*vectab+.pad	; reset values
	rts			; end command

	;************	offset - compute short and long
	;*				branch offsets

coffs:	bsr	cdnum		; obtain instruction address
	tfr	d,x		; use as from address
	bsr	cdnum		; obtain to address

	;* d=to instruction, x=from instruction offset byte(s)

	leax	1,x		; adjust for *+2 short branch
	pshs	y,x		; store work word and value on s
	subd	,s		; find offset
	std	,s		; save over stack
	leax	1,s		; point for one byte display
	sex			; sign extend low byte
	cmpa	,s		; ? valid one byte offset
	bne	1$		; branch if not
	swi			; show one byte offset
	.byte	out2hs		; function
1$:	ldu	,s		; reload offset
	leau	-1,u		; convert to long branch offset
	stu	,x		; store back where x points now
	swi			; show two byte offset
	.byte	out4hs		; function
	swi			; force new line
	.byte	pcrlf		; function
	puls	pc,x,d		; restore stack and end command

	;************	breakpoint - display/enter/delete/clear
	;*				breakpoints

cbkpt:	beq	5$		; branch display of just 'b'
	lbsr	bldnum		; attempt value entry
	beq	7$		; branch to add if so
	cmpa	#'-		; ? correct delimiter
	bne	9$		; no, branch for error
	lbsr	bldnum		; attempt delete value
	beq	2$		; got one, go delete it
	clr	*bkptct		; was 'b -', so zero count
1$:	rts			; end command

	;* delete the entry

2$:	bsr	11$		; setup registers and value
3$:	decb			; ? any entries in table
	bmi	9$		; branch no, error
	cmpx	,y++		; ? is this the entry
	bne	3$		; no, try next

	;* found, now move others up in its place

4$:	ldx	,y++		; load next one up
	stx	-4,y		; move down by one
	decb			; ? done
	bpl	4$		; no, continue move
	dec	*bkptct		; decrement breakpoint count
5$:	bsr	11$		; setup registers and load value
	beq	1$		; return if none to delete
6$:	leax	,y++		; point to next entry
	swi			; display in hex
	.byte	out4hs		; function
	decb			; count down
	bne	6$		; loop if more to do
	swi			; skip to new line
	.byte	pcrlf		; function
	rts			; return to end command

	;* add new entry

7$:	bsr	11$		; setup registers
	cmpb	#numbkp		; ? already full
	beq	9$		; branch error if so
	lda	,x		; load byte to trap
	stb	,x		; try to change
	cmpb	,x		; ? changable ram
	bne	9$		; branch error if not
	sta	,x		; restore byte
8$:	decb			; count down
	bmi	10$		; branch if done to add it
	cmpx	,y++		; ? entry already here
	bne	8$		; loop if not
9$:	lbra	cmdbad		; exit with error

10$:	stx	,y		; add this entry
	clr	-numbkp*2+1,y	; clear optional byte
	inc	*bkptct		; add one to count
	bra	5$		; and now display all of 'em

	;* setup registers for scan

11$:	ldx	*anumber	; load value desired
cbkldr:	leay	bkptbl,pcr	; load start of table
	ldb	*bkptct		; load entry count
	rts			; return

	;************	encode  -  encode a postbyte

cencde:	clr	,-s		; default to not indirect
	clrb			; zero postbyte value
	leax	conv1,pcr	; start table search
	swi			; obtain first character
	.byte	inchnp		; function
	cmpa	#'[		; ? indirect here
	bne	2$		; branch if not
	lda	#0x10		; set indirect bit on
	sta	,s		; save for later
1$:	swi			; obtain next character
	.byte	inchnp		; function
2$:	cmpa	#cr		; ? end of entry
	beq	4$		; branch yes
3$:	tst	,x		; ? end of table
	lbmi	cmdbad		; exit with error
	cmpa	,x++		; ? this the character
	bne	3$		; branch if not
	addb	-1,x		; add this value
	bra	1$		; get next input
4$:	leax	conv2,pcr	; point at table 2
	tfr	b,a		; save copy in a
	anda	#0x60		; isolate register mask
	ora	,s		; add in indirection bit
	sta	,s		; save back as postbyte skeleton
	andb	#0x9f		; clear register bits
5$:	tst	,x		; ? end of table
	lbeq	cmdbad		; exit with error
	cmpb	,x++		; ? same value
	bne	5$		; loop if not
	ldb	-1,x		; load result value
	orb	,s		; add to base skeleton
	stb	,s		; save postbyte on stack
	leax	,s		; point to it
	swi			; send out as hex
	.byte	out2hs		; function
	swi			; to next line
	.byte	pcrlf		; function
	puls	pc,b		; end of command
   	
	;* table one defines valid input in sequence
conv1:	.byte	'A,0x04,'B,0x05,'D,0x06,'H,0x01
	.byte	'H,0x01,'H,0x01,'H,0x00,',,0x00
	.byte	'-,0x09,'-,0x01,'S,0x70,'Y,0x30
	.byte	'U,0x50,'X,0x10,'+,0x07,'+,0x01
	.byte	'P,0x80,'C,0x00,'R,0x00,'],0x00
	.byte	0xff		; end of table

	;*conv2 uses above conversion to set postbyte
	;*                             bit skeleton.

conv2:	.word	0x1084,0x1100	; R,        H,R
	.word	0x1288,0x1389	; HH,R      HHHH,R
	.word	0x1486,0x1585	; A,R       B,R
	.word	0x168b,0x1780	; D,R       ,R+
	.word	0x1881,0x1982	; ,R++      ,-R
	.word	0x1a83,0x828c	; ,--R      HH,pcr
	.word	0x838d,0x039f	; HHHH,pcr  [HHHH]
	.byte	0		; end of table

	;****************************************************
	;*            default interrupt transfers           *
	;****************************************************

rsrvd:	jmp	[vectab+.rsvd,pcr]	; reserved vector
swi3:	jmp	[vectab+.swi3,pcr]	; swi3 vector
swi2:	jmp	[vectab+.swi2,pcr]	; swi2 vector
firq:	jmp	[vectab+.firq,pcr]	; firq vector
irq:	jmp	[vectab+.irq,pcr]	; irq vector
swi:	jmp	[vectab+.swi,pcr]	; swi vector
nmi:	jmp	[vectab+.nmi,pcr]	; nmi vector

	.page
	.sbttl	Hardware Interrupt Tables

	;********************************************************
	;*             assist09 hardware vector table
	;*
	;*  this table is used if the assist09 rom addresses
	;*  the mc6809 hardware vectors.
	;********************************************************

	.=  bldvtr+0d2048-0d16	; assume 2K ROM

	.word	rsrvd		; reserved slot
	.word	swi3		; software interrupt 3
	.word	swi2		; software interrupt 2
	.word	firq		; fast interrupt request
	.word	irq		; interrupt request
	.word	swi		; software interrupt
	.word	nmi		; non-maskable interrupt
	.word	reset		; restart