Finished SuBAsm's screen editor.

Which I am now calling, SuBEditor.

2 files changed, 535 insertions, 84 deletions

diff --git a/test/fib-new.s b/test/fib-new.s
new file mode 100644
index 0000000..43538a0
--- /dev/null
+++ b/test/fib-new.s
@@ -0,0 +1,73 @@
+; Name: fib.s
+; Description: Computes the Fibbonacci sequence.
+;
+; Written in Sux Assembly
+; by mr b0nk 500 <b0nk@b0nk.xyz>
+
+; Variables for thread 0.
+.org $0
+x:
+	.qword $0
+y:
+	.qword $0
+z:
+	.qword $0
+
+; Variables for thread 1.
+x2:
+	.qword $0
+y2:
+	.qword $0
+z2:
+	.qword $0
+
+.org $1000
+init:
+	cps		; Clear the Processor Status register.
+
+start:
+	lda #$0		; Clear the accumulator.
+	ldy #$1		; y=1.
+	sty.q y		; Store y into memory.
+
+fib:
+	ldx #$0		; x=0.
+	ldx.q x		; Output the value of x.
+	adc.q y		; Add x with y.
+	sta.q z		; z=x+y
+	ldy.q y
+	sty.q x		; x=y.
+	sta.q y		; y=z.
+	lda.q x
+	bcs start	; Start all over again, if the carry flag was set.
+	jmp fib		; Otherwise, keep looping.
+
+.org $2000
+init2:
+	cps		; Clear the Processor Status register.
+
+start2:
+	lda #$0		; Clear the accumulator.
+	ldy #$1		; y2=1.
+	sty.q y2	; Store y into memory.
+
+fib2:
+	ldx #$0		; x2=0.
+	ldx.q x2	; Output the value of x2.
+	adc.q y2	; Add x2 with y2.
+	sta.q z2	; z2=x2+y2
+	ldy.q y2
+	sty.q x2	; x2=y2.
+	sta.q y2	; y2=z2.
+	lda.q x2
+	bcs start2	; Start all over again, if the carry flag was set.
+	jmp fib2	; Otherwise, keep looping.
+
+.org $FFC0
+.qword init
+; Set up the thread vectors.
+.org $FF50
+.qword init2
+; Execute the program.
+done
+
diff --git a/test/input-3.s b/test/input-3.s
index a05cb9d..35547a7 100644
--- a/test/input-3.s
+++ b/test/input-3.s
@@ -18,14 +18,6 @@ buffer:
 .org $4000
 cmd_buf:
 
-.org $200
-bitmask:
-	.byte $0
-bitabl:
-	.qword $0
-	.word $0
-bits:
-	.byte $0
 
 ; Initalize some variables.
 .org $0
@@ -33,12 +25,12 @@ scr_row:
 	.byte $0
 scr_col:
 	.byte $0
-scr_lnst:
-	.word $0
-scr_lncnt:
-	.word $0
-scr_rowst:
+scr_trow:
 	.byte $0
+scr_tcol:
+	.byte $0
+scr_ptr:
+	.word $0
 a:
 	.byte $0
 b:
@@ -49,12 +41,34 @@ d:
 	.byte $0
 e:
 	.byte $0
+f:
+	.byte $0
 string:
 	.byte "Please, type something.\n"
 string2:
 	.byte "You typed, "
 end:
 	.byte $0
+bits:
+	.byte $80
+	.byte $40
+	.byte $20
+	.byte $10
+	.byte $08
+	.byte $04
+	.byte $02
+	.byte $01
+bitmask:
+	.byte $0
+bitabl:
+	.qword $0
+	.qword $0
+scr_str:
+.byte $0
+scr_end:
+.byte $0
+wrapped:
+.byte $0
 
 ; Pointers
 ptr:
@@ -65,10 +79,6 @@ tptr:
 	.qword tok
 mptr:
 	.qword msg
-bmptr:
-	.qword bitmask
-btptr:
-	.qword bitabl
 
 ; Main program
 .org $8000
@@ -77,7 +87,14 @@ reset:
 	ldx.w #$FFFF
 	txs
 	ldy #0
+	lda #23
+	sta scr_end
 	lda #0
+	sta scr_str
+	ldx #8
+	sta.q bitabl
+	sta.q bitabl, x
+	tax
 	jsl clr_buf
 	jmp start
 clr_buf:
@@ -99,8 +116,6 @@ start:
 	ldy.w #0
 	jsl clr_cbuf
 	ply #2
-	lda #1
-	sta $C000
 	jmp print
 
 clr_cbuf:
