ttl assist09 - mc6809 monitor

*  Modification date:  March 4, 1985
   
*************************************
* copyright (c) motorola, inc. 1979 *
*************************************
   
*************************************
*  This version of assist09 contains modifications
*  which allow a mc68681 duart to be used in place 
*  of the mc6850 acia and mc6840 ptm, while also
*  providing software controlled baud rate.
*  several options (opt) are used to generate
*  printouts of the modified sections only.
*************************************
   
*********************************************
*         global module	equates
********************************************

rombeg	equ	$f800		rom start assembly address
ramofs	equ	-$3800		rom offset to ram work page
romsiz	equ	2048		rom size
rom2of	equ	rombeg-romsiz	start of extension rom
duart	equ	$8010		default acia address
ptm	equ	$8020		default dumb address

* refer to table below in miscellaneous	equates
* section for modificatiuons of baud rate

mbaud	equ	$02bb		byte1 is mode byte2 is baud rate
dftchp	equ	0		default character pad count
dftnlp	equ	5		default new line pad count
prompt	equ	'>		prompt character
numbkp	equ	8		number of breakpoints

*********************************************
*  miscelaneous	equates
*********************************************

eot	equ	$04		end of transmission
bell	equ	$07		bell character
lf	equ	$0a		line feed
cr	equ	$0d		carriage return
dle	equ	$10		data link escape
can	equ	$18		cancel (ctl-x)

* duart access definitions

mr1a	equ	$00		mode register 1 port a
mr2a	equ	$00		mode register 2 port a
csra	equ	$01		clock select register
trans	equ	$03		transmit buffer
reciv	equ	$03		receiver buffer
acr	equ	$04		auxillery control
cra	equ	$02		command register a
stat	equ	$01		status register a
scc	equ	$0e		start counter command
stop	equ	duart+$0f
imr	equ	$05
ctur	equ	$06

*
* baud rate select table for
* some common selections for 
* baud rate set #2 on mc68681 
*
*    300 baud = $44
*   1200 baud = $66
*   2400 baud = $88
*   4800 baud = $99
*   9600 baud = $bb
*  19.2k baud = $cc
    
skip2	equ	$8c		"cmpx #" opcode - skips two byte
   
*******************************************
*    assist09 monitor swi functions
* the following	equates define functions provided
* by the assist09 monitor via the swi instruction.
******************************************

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

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

.avtbl	equ	0		address of vector table
.cmdl1	equ	2		first command list
.rsvd	equ	4		reserved hardware vector
.swi3	equ	6		swi3 routine
.swi2	equ	8		swi2 routine
.firq	equ	10		firq routine
.irq	equ	12		irq routine
.swi	equ	14		swi routine
.nmi	equ	16		nmi routine
.reset	equ	18		reset routine
.cion	equ	20		console on
.cidta	equ	22		console input data
.cioff	equ	24		console input off
.coon	equ	26		console output on
.codta	equ	28		console output data
.cooff	equ	30		console output off
.hsdta	equ	32		high speed printdata
.bson	equ	34		punch/load on
.bsdta	equ	36		punch/load data
.bsoff	equ	38		punch/load off
.pause	equ	40		task pause routine
.expan	equ	42		expression analyzer
.cmdl2	equ	44		second command list
.duart	equ	46		duart address
.pad	equ	48		character pad and new line pad
.echo	equ	50		echo/load and null bkpt flag
.ptm	equ	52		ptm not really used
 
* ptm	equate was deleted due to implementation
* of trace by the timer/counter on the mc68681
 
numvtr	equ	52/2+1		number of vectors
hivtr	equ	52		highest vector offset

******************************************
*              work area
* This work area is assigned to the page addressed by
* -$800, pcr from the base address of the assist09
* rom.  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.
******************************************

workpg	equ	rombeg+ramofs	setup direct page address

* setdp workpg!>8 notify assembler

	org	workpg+256	ready page definitions

* the following thru bkptop must reside in this order
* for proper initialization

	org	*-4
pauser	equ	*		pause routine
	org	*-1
swibfl	equ	*		bypass swi as breakpoint flag
	org	*-1
bkptct	equ	*		breakpoint count
	org	*-2
slevel	equ	*		stack trace level
	org	*-$36 
vectab	equ	*		vector table
	org	*-$10
bkptbl	equ	*		breakpoint table
	org	*-$10
bkptop	equ	*		breakpoint opcode table
	org	*-2       
window	equ	*		window 
	org	*-2
addr	equ	*		address pointer value
	org	*-1
basepg	equ	*		base page value
	org	*-2
number	equ	*		binary build area
	org	*-2
lastop	equ	*		last opcode traced
	org	*-2
rstack	equ	*		reset stack pointer
	org	*-2
pstack	equ	*		command recovery stack
	org	*-2 
pcnter	equ	*		last program counter
	org	*-2
tracec	equ	*		trace count
	org	*-1
swicnt	equ	*		trace "swi" nest level count
	org	*-1		(misflg must follow swicnt)
misflg	equ	*		load cmd/thru breakpoint flag
	org	*-1
delim	equ	*		expression delimiter/work byte
	org	*-40
rom2wk	equ	*		extension rom reserved area
	org	*-21
tstack	equ	*		temporary stack hold
stack	equ	*		start of initial stack
   
