Apple-2-SW/Applecorn
1
0
Fork 0
mirror of https://github.com/bobbimanners/Applecorn.git synced 2025-02-13 01:30:33 +00:00
Code Issues Projects Releases Wiki Activity

Rolled back latest VDU/CHARIO changes. Broken!

Browse Source
This commit is contained in:
Bobbi Webber-Manners 2021-08-17 11:19:30 -04:00
parent eb960cfcdf
commit 1e2f4285e1
3 changed files with 137 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
applecorn.po
View File

Binary file not shown.

232
auxmem.chario.s
View File

@ -1,5 +1,5 @@
********************************************************* *********************************************************
* Kernel / Character I/O * Kernel / Misc
********************************************************* *********************************************************
* KERNEL/CHARIO.S * KERNEL/CHARIO.S
@ -10,21 +10,13 @@
* with VBLK. Ensured cursor turned on straight away. * with VBLK. Ensured cursor turned on straight away.
* 15-Aug-2021 Cursor keys move copy cursor, copy reads char. * 15-Aug-2021 Cursor keys move copy cursor, copy reads char.
* Copy cursor not visible yet. * Copy cursor not visible yet.
* 16-Aug-2021 Copy cursor and Edit cursor visible.
* TEMP: * TEMP:
FLASHER EQU $290 FXESCCHAR EQU $240
CURSOR EQU $291 FXESCON EQU $241
OLDCHAR EQU $292 FLASHER EQU $242
COPYCHAR EQU $293 OLDCHAR EQU $243
CURSOR EQU $244
FXTABCHAR EQU BYTEVARBASE+219
FXESCCHAR EQU BYTEVARBASE+220
FXESCON EQU BYTEVARBASE+229
FX2VAR EQU BYTEVARBASE+$B1
FX3VAR EQU BYTEVARBASE+$EC
FX4VAR EQU BYTEVARBASE+$ED
* OSWRCH handler * OSWRCH handler
@ -50,7 +42,7 @@ WRCHHND PHA
* All registers preserved except A, Carry * All registers preserved except A, Carry
* Flashes a fake cursor while waiting for input * Flashes a fake cursor while waiting for input
* *
RDCHHND LDA #$80 ; flag=wait forever RDCHHND LDA #$80 ; flag=wait forever
PHY PHY
TAY TAY
* TEST * TEST
@ -58,119 +50,98 @@ RDCHHND LDA #$80 ; flag=wait forever
BNE INKEYGO BNE INKEYGO
LDA #'_' LDA #'_'
STA CURSOR STA CURSOR
LDA #$1B
STA FXESCCHAR
* TEST * TEST
BRA INKEYGO ; Wait forever for input BRA INKEYGO ; Wait forever for input
; XY<$8000 - wait for a keypress ; XY<$8000 - wait for a keypress
INKEY PHY ; Dummy PHY to balance RDCH INKEY PHY ; Dummy PHY to balance RDCH
INKEYGO PHX ; Save registers INKEYGO PHX ; Save registers
PHY PHY
JSR GETCHRC ; Get character under cursor JSR GETCHRC ; Get character under cursor
STA OLDCHAR STA OLDCHAR
* This can be optimised CLI
BIT VDUSTATUS BRA INKEY1 ; Turn cursor on
BVC INKEYGO2 ; No editing cursor
STA COPYCHAR ; Save char under edit cursor
LDA #$A0
JSR PUTCHRC ; Display edit cursor
JSR COPYSWAP1 ; Swap to copy cursor
JSR GETCHRC ; Get character under copy cursor
STA OLDCHAR
*
INKEYGO2 CLI
BRA INKEY1 ; Turn cursor on
; ;
INKEYLP1 PHX INKEYLP1 PHX
INKEYLP2 PHY INKEYLP2 PHY
INKEYLP CLC * TO DO: display copy cursor as well
LDA #$01 ; Slow flash, every 32 frames INKEYLP INC FLASHER ; Increment cursor counter
BIT VDUSTATUS INC FLASHER
BVC INKEY0 * INC FLASHER ; Fast flash
ASL A ; Fast flash, every 16 frames * INC FLASHER
INKEY0 ADC FLASHER LDA FLASHER
STA FLASHER AND #127 ; Flash every 64/100sec = 32/50sec
AND #15 BNE INKEY3 ; Not time to toggle yet
BNE INKEY3 ; Not time to toggle yet LDA OLDCHAR ; Prepare to remove cursor
LDA OLDCHAR ; Prepare to remove cursor
BIT FLASHER BIT FLASHER
BMI INKEY2 ; Remove cursor BMI INKEY2 ; Remove cursor
INKEY1 LDA CURSOR ; Add cursor INKEY1 LDA CURSOR ; Add cursor
INKEY2 JSR PUTCHRC ; Toggle cursor INKEY2 JSR PUTCHRC ; Toggle cursor
INKEY3 LDA ESCFLAG INKEY3 LDA ESCFLAG
BMI INKEYOK ; Escape pending, return it BMI INKEYOK ; Escape pending, return it
INKEY4 JSR KEYREAD ; Test for input, all can be trashed INKEY4 JSR KEYREAD ; Test for input, all can be trashed
BCC INKEYOK ; Char returned, return it BCC INKEYOK ; Char returned, return it
* JSR DELAY ; Wait 1/100sec
; ;
* VBLK pulses at 50Hz, changes at 100Hz * VBLK pulses at 50Hz, changes at 100Hz
* (60Hz in US, will need tweeking) * (60Hz in US, will need tweeking)
LDX $C019 ; Get initial VBLK state LDX $C019 ; Get initial VBLK state
INKEY5 BIT $C000 INKEY5 BIT $C000
BMI INKEY4 ; Key pressed BMI INKEY4 ; Key pressed
TXA TXA
EOR $C019 EOR $C019
BPL INKEY5 ; Wait for VBLK change BPL INKEY5 ; Wait for VBLK change
; ;
PLY PLY
BMI INKEYLP2 ; Loop forever BMI INKEYLP2 ; Loop forever
PLX PLX
TXA TXA
BNE INKEYDEC ; Decrement XY BNE INKEYDEC ; Decrement XY
DEY DEY
INKEYDEC DEX INKEYDEC DEX
BNE INKEYLP1 ; Not 0, loop back BNE INKEYLP1 ; Not 0, loop back
TYA TYA
BNE INKEYLP1 ; Not 0, loop back BNE INKEYLP1 ; Not 0, loop back
DEY ; Y=$FF DEY ; Y=$FF
TYA ; A=$FF TYA ; A=$FF
PLX ; Drop dummy PHY PLX ; Drop dummy PHY
RTS ; CS from above RTS ; CS from above
; Timeout: CS, AY=$FFFF, becomes XY=$FFFF ; Timeout: CS, AY=$FFFF, becomes XY=$FFFF
INKEYOK PHA INKEYOK PHA
* This can be optimised
BIT VDUSTATUS
BVC INKEYOK2 ; No editing cursor
LDA OLDCHAR LDA OLDCHAR
JSR PUTCHRC ; Remove copy cursor JSR PUTCHRC ; Remove cursor
JSR COPYSWAP1 ; Swap cursor back
LDA COPYCHAR
BRA INKEYOK3 ; Restore char under edit cursor
*
INKEYOK2 LDA OLDCHAR ; and swap cursor back
INKEYOK3 JSR PUTCHRC ; Remove edit cursor
PLA PLA
PLY ; <$80=INKEY or $80=RDCH PLY ; <$80=INKEY or $80=RDCH
PLX ; Restore X PLX ; Restore X
PLY ; <$80=INKEY or restore=RDCH PLY ; <$80=INKEY or restore=RDCH
PHA ; Save char for a mo PHA ; Save char for a mo
LDA ESCFLAG LDA ESCFLAG
ASL A ; Cy=Escape flag ASL A ; Cy=Escape flag
PLA ; Get char back PLA ; Get char back
RTS RTS
; Character read: CC, A=char, X=???, Y<$80 ; Character read: CC, A=char, X=???, Y<$80
; Escape: CS, A=?? , X=???, Y<$80 ; Escape: CS, A=?? , X=???, Y<$80
BYTE81 TYA BYTE81 TYA
BMI NEGINKEY ; XY<0, scan for keypress BMI NEGINKEY ; XY<0, scan for keypress
JSR INKEY ; XY>=0, wait for keypress JSR INKEY ; XY>=0, wait for keypress
* Y=$FF, A=FF, X=??, CS - timeout * Y=$FF, A=FF, X=??, CS - timeout
* Y<$80, A=esc, X=??, CS - escape * Y<$80, A=esc, X=??, CS - escape
* Y<$80, A=char, X=??, CC - character read * Y<$80, A=char, X=??, CC - character read
TAX ; X=character returned TAX ; X=character returned
TYA TYA
BMI BYTE81DONE ; Y=$FF, timeout BMI BYTE81DONE ; Y=$FF, timeout
LDY #$00 LDY #$00
BCC BYTE81DONE ; CC, not Escape BCC BYTE81DONE ; CC, not Escape
LDY #$1B ; Y=27 LDY #$1B ; Y=27
BYTE81DONE RTS BYTE81DONE RTS
* Returns: Y=$FF, X=$FF, CS - timeout * Returns: Y=$FF, X=$FF, CS - timeout
* Y=$1B, X=???, CS - escape * Y=$1B, X=???, CS - escape
* Y=$00, X=char, CC - keypress * Y=$00, X=char, CC - keypress
NEGINKEY LDX #$00 ; Unimplemented NEGINKEY LDX #$00 ; Unimplemented
LDY #$00 LDY #$00
CLC CLC
RTS RTS
@ -190,40 +161,31 @@ NEGINKEY LDX #$00 ; Unimplemented
KEYREAD KEYREAD
* TO DO: check *EXEC source * TO DO: check *EXEC source
* TO DO: expand current soft key * TO DO: expand current soft key
JSR KBDREAD ; Fetch character from KBD "buffer" JSR KBDREAD ; Fetch character from KBD "buffer"
BCS KEYREADOK ; Nothing pending BCS KEYREADOK ; Nothing pending
* TO DO: process new soft keys * TO DO: process new soft keys
* *
* Process cursor keys * Process cursor keys
* TO DO: check FX4VAR * TO DO: check FX4VAR
KEYCURSOR CMP #$C9 CMP #$C9
BEQ KEYCOPY BEQ KEYCOPY
CMP #$CC CMP #$CC
BCC KEYREADOK ; Not cursor key BCC KEYREADOK ; Not cursor key
PHA JSR MOVECOPY ; Move copy cursor
LDA OLDCHAR KEYCOPYBAD SEC
JSR PUTCHRC ; Remove cursor
PLA
JSR COPYMOVE ; Move copy cursor
JSR GETCHRC ; Save char under cursor
STA OLDCHAR
SEC
KEYREADOK RTS KEYREADOK RTS
KEYCOPY LDA FXTABCHAR ; Prepare TAB if no copy cursor KEYCOPY AND #$0F ; TAB=$09 if no copy cursor
BIT VDUSTATUS BIT VDUSTATUS
BVC KEYREADOK ; No copy cursor, return TAB BVC KEYCOPYOK ; No copy cursor
LDA OLDCHAR ; Get the char under cursor JSR COPYSWAP ; Swap to copy cursor
JSR GETCHRC ; Get the character
PHA PHA
JSR OUTCHARGO ; Output it to restore and move cursor JSR MOVECOPY3 ; Move copy cursor, swap back
JSR GETCHRC ; Save char under cursor
STA OLDCHAR
PLA PLA
BNE KEYCOPYOK ; Ok character BEQ KEYCOPYBAD ; Bad character read
SEC
JMP BEEP ; Beep and return CS=No char
KEYCOPYOK CLC KEYCOPYOK CLC
RTS ; Return the character RTS ; Return the character
* KBDREAD * KBDREAD
@ -238,60 +200,60 @@ KEYCOPYOK CLC
* TAB -> $C9 * TAB -> $C9
* Cursors -> $CC-$CF * Cursors -> $CC-$CF
* *
KBDREAD CLV ; VC=return keypress KBDREAD CLV ; VC=return keypress
KBDTEST LDA $C000 ; VS here to test for keypress KBDTEST LDA $C000 ; VS here to test for keypress
EOR #$80 ; Toggle bit 7 EOR #$80 ; Toggle bit 7
CMP #$80 CMP #$80
BCS KBDDONE ; No key pressed BCS KBDDONE ; No key pressed
BVS KBDDONE ; VS=test for keypress BVS KBDDONE ; VS=test for keypress
STA $C010 ; Ack. keypress STA $C010 ; Ack. keypress
BIT $C061 BIT $C061
BMI KBDLALT ; Left Apple pressed BMI KBDLALT ; Left Apple pressed
BIT $C062 BIT $C062
BMI KBDRALT ; Right Apple pressed BMI KBDRALT ; Right Apple pressed
CMP #$09 CMP #$09
BEQ KBDTAB ; BEQ KBDTAB ;
CMP #$08 CMP #$08
BCC KBDESC ; <$08 not cursor key BCC KBDDONE ; <$08 not cursor key
CMP #$0C CMP #$0C
BCC KBDCURSR BCC KBDCURSR
CMP #$15 CMP #$15
BEQ KBDCUR15 BEQ KBDCUR15
* Test for Escape key * Test for Escape key
KBDESC CMP FXESCCHAR ; Current ESCAPE char? KBDESC CMP #27 ; TEMP
* CMP #27 ; TEMP * CMP FXESCCHAR ; Current ESCAPE char?
BNE KBDNOESC ; No BNE KBDNOESC ; No
LDX FXESCON ; Is ESCAPE enabled? LDX FXESCON ; Is ESCAPE enabled?
BNE KBDNOESC ; No BNE KBDNOESC ; No
ROR ESCFLAG ; Set Escape flag ROR ESCFLAG ; Set Escape flag
KBDNOESC CLC ; CLC=Ok KBDNOESC CLC ; CLC=Ok
KBDDONE RTS KBDDONE RTS
KBDRALT ; Right Apple key pressed KBDRALT ; Right Apple key pressed
KBDLALT CMP #$40 ; Left Apple key pressed KBDLALT CMP #$40 ; Left Apple key pressed
BCS KBDCTRL BCS KBDCTRL
CMP #$30 CMP #$30
BCC KBDFUNOK ; <'0' BCC KBDFUNOK ; <'0'
CMP #$3A CMP #$3A
BCS KBDOK ; >'9' BCS KBDOK ; >'9'
KBDFUNC AND #$0F ; Convert Apple-Num to function key KBDFUNC AND #$0F ; Convert Apple-Num to function key
ORA #$80 ORA #$80
BIT $C062 BIT $C062
BPL KBDFUNOK ; Left+Digit -> $8x BPL KBDFUNOK ; Left+Digit -> $8x
ORA #$90 ; Right+Digit -> $9x ORA #$90 ; Right+Digit -> $9x
BIT $C061 BIT $C061
BPL KBDFUNOK BPL KBDFUNOK
EOR #$30 ; Left+Right+Digit -> $Ax EOR #$30 ; Left+Right+Digit -> $Ax
KBDFUNOK RTS KBDFUNOK RTS
KBDCTRL AND #$1F ; Apple-Letter -> Ctrl-Letter KBDCTRL AND #$1F ; Apple-Letter -> Ctrl-Letter
KBDOK CLC KBDOK CLC
RTS RTS
KBDTAB LDA #$11 ; Convert TAB to $C9, expanded later KBDTAB LDA #$11 ; Convert TAB to $C9, expanded later
KBDCUR15 SBC #$0C ; Convert RGT to $09 KBDCUR15 SBC #$0C ; Convert RGT to $09
KBDCURSR CLC KBDCURSR CLC
ADC #$C4 ; Cursor keys $CC-$CF ADC #$C4 ; Cursor keys $CC-$CF
RTS ; CLC=Ok set earlier RTS ; CLC=Ok set earlier