@@ -124,9 +139,6 @@ read:
 	jsl getchar	; We got a key.
 	beq parse	; We got a newline, so start parsing the line.
 	jmp rset_a	; We didn't get a newline, so keep getting more characters.
-sleep:
-	lda end
-	bne spin	; Are we done with getting input?
 
 print:
 	phy #2
@@ -139,17 +151,45 @@ print:
 	jmp print
 
 getbit:
-	phy #2
+	clc
+	lda scr_str
+	bne getbt0
 	ldx scr_row
+	jmp getbt1
+getbt0:
+	lda scr_row
+	adc scr_str
+	tax
 getbt1:
 	jsl bitpos
-	txy
-	ldb (btptr), y
-	ply #2
+	ldb bitabl, x
 	aba
 	cmp #1
 	jmp bitout
 
+;putbit:
+;	ldx scr_row
+;putbt1:
+;	bcc setbit
+
+
+clrbit:
+	jsl bitpos
+	xor #$FF
+	ldb bitabl, x
+	aba
+bitsav:
+	sta bitabl, x
+bitout:
+	ldx bitmask
+	rtl
+
+setbit:
+	jsl bitpos
+	ldb bitabl, x
+	oab
+	jmp bitsav
+
 bitpos:
 	stx bitmask
 	txa
@@ -163,12 +203,11 @@ bitpos:
 	pla #1
 	rtl
 
-bitout:
-	ldx bitmask
-	rtl
 
 getchar:
 	lda $C002	; Get typed character.
+	ldb #0
+	stb e
 	pha #1
 	phy #2
 	cmp #10
@@ -176,13 +215,27 @@ getchar:
 getchar_pnt:
 	ply #2
 	pla #1
+	ldb e
+	bne reset_row
+getchar_pnt1:
 	jsl print_char
 	lda a
 	cmp #10
 	beq getchar_line
 	jmp getchar_char
+reset_row:
+	ldb e
+	stb scr_row
+	jmp getchar_pnt1
+
+
 cmd_cpy:
+	ldb scr_row
+	stb e
+	jsl findst
+	clc
 	lda scr_row
+	adc scr_str
 	mul #80
 	tay
 	ldx.w #$0
@@ -197,14 +250,22 @@ cmd_cpy_strt:
 	iny
 	jmp cmd_cpy_strt
 getchar_line:
-	lda #$0
-	sta scr_lncnt
+	lda #0
 	jmp getchar_end
 getchar_char:
-	lda #$1
+	lda #1
 getchar_end:
 	rtl
 
+findst:
+	jsl getbit
+	bcc findst_done
+	dec scr_row
+	bpo findst
+	inc scr_row
+findst_done:
+	rtl
+
 parse:
 	lda #0
 	tax
@@ -222,31 +283,62 @@ print_char:
 	beq nl		; Did the user type a newline?
 	cmp #$C
 	beq clr_scr
+	cmp #19
+	beq en_step
+	cmp #18
+	beq dis_step
 	cmp #8
 	beq bs		; Did the user type a backspace?
 	cmp #$7F
 	beq bs		; Did the user type a backspace?
 	sta a
-	ldb scr_col
-	cpb #79
-	beq linewrap
-	jmp printc
-linewrap:
-	ldb #0
-	stb scr_col
-	lda #$42
-	sta c
-	jsl isdown
-	ldb scr_row
-	cpb #23
-	beq printc_end
 printc:
 	lda a
-	inc scr_col	; Increment the cursor's x coordinate.
-	inc scr_lncnt
 	sta (ptr), y	; Store typed character into the input buffer.
+	inc scr_col	; Increment the cursor's x coordinate.
 	iny
+printc_2:
+	ldb #1
+	stb f
+	ldb scr_col
+	cpb #80
+	bcs printc_4
+printc_3:
+	sta $C001	; Echo typed character.
+	ldb f
+	beq printc_wrap
+	jmp printc_end
+printc_4:
+	ldb scr_row
+	cpb #23
+	bcs printc_scrl
+printc_5:
+	ldb #0
+	stb f
+	jmp printc_3
+printc_scrl:
 	sta $C001	; Echo typed character.
+	clc
+	lda #1
+	sta wrapped
+	jsl scrl_down
+printc_wrap:
+	ldb #0
+	stb scr_col
+	ldb scr_row
+	cpb #23
+	bcs printc_wrap2
+printc_wrap1:
+	inc scr_row
+printc_wrap2:
+	phx #2
+	clc
+	lda scr_row
+	adc scr_str
+	tax
+	jsl setbit
+	plx #2
+	jsl update_pos
 printc_end:
 	rtl
 