******************************************
* default the rom beginning address to 'rombeg'
* assist09 is position address independent, however
* we assemble assuming control of the hardware vectors.
* note that the work ram page must be 'ramofs'
* from the rom beginning address.
********************************************

	org	rombeg		rom assembly/default address
   
*****************************************************
*            bldvtr - build assist09 vector table
*  hardware reset calls this subroutine to build the
*  assist09 vector table.  this subroutine resides at
*  the first byte of the assist09 rom, and can be
*  called via external control code for remote
*  assist09 execution.
* 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
	leay	<initvt,pcr	load from addr
	stu	,x++		init vector table address
	ldb	#numvtr-5	number relocatable vectors
	pshs	b		store index on stack
bld2	tfr	y,d		prepare address resolve
	addd	,y++		to absolute address
	std	,x++		into vector table
	dec	,s		count down
	bne	bld2		branch if more to insert
	ldb	#intve-intvs	static value init length
bld3	lda	,y+		load next byte
	sta	,x+		store into position
	decb			count down
	bne	bld3		loop until done
	leay	rom2of,pcr	test possible extension rom
	ldx	#$20fe		load "bra *" flag pattern
	cmpx	,y++		? extended rom here
	bne	bldrtn		branch not our rom to return
	jsr	,y		call extended rom initialize
bldrtn	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	stack,pcr	setup initial stack
	bsr	bldvtr		build vector table
reset2	clra			issue startup message
	tfr	a,dp		default to page zero
	swi			perform monitor fireup
	fcb	monitr		to enter command processing
	bra	reset2		reenter monitor if 'continue'
 	 
******************************************************
*         initvt - initial 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	fdb	cmdtbl-*	default first command table
	fdb	rsrvdr-*	default undefined hardware vector
	fdb	swi3r-*		default swi3
	fdb	swi2r-*		default swi2
	fdb	firqr-*		default firq
	fdb	irqr-*		default irq routine
	fdb	swir-*		default swi routine
	fdb	nmir-*		default nmi routine
	fdb	reset-*		restart vector
	fdb	cion-*		default cion
	fdb	cidta-*		default cidta
	fdb	cioff-*		default cioff
	fdb	coon-*		default coon
	fdb	codta-*		default codta
	fdb	cooff-*		default cooff
	fdb	hsdta-*		default hsdta
	fdb	bson-*		default bson
	fdb	bsdta-*		default bsdta
	fdb	bsoff-*		default bsoff
	fdb	pauser-*	default pause routine
	fdb	exp1-*		default expression analyzer
	fdb	cmdtb2-*	default second command table
* constants
*
intvs	fdb	duart		default duart
*
	fcb	dftchp,dftnlp	default null padds
	fdb	0		default echo
	fdb	ptm		not really used
*
* ptm rmb was deleted from here
* since it was no longer needed
*
	fdb	0		initial stack trace level
	fcb	0		initial breakpoint count
	fcb	0		swi breakpoint level
	fcb	$39		default pause routine (rts)
intve	equ	* 
*b
   
***********************************************
*             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	fdb	 zinch-swivtb	inchnp
	fdb	zotch1-swivtb	outch
	fdb	zpdta1-swivtb	pdata1
	fdb	zpdata-swivtb	pdata
	fdb	zot2hs-swivtb	out2hs
	fdb	zot4hs-swivtb	out4hs
	fdb	zpcrlf-swivtb	pcrlf
	fdb	zspace-swivtb	space
	fdb	zmontr-swivtb	monitr
	fdb	zvswth-swivtb	vctrsw
	fdb	zbkpnt-swivtb	breakpoint
	fdb	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	swidne		branch if so to let through
	lbsr	cbkldr		obtain breakpoint pointers
	negb	obtain		positive count
swilp	decb	count		down
	bmi	swidne		branch when done
	cmpu	,y++		?  was this a breakpoint
	bne	swilp		branch if not
	stu	10,s		set program counter back
	lbra	zbkpnt		go do breakpoint    
swidne	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
    
**********************************************
* 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) initialize ptm for single stepping
*   4) enter command processor
* input: a=0 init console and print startup message 
*        a#0 omit console init and startup message      
*************************************************
    
signon  fcc	/assist09/	signon eye-catcher
	fcb	eot
    
zmontr	sts	<rstack		save for bad stack recovery
	tst	1,s		? init console and send msg
	bne	zmont2		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
	fcb	pdata		print string
*
* ptm initialization deleted
*
zmont2	bra	cmd
*
   
***************************************************
*          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
***********************************************

cmd	swi			to new line
	fcb	pcrlf		function
* disarm the breakpoints
cmdnep	lbsr	cbkldr		obtain breakpoint pointers
	bpl	cmdnol		branch if not armed or none
	negb			make positive
	stb	<bkptct		flag as disarmed
cmdddl	decb			?  finished
	bmi	cmdnol		branch if so
	lda	-numbkp*2,y	load opcode stored
	sta	[,y++]		store back over "swi"
	bra	cmdddl		loop until done
cmdnol	ldx	10,s		load users program counter
	stx	<pcnter		save for expression analyzer
	lda	#prompt		load prompt character
	swi			send to output handler
	fcb	outch		function
	leau	,s		remember stack restore address
	stu	<pstack		remember stack for error use
	clra			prepare zero
	clrb			prepare zero
	std	<number		clear number build area
	std	<misflg		clear miscel. and swicnt flags
	std	<tracec		clear trace count
	ldb	#2 		set d to two
	pshs	d,cc		place defaults onto stack
