Apple-2-SW/Applecorn
1
0
Fork 0
mirror of https://github.com/bobbimanners/Applecorn.git synced 2024-06-03 03:29:38 +00:00
Code Issues Projects Releases Wiki Activity

Update .po disk image.

Browse Source
This commit is contained in:
Bobbi Webber-Manners 2021-09-17 17:51:11 -04:00
parent 3a297929fc
commit 80c4a99032
19 changed files with 485 additions and 455 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
applecorn.po
View File

Binary file not shown.

2
applecorn.s
View File

@ -202,3 +202,5 @@ MAINZP MAC

2
auxmem.bytwrd.s
View File

@ -472,3 +472,5 @@ OSBM2 ASC ').'

900
auxmem.chario.s
View File

@ -1,449 +1,451 @@
* AUXMEM.CHARIO.S * AUXMEM.CHARIO.S
* (c) Bobbi 2021 GPLv3 * (c) Bobbi 2021 GPLv3
* *
* AppleMOS Character I/O * AppleMOS Character I/O
* KERNEL/CHARIO.S * KERNEL/CHARIO.S
***************** *****************
* Character read and write * Character read and write
* *
* 14-Aug-2021 Flashing cursor and INKEY sync'd to frame rate * 14-Aug-2021 Flashing cursor and INKEY sync'd to frame rate
* with VBLK. Ensured cursor turned on straightaway. * with VBLK. Ensured cursor turned on straightaway.
* 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. * 16-Aug-2021 Copy cursor and Edit cursor visible.
* 17-Aug-2021 OSBYTE 4 for cursors, OSBYTE 221-228 for topbit * 17-Aug-2021 OSBYTE 4 for cursors, OSBYTE 221-228 for topbit
* keys. * keys.
* 21-Aug-2021 FIXED: If screen scrolls, copy cursor ends on * 21-Aug-2021 FIXED: If screen scrolls, copy cursor ends on
* wrong line. * wrong line.
* FIXED: KBDREAD has several paths that don't * FIXED: KBDREAD has several paths that don't
* test ESCHAR. * test ESCHAR.
* FIXED: INKEY doesn't restore cursor on timeout. * FIXED: INKEY doesn't restore cursor on timeout.
* The three separate cursors can be set seperately. * The three separate cursors can be set seperately.
* 02-Sep-2021 INKEY-256 tests Apple IIe vs IIc. * 02-Sep-2021 INKEY-256 tests Apple IIe vs IIc.
* 05-Sep-2021 KBDINIT returns startup value to pass to VDUINT. * 05-Sep-2021 KBDINIT returns startup value to pass to VDUINT.
* 09-Sep-2021 Moved keyboard OSBYTEs to here. * 09-Sep-2021 Moved keyboard OSBYTEs to here.
* 12-Sep-2021 COPY calls new VDU entry point. * 12-Sep-2021 COPY calls new VDU entry point.
* 15-Sep-2021 INKEY(0) tests once and returns immediately. * 15-Sep-2021 INKEY(0) tests once and returns immediately.
* TO DO: move these to VDU * TO DO: move these to VDU
OLDCHAR EQU OSKBD1 ; *TEMP* ; character under cursor OLDCHAR EQU OSKBD1 ; *TEMP* ; character under cursor
* COPYCHAR EQU OSKBD2 ; *TEMP* ; character under copy cursor * COPYCHAR EQU OSKBD2 ; *TEMP* ; character under copy cursor
FLASHER EQU BYTEVARBASE+176 ; VSync counter for flashing cursor FLASHER EQU BYTEVARBASE+176 ; VSync counter for flashing cursor
FXEXEC EQU BYTEVARBASE+198 FXEXEC EQU BYTEVARBASE+198
FXSPOOL EQU BYTEVARBASE+199 FXSPOOL EQU BYTEVARBASE+199
FXTABCHAR EQU BYTEVARBASE+219 FXTABCHAR EQU BYTEVARBASE+219
FXESCCHAR EQU BYTEVARBASE+220 FXESCCHAR EQU BYTEVARBASE+220
FXKEYBASE EQU BYTEVARBASE+221 FXKEYBASE EQU BYTEVARBASE+221
FXESCON EQU BYTEVARBASE+229 FXESCON EQU BYTEVARBASE+229
FXESCEFFECT EQU BYTEVARBASE+230 FXESCEFFECT EQU BYTEVARBASE+230
FX200VAR EQU BYTEVARBASE+200 FX200VAR EQU BYTEVARBASE+200
FX254VAR EQU BYTEVARBASE+254 FX254VAR EQU BYTEVARBASE+254
FX2VAR EQU BYTEVARBASE+$B1 FX2VAR EQU BYTEVARBASE+$B1
FX3VAR EQU BYTEVARBASE+$EC FX3VAR EQU BYTEVARBASE+$EC
FX4VAR EQU BYTEVARBASE+$ED FX4VAR EQU BYTEVARBASE+$ED
* OSWRCH handler * OSWRCH handler
**************** ****************
* Send a character to current output * Send a character to current output
* All registers preserved * All registers preserved
* *
WRCHHND PHA WRCHHND PHA
PHX PHX
PHY PHY
* TO DO Check any output redirections * TO DO Check any output redirections
* TSX * TSX
* LDA $103,X * LDA $103,X
* PHA * PHA
JSR OUTCHAR JSR OUTCHAR
* TO DO Check any printer output * TO DO Check any printer output
* BCC WRCHHND3 * BCC WRCHHND3
* PLA * PLA
* PHA * PHA
* JSR PRNCHAR * JSR PRNCHAR
* WRCHHND3 * WRCHHND3
* TO DO Check any spool output * TO DO Check any spool output
* LDY FXSPOOL * LDY FXSPOOL
* BEQ WRCHHND4 * BEQ WRCHHND4
* PLA * PLA
* PHA * PHA
* JSR OSBPUT * JSR OSBPUT
* WRCHHND4 * WRCHHND4
* PLA * PLA
* *
PLY PLY
PLX PLX
PLA PLA
RTS RTS
* Character Input * Character Input
***************** *****************
* Default keyboard OSBYTE variables * Default keyboard OSBYTE variables
*DEFBYTELOW EQU 219 ; First default OSBYTE value *DEFBYTELOW EQU 219 ; First default OSBYTE value
*DEFBYTE DB $09,$1B ; Default key codes *DEFBYTE DB $09,$1B ; Default key codes
* DB $01,$D0,$E0,$F0 ; Default key expansion * DB $01,$D0,$E0,$F0 ; Default key expansion
* DB $01,$80,$90,$00 ; Default key expansion * DB $01,$80,$90,$00 ; Default key expansion
*DEFBYTEEND *DEFBYTEEND
* TEMP as no *KEY * TEMP as no *KEY
* Default keyboard OSBYTE variables * Default keyboard OSBYTE variables
DEFBYTELOW EQU 219 ; First default OSBYTE value DEFBYTELOW EQU 219 ; First default OSBYTE value
DEFBYTE DB $09,$1B ; Default key codes DEFBYTE DB $09,$1B ; Default key codes
DB $C0,$D0,$E0,$F0 ; Default key expansion DB $C0,$D0,$E0,$F0 ; Default key expansion
DB $80,$90,$A0,$B0 ; Default key expansion DB $80,$90,$A0,$B0 ; Default key expansion
DEFBYTEEND DEFBYTEEND
KBDINIT LDX #DEFBYTEEND-DEFBYTE-1 KBDINIT LDX #DEFBYTEEND-DEFBYTE-1
:KBDINITLP LDA DEFBYTE,X ; Initialise KBD OSBYTE variables :KBDINITLP LDA DEFBYTE,X ; Initialise KBD OSBYTE variables
STA BYTEVARBASE+DEFBYTELOW,X STA BYTEVARBASE+DEFBYTELOW,X
DEX DEX
BPL :KBDINITLP BPL :KBDINITLP
LDX #$C0 LDX #$C0
STX FX254VAR ; b7-b4=default KBD map, b3-b0=default MODE STX FX254VAR ; b7-b4=default KBD map, b3-b0=default MODE
BIT SETV BIT SETV
JSR KBDTEST JSR KBDTEST
BCS :KBDINITOK ; Return default MODE=0 BCS :KBDINITOK ; Return default MODE=0
STA $C010 ; Ack. keypress STA $C010 ; Ack. keypress
TAX ; Use keypress as default MODE TAX ; Use keypress as default MODE
:KBDINITOK TXA :KBDINITOK TXA
RTS RTS
* OSRDCH/INKEY handler * OSRDCH/INKEY handler
********************** **********************
* Read a character from current input * Read a character from current input
* All registers preserved except A, Carry * All registers preserved except A, Carry
* Flashes a soft cursor while waiting for input * Flashes a soft cursor while waiting for input
* *
RDCHHND LDA #$80 ; flag=wait forever RDCHHND LDA #$80 ; flag=wait forever
PHY PHY
TAY TAY
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
BIT VDUSTATUS ; Enable editing cursor BIT VDUSTATUS ; Enable editing cursor
BVC INKEYGO2 ; No editing cursor BVC INKEYGO2 ; No editing cursor
JSR GETCHRC ; Get character under cursor JSR GETCHRC ; Get character under cursor
STA COPYCHAR ; Save char under edit cursor STA COPYCHAR ; Save char under edit cursor
LDA CURSORED LDA CURSORED
JSR PUTCHRC ; Display edit cursor JSR PUTCHRC ; Display edit cursor
JSR COPYSWAP1 ; Swap to copy cursor JSR COPYSWAP1 ; Swap to copy cursor
INKEYGO2 JSR GETCHRC ; Get character under cursor INKEYGO2 JSR GETCHRC ; Get character under cursor
STA OLDCHAR STA OLDCHAR
CLI CLI
BRA INKEY1 ; Turn cursor on BRA INKEY1 ; Turn cursor on
INKEYLP CLC INKEYLP CLC
LDA #$01 ; Slow flash, every 32 frames LDA #$01 ; Slow flash, every 32 frames
BIT VDUSTATUS BIT VDUSTATUS
BVC INKEY0 BVC INKEY0
ASL A ; Fast flash, every 16 frames ASL A ; Fast flash, every 16 frames
INKEY0 ADC FLASHER INKEY0 ADC FLASHER
STA FLASHER STA FLASHER
AND #15 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
BIT VDUSTATUS BIT VDUSTATUS
BVC INKEY2 BVC INKEY2
LDA CURSORCP LDA CURSORCP
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
PLY PLY
BCC INKEYOK ; Char returned, return it BCC INKEYOK ; Char returned, return it
BMI INKEY6 ; Loop forever, skip countdown BMI INKEY6 ; Loop forever, skip countdown
PLX PLX
BNE INKEY5 BNE INKEY5
TYA TYA
BEQ INKEYOUT ; XY=0, timed out BEQ INKEYOUT ; XY=0, timed out
DEY ; 16-bit decrement DEY ; 16-bit decrement
INKEY5 DEX INKEY5 DEX
PHX PHX
INKEY6 PHY INKEY6 PHY
* *
* VBLK pulses at 50Hz/60Hz, toggles at 100Hz/120Hz * VBLK pulses at 50Hz/60Hz, toggles at 100Hz/120Hz
LDX $C019 ; Get initial VBLK state LDX $C019 ; Get initial VBLK state
INKEY8 BIT $C000 INKEY8 BIT $C000
BMI INKEY4 ; Key pressed BMI INKEY4 ; Key pressed
TXA TXA
EOR $C019 EOR $C019
BPL INKEY8 ; Wait for VBLK change BPL INKEY8 ; Wait for VBLK change
BMI INKEYLP ; Loop back to key test BMI INKEYLP ; Loop back to key test
INKEYOUT PLA ; Drop stacked Y INKEYOUT PLA ; Drop stacked Y
LDA #$FF ; Prepare to stack $FF LDA #$FF ; Prepare to stack $FF
* *
INKEYOK PHA ; Save key or timeout INKEYOK PHA ; Save key or timeout
PHP ; Save CC=key, CS=timeout PHP ; Save CC=key, CS=timeout
LDA OLDCHAR ; Prepare for main cursor LDA OLDCHAR ; Prepare for main cursor
BIT VDUSTATUS BIT VDUSTATUS
BVC INKEYOFF2 ; No editing cursor BVC INKEYOFF2 ; No editing cursor
JSR PUTCHRC ; Remove cursor JSR PUTCHRC ; Remove cursor
JSR COPYSWAP1 ; Swap cursor back JSR COPYSWAP1 ; Swap cursor back
LDA COPYCHAR ; Remove main cursor LDA COPYCHAR ; Remove main cursor
INKEYOFF2 JSR PUTCHRC ; Remove cursor INKEYOFF2 JSR PUTCHRC ; Remove cursor
* *
PLP PLP
BCS INKEYOK3 ; Timeout BCS INKEYOK3 ; Timeout
LDA ESCFLAG ; Keypress, test for Escape LDA ESCFLAG ; Keypress, test for Escape
ASL A ; Cy=Escape flag ASL A ; Cy=Escape flag
PLA ; Get char back PLA ; Get char back
PLX ; Restore X,Y for key pressed PLX ; Restore X,Y for key pressed
INKEYOK3 PLY ; Or pop TimeOut INKEYOK3 PLY ; Or pop TimeOut
RTS RTS
* RDCH Character read: CC, A=char, X=restored, Y=restored * RDCH Character read: CC, A=char, X=restored, Y=restored
* RDCH Escape: CS, A=char, X=restored, Y=restored * RDCH Escape: CS, A=char, X=restored, Y=restored
* INKEY Character read: CC, A=char, X=???, Y<$80 * INKEY Character read: CC, A=char, X=???, Y<$80
* INKEY Escape: CS, A=char, X=???, Y<$80 * INKEY Escape: CS, A=char, X=???, Y<$80
* INKEY Timeout: CS, A=???, X=???, Y=$FF * INKEY Timeout: CS, A=???, X=???, Y=$FF
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
* Character read: CC, A=char, X=???, Y<$80 * Character read: CC, A=char, X=???, Y<$80
* Escape: CS, A=char, X=???, Y<$80 * Escape: CS, A=char, X=???, Y<$80
* Timeout: CS, A=???, X=???, Y=$FF * Timeout: CS, A=???, X=???, Y=$FF
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=???, CS - timeout * Returns: Y=$FF, X=???, 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 CPX #$01 NEGINKEY CPX #$01
LDX #$00 ; Unimplemented LDX #$00 ; Unimplemented
BCS NEGINKEY0 BCS NEGINKEY0
JSR NEGCALL ; Read machine ID from aux JSR NEGCALL ; Read machine ID from aux
TAX ; *TEST* TAX ; *TEST*
BIT $E0 ; *TEST* BIT $E0 ; *TEST*
BVS NEGINKEY1 ; *TEST* BVS NEGINKEY1 ; *TEST*
LDX #$2C LDX #$2C
TAY TAY
BEQ NEGINKEY0 ; $00 = Apple IIc -> INKEY-256 = $2C BEQ NEGINKEY0 ; $00 = Apple IIc -> INKEY-256 = $2C
LDX #$2E LDX #$2E
AND #$0F AND #$0F
BEQ NEGINKEY0 ; $x0 = Apple IIe -> INKEY-256 = $2E BEQ NEGINKEY0 ; $x0 = Apple IIe -> INKEY-256 = $2E
LDX #$2A ; else = Apple IIgs -> INKEY-256 = $2A LDX #$2A ; else = Apple IIgs -> INKEY-256 = $2A
NEGINKEY0 LDY #$00 NEGINKEY0 LDY #$00
NEGINKEY1 CLC NEGINKEY1 CLC
RTS RTS
NEGCALL >>> XF2MAIN,MACHRD ; Try to read Machine ID NEGCALL >>> XF2MAIN,MACHRD ; Try to read Machine ID
* KERNEL/KEYBOARD.S * KERNEL/KEYBOARD.S
******************* *******************
* KEYREAD * KEYREAD
************************ ************************
* Test for and read from input, * Test for and read from input,
* expanding keyboard special keys * expanding keyboard special keys
* *
* On exit, CS=no keypress * On exit, CS=no keypress
* CC=keypress * CC=keypress
* A =keycode, X,Y=corrupted * A =keycode, X,Y=corrupted
KEYREAD KEYREAD
* TO DO: check *EXEC source * TO DO: check *EXEC source
* LDY FXEXEC * LDY FXEXEC
* BEQ KEYREAD1 * BEQ KEYREAD1
* JSR OSBGET * JSR OSBGET
* BCC KEYREADOK * BCC KEYREADOK
* LDA #0 * LDA #0
* STA FXVAREXEC * STA FXVAREXEC
* JSR OSFIND * JSR OSFIND
* KEYREAD1 * KEYREAD1
* *
* TO DO: expand current soft key * TO DO: expand current soft key
* LDA SOFTKEYLEN * LDA SOFTKEYLEN
* BEQ KEYREAD2 * BEQ KEYREAD2
* LDX SOFTKEYOFF * LDX SOFTKEYOFF
* LDA SOFTKEYS,X * LDA SOFTKEYS,X
* INC SOFTKEYOFF * INC SOFTKEYOFF
* DEC SOFTKEYLEN * DEC SOFTKEYLEN
* CLC * CLC
* RTS * RTS
* KEYREAD2 * KEYREAD2
* *
JSR KBDREAD ; Fetch character from KBD "buffer" JSR KBDREAD ; Fetch character from KBD "buffer"
BCS KEYREADOK ; Nothing pending BCS KEYREADOK ; Nothing pending
* *
TAY TAY
BPL KEYREADOK ; Not top-bit key BPL KEYREADOK ; Not top-bit key
AND #$CF AND #$CF
CMP #$C9 CMP #$C9
BCC KEYSOFT ; Not cursor key BCC KEYSOFT ; Not cursor key
LDX FX4VAR LDX FX4VAR
BEQ KEYCURSOR ; *FX4,0 - editing keys BEQ KEYCURSOR ; *FX4,0 - editing keys
DEX DEX
BNE KEYSOFT1 ; Not *FX4,1 - soft key BNE KEYSOFT1 ; Not *FX4,1 - soft key
LDY FXTABCHAR LDY FXTABCHAR
CMP #$C9 CMP #$C9
BEQ KEYREADOKY ; TAB key BEQ KEYREADOKY ; TAB key
SBC #$44 ; Return $88-$8B SBC #$44 ; Return $88-$8B
TAY TAY
KEYREADOKY TYA KEYREADOKY TYA
KEYREADOK1 CLC KEYREADOK1 CLC
KEYREADOK RTS KEYREADOK RTS
* *
* Process soft key * Process soft key
KEYSOFT1 LDX FX254VAR KEYSOFT1 LDX FX254VAR
CPX #$C0 CPX #$C0
BCC KEYSOFT BCC KEYSOFT
AND #$BF AND #$BF
TAY TAY
KEYSOFT TYA KEYSOFT TYA
LSR A LSR A
LSR A LSR A
LSR A LSR A
LSR A ; A=key DIV 16 LSR A ; A=key DIV 16
EOR #$04 ; Offset into KEYBASE EOR #$04 ; Offset into KEYBASE
TAX TAX
LDA FXKEYBASE-8,X LDA FXKEYBASE-8,X
* TO DO: * TO DO:
*BEQ KEYNONE ; $00=ignored *BEQ KEYNONE ; $00=ignored
*DEC A *DEC A
*BEQ expandfunction *BEQ expandfunction
CMP #2 ; *TEMP* CMP #2 ; *TEMP*
BCC KEYNONE ; *TEMP* BCC KEYNONE ; *TEMP*
TYA TYA
AND #$0F AND #$0F
CLC CLC
ADC FXKEYBASE-8,X ADC FXKEYBASE-8,X
CLC CLC
RTS RTS
* Process cursor keys * Process cursor keys
KEYCURSOR CMP #$C9 KEYCURSOR CMP #$C9
BEQ KEYCOPY BEQ KEYCOPY
PHA PHA
LDA OLDCHAR LDA OLDCHAR
JSR PUTCHRC ; Remove cursor JSR PUTCHRC ; Remove cursor
PLA PLA
JSR COPYMOVE ; Move copy cursor JSR COPYMOVE ; Move copy cursor
JSR GETCHRC ; Save char under cursor JSR GETCHRC ; Save char under cursor
STA OLDCHAR STA OLDCHAR
KEYNONE SEC KEYNONE SEC
RTS RTS
KEYCOPY LDA FXTABCHAR ; Prepare TAB if no copy cursor KEYCOPY LDA FXTABCHAR ; Prepare TAB if no copy cursor
BIT VDUSTATUS BIT VDUSTATUS
BVC KEYREADOK1 ; No copy cursor, return TAB BVC KEYREADOK1 ; No copy cursor, return TAB
LDA OLDCHAR ; Get the char under cursor LDA OLDCHAR ; Get the char under cursor
PHA PHA
JSR OUTCHARCP ; Output it to restore and move cursor JSR OUTCHARCP ; Output it to restore and move cursor
JSR GETCHRC ; Save char under cursor JSR GETCHRC ; Save char under cursor
STA OLDCHAR STA OLDCHAR
PLA PLA
BNE KEYREADOK1 ; Ok character BNE KEYREADOK1 ; Ok character
SEC SEC
JMP BEEP ; Beep and return CS=No char JMP BEEP ; Beep and return CS=No char
* KBDREAD * KBDREAD
************************ ************************
* Test for and fetch key from keyboard * Test for and fetch key from keyboard
* *
* On exit, CS=no keypress * On exit, CS=no keypress
* CC=keypress * CC=keypress
* A =keycode, X=corrupted * A =keycode, X=corrupted
* Apple+Letter -> Ctrl+Letter * Apple+Letter -> Ctrl+Letter
* Apple+Digits -> 80+x, 90+x, A0+x * Apple+Digits -> 80+x, 90+x, A0+x
* 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 ; TAB is dual action TAB/COPY BEQ KBDTAB ; TAB is dual action TAB/COPY
CMP #$08 CMP #$08
BCC KBDCHKESC ; <$08 not cursor key BCC KBDCHKESC ; <$08 not cursor key
CMP #$0C CMP #$0C
BCC KBDCURSR ; $08-$0B are cursor keys BCC KBDCURSR ; $08-$0B are cursor keys
CMP #$15 CMP #$15
BNE KBDCHKESC ; $15 is cursor key BNE KBDCHKESC ; $15 is cursor key
* *
KBDCUR15 LDA #$0D ; Convert RGT to $09 KBDCUR15 LDA #$0D ; Convert RGT to $09
KBDTAB SBC #$04 ; Convert TAB to &C9 KBDTAB SBC #$04 ; Convert TAB to &C9
KBDCURSR CLC KBDCURSR CLC
ADC #$C4 ; Cursor keys $C0+x ADC #$C4 ; Cursor keys $C0+x
BRA KBDCHKESC BRA KBDCHKESC
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 KBDCHKESC ; <'0' BCC KBDCHKESC ; <'0'
CMP #$3A CMP #$3A
BCS KBDCHKESC ; >'9' BCS KBDCHKESC ; >'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 KBDCHKESC ; Left+Digit -> $8x BPL KBDCHKESC ; Left+Digit -> $8x
ORA #$90 ; Right+Digit -> $9x ORA #$90 ; Right+Digit -> $9x
BIT $C061 BIT $C061
BPL KBDCHKESC BPL KBDCHKESC
EOR #$30 ; Left+Right+Digit -> $Ax EOR #$30 ; Left+Right+Digit -> $Ax
BRA KBDCHKESC BRA KBDCHKESC
KBDCTRL AND #$1F ; Apple-Letter -> Ctrl-Letter KBDCTRL AND #$1F ; Apple-Letter -> Ctrl-Letter
* *
* Test for Escape key * Test for Escape key
KBDCHKESC TAX ; X=keycode KBDCHKESC TAX ; X=keycode
EOR FXESCCHAR ; Current ESCAPE char? EOR FXESCCHAR ; Current ESCAPE char?
ORA FXESCON ; Is ESCAPE an ASCII char? ORA FXESCON ; Is ESCAPE an ASCII char?
BNE KBDNOESC ; Not ESCAPE or ESCAPE=ASCII BNE KBDNOESC ; Not ESCAPE or ESCAPE=ASCII
LDA FX200VAR ; Is ESCAPE ignored? LDA FX200VAR ; Is ESCAPE ignored?
LSR A ; Check bit 0 LSR A ; Check bit 0
BCS KBDDONE ; ESCAPE completely ignored BCS KBDDONE ; ESCAPE completely ignored
SEC SEC
ROR ESCFLAG ; Set Escape flag ROR ESCFLAG ; Set Escape flag
KBDNOESC TXA ; A=keycode KBDNOESC TXA ; A=keycode
CLC ; CLC=Ok CLC ; CLC=Ok
KBDDONE RTS KBDDONE RTS
* Process pending Escape state * Process pending Escape state
BYTE7E LDX #$00 ; $7E = ack detection of ESC BYTE7E LDX #$00 ; $7E = ack detection of ESC
BIT ESCFLAG BIT ESCFLAG
BPL BYTE7DOK ; No Escape pending BPL BYTE7DOK ; No Escape pending
LDA FXESCEFFECT ; Process Escape effects LDA FXESCEFFECT ; Process Escape effects
BEQ BYTE7E2 BEQ BYTE7E2
CLI ; Allow IRQs while flushing CLI ; Allow IRQs while flushing
STA FXLINES ; Clear scroll counter STA FXLINES ; Clear scroll counter
* JSR STAREXEC0 ; Close any EXEC file * JSR STAREXEC0 ; Close any EXEC file
* JSR FLUSHALL ; Flush all buffers * JSR FLUSHALL ; Flush all buffers
BYTE7E2 LDX #$FF ; X=$FF, Escape was pending BYTE7E2 LDX #$FF ; X=$FF, Escape was pending
BYTE7C CLC ; &7C = clear escape condition BYTE7C CLC ; &7C = clear escape condition
BYTE7D ROR ESCFLAG ; $7D = set escape condition BYTE7D ROR ESCFLAG ; $7D = set escape condition
BYTE7DOK RTS BYTE7DOK RTS
BYTE76 LDX #$00 ; Update LEDs and return X=SHIFT BYTE76 LDX #$00 ; Update LEDs and return X=SHIFT
RTS ; Not possible with Apple RTS ; Not possible with Apple

