summaryrefslogtreecommitdiff
path: root/programs
diff options
context:
space:
mode:
Diffstat (limited to 'programs')
-rw-r--r--programs/c-ports/subasm.c24
-rw-r--r--programs/c-ports/subeditor.c205
-rw-r--r--programs/c-ports/subeditor.h19
-rw-r--r--programs/subeditor.s1266
4 files changed, 869 insertions, 645 deletions
diff --git a/programs/c-ports/subasm.c b/programs/c-ports/subasm.c
index 89d1507..73bb74c 100644
--- a/programs/c-ports/subasm.c
+++ b/programs/c-ports/subasm.c
@@ -1,18 +1,7 @@
#include "subeditor.h"
-struct line {
- uint8_t dir;
- uint8_t mne;
- uint8_t am;
- uint8_t opbase;
- uint16_t com;
- uint16_t label;
- uint64_t op;
-};
-char *label[0x1000];
+
uint64_t label_addr[0x1000];
-/*char *comment[0x1000];*/
-/*char *string[0x1000];*/
enum dir {
DIR_ORG,
@@ -52,9 +41,8 @@ enum base {
};
-char lexeme[0x100];
+char lexeme[0x200];
uint8_t lex_type;
-struct line tokline[0x1000];
uint16_t linenum = 10;
static const char *mne_t[90] = {
@@ -258,7 +246,7 @@ uint8_t lex(char *str) {
uint16_t j = 0;
lex_type = 0xFF;
uint8_t k = 0;
- int line = 40;
+ int line = 56;
int16_t ln = -1;
int y, x;
char lnum[6];
@@ -333,12 +321,12 @@ uint8_t lex(char *str) {
case ';':
i++;
while (str[i] != '\0') {
- lexeme[j++] = str[i++];
+ lexeme[j] = str[i];
/*comment[linenum][j] = str[i];*/
- /*j++, i++;*/
+ j++, i++;
}
lexeme[j] = '\0';
- /*comment[linenum][j] = '\0';*/
+ comment[linenum][j] = '\0';
lex_type = TOK_COMMENT;
break;
case '#':
diff --git a/programs/c-ports/subeditor.c b/programs/c-ports/subeditor.c
index 76ee544..44ca288 100644
--- a/programs/c-ports/subeditor.c
+++ b/programs/c-ports/subeditor.c
@@ -45,6 +45,7 @@ uint8_t scr_trow = 0;
uint8_t scr_tcol = 0;
uint16_t scr_ptr = 0;
uint16_t scr_ptr2 = 0;
+uint16_t scr_ptr3 = 0;
uint8_t byte = 0;
uint8_t mask = 0;
@@ -141,6 +142,62 @@ void clr_cbuf() {
}
}
+#define dir(a) tokline[a].dir
+#define mne(a) tokline[a].mne
+#define amo(a) tokline[a].am
+#define opb(a) tokline[a].opbase
+#define com(a) tokline[a].com
+#define lab(a) tokline[a].label
+#define opc(a) tokline[a].op
+
+#define tok(a) { \
+ dir(a) = 0xFF; \
+ mne(a) = 0xFF; \
+ amo(a) = 0xFF; \
+ opb(a) = 0xFF; \
+ com(a) = 0xFFFF; \
+ lab(a) = 0xFFFF; \
+ opc(a) = 0xFF; \
+}
+void clr_tokline() {
+ uint16_t i = 0;
+ for (; i < 0x2000;) {
+ tok(i+0x00);
+ tok(i+0x01);
+ tok(i+0x02);
+ tok(i+0x03);
+ tok(i+0x04);
+ tok(i+0x05);
+ tok(i+0x06);
+ tok(i+0x07);
+ tok(i+0x08);
+ tok(i+0x09);
+ tok(i+0x0A);
+ tok(i+0x0B);
+ tok(i+0x0C);
+ tok(i+0x0D);
+ tok(i+0x0E);
+ tok(i+0x0F);
+ tok(i+0x10);
+ tok(i+0x11);
+ tok(i+0x12);
+ tok(i+0x13);
+ tok(i+0x14);
+ tok(i+0x15);
+ tok(i+0x16);
+ tok(i+0x17);
+ tok(i+0x18);
+ tok(i+0x19);
+ tok(i+0x1A);
+ tok(i+0x1B);
+ tok(i+0x1C);
+ tok(i+0x1D);
+ tok(i+0x1E);
+ tok(i+0x1F);
+ i+=0x20;
+ }
+}
+
void update_pos() {
scr_ptr = (scr_row+scr_str)*80;
scr_ptr += scr_col;
@@ -163,12 +220,26 @@ void rdrw_row() {
}
scr_col++;
if (!buffer[ptr+i]) {
- update_pos();
+ #if !debug
+ waddch(scr, ' ');
+ #endif
}
}
scr_col = 0;
}
+void rdrw_ln(uint8_t start, uint8_t end) {
+ uint8_t tmp_row = scr_row;
+ uint8_t tmp_col = scr_col;
+ scr_row = start;
+ for (; scr_row <= end; ) {
+ rdrw_row();
+ ++scr_row;
+ }
+ scr_row = tmp_row;
+ scr_col = tmp_col;
+}
+
void scrl_down() {
scr_str++;
scr_end++;
@@ -201,9 +272,6 @@ void bitpos(uint8_t row) {
bit = row & 7;
mask = bits[bit];
byte = bitmask >> 3;
- #if debug
- /*mvwprintw(scr, 2, 0, "bit: $%02X, row: $%02X, byte: $%02X, mask: $%02X, bitmask: $%02X\r", bit, row, byte, mask, bitmask);*/
- #endif
}
void clrbit (uint8_t row) {
@@ -231,28 +299,68 @@ uint8_t getbit() {
return (mask & bitabl[byte]);
}
-void findst() {
+uint8_t findst() {
+ uint8_t line_count = 0;
while (getbit()) {
+ line_count++;
scr_row--;
if ((int8_t)scr_row < 0) {
+ line_count--;
scr_row++;
+ break;
}
}
+ return line_count;
}
+void fndend() {
+ uint16_t i = scr_ptr;
+ for (; buffer[i] != '\0'; i++);
+ scr_ptr3 = i;
+}
+
+void findend() {
+ fndend();
+ c = (uint16_t)(scr_ptr3/80);
+}
+
+
void shftln(uint16_t src, uint16_t dst, uint8_t flag) {
if (!flag) {
while (buffer[src] != '\0') {
buffer[dst++] = buffer[src];
buffer[src++] = '\0';
}
+ scr_ptr2 = scr_ptr;
+ scr_ptr = src;
+ findend();
+ scr_ptr = scr_ptr2;
+ if ((scr_ptr3 % 80 == 0) && (c > scr_row)) {
+ clrbit(c);
+ }
} else {
while (scr_ptr <= src) {
- mvwprintw(scr, 2, 0, "buffer[0x%04X]: $%02X, buffer[0x%04X]: $%02X, src: $%04X, dst: $%04X, scr_ptr: $%04X\r", src, buffer[src], dst, buffer[dst], src, dst, scr_ptr);
- wrefresh(scr);
+ if ((int16_t) src < 0) {
+ src = 0;
+ buffer[src] = '\0';
+ break;
+ }
buffer[dst--] = buffer[src];
buffer[src--] = '\0';
}
+ if (buffer[src+1] == '\0') {
+ buffer[src+1] = ' ';
+ }
+ scr_ptr2 = scr_ptr;
+ scr_ptr = src;
+ findend();
+ scr_ptr = scr_ptr2;
+ if (buffer[src+1] == ' ') {
+ buffer[src+1] = '\0';
+ }
+ if (c > scr_row) {
+ setbit(c);
+ }
}
}
@@ -262,6 +370,8 @@ void print_char(char ch) {
uint8_t is_esc = 0;
uint8_t done = 0;
uint16_t i = 0;
+ uint16_t x = 0;
+ uint16_t y = 0;
a = ch;
switch (ch) {
case 0x1B:
@@ -387,6 +497,7 @@ void print_char(char ch) {
scr_str = 0;
clr_bitabl();
clr_buf();
+ clr_tokline();
clr_cbuf();
scr_row = 0;
scr_col = 0;
@@ -409,7 +520,6 @@ void print_char(char ch) {
break;
}
}
- clrbit(scr_row+scr_str);
scr_row--;
scr_col = 80;
update_pos();
@@ -417,23 +527,52 @@ void print_char(char ch) {
break;
}
}
- scr_col--;
- update_pos();
- buffer[scr_ptr] = 0;
+ e = 0;
+ scr_trow = scr_row;
+ findend();
+ scr_row = c;
+ e = findst();
+ buffer[--scr_ptr] = 0;
shftln(scr_ptr+1, scr_ptr, 0);
#if !debug
- wdelch(scr);
+ int y, x;
+ getyx(scr, y, x);
+ if (x > 0) {
+ wmove(scr, y, x-1);
+ }
+ wdelch(scr);
#endif
+ if (e) {
+ findend();
+ scr_tcol = scr_col;
+ rdrw_ln(scr_row, c);
+ scr_col = scr_tcol;
+ }
+ scr_row = scr_trow;
+ scr_col--;
+ update_pos();
break;
default:
- if (buffer[scr_ptr] != '\0') {
- for (i = scr_ptr; buffer[i] != '\0'; i++);
- scr_ptr2 = scr_ptr-1;
- shftln(i-1, i, 1);
- i = 0;
+ d = 0;
+ if (buffer[scr_ptr] != '\0' && !b) {
+ fndend();
+ scr_ptr3++;
+ shftln(scr_ptr3-2, scr_ptr3-1, 1);
+ scr_trow = scr_row;
+ scr_tcol = scr_col;
+ a = ch;
+ buffer[scr_ptr] = ch;
+ findend();
+ scr_row = c;
+ findst();
+ rdrw_ln(scr_row, c);
+ scr_row = scr_trow;
+ scr_col = scr_tcol;
+ update_pos();
+ } else {
+ a = ch;
+ buffer[scr_ptr] = ch;
}
- a = ch;
- buffer[scr_ptr] = ch;
scr_col++;
#if !debug
waddch(scr, ch);
@@ -457,19 +596,26 @@ void print_char(char ch) {
uint8_t getkey(char ch) {
e = 0;
+ b = 0;
if (ch == '\n') {
uint16_t i = 0;
uint16_t ptr;
+ scr_trow = scr_row;
+ findend();
+ scr_row = c;
e = scr_row;
- findst(scr_row);
+ findst();
ptr = (scr_row+scr_str)*80;
for (;buffer[ptr+i] != '\0';i++) {
cmd_buf[i] = buffer[ptr+i];
}
+ if (e <= 23) {
+ scr_row = e;
+ } else {
+ scr_row = 23;
+ }
}
- if (e) {
- scr_row = e;
- }
+
print_char(ch);
wrefresh(scr);
if (a == '\n') {
@@ -481,9 +627,11 @@ uint8_t getkey(char ch) {
void print_str(const char *str) {
uint16_t i = 0;
+ b = 1;
for (;str[i] != '\0'; i++) {
print_char(str[i]);
}
+ b = 0;
}
uint8_t dabbed() {
@@ -525,6 +673,7 @@ int main() {
cmd_buf = malloc(0x400);
clr_bitabl();
clr_buf();
+ clr_tokline();
uint8_t end = 0;
uint8_t next = 1;
char ch;
@@ -541,6 +690,7 @@ int main() {
#define maxline 24
#endif
uint8_t ln = 0;
+ int row, col;
mvwprintw(scr, ln++, 0, "scr_row: $%02X, scr_col: $%02X\r", scr_row, scr_col);
mvwprintw(scr, ln++, 0, "scr_str: $%02X, scr_end: $%02X, scr_ptr: $%04X\r", scr_str, scr_end, scr_ptr);
wmove(scr, ++ln, 0);
@@ -550,6 +700,15 @@ int main() {
for (uint16_t i = 0; i < maxline; i++) {
for (uint16_t j = 0; j < 80; j++) {
wprintw(scr, "%02x", buffer[(j+(i*80))]);
+ if (j == scr_col && i == scr_row) {
+ getyx(scr, row, col);
+ wmove(scr, ln++, 0);
+ wclrtoeol(scr);
+ wmove(scr, row+1, col-2);
+ wprintw(scr, "/\\\r");
+ wmove(scr, row, col);
+ wrefresh(scr);
+ }
}
wprintw(scr, ", i: $%02X\r", i);
wmove(scr, ln++, 0);
diff --git a/programs/c-ports/subeditor.h b/programs/c-ports/subeditor.h
index ddb8947..452dfb3 100644
--- a/programs/c-ports/subeditor.h
+++ b/programs/c-ports/subeditor.h
@@ -4,11 +4,12 @@
#include <string.h>
#include <curses.h>
-#define debug 0
+#define debug 1
#define debug_cmd_buf 0
extern WINDOW *scr;
+/* SuBEditor Stuff. */
extern char *buffer;
extern char *cmd_buf;
@@ -35,6 +36,22 @@ extern uint8_t scr_str;
extern uint8_t scr_end;
extern uint8_t wrapped;
+/* SuBAsm Stuff. */
+struct line {
+ uint8_t dir;
+ uint8_t mne;
+ uint8_t am;
+ uint8_t opbase;
+ uint16_t com;
+ uint16_t label;
+ uint64_t op;
+};
+
+char *label[0x1000];
+char *comment[0x1000];
+char *str[0x1000];
+struct line tokline[0x1000];
+
extern void print_str(const char *str);
extern int str_cmp(const char *s0, const char *s1);
extern uint8_t subasm();
diff --git a/programs/subeditor.s b/programs/subeditor.s
index 1001f83..eaecab5 100644
--- a/programs/subeditor.s
+++ b/programs/subeditor.s
@@ -3,8 +3,8 @@
; Writen in Sux assembly by
; mr b0nk 500 <b0nk@b0nk.xyz>
+.org $A000
; String Literals/Constants.
-.org $1000
tok:
.byte "dab"
msg:
@@ -15,7 +15,6 @@ string2:
.byte "You typed, "
; Linewrap bitmask table.
-.org $1100
bits:
.byte $80
.byte $40
@@ -73,11 +72,11 @@ bitabl:
.qword $0
.qword $0
scr_str:
-.byte $0
+ .byte $0
scr_end:
-.byte $0
+ .byte $0
wrapped:
-.byte $0
+ .byte $0
; Pointers
ptr:
@@ -92,471 +91,503 @@ ptr5:
.qword $0
ptr6:
.qword $0
+scr_ptr3:
+ .word $0
; Main program
.org $8000
reset:
- cps
- ldx.w #$FFFF
- txs
- ldy #0
- tyx
- lda #23
- sta scr_end
- lda.w #buffer
- sta.q ptr5
- lda.w #cmd_buf
- sta.q ptr6
- tya
- sta scr_str
- sta.q bitabl
- sta.q bitabl+8
- jsl clr_buf
- jmp start
+ cps ; Reset the processor status register.
+ ldx.w #$FFFF ; Reset the stack pointer.
+ txs ;
+ ldy #0 ; Reset the Y register.
+ tyx ; Reset the X register.
+ lda #23 ; Set the end of the screen back to 23.
+ sta scr_end ;
+ lda.w #buffer ; Place the address for the screen buffer
+ sta.q ptr5 ; into one of the pointers.
+ lda.w #cmd_buf ; Place the address for the command buffer
+ sta.q ptr6 ; into one of the pointers.
+ tya ; Reset the Accumulator.
+ sta scr_str ; Set the start of the screen back to zero.
+ sta.q bitabl ; Reset the first half of the linewrap table.
+ sta.q bitabl+8 ; Reset the second half of the linewrap table.
+ jsl clr_buf ; Clear the screen buffer.
+ jmp start ; Goto the start of the main program.
clr_buf:
- phb #1
- ldb #0
+ phb #1 ; Preserve whatever was in B.
+ ldb #0 ; Clear B.
+ lda.w #buffer+8 ;
+ sta.q ptr4 ;
+ tba ;
clr_buf_st:
- cpy.w #$1FFF
- bcs clr_buf_end
- sta.q (ptr5), y
- tya
- adc #8
- tay
- tba
- sta.q (ptr5), y
- tya
- adc #8
- tay
- tba
- sta.q (ptr5), y
- tya
- adc #8
- tay
- tba
- sta.q (ptr5), y
- tya
- adc #8
- tay
- tba
- jmp clr_buf_st
+ cpy.w #$1FFF ; Did we clear all of the screen buffer?
+ bcs clr_buf_end ; Yes, so we're done.
+ sta.q (ptr5), y ; No, so clear eight bytes.
+ sta.q (ptr4), y ; Clear eight more bytes.
+ tya ; Copy the buffer index.
+ adc #$10 ; Increment the index by 16.
+ tay ; Update the index.
+ tba ; Reset the Accumulator.
+ sta.q (ptr5), y ; Do this one more time, to clear 32 bytes.
+ sta.q (ptr4), y ;
+ tya ;
+ adc #$10 ;
+ tay ;
+ tba ;
+ jmp clr_buf_st ; Keep looping.
clr_buf_end:
- ldy.w zero
- plb #1
- rtl
+ ldy.w zero ; Set the index back to zero.
+ plb #1 ; Get whatever was in the B register, back.
+ rtl ; End of clr_buf.
start:
- lda #0
- sta $C000
- tax
- phy #2
- tay
- jsl clr_cbuf
- ply #2
- ;lda #1
- ;sta $C010
- lda.w #string
- jsl print_str
- lda.w zero
- jmp rset_a
+ lda #0 ; TODO: Update this for the Super VIA.
+ sta end ;
+ sta $C000 ; Clear the controll register of the I/O adapter.
+ tax ; Reset X.
+ phy #2 ; Save the cursor index for later.
+ tay ; Reset the cursor index.
+ jsl clr_cbuf ; Clear the command buffer.
+ ply #2 ; Get back the cursor index.
+ lda.w #string ; Print the startup message.
+ jsl print_str ;
+ lda.w zero ; Reset the Accumulator.
+ jmp read ; Start reading the keyboard.
clr_cbuf:
- phb #1
- ldb #0
+ phb #1 ; Start of callee preservation.
+ ldb #0 ; Reset the B register.
+ lda.w #cmd_buf+8;
+ sta.q ptr4 ;
+ tba ;
clr_cbuf_st:
- cpy.w #$3FF
- bcs clr_cbuf_end
- sta.q (ptr6), y
- tya
- adc #8
- tay
- tba
- sta.q (ptr6), y
- tya
- adc #8
- tay
- tba
- sta.q (ptr6), y
- tya
- adc #8
- tay
- tba
- sta.q (ptr6), y
- tya
- adc #8
- tay
- tba
- jmp clr_cbuf_st
-clr_cbuf_end:
- plb #1
- rtl
+ cpy.w #$3FF ; Did we clear all of the command buffer?
+ bcs clr_cbuf_nd ; Yes, so we're done.
+ sta.q (ptr6), y ; No, so clear eight bytes.
+ sta.q (ptr4), y ; Clear eight more bytes.
+ tya ; Copy the buffer index.
+ adc #$10 ; Increment the index by 16.
+ tay ; Update the index.
+ tba ; Reset the Accumulator.
+ sta.q (ptr6), y ; Do this one more time, to clear 32 bytes.
+ sta.q (ptr4), y ;
+ tya ;
+ adc #$10 ;
+ tay ;
+ tba ;
+ jmp clr_cbuf_st ; Keep looping.
+clr_cbuf_nd:
+ plb #1 ; End of callee preservation.
+ rtl ; End of clr_cbuf.
-pull_y:
- ply #2
-rset_a:
- lda #0
- sta $C000
- inc
read:
- lda $C000 ; Get control register.
- beq rset_a ; Loop until we get a character.
- 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.
+ lda $C000 ; Did we get a key?
+ beq read ; No, so try again.
+ jsl getchar ; Yes, and was it a newline?
+ beq parse ; Yes, so start parsing the line.
+ jmp read ; No, so keep looping.
print_str:
- sta.q ptr
- ldb #0
- tba
- inb
- stb b
+ sta.q ptr ; Place the string pointer into the main pointer.
+ ldb #0 ; Clear the B register.
+ tba ; Clear the Accumulator.
+ inb ; Enable replace mode.
+ stb b ;
pntstr_st:
- phy #2
- txy
- lda (ptr), y ; Get character at offset x.
- beq pntstr_end ; Did we find a null terminator?
- ply #2
- inx
- jsl print_char
- jmp pntstr_st
+ phy #2 ; Save the cursor index.
+ txy ; Copy the string index into Y.
+ lda (ptr), y ; Are we at the end of the string?
+ beq pntstr_end ; Yes, so we're done.
+ ply #2 ; No, so get the cursor index back.
+ inx ; Increment the string index.
+ jsl print_char ; Print the character.
+ jmp pntstr_st ; Keep looping.
pntstr_end:
- ply #2
- ldb #0
- stb b
- rtl
-
+ ply #2 ; Get the cursor index back.
+ ldb #0 ; Enable insert mode.
+ stb b ;
+ rtl ; End of print_str.
getbit:
- clc
- lda scr_str
- bne getbt0
- ldx scr_row
- jmp getbt1
+ 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.
+ jmp getbt1 ; Start getting the bit.
getbt0:
- lda scr_row
- adc scr_str
- tax
+ 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:
- jsl bitpos
- ldb bitabl, x
- aba
- cmp #1
- jmp bitout
+ jsl bitpos ; Get the bit, and byte position.
+ ldb bitabl, x ; Get one byte of the wrap table.
+ aba ; Mask out the bit of the current line number.
+ cmp #1 ; Set the carry flag, if true.
+ jmp bitout ; We are done.
clrbit:
- jsl bitpos
- xor #$FF
- ldb bitabl, x
- aba
+ jsl bitpos ; Get the bit, and byte position.
+ xor #$FF ; Invert the bitmask.
+ ldb bitabl, x ; Get one byte of the wrap table.
+ aba ; Clear the bit of the current line number.
bitsav:
- sta bitabl, x
+ sta bitabl, x ; Update the wrap table.
bitout:
- ldx bitmask
- rtl
+ ldx bitmask ; Return the bitmask.
+ rtl ; We are done.
setbit:
- jsl bitpos
- ldb bitabl, x
- oab
- jmp bitsav
+ jsl bitpos ; Get the bit, and byte position.
+ ldb bitabl, x ; Get one byte of the wrap table.
+ oab ; Set the bit of the current line number.
+ jmp bitsav ; Save the bit.
bitpos:
- pha #1
- lda.w #bits
- sta.q ptr3
- lda.w zero
- pla #1
- stx bitmask
- txa
- and #7
- phy #2
- tay
- tax
- lda (ptr3), y
- ply #2
- pha #1
- lda bitmask
- lsr #3
- tax
- pla #1
- rtl
-
+ pha #1 ; Save the parameter.
+ lda.w #bits ; Place the address of the bitmask table,
+ sta.q ptr3 ; in the third pointer.
+ lda.w zero ; Clear the Accumulator.
+ pla #1 ; 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 #2 ; Save the cursor index.
+ tay ; Use the bit position as the index.
+ tax ; Copy it into X.
+ lda (ptr3), y ; Get the bitmask.
+ ply #2 ; Get back the cursor index.
+ pha #1 ; Save the bitmask.
+ lda bitmask ; Get the line number.
+ lsr #3 ; Get the byte position.
+ tax ; Copy it into X.
+ pla #1 ; Get back the bitmask.
+ rtl ; End of bitpos.
getchar:
lda $C002 ; Get typed character.
- ldb #0
- stb e
- stb b
- pha #1
- phy #2
- cmp #10
- beq cmd_cpy
+ ldb #0 ;
+ stb e ;
+ stb b ;
+ pha #1 ;
+ phy #2 ;
+ cmp #10 ;
+ beq cmd_cpy ;
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
+ ply #2 ;
+ pla #1 ;
+ ldb e ;
+ bne reset_row ;
+getchar_pt1:
+ jsl print_char ;
+ lda a ;
+ cmp #10 ;
+ beq getchar_ln ;
+ jmp getchar_chr ;
reset_row:
- ldb e
- stb scr_row
- jmp getchar_pnt1
-
+ ldb e ;
+ cpb #23 ;
+ beq reset_row2 ;
+ bcs reset_row1 ;
+ jmp reset_row2 ;
+reset_row1:
+ ldb #23 ;
+reset_row2:
+ stb scr_row ;
+ jmp getchar_pt1 ;
cmd_cpy:
- ldb scr_row
- stb e
- jsl findst
- clc
- lda scr_row
- adc scr_str
- mul #80
- tay
- ldx.w #$0
-cmd_cpy_strt:
- lda (ptr5), y
- beq getchar_pnt
- phy #2
- txy
- sta (ptr6), y
- inx
- ply #2
- iny
- jmp cmd_cpy_strt
-getchar_line:
- lda #0
- jmp getchar_end
-getchar_char:
- lda #1
+ lda scr_row ;
+ sta scr_trow ;
+ jsl findend ;
+ sta scr_row ;
+ sta e ;
+ jsl findst ;
+ clc ;
+ lda scr_row ;
+ adc scr_str ;
+ mul #80 ;
+ tay ;
+ ldx.w #$0 ;
+cmd_cpy_st:
+ lda (ptr5), y ;
+ beq getchar_pnt ;
+ phy #2 ;
+ txy ;
+ sta (ptr6), y ;
+ inx ;
+ ply #2 ;
+ iny ;
+ jmp cmd_cpy_st ;
+getchar_ln:
+ lda #0 ;
+ jmp getchar_end ;
+getchar_chr:
+ lda #1 ;
getchar_end:
- rtl
+ rtl ;
findst:
- jsl getbit
- bcc findst_done
- dec scr_row
- bpo findst
- inc scr_row
+ lda #0 ;
+findst_lp:
+ pha #1 ;
+ jsl getbit ;
+ pla #1 ;
+ bcc findst_done ;
+ inc ;
+ dec scr_row ;
+ bpo findst_lp ;
+ dec ;
+ inc scr_row ;
findst_done:
- rtl
+ cmp #0 ;
+ rtl ;
+
+fndend:
+ phy #2 ;
+fndend_lp:
+ lda (ptr5), y ; Are we at the end of the string?
+ beq fndend_done ; Yes, so we're done.
+ iny ; No, so increment the cursor index.
+ jmp fndend_lp ; Keep looping.
+fndend_done:
+ sty.w scr_ptr3 ;
+ ply #2 ;
+ rtl ; End of fndend.
+
+findend:
+ jsl fndend ;
+ lda.w scr_ptr3 ;
+ div #80 ;
+ rtl ;
parse:
- lda #0
- tax
- jsl dabbed
- beq start
- lda #0
- tax
- jmp result
+ lda #0 ;
+ tax ;
+ jsl dabbed ;
+ beq start ;
+ lda #0 ;
+ tax ;
+ jmp result ;
print_char:
- sta a
- cmp #$1B
- beq esc
- cmp #$A
+ sta a ;
+ cmp #$1B ;
+ beq esc ;
+ cmp #$A ;
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
+ 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
+ cmp #$7F ;
beq bs ; Did the user type a backspace?
- sta a
+ sta a ;
printc:
+ lda #0 ;
+ sta d ;
lda (ptr5), y ; Are we at the end of the string?
beq printc_save ; Yes, so just print the character.
lda b ; No, but was the flag set?
bne printc_save ; Yes, so don't shift the line.
sty.w scr_ptr ; No, so save the cursor index for later.
-prntc_fndnd:
- lda (ptr5), y ; Are we at the end of the string?
- beq prntc_movln ; Yes, so make room for the next character.
- iny ; No, so increment the cursor index.
- jmp prntc_fndnd ; Keep looping.
-printc_updt:
- jmp prntc_updt2
-prntc_updt1:
- pla #1
- clc
- adc scr_row
- sta scr_row
- jsl update_pos
+ jsl fndend ;
+ jmp prntc_movln ;
+prntc_updt:
+ lda scr_col ;
+ sta scr_tcol ;
prntc_updt2:
- lda scr_row
- pha #1
- lda scr_col
- pha #1
- jsl rdrw_row
- pla #1
- sta scr_col
- pla #1
- sta scr_row
- jsl update_pos
+ jsl findend ;
+ sta e ;
+ sta scr_row ;
+ jsl findst ;
+ lda scr_row ;
prntc_updt3:
- ldb scr_row
- lda scr_trow
- sec
- sab
- pha #1
- tab
- sec
- sab
- clc
- sta scr_row
-prntc_updt4:
- jsl getbit
- bcs prntc_updt1
- pla #1
- lda scr_trow
- sta scr_row
- jsl update_pos
- dec d
- jmp printc_sav1
+ sta f ;
+ jsl rdrw_ln ;
+ lda scr_trow ;
+ sta scr_row ;
+ lda scr_tcol ;
+ sta scr_col ;
+ jsl update_pos ;
+ dec d ;
+ jmp printc_sav1 ;
prntc_movln:
- tyx
- dey
- ldb #1
- stb d
- jsl shftln
- ldb #1
- stb d
- lda scr_row
- sta scr_trow
+ ldy.w scr_ptr3 ;
+ inc scr_ptr3 ;
+ tyx ;
+ dey ;
+ ldb #1 ;
+ stb d ;
+ jsl shftln ;
+ ldb #1 ;
+ stb d ;
+ lda a ;
+ sta (ptr5), y ; store typed character into the input buffer.
+ lda scr_row ;
+ sta scr_trow ;
+ jmp prntc_updt ;
printc_save:
- ldb d
- bne printc_updt
+ ldb d ;
+ bne prntc_updt ;
printc_sav1:
- lda a
- sta (ptr5), y ; Store typed character into the input buffer.
+ lda a ;
+ sta (ptr5), y ; store typed character into the input buffer.
printc_inc:
inc scr_col ; Increment the cursor's x coordinate.
- iny
+ iny ;
printc_2:
- ldb #1
- stb f
- ldb scr_col
- cpb #80
- bcs printc_4
+ 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
+ ldb f ;
+ beq printc_wrap ;
+ jmp printc_end ;
printc_4:
- ldb scr_row
- cpb #23
- bcs printc_scrl
+ ldb scr_row ;
+ cpb #23 ;
+ bcs printc_scrl ;
printc_5:
- ldb #0
- stb f
- jmp printc_3
+ ldb #0 ;
+ stb f ;
+ jmp printc_3 ;
printc_scrl:
sta $C001 ; Echo typed character.
- clc
- lda #1
- sta wrapped
- jsl scrl_down
+ clc ;
+ lda #1 ;
+ sta wrapped ;
+ jsl scrl_down ;
printc_wrap:
- ldb #0
- stb scr_col
- ldb scr_row
- cpb #23
- bcs printc_wrap2
+ ldb #0 ;
+ stb scr_col ;
+ ldb scr_row ;
+ cpb #23 ;
+ bcs printc_wrp2 ;
printc_wrap1:
- inc scr_row
-printc_wrap2:
- phx #2
- clc
- lda scr_row
- adc scr_str
- tax
- jsl setbit
- plx #2
- jsl update_pos
+ inc scr_row ;
+printc_wrp2:
+ phx #2 ;
+ clc ;
+ lda scr_row ;
+ adc scr_str ;
+ tax ;
+ jsl setbit ;
+ plx #2 ;
+ jsl update_pos ;
printc_end:
- rtl
+ rtl ;
nl:
- lda #0
- ldb (ptr5), y
- bne nl1
+ lda #0 ;
+ ldb (ptr5), y ;
+ bne nl1 ;
sta (ptr5), y ; Store said terminator into the input buffer.
nl1:
- sta scr_col
- lda scr_row
- cmp #23
- bne nl_inc
- jsl scrl_down
- lda #10
- sta a
- jmp printc_end
+ sta scr_col ;
+ lda scr_row ;
+ cmp #23 ;
+ bcc nl_inc ;
+ jsl scrl_down ;
+ lda #10 ;
+ sta a ;
+ jmp printc_end ;
nl_inc:
- inc scr_row
- jsl update_pos
- lda #10
- sta a
- jmp printc_end
+ inc scr_row ;
+ jsl update_pos ;
+ lda #10 ;
+ sta a ;
+ jmp printc_end ;
clr_scr:
- lda #23
- sta scr_end
- lda #0
- sta scr_str
- sta.q bitabl
- sta.q bitabl+8
- tay
- jsl clr_buf
- tay
- jsl clr_cbuf
- sta scr_col
- sta scr_row
- jsl update_pos
- lda #$C
- sta $C001
- jmp printc_end
+ lda #23 ;
+ sta scr_end ;
+ lda #0 ;
+ sta scr_str ;
+ sta.q bitabl ;
+ sta.q bitabl+8 ;
+ tay ;
+ jsl clr_buf ;
+ tay ;
+ jsl clr_cbuf ;
+ sta scr_col ;
+ sta scr_row ;
+ jsl update_pos ;
+ lda #$C ;
+ sta $C001 ;
+ jmp printc_end ;
en_step:
- lda $C010
- beq step_en
- jmp stp_end
+ lda $C010 ;
+ beq step_en ;
+ jmp printc_end ;
step_en:
- lda #1
- sta $C010
- jmp stp_end
+ lda #1 ;
+ sta $C010 ;
+ jmp printc_end ;
dis_step:
- lda $C010
- bne step_dis
- jmp stp_end
+ lda $C010 ;
+ bne step_dis ;
+ jmp printc_end ;
step_dis:
- lda #0
- sta $C010
-stp_end:
- jmp printc_end
+ lda #0 ;
+ sta $C010 ;
+ jmp printc_end ;
back:
+ ldb #0 ;
+ stb e ;
+ stb f ;
+ lda scr_row ;
+ sta scr_trow ;
+ jsl findend ;
+ sta scr_row ;
+back0:
+ jsl findst ;
+ beq back1 ;
+ bcs back_updt ;
+ lda scr_trow ;
+ sta scr_row ;
+back1:
dey ; Decrement the buffer's offset.
lda #0 ; Place a null terminator
sta (ptr5), y ; into the buffer.
tyx ; Copy the current cursor index to X.
iny ; Increment cursor index.
- ldb #0
- stb d
- jsl shftln ; Move/Shift line back by one character.
+ ldb #0 ;
+ stb d ;
+ jsl shftln ; Shift line back by one character.
lda #$7F ; Print a backspace to the screen.
sta $C001 ;
+ lda e ;
+ beq back3 ;
+back2:
+ jsl findend ;
+ sta e ;
+ lda scr_col ;
+ sta scr_tcol ;
+ jsl rdrw_ln ;
+ lda scr_tcol ;
+ sta scr_col ;
+back3:
+ lda scr_trow ;
+ sta scr_row ;
dec scr_col ; Move the cursor back by one column,
jsl update_pos ; and update it's position.
jmp printc_end ; We are done.
+back_updt:
+ lda scr_row ;
+ sta f ;
+ inc e ;
+ jmp back1 ;
bs:
lda scr_col ; Are we at the far left of the screen?
@@ -585,20 +616,20 @@ backwrp:
tax ; Transfer that into X.
backwrp2:
dec scr_row ; Move up by one row.
- jsl clrbit ; Clear the wrap bit for this row.
+; jsl clrbit ; Clear the wrap bit for this row.
ldb #80 ; Move the cursor to the absolute right of the screen.
stb scr_col ;
jsl update_pos ; Update the cursor's position.
jmp back ; Delete the previous character.
shftln:
- ldb d ; Is the flag set?
- beq shftln_lp1 ; Yes, so shift, and increment.
- jmp shftln_lp0 ; No, so shift, and decrement.
+ ldb d ; Is the flag not set?
+ beq shftln_lp1 ; Yes, so shift, and decrement.
+ ldb #0 ; Clear the B register.
+ jmp shftln_lp0 ; No, so shift, and increment.
shftln_neg:
ldy.w zero ; Set the source poition to 0.
- lda #0 ; Clear the character
- sta (ptr5), y ; that is in the source.
+ stb (ptr5), y ; Clear the character that is in the source.
jmp shftln_end ; We are done.
shftln_lp0:
sty.w scr_ptr2 ; Save the source position for later.
@@ -613,26 +644,61 @@ shftln_lp01:
txy ; Set our position to the destination.
sta (ptr5), y ; Place the character from the source position, to the destination position.
ply #2 ; Set our position back to the source.
- lda #0 ; Clear the character
- sta (ptr5), y ; that is in the source.
- dey ; Decrement the source position.
+ stb (ptr5), y ; Clear the character that is in the source.
bng shftln_neg ; The source underflowed, so set it back to zero,
+ dey ; Decrement the source position.
dex ; Decrement the destination position.
jmp shftln_lp0 ; Keep looping.
shftln_lp1:
+ stx.w scr_ptr2 ; Save the destination position for later.
lda (ptr5), y ; Is the character at the source position, a null terminator?
- beq shftln_end ; Yes, so we're done.
+ beq shftln_end1 ; Yes, so we're done.
phy #2 ; No, so save the source position for later.
txy ; Set our position to the destination.
sta (ptr5), y ; Place the character from the source position, to the destination position.
inx ; Increment the destination position.
ply #2 ; Set our position back to the source.
- lda #0 ; Clear the character
- sta (ptr5), y ; that is in the source.
+ stb (ptr5), y ; Clear the character that is in the source.
iny ; Increment the source position.
jmp shftln_lp1 ; Keep looping.
+shftln_wrap:
+ tax ; Use the ending line as a parameter for setbit.
+ jsl setbit ; Set the wrap bit of the ending line.
+ jmp shftln_end2 ; We are done.
+shftln_wrp1:
+ tax ; Use the ending line as a parameter for clrbit.
+ jsl clrbit ; Clear the wrap bit of the ending line.
+ jmp shftln_end2 ; We are done.
shftln_end:
- rtl ; We are done.
+ lda (ptr5), y ; Is this character a null terminator?
+ bne shftln_nd0 ; No, so just find the end of the line.
+ lda #$20 ; Yes, so convert it to a space for now.
+ sta (ptr5), y ;
+shftln_nd0:
+ jsl findend ; Find the ending line.
+ sta d ; Save ending line for later.
+ lda (ptr5), y ; Is this character a space?
+ cmp #$20 ;
+ bne shftln_nd1 ; No, so skip the conversion.
+ lda #0 ; Yes, so convert it back to zero.
+ sta (ptr5), y ;
+shftln_nd1:
+ lda d ; Get the ending line.
+ cmp scr_row ; Is the ending line greater than the starting line?
+ beq shftln_end2 ; No, so we're done.
+ bcs shftln_wrap ; Yes, so set the wrap bit.
+ jmp shftln_end2 ; No, so we're done.
+shftln_end1:
+ jsl findend ; Find the ending line.
+ cpb #0 ; Is the remainder zero?
+ beq shftln_nd01 ; Yes, so check if the ending line is greater than the starting line.
+ jmp shftln_end2 ; No, so we're done.
+shftln_nd01:
+ cmp scr_row ; Is the ending line greater than the starting line?
+ beq shftln_end2 ; No, so we're done.
+ bcs shftln_wrp1 ; Yes, so clear the wrap bit.
+shftln_end2:
+ rtl ; End of shftln.
esc:
lda $C000 ; Get the next character.
@@ -657,9 +723,9 @@ esc:
bne esc_end ; Yes, so we're done.
jsl isright ; No, so check if the user pressed right.
esc_end:
- lda #0 ; Set the D pseudo register to zero.
+ lda #0 ; Clear the D pseudo register.
sta d ;
- jmp printc_end ; Go back to getting user input.
+ jmp printc_end ; We are done.
shftesc:
lda $C000 ; Skip the '['.
@@ -667,22 +733,22 @@ shftesc:
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 ;
+ lda #0 ; Use the D pseudo register as a skip flag.
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.
+ lda d ; Was it successful?
+ bne shftesc_end ; Yes, so we're done.
+ jsl isshftdown ; No, so check if the user pressed shift+down.
shftesc_end:
- lda #0 ;
+ lda #0 ; Clear the D pseudo register.
sta d ;
- jmp printc_end ; Go back to getting user input.
+ jmp printc_end ; We are done.
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 we're done.
- lda scr_row ; No, so is the cursor at the top of the screen?
+ bne isup_done ; No, so we're done.
+ lda scr_row ; Yes, but is the cursor at the top of the screen?
beq isup_scrl ; Yes, so check if we need to scroll.
isup_2:
lda c ; No, so load the escape code back into the accumulator.
@@ -693,16 +759,18 @@ isup_scrl:
lda scr_str ; Are we at the top of the screen buffer?
beq isup_done ; Yes, so we're done.
jsl scrl_up ; No, so scroll up.
+ lda #1 ; Tell the escape routine that we were successful.
+ sta d ;
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.
+ bne isdown_done ; No, so we're done.
+ lda scr_row ; Yes, so start checking the y coordinate of the cursor.
cmp #23 ; Is the cursor at the bottom of the screen?
- beq isdown_scrl ; Yes, so return.
+ beq isdown_scrl ; Yes, so scroll down.
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.
@@ -717,6 +785,8 @@ isdown_scrl:
sta scr_row ;
lda scr_tcol ; Load the cursor's column number.
sta scr_col ;
+ lda #1 ; Tell the escape routine that we were successful.
+ sta d ;
isdown_done:
rtl ; End of isdown.
@@ -735,8 +805,8 @@ isright_wrp:
dec scr_row ; No, so move the cursor back up a row.
jmp isright_dne ; We are done.
isright_scr:
-; lda scr_str ; Are we at the top of the screen buffer?
-; beq isright_end ; Yes, so we're done.
+ lda scr_str ; Are we at the top of the screen buffer?
+ beq isright_end ; Yes, so we're done.
lda #1 ; No, so scroll down.
sta wrapped ; Set the wrapped flag.
jsl scrl_down ; Scroll down.
@@ -748,7 +818,7 @@ wrap_inc:
cmp #23 ; Are we at the bottom of the screen?
beq isright_nd2 ; No, so we're done.
bcs isright_scr ; Yes, so check if we are scrolling down.
- jmp isright_nd2 ; We are done.
+ jmp isright_nd2 ; No, so we're done.
isright_end:
dec scr_row ; Move back up a row.
isright_nd2:
@@ -759,29 +829,29 @@ isright_dne:
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?
+ lda c ; Get the saved character.
+ cmp #$43 ; Did the user press right?
+ beq isleft_done ; Yes, so we're done
+ lda scr_col ; No, but is the cursor at the far left of the screen?
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 ; We are done.
+ jmp isleft_done ; No, so we're done.
isleft_wrp:
jsl getbit ; Is the current line, a wrapped line?
bcs wrap_dec ; Yes, so wrap back up a line.
- jmp isleft_done ; No, so return.
+ jmp isleft_done ; No, so we're done.
wrap_dec:
lda scr_row ; Is the cursor at the top of the screen?
- beq wrap_dec1 ; Yes, so don't move up a row.
- lda #1 ; No, so move up a row.
- sta wrapped ; Set the wrapped flag.
- dec scr_row ; Move the cursor up by one row.
+ beq wrap_dec1 ; Yes, so don't move up a line.
+ lda #1 ; No, so set the wrapped flag.
+ sta wrapped ;
+ dec scr_row ; Move the cursor up one line.
wrap_dec1:
lda #79 ; Move the Cursor to the far right of the screen.
sta scr_col ;
- lda #1 ; Tell the escape routine to stop after this.
+ lda #1 ; Tell the escape routine that we were successful.
sta d ;
lda scr_row ; Are we at the top of the screen?
beq isleft_scrl ; Yes, so check if we need to scroll.
@@ -801,81 +871,81 @@ isleft_done:
rtl ; End of isleft.
up:
- dec scr_row
- jsl update_pos
- lda #1
- sta d
- jmp isup_done
+ dec scr_row ; Move the cursor up a line.
+ jsl update_pos ; Update it's position.
+ lda #1 ; Tell the escape routine that we succeded.
+ sta d ;
+ jmp isup_done ; We are done.
down:
- inc scr_row
- jsl update_pos
- lda #1
- sta d
- jmp isdown_done
+ inc scr_row ; Move the cursor down a line.
+ jsl update_pos ; Update it's position.
+ lda #1 ; Tell the escape routine that we succeded.
+ sta d ;
+ jmp isdown_done ; We are done.
right:
- inc scr_col
- jsl update_pos
- jmp isright_dne
+ inc scr_col ; Move the cursor right by one character.
+ jsl update_pos ; Update it's position.
+ jmp isright_dne ; We are done.
left:
- dec scr_col
- jsl update_pos
- lda #1
- sta d
- jmp isleft_done
+ dec scr_col ; Move the cursor left a character.
+ jsl update_pos ; Update it's position.
+ lda #1 ; Tell the escape routine that we succeded.
+ sta d ;
+ jmp isleft_done ; We are 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
+ bne shftup_done ;
+ lda #1 ;
+ sta d ;
+ lda scr_str ;
+ beq shftup_done ;
+ jmp shftup ;
+shftup_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
+ bne shftdn_done ;
+ lda #1 ;
+ sta d ;
+ lda scr_end ;
+ cmp #71 ;
+ bcs shftdn_done ;
+ jmp shftdown ;
+shftdn_done:
+ rtl ;
shftup:
- jsl scrl_up
- lda #1
- sta d
- jmp isshftup_done
+ jsl scrl_up ;
+ lda #1 ;
+ sta d ;
+ jmp shftup_done ;
shftdown:
- jsl scrl_down
- lda #1
- sta d
- jmp isshftdown_done
+ jsl scrl_down ;
+ lda #1 ;
+ sta d ;
+ jmp shftdn_done ;
update_pos:
- ldb #1
- stb f
- clc
- lda scr_row
- adc scr_str
- tay
- clc
- lsl #6
- tab
- tya
- lsl #4
- aab
- clc
- adc scr_col
- tay
+ ldb #1 ; Set the F pseudo register to one, to fix some bugs.
+ stb f ;
+ 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.
+ tay ; Place it in the Y regster for now.
+ clc ; Clear the carry flag.
+ lsl #6 ; Multiply the absolute line number by 64.
+ tab ; Use it as a second operand.
+ tya ; Place the absolute line number back into the Accumulator
+ lsl #4 ; Multiply the absolute line number by 16.
+ aab ; Add both the Accumulator, and the B register together, to multiply the line number by 80.
+ clc ; Clear the carry flag.
+ adc scr_col ; Add the cursor's column number to get the screen index.
+ tay ; Place the index into the Y register.
lda #$1B ; Print an escape character
sta $C001 ; to the screen.
lda #$5B ; Print '['
@@ -911,190 +981,180 @@ getcol:
rtl ; End of getrow.
scrl_down:
- inc scr_str
- inc scr_end
+ inc scr_str ; Increment the starting line of the screen.
+ inc scr_end ; Increment the ending line of the screen.
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
+ lda scr_row ; Get the cursor's line number.
+ pha #1 ; Save it in the stack.
+ lda wrapped ; Was the wrapped flag set?
+ beq scrldn_save ; Yes, so save the cursor position.
scrldn1:
- jsl rdrw_row
- lda wrapped
- beq scrldn_load
- jmp scrldn_end
+ jsl rdrw_row ; Redraw this row.
+ lda wrapped ; Was the wrapped flag set?
+ beq scrldn_load ; Yes, so load the previous cursor position back.
+ jmp scrldn_end ; No, so we're done.
scrldn_save:
- lda scr_row
- pha #1
- lda scr_col
- pha #1
- jmp scrldn1
+ lda scr_col ; Get the cursor's column number.
+ pha #1 ; Save it in the stack.
+ jmp scrldn1 ; Start redrawing the current row.
scrldn_load:
- pla #1
- sta scr_col
- pla #1
- sta scr_row
- jsl update_pos
+ pla #1 ; Get the cursor's previous column number back.
+ sta scr_col ;
scrldn_end:
- lda #0
- sta wrapped
+ pla #1 ; Get the cursor's previous line number back.
+ sta scr_row ;
+ jsl update_pos ; Update the cursor's position.
+ lda #0 ; Clear the wrapped flag.
+ sta wrapped ;
scrldn_done:
- rtl
+ rtl ; End of scrl_down.
scrl_up:
- dec scr_str
- dec scr_end
+ 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
+ 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
+ rtl ;
rdrw_row:
- lda #0
- sta scr_col
- jsl update_pos
+ lda #0 ;
+ sta scr_col ;
+ jsl update_pos ;
rdrow_st:
- lda (ptr5), y
- beq rdrow_inc
- sta $C001
+ lda (ptr5), y ;
+ beq rdrow_inc ;
+ sta $C001 ;
rdrow_inc:
- inc scr_col
- lda (ptr5), y
- beq rdrow_skip
+ inc scr_col ;
+ lda (ptr5), y ;
+ beq rdrow_skip ;
rdrow_inc1:
- iny
+ iny ;
rdrow_inc2:
- lda scr_col
- cmp #80
- bcs rdrow_end
- jmp rdrow_st
+ lda scr_col ;
+ cmp #80 ;
+ bcs rdrow_end ;
+ jmp rdrow_st ;
rdrow_skip:
- lda #$20
+ lda #$20 ;
sta $C001 ; to the screen.
- jmp rdrow_inc1
+ jmp rdrow_inc1 ;
rdrow_end:
- lda #0
- sta scr_col
- jsl update_pos
+ lda #0 ;
+ sta scr_col ;
+ jsl update_pos ;
rdrow_done:
- rtl
-
-;rdrw_scr:
-; lda scr_row
-; sta e
-; lda #0
-; sta scr_row
-; lda scr_col
-; sta f
-; jsl update_pos
-;rdscr_st:
-; jsl rdrw_row
-; lda scr_row
-; cmp #23
-; beq rdscr_inc
-; bcs rdscr_done
-;rdscr_inc:
-; inc scr_row
-; jmp rdscr_st
-;rdscr_done:
-; lda e
-; sta scr_row
-; lda f
-; sta scr_col
-; jsl update_pos
-; lda #0
-; sta e
-; sta f
-; rtl
+ rtl ;
result:
- lda.w #string2
- ldx.w zero
- jsl print_str
+ lda.w #string2 ;
+ ldx.w zero ;
+ jsl print_str ;
rset_x:
lda #0 ; Reset a.
tax ; Reset x.
jmp print_buf ; Print the input buffer.
dabbed:
- ldb #0
- lda.w #tok
- sta.q ptr2
- tba
+ ldb #0 ;
+ lda.w #tok ;
+ sta.q ptr2 ;
+ tba ;
dab_st:
- phy #2
- txy
+ phy #2 ;
+ txy ;
lda (ptr6), y ; Get a character from the input buffer.
beq dab_pend ; Are we done with printing the buffer?
- cmp (ptr2), y
- beq chk_str
- jmp dab_pend
+ cmp (ptr2), y ;
+ beq chk_str ;
+ jmp dab_pend ;
chk_str:
- ply #2
- inx
- cpx #3
- bne dab_st
- ldx #0
+ ply #2 ;
+ inx ;
+ cpx #3 ;
+ bne dab_st ;
+ ldx #0 ;
pnt_msg:
- lda.w #msg
- ldx #0
- stx.q ptr
- jsl print_str
- jmp dab_peqnd
+ lda.w #msg ;
+ ldx #0 ;
+ stx.q ptr ;
+ jsl print_str ;
+ jmp dab_peqnd ;
dab_pend:
- ply #2
- lda #1
- jmp dab_end
+ ply #2 ;
+ lda #1 ;
+ jmp dab_end ;
dab_peqnd:
- lda #0
- jmp dab_end
+ lda #0 ;
+ jmp dab_end ;
dab_end:
- rtl
+ rtl ;
print_buf:
- lda.w #cmd_buf
- jsl print_str
- lda.w zero
+ lda.w #cmd_buf ;
+ jsl print_str ;
+ lda.w zero ;
cmd_clr:
- lda #10
- jsl print_char
- jmp start
+ lda #10 ;
+ jsl print_char ;
+ jmp start ;
+
+rdrw_ln:
+ lda scr_row ;
+ pha #1 ;
+ inc end ;
+ lda f ;
+ sta scr_row ;
+ lda scr_col ;
+ pha #1 ;
+ jsl update_pos ;
+rdrwln_lp:
+ lda scr_row ;
+ cmp e ;
+ beq rdrwln_lp1 ;
+ bcs rdrwln_done ;
+rdrwln_lp1:
+ jsl rdrw_row ;
+rdrwln_inc:
+ inc scr_row ;
+ jmp rdrwln_lp ;
+rdrwln_done:
+ pla #1 ;
+ sta scr_col ;
+ pla #1 ;
+ sta scr_row ;
+ jsl update_pos ;
+ lda #0 ;
+ sta e ;
+ sta f ;
+ dec end ;
+ rtl ;
.org $FFC0
.qword reset
r
-;.org $8000
-;v
-;.org $8100
-;v
-;.org $8200
-;v
-;.org $8300
-;v
-;.org $8400
-;v
-;.org $8500
-;v
-;q
done
generated by cgit v1.2.3-13-gbd6f (git 2.30.0) at 2024-12-26 19:56:05 +0000