@@ -257,22 +349,25 @@ nl:
 	lda scr_row
 	cmp #23
 	bne nl_inc
-	lda #1
+	jsl scrl_down
+	lda #10
 	sta a
 	jmp printc_end
 nl_inc:
-	lda #$42
-	sta c
-	jsl isdown
-	sty.w scr_lnst
+	inc scr_row
+	jsl update_pos
 	lda #10
 	sta a
 	jmp printc_end
 
 clr_scr:
+	lda #23
+	sta scr_end
 	lda #0
-	sta.w scr_lnst
-	sta scr_rowst
+	sta scr_str
+	ldx #8
+	sta.q bitabl
+	sta.q bitabl, x
 	tay
 	jsl clr_buf
 	sta scr_col
@@ -282,25 +377,73 @@ clr_scr:
 	sta $C001
 	jmp printc_end
 
+en_step:
+	lda $C010
+	beq step_en
+	jmp stp_end
+step_en:
+	lda #1
+	sta $C010
+	jmp stp_end
+
+dis_step:
+	lda $C010
+	bne step_dis
+	jmp stp_end
+step_dis:
+	lda #0
+	sta $C010
+stp_end:
+	jmp printc_end
+
 back:
 	lda #$7F
 	sta $C001
 	dey		; Decrement buffer offset.
 	lda #0		; Put a null terminator, in place of the backspace.
 	sta (ptr), y	; Place it into the input buffer.
-	lda #$44
 	dec scr_col
-	dec scr_lncnt
 	jsl update_pos
 	jmp printc_end	; Get next character.
 
 bs:
 	lda scr_col	; Are we at the start of the buffer?
-	beq printc_end
+	beq back_wrap
 	jmp back	; We are not, so add the backspace to the buffer.
+back_wrap:
+	jsl getbit
+	bcs back_wrap1
+	jmp printc_end
+back_wrap1:
+	lda scr_row
+	beq back_wrap2
+	jmp backwrp
+back_wrap2:
+	lda scr_str
+	bne back_scrl
+	jmp printc_end
+back_scrl:
+	clc
+	jsl scrl_up
+	inc scr_row
+backwrp:
+	clc
+	lda scr_row
+	adc scr_str
+	tax
+backwrp2:
+	dec scr_row
+	jsl clrbit
+	ldb #80
+	stb scr_col
+	jsl update_pos
+	jmp back
 
 esc:
 	lda $C000	; Skip the '['.
+	lda $C002
+	cmp #$1B
+	beq shftesc
 	lda $C000	; Get the next character.
 	beq printc_end	; We have an error, so discard it, and go back to getting user input.
 	lda $C002	; Get the escape code.
@@ -308,13 +451,9 @@ esc:
 	lda #0
 	sta d
 	jsl isup	; Check if the user pressed up.
-	lda e
-	bne esc_lnst
 	lda d
 	bne esc_end
 	jsl isdown	; Check if the user pressed down.
-	lda e
-	bne esc_lnst
 	lda d
 	bne esc_end
 	lda #0
@@ -322,61 +461,147 @@ esc:
 	lda d
 	bne esc_end
 	jsl isright	; Check if the user pressed right.
-	jmp esc_end
-esc_lnst:
-	lda scr_row
-	sta scr_rowst
-	mul #80
-	sta.w scr_lnst
 esc_end:
 	lda #0
 	sta d
 	jmp printc_end	; Go back to getting user input.
 
+shftesc:
+	lda $C000	; Skip the '['.
+	lda $C000	; Get the next character.
+	beq printc_end	; We have an error, so discard it, and go back to getting user input.
+	lda $C002	; Get the escape code.
+	sta c		; Store the escape code, until we need it.
+	lda #0
+	sta d
+	jsl isshftup	; Check if the user pressed shift+up.
+	lda d
+	bne shftesc_end
+	jsl isshftdown	; Check if the user pressed shift+down.
+shftesc_end:
+	lda #0
+	sta d
+	jmp printc_end	; Go back to getting user input.
+
 isup:
+	lda c		; No, so load the escape code back into the accumulator.
+	cmp #$41	; Did the user press the up arrow key?
+	bne isup_done	; Yes, so return.
+	lda #1
+	sta d
 	lda scr_row	; Is the cursor at the top of the screen?
-	beq isup_done	; Yes, so return.
+	beq isup_scrl	; Yes, so return.
+isup_2:
 	lda c		; No, so load the escape code back into the accumulator.
 	cmp #$41	; Did the user press the up arrow key?
 	beq up		; Yes, so move the cursor up.