* check for "quick" commands.
	lbsr	read		obtain first character
	leax	cdot+2,pcr	preset for single trace
	cmpa	#'.		? quick trace
	beq	cmdxqt		branch	equal for trace one
	leax	cmpadp+2,pcr	ready memory entry point
	cmpa	#'/		? open last used memory
	beq	cmdxqt		branch to do it if so
* process next character
cmd2	cmpa	#' 		? blank or delimiter
	bls	cmdgot		branch yes, we have it
	pshs			a build onto stack
	inc	-1,u		count this character
	cmpa	#'/		? memory command
	beq	cmdmem		branch if so
	lbsr	bldhxc		treat as hex value
	beq	cmd3		branch if still valid number
	dec	-2,u		flag as invalid number
cmd3	lbsr	read		obtain next character
	bra	cmd2		test next character
* got command, now search tables
cmdgot	suba	#cr		set zero if carriage return
	sta	-3,u		setup flag
	ldx	<vectab+.cmdl1	start with first cmd list
cmdsch	ldb	,x+		load entry length
	bpl	cmdsme		branch if not list end
	ldx	<vectab+.cmdl2	now to second cmd list
	incb			? to continue to default list
	beq	cmdsch		branch if so
cmdbad	lds	<pstack		restore stack
	leax	errmsg,pcr	point to error string
	swi			send out
	fcb	pdata1		to console
	bra	cmd		and try again
* search next entry
cmdsme	decb			take account of length byte
	cmpb	-1,u		? entered longer than entry
	bhs	cmdsiz		branch if not too long
cmdfls	abx			skip to next entry
	bra	cmdsch		and try next
cmdsiz	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
cmdcmp	decb			down one byte
	lda	,x+		next command character
	cmpa	,-y		? same as that entered
	bne	cmdfls		branch to flush  if not
	dec	-2,u		count down length of entry
	bne	cmdcmp		branch if more to test
	abx			to next entry
	ldd	-2,x		load offset
	leax	d,x		compute routine address+2
cmdxqt	tst	-3,u		set cc for carriage return test
	leas	,u		delete stack work area
	jsr	-2,x		call command
	lbra	cmdnol		go get next command
cmdmem	tst	-2,u		? valid hex number entered
	bmi	cmdbad		branch error if not
	leax	<cmemn-cmpadp,x to different entry
	ldd	<number		load number entered
	bra	cmdxqt		and enter memory command
    
** 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 (*).
   
**************************************************
*        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	fcb	-2		stop command searches
    
* this is the default list for the first command
* list entry.
cmdtbl	equ	*		monitor command table
	fcb	4
	fcc	/B/		'breakpoint' command
	fdb	cbkpt-*
	fcb	4
	fcc	/C/		'call' command
	fdb	ccall-*
	fcb	4
	fcc	/D/		'display' command
	fdb	cdi   -*
	fcb	4
	fcc	/E/		'encode' command
	fdb	cencde-*
	fcb	4
	fcc	/G/		'go' command
	fdb	cgo-*
	fcb	4
	fcc	/L/		'load' command
	fdb	cload-*
	fcb	4
	fcc	/M/		'memory' command
	fdb	cmem-*
	fcb	4
	fcc	/N/		'nulls' command
	fdb	cnulls-*
	fcb	4
	fcc	/O/		'offset' command
	fdb	coffs-*
	fcb	4
	fcc	/P/		'punch' command
	fdb	cpunch-*
	fcb	4
	fcc	/R/		'registers' command
	fdb	creg-*
	fcb	4
	fcc	/S/		'stlevel' command
	fdb	cstlev-*
	fcb	4
	fcc	/T/		'trace' command
	fdb	ctrace-*
	fcb	4
	fcc	/V/		'verify' command
	fdb	cver-*
	fcb	4
	fcc	/W/		'window' command
	fdb	cwindo-*
	fcb	-1		end, continue with the second
   