2
auxmem.hostfs.s
View File

@ -946,6 +946,8 @@ ERROR2E DW $C800

6
auxmem.init.s
View File

@ -177,10 +177,6 @@ BYTE00XX BEQ BYTE00A ; OSBYTE 0,0 - generate error
RTS ; %000x1xxx host type, 'A'pple RTS ; %000x1xxx host type, 'A'pple
BYTE00A BRK BYTE00A BRK
DB $F7 DB $F7
HELLO ASC 'Applecorn MOS 2021-09-16 snapshot' HELLO ASC 'Applecorn MOS 2021-09-17'
DB $00 ; Unify MOS messages DB $00 ; Unify MOS messages

2
auxmem.misc.s
View File

@ -497,6 +497,8 @@ AUXBLK ASC '**ENDOFCODE**'

2
auxmem.mosequ.s
View File

@ -68,3 +68,5 @@ COPYCHAR EQU OSKBD2 ; ** TEMP **
* $0300-$03DF * $0300-$03DF
* $03E0-$03FF Used for interfacing with ProDOS XFER * $03E0-$03FF Used for interfacing with ProDOS XFER

2
auxmem.oscli.s
View File

@ -531,3 +531,5 @@ ECHOLP1 JSR GSREAD

2
auxmem.vdu.s
View File