+	jmp isup_done
+isup_scrl:
+	lda scr_str
+	beq isup_done
+	jsl scrl_up
 isup_done:
 	rtl		; End of isup.
 
 isdown:
+	lda c		; No, so load the escape code back into the accumulator.
+	cmp #$42	; Did the user press the down arrow key?
+	bne isdown_done
 	lda scr_row	; Start checking the y coordinate of the cursor.
 	cmp #23		; Is the cursor at the bottom of the screen?
-	beq isdown_done	; Yes, so return.
+	beq isdown_scrl	; Yes, so return.
 	lda c		; No, so load the escape code back into the accumulator.
 	cmp #$42	; Did the user press the down arrow key?
 	beq down	; Yes, so move the cursor down.
 	jmp isdown_done
 isdown_scrl:
-	lda #$1B	; Print an escape character
-	sta $C001	; to the screen.
-	lda #$5B	; Print '['
-	sta $C001	; to the screen, and start the escape sequence.
-	lda #$54	; Print 'T'
-	sta $C001	; to the screen, and end the escape sequence.
+	lda scr_row
+	sta scr_trow
+	lda scr_col
+	sta scr_tcol
+	jsl scrl_down
+	lda scr_trow
+	sta scr_row
+	lda scr_tcol
+	sta scr_col
 isdown_done:
 	rtl		; End of isdown.
 
 isright:
-	lda scr_col	; Start checking the x coordinate of the cursor.
-	cmp #79		; Is the cursor at the far right of the screen?
-	beq isright_end	; Yes, so return.
 	lda c		; No, so load the escape code back into the accumulator.
 	cmp #$43	; Did the user press the right arrow key?
-	beq right	; Yes, so move the cursor right.
+	bne isright_done
+	lda scr_col	; Start checking the x coordinate of the cursor.
+	cmp #79		; Is the cursor at the far right of the screen?
+	beq isright_wrp	; Yes, so check if this is a wrapped line.
+	jmp right	; No, so move the cursor right, like normal.
+isright_wrp:
+	inc scr_row
+	jsl getbit
+	bcs wrap_inc
+	dec scr_row
+	jmp isright_done
+isright_scrl:
+	lda scr_str
+	beq isright_end
+	lda #1
+	sta wrapped
+	jsl scrl_down
+	dec scr_row
+	jmp isright_end
+wrap_inc:
+	lda #0
+	sta scr_col
+	lda scr_row
+	cmp #23
+	bcs isright_scrl
 isright_end:
+	jsl update_pos
+isright_done:
+	lda #0
+	sta wrapped
 	rtl		; End of isright.
 
 isleft:
+	lda c
+	cmp #$43
+	beq isleft_done
 	lda scr_col	; Is the cursor at the far left of the screen?
-	beq isleft_done	; Yes, so return.
+	beq isleft_wrp	; Yes, so start checking if this is a wrapped line.
 	lda c		; No, so load the escape code back into the accumulator.
 	cmp #$44	; Did the user press the left arrow key?
 	beq left	; Yes, so move the cursor left.
+	jmp isleft_done
+isleft_wrp:
+	jsl getbit
+	bcs wrap_dec
+	jmp isleft_done
+wrap_dec:
+	lda scr_row
+	beq wrap_dec1
+	lda #1
+	sta wrapped
+	dec scr_row
+wrap_dec1:
+	lda #79
+	sta scr_col
+	lda #1
+	sta d
+	lda scr_row
+	beq isleft_scrl
+	jmp isleft_end
+isleft_scrl:
+	lda wrapped
+	bne isleft_end
+	lda scr_str
+	beq isleft_done
+	jsl scrl_up
+	jmp isleft_done
+isleft_end:
+	jsl update_pos
 isleft_done:
+	lda #0
+	sta wrapped
 	rtl		; End of isleft.
 
 up:
@@ -394,7 +619,7 @@ down:
 right:
 	inc scr_col
 	jsl update_pos
-	jmp isright_end
+	jmp isright_done
 left:
 	dec scr_col
 	jsl update_pos
@@ -402,9 +627,52 @@ left:
 	sta d
 	jmp isleft_done
 