*************************************************
*             [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	#$0f		isolate right hex
zouthx	adda	#$90		prepare a-f adjust
	daa			adjust
	adca	#$40		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
*d
   
************************************************
*                    [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	#$7f		? 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	zin2		no, test echo byte
	lda	#lf		load line feed
	bsr	send		always echo line feed
zin2	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	fcb	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 ($04)
*  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	chkrtn		branch no to return
	cmpa	#can		? ctl-x for abort
	bne	chkwt		branch no to pause
chksec	comb			set carry
chkrtn	rts			return to caller with cc set  
chkwt	bsr			xqpaus pause for a moment
	bsr	xqcidt		? key for start
	bcc	chkwt		loop until recieved
	cmpa	#can		? abort signaled from wait
	beq	chksec		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	#$7f		strip parity
	rts			return to caller
   
********************************************
*          nmi default interrupt handler
*  the nmi handler is used for tracing instructions.
*  trace printouts occur only as long as the stack
*  trace level is not breached by falling below it.
*  tracing continues until the count turns zero or
*  a ctl-x is entered from the input console device.
*********************************************
    
mshowp	fcb	'O,'P,'-,eot	opcode prep
    
*
* one instruction was added to the nmi handler
* this instruction stops the counter on the 
* mc68681 duart which also negates the signal
* which caused the interrupt (nmi)
*
nmir	tst	stop
*
*
	bsr	lddp		load page and verify stack
	tst	<misflg		? thru a breakpoint
	bne	nmicon		branch if so to continue
	tst	<swicnt		? inhibit "swi" during trace
	bmi	nmitrc		branch yes
	leax	12,s		obtain users stack pointer
	cmpx	<slevel		? to trace here
	blo	nmitrc		branch if too low to display
	leax	mshowp,pcr	load op prep
	swi			send to console
	fcb	pdata1		function
	rol	<delim		save carry bit
	leax	lastop,pcr	point to last op
	swi			send out as hex
	fcb	out4hs		function
	bsr	regprs		follow memory with registers
	bcs	zbkcmd		branch if "cancel"
	ror	<delim		restore carry bit
	bcs	zbkcmd		branch if "cancel" 
	ldx	<tracec		load trace count
	beq	zbkcmd		if zero to command handler
	leax	-1,x		minus one
	stx	<tracec		refresh
	beq	zbkcmd		stop trace when zero
	bsr	chkabt		? abort the trace
	bcs	zbkcmd		branch yes to command handler
nmitrc	lbra	ctrce3		no, trace another instruction
    
regprs	lbsr	regprt		print registers as from command
	rts	return		to caller
    
* just executed thru a brkpnt.  now continue normally
nmicon	clr	<misflg		clear thru flag
	lbsr	armbk2		arm breakpoints
rti	rti			and continue users program
    
* 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	fcb	'?,bell,$20,eot error response
    
lddp	ldb	basepg,pcr	load direct page high byte
	tfr	b,dp		setup direct page register
	cmpa	3,s		? is stack valid
	beq	rts		yes, return
	lds	<rstack		reset to initial stack pointer
error	leax	errmsg,pcr	load error report
	swi			send out before registers
	fcb	pdata		on next line

* fall into breakpoint handler
   
**********************************************
*             [swi function 10]
*         breakpoint program function
*  print registers and go to command hanler
***********************************************

zbkpnt	bsr	regprs		print out registers
zbkcmd	lbra	cmdnep		now enter command handler
   
********************************************
*    irq, reserved, swi2 and swi3 interrupt handlers
*  the default handling is to cause a breakpoint.
********************************************

swi2r	equ	*		swi2 entry
swi3r	equ	*		swi3 entry
irqr	equ	*		irq entry
rsrvdr	bsr	lddp		set base page, validate stack
	bra	zbkpnt 		force a breakpoint
   
******************************************
*        firq handler
*  just return for the firq interrupt
******************************************

firqr	equ	rti		immediate return
   
**************************************************
*      default i/o drivers
**************************************************
   
* cidta - return console input character
* output: c=0 if no data ready, c=1 a=character
* u volatile
*
* several modifications were made to the acia
* i/o driver so that a mc68681 duart could be
* used in its place.  modifications involved setting
* up offsets (stat,reciv,etc.) to the base hardware
* address so that the duart's internal registers 
* could be accessed, along with more extensive
* initialization than that needed by the acia
* (i.e. setting up baud rate etc.)
*
cidta	ldu	<vectab+.duart	load acia address
	lda	stat,u		load status register
	lsra	test		reciever register flag
	bcc	cirtn		return if nothing
	lda	reciv,u		load data byte
cirtn	rts			return to caller
   
* cion - input console initialization
* coon - output console initialization
* a,x  volatile
cion	equ	*
coon	ldd	#mbaud		initialize mode r1 and baud rate
	ldx	<vectab+.duart	load duart address
	std	mr1a,x		7bity no parity and 9600 baud
	lda	#$07		mode register 2
	sta	mr2a,x		normal mode 2 stop bits
	ldd	#$8008		counter mode,external clock
	std	acr,x		baud rate set 2 timer int enabled
	lda	#$15		command register init.
	sta	cra,x		enable transmitter and receiver
	ldd	#$0010		initial count is 16 for the counter
	std	ctur,x		15 for rti 1 to trace 1 inst.
rts	rts			return to caller
    
* the following have no duties to perform

cioff	equ	rts		console input off
cooff	equ	rts		console output off
   
* codta - output character to console device
* input: a=character to send
* output: char sent to terminal with proper padding
* all registers transparent
    
codta	pshs	u,d,cc		save registers,work byte
	ldu	<vectab+.duart	address duart
	bsr	codtao		call output char subrotine
	cmpa	#dle		? data line escape
	beq	codtrt		yes, return
	ldb	<vectab+.pad	default to char pad count
	cmpa	#cr		? cr
	bne	codtpd		branch no
	ldb	<vectab+.pad+1	load new line pad count
codtpd	clra			create null
	stb	,s		save count
	fcb	skip2		enter loop
codtlp	bsr	codtao		send null
	dec	,s		? finished
	bpl	codtlp		no, continue with more
codtrt	puls	pc,u,d,cc	restore registers and return
    
codtad	lbsr	xqpaus		temporary give up control
codtao	ldb	stat,u		load acia control register
	bitb	#$04		? tx register clear
	beq	codtad		release control if not
	sta	trans,u		store into data register
	rts			return to caller
*e
   
* bson - turn on read/verify/punch mechanism
* a is volatile
    
bson	lda	#$11		set read code
	tst	6,s		? read or verify
	bne	bson2		branch yes
	inca			set to write
bson2	swi			perform output
	fcb	outch		function
	inc	<misflg		set load in progress flag
	rts	return		to caller
   
* bsoff - turn off read/verify/punch mechanism
* a,x volatile

bsoff	lda	#$14		to dc4 - stop
	swi			send out
	fcb	outch		function
	deca			change to dc3 (x-off)
	swi			send out
	fcb	outch		function
	dec	<misflg		clear load in progress flag
	ldx	#25000 		delay 1 second (2mhz clock)
bsoflp	leax	-1,x		count down
	bne	bsoflp		loop till done
	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	bsdpun		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
bsdld1	swi			get next character
	fcb	inchnp		function
bsdld2	cmpa	#'S		? start of s1/s9
	bne	bsdld1		branch not
	swi			get next character
	fcb	inchnp		function
	cmpa	#'9		? have s9
	beq	bsdsrt		yes, return good code
	cmpa	#'1		? have new record
	bne	bsdld2		branch if not
	clr	,s		clear checksum
	bsr	byte		obtain byte count
	stb	1,s		save for decrement
* read address
	bsr	byte		obtain high value
	stb	2,s		save it
	bsr	byte		obtain low value
	lda	2,s		make d=value
	leay	d,u		y=address+offset
* store text
bsdnxt	bsr	byte		next byte
	beq	bsdeol		branch if checksum
	tst	9,s		? verify only
	bmi	bsdcmp		yes, only compare
	stb	,y		store into memory
bsdcmp	cmpb	,y+		? valid ram
	beq	bsdnxt		yes, continue reading
bsdsrt	puls	pc,x,a		return with z set proper
    
bsdeol	inca			? valid checksum
	beq	bsdld1		branch yes
	bra	bsdsrt		return z=0 invalid
    
* byte builds 8 bit value from two hex digits in
byte	bsr	bythex		obtain first hex
	ldb	#16		prepare shift
	mul			over to a
	bsr	bythex		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
bytrts	rts			return to caller
    
bythex	swi			get next hex
	fcb	inchnp		character
	lbsr	cnvhex		convert to hex
	beq	bytrts		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

bsdpun	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
	fcb	outch		function
	ldb	#4		setup new line pad to 4
	std	<vectab+.pad	setup punch padding
* calculate size
bspgo	ldd	8,s		load to
	subd	2,s		minus from=length
	cmpd	#24		? more than 23
	blo	bspok		no, ok
	ldb	#23		force to 23 max
bspok	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	<bspstr,pcr	load start record header
	swi			send out
	fcb	pdata		function
* send frame count
	clrb			initialize checksum
	leax	1,s		point to frame count and addr
	bsr	bspun2		send frame count
*data address
	bsr	bspun2		send address hi
	bsr	bspun2		send address low
*punch data
	ldx	2,s		load start data address
bspmre	bsr	bspun2		send out next byte
	dec	,s		? final byte
	bne	bspmre		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	bspunc		send out as hex
	ldx	8,s		load top address
	cmpx	2,s		? done
	bhs	bspgo		branch not
	leax	<bspeof,pcr	prepare end of file
	swi			send out string
	fcb	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
    
bspun2	addb	,x		add to checksum
bspunc	lbra	zout2h		send out as hex and return
    
bspstr	fcb	'S,'1,eot cr,lf,nulls,S,1
bspeof	fcc	/S9030000FC/	eof string
	fcb	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
	fcb	pcrlf		function
	ldb	#6		prepare 6 spaces
hsblnk	swi			send blank
	fcb   space		function
	decb			count down
	bne	hsblnk		loop if more
	clrb			setup byte count
hshttl	tfr	b,a		prepare for convert
	lbsr	zouthx		convert to a hex digit
	swi			send blank
	fcb	space		function
	swi			send another
	fcb	space		blank
	incb			up another
	cmpb	#$10		? past 'f'
	blo	hshttl		loop until so
hshlne	swi			to next line
	fcb	pcrlf		function
	bcs	hsdrtn		return if user entered ctl-x
	leax	4,s		point at address to convert
	swi			print out address
	fcb	out4hs		function
	ldx	4,s		load address proper
	ldb	#16		next sixteen
hshnxt	swi			convert byte to hex and send
	fcb	out2hs		function
	decb			count down
	bne	hshnxt		loop if not sixteenth
	swi			send blank
	fcb	space		function
	ldx	4,s		reload from address
	ldb	#16		count
hshchr	lda	,x+		next byte
	bmi	hshdot		too large, to a dot
	cmpa	#' 		? lower than a blank
	bhs	hshcok		no, branch ok
hshdot	lda	#'.		convert invalid to a blank
hshcok	swi			send character
	fcb	outch		function
	decb			? done
	bne	hshchr		branch no
	cpx	2,s		? past last address
	bhs	hsdrtn		quit if so
	stx	4,s		update from address
	lda	5,s		load low byte address
	asla			? to section boundry
	bne	hshlne		branch if not
	bra	hsdta		branch if so
hsdrtn	swi			send new line
	fcb	pcrlf		function
	rts			return to caller
*f
   
***********************************************
*     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	fcb	'P,'C,-1,19	pc reg
	fcb	'A,0,10		a reg
	fcb	'B,0,11		b reg
	fcb	'X,-1,13	x reg
	fcb	'Y,-1,15	y reg
	fcb	'U,-1,17	u reg
	fcb	'S,-1,1		s reg
	fcb	'C,'c,0,9	cc reg
	fcb	'D,'p,0,12	dp reg
	fcb	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
regp1	ldd	,y+		load next char or <=0
	tsta			? end of characters
	ble	regp2		branch not character
	swi			send to console
	fcb	outch		function byte
	bra	regp1		check next
regp2	lda	#'-		 ready '-'
	swi			send out
	fcb	outch		with outch
	leax	b,s		x->register to print
	tst	,s		? change option
	bne	regcng		branch yes
	tst	-1,y		? one or two bytes
	beq	regp3		branch zero means one
	swi			perform word hex
	fcb	out4hs		function
	fcb	skip2		skip byte print
regp3	swi			perform byte hex
	fcb	out2hs		function
reg4	ldd	,y+		to front of next entry
	tstb			? end of entries
	bne	regp1		loop if more
	swi			force new line
	fcb	pcrlf		function
regrtn	puls	pc,y,x,a	restore stack and return
    
regcng	bsr	bldnnb		input binary number
	beq	regnxc		if change then jump
	cmpa	#cr		? no more desired
	beq	regagn		branch nope
	ldb	-1,y		load size flag
	decb			minus one
	negb			make positive
	aslb			times two (=2 or =4)
regskp	swi			perform spaces
	fcb	space		function
	decb
	bne	regskp		loop if more
	bra	reg4		continue with next register
regnxc	sta	,s		save delimiter in option
*                     (always > 0)
	ldd	<number		obtain binary result
	tst	-1,y		? two bytes worth
	bne	regtwo		branch yes
	lda	,-x		setup for two
regtwo	std	,x		store in new value
	lda	,s		recover delimiter
	cmpa	#cr		? end of changes
	bne	reg4		no, keep on truck'n
* move stacked data to new stack in case stack
* pointer has changed
regagn	leax	tstack,pcr	load temp area
	ldb	#21		load count
regtf1	puls	a		next byte
	sta	,x+		store into temp
	decb			count down
	bne	regtf1		loop if more
	lds	-20,x		load new stack pointer
	ldb	#21		load count again
regtf2	lda	,-x		next to store
	pshs	a		back onto new stack
	decb			count down
	bne	regtf2		loop if more
	bra	regrtn		go restart command
   
*********************************************
*  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
	fcb	skip2		skip next instruction
* 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
expdlm	bsr	bldhxi		clear number, check first char
	beq	exp2		if hex digit continue building
* skip blanks if desired
	cmpa	<delim		? correct delimiter
	beq	expdlm		yes, ignore it
* test for m or p
	ldx	<addr		default for 'm'
	cmpa	#'M		? memory examine addr wanted
	beq	exptdl		branch if so
	ldx	<pcnter		default for 'p'
	cmpa	#'P		? last program counter wanted
	beq	exptdl		branch if so
	ldx	<window		default to window
	cmpa	#'W		? window wanted
	beq	exptdl
exprtn	puls	pc,x,b		return and restore registers
* got hex, now continue building
exp2	bsr	bldhex		compute next digit
	beq	exp2		continue if more
	bra	expcdl		search for +/-
* store value and check if need delimiter
exptdi	ldx	,x		indirection desired
exptdl	stx	<number		store result
	tst	<delim		? to force a delimiter
	beq	exprtn		return if not with value
	bsr	read		obtain next character
* test for + or -
expcdl	ldx	<number		load last value
	cmpa	#'+		? add operator
	bne	expchm		branch not 
	bsr	exptrm		compute next term
	pshs	a		save delimiter
	ldd	<number		load new term
expadd	leax	d,x		add to x
	stx	<number		store as new result
	puls	a		restore delimiter
	bra	expcdl		now test it
expchm	cmpa	#'-		? subtract operator
	beq	expsub		branch if so
	cmpa	#'@		? indirection desired
	beq	exptdi		branch if so
	clrb			set delimiter return
	bra	exprtn		and return to caller
expsub	bsr	exptrm		obtain next term
	pshs	a		save delimiter
	ldd	<number		load up next term
	nega	negate		a
	negb	negate		b
	sbca	#0		correct for a
	bra	expadd		go add to expresion

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

exptrm	bsr	bldnum		obtain next value
	beq	cnvrts		return if valid number
bldbad	lbra	cmdbad		abort command if invalid
   
*********************************************
*  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	<number		clear number
	clr	<number+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
bldshf	aslb			obtain next bit
	rol	<number+1		into low byte
	rol	<number		into hi byte
	deca			count down
	bne	bldshf		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	#$0f		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
	fcb			inchnp function
	cmpa	#can		? abort command
	beq	bldbad		branch to abort if so
	rts			return to caller
*g
   
************   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		recover return address
	pshs	x		store return back
	bne	gondft		if no carf ? swi breakpointed
*  default program counter, so fall through if
*  immediate breakpoint.
	lbsr	cbkldr		search breakpoints
	ldx	12,s		load program counter
armblp	decb			count down
	bmi	armbk2		done, none to single trace
	lda	-numbkp*2,y	pre-fetch opcode
	cmpx	,y++		? is this a breakpoint
	bne	armblp		loop if not
	cmpa	#$3f		? swi breakpointed
	bne	armnsw		no, skip setting of pass flag
	sta	<swibfl		show upcomming swi not brkpnt
armnsw	inc	<misflg		flag thru a breakpoint
	lbra	cdot		do single trace w/o breakpoints
* obtain new program counter
gondft	lbsr	cdnum		obtain new program counter
	std	12,s		store into stack
armbk2	lbsr	cbkldr		obtain table
	neg	<bkptct		complement to show armed
armlop	decb			? done
	bmi	cnvrts		return when done
	lda	[,y]		load opcode
	sta	-numbkp*2,y	store into opcode table
	lda	#$3f		ready "swi" opcode
	sta	[,y++]		store and move up table
	bra	armlop		and continue

*****************   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
cgobrk	swi			perform breakpoint
	fcb	brkpt		function
	bra	cgobrk		loop until user changes pc
   
*****************memory - display/change memory
* cmemn and cmpadp are direct entry points from
* the command handler for quick commands
cmem	lbsr	cdnum		obtain address
cmemn	std	<addr		store default
cmem2	ldx	<addr		load pointer
	lbsr	zout2h		send out hex value of byte
	lda	#'-		load delimiter
	swi			send out
	fcb	outch		function
cmem4	lbsr	bldnnb		obtain new byte value
	beq	cmenum		branch if number
* coma - skip byte
	cmpa	#',		? comma
	bne	cmnotc		branch not
	stx	<addr		update pointer
	leax	1,x		to next byte
	bra	cmem4		and input it
cmenum	ldb	<number+1	load low byte value
	bsr	mupdat		go overlay memory byte
	cmpa	#',		? continue with no display
	beq	cmem4		branch yes
* quoted string
cmnotc	cmpa	#''		? quoted string
	bne	cmnotq		branch no
cmestr	bsr	read		obtain next character
	cmpa	#''		? end of quoted string
	beq	cmspe		yes, quit string mode
	tfr	a,b		to b for subroutine
	bsr	mupdat		go update byte
	bra	cmestr		get next character
* blank - next byte
cmnotq	cmpa	#$20		? blank for next byte
	bne	cmnotb		branch not
	stx	<addr		update pointer
cmspe	swi			give space
	fcb	space		function
	bra	cmem2
* line feed - next byte with address
cmnotb	cmpa	#lf		? line feed for next byte
	bne	cmnotl		branch no
	lda	#cr		give carriage return
	swi			to console
	fcb	outch		handler
	stx	<addr		store next address
	bra	cmpadp		branch to show
* up arrow - previous byte and address
cmnotl	cmpa	#'^		? up arrow for previous byte
	bne	cmnotu		branch not
	leax	-2,x		down to previous byte
	stx	<addr		store new pointer
cmpads	swi			force new line
	fcb	pcrlf		function
cmpadp	bsr	prtadr		go print its value
	bra	cmem2		then prompt for input
* slash - next byte with address
cmnotu	cmpa	#'/		? slash for current display
	beq	cmpads		yes, send address
	rts			return from command
    
* print current address
prtadr	ldx	<addr		load pointer value
	pshs	x		save x on stack
	leax	,s		point to it for display
	swi			display pointer in hex
	fcb	out4hs		function
	puls	pc,x		recover pointer and return
   
* update byte
mupdat	ldx	<addr		load next byte pointer
	stb	,x+		store and increment x
	cmpb	-1,x		?  successfull store
	bne	mupbad		branch for '?'  if not
	stx	<addr		store new pointer value
	rts			back to caller
mupbad	pshs	a		save a register
	lda	#'?		show invalid
	swi			send out
	fcb	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	#$f0		force to 16 boundry
	tfr	d,y		save in y
	leax	15,y		default length          
	bcs	cdisps		branch if end of input
	bsr	cdnum		obtain count
	leax	d,y		assume count, compute end addr
cdisps	pshs	y,x		setup parameters for hsdata
	cmpd	2,s		? was it count
	bls	cdcnt		branch yes
	std	,s		store high address
cdcnt	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
	bne	cdbadn		branch if invalid
	cmpa	#'/		? valid delimiter
	bhi	cdbadn		branch if not for error
	cmpa	#cr+1		leave compare for carriage ret
	ldd	<number		load number
	rts
cdbadn	lbra	cmdbad		return to error mechanism
   
*************   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
	bne	cdbadn		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
	fcb	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	clvdft		branch if carriage return next
	bsr	cdnum		obtain offset
	fcb	skip2		skip default offset
clvdft	clra	create		zero offset
	clrb			as default
	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
	fcb	-1		verify fnctn code for packet
   
***************  trace - trace instructions
*                . - single step trace
*
* modifications were made to the trace routine 
* so the counter on the mc68681 duart could be 
* used in place of the timer on the mc6840 ptm.
* irq on the mc68681 was used to execute the trace.
*
ctrace	bsr	cdnum		obtain trace count
	std	<tracec		store count
cdot	leas	2,s		rid command return from stack
ctrce3	ldu	[10,s]		load opcode to execute
	stu	<lastop		store for trace interrupt
	ldu	<vectab+.duart load duart address
	lda	scc,u		issue start counter command
	rti			return for one instruction
   
*************nulls  -  set new line and char padding

cnulls	bsr	cdnum		obtain new line pad
	std	<vectab+.pad	reset values
	rts			end command
   
******************stlevel - set stack trace level

cstlev	beq	stldft		take default
	bsr	cdnum		obtain new stack level
	std	<slevel		store new entry
	rts			to command handler
stldft	leax	14,s		compute nmi compare
	stx	<slevel		and store it
	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	cofno1		branch if not
	swi			show one byte offset
	fcb	out2hs		function
cofno1	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
	fcb	out4hs		function
	swi			force new line
	fcb	pcrlf		function
	puls	pc,x,d		restore stack and end command
*h
   
*************  breakpoint - display/enter/delete/clear
*              breakpoints

cbkpt	beq	cbkd		branch display of just 'b'
	lbsr	bldnum		attempt value entry
	beq	cbkadd		branch to add if so
	cmpa	#'-		? correct delimiter
	bne	cbkerr		no, branch for error
	lbsr	bldnum		attempt delete value
	beq	cbkdle		got one, go delete it
	clr	<bkptct		was 'b -', so zero count
cbkrts	rts			end command
* delete the entry
cbkdle	bsr	cbkset		setup registers and value
cbkdlp	decb			? any entries in table
	bmi	cbkerr		branch no, error
	cmpx	,y++		? is this the entry
	bne	cbkdlp		no, try next
* found, now move others up in its place
cbkdlm	ldx	,y++		load next one up
	stx	-4,y		move down by one
	decb			? done
	bpl	cbkdlm		no, continue move
	dec	<bkptct		decrement breakpoint count
cbkd	bsr	cbkset		setup registers and load value
	beq	cbkrts		return if none to di   ly
cbkdsl	leax	,y++		point to next entry
	swi			display in hex
	fcb	out4hs		function
	decb			count down
	bne	cbkdsl		loop if more to do
	swi			skip to new line
	fcb	pcrlf		function
	rts			return to end command
* add new entry
cbkadd	bsr	cbkset		setup registers
	cmpb	#numbkp		? already full
	beq	cbkerr		branch error if so
	lda	,x		load byte to trap
	stb	,x		try to change
	cmpb	,x		? changable ram
	bne	cbkerr		branch error if not
	sta	,x		restore byte
cbkadl	decb			count down
	bmi	cbkadt		branch if done to add it
	cmpx	,y++		? entry already here
	bne	cbkadl		loop if not
cbkerr	lbra	cmdbad		return to error produce
cbkadt	stx	,y		add this entry
	clr	-numbkp*2+1,y	clear optional byte
	inc	<bkptct		add one to count
	bra	cbkd		and now display all of 'em
* setup registers for scan
cbkset	ldx	<number		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
	fcb	inchnp		function
	cmpa	#'[		? indirect here
	bne	cen2		branch if not
	lda	#$10		set indirect bit on
	sta	,s		save for later
cenget	swi			obtain next character
	fcb	inchnp		function
cen2	cmpa	#cr		? end of entry
	beq	cend1		branch yes
cenlp1	tst	,x		? end of table
	bmi	cbkerr		branch error if so
	cmpa	,x++		? this the character
	bne	cenlp1		branch if not
	addb	-1,x		add this value
	bra	cenget		get next input
cend1	leax	<conv2,pcr	point at table 2
	tfr	b,a		save copy in a
	anda	#$60		isolate register mask
	ora	,s		add in indirection bit
	sta	,s		save back as postbyte skeleton
	andb	#$9f		clear register bits
cenlp2	tst	,x		? end of table
	beq	cbkerr		branch error if so
	cmpb	,x++		? same value
	bne	cenlp2		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
	fcb	out2hs		function
	swi			to next line
	fcb	pcrlf		function
	puls	pc,b		end of command
   	 
* table one defines valid input in sequence
conv1	fcb	'A,$04,'B,$05,'C,$06,'H,$01
	fcb	'H,$01,'H,$01,'H,$00,',,$00
	fcb	'-,$09,'-,$01,'S,$70,'Y,$30
	fcb	'U,$50,'X,$10,'+,$07,'+,$01
	fcb	'P,$80,'C,$00,'R,$00,'],$00
	fcb	$ff		end of table
*conv2 uses above conversion to set postbyte
*                             bit skeleton.
conv2	fdb	$1084,$1100	R,        H,R
	fdb	$1288,$1389	HH,R      HHHH,R
	fdb	$1486,$1585	A,R       B,R
	fdb	$168b,$1780	D,R       ,R+
	fdb	$1881,$1982	,R++      ,-R
	fdb	$1a83,$828c	,--R      HH,pcr
	fdb	$838d,$039f	HHHH,pcr  [HHHH]
	fcb	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
   
******************************************************
*             assist09 hardware vector table
*  this table is used if the assist09 rom addresses
*  the mc6809 hardware vectors.
******************************************************

	org	rombeg+romsiz-16	setup hardware vectors
	fdb	rsrvd		reserved slot
	fdb	swi3		software interrupt 3
	fdb	swi2		software interrupt 2
	fdb	firq		fast interrupt request
	fdb	irq		interrupt request
	fdb	swi		software interrupt
	fdb	nmi		non-maskable interrupt
	fdb	reset		restart
   
	end	reset