GEMini Atari

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

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

Wrap

Assembly Source File | 1993-10-23 | 53.5 KB | 2,290 lines

.title MONDEB - 09 ; ********************************************************* ; * * ; * MONDEB - 09 - a monitor/debugger * ; * for the 6809 microprocessor * ; * * ; ********************************************************* ; ; author: Don Peters (6800 version) ; date: April 1977 ; ; modified for the 6809 ; by: Alan R. Baldwin ; date: Nov 1988 ; ; This 6809 monitor/debugger does not use the ; direct page addressing mode. Thus the user ; program has complete control of the page ; assignment and may use the monitor routines ; without concern for variable locations. ; ; To add user functions to MONDEB - 09 ; ; 1) add your commands to the end of command list #1 ; 2) add the command entry points to the jump table ; 3) append any local command lists after MONDEB's ; 4) provide an external initialization routine to ; set up the console (and/or alternate) ; ports and any other start up processing. ; MONDEB will call 'userinit' if inituser = 1. ; .module mond09 standalone = 0 ; standalone flag indicating the ; vectors and associated code are ; to be included during assembly inituser = 0 ; call 'userinit' flag indicating ; a user startup routine will be ; called during intialization .page .sbttl MONDEB - 09 working variables .radix d .if standalone .area WORKPG (REL,CON) .else .area WORKPG (ABS,OVR) .endif .setdp 0 workpg: .blkb 256-(endpg-mstack) ; main stack storage mstack: .blkb 12 ; stack storage for rti instruction ttybuf: .blkb 72 ; start of input line buffer ttyend: .blkb 1 ; end of input line buffer bufbeg: .blkb 2 ; input line start of buffer bufend: .blkb 2 ; input line end of buffer comadr: .blkb 2 ; address of beginning of command lists synptr: .blkb 2 ; input line character pointer for good syntax linptr: .blkb 2 ; input line character pointer (content => ; content of synptr) bolflg: .blkb 1 ; "beginning of line flg" delim: .blkb 1 ; characters permitted as valid command/modifier ; delimiter ibcode: .blkb 1 ; input base (1=hex, 2=dec, 3=oct) dbcode: .blkb 1 ; display base (1=hex, 2=dec, 3=oct, 4=bin) dbnbr: .blkb 1 ; display base number (e.g., 16,10,8, or 2) nbrhi: .blkb 1 ; most significant byte of scanned number nbrlo: .blkb 1 ; least significant byte of scanned number ranglo: .blkb 2 ; range lower limit picked up by gtrang ranghi: .blkb 2 ; range upper limit picked up by gtrang verfrm: .blkb 2 ; beginning address of range to verify verto: .blkb 2 ; ending address of range to checksum verify chksum: .blkb 1 ; checksum of range given in the verify command brkadr: .blkb 2 ; address of inserted breakpoint brkins: .blkb 1 ; instruction which should be there normally inpflg: .blkb 1 ; alternate input flag outflg: .blkb 1 ; alternate output flag outadr: .blkb 2 ; alternate address that the output chars go to hdxflg: .blkb 1 ; half-duplex terminal flag (if non-zero, no echo) cplcnt: .blkb 1 ; "characters per line" count cplmax: .blkb 1 ; "characters per line" maximum ; temporary (locally used) variables temp1: .blkb 2 ; in: main temp2: .blkb 2 ; in: main temp3: .blkb 2 ; in: main temp4: .blkb 2 ; in: main temp5: .blkb 2 ; in: main temp6: .blkb 2 ; in: main nummat: .blkb 1 ; used in command lisnum: .blkb 1 ; used in command comnum: .blkb 1 ; used in command lisptr: .blkb 2 ; used in command decdig: .blkb 1 ; decimal digit being built numbhi: .blkb 1 ; used by outnum numblo: .blkb 1 ; used by outnum nbr2x: .blkb 2 ; used by number timcon: .blkb 2 ; delay time constant bytect: .blkb 1 ; record byte count used in load command cksm: .blkb 1 ; record checksum used in load command conin: .blkb 2 ; address of console input routine conout: .blkb 2 ; address of console output routine altin: .blkb 2 ; address of alternate input routine altout: .blkb 2 ; address of alternate output routine .rsrvd: .blkb 2 ; reserved vector .swi3: .blkb 2 ; swi3 vector .swi2: .blkb 2 ; swi2 vector .firq: .blkb 2 ; firq vector .irq: .blkb 2 ; irq vector .swi: .blkb 2 ; swi vector .nmi: .blkb 2 ; nmi vector spsave: .blkb 2 ; saved stack pointer endpg: ; convenient equivalences for local variables memadr = temp1 ; display, set, search, test strnum = temp2 ; fndstr eoschr = temp2+1 ; fndstr ; for "search" command bytptr = temp2 nbytes = temp3 nbrmat = temp3+1 bytstr = temp4 ; other constants cr = 13 ; carriage return lf = 10 ; line feed .page .sbttl MOND09 Startup .if standalone .area MONDEB (REL,CON) reset: lds #mstack+12 ; load stack pointer bsr mond09 ; stack pc and start mondeb bra reset .else .area MONDEB (ABS,OVR) .endif mond09: pshs u,y,x,dp,b,a,cc ; pseudo swi sts spsave ; save the pointer orcc #0b01010000 ; hold irq and firq interrupts lds #mstack ; initialize the stack pointer jsr inital ; initialize variables jsr docrlf ; advance to a clean line ldx #msghed ; get address of header jsr outstr ; type it ldx #ttybuf-1 ; get address of terminal input buffer stx bufbeg ; save it ldx #ttyend ; define end of input buffer stx bufend ; 72 char capacity, incl cr lda #3 ; delimiter class definition sta delim ; space or comma (code 3) bra promp1 ; prepare to get a new command prompt: jsr docrlf ; type cr-lf inc bolflg ; set 'beginning of line' flag ldx synptr ; point to current character lda ,x ; get it cmpa #'; ; semicolon? beq getcmd ; continue scan if it is, ; skipping the prompt promp1: ldx #msgprm ; type prompt jsr outstr jsr getlin ; get line of input cmpb #3 ; abort line on a control-c beq prompt ldx bufbeg ; set syntax scanning pointer stx synptr ; to beginning of buffer/line lda 1,x ; get first char jsr tsteol ; reprompt on an empty line beq prompt ; (first char = cr,lf,or ;) .page .sbttl Get Command getcmd: lda #1 ; use list 1 when matching jsr comand ; now go for a match beq prompt ; reprompt if just a cr was typed bgt jmpcmd ; good command if positive badsyn: ldx bufbeg ; get start of line 1$: cpx linptr ; space over to the error in syntax beq 2$ ; at error ? jsr outsp ; output a space inx ; no, move on bra 1$ ; the 'extra' char '1' is compensated for by the prompt ; char on the preceeding line 2$: lda #'^ ; at error - get an up-arrow jsr outchr ; print it jsr docrlf bra promp1 ; ignore any succeeding packed ; commands ; ******* ; *there should be no more characters on the input line ; (except delimiters) nomore: jsr skpdlm bcs prompt ; if carry bit set, end of line ; (normal) bra badsyn ; there is something there but shouldn't be .page .sbttl Command Dispatcher ; ****** ; execute a computed 'goto' to the proper command jmpcmd: asla ; multiply command by 2 ldx #1$-2 jmp [a,x] ; jump to designated command 1$: .word break .word contin .word compar .word copy .word displa .word dbase .word delay .word dump .word goto .word help .word ibase .word load .word reg .word set .word search .word test .word verify .word cli .word clf .word sei .word sef .word xirq .word xfirq .word xnmi .word xrsrvd .word xswi .word xswi2 .word xswi3 .page .sbttl REG - display registers reg: ; print stack stored swi data disreg: ldx spsave ; get saved stack pointer clr comnum ; start at beginning of the ; register name list bsr 1$ ; type condition codes bsr 1$ ; type acca bsr 1$ ; type accb bsr 1$ ; type dp jsr docrlf ; advance to a clean line bsr 2$ ; type index reg x bsr 2$ ; type index reg y bsr 2$ ; type index reg u jsr docrlf ; advance to a clean line leax -9,x ; back to d bsr 2$ ; type d leax 7,x ; back to pc bsr 2$ ; type program counter ; type the stack pointer location bsr 3$ ; type stack pointer id ldx #spsave jsr out2by ; type the value jmp nomore ; output content of a 1 byte register 1$: bsr 3$ jsr out1by inx rts ; output content of a 2 byte register 2$: bsr 3$ jsr out2by leax 2,x ; skip to next word in stack rts ; misc setup for register display 3$: jsr outsp ; output a space inc comnum ; skip to next register name lda #5 ; register name is in list 5 jsr typcmd ; type it jsr outeq ; type an '=' rts .page .sbttl Software Interrupt Entry Point typswi: sts spsave ldx #msgswi jsr outstr ; decrement pc so it points to 'swi' instruction ldx spsave ldd 10,x subd #1 cmpd brkadr ; a break point ? bne disreg ; no - allow to pass std 10,x ; backup PC bra disreg ; go display registers .sbttl GOTO - Go To Memory Address goto: jsr mnumber ; get destination beq contin ; if none, just continue ldd nbrhi lds spsave ; place new PC std 10,s ; fall through to Continue .sbttl Continue - Continue From a 'SWI' contin: lds spsave ; in case sp was modified via set rti ; command .sbttl SEI - Set Interrupt Mask sei: orcc #0b00010000 jmp nomore .sbttl CLI - Clear Interrupt Mask cli: andcc #~0b00010000 jmp nomore .sbttl SEF - Set Fast Interrupt Mask sef: orcc #0b01000000 jmp nomore .sbttl CLF - Clear Fast Interrupt Mask clf: andcc #~0b01000000 jmp nomore .page .sbttl COPY - Copy From One Location To Another copy: jsr gtrang ; get source range into ranglo & ; ranghi lble badsyn ; error if no source jsr mnumber ; get destination lble badsyn ; error if no destination ldx ranglo ; get source address pointer ldu nbrhi ; get destination address pointer lda ,x ; get byte from source 1$: sta ,u+ ; save byte in destination cpx ranghi ; compare to end of input range lbeq nomore ; done if equal lda ,x+ ; get byte from source bra 1$ ; loop for next byte .page .sbttl BREAK - Set Breakpoint at Specified Address break: jsr mnumber ; get breakpoint location bmi 3$ ; if not numeric, look for '?' beq 2$ ; if no modifier, remove old breakpoint ldx brkadr ; get current break address lda ,x ; and the char there cmpa #0x3f ; compare to 'swi' bne 1$ ; equal? lda brkins ; yes, restore the old instruction sta ,x ; restore it 1$: ldx nbrhi ; get new breakpoint stx brkadr ; save it lda ,x ; get instruction stored there sta brkins ; save it lda #0x3f ; get code for software interrupt sta ,x ; put it at breakpoint bra 5$ ; all done 2$: ldx brkadr ; get address of break lda ,x ; get inst. there cmpa #0x3f ; swi? bne 5$ ; if not, return & prompt lda brkins ; was a swi - get previous inst. sta ,x ; & restore it bra 5$ 3$: lda #4 jsr comand ; scan for it lble badsyn ; bad syntax if not '?' ldx brkadr ; it is, get break address lda ,x ; get instruction there cmpa #0x3f ; is it a 'swi'? beq 4$ ; if yes, say so ldx #msgnbr ; get that message jsr outstr ; say it bra 5$ 4$: ldx #msgbat ; get that message jsr outstr ; say it ldx #brkadr ; get break address jsr out2by ; type it 5$: jmp nomore .page .sbttl IBASE - Set Input Base ibase: lda #3 ; look for hex,dec,or oct in list #3 jsr comand bmi 2$ ; unrecognizable base, try'?' bgt 1$ lda #1 ; no base given - default to hex 1$: sta ibcode ; save base code jmp nomore 2$: lda ibcode ; get ib code in case its needed pshs a ; save it on stack temporarily bra ibdbq .sbttl DBASE - Set Display Base dbase: lda #3 ; look for hex,dec,oct, or bin in list #3 jsr comand bmi 3$ ; unrecognizable base, try '?' bgt 1$ lda #1 ; no base given - default to hex 1$: sta dbcode ldx #2$-1 ; get numeric base from table lda a,x sta dbnbr ; save it jmp nomore ; done 2$: .byte 16 ; display base table .byte 10 .byte 8 .byte 2 3$: lda dbcode ; get db code in case its needed pshs a ; save it on stack temporarily ibdbq: lda #4 ; look for '?' in list #4 jsr comand puls b ; retrieve input base/display base code lble badsyn ; error if the 'something' was not a '?' lda #3 ; base code is in list 3 stb comnum ; store base code jsr typcmd ; type out base jmp nomore .page .sbttl Display - Display Memory Data displa: jsr gtrang ; get memory display range lble badsyn ; address is required ldx ranglo ; initialize address pointer stx memadr lda #6 ; search list 6 for jsr comand ; display modifiers 'data' or 'used' lbmi badsyn ; any other modifier is illegal deca ; adj display modifier code so that: sta comnum ; -1=addr & data, 0=data, 1=used clrb ; init 'data values per line' counter incb 1$: ldx #memadr tst comnum ; which display option? bmi 6$ ; if 'address & data', go there decb ; count data values per line bne 2$ ; if count not up, skip address output jsr docrlf ; get to line beginning jsr out2by ; output address jsr outsp ; and a space ldb dbnbr ; reset line counter 2$: ldx memadr ; point to data at that address tst comnum ; want 'data' option? bgt 3$ ; if not, go to 'used' code jsr outsp ; output preceedng space bra 7$ 3$: lda ,x ; get the data bne 4$ lda #'. ; its zero, get a '.' bra 5$ 4$: lda #'+ ; its non-zero, get a '+' 5$: jsr outchr ; output the '.' or '+' bra 8$ 6$: jsr outsp ; output a preceeding space jsr out2by ; type address jsr outeq ; type '=' ldx ,x ; get content 7$: jsr out1by ; type it 8$: cpx ranghi ; are we done lbeq nomore ; if yes, back to prompt inx ; no, inc memory address stx memadr ; save it bra 1$ .page .sbttl SET - Set Memory Locations set: jsr gtrang ; get memory location/range bmi 5$ ; if not an address, look for a ; register name lbeq badsyn ; an address modifier is required ; range of address specified? ldx ranglo cpx ranghi beq 2$ ; if single address, set up ; addresses individually ; set a range of addresses to a single value jsr mnumber ; get that value lble badsyn ; its required lda nbrlo ; put it in acca 1$: sta ,x ; store it in destination cpx ranghi ; end of range hit? lbeq nomore ; if yes, all done inx ; no, on to next address in range bra 1$ ; loop to see it ; set addresses up individually 2$: stx memadr ; save memory loc 3$: jsr mnumber ; get data to put there beq 4$ ; end of line? lblt badsyn ; abort if bad syntax lda nbrlo ; load data byte ldx memadr ; load address sta ,x+ ; store data bra 2$ 4$: ldx synptr ; point to end of line lda ,x ; get char there cmpa #lf ; line feed? lbne nomore ; if not,back to prompt ldx #memadr ; yes, get next address to be set jsr out2by ; type it jsr outsp ; and a space jsr getlin ; get a new line ldx bufbeg ; get buffer beginning stx synptr ; equate it to syntax scan pointer bra 3$ ; go pick up data ; look for (register name, register value) pairs 5$: lda #5 jsr comand ; pick up a register name lbmi badsyn ; error if unrecognizable lbeq nomore ; done if end of line pshs a ; save register name(number) jsr mnumber ; get new register value puls a ; restore register name(number) lble badsyn ; got good register value? deca ldu #6$ lda a,u leau a,u ldx spsave ; yes, point to top of stack ldd nbrhi ; get register value jsr ,u ; go to function bra 5$ ; and loop 6$: .byte 7$-6$ .byte 8$-6$ .byte 9$-6$ .byte 10$-6$ .byte 11$-6$ .byte 12$-6$ .byte 13$-6$ .byte 14$-6$ .byte 15$-6$ .byte 16$-6$ 7$: stb ,x ; condition codes rts 8$: stb 1,x ; acca rts 9$: stb 2,x ; accb rts 10$: stb 3,x ; dp rts 11$: std 4,x ; ix rts 12$: std 6,x ; iy rts 13$: std 8,x ; iu rts 14$: std 1,x ; d rts 15$: std 10,x ; pc rts 16$: std spsave ; sp rts .page .sbttl Checksum Verify a Block of Memory verify: jsr gtrang ; get a number range beq 1$ ; no modifier means check what we have lbmi badsyn ; anything else is illegal ldx ranglo ; good range given, stx verfrm ; transfer it to checksum addresses ldx ranghi stx verto bsr cksum ; compute checksum sta chksum ; save it ldx #chksum ; type the checksum jsr out1by bra 3$ 1$: bsr cksum ; compute checksum cmpa chksum ; same as stored checksum? bne 2$ ldx #msgver ; they verify - say so jsr outstr bra 3$ 2$: ldx #msgnve ; they don't - say so jsr outstr 3$: jmp nomore ; compute the checksum from addresses verfrm to verto ; return the checksum in acca cksum: clra ; init checksum to zero ldx verfrm ; get first address dex ; init to one less 1$: inx ; start of checksum loop adda ,x ; update checksum in acca with ; byte pointed to cpx verto ; hit end of range? bne 1$ ; if not, loop back coma ; complement the sum rts ; return with it .page .sbttl Search Memory for Byte String ; global variables used ; linptr - input line character pointer ; lisptr - command list character pointer ; ranglo - 'search from' address ; ranghi - 'search to' address ; ; local variables used ; memadr - starting memory address where a match ; occurred ; bytptr - address pointer used to fill bytstr and ; substr buffers ; nbytes - number of bytes in byte string ; nbrmat - number of chars that match so far in the ; matching process ; bytstr - starting address of 6 character byte sring ; buffer ; ; the search string occupies temp4, temp5, & temp6 ; (6 bytes max) search: jsr gtrang ; get search range lble badsyn ; abort if no pair ldx #bytstr ; get start of byte string ; to search for stx bytptr ; set pointer to it clr nbytes ; zero # of bytes in byte string 1$: jsr mnumber ; get a byte string beq 2$ ; begin search if eol lblt badsyn ; good byte, add it to string inc nbytes ; count this byte lda nbytes ; don't accept over 6 bytes cmpa #6 lbgt badsyn lda nbrlo ; get (low order) byte ldx bytptr ; get byte pointer sta ,x+ ; save byte, bump pointer stx bytptr ; save it bra 1$ 2$: tst nbytes ; is # of bytes to look for >0 lbeq badsyn ; if not,bad syntax ldx ranglo ; initialize memory pointer dex stx linptr 3$: ldx #bytstr-1 ; initialize byte pointer stx lisptr clr nbrmat ; set 'number of bytes that ; matched' to zero jsr getlst ; get byte from byte string 4$: jsr mgetchr ; get byte from memory range cba ; compare memory & byte string ; characters beq 5$ ; if no match, test for range end cpx ranghi ; have we reached the range ; search upper limit? lbeq nomore ; yes, go prompt for next command bra 4$ 5$: stx memadr ; match achieved - save address of match 6$: inc nbrmat ; bump number matched lda nbrmat cmpa nbytes ; have all characters matched? beq 8$ ; if so, match achieved jsr getlst ; haven't matched all yet, go get next pair jsr mgetchr ; even if past 'search to' address cba beq 6$ 7$: ldx memadr ; mismatch on some byte past the first one cpx ranghi ; this test handles special case lbeq nomore ; of a match on range end stx linptr bra 3$ ; go reset the byte string pointer 8$: ldx #memadr ; match on byte string achieved, jsr out2by ; type out memory address jsr outsp ; and a space bra 7$ .page .sbttl Test Ram test: jsr gtrang ; get an address range lble badsyn ; abort if no pair ldu ranglo ; ranglo holds starting address of range ; ranghi holds ending address of range 1$: lda ,u ; get byte stored at test location pshs a ; save it clr ,u ; zero the location tst ,u ; test it beq 2$ ; ok if = zero ldx #msgccl ; can't clear location bra 4$ 2$: dec ,u ; set location to $ff lda #0xff cmpa ,u ; did it get set to $ff? beq 3$ ldx #msgcso ; can't set location to one's bra 4$ 3$: puls a sta ,u ; restore previous content cmpu ranghi ; hit end of test range? lbeq nomore ; yes, all done leau 1,u ; no, move to test next location bra 1$ 4$: stx temp3 ; save error message temporarily ldx #temp4 stu ,x jsr out2by ; type out bad address jsr outeq ; and equal sign ldx temp4 jsr out1by ; its content jsr outsp ; a space ldx temp3 jsr outstr ; and the type of error jsr docrlf bra 3$ .page .sbttl vector settup commands ; rsrvd - set up rsvd pointer xrsrvd: jsr numinx ; get pointer in ix stx .rsrvd ; save it jmp nomore ; swi3 - set up swi3 pointer xswi3: jsr numinx ; get pointer in ix stx .swi3 ; save it jmp nomore ; swi2 - set up swi2 pointer xswi2: jsr numinx ; get pointer in ix stx .swi2 ; save it jmp nomore ; firq - set up interrupt pointer xfirq: jsr numinx ; get pointer in ix stx .firq ; save it jmp nomore ; irq - set up interrupt pointer xirq: jsr numinx ; get pointer in ix stx .irq ; save it jmp nomore ; swi - set up swi pointer xswi: jsr numinx ; get pointer in ix stx .swi ; save it jmp nomore ; nmi - set up non-maskable interrupt pointer xnmi: jsr numinx ; get ponter in ix stx .nmi ; save it jmp nomore .page .sbttl compare numbers ; compare - output sum & difference of two input numbers compar: jsr numinx ; get first number stx ranglo ; put it in ranglo jsr numinx ; get second number stx nbrhi ; save it in nbrhi ; compute and output the sum jsr sumnum ; compute sum ldx #msgsis ;get its title bsr 1$ ; output title & sum jsr difnum ; compute difference ldx #msgdis ; get its title bsr 1$ ; output title & diff jmp nomore ; compute and output the result 1$: jsr outstr ; output it ldx #ranghi ; get result jsr out2by ; display result rts .page .sbttl dump memory in S1-S9 format ; ***** ; dump - dump portion of memory in S1-S9 format ; ; get address range: start in ranglo (2 bytes), end in ; ranghi (2bytes) ; if no address range is given, use whatever is n ; ranlo & ranghi dump: jsr gtrang clr temp5 ; initialize to dump to terminal 1$: lda #2 ; look for a 'TO' modifier jsr comand beq 2$ lble badsyn ; error if bad syntax cmpa #1 ; TO ? bne 1$ ; go look for another modifier jsr numinx ; get 'TO' address stx outadr ; save it inc temp5 ; remember this bra 1$ ; go look for another modifier 2$: tst temp5 beq 3$ inc outflg ; set flag for proper output device 3$: ldd ranghi ; compute # of bytes to output subd ranglo ; subtract lo bytes cmpd #16 ; diff 0-15. bcs 5$ 4$: ldb #15 ; to get frame count, add 1 ; (diff of 0 implies 1 output) + # of data bytes ; + 2 addr bytes + 1 checksum byte 5$: addb #4 stb temp3 ; temp3 is the frame count subb #3 stb temp4 ; temp4 is the record byte count ldx #msgs1 ; output a 'S1' header data record jsr outstr clrb ; zero checksum ldx #temp3 ; punch frame count bsr 7$ ldx #ranglo ; punch address bsr 7$ bsr 7$ ldx ranglo ; load memory pointer 6$: bsr 7$ ; output data byte dec temp4 ; dec byte count bne 6$ stx ranglo ; save memory pointer comb ; complement checksum pshs b ; put it on stack tfr s,x ; let ix point to it bsr 7$ ; output checksum puls b ; pull it off stack ldx ranglo ; restore memory pointer dex cpx ranghi ; hit end of range? bne 3$ ldx #msgs9 ; yes, output an 'S9' record jsr outstr clr outflg ; set to terminal output jmp nomore 7$: jsr out1by ; output a byte pointed to by ix as addb ,x+ ; 2 hex characters, update checksum rts .page .sbttl Load S1-S9 format Data load: jsr inpchr ; get a char cmpa #'S ; is it an S ? bne load jsr inpchr ; got an 'S', examine next character cmpa #'9 ; done if its a '9' beq 3$ cmpa #'1 ; is it a '1'? bne load ; if not, look for next 'S' clr cksm ; clear checksum jsr 5$ ; read record byte count suba #2 sta bytect ; save count minus 2 address bytes bsr 4$ ; build address 1$: bsr 5$ ; read a data byte into acca dec bytect ; count it beq 2$ ; if done with record, check checksum sta ,x+ ; not done, store byte in memory bra 1$ ; on to next memory address 2$: inc cksm ; test checksum by adding 1 beq load ; if ok, result should be zero ldx #msgnve ; record checksum error jsr outstr ldx #temp1 ; get record address of it jsr out2by ; type it too 3$: clr inpflg ; reset flag to normal terminal input jmp nomore 4$: bsr 5$ ; build address sta temp1 bsr 5$ sta temp1+1 ldx temp1 rts 5$: bsr 6$ ; get left hex digit asla ; move to hi 4 bits asla asla asla tab ; save it in acca bsr 6$ ; get right hex digit aba ; combine then in acca tab ; update the checksum addb cksm stb cksm rts 6$: jsr inpchr ; input a hex char & convert to internal form suba #'0 bmi 8$ ; not hex if below ascii '1' cmpa #'9-'0 ble 7$ ; ok if ascii '9' or less cmpa #'A-'0 ; below ascii 'A'? bmi 8$ ; error if it is cmpa #'F-'0 ; over ascii 'F'? bgt 8$ ; error if it is suba #7 ; conv ascii A-F to hex A-F 7$: rts 8$: ldx #msgcnh ; error - char not hex, say so jsr outstr rts .page .sbttl Delay Function ; ***** ; delay - delay specified # of milliseconds delay: jsr numinx ; get delay time bsr timdel jmp nomore ; ***** ; time delay subroutine ; ix is input as the # of milliseconds to delay ; adj timcon so (7*timcon*cycle time=1 ms) timdel: pshs d 1$: ldd timcon 2$: subd #1 ; a 7 cycle loop bne 2$ dex ; decrement millisecond counter bne 1$ puls d,pc .page .sbttl Help List help: jsr docrlf ; next line ldx #comlst ; command list 1$: ldb #4 ; commands per line stb temp1 2$: ldb #12 ; positions per command ; must be larger than longest command 3$: lda ,x+ ; get character cmpa #cr ; <cr> is end of command beq 4$ jsr outchr ; print command character decb bne 3$ 4$: lda ,x ; get character cmpa #lf ; <lf> is end of list beq 6$ ; finished dec temp1 ; per line done ? bne 5$ ; no - skip jsr docrlf ; next line bra 1$ 5$: lda #' ; space jsr outchr decb bne 5$ bra 2$ 6$: jsr docrlf ; next line jmp nomore .page .sbttl Command Lists ;================================================ ; ; c o m m a n d l i s t s c a n n i n g ; r o u t i n e ; ; this routine seeks a match of the characters pointed ; at by the input line scanning pointer to one of the ; commands in a list specified by acca. ; the result of the scan for a match is returned in ; acca as follows: ; ; acca=-1: the match was unsuccessful. the syntax ; pointer (synptr) was not updated ; (advanced). ; ; acca= 0: the match was unsuccessful since there ; were ; no more characters, i.e., the end of ; the ; line was reached. ; ; acca=+n: successful match. the syntax pointer ; was updated ; to the first character following the ; command ; delimiter. acca holds the number of ; the ; command matched. ; global variables for external communication ; synptr - good syntax input line char pointer ; linptr - input line character pointer ; delim - class of permissible command delimiters ; ; temporary 2 byte internal variables ; lisptr - command list character pointer ; ; temporary 1 byte internal variables ; nummat - number of characters that successfully match ; lisnum - # of list within which a match will be sought ; comnum - command number matched ; ; constants used ; cr - carriage return ; lf - line feed ; ; a, b & ix are not preserved comand: sta lisnum ; save list # to match within jsr skpdlm ; test if we are at the end of the line bcc 1$ clra rts ; initialize the command list pointer to one less than ; the beginning of the command lists 1$: ldx comadr ; entry point ; move to the beginning of the desired command list lda lisnum ; search for 'string' # lisnum ldb #lf ; use lf as a 'string' terminator bsr fndstr stx lisptr ; the list pointer, lisptr, now points to one less than ; the first character ; of the first command in the desired list clr comnum ; reset input line pointer to: 1) beginning of line, or ; to 2) point where last successful scan terminated 2$: inc comnum ; initialize the command # to 1 ldx synptr stx linptr clr nummat ; clear number of characters ; matched 3$: jsr mgetchr ; get input line char in accb jsr tstdlm ; test for a delimiter bne 4$ ; success (found delimiter) jsr getlst ; get command list char in acca cmpa #lf ; has end of command list been reached ? beq 5$ ; if so, potential match failure cmpa #cr ; has end of command been reached ? beq 5$ ; if so, potential match failure cba ; compare the two characters bne 6$ ; match not possible on this command inc nummat ; they match, compare the succeeding characters bra 3$ ; inc number of characters matched 4$: ldx linptr ; successful match stx synptr ; update good syntax pointer lda comnum ; return command number rts ; no match 5$: tst nummat ; did at least one match? beq 6$ ; to next command if none matched jsr tstdlm ; at least one matched - test for delimiter bne 4$ ; if a delimiter, match has been achieved lda ,x ; retrieve last character ; illegal delimiter ; move to next command within list 6$: cmpa #lf ; end of this list? beq 7$ ; if so, nothing on list matched cmpa #cr ; is it a cr? beq 2$ ; yes, next command jsr getlst ; get next command list character bra 6$ ; no, get to end of command 7$: clra ; match failure deca ; no match possible within this list rts .page .sbttl Typeout Command ;==================================== ; this routine types out command number "comnum" ; the list is specified in acca ; accb & ix are preserved typcmd: pshs b,x ldx #comlst-1 ; move to head of command lists ldb #lf ; and list terminator bsr fndstr ; go to head of desired list lda comnum ; get command number ldb #cr ; get command terminator bsr fndstr ; go to head of desired command 1$: inx ; move to next character lda ,x ; get a command character cmpa #cr ; is it a command terminator? beq 2$ ; if so, return jsr outchr ; no, type it bra 1$ 2$: puls b,x,pc .page .sbttl Find string ;====================================== ; move to beginning of desired string number (in acca) ; each string is terminated by an end of string ; character (in accb) ; the index register is assumed initialized pointing to ; one less than the first character of the first string ; acca, accb & ix are not preserved ; local variables ; strnum - string # to find ; eoschr - "end of string" character fndstr: sta strnum ; save string number stb eoschr ; save terminator clrb 1$: incb ; string 1 is the first string cmpb strnum ; is this the right string? beq 3$ ; if so, done ; no, swallow up characters until an end of string char is hit 2$: inx ; bump pointer to next one lda ,x ; get char pointed at cmpa eoschr ; end of string hit? beq 1$ ; if it is, bump the string counter bra 2$ ; no, move on to next char 3$: rts ; ix set properly, return .page .sbttl Skip Leading Delimiters ;================================================= ; skip leading delimiters ; this routine should be called prior to scanning for ; any information ; on the input line ; the current character is ignored if the scannng ; pointer is at the beginning of a line. if not, the ; scanning pointer skips over spaces and commas ; until an end of line or non-delimiter is found. ; the carry bit is set if and end of line is encountered. ; acca, accb, & ix are not preserved skpdlm: clc tst bolflg ; at beginning of line? bgt 2$ ; look at current input character 1$: ldx synptr ; get pointer to it lda ,x ; get char bsr tsteol ; test for end of line bne 2$ sec ; yes, end hit, set carry rts ; "peek" at next char in line 2$: ldb 1,x ; get it bsr tstdlm ; see if its a delimiter bne 3$ rts ; if not, return ; next char is a delimiter 3$: jsr mgetchr ; move to next char in input line stx synptr ; update syntax pointer bra 1$ ; go test for end of line .page .sbttl Test for End-of-Line Character ;============================================ ; test for end-of-line character ; z bit of cc reg set if char in acca is a terminator ; acca, accb, & ix are preserved tsteol: cmpa #cr ; carriage return? beq 1$ cmpa #lf ; line feed? (continued lines) beq 1$ cmpa #'; ; for several commands on one line 1$: rts .sbttl Test for Delimeter ;=============================================== ; check the character n accb aganst the delimiter(s) ; specified by variable delim ; accb & ix are preserved ; acca is set to 0 if accb is not a delimiter, to 1 ; if it is ; if delim=1, space s delimiter ; if delim=2, comma is delimiter ; if delim=3, space or comma is delimiter ; if delim=4, any non-alphanumeric is a delimiter ; test for end-of-line (logical or physical) tstdlm: pshs b tba bsr tsteol puls b beq 5$ lda delim cmpa #1 bne 1$ cmpb #' ; want a space - is it? bne 6$ bra 5$ 1$: cmpa #2 bne 3$ 2$: cmpb #', ; want a comma - is it? bne 6$ bra 5$ 3$: cmpa #3 bne 4$ cmpb #' ; want either, is it a space? beq 5$ bra 2$ ; or a comma? 4$: cmpa #4 bne 7$ ; error if delm not 1-4 cmpb #'0 ; test if char is 0-9 inclusive blt 5$ cmpb #'9 ble 6$ cmpb #'A ; test if char is A to Z inclusive blt 5$ cmpb #'Z ble 6$ ; over Z - its a delimiter 5$: lda #1 ; char in accb is a delimiter rts 6$: clra ; char in accb is not a delimiter rts ; error in specifying delimiter class 7$: swi ; have monitor type out pertinent ; statistics .page .sbttl Sum Two Numbers ;================================================ ; add the 2 byte number stored in (ranglo,ranglo+1) to ; the number stored in (nbrhi,nbrlo) and put the result ; in (ranghi,ranghi+1) sumnum: pshs d ; add lo order bytes ldd ranglo addd nbrhi std ranghi puls d,pc .sbttl Subtract Two Numbers ;==================================================== ; subtract the 2 byte number stored in (nbrhi,nbrlo) ; from the two byte number stored in (ranglo,ranglo+1) ; and put the result in (ranghi,ranghi+1) ; accb & ix are preserved ; acca is altered difnum: pshs d ; subtract lo order bytes ldd ranglo subd nbrhi std ranghi puls d,pc .page .sbttl Get Range ;=================================================== ; this routine scans the input line for a pair of numbers ; representing an address range. a colon separating the ; pair implies "thru", while an "!" implies "thru the ; following" ; e.g., 100:105 is equivalent to 100!5 ; a single number implies a range of 1 ; on return (ranglo,ranglo+1) holds the range start, and ; (ranghi,ranghi+1) holds the range end ; acca, accb, & ix are not preserved gtrang: bsr mnumber ; pick up first number bgt 1$ blt 2$ rts ; nothing more on input line 1$: ldx nbrhi ; good single number stx ranglo ; transfer it to ranglo bra 3$ ; and to ranghi ; bad number, but is it bad due to a ":" or "!" delimiter? ; get the terminator for the first number 2$: ldx linptr lda ,x cmpa #': ; was it a colon? bne 4$ ; if not, go test for "!" bsr 8$ ; was ":", process first number & ; get next one ble 5$ ; illegal if end of line or non-numeric 3$: ldx nbrhi ; transfer second number to ranghi stx ranghi bra 7$ 4$: cmpa #'! ; was delimiter a "!"? beq 6$ ; if yes, get 2nd number clra ; illegal delimiter, return deca 5$: rts 6$: bsr 8$ ; was "!", process first number & ; get next one ble 5$ bsr sumnum ; compute range end, put into ranghi 7$: lda #1 ; successful exit rts ; update syntax pointer, move first number to ranglo, ; & get 2nd number 8$: stx synptr ; update syntax pointer ldx nbrhi ; get first number of the pair stx ranglo ; save it in "low range" value bsr mnumber ; pick up the second number of the pair rts .page .sbttl Get number in IX ;==================================================== ; get a 2 byte number & return it in the index register numinx: bsr mnumber bgt 1$ jmp badsyn 1$: ldx nbrhi rts .page .sbttl Scan For a Number ;================================================== ; scan for a number ; return the most significant byte in nbrhi ; and the least significant byte in nbrlo ; the result of the scan for a number is returned in ; acca as follows: ; ; acca=-1: the match was unsuccessful. the syntax ; pointer (synptr) was not updated. ; ; acca= 0: the scan was unsuccessful since there ; were no more characters. (i.e., the end ; of the line was encountered.) ; ; acca=+1: the scan was successful. the syntax ; pointer was updated to the first character ; following the command. ; ; ix is preserved ; global variables for external communication ; nbrhi - number hi byte ; nbrlo - number lo byte ; ibcode - input base code ; dbcode - display base code ; ; local variables ; nbr2x - used in decimal conversion ; initialize both bytes to zero mnumber:pshs x ; save ix clr nbrhi clr nbrlo ldx synptr ; initialize the line scanning pointer stx linptr jsr skpdlm ; are we at end of line? bcc 1$ clra ; yes, zero acca puls x,pc 1$: jsr mgetchr ; get a character from the input ; line into accb jsr tstdlm ; test for a delimiter bne 6$ ; good delimiter if acca is non-zero subb #'0 ; subtract ascii 0 bmi 8$ ; error if less lda ibcode ; determine input base & go to right routine cmpa #1 ; hex code ? beq 2$ cmpa #2 ; decimal code ? beq 4$ cmpa #3 ; octal code ? beq 5$ ; hex input processing 2$: cmpb #'9-'0 ; default an illegal input base to hex ble 3$ ; if 9 or less cmpb #'A-'0 bmi 8$ ; not hex if < A cmpb #'F-'0 bgt 8$ ; not hex if > F subb #7 ; move A-F above 0-9 3$: bsr 9$ ; shift lo & hi bytes left 4 bits bsr 9$ orb nbrlo stb nbrlo bra 1$ ; decimal input 4$: cmpb #9 bgt 8$ ; not decimal if > 9 ; multiply saved value by 10 & add in new digit bsr 10$ ; multiply current number by 2 to get 2x value ldx nbrhi ; save this *2 number temporarily stx nbr2x bsr 9$ ; multiply this # by 4 to get 8x value clra ; new digit <a,b> addd nbr2x ; note that 10x=2x+8x bcs 8$ ; carry out of ms byte is an error addd nbrhi bcs 8$ ; carry out of ms byte is an error std nbrhi ; save result bra 1$ ; octal input 5$: cmpb #7 bgt 8$ ; not octal if > 7 bsr 9$ ; shift hi & lo bytes 3 places left bsr 10$ ; carry out of hibyte is illegal orb nbrlo ; add in new digit stb nbrlo bra 1$ 6$: ldx linptr ; good number - scan was successful stx synptr ; update good syntax line pointer lda #1 ; set "good scan" flag puls x,pc 7$: leas 2,s 8$: clra ; conversion error - scan was unsuccessful deca puls x,pc 9$: asl nbrlo ; shift a two byte number left one position rol nbrhi bcs 7$ 10$: asl nbrlo ; shift a two byte number left one position rol nbrhi bcs 7$ rts .page .sbttl General Output Routines ;=========================================== ; output a space outsp: lda #' jsr outchr rts ;=========================================== ; output an "=" sign outeq: lda #'= jsr outchr rts ;========================================== ; output a 1 byte number out1by: pshs d ldb #1 bsr outnum puls d,pc ;========================================== ; output a 2 byte number out2by: pshs d ldb #2 bsr outnum puls d,pc ;========================================== ; display the number pointed at by the address in the ; index register and output it according to the base ; specified in "dbcode" ; leading zeros are included ; acca & ix are preserved ; accb is input as the number of bytes comprising the ; number. ; global variables for external communication ; ibcode - input base code ; dbcode - display base code ; ; local variables ; decdig - decimal digit being built ; numbhi - hi byte of number being output ; numblo - lo byte of number being output outnum: pshs d,x ; save these ldx ,x ; get the two bytes at that address stx numbhi ; put them in a scratch area for processing lda dbcode ; get display base cmpa #1 beq 1$ cmpa #2 beq 4$ cmpa #3 beq 11$ cmpa #4 beq 14$ ; output a hex number 1$: aslb ; 1 byte=2 chars, 2 bytes=4 chars 2$: bsr 16$ ; get next 4 bits bsr 16$ anda #0x0f ; extract 4 bits cmpa #9 ble 3$ adda #7 ; convert 10:15 to A-F 3$: bsr 18$ decb bne 2$ puls d,x,pc ; restore registers & return ; output a decimal number 4$: decb ; test # of bytes to output beq 5$ ldx #9$ ; initialize for output of a 2 byte number ldd numbhi bra 6$ 5$: ldx #10$ ; initialize for output of a 1 byte number clra ldb numbhi 6$: clr decdig ; clear the digit to output 7$: subd ,x ; subtract the power of 10 conversion constant bcs 8$ ; test for borrow (carry) inc decdig ; no borrow yet - nc digit being built bra 7$ ; repeat loop ; building of digit to output is complete - print it 8$: pshs a ; save lo byte of number being output lda decdig ; get digit bsr 18$ ; print it puls a ; restore lo byte addd ,x++ ; borrow generated - cancel last subtraction cpx #9$+10 ; are we thru with units conversion? bne 6$ ; if not, back to get next digit puls d,x,pc ; if yes, restore registers & return ; decimal output conversion constants 9$: .word 10000 .word 1000 10$: .word 100 .word 10 .word 1 ; output an octal number 11$: aslb ; first approximation of # of clra ; digits to output cmpb #2 bgt 12$ bsr 16$ ; 1 byte - get first 2 bits bsr 18$ bra 13$ ; go output last 2 digits 12$: bsr 17$ ; two byte # - output hi order bit/digit bsr 18$ incb ; 5 more digits to go 13$: bsr 16$ ; get next 3 bits bsr 17$ anda #7 ; extract 3 bits bsr 18$ decb ; count this digit bne 13$ ; are we done? puls d,x,pc ; if yes, restore registers & return 14$: aslb ; output a binary number aslb aslb 15$: bsr 17$ ; get next bit anda #1 ; extract the bit bsr 18$ ; output it decb ; count it bne 15$ ; are we done? puls d,x,pc ; if yes, restore registers & return 16$: bsr 17$ ; left shift 2 bits 17$: asl numblo ; left shift the 3 byte number 1 bit rol numbhi rola rts 18$: adda #'0 ; convert to a numeric ascii digit & output it jsr outchr rts .page .sbttl Get Character Routines ;================================================= ; this routine gets the next character from the input ; line buffer ; acca is preserved ; accb is loaded with the character ; ix is incremented and left pointing to the character ; returned mgetchr: ldx linptr inx ldb ,x stx linptr clr bolflg ; set flag to not at "beginning of line" rts ;================================================== ; this routine gets the next character in the command ; lists ; acca is the character retrieved ; accb is preserved ; ix is incremented & left pointing to the character returned getlst: ldx lisptr ; get current list pointer inx ; move pointer to next character lda ,x ; get character pointed at stx lisptr ; save pointer rts ; and return .page .sbttl Command Lists ;===================================================== ; command lists ; a carriage return signifies end-of-command ; a line feed signifies end-of-command-list ; list 1 - major commands comlst: .ascii /BREAK/ ; set breakpoint (swi code) .byte cr .ascii /CONTINUE/ ; continue from "swi" .byte cr .ascii /COMPARE/ ; print sum & difference of 2 numbers .byte cr .ascii /COPY/ ; copy from one location to another .byte cr .ascii /DISPLAY/ ; display memory data .byte cr .ascii /DBASE/ ; set display base .byte cr .ascii /DELAY/ ; delay specified # of bytes .byte cr .ascii /DUMP/ ; dump memory in mikbug or image format .byte cr .ascii /GOTO/ ; go to memory address .byte cr .ascii /HELP/ ; help listing .byte cr .ascii /IBASE/ ; set input base .byte cr .ascii /LOAD/ ; load mikbug tape .byte cr .ascii /REG/ ; display registers .byte cr .ascii /SET/ ; set memory data .byte cr .ascii /SEARCH/ ; search memory for a byte string .byte cr .ascii /TEST/ ; test a range of memory .byte cr .ascii /VERIFY/ ; verify that memory content is unchanged .byte cr .ascii /CLI/ ; clear interrupt mask .byte cr .ascii /CLF/ ; clear fast interrupt mask .byte cr .ascii /SEI/ ; set interrupt mask .byte cr .ascii /SEF/ ; set fast interrupt mask .byte cr .ascii /IRQ/ ; set interrupt pointer .byte cr .ascii /FIRQ/ ; set fast interrupt pointer .byte cr .ascii /NMI/ ; set non-maskable interrupt pointer .byte cr .ascii /RSRVD/ ; set reserved interrupt pointer .byte cr .ascii /SWI/ ; set software interrupt pointer .byte cr .ascii /SWI2/ ; set swi2 interrupt pointer .byte cr .ascii /SWI3/ ; set swi3 interrupt pointer .byte cr .byte lf ; end of list 1 ; list 2 - modifier to dump .ascii /TO/ ; destination .byte cr .byte lf ; end of list 2 ; list 3 - number base specifiers .ascii /HEX/ ; base 16 .byte cr .ascii /DEC/ ; base 10 .byte cr .ascii /OCT/ ; base 8 .byte cr .ascii /BIN/ ; base 2 .byte cr .byte lf ; end of list 3 ; list 4 - information request .ascii /?/ .byte cr .byte lf ; end of list 4 ; list 5 - register names .ascii /.CC/ .byte cr .ascii /.A/ .byte cr .ascii /.B/ .byte cr .ascii /.DP/ .byte cr .ascii /.IX/ .byte cr .ascii /.IY/ .byte cr .ascii /.IU/ .byte cr .ascii /.AB/ .byte cr .ascii /.PC/ .byte cr .ascii /.SP/ .byte cr .byte lf ; end of list 5 ; list 6 - modifiers to "display" .ascii /DATA/ .byte cr .ascii /USED/ .byte cr .byte lf ; end of list 6 ; list 7 - modifier to "load" .ascii /FROM/ ; source .byte cr .byte lf ; end of list 7 .page .sbttl Get a line ;======================================================= ; ; this routine constructs a line of input by getting all ; input characters up to and including a carriage return ; (which then designates "end of line"). ; typing rubout will delete the previous character ; typing control-c will abort the line ; typing control-z will use the previous line ; the input line is stored beginning at the address ; stored in bufbeg and ending at the address stored ; in bufend ; acca, accb, & ix are not preserved ; ; global variables ; bufbeg - input line start of buffer ; bufend - input line end of buffer ; ; local constants getlin: ldx bufbeg ; set pointer to one less than ; the beginning of the line buffer clrb ; accb holds last input char 1$: cpx bufend ; check current line end against buffer end bne 2$ ; line too long - abort it as if a control-c had been typed ldx #msgltl ; get message jsr outstr ; output it ldb #3 ; put ctl-c in accb rts 2$: jsr inpchr ; get a character (returned in acca) anda #0x7f ; drop parity bit ; control-z copies from present position to previous end of line cmpa #26 ; is char a control-z? bne 3$ jsr docrlf ; yes, type cr-lf rts 3$: cmpa #13 ; is char a cr? beq 4$ cmpa #10 ; or a lf? bne 6$ 4$: inx sta ,x ; yes, store the terminator tst hdxflg ; test for half-duplex terminal bne 5$ jsr docrlf ; type cr-lf 5$: rts ; now return 6$: cmpa #3 ; is char a control-c? bne 7$ ; no tab ; return ctl-c in accb lda #'^ ; echo an up-arrow jsr outchr rts 7$: cmpa #127 ; no, is it delete? beq 10$ ; yes - delete character inx ; not a delete, so advance to next char sta ,x ; store it in inplin tab ; last character in b tst hdxflg ; check half duplex bne 9$ ; yes - skip jsr outchr ; echo character 9$: bra 1$ ; get another ; current character is a delete ; test line length - if its zero, ignore this delete ; since we can't delete prior to first char in input line 10$: cpx bufbeg beq 1$ pshs x ldx #11$ ; delete character on screen bsr outstr puls x ldb ,-x ; last character bra 1$ 11$: .byte 8,32,8,4 ; BS, SPACE, BS, EOT ;==================================================== ; initialization routine inital: lda #1 sta ibcode ; set input base to hex sta dbcode ; set display base to hex ; set up display base number lda #16 sta dbnbr ; max # of characters per line lda #72 sta cplmax clr inpflg ; default input from terminal clr outflg ; default output to terminal clr hdxflg ; clear half-duplex flag ; set up swi interrupt address pointer ldx #typswi ; type "swi" & do "reg" command stx .swi ; clear breakpoint address ldd #0xfffe ; normal systems have rom here std brkadr ; initialize to mondeb's command lists ldx #comlst-1 stx comadr ; time constant for a .5 microsecond clock ldd #285 std timcon .if inituser jmp userinit ; user returns via rts .else rts .endif ;=================================================== ; output a character string which begins at the address ; in the index register ; acca & accb are preserved ; ix is left pointing to the string terminator outstr: pshs a 1$: lda ,x ; get char pointed to cmpa #4 ; is it a string terminator? beq 2$ ; done if it is bsr outchr ; isn't, output it inx ; on to next char bra 1$ 2$: puls a,pc ;===================================================== ; input a character inpchr: tst inpflg ; console ? bne 2$ 1$: jsr [conin] ; tst for a character bcc 1$ ; none - loop until there is rts 2$: jsr [altin] ; tst for a character bcc 2$ ; none - loop until there is rts ;====================================================== ; output the character in acca to the desired output ; device/location ; if outflg = 0, output is to terminal ; if outflg # 0, output is to address in outadr ; & this address is then incremented outchr: pshs d,x ; save d and x ldb outflg ; test output destination flag decb ble 1$ ; skip this code if terminal output ; output to something other than terminal ldx outadr ; get output char destination addr sta ,x+ ; save char in memory stx outadr ; update output address puls d,x,pc 1$: cmpa #lf ; ignore line feeds bne 2$ puls d,x,pc 2$: cmpa #cr ; test for carriage return bne 3$ bsr docrlf puls d,x,pc 3$: ldb cplcnt ; get "chars per line" count cmpb cplmax bge 4$ ; send cr-lf if greater ; less than max, but also send cr-lf if 10 from end and ; printing a space addb #10 cmpb cplmax blt 5$ cmpa #' ; near end, test if about to print a space bne 5$ ; terminal line full or nearly full - interject a cr-lf 4$: bsr docrlf 5$: inc cplcnt ; bump counter bsr chrout ; send it to acia1 puls d,x,pc ;====================================================== ; send a carriage return-line feed to the terminal docrlf: pshs d lda #cr bsr chrout lda #lf bsr chrout clr cplcnt ; zero "chars/line" count puls d,pc ;====================================================== ; send char in acca chrout: tst outflg ; check destination bne 1$ jmp [conout] ; output a character 1$: jmp [altout] ;====================================================== ; misc text msghed: .ascii /MONDEB-09 1.00/ .byte cr,4 msgprm: .byte '*,4 msgswi: .byte cr,lf .ascii /swi:/ .byte cr,lf,4 msgltl: .ascii /too long/ .byte 4 msgnbr: .ascii /not set/ .byte 4 msgbat: .ascii /set @ / .byte 4 msgver: .ascii /ok/ .byte 4 msgnve: .ascii /checksum error / .byte 4 msgccl: .ascii /can't clear/ .byte 4 msgcso: .ascii /can't set to ones/ .byte 4 msgsis: .ascii /sum is / .byte 4 msgdis: .ascii /, dif is / .byte 4 msgs1: .byte cr,lf,0,0,'S,'1,4 msgs9: .byte cr,lf,0 .ascii /S9030000FC/ .byte cr,lf,4 msgcnh: .ascii /char not hex/ .byte cr,4 ;**************************************************** ;* default interrupt transfers * ;**************************************************** .if standalone rsrvd: jmp [.rsrvd] ; reserved vector swi3: jmp [.swi3] ; swi3 vector swi2: jmp [.swi2] ; swi2 vector firq: jmp [.firq] ; firq vector irq: jmp [.irq] ; irq vector swi: jmp [.swi] ; swi vector nmi: jmp [.nmi] ; nmi vector .endif .page .sbttl dispatch table .if standalone .area DISPAT (REL,CON) .word timdel ; time delay for # of ms specified by ix .word cksum ; return checksum of an address range in acca .word mgetchr ; return (in accb) char pointed to by linptr .word getlst ; return (in acca) char pointed to by lisptr .word gtrang ; pick up an address range in ranglo & ranghi .word mnumber ; pick up a number & return it in nbrhi & nbrlo .word skpdlm ; skip over input line delimiters .word tstdlm ; test char in accb for a delimiter .word tsteol ; test char in acca for end-of-line .word comand ; search specified command list for a command .word typcmd ; types out command number "comnum" in list acca .word out1by ; display the 1 byte number pointed at by ix .word out2by ; display the 2 byte number pointed at by ix .word getlin ; get a line of input into the tty buffer .word outstr ; output char string ix points to .word docrlf ; send cr-lf with delay & zero line count .word outchr ; like chrout, but with folding, cr delay, & lf .word chrout ; send acca to console .word inpchr ; get a char, return it in acca .word prompt ; to prompt for new command .word mond09 ; start of mondeb .endif .page .sbttl Hardware Interrupt Tables ;******************************************************** ;* MONDEB-09 hardware vector table ;* ;* this table is used if the MONDEB-09 rom addresses ;* the mc6809 hardware vectors. ;******************************************************** .if standalone .area INTVEC (ABS,OVR) . = 0xFFF0 ; vector position .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 .endif