128
auxmem.vdu.s
View File

@ -6,7 +6,6 @@
* 15-Aug-2021 Optimised address calculations and PRCHRC. * 15-Aug-2021 Optimised address calculations and PRCHRC.
* Entry point to move copy cursor. * Entry point to move copy cursor.
* Start to consolidate VDU workspace. * Start to consolidate VDU workspace.
* 16-Aug-2021 Added COPY cursor handling.
********************************** **********************************
@ -31,8 +30,6 @@ VDUTEXTX EQU COL
VDUTEXTY EQU ROW VDUTEXTY EQU ROW
VDUCOPYX EQU $250+2 ; copy cursor X coord VDUCOPYX EQU $250+2 ; copy cursor X coord
VDUCOPYY EQU $250+3 ; copy cursor Y coord VDUCOPYY EQU $250+3 ; copy cursor Y coord
VDUCOPYCHR EQU $260+0 ; char underneath cursor when copying
* VDUCURSOR EQU $250+4 ; cursor character * VDUCURSOR EQU $250+4 ; cursor character
* VDUMODE EQU $250+5 ; current MODE * VDUMODE EQU $250+5 ; current MODE
* VDUCHAR EQU $250+6 ; VDU command, 1 byte * VDUCHAR EQU $250+6 ; VDU command, 1 byte
@ -45,55 +42,34 @@ VDUCOPYCHR EQU $260+0 ; char underneath cursor when copying
* Move editing cursor * Move editing cursor
* A=cursor key, CS from caller * A=cursor key
COPYMOVE PHA MOVECOPY PHA
BIT VDUSTATUS BIT VDUSTATUS
BVS COPYMOVE2 ; Edit cursor already on BVS MOVECOPY2 ; Edit cursor already on
JSR GETCHRC LDX #1
STA COPYCHAR MOVECOPY1 LDA VDUTEXTX,X ; Initialise copy cursor
LDA #$A0 STA VDUCOPYX,X
JSR PUTCHRC ; Edit cursor DEX
SEC BPL MOVECOPY1
JSR COPYSWAP2 ; Initialise copy cursor LDA #$40
ROR FLASHER
ASL FLASHER ; Ensure b0=0
LDA #$42
ORA VDUSTATUS ORA VDUSTATUS
STA VDUSTATUS ; Turn cursor editing on STA VDUSTATUS ; Turn edit cursor on
COPYMOVE2 PLA MOVECOPY2 JSR COPYSWAP ; Use edit cursor
AND #3 ; Convert to 8/9/10/11 PLA
AND #3
ORA #8 ORA #8
COPYMOVE3 JMP OUTCHARGO ; Move edit cursor MOVECOPY3 JSR OUTCHARGO ; Move edit cursor
* JSR CHARADDR ; Get character address
;* Turn editing cursor on/off * ; Swap cursors back
;COPYCURSOR BIT VDUSTATUS COPYSWAP LDX #1
; BVC COPYSWAP4 ; Copy cursor not active
; PHP ; Save CS=Turn On, CC=Turn Off
; JSR COPYSWAP1 ; Swap to edit cursor
; LDA COPYCHAR ; Prepare to turn edit cursor off
; PLP
; BCC COPYCURS2 ; Restore character
;COPYCURS1 JSR GETCHRC ; Get character under edit cursor
; STA COPYCHAR
; LDA #$A0 ; Output edit cursor
;COPYCURS2 JSR PUTCHRC
;* ; Drop through to swap back
* Swap between edit and copy cursors
;COPYSWAP BIT VDUSTATUS
; BVC COPYSWAP4 ; Edit cursor off
COPYSWAP1 CLC ; CC=Swap TEXT and COPY
COPYSWAP2 LDX #1
COPYSWAPLP LDY VDUCOPYX,X COPYSWAPLP LDY VDUCOPYX,X
LDA VDUTEXTX,X LDA VDUTEXTX,X
STA VDUCOPYX,X STA VDUCOPYX,X
BCS COPYSWAP3 ; CS=Copy TEXT to COPY
TYA TYA
STA VDUTEXTX,X STA VDUTEXTX,X
COPYSWAP3 DEX DEX
BPL COPYSWAPLP BPL COPYSWAPLP
COPYSWAP4 RTS RTS
* Clear to EOL * Clear to EOL
CLREOL LDA ROW CLREOL LDA ROW
@ -124,7 +100,6 @@ CLREOL LDA ROW
RTS RTS
* Clear the screen * Clear the screen
VDUINIT
CLEAR STZ ROW CLEAR STZ ROW
STZ COL STZ COL
:L1 JSR CLREOL :L1 JSR CLREOL
@ -194,14 +169,14 @@ PRCHR6 EOR #$80 ; Convert character
RTS RTS
* PHA * PHA
* LDA $C000 ; Kbd data/strobe * LDA $C000 ; Kbd data/strobe
* BMI :KEYHIT * BMI :KEYHIT
* :RESUME LDA ROW * :RESUME LDA ROW
* ASL * ASL
* TAX * TAX
* LDA SCNTAB,X ; LSB of row address * LDA SCNTAB,X ; LSB of row address
* STA ZP1 * STA ZP1
* LDA SCNTAB+1,X ; MSB of row address * LDA SCNTAB+1,X ; MSB of row address
* STA ZP1+1 * STA ZP1+1
* LDA COL * LDA COL
* BIT $C01F * BIT $C01F
@ -212,25 +187,25 @@ PRCHR6 EOR #$80 ; Convert character
*:S1 TAY *:S1 TAY
* PLA * PLA
* EOR #$80 * EOR #$80
* STA (ZP1),Y ; Screen address * STA (ZP1),Y ; Screen address
* >>> WRTAUX * >>> WRTAUX
* RTS * RTS
*:KEYHIT STA $C010 ; Clear strobe *:KEYHIT STA $C010 ; Clear strobe
* AND #$7F * AND #$7F
* CMP #$13 ; Ctrl-S * CMP #$13 ; Ctrl-S
* BEQ :PAUSE * BEQ :PAUSE
* CMP #$1B ; Esc * CMP #$1B ; Esc
* BNE :RESUME * BNE :RESUME
*:ESC SEC *:ESC SEC
* ROR ESCFLAG ; Set ESCFLAG * ROR ESCFLAG ; Set ESCFLAG
* BRA :RESUME * BRA :RESUME
*:PAUSE STA $C010 ; Clear strobe *:PAUSE STA $C010 ; Clear strobe
*:L1 LDA $C000 ; Kbd data/strobe *:L1 LDA $C000 ; Kbd data/strobe
* BPL :L1 * BPL :L1
* AND #$7F * AND #$7F
* CMP #$11 ; Ctrl-Q * CMP #$11 ; Ctrl-Q
* BEQ :RESUME * BEQ :RESUME
* CMP #$1B ; Esc * CMP #$1B ; Esc
* BEQ :ESC * BEQ :ESC
* BRA :PAUSE * BRA :PAUSE
@ -264,11 +239,11 @@ GETCHROK RTS
* BPL :S1A ; 40-col * BPL :S1A ; 40-col
* LSR * LSR
* BCC :S1 * BCC :S1
*:S1A STA $C002 ; Read main memory *:S1A STA $C002 ; Read main memory
*:S1 TAY *:S1 TAY
* LDA (ZP1),Y * LDA (ZP1),Y
* EOR #$80 * EOR #$80
* STA $C003 ; Read aux mem again * STA $C003 ; Read aux mem again
* TAX * TAX
* LDY #$00 * LDY #$00
* BIT $C01F * BIT $C01F
@ -371,26 +346,23 @@ OUTCHARGO CMP #$00 ; NULL
BNE :T5 BNE :T5
LDA ROW LDA ROW
CMP #23 CMP #23
BEQ :TOSCROLL BEQ SCROLL
INC ROW INC ROW
:IDONE RTS :IDONE RTS
; BRA :DONE ; BRA :DONE
:TOSCROLL JMP SCROLL
:T5 CMP #$0B ; Cursor up :T5 CMP #$0B ; Cursor up
BNE :T6 BNE :T6
LDA ROW LDA ROW
BEQ :IDONE BEQ :IDONE
DEC ROW DEC ROW
; BRA :IDONE BRA :IDONE
RTS
:T6 CMP #$0D ; Carriage return :T6 CMP #$0D ; Carriage return
BNE :T7 BNE :T7
LDA #$BF LDA #$BF
AND VDUSTATUS AND VDUSTATUS
STA VDUSTATUS ; Turn copy cursor off STA VDUSTATUS ; Turn copy cursor off
STZ COL STZ COL
; BRA :IDONE BRA :IDONE
RTS
:T7 CMP #$0C ; Ctrl-L :T7 CMP #$0C ; Ctrl-L
BEQ :T7A BEQ :T7A
CMP #$16 ; MODE CMP #$16 ; MODE
@ -401,34 +373,16 @@ OUTCHARGO CMP #$00 ; NULL
TAX TAX
STA $C00C,X STA $C00C,X
:T7A JSR CLEAR :T7A JSR CLEAR
; BRA :IDONE BRA :IDONE
RTS
:T8 CMP #$1E ; Home :T8 CMP #$1E ; Home
BNE :T9 BNE :T9
STZ ROW STZ ROW
STZ COL STZ COL
; BRA :IDONE BRA :IDONE
RTS :T9 CMP #$7F ; Delete
:T9 CMP #$1F ; TAB
BNE :T9B
LDY VDUQ+8
CPY #24
BCS :IDONE
LDX VDUQ+7
CPX #80
BCS :IDONE
BIT $C01F
BMI :T9A
CPX #80
BCS :IDONE
:T9A STX COL
STY ROW
RTS
:T9B CMP #$7F ; Delete
BNE :T10 BNE :T10
JSR DELETE JSR DELETE
; BRA :IDONE BRA :IDONE
RTS
:T10 CMP #$20 :T10 CMP #$20
BCC :IDONE BCC :IDONE
JSR PRCHRC ; Store char, checking keypress JSR PRCHRC ; Store char, checking keypress
@ -498,5 +452,3 @@ SCNTAB DW $800,$880,$900,$980,$A00,$A80,$B00,$B80
DW $828,$8A8,$928,$9A8,$A28,$AA8,$B28,$BA8 DW $828,$8A8,$928,$9A8,$A28,$AA8,$B28,$BA8
DW $850,$8D0,$950,$9D0,$A50,$AD0,$B50,$BD0 DW $850,$8D0,$950,$9D0,$A50,$AD0,$B50,$BD0