@ -623,3 +623,5 @@ BYTEA0 LDY #79 ; Read VDU variable $09,$0A

2
mainmem.fsequ.s
View File

@ -62,3 +62,5 @@ GEOFCMD EQU $D1

2
mainmem.init.s
View File

@ -107,4 +107,6 @@ RESET TSX

2
mainmem.ldr.s
View File

@ -134,6 +134,8 @@ CANTOPEN ASC "Unable to open ROM file"

2
mainmem.lists.s
View File

@ -126,3 +126,5 @@ QUITPL HEX 04 ; Number of parameters

2
mainmem.menu.s
View File

@ -140,6 +140,8 @@ ROM8 STR "USERROM2.ROM"

2
mainmem.misc.s
View File

@ -188,5 +188,7 @@ FILEREFS DB $00,$00,$00,$00

4
mainmem.path.s
View File

@ -41,7 +41,7 @@ PREPATH LDX MOSFILE ; Length
:NOTCOLN JSR GETPREF ; Current pfx -> PREFIX :NOTCOLN JSR GETPREF ; Current pfx -> PREFIX
:REENTER LDA MOSFILE+1 ; First char of dirname :REENTER LDA MOSFILE+1 ; First char of dirname
CMP #'@' ; '@' means current working dir CMP #'@' ; '@' means current working dir
BEQ :CWD BEQ :CWD
CMP #'^' ; '^' means parent dir CMP #'^' ; '^' means parent dir
BEQ :CARET BEQ :CARET
CMP #'/' ; Absolute path CMP #'/' ; Absolute path
@ -307,3 +307,5 @@ PREFIX DS 65 ; Buffer for ProDOS prefix

2
mainmem.svc.s
View File

@ -1060,3 +1060,5 @@ MAINRDEXIT >>> XF2AUX,NULLRTS ; Back to an RTS

2
mainmem.wild.s
View File

@ -384,3 +384,5 @@ MATCHBUF DS 65 ; For storing match results (Pascal str)