diff options
Diffstat (limited to 'programs')
| -rw-r--r-- | programs/sub-suite/declare.s | 4 | ||||
| -rw-r--r-- | programs/sub-suite/free-new.s | 143 | ||||
| -rw-r--r-- | programs/sub-suite/free-old.s | 200 | ||||
| -rw-r--r-- | programs/sub-suite/lexer.s | 18 | ||||
| -rw-r--r-- | programs/sub-suite/libc.s | 499 | ||||
| -rw-r--r-- | programs/sub-suite/shift_line.c | 10 | ||||
| -rw-r--r-- | programs/sub-suite/subasm-syntax | 56 | ||||
| -rw-r--r-- | programs/sub-suite/subasm.s | 361 | ||||
| -rw-r--r-- | programs/sub-suite/subeditor.s | 604 | ||||
| -rw-r--r-- | programs/sub-suite/test-size.s | 59 | ||||
| -rw-r--r-- | programs/sub-suite/utils.s | 312 |
11 files changed, 1309 insertions, 957 deletions
diff --git a/programs/sub-suite/declare.s b/programs/sub-suite/declare.s index 550228d..36a4f15 100644 --- a/programs/sub-suite/declare.s +++ b/programs/sub-suite/declare.s @@ -2,7 +2,7 @@ ; Structs, and unions. ; Line struct. -.struct ln +.struct line next .qword ; Pointer to next line. tok .qword ; The tokens for this line. @@ -852,7 +852,7 @@ cmd_srt: .word list .word asm .word help - .word inst + .word instruction .word run .word set_val diff --git a/programs/sub-suite/free-new.s b/programs/sub-suite/free-new.s new file mode 100644 index 0000000..dad19d0 --- /dev/null +++ b/programs/sub-suite/free-new.s @@ -0,0 +1,143 @@ +.include "declare.s" + +.org 0 + +; free: Free allocated memory. +; Input: D = Pointer to allocated memory. +; Output: none. +; Caller preserved registers: D. +; Callie preserved registers: A, B, X, Y, E. + +free: + pha.q ; Preserve A. + phb.q ; Preserve B. + phx.q ; Preserve X. + phy.q ; Preserve Y. + phe.q ; Preserve E. + and #0 ; Reset A. + tab ; Reset B. + tax ; Reset X. + tay ; Reset Y. + mov a, d ; Get the passed pointer. + bne @getrealblk ; The pointer isn't NULL, so get the real block. + bra @end ; The pointer is NULL, so we're done. +@getrealblk: + sub #8 ; Get the start of the used block. + mov.q a, (a) ; Get the start of the real block. + mov.q b, (a+ublk.size) ; Get the size of the real block. + lea e, (a+b) ; Add the size of the real block with the start of the real block. + cmp.q e, heapptr ; Is this block on top of the heap? + bne @heapadd ; No, so add it to the free block list. +@dectop: + mov.q heapptr, (a) ; Set the top of the heap to the start of the previous real block. +@chklastblk: + mov.q b, heapl ; Get the last free list entry. + beq @end ; The free list is empty, so we're done. + ldy #fblk.size ; Get the size of the block. + mov.q a, (b+fblk.size) ; Get the size of the block. + lea e, (a+b) ; Add the size of the block, with the address of the block entry. + cmp.q e, heapptr ; Is the last block on top of the heap? + bne @end ; No, so we're done. +@delblk: + mov.q heapptr, b ; Yes, so remove the last block. +@correctblk: + mov.q a, (b+fblk.prev) ; Get the previous block. + sta.q heapl ; Set the last block to the previous block. + bne @delnxtblk ; The previous block isn't NULL, so delete the next block. + sta.q heapf ; The previous block is NULL, so empty the free list. + bra @end ; We are done. +@delnxtblk: + lea e, (a+fblk.next) ; Delete the next block. + stz.q (e) ; +@end: + ple.q ; Restore E. + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of free. + + +@heapadd: + mov.q y, heapf ; Get the first block. + bne @srchflst ; The Free list isn't empty, so start searching the free list. +@empty: + mov.q (a+fblk.next), y ; Clear the next block. + mov.q (a+fblk.prev), y ; Clear the previous block. + sta.q heapf ; Set the first block entry to the current block. + sta.q heapl ; Set the last block entry to the current block. + bra @end ; We are done. +@srchflst: +@loop: + cmp y, a ; Is the right pointer at, or below the current block? + beq @nextright ; Yes, so get the next right pointer. + bcs @chkrmerge ; No, so do the right block merge. +@nextright: + tyx ; Set the left pointer, to the right pointer. + mov.q y, (y+fblk.next) ; Set the current right pointer to the next right pointer. + bne @loop ; The next right pointer isn't NULL, so keep looping. +@st_lmerge2: + mov.q (a+fblk.next), y ; Clear the next block. + sta.q heapl ; Set the last free block entry to it. + bra @chklmerge2 ; Do the left block merge. +@chkrmerge: + lea e, (a+b) ; Add the size of the current block, to the current block. + cmp e, y ; Is the current block the same as the right block? + bne @normerge ; No, so don't merge the right block. +@rmerge: + mov e, b ; Get the size of the current block. + add.q e, (y+fblk.size) ; Add the size of the current block, with the size of the right pointer. + mov.q (a+fblk.size), e ; Set the size of the current block, to the new size. +@rmerge2: + lea fblk.next ; Get the next right pointer. + mov.q (a+e), (y+e) ; Set the next block, to the next right pointer. + mov.q b, (y+e) ; Save the next block. + beq @setheapl ; The next block is NULL, so set the last block. +@setprev: + mov.q (b+fblk.prev), a ; Set the previous block to the current block. + bra @chklmerge ; Do the left block merge. +@setheapl: + sta.q heapl ; Set the last block to the current block. + bra @chklmerge ; Do the left block merge. +@normerge: + mov.q (a+fblk.next), y ; Set the next block to the right pointer. + mov.q (y+fblk.prev), a ; Set the previous right pointer to the current block. +@chklmerge: + and x, x ; Is the left pointer NULL? + bne @chklmerge2 ; No, so keep checking. +@newstart: + mov.q (a+fblk.prev), x ; + sta.q heapf ; Set the first block, to the current block. + bra @end2 ; We are done. +@chklmerge2: + mov.q e, (x+fblk.size) ; Get the size of the left block. + add e, x ; Add the size of the left block, to the left pointer. + cmp e, a ; Is the left block adjacent? + bne @nolmerge ; No, so don't merge the left block. +@lmerge: + lea fblk.size ; Set the offset to the block size. + add.q (x+e), (a+e) ; Add the size of the left block, with the size of the current block. +@lmerge2: + lea fblk.next ; Set the offset to the next block. + mov.q (x+e), (a+e) ; Set the next left pointer, to the next block. + mov.q b, (a+e) ; Get the next block. + beq @newlast ; The next block is NULL, so set the last block. +@lprev: + mov.q (b+fblk.prev), x ; Set the next left pointer's previous pointer to the left pointer. + bra @end2 ; We are done. +@newlast: + stx.q heapl ; Set the last block, to the left pointer. + bra @end2 ; We are done. +@nolmerge: + mov.q (x+fblk.next), a ; Set the next left pointer, to the current block. +@nolmerge2: + mov.q (a+fblk.prev), x ; Set the previous block, to the left pointer. +@end2: + ple.q ; Restore E. + ply.q ; Restore Y. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of free. + +a +q diff --git a/programs/sub-suite/free-old.s b/programs/sub-suite/free-old.s new file mode 100644 index 0000000..7f75edd --- /dev/null +++ b/programs/sub-suite/free-old.s @@ -0,0 +1,200 @@ +.include "declare.s" + +.org 0 + +; free: Free allocated memory. +; Input: A = Pointer to allocated memory. +; Output: none. +; Caller preserved registers: none. +; Callie preserved registers: A, B, Y. + +free: + pha.q ; Preserve A. + phb.q ; Preserve B. + phy.q ; Preserve Y. + pha.q ; Push the pointer argument to the stack. + and #0 ; Reset A. + tay ; Reset Y. + sbs #$18 ; Allocate 3 local variables onto the stack. + lda.q sp+25 ; Get the passed pointer. + ora.d sp+29 ; Is the passed pointer NULL? + bne @getrealblk ; No, so get the real block. + bra @end ; Yes, so we're done. +@getrealblk: + lda.q sp+25 ; Get the passed pointer. + sec ; Prepare for a non borrowing subtract. + sbc #8 ; Move the passed pointer back by one. + sta.q sp+25 ; Set the first local variable to the start of the used block. + lda.q (sp+25) ; Get the real block address. + sta.q sp+25 ; Set the passed pointer to the start of the real block. + ldy #ublk.size ; Get the size of the real block. + lda.q (sp+25), y; + sta.q sp+17 ; Save the size of the real block. + clc ; Prepare for a non carrying add. + adc.q sp+25 ; Add the size of the real block with the start of the real block. + cmp.q heapptr ; Is this block on top of the heap? + bne @heapadd ; No, so add it to the free block list. +@dectop: + lda.q sp+25 ; Get the block. + sta.q heapptr ; Set the top of the heap to it. +@chklastblk: + lda.q heapl ; Get the last free list entry. + sta.q sp+17 ; Copy it into the second local variable. + ora.d sp+21 ; Is the free list empty? + beq @end ; Yes, so we're done. + lda.q sp+17 ; No, so Get the last free list entry. + ldy #fblk.size ; Get the size of the block. + lda.q (sp+17), y; + clc ; Prepare for a non carrying add. + adc.q sp+17 ; Add the size of the block, with the address of the block entry. + cmp.q heapptr ; Is the last block on top of the heap? + bne @end ; No, so we're done. +@delblk: + lda.q sp+17 ; Yes, so remove the last block. + sta.q heapptr ; +@correctblk: + ldy #fblk.prev ; Get the previous block. + lda.q (sp+17), y; + sta.q sp+25 ; Save the previous block for now. + sta.q heapl ; Set the last block to the previous block. + ora.d sp+29 ; Is the previous block non NULL? + bne @delnxtblk ; Yes, so delete the next block. + sta.q heapf ; No, so empty the free list. + bra @end ; We are done. +@delnxtblk: + and #0 ; Reset A. + ldy #fblk.next ; Delete the next block. + sta.q (sp+25), y; +@end: + ads #$20 ; Clean up the stack frame. + ply.q ; Restore Y. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of free. + + +@heapadd: + lda.q heapf ; Get the first block. + sta.q sp+9 ; Copy it into the third local variable. + ora.d sp+13 ; Is the free list empty? + bne @srchflst ; No, so start searching the free list. +@empty: + ldy #fblk.next ; Clear the next block. + sta.q (sp+25), y; + ldy #fblk.prev ; Clear the previous block. + sta.q (sp+25), y; + lda.q sp+25 ; Reset A. + sta.q heapf ; Clear the first block entry. + sta.q heapf ; Clear the last block entry. + bra @end ; We are done. +@srchflst: + and #0 ; Reset A. + sta.q sp+1 ; Reset the left pointer. + ldy #fblk.next ; Setup for the loop. +@loop: + lda.q sp+9 ; Get the right pointer. + cmp.q sp+25 ; Is the right pointer at, or below the current block? + beq @nextright ; Yes, so get the next right pointer. + bcs @chkrmerge ; No, so do the right block merge. +@nextright: + sta.q sp+1 ; Set the left pointer, to the right pointer. + lda.q (sp+9), y ; Get the next right pointer. + sta.q sp+9 ; Set the current right pointer to the next right pointer. + ora.d sp+13 ; Is the next right pointer NULL? + bne @loop ; No, so keep looping. +@st_lmerge2: + sta.q (sp+25), y; Clear the next block. + lda.q sp+25 ; Get the current block. + sta.q heapl ; Set the last free block entry to it. + bra @chklmerge2 ; Do the left block merge. +@chkrmerge: + lda.q sp+25 ; Get the current block. + clc ; Prepare for a non carrying add. + adc.q sp+17 ; Add the size of the current block, to the current block. + cmp.q sp+9 ; Is the right pointer NULL? + bne @normerge ; No, so don't merge the right block. +@rmerge: + ldy #fblk.size ; Get the size of the right pointer. + lda.q sp+17 ; Get the size of the current block. + clc ; Prepare for a non carrying add. + adc.q (sp+9), y ; Add the size of the current block, with the size of the right pointer. + sta.q (sp+25), y; Set the size of the current block, to the new size. +@rmerge2: + ldy #fblk.next ; Get the next right pointer. + lda.q (sp+9), y ; + sta.q (sp+25), y; Set the next block, to the next right pointer. + sta.q sp+17 ; Save the next block in the second local variable. + ora.d sp+21 ; Is the next block NULL? + beq @setheapl ; Yes, so set the last block. +@setprev: + lda.q sp+25 ; Get the current block. + ldy #fblk.prev ; Set the previous block to the current block. + sta.q (sp+17), y; + bra @chklmerge ; Do the left block merge. +@setheapl: + lda.q sp+25 ; Get the current block. + sta.q heapl ; Set the last block to the current block. + bra @chklmerge ; Do the left block merge. +@normerge: + lda.q sp+9 ; Get the right pointer. + ldy #fblk.next ; Set the next block to the right pointer. + sta.q (sp+25), y; + lda.q sp+25 ; Get the current block. + ldy #fblk.prev ; Set the previous right pointer to the current block. + lda.q (sp+9), y ; +@chklmerge: + lda.q sp+1 ; Get the left pointer. + ora.d sp+5 ; Is the left pointer NULL? + bne @chklmerge2 ; No, so keep checking. +@newstart: + ldy #fblk.prev ; Clear the previous block. + sta.q (sp+25), y; + lda.q sp+25 ; Get the current block. + sta.q heapf ; Set the first block, to the current block. + bra @end2 ; We are done. +@chklmerge2: + ldy #fblk.size ; Get the size of the left block. + lda.q (sp+1), y ; + clc ; Prepare for a non carrying add. + adc.q sp+1 ; Add the size of the left block, to the left pointer. + cmp.q sp+25 ; Is the left block adjacent? + bne @nolmerge ; No, so don't merge the left block. +@lmerge: + lda.q (sp+1), y ; Get the size of the left block. + clc ; Prepare for a non carrying add. + ldb.q (sp+25), y; Get the size of the current block. + adc b ; Add the size of the left block, with the size of the current block. + sta.q (sp+1), y ; Set the size of the left block to the new size. +@lmerge2: + ldy #fblk.next ; Get the next block. + lda.q (sp+25), y; + sta.q (sp+1), y ; Set the next left pointer, to the next block. + sta.q sp+17 ; Set the second local variable to the next block. + ora.d sp+21 ; Is the next left pointer NULL? + beq @newlast ; Yes, so set the last block. +@lprev: + lda.q sp+1 ; Get the left pointer. + ldy #fblk.prev ; Set the next left pointer's previous pointer to the left pointer. + sta.q (sp+17), y; + bra @end2 ; We are done. +@newlast: + lda.q sp+1 ; Get the left pointer. + sta.q heapl ; Set the last block, to the left pointer. + bra @end2 ; We are done. +@nolmerge: + lda.q sp+25 ; Get the current block. + ldy #fblk.next ; Set the next left pointer, to the current block. + sta.q (sp+1), y ; +@nolmerge2: + lda.q sp+1 ; Get the left pointer. + ldy #fblk.prev ; Set the previous block, to the left pointer. + sta.q (sp+25), y; +@end2: + ads #$20 ; Clean up the stack frame. + ply.q ; Restore Y. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of free. + +a +q diff --git a/programs/sub-suite/lexer.s b/programs/sub-suite/lexer.s index b2850aa..0d712ff 100644 --- a/programs/sub-suite/lexer.s +++ b/programs/sub-suite/lexer.s @@ -65,7 +65,7 @@ lex: ;@nextlline: ; ldb #1 ; No, so set the second pointer to the last line. ; jsr set_ptr ; -; ldy #ln.next ; Set the next last line to the current line. +; ldy #line.next ; Set the next last line to the current line. ; lda.q cline ; ; sta.q (ptr2), y ; ; bra @initline ; Initialize the line. @@ -76,11 +76,11 @@ lex: ; ldb #1 ; Set the second pointer to the current line. ; jsr set_ptr ; ; and #0 ; Reset A. -; ldy #ln.next ; Reset the next line. +; ldy #line.next ; Reset the next line. ; sta.q (ptr2), y ; -; ldy #ln.tok ; Reset the token. +; ldy #line.tok ; Reset the token. ; sta.q (ptr2), y ; -; ldy #ln.bline ; Reset the number of blank lines. +; ldy #line.bline ; Reset the number of blank lines. ; sta.w (ptr2), y ; ; tay ; Reset Y. @loop: @@ -225,11 +225,10 @@ ptok_dot: beq @found ; Yes, so create a new token. inc idx1 ; No, so increment the directive ID. @getlen: + mov d, a ; Get the string. jsr strlen ; Get the string's length. inc ; Add one to the length. - clc ; Prepare for a non carrying add. - adc.w idx2 ; Add the string offset to the current length - sta.w idx2 ; Save the offset in the third index. + add.w idx2, a ; Add the string offset to the current length bra @dir_loop ; Keep looping. @found: lda #TOK_DIR ; Set the lexeme type to TOK_DIR. @@ -443,11 +442,10 @@ ptok_alph: beq @found ; Yes, so create a new token. inc idx1 ; No, so increment the instruction ID. @offset: + mov d, a ; Get the string. jsr strlen ; Get the string's length. inc ; Add one to the length. - clc ; Prepare for a non carrying add. - adc.w idx2 ; Add the string offset to the current length - sta.w idx2 ; Save the offset in the third index. + add.w idx2, a ; Add the string offset to the current length bra @isop_loop ; Keep looping. @found: lda #TOK_MNE ; Set the lexeme type to TOK_MNE. diff --git a/programs/sub-suite/libc.s b/programs/sub-suite/libc.s index ae35146..53e936a 100644 --- a/programs/sub-suite/libc.s +++ b/programs/sub-suite/libc.s @@ -17,12 +17,10 @@ strtoull: pla ; Get the character back. beq @end ; No, so we're done. @alpha: - sec ; Yes, so prepare for a non borrowing subtract. - sbc #'a'-10 ; Get the numeric value from this digit. + sub #'a'-10 ; Yes, so get the numeric value from this digit. bra @chkbase ; Check if the value matches the base. @digit: - sec ; Prepare for a non borrowing subtract. - sbc #'0' ; Get the numeric value from this digit. + sub #'0' ; Get the numeric value from this digit. @chkbase: cmp sp+25 ; Does the value match the base? bcs @end ; No, so we're done. @@ -30,8 +28,7 @@ strtoull: tab ; Save the digit value. lda.q sp+1 ; Get the value from the value buffer. mul sp+25 ; Multiply the value by the base. - clc ; Prepare for a non carrying add. - adc b ; Add the digit value to the total value. + add a, b ; Add the digit value to the total value. sta.q sp+1 ; Place the value in the value buffer. iny ; Increment the string index. and #0 ; Reset A. @@ -44,80 +41,72 @@ strtoull: strlen: - phy.q ; Preserve Y. - pha.q ; Set the temp variable to the argument. and #0 ; Reset A. - tay ; Reset Y. @loop: - lda (sp+1), y ; Are we at the end of the string? - beq @end ; Yes, so we're done. - iny ; No, so increment the index. - bra @loop ; Keep looping. + inc ; Increment the index. + cmp (d+a-1), #0 ; Are we at the end of the string? + bne @loop ; No, so keep looping. @end: - pla.q ; Get the argument back. - tya ; Get the return value. - ply.q ; Get the preserved value back. + dec ; Decrement the length to not include the terminator. rts ; End of strlen. strcmp: - ldb #0 ; Reset B. - tba ; Reset A. + phb.q ; Preserve B. + phx.q ; Preserve X. phy.q ; Preserve Y. + and #0 ; Reset A. + tab ; Reset B. + tax ; Reset X. tay ; Reset Y. @loop: - ldb #0 ; Set the islong flag to false. - lda (sp+25), y ; Are we at the end of the first string? + ldx #0 ; Set the islong flag to false. + mov a, (d+y) ; Are we at the end of the first string? beq cmpr ; Yes, so check if we're too short, or too long. - ldb #1 ; No, so set the islong flag to true. - cmp (sp+19), y ; Is the character of both strings, the same? + ldx #1 ; No, so set the islong flag to true. + cmp a, (s+y) ; Is the character of both strings, the same? bne cmpr ; No, so check if we're too short, or too long. iny ; Yes, so increment the index. bra @loop ; Keep looping. -strccmp: strcasecmp: - ldb #0 ; Reset B. - tba ; Reset A. + phb.q ; Preserve B. + phx.q ; Preserve X. phy.q ; Preserve Y. + and #0 ; Reset A. + tab ; Reset B. + tax ; Reset X. + inx ; Set X to 1. tay ; Reset Y. @loop: - ldb #0 ; Set the islong flag to false. - lda (sp+25), y ; Are we at the end of the first string? + dex ; Set the islong flag to false. + mov a, (d+y) ; Are we at the end of the first string? beq cmpr ; Yes, so check if we're too short, or too long. - ldb #1 ; No, so set the islong flag to true. + inx ; No, so set the islong flag to true. jsr tolower ; Convert the character of string 1 to lowercase. - phb ; Preserve the islong flag. - pha ; Preserve the converted character. - lda (sp+19), y ; Get the character of the second string. + tab ; Save the converted character. + mov a, (s+y) ; Get the character of the second string. jsr tolower ; Convert the character of string 2 to lowercase. - tab ; Place it in B. - pla ; Get the character of string 1 back. cmp b ; Is the character of both strings, the same? - plb ; Get the islong flag back. bne cmpr ; No, so check if we're too short, or too long. iny ; Yes, so increment the index. bra @loop ; Keep looping. cmpr: - lda (sp+17), y ; Are we at the end of the second string? + mov a, (s+y) ; Are we at the end of the second string? beq @islong ; Yes, so check the islong flag. @isshort: - lda (sp+25), y ; No, but are we at the end of the first string? - beq @short ; Yes, so return -1. -@islong: - cpb #1 ; Is the islong flag true? - bne @equ ; No, so return 0. -@long: - lda #1 ; Yes, so return 1. + mov a, (d+y) ; No, but are we at the end of the first string? + bne @islong ; No, so check if the islong flag is true. + lda #$FF ; Yes, so return -1. bra @end ; We are done. -@equ: - lda #0 ; Return 0. - bra @end ; We are done. -@short: - lda #$FF ; Return -1. +@islong: + cpx #1 ; Is the islong flag true? + set a, eq ; Return true if it is. @end: - ply.q ; Get the preserved value back. + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. rts ; End of cmpr. @@ -195,304 +184,226 @@ toupper: ; malloc: Dynamically allocate memory. -; Input: A = size in bytes to allocate. +; Input: D = size in bytes to allocate. ; Output: A = Pointer to allocated memory. -; Caller preserved registers: none. -; Callie preserved registers: Y. +; Caller preserved registers: D. +; Callie preserved registers: B, X, Y. malloc: - phy.q ; Preserve Y. - pha.q ; Preserve the size. - and #0 ; Reset A. - tay ; Reset Y. - sbs #$10 ; Allocate 2 local variables onto the stack. - lda.q sp+17 ; Get the size. - ora.d sp+21 ; Is the size zero? - beq @end ; Yes, so we're done. - lda.q sp+17 ; No, so get back the size. - clc ; Prepare for a non carrying add. - adc #ublk ; Add the size of a used block struct, to the size. - sta.q sp+17 ; Set the actual size. - lda.q heapf ; Get the first heap entry. - sta.q sp+9 ; Save it in the second local variable. - bra @checkblk ; Check the block. + phb.q ; Preserve B. + phx.q ; Preserve X. + phy.q ; Preserve Y. + xor b, b ; Reset B. + mov x, b ; Reset X. + txy ; Reset Y. + mov a, d ; Get the size. + beq @end ; The size is zero, so we're done. + add #ublk ; Add the size of a used block struct, to the size. + cmp #ublk ; Is the total size smaller than the size of a used block struct? + bcs @getheapf ; No, so get the first heap entry. +@toosmall: + lda #ublk ; Yes, so set the total size to the size of a used block struct. +@getheapf: + mov d, a ; Place the new size into the passed size. + ldb.q heapf ; Get the first heap entry. + bra @checkblk ; Check the block. @findfblk: - ldy #fblk.size ; Get the size of this free block. - lda.q (sp+9), y ; - sec ; Prepare for a non borrowing subtract. - sbc.q sp+17 ; Subtract the size of this free block, with the passed size. - bcs @blkfound ; The result is less than, or equal to the free size, so return the found block. - ldy #fblk.next ; Get the next free block. - lda.q (sp+9), y ; - sta.q sp+9 ; Set the current free block, to the next free block. + mov.q a, (b+fblk.size) ; Get the size of this free block. + sub a, d ; Subtract the size of this free block, with the passed size. + bcs @blkfound ; The result is less than, or equal to the free size, so return the found block. + mov.q b, (b+fblk.next) ; Set the current free block, to the next free block. @checkblk: - ora.d sp+13 ; Is the address of this block, zero? - bne @findfblk ; No, so keep looping. - lda.q heapptr ; Yes, so get the current top of the heap. - clc ; Prepare for a non carrying add. - adc.q sp+17 ; Add the top of the heap, with the passed size. - bcs @outofspace ; The result overflowed, so return zero. - cmp.q heapend ; Is the top of the heap, less than, or equal to the max heap size? - bcc @inctop ; Yes, so increase the current top of the heap. - beq @inctop ; + bne @findfblk ; The address of this block is non NULL, so keep looping. + mov a, d ; Get the passed size. + add.q heapptr ; Add the top of the heap, with the passed size. +; mov d, a ; Save the new size. + bcs @outofspace ; The result overflowed, so return zero. + cmp.q heapend ; Is the top of the heap, less than, or equal to the max heap size? + bcc @inctop ; Yes, so increase the current top of the heap. + beq @inctop ; @outofspace: - and #0 ; Return zero. - bra @end ; We are done. + and #0 ; Return zero. + bra @end ; We are done. @inctop: - pha.q ; Preserve heapptr + size. - lda.q heapptr ; Get the previous top of the heap. - sta.q sp+17 ; Set the current free block to the previous top of the heap. - pla.q ; Restore heapptr + size. - sta.q heapptr ; Increment the current top of the heap by the passed size. - bra @setsize ; Set the size, and start address into the used space of the block. + + ldb.q heapptr ; Set the current free block to the previous top of the heap. + sta.q heapptr ; Increment the current top of the heap by the passed size. + bra @setsize ; Set the size, and start address into the used space of the block. @blkfound: - bne @sliceblk ; The block is big enough to slice. - cmp #fblk ; Is the block big enough to slice? - bcs @sliceblk ; Yes, so slice the block. - ldy #fblk.prev ; No, so get the previous free block. - lda.q (sp+9), y ; - sta.q sp+1 ; Set the third local variable, to the previous free block. - ora.d sp+5 ; Is the previous block, set to zero? - beq @setheapf ; Yes, so set the first block. - ldy #fblk.next ; No, so get the next free block. - lda.q (sp+9), y ; - sta.q (sp+1), y ; Set the previous block's next block, to the next block. - bra @chknxtblk ; Check the next block. + bne @sliceblk ; The block is big enough to slice. + cmp #fblk ; Is the block big enough to slice? + bcs @sliceblk ; Yes, so slice the block. + mov.q x, (b+fblk.prev) ; Get the previous free block. + beq @setheapf ; The previous block is NULL, so set the first block. + ldy #fblk.next ; No, so set the offset to the next free block. + mov.q (x+y), (b+y) ; Set the previous block's next block, to the next block. + bra @chknxtblk ; Check the next block. @setheapf: - lda.q (sp+9), y ; Get the next block. - sta.q heapf ; Set the first heap entry to it. + ldy #fblk.next ; Set the offset to the next block. + mov.q heapf, (b+y) ; Set the first heap entry to the next block. @chknxtblk: - lda.q (sp+9), y ; Get the next free block. - sta.q sp+1 ; Set the third local variable to the next free block. - ora.d sp+5 ; Is the next block, zero? - beq @setheapl ; Yes, so set the least heap entry. - ldy #fblk.prev ; No, so get the current previous block. - lda.q (sp+9), y ; - sta.q (sp+1), y ; Set the next block's previous block to the current previous block. - bra @retptr ; Return the pointer. + mov.q x, (b+y) ; Get the next free block. + beq @setheapl ; The next block is NULL, so set the least heap entry. + ldy #fblk.prev ; Get the current previous block. + mov.q (x+y), (b+y) ; Set the next block's previous block to the current previous block. + bra @retptr ; Return the pointer. @setheapl: - ldy #fblk.prev ; Get the current previous block. - lda.q (sp+9), y ; - sta.q heapl ; Set the last heap entry to the current previous block. - bra @retptr ; Return the pointer. + ldy #fblk.prev ; Get the current previous block. + mov.q heapl, (b+y) ; Set the last heap entry to the current previous block. + bra @retptr ; Return the pointer. @sliceblk: - ldy #fblk.size ; Get the size of the current block. - lda.q (sp+9), y ; - sec ; Prepare for a non borrowing subtract. - sbc.q sp+17 ; Subtract the current block's size from the passed size. - sta.q (sp+9), y ; Set the current block's size to the subtracted size. - clc ; Prepare for a non carrying add. - adc.q sp+9 ; Add the current block's size to the pointer of the current block. - sta.q sp+9 ; Set the current block to the space above it (return value). + ldy #fblk.size ; Get the size of the current block. + sub.q (b+y), d ; Subtract the current block's size from the passed size. + add.q b, (b+y) ; Add the current block's size to the pointer of the current block. @setsize: - ldy #ublk.size ; Start setting the used block's size, to the passed size. - lda.q sp+17 ; Get the passed size. - sta.q (sp+9), y ; Set the used block's size to the passed size. + mov.q (b+ublk.size), d ; Set the used block's size to the passed size. @retptr: - ldy #ublk.start ; Start setting the used block's starting address, to the used block. - lda.q sp+9 ; Get the used block. - sta.q (sp+9), y ; Set the used block's starting address, to the used block. - clc ; Prepare for a non carrying add. - adc #ublk ; Return the pointer to the real memory block. + mov.q (b+ublk.start), b ; Set the used block's starting address, to the used block. + add b, #ublk ; Get the pointer to the real memory block. + tba ; Return the pointer to the real memory block. @end: - ads #$18 ; Clean up the stack frame. - ply.q ; Restore Y. - rts ; End of malloc. + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. + rts ; End of malloc. ; free: Free allocated memory. -; Input: A = Pointer to allocated memory. +; Input: D = Pointer to allocated memory. ; Output: none. -; Caller preserved registers: none. -; Callie preserved registers: A, B, Y. +; Caller preserved registers: D. +; Callie preserved registers: A, B, X, Y, E. free: - pha.q ; Preserve A. - phb.q ; Preserve B. - phy.q ; Preserve Y. - pha.q ; Push the pointer argument to the stack. - and #0 ; Reset A. - tay ; Reset Y. - sbs #$18 ; Allocate 3 local variables onto the stack. - lda.q sp+25 ; Get the passed pointer. - ora.d sp+29 ; Is the passed pointer NULL? - bne @getrealblk ; No, so get the real block. - bra @end ; Yes, so we're done. + pha.q ; Preserve A. + phb.q ; Preserve B. + phx.q ; Preserve X. + phy.q ; Preserve Y. + phe.q ; Preserve E. + and #0 ; Reset A. + tab ; Reset B. + tax ; Reset X. + tay ; Reset Y. + mov a, d ; Get the passed pointer. + bne @getrealblk ; The pointer isn't NULL, so get the real block. + bra @end ; The pointer is NULL, so we're done. @getrealblk: - lda.q sp+25 ; Get the passed pointer. - sec ; Prepare for a non borrowing subtract. - sbc #8 ; Move the passed pointer back by one. - sta.q sp+25 ; Set the first local variable to the start of the used block. - lda.q (sp+25) ; Get the real block address. - sta.q sp+25 ; Set the passed pointer to the start of the real block. - ldy #ublk.size ; Get the size of the real block. - lda.q (sp+25), y; - sta.q sp+17 ; Save the size of the real block. - clc ; Prepare for a non carrying add. - adc.q sp+25 ; Add the size of the real block with the start of the real block. - cmp.q heapptr ; Is this block on top of the heap? - bne @heapadd ; No, so add it to the free block list. + sub #8 ; Get the start of the used block. + mov.q a, (a) ; Get the start of the real block. + mov.q b, (a+ublk.size) ; Get the size of the real block. + lea e, (a+b) ; Add the size of the real block with the start of the real block. + cpe.q heapptr ; Is this block on top of the heap? + bne @heapadd ; No, so add it to the free block list. @dectop: - lda.q sp+25 ; Get the block. - sta.q heapptr ; Set the top of the heap to it. + sta.q heapptr ; Set the top of the heap to the start of the current real block. @chklastblk: - lda.q heapl ; Get the last free list entry. - sta.q sp+17 ; Copy it into the second local variable. - ora.d sp+21 ; Is the free list empty? - beq @end ; Yes, so we're done. - lda.q sp+17 ; No, so Get the last free list entry. - ldy #fblk.size ; Get the size of the block. - lda.q (sp+17), y; - clc ; Prepare for a non carrying add. - adc.q sp+17 ; Add the size of the block, with the address of the block entry. - cmp.q heapptr ; Is the last block on top of the heap? - bne @end ; No, so we're done. + ldb.q heapl ; Get the last free list entry. + beq @end ; The free list is empty, so we're done. + ldy #fblk.size ; Get the size of the block. + mov.q a, (b+fblk.size) ; Get the size of the block. + lea e, (a+b) ; Add the size of the block, with the address of the block entry. + cpe.q heapptr ; Is the last block on top of the heap? + bne @end ; No, so we're done. @delblk: - lda.q sp+17 ; Yes, so remove the last block. - sta.q heapptr ; + stb.q heapptr ; Yes, so remove the last block. @correctblk: - ldy #fblk.prev ; Get the previous block. - lda.q (sp+17), y; - sta.q sp+25 ; Save the previous block for now. - sta.q heapl ; Set the last block to the previous block. - ora.d sp+29 ; Is the previous block non NULL? - bne @delnxtblk ; Yes, so delete the next block. - sta.q heapf ; No, so empty the free list. - bra @end ; We are done. + mov.q a, (b+fblk.prev) ; Get the previous block. + sta.q heapl ; Set the last block to the previous block. + bne @delnxtblk ; The previous block isn't NULL, so delete the next block. + sta.q heapf ; The previous block is NULL, so empty the free list. + bra @end ; We are done. @delnxtblk: - and #0 ; Reset A. - ldy #fblk.next ; Delete the next block. - sta.q (sp+25), y; + lea e, (a+fblk.next) ; Delete the next block. + stz.q (e) ; @end: - ads #$20 ; Clean up the stack frame. - ply.q ; Restore Y. - plb.q ; Restore B. - pla.q ; Restore A. - rts ; End of free. + ple.q ; Restore E. + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of free. @heapadd: - lda.q heapf ; Get the first block. - sta.q sp+9 ; Copy it into the third local variable. - ora.d sp+13 ; Is the free list empty? - bne @srchflst ; No, so start searching the free list. + ldy.q heapf ; Get the first block. + bne @srchflst ; The Free list isn't empty, so start searching the free list. @empty: - ldy #fblk.next ; Clear the next block. - sta.q (sp+25), y; - ldy #fblk.prev ; Clear the previous block. - sta.q (sp+25), y; - lda.q sp+25 ; Reset A. - sta.q heapf ; Clear the first block entry. - sta.q heapf ; Clear the last block entry. - bra @end ; We are done. + mov.q (a+fblk.next), y ; Clear the next block. + mov.q (a+fblk.prev), y ; Clear the previous block. + sta.q heapf ; Set the first block entry to the current block. + sta.q heapl ; Set the last block entry to the current block. + bra @end ; We are done. @srchflst: - and #0 ; Reset A. - sta.q sp+1 ; Reset the left pointer. - ldy #fblk.next ; Setup for the loop. @loop: - lda.q sp+9 ; Get the right pointer. - cmp.q sp+25 ; Is the right pointer at, or below the current block? - beq @nextright ; Yes, so get the next right pointer. - bcs @chkrmerge ; No, so do the right block merge. + cmp y, a ; Is the right pointer at, or below the current block? + beq @nextright ; Yes, so get the next right pointer. + bcs @chkrmerge ; No, so do the right block merge. @nextright: - sta.q sp+1 ; Set the left pointer, to the right pointer. - lda.q (sp+9), y ; Get the next right pointer. - sta.q sp+9 ; Set the current right pointer to the next right pointer. - ora.d sp+13 ; Is the next right pointer NULL? - bne @loop ; No, so keep looping. + tyx ; Set the left pointer, to the right pointer. + mov.q y, (y+fblk.next) ; Set the current right pointer to the next right pointer. + bne @loop ; The next right pointer isn't NULL, so keep looping. @st_lmerge2: - sta.q (sp+25), y; Clear the next block. - lda.q sp+25 ; Get the current block. - sta.q heapl ; Set the last free block entry to it. - bra @chklmerge2 ; Do the left block merge. + mov.q (a+fblk.next), y ; Clear the next block. + sta.q heapl ; Set the last free block entry to it. + bra @chklmerge2 ; Do the left block merge. @chkrmerge: - lda.q sp+25 ; Get the current block. - clc ; Prepare for a non carrying add. - adc.q sp+17 ; Add the size of the current block, to the current block. - cmp.q sp+9 ; Is the right pointer NULL? - bne @normerge ; No, so don't merge the right block. + lea e, (a+b) ; Add the size of the current block, to the current block. + cmp e, y ; Is the current block the same as the right block? + bne @normerge ; No, so don't merge the right block. @rmerge: - ldy #fblk.size ; Get the size of the right pointer. - lda.q sp+17 ; Get the size of the current block. - clc ; Prepare for a non carrying add. - adc.q (sp+9), y ; Add the size of the current block, with the size of the right pointer. - sta.q (sp+25), y; Set the size of the current block, to the new size. + mov e, b ; Get the size of the current block. + add.q e, (y+fblk.size) ; Add the size of the current block, with the size of the right pointer. + mov.q (a+fblk.size), e ; Set the size of the current block, to the new size. @rmerge2: - ldy #fblk.next ; Get the next right pointer. - lda.q (sp+9), y ; - sta.q (sp+25), y; Set the next block, to the next right pointer. - sta.q sp+17 ; Save the next block in the second local variable. - ora.d sp+21 ; Is the next block NULL? - beq @setheapl ; Yes, so set the last block. + lea fblk.next ; Get the next right pointer. + mov.q (a+e), (y+e) ; Set the next block, to the next right pointer. + mov.q b, (y+e) ; Save the next block. + beq @setheapl ; The next block is NULL, so set the last block. @setprev: - lda.q sp+25 ; Get the current block. - ldy #fblk.prev ; Set the previous block to the current block. - sta.q (sp+17), y; - bra @chklmerge ; Do the left block merge. + mov.q (b+fblk.prev), a ; Set the previous block to the current block. + bra @chklmerge ; Do the left block merge. @setheapl: - lda.q sp+25 ; Get the current block. - sta.q heapl ; Set the last block to the current block. - bra @chklmerge ; Do the left block merge. + sta.q heapl ; Set the last block to the current block. + bra @chklmerge ; Do the left block merge. @normerge: - lda.q sp+9 ; Get the right pointer. - ldy #fblk.next ; Set the next block to the right pointer. - sta.q (sp+25), y; - lda.q sp+25 ; Get the current block. - ldy #fblk.prev ; Set the previous right pointer to the current block. - lda.q (sp+9), y ; + mov.q (a+fblk.next), y ; Set the next block to the right pointer. + mov.q (y+fblk.prev), a ; Set the previous right pointer to the current block. @chklmerge: - lda.q sp+1 ; Get the left pointer. - ora.d sp+5 ; Is the left pointer NULL? - bne @chklmerge2 ; No, so keep checking. + and x, x ; Is the left pointer NULL? + bne @chklmerge2 ; No, so keep checking. @newstart: - ldy #fblk.prev ; Clear the previous block. - sta.q (sp+25), y; - lda.q sp+25 ; Get the current block. - sta.q heapf ; Set the first block, to the current block. - bra @end2 ; We are done. + mov.q (a+fblk.prev), x ; + sta.q heapf ; Set the first block, to the current block. + bra @end2 ; We are done. @chklmerge2: - ldy #fblk.size ; Get the size of the left block. - lda.q (sp+1), y ; - clc ; Prepare for a non carrying add. - adc.q sp+1 ; Add the size of the left block, to the left pointer. - cmp.q sp+25 ; Is the left block adjacent? - bne @nolmerge ; No, so don't merge the left block. + mov.q e, (x+fblk.size) ; Get the size of the left block. + add e, x ; Add the size of the left block, to the left pointer. + cmp e, a ; Is the left block adjacent? + bne @nolmerge ; No, so don't merge the left block. @lmerge: - lda.q (sp+1), y ; Get the size of the left block. - clc ; Prepare for a non carrying add. - ldb.q (sp+25), y; Get the size of the current block. - adc b ; Add the size of the left block, with the size of the current block. - sta.q (sp+1), y ; Set the size of the left block to the new size. + lea fblk.size ; Set the offset to the block size. + add.q (x+e), (a+e) ; Add the size of the left block, with the size of the current block. @lmerge2: - ldy #fblk.next ; Get the next block. - lda.q (sp+25), y; - sta.q (sp+1), y ; Set the next left pointer, to the next block. - sta.q sp+17 ; Set the second local variable to the next block. - ora.d sp+21 ; Is the next left pointer NULL? - beq @newlast ; Yes, so set the last block. + lea fblk.next ; Set the offset to the next block. + mov.q (x+e), (a+e) ; Set the next left pointer, to the next block. + mov.q b, (a+e) ; Get the next block. + beq @newlast ; The next block is NULL, so set the last block. @lprev: - lda.q sp+1 ; Get the left pointer. - ldy #fblk.prev ; Set the next left pointer's previous pointer to the left pointer. - sta.q (sp+17), y; - bra @end2 ; We are done. + mov.q (b+fblk.prev), x ; Set the next left pointer's previous pointer to the left pointer. + bra @end2 ; We are done. @newlast: - lda.q sp+1 ; Get the left pointer. - sta.q heapl ; Set the last block, to the left pointer. - bra @end2 ; We are done. + stx.q heapl ; Set the last block, to the left pointer. + bra @end2 ; We are done. @nolmerge: - lda.q sp+25 ; Get the current block. - ldy #fblk.next ; Set the next left pointer, to the current block. - sta.q (sp+1), y ; + mov.q (x+fblk.next), a ; Set the next left pointer, to the current block. @nolmerge2: - lda.q sp+1 ; Get the left pointer. - ldy #fblk.prev ; Set the previous block, to the left pointer. - sta.q (sp+25), y; + mov.q (a+fblk.prev), x ; Set the previous block, to the left pointer. @end2: - ads #$20 ; Clean up the stack frame. - ply.q ; Restore Y. - plb.q ; Restore B. - pla.q ; Restore A. - rts ; End of free. + ple.q ; Restore E. + ply.q ; Restore Y. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of free. ; memcpy: memory to memory copy. diff --git a/programs/sub-suite/shift_line.c b/programs/sub-suite/shift_line.c index 255d21b..365666b 100644 --- a/programs/sub-suite/shift_line.c +++ b/programs/sub-suite/shift_line.c @@ -24,6 +24,12 @@ uint8_t bitpos(unsigned int row, uint8_t *mask) { } +uint8_t getbit(unsigned int row, unsigned int offset) { + uint8_t mask; + uint8_t byte = bitpos(row+offset, &mask); + return (bitabl[byte] & mask); +} + void setbit(unsigned int row) { uint8_t mask; uint8_t byte = bitpos(row, &mask); @@ -48,7 +54,7 @@ void shift_line(char *str, int cursor, int left) { if (left) { int i = end-1; int j = end; - for (; i > cursor; i--, j--) { + for (; i >= cursor; i--, j--) { if (i < 0) { i = 0; str[i] = 0; @@ -72,7 +78,7 @@ void shift_line(char *str, int cursor, int left) { str[i] = 0; } end = find_end(str, i); - if ((end % maxcol) == 0 && (end/maxcol) > scr_row) { + if (((end-1) % maxcol) == 0 && ((end-1)/maxcol) > scr_row) { clrbit(end/maxcol); } } diff --git a/programs/sub-suite/subasm-syntax b/programs/sub-suite/subasm-syntax new file mode 100644 index 0000000..1337914 --- /dev/null +++ b/programs/sub-suite/subasm-syntax @@ -0,0 +1,56 @@ +/* Assembly language syntax for SuBAsm. */ + +/* Comments begin with "/*", and end with "*/". + * Directives begin with a `\`. + */ + +/* mnemonic is the instruction name/mnemonic. + * expr is an expression. + * Indirect Indexed means applying the index after the indirection. + * Indexed Indirect means applying the index before the indirection. + */ + +Expression syntax: + /* TODO */ +Instruction syntax: + Base ISA, and Base Extension: + Implied: + <mnemonic> + B register: + <mnemonic> b + Absolute/Zero Matrix: + /* [, <x|y>] means Indexed with x, or y. */ + <mnemonic> <expr>[, <x|y>] + Immediate Data: + <mnemonic> #<expr> + Absolute/Zero Matrix Indirect: + /* Indexing with x means Indexed Indirect. + * Indexing with y means Indirect Indexed. + */ + <mnemonic> (<expr>[, x])[, y] + E Indirect: + <mnemonic> (e) + Orthogonal Extension: + <mnemonic> <operand>[, operand] + Operand syntax: + <\( + /* The operand starts with a register. + * If the statment is inside brackets, then + * it's a register indirect mode. + */ + [(]reg[+<reg>][\(+|-\)<expr>][)] + /* The operand starts with an expression. + * If the statment is inside brackets, then + * it's an indirect mode. + */ + |[(]expr + /* Is the operand using Indirect, or Indirect Indexed? */ + \if (ind || ind_indexed) { + [)] + \} + [\(+|-\)<reg[+<reg>]>] + /* Is the operand using Indexed Indirect? */ + \if (indexed_ind) { + [)] + \} + \)> diff --git a/programs/sub-suite/subasm.s b/programs/sub-suite/subasm.s index 80aaa47..f22ee60 100644 --- a/programs/sub-suite/subasm.s +++ b/programs/sub-suite/subasm.s @@ -3,153 +3,260 @@ ; ; by mr b0nk 500 <b0nk@b0nk.xyz> +;subasm: +; ldb #0 ; Set the first pointer +; lda.q cmd_buf ; to the command buffer. +; jsr set_ptr ; +; tba ; Reset A. +; tax ; Reset X. +; jsr chk_shcmd ; Did we get a shortend command? +; bne @cmd ; Yes, so skip everything else. +; jsr chk_cmd ; No, but did we get a full command? +; bne @cmd ; Yes, so skip everything else. +; jsr lex ; No, so start lexing this line. +; bra @end ; We are done. +;@cmd: +; lda regf ; Get the command ID. +; cmp #8 ; Is the command ID greater than the command count? +; bcs @end ; Yes, so we're done. +; lsl #1 ; No, so multiply the command ID by two. +; phx.q ; Preserve X. +; tax ; Set the index to the offset that we just calculated. +; lea.w (cmd_srt, x); Get the pointer, from the command subroutine table. +; plx.q ; Restore X. +; and #0 ; Reset A. +; tab ; Reset B. +; jsr (e) ; Run the command's subroutine. +;@end: +; and #0 ; Reset A. +; jsr update_ptr ; Get the screen buffer index. +; tay ; Save it in Y. +; and #0 ; Reset A. +; rts ; End of subasm. +; +;chk_shcmd: +; and #0 ; Reset A. +; tab ; Reset B. +;; inb ; Set the second pointer +;; lda.w #sh_cmds ; to the shortend command table. +;; jsr set_ptr ; +;; deb ; Reset B. +;; tba ; Reset A. +; lea sh_cmds ; Get the address of the short command table. +; phy.w ; Preserve the screen buffer position. +; txy ; Set our index to zero. +; lda (ptr), y ; Is there nothing in the command buffer? +; beq @false ; Yes, so return that we failed. +; cmp #' ' ; No, but is this character, a space? +; beq @false ; Yes, so return that we failed. +; jsr tolower ; No, so convert it to lowercase. +;@loop: +;; ldb (ptr2), y ; Are we at the end of the table? +; ldb (e) ; Are we at the end of the table? +; beq @false ; Yes, so return that we failed. +; cmp b ; No, so did the character match? +; beq @found ; Yes, so check if there are any arguments. +; ine ; No, so check the next command. +; iny ; +; bra @loop ; Keep looping. +;@found: +; sty regf ; Save the command ID. +; lea (ptr) ; Get the address of the next character. +; ine ; +;; ldy #1 ; Check the next character in the command buffer. +;; lda (ptr), y ; Is this the end of the buffer? +; lda (e) ; Is this the end of the buffer? +; beq @true ; Yes, so return true. +; cmp #' ' ; No, but is this a space? +; beq @true ; Yes, so return true. +;@false: +; ldb #0 ; Reset B. +; tba ; Return false. +; tax ; Reset X. +; bra @end ; We are done. +;@true: +; lda #1 ; Return true. +;@end: +; ply.w ; Get back the screen buffer position. +; rts ; End of chk_shcmd. +; +; +;chk_cmd: +; and #0 ; Reset A. +; tab ; Reset B. +; tax ; Reset X. +; sta.q idx0 ; Reset the first index. +; sta.q idx1 ; Reset the second index. +; mov.q ptr, d ; Set the first pointer to the command buffer. +;@loop: +; lda.w #cmds ; Get pointer to the start of the command table. +; add.w idx0 ; Offset the pointer, by the length of the previous string. +; pha.q ; Preserve the command string pointer. +; jsr strcaseg ; Is the command buffer, the same as the command string? +; pla.q ; Get the command string pointer back. +; beq @true ; Yes, so return true. +; ldb idx1 ; No, so Get the command ID. +; cpb #7 ; Have we reached the end of the command table? +; beq @false ; Yes, so return false. +; inc idx1 ; No, so increment the command ID. +;@getlen: +; mov d, a ; Get the string. +; jsr strlen ; Get the string's length. +; inc ; Add one to the length. +; add.w idx0, a ; Add the string offset to the current length +; bra @loop ; Keep looping. +;@true: +; ldb idx1 ; Get the command ID. +; stb regf ; Return the command ID. +; ldb #1 ; Return true. +; bra @end ; We are done. +;@false: +; ldb #0 ; Return false. +;@end: +; rts ; End of chk_cmd. + + subasm: - ldb #0 ; Set the first pointer - lda.q cmd_buf ; to the command buffer. - jsr set_ptr ; - tba ; Reset A. - tax ; Reset X. - jsr chk_shcmd ; Did we get a shortend command? - bne @cmd ; Yes, so skip everything else. - jsr chk_cmd ; No, but did we get a full command? - bne @cmd ; Yes, so skip everything else. - jsr lex ; No, so start lexing this line. - bra @end ; We are done. + pha.q ; Preserve A. + phe.q ; Preserve E. + des ; Make room for the command id. + and #0 ; Reset A. + lea d, (cmd_buf) ; Get the command buffer. + lea s, (sp+1) ; Get the pointer to the command id. + jsr chk_shcmd ; Did we get a shortend command? + bne @cmd ; Yes, so skip everything else. + jsr chk_cmd ; No, but did we get a full command? + bne @cmd ; Yes, so skip everything else. + mov.q ptr, d ; + jsr lex ; No, so start lexing this line. + bra @end ; We are done. @cmd: - lda regf ; Get the command ID. - cmp #8 ; Is the command ID greater than the command count? - bcs @end ; Yes, so we're done. - lsl #1 ; No, so multiply the command ID by two. - phx.q ; Preserve X. - tax ; Set the index to the offset that we just calculated. - lea.w (cmd_srt, x); Get the pointer, from the command subroutine table. - plx.q ; Restore X. - and #0 ; Reset A. - tab ; Reset B. - jsr (e) ; Run the command's subroutine. + mov s, (s) ; Get the command ID. + cmp s, #7 ; Is the command ID greater than the command count? + bcs @end ; Yes, so we're done. + lsl s, #1 ; No, so multiply the command ID by two. + lea.w e, (cmd_srt+s) ; Get the pointer, from the command subroutine table. + and #0 ; Reset A. + tab ; Reset B. + jsr (e) ; Run the command's subroutine. @end: - and #0 ; Reset A. - jsr update_ptr ; Get the screen buffer index. - tay ; Save it in Y. - and #0 ; Reset A. - rts ; End of subasm. + and #0 ; Reset A. + jsr update_ptr ; Get the screen buffer index. + tay ; Save it in Y. + ins ; Cleanup the stack frame. + ple.q ; Restore E. + pla.q ; Restore A. + rts ; End of subasm. + chk_shcmd: - and #0 ; Reset A. - tab ; Reset B. -; inb ; Set the second pointer -; lda.w #sh_cmds ; to the shortend command table. -; jsr set_ptr ; -; deb ; Reset B. -; tba ; Reset A. - lea sh_cmds ; Get the address of the short command table. - phy.w ; Preserve the screen buffer position. - txy ; Set our index to zero. - lda (ptr), y ; Is there nothing in the command buffer? - beq @false ; Yes, so return that we failed. - cmp #' ' ; No, but is this character, a space? - beq @false ; Yes, so return that we failed. - jsr tolower ; No, so convert it to lowercase. + phb.q ; Preserve B. + lea b, sh_cmds ; Get the address of the short command table. + mov a, (d) ; Is the string empty? + beq @false ; Yes, so return that we failed. + cmp #' ' ; No, but is this character, a space? + beq @false ; Yes, so return that we failed. + jsr tolower ; No, so convert it to lowercase. @loop: -; ldb (ptr2), y ; Are we at the end of the table? - ldb (e) ; Are we at the end of the table? - beq @false ; Yes, so return that we failed. - cmp b ; No, so did the character match? - beq @found ; Yes, so check if there are any arguments. - ine ; No, so check the next command. - iny ; - bra @loop ; Keep looping. + cmp (b), #0 ; Are we at the end of the table? + beq @false ; Yes, so return that we failed. + cmp a, (b) ; No, so did the character match? + beq @found ; Yes, so check if there are any arguments. + inb ; No, so check the next command. + bra @loop ; Keep looping. @found: - sty regf ; Save the command ID. - lea (ptr) ; Get the address of the next character. - ine ; -; ldy #1 ; Check the next character in the command buffer. -; lda (ptr), y ; Is this the end of the buffer? - lda (e) ; Is this the end of the buffer? - beq @true ; Yes, so return true. - cmp #' ' ; No, but is this a space? - beq @true ; Yes, so return true. + sub.w b, #sh_cmds ; Get the command ID. + mov (s), b ; Save the command ID. + mov a, (d+1) ; Is this the end of the string? + beq @true ; Yes, so return true. + cmp #' ' ; No, but is this a space? + beq @true ; Yes, so return true. @false: - ldb #0 ; Reset B. - tba ; Return false. - tax ; Reset X. - bra @end ; We are done. + and #0 ; Return false. + bra @end ; We are done. @true: - lda #1 ; Return true. + lda #1 ; Return true. @end: - ply.w ; Get back the screen buffer position. - rts ; End of chk_shcmd. + plb.q ; Restore B. + rts ; End of chk_shcmd. chk_cmd: - tba ; Reset A. - tax ; Reset X. - sta.q idx0 ; Reset the first index. - sta.q idx1 ; Reset the second index. + phb.q ; Preserve B. + phx.q ; Preserve X. + phy.q ; Preserve Y. + and #0 ; Reset A. + tab ; Reset B. + mov x, s ; Preserve the command ID pointer. + mov y, d ; Preserve the string pointer. + lea s, cmds ; Get pointer to the start of the command table. @loop: - lda.w #cmds ; Get pointer to the start of the command table. - clc ; Prepare for a non carrying add. - adc.w idx0 ; Offset the pointer, by the length of the previous string. - pha.q ; Preserve the command string pointer. - jsr strcaseg ; Is the command buffer, the same as the command string? - pla.q ; Get the command string pointer back. - beq @true ; Yes, so return true. - ldb idx1 ; No, so Get the command ID. - cpb #7 ; Have we reached the end of the command table? - beq @false ; Yes, so return false. - inc idx1 ; No, so increment the command ID. + jsr strcasecmp ; Is the command buffer, the same as the command string? + beq @true ; Yes, so return true. + inb ; No, so increment the command ID. + cpb #7 ; Have we reached the end of the command table? + bcs @false ; Yes, so return false. @getlen: - jsr strlen ; Get the string's length. - inc ; Add one to the length. - clc ; Prepare for a non carrying add. - adc.w idx0 ; Add the string offset to the current length - sta.w idx0 ; Save the offset in the first index. - bra @loop ; Keep looping. + mov d, s ; Get the command table string. + jsr strlen ; Get the string's length. + mov d, y ; Restore the string pointer. + inc ; Add one to the length. + add s, a ; Add the string offset to the current length + bra @loop ; Keep looping. @true: - ldb idx1 ; Get the command ID. - stb regf ; Return the command ID. - ldb #1 ; Return true. - bra @end ; We are done. + lda #1 ; Return true. + bra @end ; We are done. @false: - ldb #0 ; Return false. + lda #0 ; Return false. @end: - rts ; End of chk_cmd. + mov s, x ; Restore the command ID pointer. + mov (s), b ; Save the command ID. + and a, a ; Set the flags accordingly. + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. + rts ; End of chk_cmd. + viewmem: - lda.q prg_cnt ; Get the program counter. - sta.q idx0 ; Save the address in the first index. - and #$F0 ; Clear the first four bits of the address. - sta idx0 ; Overwrite the first byte, with the masked byte. - lda #19 ; Move the cursor to the right, by 19 columns. - sta scr_col ; - jsr update_pos ; - jsr print_lo ; Print the low nibble offsets. - ldx #0 ; Reset X. - ldb #0 ; Reset B. - stb idx1 ; Reset the byte count. + pha.q ; Preserve A. + phb.q ; Preserve B. + phx.q ; Preserve X. + sbs #$50 ; Make room for the string buffer. + and #0 ; Reset A. + tab ; Reset B. + ldx.q prg_cnt ; Get the program counter. + lda #19 ; Move the cursor to the right, by 19 columns. + sta scr_col ; + jsr update_pos ; + jsr print_lo ; Print the low nibble offsets. @loop: - lda #'\n' ; Print a newline. - jsr print_char ; - jsr print_hi ; Place the address in the string buffer. - jsr print_chunk ; Place the next 16 bytes in the string buffer. - lea strbuf ; Print the string buffer. -; jsr print_str ; - jsr print_sfast ; - inc idx1 ; Increment the chunk count. - ldb idx1 ; Get the chunk count. - cpb #$10 ; Did we print 16 chunks? - beq @end ; Yes, so we're done. - lda.q idx0 ; No, so get the address index. - clc ; Prepare for a non carrying add. - adc #$10 ; Add 16 to the address. - sta.q idx0 ; Put it back into the address. - and #0 ; Reset A. - bra @loop ; Keep looping. + lda #'\n' ; Print a newline. + jsr print_char ; + lea d, (sp+1) ; Get the address of the string buffer. + mov s, x ; Get the program counter. + jsr print_hi ; Print the address to the string buffer. + mov d, a ; Get the string buffer pointer after the printed address. + mov s, x ; Get the program counter. + jsr print_chunk ; Print the next 16 bytes to the string buffer. + lea d, (sp+1) ; Get the address of the string buffer. + lea s, (buffer)+y ; Get the address of the screen buffer, at the current cursor position. +; jsr print_str ; Print the string buffer. + jsr print_sfast ; + inb ; Increment the chunk count. + cpb #$10 ; Did we print 16 chunks? + beq @end ; Yes, so we're done. + add x, #$10 ; No, so add 16 to the address. + and #0 ; Reset A. + bra @loop ; Keep looping. @end: - lda #'\n' ; Print a newline. - jsr print_char ; - and #0 ; Reset A. - rts ; End of viewmem. + lda #'\n' ; Print a newline. + jsr print_char ; + ads #$50 ; Cleanup the stack frame. + plx.q ; Restore X. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of viewmem. list: @@ -164,10 +271,10 @@ help: nop ; @end: rts ; End of help. -inst: +instruction: nop ; @end: - rts ; End of inst. + rts ; End of instruction. run: nop ; @end: diff --git a/programs/sub-suite/subeditor.s b/programs/sub-suite/subeditor.s index 387b5db..f6b647f 100644 --- a/programs/sub-suite/subeditor.s +++ b/programs/sub-suite/subeditor.s @@ -11,8 +11,8 @@ reset: ldy #0 ; Reset Y. tyx ; Reset X. jsr init_heap ; Initialize the heap. - tax ; Set the stack pointer to the end of RAM. - txs ; + mov sp, a ; Set the stack pointer to the end of RAM. +; txs ; sub.d #STKSIZE ; Subtract the stack size, from the end of RAM. sta.q heapend ; Save the end of the heap. and #0 ; Reset A. @@ -28,45 +28,39 @@ reset: init_heap: lea HEAPORG ; Get the heap's starting point. ste.q heapptr ; + mov d, e ; jsr findramend ; Find the end of the heap. rts ; End of init_heap. init_tables: - and #0 ; Reset A. - lda.w #SCRSIZE ; Allocate SCRSIZE bytes of RAM for the screen buffer. + lea d, SCRSIZE ; Allocate SCRSIZE bytes of RAM for the screen buffer. jsr malloc ; sta.q buffer ; - and #0 ; Reset A. - lda.w #CMDSIZE ; Allocate CMDSIZE bytes of RAM for the command buffer. + lea d, CMDSIZE ; Allocate CMDSIZE bytes of RAM for the command buffer. jsr malloc ; sta.q cmd_buf ; - and #0 ; Reset A. - lda.w #LWSIZE ; Allocate LWSIZE bytes of RAM for the linewrap table. + lea d, LWSIZE ; Allocate LWSIZE bytes of RAM for the linewrap table. jsr malloc ; sta.q bitabl ; - and #0 ; Reset A. rts ; End of init_tables. ;test_free: ; inc step ; -; lda.q bitabl ; +; mov.q d, bitabl ; ; jsr free ; -; lda.q buffer ; +; mov.q d, buffer ; ; jsr free ; -; and #0 ; Reset A. -; lda.w #LWSIZE ; Allocate LWSIZE bytes of RAM for the linewrap table. +; lea d, LWSIZE ; Allocate LWSIZE bytes of RAM for the linewrap table. ; jsr malloc ; ; sta.q bitabl ; -; lda.q cmd_buf ; +; mov.q d, cmd_buf; ; jsr free ; -; and #0 ; Reset A. -; lda.w #SCRSIZE ; Allocate SCRSIZE bytes of RAM for the screen buffer. +; lea d, SCRSIZE ; Allocate SCRSIZE bytes of RAM for the screen buffer. ; jsr malloc ; ; sta.q buffer ; -; and #0 ; Reset A. -; lda.w #CMDSIZE ; Allocate CMDSIZE bytes of RAM for the command buffer. +; lea d, CMDSIZE ; Allocate CMDSIZE bytes of RAM for the command buffer. ; jsr malloc ; ; sta.q cmd_buf ; ; and #0 ; Reset A. @@ -74,33 +68,38 @@ init_tables: clr_arr: - stz.q (e) ; Clear eight bytes. - ade #8 ; Increment the pointer by 8. - stz.q (e) ; Clear eight bytes. - ade #8 ; Increment the pointer by 8. - sub #$10 ; Subtract 16 from the size. + pha.q ; Preserve A. + and #0 ; Reset A. +@loop: + mov.q (d), a ; Clear 16 bytes. + mov.q (d+8), a ; + add d, #$10 ; Increment the pointer by 16. + sub s, #$10 ; Subtract 16 from the size. bcc @end ; We've reached the end of the array, so we're done. beq @end ; - bra clr_arr ; Keep looping. + bra @loop ; Keep looping. @end: + pla.q ; Restore A. rts ; End of clr_arr. pnt_strt: - lea ed_name ; Print the name of the editor. + lea d, ed_name ; Print the name of the editor. jsr print_str ; - lea ver_str ; Print the version text. + lea d, ver_str ; Print the version text. jsr print_str ; - lea ed_ver ; Print the version number. + lea d, ed_ver ; Print the version number. jsr print_str ; - lea ed_sver ; Print the sub version number. + lea d, ed_sver ; Print the sub version number. jsr print_str ; + lea d, '\n' ; Print a newline. lda #'\n' ; Print a newline. jsr print_char ; - lea made ; Print the "Created by" text. + lea d, made ; Print the "Created by" text. jsr print_str ; - lea author ; Print the name of the author. + lea d, author ; Print the name of the author. jsr print_str ; + lea d, '\n' ; Print a newline. lda #'\n' ; Print a newline. jsr print_char ; rts ; End of pnt_strt. @@ -109,8 +108,8 @@ pnt_strt: clr_cmd: and #0 ; Reset A. tay ; Reset Y. - lda.w #CMDSIZE ; Set the clear count to CMDSIZE. - lea (cmd_buf) ; Set the array to be cleared to the command buffer. + lea s, CMDSIZE ; Set the clear count to CMDSIZE. + lea d, (cmd_buf); Set the array to be cleared to the command buffer. jsr clr_arr ; Clear the command buffer. rts ; End of clr_cmd. @@ -149,140 +148,68 @@ getchar: print_str: + pha.q ; Preserve A. + phb.q ; Preserve B. and #0 ; Reset A. tba ; Reset B. @loop: - ldb #1 ; Enable replace mode. - stb regb ; - and #0 ; No, reset the accumulator. - ldb (e) ; Are we at the end of the string? + mov regb, #1 ; Enable replace mode. + and #0 ; Reset A. + mov b, (d) ; Are we at the end of the string? beq @end ; Yes, so we're done. jsr update_ptr ; No, so get the screen buffer index. tay ; Save it in Y. tba ; Get the character back. - ine ; Increment the string pointer. + inc d ; Increment the string pointer. jsr print_char ; Print the character. bra @loop ; Keep looping. @end: stz regb ; Enable insert mode. and #0 ; Reset A. tab ; Reset B. + pla.q ; Restore A. + plb.q ; Restore B. rts ; End of print_str. -;print_str: -; ldx #0 ; Reset X. -; sta.q end ; Save the parameter. -;@reset: -; lda.q end ; Get the parameter. -; ldb #0 ; Clear the B register. -; jsr set_ptr ; Set the first pointer to the parameter. -; tba ; Clear the Accumulator. -;@loop: -; ldb #1 ; Enable replace mode. -; stb regb ; -; lda.q ptr ; Get the first pointer. -; cmp.q end ; Did the pointer change? -; bne @reset ; Yes, so set it back. -; and #0 ; No, reset the accumulator. -; txy ; Copy the string index into Y. -; ldb (ptr), y ; Are we at the end of the string? -; beq @end ; Yes, so we're done. -; jsr update_ptr ; No, so get the screen buffer index. -; tay ; Save it in Y. -; tba ; Get the character back. -; inx ; Increment the string index. -; phx ; Preserve the string index. -; jsr print_char ; Print the character. -; plx ; Get the string index back. -; bra @loop ; Keep looping. -;@end: -; stz regb ; Enable insert mode. -; and #0 ; Reset A. -; tab ; Reset B. -; rts ; End of print_str. - getbit: - clc ; Clear the carry flag. - lda scr_str ; Has the screen been scrolled? - bne getbt0 ; Yes, so add the screen offset to the current line number. - ldx scr_row ; No, so just use the current line number. - bra getbt1 ; Start getting the bit. -getbt0: - lda scr_row ; Get the current line number. - adc scr_str ; Add the screen offset to it. - tax ; Use it as the wrap index. -getbt1: - pha ; Save the parameter. - ldb #1 ; Make sure that set_ptr sets the second pointer. - lda.q bitabl ; Set the second pointer to the linewrap table. - jsr set_ptr ; - lsr #$10 ; Clear the Accumulator. - pla ; Get the return byte back. - jsr bitpos ; Get the bit, and byte position. - phy.w ; Save the screen index. - txy ; Get the byte position. - ldb (ptr2), y ; Get one byte of the wrap table. - ply.w ; Get the screen index back. - and b ; Mask out the bit of the current line number. - cmp #1 ; Set the carry flag, if true. - bra bitout ; We are done. + des ; Create the stack frame. + add d, s ; Add the row position with the row offset position. + lea s, (sp+1) ; Get the address of the bitmask. + jsr bitpos ; Get the bit, and byte position. + ins ; Cleanup the stack frame. + mov a, (bitabl)+a ; Get the bit of the row position. + and a, (s) ; Return the masked bit. + rts ; End of getbit. + clrbit: - pha ; Save the parameter. - ldb #1 ; Make sure that set_ptr sets the second pointer. - lda.q bitabl ; Set the second pointer to the linewrap table. - jsr set_ptr ; - and #0 ; Clear the Accumulator. - pla ; Get the return byte back. - jsr bitpos ; Get the bit, and byte position. - xor #$FF ; Invert the bitmask. - phy.w ; Save the screen index. - txy ; Get the byte position. - ldb (ptr2), y ; Get one byte of the wrap table. - and b ; Clear the bit of the current line number. -bitsav: - sta (ptr2), y ; Update the wrap table. - ply.w ; Get the screen index back. -bitout: - ldx bitmask ; Return the bitmask. - rts ; We are done. + pha.q ; Preserve A. + des ; Create the stack frame. + lea s, (sp+1) ; Get the address of the bitmask. + jsr bitpos ; Get the bit, and byte position. + ins ; Cleanup the stack frame. + not (s) ; Invert the bitmask. + and (bitabl)+a, (s) ; Set the bit of the current row number to zero. + pla.q ; Restore A. + rts ; End of clrbit. setbit: - pha ; Save the parameter. - ldb #1 ; Make sure that set_ptr sets the second pointer. - lda.q bitabl ; Set the second pointer to the linewrap table. - jsr set_ptr ; - and #0 ; Clear the Accumulator. - pla ; Get the return byte back. - jsr bitpos ; Get the bit, and byte position. - phy.w ; Save the screen index. - txy ; Get the byte position. - ldb (ptr2), y ; Get one byte of the wrap table. - ora b ; Set the bit of the current line number. - bra bitsav ; Save the bit. + pha.q ; Preserve A. + des ; Create the stack frame. + lea s, (sp+1) ; Get the address of the bitmask. + jsr bitpos ; Get the bit, and byte position. + ins ; Cleanup the stack frame. + or (bitabl)+a, (s) ; Set the bit of the current row number to one. + pla.q ; Restore A. + rts ; End of setbit. bitpos: - pha ; Save the parameter. - ldb #0 ; Make sure that set_ptr sets the first pointer. - lda.w #bits ; Set the first pointer to the bitmask table. - jsr set_ptr ; - and #0 ; Clear the Accumulator. - pla ; Get the parameter back. - stx bitmask ; Make the line number the bitmask. - txa ; Copy it to the Accumulator. - and #7 ; Get the bit position. - phy.w ; Save the cursor index. - tay ; Use the bit position as the index. - tax ; Copy it into X. - lda (ptr), y ; Get the bitmask. - ply.w ; Get back the cursor index. - pha ; Save the bitmask. - lda bitmask ; Get the line number. - lsr #3 ; Get the byte position. - tax ; Copy it into X. - pla ; Get back the bitmask. - rts ; End of bitpos. + mov a, d ; Preserve the row number. + and d, #7 ; Get the bit position. + lsr #3 ; Return the byte position. + mov (s), (d+bits) ; Place the bitmask into the mask argument. + rts ; End of bitpos. handle_char: @@ -328,7 +255,10 @@ handle_char: cmd_cpy: lda scr_row ; Get the row position. sta scr_trow ; Save it for later. - jsr findend ; Find the end of the line. + lea d, (buffer) ; Get the screen buffer. + mov s, y ; Get the cursor index. + jsr find_end ; Find the end of the line. + div #maxcol+1 ; Get the ending line. ldb scr_str ; Has the screen been scrolled? beq @start ; No, so don't subtract the screen's starting point from the line number. @offset: @@ -388,48 +318,45 @@ cmd_cpy: findst: - lda #0 ; Reset A. +; lda #0 ; Reset A. +; xor d, d ; Reset D. +; xor s, s ; Reset S. + mov d, scr_row ; Get the row position. + mov s, scr_str ; Get the row offset. @loop: - pha ; Save the current line number. +; pha ; Save the current line number. jsr getbit ; Is this the start of the line? - pla ; Get the current line number back. - bcc @end ; Yes, so we're done. - inc ; No, so check the next physical line. +; pla ; Get the current line number back. + beq @end ; Yes, so we're done. + inc d ; No, so check the next physical line. dec scr_row ; Are we at the top of the screen? bpo @loop ; No, so keep looping. - dec ; Yes, so move back one line. + dec d ; Yes, so move back one line. inc scr_row ; Put the row postiion back to zero. @end: - cmp #0 ; Update all the flags. + cmp d, #0 ; Update all the flags. rts ; End of findst. -fndend: - phb ; Save the contents of the B register. - ldb #0 ; Make sure that set_ptr sets the first pointer. - lda.q buffer ; Set the first pointer to the start of the screen buffer. - jsr set_ptr ; - tba ; Set the Accumulator to zero. - plb ; Restore the contents of the B register. - phy.w ; +find_end: + mov a, s ; Set the loop counter. @loop: - lda (ptr), y ; Are we at the end of the string? - beq @end ; Yes, so we're done. - iny ; No, so increment the cursor index. - bra @loop ; Keep looping. + inc ; Increment the loop counter. + cmp (d+a-1), #0 ; Did we hit the null terminator? + bne @loop ; No, so keep looping. @end: - sty.w scr_ptr3 ; - ply.w ; - rts ; End of fndend. - -findend: - jsr fndend ; - lda.w scr_ptr3 ; - div #maxcol+1 ; - rts ; + rts ; End of find_end. + + +get_endrow: + jsr find_end ; Find the end of the line. + div #maxcol+1 ; Get the ending row. + rts ; End of get_endrow print_char: + phb.q ; Preserve B. + phx.q ; Preserve X. phe.q ; Preserve E. sta rega ; Preserve the character. ldb #2 ; Make sure that set_ptr sets the third pointer. @@ -441,15 +368,13 @@ print_char: lda rega ; Get the character back. jsr get_ctrlidx ; Get the control code jump table index. lsl #1 ; Multiply the return value by two, to get the index. - tax ; - lea.w (ct_jtb, x); Get the address of the control code handler. -; pha.q ; -; ple.q ; -; jsr set_ptr ; Set the second pointer to the control code handler. + lea.w e, (ct_jtb+a); Get the address of the control code handler. deb ; Reset B. tba ; Reset A. jsr (e) ; Jump to the handler for that control code. ple.q ; Restore E. + plx.q ; Restore X. + plb.q ; Restore B. rts printc: lda #0 ; start trying to print a character. @@ -458,18 +383,20 @@ printc: beq @save ; Yes, so just print the character. lda regb ; No, but was the flag set? bne @save ; Yes, so don't shift the line. - sty.w scr_ptr ; No, so save the cursor index for later. - jsr fndend ; Find the end of the line. +; sty.w scr_ptr ; No, so save the cursor index for later. +; jsr fndend ; Find the end of the line. bra @shift ; Start shifting the line right. @update: lda scr_col ; Save the current column position for later. sta scr_tcol ; @update1: - jsr findend ; Find the end of the line. - sta rege ; Use it for redrawing the line. + lea d, (buffer) ; Get the screen buffer. + mov s, y ; Get the cursor index. + jsr get_endrow ; Get the ending line. + mov d, a ; + mov s, scr_trow ; Get the current row position. lda scr_trow ; Get the current row position. @update2: - sta regf ; Set the starting line, to the current row position. jsr rdrw_ln ; Redraw the line. lda scr_trow ; Get the real row position back. sta scr_row ; @@ -479,12 +406,15 @@ printc: dec regd ; bra @save1 ; @shift: - ldy.w scr_ptr3 ; - inc scr_ptr3 ; - tyx ; - dey ; - ldb #1 ; - stb regd ; +; ldy.w scr_ptr3 ; +; inc scr_ptr3 ; +; tyx ; +; dey ; +; ldb #1 ; +; stb regd ; + lea d, (buffer) ; Get the screen buffer. + mov.w s, scr_ptr; Get the cursor index. + mov f, #1 ; Set the left flag to true. jsr shftln ; ldb #1 ; stb regd ; @@ -501,6 +431,7 @@ printc: sta (ptr3), y ; store typed character into the input buffer. @incr: inc scr_col ; Increment the cursor's x coordinate. + inc.w scr_ptr ; Increment the screen index. iny ; @wrapped: ldb #1 ; @@ -536,13 +467,15 @@ printc: @wrap1: inc scr_row ; @wrap2: - phx.w ; - clc ; - lda scr_row ; - adc scr_str ; - tax ; - jsr setbit ; - plx.w ; +; phx.w ; +; clc ; +; lda scr_row ; +; adc scr_str ; +; tax ; + mov d, scr_row ; Get the row position. + add d, scr_str ; Add the row offset to the row position. + jsr setbit ; Set the bit of that row. +; plx.w ; jsr update_pos ; printc_end: rts ; @@ -573,11 +506,11 @@ clr_scr: sta scr_end ; stz scr_str ; tay ; - lda.w #LWSIZE ; Set the clear count to LWSIZE. - lea (bitabl) ; Set the array to be cleared to the linewrap table. + lea s, LWSIZE ; Set the clear count to LWSIZE. + lea d, (bitabl) ; Set the array to be cleared to the linewrap table. jsr clr_arr ; Clear the linewrap table. - lda.w #SCRSIZE ; Set the clear count to SCRSIZE. - lea (buffer) ; Set the array to be cleared to the screen buffer. + lea s, SCRSIZE ; Set the clear count to SCRSIZE. + lea d, (buffer) ; Set the array to be cleared to the screen buffer. jsr clr_arr ; Clear the screen buffer. ; lda.w #CMDSIZE ; Set the clear count to CMDSIZE. ; lea (cmd_buf) ; Set the array to be cleared to the command buffer. @@ -613,8 +546,10 @@ bs: beq @wrap ; Yes, so check for a wrapped line. bra back ; No, so add the backspace to the buffer. @wrap: + mov d, scr_row ; Get the row position. + mov s, scr_str ; Get the row offset. jsr getbit ; Is this line, a wrapped line? - bcs @wrap1 ; Yes, so check if the cursor is at the top. + bne @wrap1 ; Yes, so check if the cursor is at the top. rts ; No, so we're done. @wrap1: lda scr_row ; Are we at the top of the screen? @@ -644,7 +579,9 @@ back: stb regf ; lda scr_row ; Save the current row position for later. sta scr_trow ; - jsr findend ; Find the end of the line. + lea d, (buffer) ; Get the screen buffer. + mov s, y ; Get the cursor index. + jsr get_endrow ; Get the ending line. sta scr_row ; Set our row position to the end of the line. @find_st: jsr findst ; Does this line take up more than one real line? @@ -660,14 +597,20 @@ back: iny ; Increment cursor index. ldb #0 ; Set shifting direction to left. stb regd ; + lea d, (buffer) ; Get the screen buffer. + mov s, y ; Get the cursor index. + mov f, #0 ; Set the left flag to false. jsr shftln ; Shift line back by one character. lda #$7F ; Print a backspace to the screen. sta scr ; lda rege ; Are we updating more than one line? beq @load ; No, so skip to the next step. @find_end: - jsr findend ; Yes, so find the end of the line. - sta rege ; Set the end parameter to it. + lea d, (buffer) ; Get the screen buffer. + mov s, y ; Get the cursor index. + jsr get_endrow ; Yes, so Get the ending line. + mov d, a ; + mov s, scr_trow ; Get the current row position. lda scr_col ; Save the current column position for now. sta scr_tcol ; jsr rdrw_ln ; Start redrawing the line. @@ -683,88 +626,73 @@ back: lda (ptr3), y ; Are we at the end of the line? beq @shift ; Yes, so skip redrawing. lda scr_trow ; No, so set the line to start redrawing, to the line that the cursor is on. - sta regf ; inc rege ; Set the redraw flag to true. bra @shift ; Start shifting the line back. shftln: - ldb regd ; Is the flag not set? - beq @dec_loop ; Yes, so shift, and decrement. - ldb #0 ; Clear the B register. - bra @inc_loop ; No, so shift, and increment. + pha.q ; Preserve A. + phb.q ; Preserve B. + and f, f ; Is the left flag not set? + beq @right ; Yes, so shift the line to the right. +; txa ; Get the end of the line. + jsr find_end ; Find the end of the line. + dec ; Decrement the source position. + bra @left ; No, so shift the line to the left. @minus: - ldy.w zero ; Set the source poition to 0. - stb (ptr3), y ; Clear the character that is in the source. - bra @end ; We are done. -@inc_loop: - sty.w scr_ptr2 ; Save the source position for later. - ldy.w scr_ptr ; Get the previous cursor index. - cpy.w scr_ptr2 ; Is the source position, at, or below the cursor index? - beq @inc_loop1 ; Yes, so keep looping. - bcs @end ; No, so we're done. -@inc_loop1: - ldy.w scr_ptr2 ; Get the source position. - lda (ptr3), y ; Get the character from the source position. - phy.w ; Save the source position for later. - txy ; Set our position to the destination. - sta (ptr3), y ; Place the character from the source position, to the destination position. - ply.w ; Set our position back to the source. - stb (ptr3), y ; Clear the character that is in the source. - bng @minus ; The source underflowed, so set it back to zero, - dey ; Decrement the source position. - dex ; Decrement the destination position. - bra @inc_loop ; Keep looping. -@dec_loop: - stx.w scr_ptr2 ; Save the destination position for later. - lda (ptr3), y ; Is the character at the source position, a null terminator? - beq @end3 ; Yes, so we're done. - phy.w ; No, so save the source position for later. - txy ; Set our position to the destination. - sta (ptr3), y ; Place the character from the source position, to the destination position. - inx ; Increment the destination position. - ply.w ; Set our position back to the source. - stb (ptr3), y ; Clear the character that is in the source. - iny ; Increment the source position. - bra @dec_loop ; Keep looping. + and #0 ; Set the source poition to 0. + mov (d), a ; Clear the character that is in the source. + bra @lend ; We are done. +@left: + cmp s, a ; Is the cursor index, at, or below the source position? + beq @left1 ; Yes, so keep looping. + bcs @lend ; No, so we're done. +@left1: + cmp #0 ; Is the source position less than 0? + bcc @minus ; Yes, so set the source position to zero. + mov (d+a+1), (d+a) ; No, so shift the current character to the left by one. + mov (d+a), #0 ; Clear the current character. + dec ; Decrement the source position. + bra @left ; Keep looping. +@right: + cmp (d+s), #0 ; Is this character a null terminator? + beq @rend ; Yes, so we're done. + mov (d+s-1), (d+s) ; No, so shift the current character to the right by one. + mov (d+s), #0 ; Clear the current character. + inc s ; Increment the source position. + bra @right ; Keep looping. @wrap: - tax ; Use the ending line as a parameter for setbit. - jsr setbit ; Set the wrap bit of the ending line. - bra @end5 ; We are done. + mov d, a ; Get the ending line. + jsr setbit ; Set the wrap bit of the ending line. + bra @end ; We are done. @wrap1: - tax ; Use the ending line as a parameter for clrbit. - jsr clrbit ; Clear the wrap bit of the ending line. - bra @end5 ; We are done. + mov d, a ; Get the ending line. + jsr clrbit ; Clear the wrap bit of the ending line. + bra @end ; We are done. +@lend: + lea s, (a+2) ; Add 2 to the source position. + jsr find_end ; Find the end of the line. + dec ; Decrement the end of line position. + div #maxcol+1 ; Get the ending line. +@lend2: + cmp scr_row ; Is the ending line greater than the starting line? + beq @end ; No, so we're done. + bcs @wrap ; Yes, so set the wrap bit. + bra @end ; No, so we're done. +@rend: + jsr find_end ; Find the end of the line. + dec ; Decrement the end of line position. + div #maxcol+1 ; Get the ending line. + cpb #0 ; Is the remainder zero? + bne @end ; No, so we're done. +@rend2: + cmp scr_row ; Is the ending line greater than the starting line? + beq @end ; No, so we're done. + bcs @wrap1 ; Yes, so clear the wrap bit. @end: - lda (ptr3), y ; Is this character a null terminator? - bne @end1 ; No, so just find the end of the line. - lda #$20 ; Yes, so convert it to a space for now. - sta (ptr3), y ; -@end1: - jsr findend ; Find the ending line. - sta regd ; Save ending line for later. - lda (ptr3), y ; Is this character a space? - cmp #$20 ; - bne @end5 ; No, so skip the conversion. - lda #0 ; Yes, so convert it back to zero. - sta (ptr3), y ; -@end2: - lda regd ; Get the ending line. - cmp scr_row ; Is the ending line greater than the starting line? - beq @end5 ; No, so we're done. - bcs @wrap ; Yes, so set the wrap bit. - bra @end5 ; No, so we're done. -@end3: - jsr findend ; Find the ending line. - cpb #0 ; Is the remainder zero? - beq @end4 ; Yes, so check if the ending line is greater than the starting line. - bra @end5 ; No, so we're done. -@end4: - cmp scr_row ; Is the ending line greater than the starting line? - beq @end5 ; No, so we're done. - bcs @wrap1 ; Yes, so clear the wrap bit. -@end5: - rts ; End of shftln. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of shftln. esc: @@ -883,8 +811,10 @@ isright: bra @right ; No, so move the cursor right, like normal. @wrap: inc scr_row ; Move down a row. + mov d, scr_row ; Get the row position. + mov s, scr_str ; Get the row offset. jsr getbit ; Is the current line, a wrapped line? - bcs @incr ; Yes, so leave the cursor where it is. + bne @incr ; Yes, so leave the cursor where it is. dec scr_row ; No, so move the cursor back up a row. bra @end2 ; We are done. @scroll: @@ -927,8 +857,10 @@ isleft: beq @left ; Yes, so move the cursor left. bra @end1 ; No, so we're done. @wrap: + mov d, scr_row ; Get the row position. + mov s, scr_str ; Get the row offset. jsr getbit ; Is the current line, a wrapped line? - bcs @decr ; Yes, so wrap back up a line. + bne @decr ; Yes, so wrap back up a line. bra @end1 ; No, so we're done. @decr: lda scr_row ; Is the cursor at the top of the screen? @@ -999,12 +931,11 @@ isshftdown: update_ptr: - clc ; Clear the carry flag. lda scr_row ; Add the cursor's line number, - adc scr_str ; with the starting line number to get the absolute line number. + add scr_str ; with the starting line number to get the absolute line number. mul #maxcol+1 ; Multiply the line number by the screen's max column count, plus 1. - clc ; Clear the carry flag. - adc scr_col ; Add the cursor's column number to get the screen index. + add scr_col ; Add the cursor's column number to get the screen index. + sta.w scr_ptr ; Save the screen index. ; cmp.w #$2000 ; Is the index greater than, or equal to the end of the screen buffer? ; bcc @end ; No, so we're done. ;@wrap: @@ -1021,22 +952,21 @@ update_ptr: update_pos: + phb.q ; Preserve B. + and #0 ; Reset A. + tab ; Reset B. ldb #1 ; Set the F pseudo register to one, to fix some bugs. stb regf ; jsr update_ptr ; Update the screen buffer index. tay ; Place the index into the Y register. tba ; Reset A. - lda #$1B ; Print an escape character - sta scr ; to the screen. - lda #'[' ; Print '[' - sta scr ; to the screen, and start the escape sequence. + mov scr, #$1B ; Print an escape character to the screen. + mov scr, #'[' ; Print '[' to the screen, and start the escape sequence. jsr getrow ; Start printing the row number to the screen. - lda #';' ; Print ';' - sta scr ; to the screen. + mov scr, #';' ; Print ';' to the screen. jsr getcol ; Start printing the column number to the screen. - lda #'H' ; Print 'H' - sta scr ; to the screen. - ;inc step ; + mov scr, #'H' ; Print 'H' to the screen. + plb.q ; Restore B. rts ; End of update_pos. getrow: @@ -1068,6 +998,7 @@ scrl_down: lda wrapped ; Was the wrapped flag set? beq @save ; Yes, so save the cursor position. @redraw: + lea d, (buffer) ; Get the screen buffer. jsr rdrw_row ; No, so redraw this row. lda wrapped ; Was the wrapped flag set? beq @load ; Yes, so load the previous cursor position back. @@ -1103,6 +1034,7 @@ scrl_up: pha ; lda #0 ; sta scr_row ; + lea d, (buffer) ; Get the screen buffer. jsr rdrw_row ; pla ; sta scr_col ; @@ -1112,64 +1044,54 @@ scrl_up: @end: rts ; + rdrw_row: - lda #0 ; - sta scr_col ; - jsr update_pos ; + pha.q ; Preserve A. + phb.q ; Preserve B. + stz scr_col ; Reset the column position. + jsr update_pos ; Update the cursor position. + xor b, b ; Reset B. + tya ; Get the screen index. + tab ; + add b, #maxcol+1; Get the end of the row plus one. @loop: - lda (ptr3), y ; - beq @incr ; - sta scr ; -@incr: - inc scr_col ; - lda (ptr3), y ; - beq @skip ; -@incr1: - iny ; -@incr2: - lda scr_col ; - cmp #maxcol+1 ; - bcs @end ; - bra @loop ; -@skip: - lda #' ' ; - sta scr ; to the screen. - bra @incr1 ; + cmp (d+a), #0 ; Is this a null terminator? + mne scr, (d+a) ; No, so print the character. + meq scr, #' ' ; Yes, so print a space. + inc ; Increment the screen index. + cmp b ; Is the column position at, or above the maximum column count? + bcc @loop ; No, so keep looping. @end: - lda #0 ; - sta scr_col ; - jsr update_pos ; -@end1: - rts ; + stz scr_col ; Reset the column position. + jsr update_pos ; Update the cursor position. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of rdrw_row. + rdrw_ln: - lda scr_row ; - pha ; - lda regf ; - sta scr_row ; - lda scr_col ; - pha ; - jsr update_pos ; + pha.q ; Preserve A. + psh scr_row ; Preserve the row position. + psh scr_col ; Preserve the column position. + mov scr_row, s ; Set the row position to the starting position. + jsr update_pos ; Update the cursor position. + mov a, d ; Get the ending position. + lea d, (buffer) ; Get the address of the screen buffer. @loop: - lda scr_row ; - cmp rege ; - beq @loop1 ; - bcs @end ; -@loop1: - jsr rdrw_row ; + cmp scr_row, a ; Is the row position at, or below the ending position? + beq @redraw ; Yes, so redraw the row. + bcs @end ; No, so we're done. +@redraw: + jsr rdrw_row ; Redraw the line. @incr: - inc scr_row ; - bra @loop ; + inc scr_row ; Increment the row position. + bra @loop ; Keep looping @end: - pla ; - sta scr_col ; - pla ; - sta scr_row ; - jsr update_pos ; - lda #0 ; - sta rege ; - sta regf ; - rts ; + pul scr_col ; Restore the column position. + pul scr_row ; Restore the row position. + jsr update_pos ; Update the cursor position. + pla.q ; Restore A. + rts ; End of rdrw_ln. set_ptr: diff --git a/programs/sub-suite/test-size.s b/programs/sub-suite/test-size.s new file mode 100644 index 0000000..b543a36 --- /dev/null +++ b/programs/sub-suite/test-size.s @@ -0,0 +1,59 @@ +MAGIC = $AA + + +.org 0 +findramend: + and #0 ; Reset A. +; lda #MAGIC ; Set A to a magic number. +@loop: + mov a, (d) ; Preserve the value. + mov (d), #MAGIC ; Write the magic number to the current end of RAM. + cmp (d), #MAGIC ; Is the value in RAM, the same as the magic number we wrote? + bne @moveback ; No, so move back until we find the last writable memory location. + mov (d), a ; Yes, so restore the previous value. + add.w d, #$4000 ; Increment the end of RAM pointer by 16K. + bra @loop ; Keep looping. +@moveback: + dec d ; Decrement the end of RAM pointer. + mov a, (d) ; Preserve the value. + mov (d), #MAGIC ; Write the magic number to the current end of RAM. + cmp (d), #MAGIC ; Is the value in RAM, the same as the magic number we wrote? + bne @moveback ; No, so keep looping. + mov (d), a ; Yes, so restore the previous value. +@end: + mov a, d ; Return the end of RAM pointer. +; ple.q ; Restore E. + rts ; End of findramend. + + +;findramend: +; phe.q ; Preserve E. +; phb.q ; Preserve B. +; mov e, d ; Set E to the RAM pointer. +; and #0 ; Reset A. +; lda #MAGIC ; Set A to a magic number. +;@loop: +; ldb (e) ; Preserve the value. +; sta (e) ; Write the magic number to the current end of RAM. +; cmp (e) ; Is the value in RAM, the same as the magic number we wrote? +; bne @moveback ; No, so move back until we find the last writable memory location. +; stb (e) ; Yes, so restore the previous value. +; ade.w #$4000 ; Increment the end of RAM pointer by 16K. +; bra @loop ; Keep looping. +;@moveback: +; dee ; Decrement the end of RAM pointer. +; ldb (e) ; Preserve the value. +; sta (e) ; Write the magic number to the current end of RAM. +; cmp (e) ; Is the value in RAM, the same as the magic number we wrote? +; bne @moveback ; No, so keep looping. +; stb (e) ; Yes, so restore the previous value. +;@end: +; mov a, e ; Return the end of RAM pointer. +; ple.q ; Restore E. +; plb.q ; Restore B. +; rts ; End of findramend. + +a +.org findramend +v +q diff --git a/programs/sub-suite/utils.s b/programs/sub-suite/utils.s index 3813a05..6479099 100644 --- a/programs/sub-suite/utils.s +++ b/programs/sub-suite/utils.s @@ -1,141 +1,125 @@ ; Utility subroutines for SuBAsm. print_hi: - and #0 ; Reset A. - sta idx3 ; Clear the string index. - tax ; Reset X. - lda #'$' ; Print the hex delimiter. - sta strbuf, x ; Save it in the string buffer. - lda.q idx0 ; Get the masked address. - ldx #$10 ; Set digit count to 16. - jsr print_hex ; Print the address. - lda.q hex_str ; Get the lower half of the string. - sta.q strbuf+1 ; Save it in the string buffer. - lda.q hex_str+8 ; Get the upper half of the string. - sta.q strbuf+9 ; Save it in the string buffer. - ldx #$11 ; Add 16 to the index. - stx idx3 ; - lda.w #': ' ; Print a space. - sta.w strbuf, x ; Save it in the string buffer. - inc idx3 ; Increment the string index twice. - inc idx3 ; - and #0 ; Reset A. - rts ; End of print_hi. + phb.q ; Preserve B. + sbs #$10 ; Make room for the hex string buffer. + and #0 ; Reset A. + mov b, d ; Get the string buffer pointer. + mov (b), #'$' ; Print the hex delimiter to the string buffer. + inb ; Increment the string buffer pointer. + lea d, (sp+1) ; Get the address of the hex string buffer. + mov f, #$10 ; Set digit count to 16. + jsr print_hex ; Print the address. + mov.q (b), (a) ; Print the lower half of the hex string to the string buffer. + mov.q (b+8), (a+8) ; Print the upper half of the hex string to the string buffer. + add b, #$10 ; Add 16 to the index. + mov.w (b), #': ' ; Print a colon, and space to the string buffer. + add b, #2 ; Add two to the string buffer pointer. + tba a ; Return the string buffer pointer after the printed string. + ads #$10 ; Cleanup the stack frame. + plb.q ; Restore B. + rts ; End of print_hi. print_lo: - and #0 ; Reset A. - sta idx3 ; Clear the string index. + pha.q ; Preserve A. + phb.q ; Preserve B. + phx.q ; Preserve X. + sbs #$33 ; Make room for the hex string buffer, and the normal string buffer. + and #0 ; Reset A. + tab ; Reset B. + lea d, (sp+1) ; Get the address of the hex string buffer. + lea x, (sp+3) ; Get the address of the string buffer. @loop: - ldx #2 ; Set digit count to 2. - pha ; Preserve the nibble offset. - jsr print_hex ; Print the low nibble offset. - lda.w (ptr3) ; Get the two digits. - ldx idx3 ; Get the string index. - sta.w strbuf, x ; Save it in the string buffer. - inc idx3 ; Increment the string index twice. - inc idx3 ; - ldx idx3 ; Get the string index. - pla ; Get the nibble offset back. - inc ; Increment the offset. - cmp #$10 ; Are we at the last offset? - bcs @end ; Yes, so we're done. + lea f, 2 ; Set the digit count to two. + mov s, b ; Get the low nibble offset. + jsr print_hex ; Print the low nibble offset. + mov.w (x), (a) ; Place the hex digits in the string buffer. + add x, #2 ; Add two to the string buffer pointer. + inb ; Increment the nibble offset. + cpb #$10 ; Are we at the last offset? + bcs @end ; Yes, so we're done. @loop1: - pha ; No, so preserve the nibble offset. - lda #' ' ; Add a space to the string buffer. - sta strbuf, x ; Save it in the string buffer. - inc idx3 ; Increment the string index. - pla ; Get the nibble offset back. - bra @loop ; Keep looping. + mov (x), #' ' ; No, so add a space to the string buffer. + inx ; Increment the string buffer pointer. + bra @loop ; Keep looping. @end: - and #0 ; Reset A. - sta strbuf, x ; Null terminate the string buffer. - tax ; Reset X. - lea strbuf ; Print the string buffer. -; jsr print_str ; - jsr print_sfast ; Use the faster, but less robust print string routine. - rts ; End of print_lo. -;@end: -; lda #0 ; Null terminate the string buffer. -; sta strbuf, x ; -; tax ; Reset X. -; lea strbuf ; Print the string buffer. -; jsr print_str ; -; rts ; End of print_lo. + mov (x), #0 ; Null terminate the string buffer. + lea d, (sp+3) ; Get the address of the string buffer. + lea s, (buffer)+y ; Get the address of the screen buffer, at the current cursor position. +; jsr print_str ; Print the string buffer. + jsr print_sfast ; Use the faster, but less robust print string routine. + ads #$33 ; Cleanup the stack frame. + plx.q ; Restore X. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of print_lo. print_chunk: - ldx #0 ; Reset X. - phy.w ; Preserve the screen buffer index. - txy ; Copy the byte index to it. + pha.q ; Preserve A. + phb.q ; Preserve B. + phx.q ; Preserve X. + phy.q ; Preserve Y. + sbs #2 ; Make room for the hex string buffer. + and #0 ; Reset A. + tab ; Reset B. + mov x, d ; Get the address of the string buffer. + mov y, s ; Get the starting address. + lea d, (sp+1) ; Get the address of the hex string buffer. + xor s, s ; Reset S. @loop: - and #0 ; Reset A. - ldx #2 ; Set the digit count to 2. - lda (idx0), y ; Get the byte at that address. - jsr print_hex ; Print the byte. - lda.w (ptr3) ; Get the two digits. - ldx idx3 ; Get the string index. - sta.w strbuf, x ; Save it in the string buffer. - inc idx3 ; Increment the string index twice. - inc idx3 ; - ldx idx3 ; Get the string index. - iny ; Increment the byte index. - cpy #$10 ; Have we read 16 bytes? - beq @end ; Yes, so we're done. - lda #' ' ; No, so add a soace to the string buffer. - sta strbuf, x ; Save it in the string buffer. - inc idx3 ; Increment the string index. - bra @loop ; Keep looping. + lea f, 2 ; Set the digit count to two. + mov s, (y+b) ; Get the byte at that address. + jsr print_hex ; Print the byte. + mov.w (x), (a) ; Print the hex string to the string buffer. + add x, #2 ; Add two to the string buffer pointer. + inb ; Increment the byte index. + cpb #$10 ; Have we read 16 bytes? + beq @end ; Yes, so we're done. + mov (x), #' ' ; No, so print a space to the string buffer. + inx ; Increment the string buffer pointer. + bra @loop ; Keep looping. @end: - ply.w ; Get the screen buffer index back. - inx ; Increment the index by one. - and #0 ; Null terminate the string. - sta strbuf, x ; - tax ; Reset X. - sta idx3 ; Clear the string index. - rts ; End of print_chunk. + mov (x), #0 ; Null terminate the string. + ads #2 ; Cleanup the stack frame. + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. + pla.q ; Restore A. + rts ; End of print_chunk. print_hex: - pha.q ; Preserve the hex value. - and #0 ; Reset A. - ldb #1 ; Set the second pointer - lda.w #hex_char ; to the start of hex character table. - jsr set_ptr ; - inb ; Set the third pointer - lda.d #hex_str ; to the end of hex string buffer. - clc ; Do a non carrying add. - adc #$10 ; - jsr set_ptr ; - ldb #0 ; Reset B. - pla.q ; Get the hex value back. + phb.q ; Preserve B. + phx.q ; Preserve X. + phy.q ; Preserve Y. + lea b, hex_char ; Get the address of the hex character table. + and f, f ; Is the digit count zero? + set x, eq ; Set the auto digit count flag if so. + mne f, #$10 ; Also set the digit count to 16 if the digit count is zero. + mov a, f ; Get the digit count. + add a, d ; Add the string pointer with the digit count. @loop: - pha.q ; Preserve the hex value. - and #$F ; Mask the lowest nibble. - phy.w ; Preserve the screen buffer position. - tay ; Get the index for the hex digit. - lda (ptr2), y ; Get the hex digit. - dec ptr3 ; Decrement the string pointer. - sta (ptr3) ; Save the hex digit character in the string. - ply.w ; Get back the screen buffer position. - pla.q ; Get the hex value back. + mov y, s ; No, so mask the low nibble of the value. + and y, #$F ; + dec ; Decrement the string pointer. + mov (a), (b+y) ; Place the hex digit character in the string. + lsr s, #4 ; Is the next nibble zero? + bne @loop1 ; No, so decrement the digit count. @isauto: - cpx #1 ; Is the digit count less than one? - bcc @auto ; Yes, so don't decrement the digit count. - dex ; No, but was the digit count zero, when decremented? - beq @end ; Yes, so we're done. - bra @next ; No, so get the next nibble. -@auto: - ldb #1 ; Enable auto digit count. -@next: - lsr #4 ; Is the next nibble, a zero? - beq @isauto1 ; Yes, so check if auto digit count is enabled. - bra @loop ; No, so print the next digit. -@isauto1: - cpb #1 ; Is auto digit count enabled? - beq @end ; Yes, so we're done. - bra @loop ; No, so keep printing more digits. + and x, x ; Is the auto digit count flag set? + bne @end ; Yes, so we're done. +@loop1: + cpx #1 ; Is the auto digit count flag set? + sbc f, #0 ; Decrement the digit count if not. + mov y, f ; Get the digit count. + or y, x ; Are both the digit count, and the auto digit count flag zero? + bne @loop ; No, so keep looping. @end: + ply.q ; Restore Y. + plx.q ; Restore X. + plb.q ; Restore B. rts ; End of print_hex. @@ -147,26 +131,18 @@ charcpy: strcmpg: - ldb.w #strcmp ; Get the address of strcmp. - phb.q ; Use it for an indirect call. - ldb.q ptr ; Get the first pointer. + lea strcmp ; Get the address of strcmp. + mov.q d, ptr ; Get the first pointer. bra gargs ; Jump to the argument handler. strcaseg: - ldb.w #strccmp ; Get the address of strcasecmp. - phb.q ; Use it for an indirect call. - ldb.q ptr ; Get the first pointer. + lea strcasecmp ; Get the address of strcasecmp. + mov.q d, ptr ; Get the first pointer. bra gargs ; Jump to the argument handler. gargs: - phb.q ; Use the pointer in B as the first arg. - pha.q ; Use the value in A as the second arg. - and #0 ; reset a. - tab ; reset b. - jsr (sp+17) ; call the pushed routine. - tab ; Preserve the return value. - pla.q ; Get the second arg back. - pla.q ; Get the first arg back. - pla.q ; Get the pushed routine back. - tba ; Get the return value back. + mov s, a ; Use the value in A as the second arg. + and #0 ; Reset a. + tab ; Reset b. + jsr (e) ; Call the pushed routine. rts ; End of gargs. @@ -310,11 +286,6 @@ get_ptok: get_ctrlidx: -; phe.q ; Preserve E. -; cmp #$7F ; Is this a delete character? -; beq @del ; Yes, so return the same value as backspace. -; sec ; Do a non borrowing subtract. -; sbc #8 ; Subtract 8 from the character, to get the index. sub #8 ; Subtract 8 from the character, to get the index. tax ; Copy the index to X. and #0 ; Reset A. @@ -324,62 +295,41 @@ get_ctrlidx: leq (e) ; cmp #$7F ; Is this a delete character? leq #2 ; Return 2 if this is the delete character. -; bcc @get_rtval ; Yes, so get the return value from the table. -; beq @get_rtval ; -; ple.q ; Restore E. rts ; End of get_ctrlidx. -;@get_rtval: -; lda ct_rtb, x ; Get the return value from the table. -; rts ; End of get_ctrlidx. -;@del: -; lda #2 ; Return 2. -; rts ; End of get_ctrlidx. findramend: - phx.q ; Preserve X. and #0 ; Reset A. - lda #MAGIC ; Set A to a magic number. @loop: - ldx (e) ; Preserve the value. - sta (e) ; Write the magic number to the current end of RAM. - cmp (e) ; Is the value in RAM, the same as the magic number we wrote? + mov a, (d) ; Preserve the value. + mov (d), #MAGIC ; Write the magic number to the current end of RAM. + cmp (d), #MAGIC ; Is the value in RAM, the same as the magic number we wrote? bne @moveback ; No, so move back until we find the last writable memory location. - stx (e) ; Yes, so restore the previous value. - ade.w #$4000 ; Increment the end of RAM pointer by 16K. + mov (d), a ; Yes, so restore the previous value. + add.w d, #$4000 ; Increment the end of RAM pointer by 16K. bra @loop ; Keep looping. @moveback: - dee ; Decrement the end of RAM pointer. - ldx (e) ; Preserve the value. - sta (e) ; Write the magic number to the current end of RAM. - cmp (e) ; Is the value in RAM, the same as the magic number we wrote? + dec d ; Decrement the end of RAM pointer. + mov a, (d) ; Preserve the value. + mov (d), #MAGIC ; Write the magic number to the current end of RAM. + cmp (d), #MAGIC ; Is the value in RAM, the same as the magic number we wrote? bne @moveback ; No, so keep looping. - stx (e) ; Yes, so restore the previous value. + mov (d), a ; Yes, so restore the previous value. @end: - phe.q ; Return the end of RAM pointer. - pla.q ; - plx.q ; Restore X. + mov a, d ; Return the end of RAM pointer. rts ; End of findramend. print_sfast: -; inc step ; - pea (buffer), y ; Push the address of the cursor's postion in the screen buffer to the stack. + pha.q ; Preserve A. + and #0 ; Reset A. @loop: - lda (e) ; Get the character. - beq @end ; We've hit the end of the string, so we're done. - cmp #'\n' ; Did we get a newline? - beq @nl ; Yes, so move the cursor to the next line. - sta (sp+1) ; Print the character to the screen buffer. - sta scr ; Print the character to the screen. - inc scr_col ; Move the cursor left by one character. - ine ; Increment the string pointer. - inc.q sp+1 ; Increment the screen buffer pointer. - bra @loop ; Keep looping. -@nl: - stz scr_col ; Move the cursor to the start of the line. - inc scr_row ; Move the cursor down by one line. - bra @loop ; Keep looping. + inc ; Increment the index. + cmp (d+a-1), #0 ; Did we hit the end of the string? + beq @end ; Yes, so we're done. + mov (s+a-1), (d+a-1) ; No, so print the character to the buffer. + mov scr, (d+a-1) ; Print the character to the screen. + bra @loop ; Keep looping. @end: - ads #8 ; Cleanup the stack frame. - rts ; End of print_sfast. + pla.q ; Restore A. + rts ; End of print_sfast. |