+isshftup:
+	lda c		; Load the escape code back into the accumulator.
+	cmp #$41	; Did the user press the up arrow key?
+	bne isshftup_done
+	lda #1
+	sta d
+	lda scr_str
+	beq isshftup_done
+	jmp shftup
+isshftup_done:
+	rtl
+
+isshftdown:
+	lda c		; Load the escape code back into the accumulator.
+	cmp #$42	; Did the user press the down arrow key?
+	bne isshftdown_done
+	lda #1
+	sta d
+	lda scr_end
+	cmp #71
+	bcs isshftdown_done
+	jmp shftdown
+isshftdown_done:
+	rtl
+
+shftup:
+	jsl scrl_up
+	lda #1
+	sta d
+	jmp isshftup_done
+
+shftdown:
+	jsl scrl_down
+	lda #1
+	sta d
+	jmp isshftdown_done
+
 update_pos:
+	ldb #1
+	stb f
+	clc
 	lda scr_row
+	adc scr_str
+	clc
 	mul #80
+	clc
 	adc scr_col
 	tay
 	lda #$1B	; Print an escape character
@@ -432,13 +700,124 @@ getcol:
 	sta $C001	; to the screen.
 	lda scr_col	; Get the cursor's x coordinate.
 	div #10		; Divide A by 10.
+	clc
 	adc #$30	; Convert it to ascii, and
 	sta $C001	; print to the screen.
 	tba		; Get the remainder.
+	clc
 	adc #$30	; Convert it to ascii, and
 	sta $C001	; print to the screen.
 	rtl		; End of getrow.
 
+scrl_down:
+
+	inc scr_str
+	inc scr_end
+	lda #$1B	; Print an escape character
+	sta $C001	; to the screen.
+	lda #$5B	; Print '['
+	sta $C001	; to the screen, and start the escape sequence.
+	lda #$54	; Print 'T'
+	sta $C001	; to the screen, and end the escape sequence.
+	lda wrapped
+	beq scrldn_save
+scrldn1:
+	jsl rdrw_row
+	lda wrapped
+	beq scrldn_load
+	jmp scrldn_end
+scrldn_save:
+	lda scr_row
+	pha #1
+	lda scr_col
+	pha #1
+	jmp scrldn1
+scrldn_load:
+	pla #1
+	sta scr_col
+	pla #1
+	sta scr_row
+	jsl update_pos
+scrldn_end:
+	lda #0
+	sta wrapped
+scrldn_done:
+	rtl
+
+scrl_up:
+	dec scr_str
+	dec scr_end
+	lda #$1B	; Print an escape character
+	sta $C001	; to the screen.
+	lda #$5B	; Print '['
+	sta $C001	; to the screen, and start the escape sequence.
+	lda #$53	; Print 'S'
+	sta $C001	; to the screen, and end the escape sequence.
+	lda scr_row
+	pha #1
+	lda scr_col
+	pha #1
+	lda #0
+	sta scr_row
+	jsl rdrw_row
+	pla #1
+	sta scr_col
+	pla #1
+	sta scr_row
+	jsl update_pos
+scrlup_done:
+	rtl
+
+rdrw_row:
+	lda #0
+	sta scr_col
+	jsl update_pos
+rdrow_st:
+	lda (ptr), y
+	beq rdrow_inc
+	sta $C001
+rdrow_inc:
+	inc scr_col
+	lda (ptr), y
+	beq rdrow_skip
+	iny
+rdrow_inc1:
+	lda scr_col
+	cmp #80
+	bcs rdrow_end
+	jmp rdrow_st
+rdrow_skip:
+	jsl update_pos
+	jmp rdrow_inc1
+rdrow_end:
+	lda #0
+	sta scr_col
+	jsl update_pos
+rdrow_done:
+	rtl
+
+
+;rdrw_scr:
+;	lda #$C
+;	sta $C001
+;	lda scr_col
+;	sta scr_tcol
+;	lda scr_row
+;	sta scr_trow
+;	lda #0
+;	sta scr_col
+;	sta scr_row
+;	phy #2
+;	jsl update_pos
+;	ply #2
+;	ldx scr_ptr
+;	phy #2
+;	txy
+;	lda (ptr), y
+;	sta $C001
+;	ply #2
+;	rtl
+
 result:
 	phy #2
 	txy
@@ -461,9 +840,9 @@ dabbed:
 	lda (cptr), y	; Get a character from the input buffer.
 	beq dab_pend	; Are we done with printing the buffer?
 	cmp (tptr), y
-	bcs dab_pend
-	beq chk_str
 	bcc dab_pend
+	beq chk_str
+	bcs dab_pend
 chk_str:
 	ply #2
 	inx
@@ -517,6 +896,5 @@ cmd_clr:
 .qword spin
 .qword spin
 .qword spin
-.org $FF50
 done