GEMini Atari

home *** CD-ROM | disk | FTP | other *** search

/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / language / asxbin / ast09.asm < prev next >

Wrap

Assembly Source File | 1993-10-23 | 49.7 KB | 1,726 lines

.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