;
; The Complete Commodore 1551 ROM disassembly
; by Attila Grósz
; http://yape.plus4.net
; grosza_AT_hotmail_DOT_com
;
; revision 0
;
; Based on 1541 ROM disassembly from AAY1541
;
;
; ROM is mapped between $C000-$FFFF in the drive memory
ORG $C000 - 2
DW $C000
; Zeropage vectors
zp0E = $0E ;(3)
zp12 = $12 ;(1)
zp15 = $15 ;(7)
zp1E = $1E ;(24)
zp20 = $20 ;(37)
zp27 = $27 ;(38) address of current buffer
zp32 = $32 ;(3)
zp34 = $34 ;(3)
zp45 = $45 ;(9)
zp49 = $49 ;(15)
zp4E = $4E ;(6)
zp59 = $59 ;(4)
zp6A = $6A ;(3)
zp6C = $6C ;(25)
zp6E = $6E ;(79)
zp70 = $70 ;(22)
zp74 = $74 ;(8)
zp7F = $7F ;(42) counter for erased files
zp81 = $81 ;(17)
zp82 = $82 ;(11)
zp8D = $8D ;(85)
zpA4 = $A4 ;(9) Pointer: Next byte in command buffer [0200]
zpA6 = $A6 ;(10)
zpC0 = $C0 ;(4)
zpC4 = $C4 ;(3)
zpC9 = $C9 ;(2)
zpCB = $CB ;(1)
zpE5 = $E5 ;(1)
;-------------------
; Zeropage variables
;-------------------
;
zp00 = $00 ;(9) cpu data direction register
zp01 = $01 ;(65) cpu port, FDC control register
; bit 0: drive head stepper 0 (STP)
; bit 1: drive head stepper 1 (STP)
; bit 2: drive motor on/off (MTR)
; bit 3: drive LED (ACT)
; bit 4: write protect sensor (WPS)
; bit 5: density select #0 (DS0)
; bit 6: density select #1 (DS1)
; bit 7: byte latched (1 - yes, 0 - no)
;
zp02 = $02 ;(14) Command code for buffer 0
zp03 = $03 ;(2) Command code for buffer 1
zp04 = $04 ;(3) Command code for buffer 2
zp05 = $05 ;(1) Command code for buffer 3
zp06 = $06 ;(6) Command code for buffer 4
zp07 = $07 ;(2) Command code for buffer 5 (unused)
zp08 = $08 ;(6) Track and sector for buffer 0
zp09 = $09 ;(5)
zp0A = $0A ;(2) Track and sector for buffer 1
zp0C = $0C ;(1) Track and sector for buffer 2
zp14 = $14 ;(6) disk id 1
zp18 = $18 ;(6) block header id 1
zp19 = $19 ;(6) block header id 2
zp1A = $1A ;(5) track blockheader
zp1B = $1B ;(5) sector blockheader
zp1C = $1C ;(3) checksum of block header
zp1D = $1D ;(5) current drive number (always 0)
zp22 = $22 ;(8) write protect flag for drive 0 or 1
zp23 = $23 ;(2) write protect flag for drive 1 (unused)
zp24 = $24 ;(4)
zp26 = $26 ;(1)
zp29 = $29 ;(6) FDC current track
zp2B = $2B ;(14) drive status flag
; bit 5: drive motor
; bit 6: stepper motor
; bit 7: drive ready
zp2D = $2D ;(10)
zp2E = $2E ;(19)
zp2F = $2F ;(2)
zp30 = $30 ;(8)
zp31 = $31 ;(7)
zp36 = $36 ;(4)
zp37 = $37 ;(4)
zp38 = $38 ;(5)
zp39 = $39 ;(7)
zp3A = $3A ;(2) temporary stack storage
zp3B = $3B ;(9) stepper motor direction (<$80 inner, >=$80 outer)
zp3C = $3C ;(6)
zp3D = $3D ;(3) last sector read
zp3E = $3E ;(2) next sector to be read
zp3F = $3F ;(5) GCR/BIN indicator for current buffer
zp40 = $40 ;(11) current track
zp41 = $41 ;(17)
zp42 = $42 ;(18)
zp43 = $43 ;(20)
zp44 = $44 ;(18)
zp47 = $47 ;(4)
zp48 = $48 ;(9)
zp4B = $4B ;(4)
zp4C = $4C ;(3)
zp4D = $4D ;(5)
zp50 = $50 ;(5)
zp51 = $51 ;(3)
zp52 = $52 ;(5)
zp53 = $53 ;(10)
zp54 = $54 ;(9)
zp55 = $55 ;(2) drive LED flash counter
zp56 = $56 ;(2)
zp57 = $57 ;(6)
zp58 = $58 ;(6)
zp5B = $5B ;(4) TALK flag
zp5C = $5C ;(4) LISTEN flag (1/0)
zp5D = $5D ;(4) format string of disk after init (2A)
zp5E = $5E ;(1)
zp5F = $5F ;(6)
zp61 = $61 ;(2) ROM-test checksum
zp62 = $62 ;(4)
zp63 = $63 ;(3)
zp65 = $65 ;(1)
zp66 = $66 ;(3) device number
zp68 = $68 ;(6)
zp69 = $69 ;(4)
zp72 = $72 ;(4)
zp76 = $76 ;(2) LED blink flag (#$E0 = on)
zp77 = $77 ;(2) last track number
zp78 = $78 ;(69) current drive number
zp79 = $79 ;(86) current track
zp7A = $7A ;(83) current sector
zp7B = $7B ;(102) current channel
zp7C = $7C ;(58) secondary address
zp7D = $7D ;(6) secondary address from computer
zp7E = $7E ;(26)
zp84 = $84 ;(7)
zp85 = $85 ;(3)
zp86 = $86 ;(3)
zp87 = $87 ;(2)
zp89 = $89 ;(12)
zp8A = $8A ;(7)
zp8B = $8B ;(2)
zp8C = $8C ;(1)
zp8F = $8F ;(1)
zp91 = $91 ;(5) pointer in record
zp92 = $92 ;(15)
zp93 = $93 ;(14)
zp94 = $94 ;(7)
zp95 = $95 ;(10) EOI
zp96 = $96 ;(2)
zp97 = $97 ;(8)
zp98 = $98 ;(26) buffer number
zp99 = $99 ;(6) Pointer to first filename
zp9A = $9A ;(55)
zp9B = $9B ;(6)
zpA8 = $A8 ;(38)
zpAC = $AC ;(1)
zpAD = $AD ;(2)
zpAE = $AE ;(1)
zpAF = $AF ;(24)
zpB5 = $B5 ;(1)
zpB6 = $B6 ;(10)
zpBC = $BC ;(9)
zpC2 = $C2 ;(13)
zpC8 = $C8 ;(10)
zpCE = $CE ;(18)
zpD2 = $D2 ;(1)
zpD3 = $D3 ;(1)
zpD4 = $D4 ;(4)
zpD8 = $D8 ;(1)
zpD9 = $D9 ;(7)
zpDA = $DA ;(2)
zpDD = $DD ;(1)
zpDE = $DE ;(7)
zpDF = $DF ;(2)
zpE2 = $E2 ;(1)
zpE3 = $E3 ;(18)
zpE4 = $E4 ;(5)
zpE7 = $E7 ;(1)
zpE8 = $E8 ;(18)
zpE9 = $E9 ;(2)
zpEB = $EB ;(1)
zpED = $ED ;(12)
zpF1 = $F1 ;(1)
zpF3 = $F3 ;(13)
zpF7 = $F7 ;(1)
zpF8 = $F8 ;(3)
zpF9 = $F9 ;(12)
zpFA = $FA ;(12)
zpFB = $FB ;(10)
zpFC = $FC ;(4)
zpFD = $FD ;(5)
zpFE = $FE ;(3)
zpFF = $FF ;(9)
;
; GCR overflow area and stack $100-$1ff
;
V_0100 = $0100
V_0101 = $0101
V_0102 = $0102
V_0103 = $0103
V_0111 = $0111
V_0112 = $0112
V_011B = $011B
V_01A9 = $01A9
V_01FF = $01FF
;
; Command buffer, parser, tables, variables $200-$2ff
;
V_0200 = $0200 ; input buffer $0200-$0229 for command string,
L_0201 = $0201
V_0202 = $0202
V_0203 = $0203
V_0204 = $0204
V_0205 = $0205
V_0206 = $0206
V_022A = $022A ; command number temporary storage (Command code)
V_022B = $022B ; Logical index, channel 0
V_022C = $022C ; Logical index, channel 1
V_022D = $022D ; Logical index, channel 2
V_023A = $023A
V_023B = $023B
V_023C = $023C
V_023D = $023D
V_023E = $023E
V_0243 = $0243
V_0244 = $0244
V_0249 = $0249 ; end of error message
V_024A = $024A ; active data/file type
V_024B = $024B ; filename/string length
V_024C = $024C ; Temp. channel number (secondary address)
V_024D = $024D ; Current work with drive number
V_024E = $024E ; Work area to find the best sector
V_024F = $024F ; Buffer allocated
V_0250 = $0250 ; Buffer allocated
V_0251 = $0251 ; Flag: BAM changed, drive 0
V_0253 = $0253 ; Flag for directory entry found (FF = Not found, 00 = Found)
V_0254 = $0254 ; Flag for directory output
V_0255 = $0255 ; Flag: Waiting for command
V_0256 = $0256 ; buffer allocation register
V_0257 = $0257 ; Last used buffer
V_0258 = $0258 ; Record length
V_0259 = $0259 ; Track of side sector
V_025A = $025A ; Sector of side sector
V_025B = $025B ; Last work (buffers) $025B-$025F
V_0260 = $0260 ; Directory sector (buffers) $0260-$0265
V_0266 = $0266 ; File's index in directory (buffers) $0266-$026B
V_026C = $026C ; error flag, counter for led flash?
V_026E = $026E ; last program's drive number
V_026F = $026F ; last sector number
V_0270 = $0270 ; temporary storage for channel number
V_0272 = $0272 ; number of blocks free
V_0273 = $0273
V_0274 = $0274 ; length of filename/input
V_0275 = $0275
V_0276 = $0276
V_0277 = $0277 ; nr of commas
V_0278 = $0278
V_0279 = $0279 ; nr of commas
V_027A = $027A ; pointer to drive number
V_027B = $027B
V_027F = $027F
V_0280 = $0280
V_0281 = $0281
V_0284 = $0284
V_0285 = $0285
V_0286 = $0286
V_0287 = $0287
V_028A = $028A ; wildcard flag
V_028B = $028B ; syntax flag
V_028C = $028C ; number of drives to look for
V_028D = $028D ; Flag: Looking for drive
V_028E = $028E ; last drive number
V_028F = $028F ; Flag: Found in directory
V_0290 = $0290 ; Directory sector
V_0291 = $0291 ; Sector for first available file
V_0292 = $0292 ; Index (in directory) for first available file
V_0293 = $0293 ; For the last directory entry 0
V_0294 = $0294 ; Current buffer-index
V_0295 = $0295 ; Counter: Files
V_0296 = $0296 ; Flag: Name matching wild cards
V_0297 = $0297 ; Active operating mode (R or W)
V_0298 = $0298 ; dos error flag, Flag: Work return
V_0299 = $0299 ; Pointer: Re-read error
V_029A = $029A ; Total tracks
V_029B = $029B ; Pointer: BAM last update $029B-$029C
V_029D = $029D ; BAM: image sector (drive 0)
V_02A1 = $02A1 ; BAM image $02A1-$02B0
V_02B0 = $02B0
V_02B1 = $02B1 ; Buffer for directory output, $02B1-$02D4
V_02B2 = $02B2
V_02B3 = $02B3
V_02C3 = $02C3
V_02C4 = $02C4
V_02D5 = $02D5
V_02F9 = $02F9 ; Flag: Don't write BAM
V_02FA = $02FA ; Number of free blocks, low byte for drive 0 and 1, $02FA-$02FB
V_02FC = $02FC ; Number of free blocks, hi byte for drives 0 and 1, $02FC-$02FD
V_02FE = $02FE ; Stepper motor sequence
V_02FF = $02FF
; 4 data buffers, 0-3, $0300-06ff
V_03A9 = $03A9
V_04A9 = $04A9
L_04C5 = $04C5
V_04FF = $04FF
V_0504 = $0504
V_0605 = $0605
V_0610 = $0610
V_06A9 = $06A9
; $0700-07ff BAM resident in memory
S_08FF = $08FF
V_2036 = $2036
V_21F1 = $21F1
S_3008 = $3008
;
; TIA 6523 registers $4000-$4005
;
; Port registers A, B and C
V_4000 = $4000 ; I/O port towards the computer
V_4001 = $4001 ; connected to the shift register of the R/W head
V_4002 = $4002 ; drive control, status and sync register
;
; bit 7: DAV (DAta Valid)
; handshake from bit #6 from $FEF2/FEC2 of plus/4
; bit 6: SYNC
; 0 -> SYNC found
; 1 -> no SYNC
; bit 5: MODE (jumper)
; drive number (0 -> 8, 1 -> 9)
; bit 4: MODE (R/W head)
; 0 -> head in write mode
; 1 -> head in read mode
; bit 3: ACK (ACKnowledge)
; handshake to bit #7 of $FEF2/$FEC2
; bit 2: DEV
; 1 -> drive mapped at $FEF0 on plus/4
; 0 -> drive mapped at $FEC0 on plus/4
; bit 1: STATUS1 - mapped at $FEF1/FEC1 on plus/4
; bit 0: STATUS0 - mapped at $FEF1/FEC1 on plus/4
; 01 Timeout during reading
; 10 Timeout during writing
; 11 End of data
;
; Data direction registers for ports A, B and C
V_4003 = $4003
V_4004 = $4004
V_4005 = $4005
;--------- Copyright text
T_C000 DB "DAVID G SIRACUSA CBM COPYRIGHT 84"
;--------- Start of 1551 ROM program
S_C022 LDA V_4000 ; read data from computer
CMP V_4000 ; port stable?
BEQ B_C02D ; if yes, then jump
JMP L_EABD ; otherwise back to main wait loop
;
B_C02D AND #$0F ; lowest 4 bits only
ASL A ; * 2
TAY ; Y = A, make it an index
LDA V_C046,Y ; look up address of subroutine
STA zp6E
LDA V_C046 + 1,Y
STA zp6E+1 ; $6E/$6F
LDA V_4002
AND #$F7
STA V_4002 ; ACK handshake
JMP ($006E) ; *** Indirect jump to TCBM bus command handler
;
; Jump vectors for TCBM bus commands,
; only $01 - $04 are valid. The 264 is sending these values
; OR-ed with $80 through the TCBM interface.
;
V_C046 DB $66,$C0 ; $C066: N/A
DB $71,$C0 ; $C071: Command w/ dev nr coming (TALK/LISTEN/UNTALK/UNLISTEN)
DB $D6,$C0 ; $C0D6: Command w/ sec addr. coming (0x60, 0xE0, 0xF0)
DB $F6,$C0 ; $C0F6: Data comes to the drive (filename, command, data etc.)
DB $4E,$C1 ; $C14E: Data goes to computer
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0
DB $66,$C0 ; N/A
;
; $C066
S_C066 LDA V_4002 ; not a valid command
ORA #$08 ; just acknowledge
STA V_4002
JMP L_EABD ; and jump back to main loop
;
; Command w/ dev nr coming (TALK/LISTEN/UNTALK/UNLISTEN)
;
B_C071 LDA V_4002
BMI B_C071 ; wait for DAV handshake from plus/4
LDA V_4000 ; read port data in from plus/4
PHA ; save to stack
LDA zp58 ;
BPL B_C08B ; MSB not set?
LDA #$00 ; reset end flag
STA zp95
LDA zp59 ; read last data byte
JSR B_C0F6
LDA #$00
STA zp58 ;
B_C08B PLA ; read port value back from stack
TSX
STX zp59+1
LDX #$00
STA zp8F ; save command
TAY ; backup A (command) in Y
AND #$60
CMP #$40 ; talk?
BEQ B_C0A8 ; yes
CMP #$20 ; listen?
BEQ B_C0C0 ; yes
LDY #$00 ; otherwise DATA ($60)
LDX #$03
STX zp6E ; set blink rate ?
SEI ; disable interrupt
JMP L_E984
;
B_C0A8 STX zp5B ; reset TALK flag
TYA ; code in accu
CMP #$5F ; UNTALK ?
BEQ B_C0BC ; yes...
STA zp5B ; set TALK flag
STX zp5C ; reset LISTEN flag
L_C0B3 LDA #$20
STA zp7C ; save sec. address
STA zp7D
JMP L_C133
;
B_C0BC LDA #$00
BEQ B_C135 ; always jump
B_C0C0 TYA ; read back A from Y
CMP #$3F ; UNLISTEN?
BNE B_C0CF ; no
LDA #$FF ;
STA zp95
LDX #$00
STX zp5C ; reset flag for listen
BEQ B_C0BC ; always jump
B_C0CF STA zp5C ; must be UNTALK then
STX zp5B
JMP L_C0B3
;
; Command w/ sec addr. coming (0x60, 0xE0, 0xF0)
;
B_C0D6 LDA V_4002
BMI B_C0D6 ; wait for DAV
TSX
STX zp59+1
LDA V_4000
STA zp7D ; store secondary address
TAY
AND #$0F
STA zp7C ; store secondary address again
TYA
AND #$F0
CMP #$E0 ; CLOSE?
BNE B_C0F2 ; not, then must be OPEN
JSR S_DBF7 ; jump to CLOSE
B_C0F2 LDA #$00
BEQ B_C135 ; always jump to finish
;
; Data comes to the drive (filename, command, data etc.)
;
B_C0F6 LDA V_4002
BMI B_C0F6 ; wait for DAV handshake from computer
TSX
STX zp59+1 ; save stack pointer
LDA V_4000 ; read data bus
PHA ; save
LDA zp58
BPL B_C12A ; branch if MSB not set, and set it now
LDA zp59 ; read data read last time
STA zp7E ; store
JSR S_D217 ; open channel
BCS B_C114
LDA zpF3,X
ROR A
BCS B_C127
B_C114 LDA zp7D ; read sec. addr. as received from computer
AND #$F0 ; get just the command bits...
CMP #$F0 ; open channel command?
BEQ B_C127 ; yes, then jump
LDA zp7C ; otherwise load secondary address (channel nr?)
CMP #$01 ; = 1 ?
BEQ B_C130 ; yes
PLA
LDA #$02
BNE B_C135 ; always jump
B_C127 JSR S_D0D3 ; write data into buffer
B_C12A LDA zp58
ORA #$80
STA zp58
B_C130 PLA ; copy back saved data from bus
STA zp59 ; store
L_C133 LDA #$00
B_C135 AND #$03
ORA #$08
STA zp97 ; preserve status, set ACK bit
LDA V_4002
ORA zp97 ; send it to machine
STA V_4002
B_C143 LDA V_4002
BPL B_C143 ; wait for DAV handshake from plus/4
AND #$FC ; send ACK to plus/4
STA V_4002
RTS
;
;$C14E -------- Data goes to computer
;
B_C14E LDA V_4002
BMI B_C14E ; wait for DAV handshake from plus/4
LDA #$FF
STA V_4003 ; set TIA port A to all outputs
TSX ; save stack pointer
STX zp59+1 ; ... to $5A
LDA zp7C ; read saved secondary address
CMP #$13 ; 19
BCC B_C163 ; bigger, then skip
AND #$0F
B_C163 CMP #$0F ; command channel ?
BNE B_C169 ; no...
LDA #$10 ; if 15 then make it 16
B_C169 TAX ; make and index from it
SEC
LDA V_022B,X
BMI B_C176
AND #$0F
STA zp7B
TAX
CLC
B_C176 BCS B_C17E
LDX zp7B
LDA zpF3,X
BMI B_C189
B_C17E LDA #$0D ; CR
STA V_4000 ; send $0D to computer via TIA port A
LDA #$0A
STA zp97
BNE B_C1A7
B_C189 LDA V_023E,X
STA V_4000 ; send the rest of the buffer
LDA zpF3,X
AND #$08
EOR #$08
ASL A
ASL A
ASL A ; multiply by 8 (becomes $40 (64) or 0)
PHA
JSR S_D4F9
PLA
CMP #$40
BNE B_C1A3
LDA #$03
B_C1A3 ORA #$08
STA zp97 ; $97 = $38
B_C1A7 LDA V_4002
AND #$FC ; clear status bits in TIA
ORA zp97 ; copy status
STA V_4002 ; send...
B_C1B1 LDA V_4002
BPL B_C1B1 ; wait for DAV handshake from machine
LDX #$00
STX V_4003 ; set TIA port A to input
AND #$F7
STA V_4002 ; clear ACK handshake
B_C1C0 LDA V_4002 ; received?
BMI B_C1C0 ; not yet
ORA #$08 ; set ACK handshake...
AND #$FC ; ...clear status bits...
STA V_4002 ; ... done
RTS
;$C1CD --------
S_C1CD LDX #$0D ; CR
STX V_4000 ; send to computer
LDA #$0A ; $8 / $2
STA zp97
BNE B_C1A7 ; jump always, set error status and device in TIA
S_C1D8 LDA #$01
JMP B_C135
;
LDX V_0274 ; X = length of filename
DEX ; decrease by 1
BEQ B_C1FB ; zero?
LDA L_0201
TAY
CMP #$52 ; "R"
BEQ B_C220 ; yes...
CMP #$53 ; "S"
BEQ B_C220 ; yes...
CMP #$39 ; 9?
BEQ B_C208 ; yes
CMP #$38 ; 8?
BNE B_C203 ; no... then error
B_C1F7 LDX #$08
BNE B_C20A ; always jump, set device number to 8
B_C1FB LDA zp66
CMP #$08 ; check device number
BEQ B_C208 ; = 8 ? then jump
BNE B_C1F7
B_C203 LDA #$31
JMP L_C2B2 ; 31, 'syntax error'
;
; Set device number flag in TIA register
;
B_C208 LDX #$09 ; set device number to 9
B_C20A STX zp66
TXA
S_C20D ASL A
ASL A ; accu * 4 = $24
AND #$04 ; isolate device nr flag in register
EOR #$04 ; toggle device number flag towards computer...
STA zp97
LDA V_4002
AND #$FB
ORA zp97 ; and then ...
STA V_4002 ; ... set device number (0 for #8 and 1 for #9)
RTS
;$C220 --------
B_C220 DEX
BEQ B_C203
LDX #$01
LDA V_0202
CPY #$52 ; "R"
BEQ B_C22D
DEX
B_C22D STA zp68,X
RTS
;$C230 -------- Interpret command from computer
S_C230 LDA #$00
STA V_02F9
LDA V_028E ; last drive number
STA zp78 ; drive number
JSR L_E7FB ; prepare 'ok' message
LDA zp7D ; secondary address
BPL B_C24A
AND #$0F
CMP #$0F ; 15, command channel
BEQ B_C24A ; yes
JMP L_D8EE ; to OPEN command
;
B_C24A JSR S_C39D ; determine line length and erase flags
LDA (zpA4),Y ; get first character
STA V_0275 ; and store
LDX #$0C ; 12
B_C254 LDA V_F0C6 + 1,X ; commands
CMP V_0275 ; compare to first character
BEQ B_C264 ; found?
DEX
BPL B_C254
LDA #$31 ; not found
JMP L_C2B2 ; 31, 'syntax error'
;
B_C264 STX V_022A ; number of command words
CPX #$0A
BCC B_C26E ; command number < 10? (1541 has 9!!!)
JSR S_C2D8 ; test for 'R', 'S', and 'N'
B_C26E LDX V_022A ; command number
LDA V_F0D4,X ; jump address lo
STA zp6E
LDA V_F0E1,X ; jump address hi
STA zp6E+1
JMP ($006E) ; *** Indirect jump to command
;
L_C27E LDA #$00
STA V_02F9
;
L_C283 LDA V_026C
BNE L_C2B2
LDY #$00
TYA ; error number 0
STY zp79 ; track number 0
L_C28D STY zp7A ; sector number 0
STY zpA4
JSR S_E806 ; prepare 'ok' message
JSR S_F3F0 ; erase error flag
L_C297 LDA zp78 ; drive number
STA V_028E ; save as last drive number
TAX
LDA #$00
STA zp5F,X
JSR S_C2A7 ; erase input buffer
JMP L_D62D ; close internal channel
; Erase input buffer
S_C2A7 LDY #$28 ; erase 41 characters
LDA #$00
B_C2AB STA V_0200,Y ; $200 to $228
DEY
BPL B_C2AB
RTS
;------------------------------------
;$C2B2 -------- Output error message
;------------------------------------
L_C2B2 LDY #$00
STY zp79 ; track = 0
STY zp7A ; sector = 0
JMP S_E781 ; error number acc, generate error message
; Check input line
S_C2BB LDX #$00
STX V_027A ; pointer to drive number
LDA #$3A ; ':'
JSR S_C352 ; test line to ':' or to end
BEQ B_C2CC ; no colon found?
DEY
DEY
STY V_027A ; point to drive number (before colon)
B_C2CC JMP L_C452
; Check ':' on input line
S_C2CF LDY #$00 ; pointer to input buffer
LDX #$00 ; counter for commas
LDA #$3A ; ':'
JMP S_C352
;
S_C2D8 JSR S_C2CF
BNE S_C2E2
B_C2DD LDA #$34
JMP L_C2B2 ; 34, 'syntax error'
;
S_C2E2 DEY
DEY ; set pointer to colon
STY V_027A ; position of the drive number
TXA ; comma before the colon
BNE B_C2DD ; yes, then 'syntax error'
S_C2EA LDA #$3D ; '='
JSR S_C352 ; check input to '='
TXA ; comma found?
BEQ B_C2F4 ; no
LDA #$40 ; bit 6
B_C2F4 ORA #$21 ; and set bit 0 and 5
STA V_028B ; flag for syntax check
INX
STX V_0277
STX V_0278
LDA V_028A ; wildcard found?
BEQ B_C312 ; no
LDA #$80
ORA V_028B ; set bit 7
STA V_028B
LDA #$00
STA V_028A ; reset wildcard flag
B_C312 TYA ; '=' found?
BEQ B_C33E ; no
STA V_027A,X
LDA V_0277 ; number of commas before '='
STA V_0279
LDA #$8D ; shift CR
JSR S_C352 ; check line to end
INX ; increment comma counter
STX V_0278 ; store number of commas
DEX
LDA V_028A ; wildcard found?
BEQ B_C32F ; no
LDA #$08 ; set bit 3
B_C32F CPX V_0277 ; comma after '='?
BEQ B_C336 ; no
ORA #$04 ; set bit 2
B_C336 ORA #$03 ; set bits 0 and 1
EOR V_028B
STA V_028B ; as flag for syntax check
B_C33E LDA V_028B ; syntax flag
LDX V_022A ; command number
AND V_F0E5,X ; combine with check byte
BNE B_C34A
RTS
;$C34A --------
B_C34A STA V_026C ; set error flag
LDA #$30
JMP L_C2B2 ; 30, 'syntax error'
; Search character in input buffer
S_C352 STA V_0275 ; save character
B_C355 CPY V_0274 ; already done?
BCS B_C388 ; yes
LDA (zpA4),Y ; get char from buffer
INY
CMP V_0275 ; compared with char
BEQ B_C38A ; found
CMP #$2A ; '*'
BEQ B_C36A
CMP #$3F ; '?'
BNE B_C36D
B_C36A INC V_028A ; set wildcard flag
B_C36D CMP #$2C ; ','
BNE B_C355
TYA
STA V_027B,X ; note comma position
LDA V_028A ; wildcard flag
AND #$7F
BEQ B_C383 ; no wildcard
LDA #$80
STA zpE8,X ; note flag
STA V_028A ; and save as wildcard flag
B_C383 INX ; increment comma counter
CPX #$04 ; 4 commas already?
BCC B_C355 ; no, continue
B_C388 LDY #$00
B_C38A LDA V_0274 ; set flag for line end
STA V_027B,X
LDA V_028A ; wildcard flag
AND #$7F
BEQ B_C39B ; no wildcard
LDA #$80
STA zpE8,X ; set flag
B_C39B TYA
RTS
;$C39D -------- Check line length
S_C39D LDY zpA4 ; pointer to command input buffer
BEQ B_C3B5 ; zero?
DEY
BEQ B_C3B4 ; one?
LDA V_0200,Y ; pointer to input buffer
CMP #$0D ; 'CR'
BEQ B_C3B5 ; yes, line end
DEY
LDA V_0200,Y ; preceding character
CMP #$0D ; 'CR'
BEQ B_C3B5 ; yes
INY
B_C3B4 INY ; pointer to old value again
B_C3B5 STY V_0274 ; same line length
CPY #$2A ; compare with 42 characters
LDY #$FF
BCC S_C3C6 ; smaller, ok
STY V_022A
LDA #$32
JMP L_C2B2 ; 32, 'syntax error' line too long
; Clear flags for command input
S_C3C6 LDY #$00
TYA
STA zpA4 ; pointer to input buffer lo
STA V_0258 ; record length
STA V_024A ; file type
STA V_0296
STA zp99
STA V_0279 ; comma counter
STA V_0277 ; "
STA V_0278 ; "
STA V_028A ; wildcard flag
STA V_026C ; error flag
LDX #$05
B_C3E7 STA V_0279,X ; flags for line analysis
STA zpD8,X ; directory sectors
STA zpDD,X ; buffer pointer
STA zpE2,X ; drive number
STA zpE7,X ; wildcard flag
STA V_027F,X ; track number
STA V_0284,X ; sector number
DEX
BNE B_C3E7
RTS
;$C3FC -------- Preserve drive number
S_C3FC LDA V_0278 ; number of commas
STA V_0277 ; save
LDA #$01
STA V_0278 ; number of drive numbers
STA V_0279
S_C40A LDY V_028E ; last drive number
LDX #$00
B_C40F STX zp99
LDA V_027A,X ; position of the colon
JSR S_C426 ; get drive number before colon
LDX zp99
STA V_027A,X ; save exact position
TYA
STA zpE3,X ; drive number in table
INX
CPX V_0278 ; got all drive numbers?
BCC B_C40F ; no, continue
RTS
;$C426 -------- Search for drive number
S_C426 TAX ; note position
LDY #$00
LDA #$3A ; ':'
CMP L_0201,X ; colon behind it?
BEQ B_C43C ; yes
CMP V_0200,X ; colon here?
BNE B_C436 ; no
INX
B_C436 TYA
B_C437 AND #$01 ; drive number
B_C439 TAY
TXA
RTS
;$C43C --------
B_C43C LDA V_0200,X ; get drive number
INX
INX
CMP #$30 ; '0'?
BEQ B_C437
CMP #$31 ; '1'?
BEQ B_C4B2
BNE B_C436 ; no, use last drive number
TYA ; last drive number
ORA #$80 ; set bit 7, uncertain drive number
AND #$81 ; erase remaining bits
BNE B_C439
BNE B_C439
; Get drive number
V_C452
L_C452 LDA #$00
STA V_028B ; erase syntax flag
LDY V_027A ; position in command line
B_C45A LDA (zpA4),Y ; get chars from command buffer
JSR S_C4A5 ; get drive number
BPL B_C472 ; certain number?
INY ; increment pointer
CPY V_0274 ; line end?
BCS B_C46D ; yes
LDY V_0274
DEY
BNE B_C45A ; search line for drive number
B_C46D DEC V_028B
LDA #$00
B_C472 AND #$01
STA zp78 ; drive number
RTS
;$C477 --------
S_C477 LDA zp78 ; drive number
EOR #$01 ; switch bit 0
AND #$01
STA zp78
RTS
;$C480 -------- Check given file type
S_C480 LDY #$00
LDA V_0277 ; '=' found?
CMP V_0278
BEQ B_C4A0 ; no
DEC V_0278 ; get pointer
LDY V_0278
LDA V_027A,Y ; set pointer to character behind '='
TAY
LDA (zpA4),Y ; pointer to buffer
LDY #$04 ; compare with marker for file type
B_C498 CMP V_F0FB + 1,Y ; 'S', 'P', 'U', 'R'
BEQ B_C4A0 ; agreement
DEY
BNE B_C498
B_C4A0 TYA
STA V_0296 ; note file type (1-4)
RTS
;$C4A5 -------- Check given drive number
S_C4A5 CMP #$30 ; '0'
BEQ B_C4AF
CMP #$31 ; '1'
BEQ B_C4B2
ORA #$80 ; no zero or one, then set bit 7
B_C4AF AND #$81
RTS
;$C4B2 -------- Verify drive number
B_C4B2 LDA #$31
JMP L_C2B2
;
S_C4B7 LDA #$00
STA zp6E
STA V_028D ; reset for looking for drive flag
PHA
LDX V_0278 ; number of drive numbers
B_C4C2 PLA ;
ORA zp6E
PHA
LDA #$01
STA zp6E
DEX
BMI B_C4DC
LDA zpE3,X
BPL B_C4D5
ASL zp6E
ASL zp6E ; $6e * 4
B_C4D5 LSR A ; ac = ac * 2
BCC B_C4C2 ; not overflow? then back
ASL zp6E ; $6e * 2
BNE B_C4C2 ; not zero? then back
B_C4DC PLA
TAX
LDA V_C528 + 2,X ; get syntax flag
PHA
AND #$03
STA V_028C
PLA
ASL A
BPL B_C527
LDA zpE3
L_C4ED AND #$01 ; isolate drive number
STA zp78
LDA V_028C
BEQ B_C521
JSR S_C722 ; initialize drive
BEQ B_C50D ; error?
JSR S_C477 ; switch to other drive
LDA #$00
STA V_028C
JSR S_C722 ; initialize drive
BEQ B_C526 ; no error?
BEQ B_C526
V_C508
B_C508 LDA #$74
JSR L_C2B2 ; 74, 'drive not ready'
B_C50D JSR S_C477
JSR S_C722 ; initialize drive
PHP
JSR S_C477 ; switch to other drive
PLP
BEQ B_C526 ; no error?
LDA #$00
STA V_028C ; number of drives
BEQ B_C526
B_C521 JSR S_C722 ; initialize drive
BNE B_C508 ; error?
B_C526 RTS
;$C527 --------
B_C527 ROL A ; drive number from carry after bit 0
V_C528 JMP L_C4ED ; *** Self mod. indirect jump!
; Flags for drive check
DB $00,$80,$41,$01,$01,$01,$01,$81
DB $81,$81,$81,$42,$42,$42,$42
; Search for file in directory
S_C53A JSR S_C4B7 ; initialize drive
L_C53D LDA #$00
STA V_0292 ; pointer
JSR S_C691 ; read first directory block
BNE B_C55D ; entry present?
B_C547 DEC V_028C ; drive number clear?
BPL B_C54D ; no
RTS
;$C54D --------
B_C54D LDA #$01
STA V_028D
JSR S_C477 ; change drive...
JMP L_C53D ; ...and search
;
B_C558 JSR S_C6FC ; search next file in directory
BEQ B_C56D ; not found?
B_C55D JSR S_C5BD ; verify directory entry
LDA V_028F
BEQ B_C566 ; more files?
RTS
;$C566 --------
B_C566 LDA V_0253
BMI B_C558 ; file not found?
BPL B_C55D ; yes
B_C56D LDA V_028F
BEQ B_C547
RTS
;$C573 --------
S_C573 JSR S_C6E9 ; search next directory block
BEQ B_C58F ; not found?
BNE B_C59F
B_C57A LDA #$01
STA V_028D
JSR S_C477 ; change drive
S_C582 LDA #$00
STA V_0292 ; read directory block
JSR S_C691 ; found?
BNE B_C59F
STA V_028F
B_C58F LDA V_028F
BNE B_C5BC
DEC V_028C
BPL B_C57A
RTS
;$C59A --------
S_C59A JSR S_C6FC ; next entry in directory
BEQ B_C58F ; not found?
B_C59F JSR S_C5BD ; check entry
LDX V_0253
BPL B_C5AE ; file found?
LDA V_028F
BEQ S_C59A ; yes
BNE B_C5BC ; no, then done
B_C5AE LDA V_0296
BEQ B_C5BC
LDA zpE8,X ; file type
AND #$07
CMP V_0296 ; same as desired file type?
BNE S_C59A ; no
B_C5BC RTS
;$C5BD --------
S_C5BD LDX #$FF
STX V_0253 ; flag for data found
INX
STX V_028A
JSR B_C66E ; set pointer to data
BEQ B_C5D1
B_C5CB RTS
;$C5CC --------
B_C5CC JSR S_C679 ; pointer to next file
BNE B_C5CB ; end, then done
B_C5D1 LDA zp78 ; drive number
EOR zpE3,X
LSR A
BCC B_C5E3
AND #$40
BEQ B_C5CC
LDA #$02
CMP V_028C ; search both drives?
BEQ B_C5CC ; yes
B_C5E3 LDA V_027A,X
TAX
JSR S_C787 ; get length of filename
LDY #$03
JMP L_C602
;
B_C5EF LDA V_0200,X ; get chars out of command line
CMP (zp8D),Y ; same character in directory?
BEQ B_C600 ; yes
CMP #$3F ; '?'
BNE B_C5CC ; no
LDA (zp8D),Y ; shift blank, end of name?
CMP #$A0 ; yes
BEQ B_C5CC
B_C600 INX ; increment pointer
INY
L_C602 CPX V_0276 ; end of the name in the command?
BCS B_C610 ; yes
LDA V_0200,X ; next character
CMP #$2A ; '*'
BEQ B_C61A ; yes, file found
BNE B_C5EF ; continue search
B_C610 CPY #$13 ; 19
BCS B_C61A ; reached end of name
LDA (zp8D),Y
CMP #$A0 ; shift blank, end of name
BNE B_C5CC ; not found
B_C61A LDX V_0279
STX V_0253
LDA zpE8,X
AND #$80
STA V_028A
LDA V_0294
STA zpDE,X
LDA zp7A ; sector number of the directory
STA zpD9,X ; enter in table
LDY #$00
LDA (zp8D),Y ; file type
INY
PHA
AND #$40 ; isolate search-protect bit
STA zp6E ; (6) and save
PLA
AND #$DF ; erase bit 7
BMI B_C641
ORA #$20 ; set bit 5
B_C641 AND #$27 ; erase bits 3 and 4
ORA zp6E ; get bit 6 again
STA zp6E
LDA #$80
AND zpE8,X ; isolate flag for wildcard
ORA zp6E
STA zpE8,X ; write in table
LDA zpE3,X
AND #$80
ORA zp78 ; drive number
STA zpE3,X
LDA (zp8D),Y
STA V_0280,X ; first track of file
INY
LDA (zp8D),Y
STA V_0285,X ; get sector from directory
LDA V_0258 ; record length
BNE B_C66E
LDY #$15
LDA (zp8D),Y ; record length
STA V_0258 ; get from directory
B_C66E LDA #$FF
STA V_028F
LDA V_0278
STA V_0279
S_C679 DEC V_0279
BPL B_C67F
RTS
;$C67F --------
B_C67F LDX V_0279
LDA zpE8,X ; wildcard flag set?
BMI B_C68B ; yes
LDA V_0280,X ; track number already set
BNE S_C679 ; yes
B_C68B LDA #$00
STA V_028F
RTS
;$C691 --------
S_C691 LDY #$00
STY V_0291
DEY
STY V_0253
LDA V_F0C3 ; 18, directory track
STA zp79
LDA #$01
STA zp7A ; sector 1
STA V_0293
JSR S_D5C8 ; read sector
L_C6A9 LDA V_0293
BNE B_C6AF
RTS
;$C6AF --------
B_C6AF LDA #$07
STA V_0295 ; number of directory entries (-1)
LDA #$00
JSR S_D649 ; get pointer from buffer
STA V_0293 ; save as track number
L_C6BC JSR S_D63B ; set buffer pointer
DEC V_0295 ; decrement counter
LDY #$00
LDA (zp8D),Y ; first byte from directory
BNE B_C6E0
LDA V_0291
BNE S_C6FC
JSR S_DF76 ; get track and sector number
LDA zp7A
STA V_0291 ; sector number
LDA zp8D
LDX V_0292
STA V_0292 ; buffer pointer
BEQ S_C6FC
RTS
;$C6E0 --------
B_C6E0 LDX #$01
CPX V_0292 ; buffer pointer to one?
BNE B_C714
BEQ S_C6FC
S_C6E9 LDA V_F0C3 ; 18, track number of BAM
STA zp79 ; track number
LDA V_0290
STA zp7A ; sector number
JSR S_D5C8 ; read block
LDA V_0294
JSR S_D61B ; set buffer pointer
S_C6FC LDA #$FF
STA V_0253 ; erase-file found flag
LDA V_0295
BMI B_C70E ; all directory entries checked?
LDA #$20
JSR S_D31C ; increment buffer ptr by 32, next entry
JMP L_C6BC ; and continue
;
B_C70E JSR S_D5A0 ; set buffer pointer
JMP L_C6A9 ; read next block
;
B_C714 LDA zp8D
STA V_0294
JSR S_DF76 ; get track & sector number from buffer
LDA zp7A
STA V_0290 ; save sector number
RTS
;$C722 -------- Test and initalise drive
S_C722 LDX zp78
LSR zp22,X
BCC B_C74A
LDA #$FF
STA V_0298 ; set error flag
JSR S_D12A ; read directory track
LDY #$FF
CMP #$02 ; 20, 'read error'?
BEQ B_C740
CMP #$03 ; 21, 'read error'?
BEQ B_C740
CMP #$0F ; 74, 'drive not ready'?
BEQ B_C740
LDY #$00
B_C740 LDX zp78 ; drive number
TYA
STA zp5F,X ; save error flag
BNE B_C74A
JSR S_D15E ; load BAM
B_C74A LDX zp78 ; drive number
LDA zp5F,X ; transmit error code
RTS
;$C74F -------- Name of file in directory buffer
S_C74F PHA
JSR S_C787 ; get end of the name
JSR S_C769 ; write filename in buffer
PLA
SEC
SBC V_024B ; compare length with maximal length
TAX
BEQ B_C768
BCC B_C768
LDA #$A0 ; pad with 'shift blank'
B_C762 STA (zp8D),Y
INY
DEX
BNE B_C762
B_C768 RTS
;$C769 -------- Copy filename to work buffer
S_C769 TYA ; buffer number
ASL A
TAY ; times 2 as pointer
LDA $009A,Y
STA zp8D
LDA $009B,Y ; buffer pointer after $9b/$9c
STA zp8D+1
LDY #$00
B_C778 LDA V_0200,X ; transmit characters in buffer
STA (zp8D),Y
INY
BEQ B_C786 ; buffer already full?
INX
CPX V_0276
BCC B_C778
B_C786 RTS
;$C787 -------- Search for end of name in command
S_C787 LDA #$00
STA V_024B
TXA
PHA
B_C78E LDA V_0200,X ; get characters out of buffer
CMP #$2C ; ','
BEQ B_C7A9
CMP #$3D ; '='
BEQ B_C7A9
INC V_024B ; increment length of name
INX
LDA #$0F ; 15
CMP V_024B
BCC B_C7A9 ; greater?
CPX V_0274 ; end of input line?
BCC B_C78E
B_C7A9 STX V_0276
PLA
TAX ; pointer to end of name
RTS
;$C7AF --------
S_C7AF LDA zp7C
PHA ; secondary address and channel number
LDA zp7B
PHA
JSR S_C7BF ; create file entry for directory
PLA
STA zp7B
PLA ; get data back
STA zp7C
RTS
;$C7BF --------
S_C7BF LDA #$11 ; 17
STA zp7C ; secondary address
JSR S_D1FB ; open channel to read
JSR S_D63B ; set buffer pointer
LDA V_0253
BPL B_C7D8 ; not yet last entry?
LDA V_028D
BNE B_C7DD
JSR S_C8E7 ; write 'blocks free.'
CLC
RTS
;$C7D8 --------
B_C7D8 LDA V_028D
BEQ B_C7FC
B_C7DD DEC V_028D
BNE B_C7EF
DEC V_028D
JSR S_C477
JSR S_C8E7
SEC
JMP S_C477
;
B_C7EF LDA #$00
STA V_0273
STA V_028D ; drive 0
JSR S_C898 ; create header ???
SEC
RTS
;$C7FC --------
B_C7FC LDX #$18
LDY #$1D
LDA (zp8D),Y ; number of blocks hi
STA V_0273 ; in buffer
BEQ B_C809 ; zero?
LDX #$16
B_C809 DEY
LDA (zp8D),Y ; number of blocks lo
STA V_0272 ; in buffer
CPX #$16
BEQ B_C81D
CMP #$0A ; 10
BCC B_C81D
DEX
CMP #$64 ; 100
BCC B_C81D
DEX
B_C81D JSR S_C88D ; erase buffer
LDA (zp8D),Y ; file type
PHA
ASL A ; bit 7 in carry
BPL B_C82B ; bit 6 not set?
LDA #$3C ; '<' for protected file
STA V_02B2,X ; write behind file type
B_C82B PLA
AND #$0F ; isolate bits 0-3
TAY ; as file type marker
LDA V_F106,Y ; 3rd letter of the file type
STA V_02B1,X ; in buffer
DEX
LDA V_F101,Y ; 2nd letter of the file type
STA V_02B1,X ; in buffer
DEX
LDA V_F0FB + 1,Y ; 1st letter of the file type
STA V_02B1,X ; in buffer
DEX
DEX
BCS B_C84C ; file not closed?
LDA #$2A ; '*'
STA V_02B2,X ; before file type in buffer
B_C84C LDA #$A0 ; pad with 'shift blank'
STA V_02B1,X ; in buffer
DEX
LDY #$12
B_C854 LDA (zp8D),Y ; filenames
STA V_02B1,X ; write in buffer
DEX
DEY
CPY #$03
BCS B_C854
LDA #$22 ; '='
STA V_02B1,X ; write before file type
B_C864 INX
CPX #$20
BCS B_C874
LDA V_02B1,X ; character from buffer
CMP #$22 ; '='
BEQ B_C874
CMP #$A0 ; 'shift blank' at end of name
BNE B_C864
B_C874 LDA #$22 ; fill through '='
STA V_02B1,X
B_C879 INX
CPX #$20
BCS B_C888
LDA #$7F ; bit 7
AND V_02B1,X
STA V_02B1,X ; erase in the remaining chars
BPL B_C879
B_C888 JSR S_C59A ; search for the directory entry
SEC
RTS
;$C88D -------- Clear Directory Output Buffer
S_C88D LDY #$1B
LDA #$20
B_C891 STA V_02B0,Y ; write in buffer
DEY
BNE B_C891
RTS
;$C898 -------- Create header with disk name
S_C898 JSR S_EF84 ; initialize if needed
JSR S_EF4A ; read disk name
JSR S_C88D ; erase buffer
LDA #$FF
STA zp6E
LDX zp78 ; drive number
STX V_0272 ; as block number lo in buffer
LDA #$00
STA V_0273 ; block number lo
LDX zp98 ; buffer number
LDA V_F123,X ; hi-byte of the buffer address
STA zp8D+1
LDA V_F0C6 ; $90, position of disk name
STA zp8D ; save
LDY #$16
LDA (zp8D),Y ; pad buffer with 'shift blank'
CMP #$A0
BNE B_C8CE
LDA #$31 ; '1'
DB $2C
B_C8C6 LDA (zp8D),Y ; character from buffer
CMP #$A0 ; compare with 'shift blank'
BNE B_C8CE
LDA #$20 ; ' ' blank
B_C8CE STA V_02B3,Y ; in buffer
DEY
BPL B_C8C6
LDA #$12 ; 'RVS ON'
STA V_02B1 ; in buffer
LDA #$22 ; '"'
STA V_02B2 ; write before
STA V_02C3 ; and after disk name
LDA #$20 ; ' ' blank
STA V_02C4 ; behind it
RTS
;$C8E7 -------- Print 'blocks free.'
S_C8E7 JSR S_C88D ; erase buffer
LDY #$0B ; 12 characters
B_C8EC LDA V_C8F8,Y ; 'blocks free.'
STA V_02B1,Y ; write in buffer
DEY
BPL B_C8EC
JMP S_EDB8 ; number of free blocks in front
;
; $C8F8 'Blocks free.'
V_C8F8 DB "BLOCKS FREE."
; Perform [S] - Scratch command
JSR S_C480 ; ascertain file type
JSR S_C40A ; get drive number
JSR S_C4B7 ; initialize drive if needed
LDA #$00
STA zp7F ; counter for erased files
JSR S_C582 ; search for file in directory
BMI B_C953 ; not found?
B_C916 JSR S_DEF2 ; is file open
BCC B_C94E ; yes
LDY #$00
LDA (zp8D),Y ; file type
AND #$40 ; scratch protect
BNE B_C94E ; yes
JSR S_C997 ; erase file and note in directory
LDY #$13
LDA (zp8D),Y ; track number of the first side-sector
BEQ B_C936 ; none present?
STA zp79 ; note track number
INY
LDA (zp8D),Y ; and sector number
STA zp7A
JSR S_C95E ; erase side-sector
B_C936 LDX V_0253 ; file number
LDA #$20
AND zpE8,X ; bit 5 set?
BNE B_C94C ; yes, file not closed
LDA V_0280,X ; get track...
STA zp79
LDA V_0285,X ; ...and sector
STA zp7A
JSR S_C95E ; erase file
B_C94C INC zp7F ; increment number of erased files
B_C94E JSR S_C573 ; search for next file
BPL B_C916 ; if present, erase
B_C953 LDA zp7F ; number of erased files
STA zp79 ; save as 'track'
LDA #$01 ; 1 as disk status
LDY #$00 ; 0 as 'sector'
JMP L_C28D ; message 'files scratched'
; Erase file
S_C95E JSR S_EDCA ; free block in BAM
JSR S_D5C8
JSR S_EF84 ; get buffer number in BAM
LDA zpA8,X
CMP #$FF
BEQ L_C975
LDA V_02F9
ORA #$40
STA V_02F9
L_C975 LDA #$00
JSR S_D61B ; buffer pointer to zero
JSR S_D271 ; get track
STA zp79
JSR S_D271 ; get sector
STA zp7A
LDA zp79 ; track number
BNE B_C98E ; not equal to zero
JSR S_ED5F ; write BAM
JMP L_D37D ; close channel
;
B_C98E JSR S_EDCA ; free block in BAM
JSR S_D5A0 ; read next block
JMP L_C975 ; and continue
; Erase dir entry
S_C997 LDY #$00
TYA
STA (zp8D),Y ; set file type to zero
JSR S_DF99 ; write block
JMP S_D6EC ; and check
; Perform [D] - Backup command (Unused)
L_C9A2 LDA #$31
JMP L_C2B2 ; 31, 'syntax error'
;
JMP L_C2B2
; Format disk ??
V_C9A7
S_C9A7 LDA #$03
JSR S_D808
LDX #$03
LDA #$F0
STA zpFF
STA V_02FE
JSR L_C9C8 ;
LDA #$01
STA zp0E
LDA #$00
STA zp0E+1
LDA #$80
STA V_02FE
JMP L_C9C8
;
L_C9C8 LDY #$03
B_C9CA LDA V_02FE
STA zp02,X
JSR S_D819
CMP #$02
BCC B_C9E4 ; smaller than two, then ok
LDA #$FF
STA zp40
STA zpFF
DEY
BNE B_C9CA
LDX #$00
JMP L_E746 ; 21, 'read error'
;
B_C9E4 RTS
;$C9E5 -------- Perform [C] - Copy command
LDA #$E0
STA V_024F
JSR S_EF3C
JSR S_EF84 ; get buffer number of BAM
LDA #$FF
STA zpA8,X
LDA #$0F
STA V_0256
JSR S_C2CF ; check input line
BNE B_CA01
JMP L_C9A2 ; 31, 'syntax error'
;
B_CA01 JSR S_C2E2 ; check input
JSR S_C40A ; test drive number
LDA V_028B ; flag for syntax check
AND #$55 ; "U"
BNE B_CA1D
LDX V_027A
LDA V_0200,X ; character of the command
CMP #$2A ; '*'
BNE B_CA1D
B_CA18 LDA #$30
JMP L_C2B2 ; 30, 'syntax error'
;
B_CA1D LDA V_028B ; syntax flag
AND #$D9
BNE B_CA18 ; 30, 'syntax error'
JMP L_CA47
;
LDA #$00
STA V_0258
STA V_028C ; number of drives
STA V_0280 ; track number in directory
STA V_0281
LDA zpE4
AND #$01
STA zp78 ; drive number
ORA #$01
STA V_0291
LDA V_027B
STA V_027A
RTS
;$CA47 --------
L_CA47 JSR S_C53A ; search for file in directory
LDA V_0278 ; number of filenames in command
CMP #$03 ; smaller than three?
BCC B_CA96 ; yes
LDA zpE3 ; first drive number
CMP zpE4 ; second drive number
BNE B_CA96 ; not on same drive?
LDA zpDE ; directory block of the 1st file
CMP zpDF ; same directory block as second file?
BNE B_CA96 ; no
LDA zpD9 ; directory sector of first file
CMP zpDA ; same directory sector as second file?
BNE B_CA96 ; no
JSR S_CBC1 ; is file present?
LDA #$01
STA V_0279
JSR S_CAEF
JSR S_D235 ; get data type
BEQ B_CA77 ; rel-file? yes
CMP #$02 ; prg-file?
BNE B_CA7C ; no
B_CA77 LDA #$64
JSR L_C2B2 ; 64, 'file type mismatch'
B_CA7C LDA #$12 ; 18
STA zp7C ; secondary address
LDA V_023C
STA V_023D
LDA #$FF
STA V_023C
JSR S_DB61 ; prepare append
LDX #$02
JSR S_CAAE ; copy file
JMP L_C27E ; done
;
B_CA96 JSR S_CA9C ; copy file
JMP L_C27E ; done
;
S_CA9C JSR S_CBDC ;
LDA zpE3 ; drive number of first file
AND #$01
STA zp78 ; backup drive number
JSR S_D5D9
JSR S_D81E ; enter file in directory
LDX V_0277
S_CAAE STX V_0279
JSR S_CAEF
LDA #$11 ; 17
STA zp7C
JSR S_D1FB ;
JSR S_D235 ; get data type
BNE B_CAC3 ; no rel-file?
JSR S_CB48
B_CAC3 LDA #$08
STA zp95
JMP L_CACD
;
B_CACA JSR S_D0BA ; write byte in buffer
L_CACD JSR S_CB2A ; and get byte
LDA #$80
JSR S_DEE1 ; test bit 7
BEQ B_CACA ; not set?
JSR S_D235 ; check file type
BEQ B_CADF ; rel-file?
JSR S_D0BA ; get data byte in buffer
B_CADF LDX V_0279
INX
CPX V_0278
BCC S_CAAE
LDA #$12 ; 18
STA zp7C
JMP L_DC39 ; close channel
;
S_CAEF LDX V_0279
LDA zpE3,X ; drive number
AND #$01
STA zp78 ; save
LDA V_F0C3 ; 18, directory track
STA zp79 ; save
LDA zpD9,X ; directory sector
STA zp7A
JSR S_D5C8 ; read block
LDX V_0279
LDA zpDE,X ; pointer in block
JSR S_D61B ; set buffer pointer
LDX V_0279
LDA zpE8,X ; file type
AND #$07 ; isolate
STA V_024A ; and save
LDA #$00
STA V_0258
JSR S_DAD7 ; get parameters for rel-file
LDY #$01
JSR S_D235 ; get file type
BEQ B_CB26 ; rel-file?
INY
B_CB26 TYA
JMP S_D61B ; set buffer pointer
;
S_CB2A LDA #$11 ; 17
STA zp7C
S_CB2E JSR S_D4ED ; open channel and get byte
STA zp7E
LDX zp7B ; channel number
LDA zpF3,X ; ... as index
AND #$08 ; isolate end marker
STA zp95
BNE B_CB47 ; not set?
JSR S_D235 ; get data type
BEQ B_CB47 ; rel-file?
LDA #$80
JSR L_DED2 ; set bit 7
B_CB47 RTS
;$CB48 --------
S_CB48 JSR S_D329 ; set drive number
JSR S_E306
LDA zp93
PHA
LDA zp92
PHA
LDA #$12 ; 18
STA zp7C
JSR S_D217 ; open write channel
JSR S_D329 ; set drive number
JSR S_E306
JSR S_E3D7
LDA zp93
STA zp7F+1
LDA zp92
STA zp7F
LDA #$00
STA zp81
STA zp91
STA zp94
PLA
STA zp92
PLA
STA zp93
JMP L_E476
; Perform [R] - Rename command
JSR S_C40A ; get drive number from command line
LDA zpE4
AND #$01
STA zpE4 ; 2nd drive number
CMP zpE3 ; compare with 1st drive number
BEQ B_CB8C ; same?
ORA #$80
B_CB8C STA zpE3
JSR S_C53A ; search for file in directory
JSR S_CBDC ; does name exist?
LDA zpE4
AND #$01
STA zp78 ; drive number
LDA zpDA
STA zp7A ; sector number
JSR S_DF92 ; read block from directory
JSR S_D6EC ; ok?
LDA zpDF ; pointer to directory entry
CLC
ADC #$03 ; pointer plus 3 to file name
JSR S_D61B ; set buffer pointer
JSR S_E0CE ; get buffer number
TAY
LDX V_027A
LDA #$10 ; 16 characters
JSR S_C74F ; write name in buffer
JSR S_DF99 ; write block to directory
JSR S_D6EC ; ok?
JMP L_C27E ; done, prepare disk status
; Check if file present
S_CBC1 LDA zpE9 ; file type
AND #$07
STA V_024A ; save
LDX V_0278
B_CBCB DEX
CPX V_0277
BCC B_CBDB
LDA V_0280,X ; track number
BNE B_CBCB ; not zero?
LDA #$62
JMP L_C2B2 ; 62, 'file not found'
;
B_CBDB RTS
;$CBDC --------
S_CBDC JSR S_CBC1 ; does file exist with old name?
B_CBDF LDA V_0280,X ; track number of new file
BEQ B_CBE9 ; file erased?
LDA #$63
JMP L_C2B2 ; 63, 'file exists'
;
B_CBE9 DEX
BPL B_CBDF
RTS
;$CBED -------- Perform [M] - Memory command
LDA L_0201 ; 2nd character from buffer
CMP #$2D ; '-'
BNE B_CC3D
LDA V_0203
STA zp6E
LDA V_0204
STA zp6E+1 ; address in $6E/$6F
LDY #$00
LDA V_0202 ; 3rd character from buffer
CMP #$52 ; "R"
BEQ B_CC12 ; to memory read
CMP #$57 ; "W"
BEQ B_CC42 ; to memory write
CMP #$45 ; "E"
BNE B_CC3D
JMP ($006E) ; *** Indirect jump!
; M-R memory read
B_CC12 LDA (zp6E),Y ; read byte
STA zp7E
LDA V_0274 ; length of command line
CMP #$06 ; less than 6?
BCC B_CC37 ; yes
LDX V_0205 ; number
DEX
BEQ B_CC37 ; only one byte?
TXA ; number of bytes
CLC
ADC zp6E ; plus start address
INC zp6E
STA V_0249 ; end pointer
LDA zp6E
STA zpA6 ; buffer pointer for error message
LDA zp6E+1 ; set to start address for 'M-R'
STA zpA6+1
JMP L_D596 ; byte out
;
B_CC37 JSR S_D1FB ; open read channel
JMP L_D58D ; byte out
;
B_CC3D LDA #$31
JMP L_C2B2 ; 31, 'syntax error'
; M-W memory write
B_CC42 LDA V_0206,Y ; read character
V_CC45 STA (zp6E),Y ; and save
INY
CPY V_0205 ; number of characters
BCC B_CC42 ; all characters?
RTS
;$CC4E -------- Perform [U] - User command
;
; User commands:
;
; User command Function
; ------------ --------
; u0 Restore default user command table address ($FFEA)
; u1 or ua Block read replacement at $CE51
; u2 or ub Block write replacement at $CE8b
; u3 or uc Jump to $0500
; u4 or ud Jump to $0503
; u5 or ue Jump to $0506
; u6 or uf Jump to $0509
; u7 or ug Jump to $050c
; u8 or uh Jump to $050f
; u9 or ui Jump to ($fffa) reset tables ($ea39)
; u: or uj Power up vector ($e9b5)
;
LDY L_0201 ; second char
CPY #$30 ; '0'
BNE B_CC5E ; no
S_CC55 LDA #$EA
STA zp6A ; pointer to table of user-addresses
LDA #$FF ; $FFEA
STA zp6A+1
RTS
;$CC5E --------
B_CC5E JSR S_CC64
JMP L_C27E ; done, prepare error message
;
S_CC64 DEY
TYA
AND #$0F ; isolate number
ASL A ; times 2
TAY ; make an index of it
LDA (zp6A),Y ; as pointer in table
STA zp74
INY ; address at $74/$75
LDA (zp6A),Y
STA zp74+1
JMP ($0074) ; *** Indirect jump, execute function!
; Open direct access channel, number
L_CC76 LDA V_028E ; last drive number
STA zp78
LDA zp7C ; channel number
PHA ; check drive and initialize
JSR S_C722
PLA
STA zp7C
LDX V_0274 ; length of filename
DEX
BNE B_CC97 ; greater than one?
LDA #$01
JSR S_D338 ; layout buffer and channel
JMP L_CCE3 ; set flags, done
;
B_CC92 LDA #$70
JMP L_C2B2 ; 70, 'no channel'
;
B_CC97 LDY #$01
JSR B_CD6E ; get buffer number
LDX V_0285 ; buffer number
CPX #$05 ; bigger than 5?
BCS B_CC92 ; 70, 'no channel'
LDA #$00
STA zp6E
STA zp6E+1
SEC
B_CCAA ROL zp6E
ROL zp6E+1
DEX
BPL B_CCAA
LDA zp6E
AND V_024F
BNE B_CC92
LDA zp6E+1
AND V_0250
BNE B_CC92
LDA zp6E
ORA V_024F
STA V_024F
LDA zp6E+1
ORA V_0250
STA V_0250
LDA #$00
JSR S_D338 ; search channel
LDX zp7B ; channel number
LDA V_0285 ; buffer number
STA zpA8,X
TAX
LDA zp78 ; drive number
STA zp02,X
STA V_025B,X
L_CCE3 LDX zp7C ; secondary address
LDA V_022B,X
ORA #$40 ; set READ and WRITE flags
STA V_022B,X
LDY zp7B ; channel number
LDA #$FF
STA V_0244,Y ; end pointer
LDA #$89
STA $00F3,Y ; set READ and WRITE flags
LDA $00A8,Y ; buffer number
STA V_023E,Y
ASL A ; times 2
TAX
LDA #$01
STA zp9A,X ; buffer pointer to one
V_CD05 LDA #$0E
STA $00ED,Y ; flag for direct access
JMP L_C27E ; done
; Perform [B] - Block/Buffer command
LDY #$00
LDX #$00
LDA #$2D ; '-'
JSR S_C352 ; search for minus sign
BNE B_CD22 ; found?
B_CD18 LDA #$31
JMP L_C2B2 ; 31, 'syntax error'
;
B_CD1D LDA #$30
JMP L_C2B2 ; 30, 'syntax error'
;
B_CD22 TXA
BNE B_CD1D
LDX #$05
LDA V_0200,Y ; char from buffer
B_CD2A CMP V_CD4F,X ; compare with 'AFRWEP'
BEQ B_CD34 ; found?
DEX
BPL B_CD2A ; compare with all characters
BMI B_CD18 ; not found, error
B_CD34 TXA
ORA #$80 ; command number, set bit 7
STA V_022A
JSR S_CD5F + 2 ; get parameters
LDA V_022A
ASL A ; number times 2
TAX ; as index
LDA V_CD56,X ; address of command hi
STA zp6E+1
LDA V_CD54 + 1,X ; address lo
B_CD4A STA zp6E
JMP ($006E) ; *** Indirect jump to command
;
V_CD4F EOR (zp45+1,X) ; AFRWEP
; $CD51
DB "R"
; $CD52
DB "WE"
V_CD54 BVC B_CD4A + 1
V_CD56 CMP V_CDE6 + 1
PHA
DEC V_CE65
; $CD5D
DB $97,$CE
S_CD5F LDX V_A0CE
BRK
LDX #$00 ; Get parameters form block commands
LDA #$3A ; ':'
JSR S_C352 ; test line to colon
BNE B_CD6E ; found?
LDY #$03 ; no, begin at 4th character
B_CD6E LDA V_0200,Y ; search for separating char
CMP #$20 ; ' ' blank
BEQ B_CD7D
CMP #$1D ; cursor right
BEQ B_CD7D
CMP #$2C ; ',' comma
BNE B_CD84
B_CD7D INY
CPY V_0274 ; line end?
BCC B_CD6E
RTS
;$CD84 --------
B_CD84 JSR S_CD93 ; preserve next parameter
INC V_0277 ; increment parameter counter
LDY V_0279
CPX #$04 ; compare with maximum number
BCC B_CD7D
BCS B_CD1D ; 30, 'syntax error'
S_CD93 LDA #$00
STA zp6E
STA zp6E+1 ; erase storage area for decimal numbers
STA zp70+1
LDX #$FF
B_CD9D LDA V_0200,Y ; get characters from input buffer
CMP #$40
BCS B_CDBC ; no digits?
CMP #$30 ; '0'
BCC B_CDBC ; no digits?
AND #$0F ; convert ASCII digits to hex
PHA ; and save
LDA zp6E+1
STA zp70 ; move digits one further
LDA zp6E
STA zp6E+1
PLA
STA zp6E ; note read number
INY ; increment pointer in input buffer
CPY V_0274 ; line end reached
BCC B_CD9D ; no
B_CDBC STY V_0279 ; save pointer
CLC
LDA #$00
B_CDC2 INX
CPX #$03
BCS B_CDD6 ; convert hex digits to one byte
LDY zp6E,X
B_CDC9 DEY
BMI B_CDC2
ADC V_CDE4,X ; add decimal value
BCC B_CDC9
CLC
INC zp70+1
BNE B_CDC9
B_CDD6 PHA
LDX V_0277 ; counter for paramaters
LDA zp70+1
STA V_0280,X ; hi-byte
PLA
STA V_0285,X ; lo-byte
RTS
;$CDE4 -------- Decimal values 1, 10, 100
V_CDE4 DB $01,$0A,$64
; -------- B-F block free
V_CDE7 DB " " ; get track, sector and drive number
INC zpCE
JSR S_EDCA ; free block
JMP L_C27E ; done, prepare error message
;
LDA #$01
STA V_02F9
;
; B-A block allocate
;
JSR S_CEE6 ; get track, sector and drive number
LDA zp7A ; sector
PHA ; save
JSR S_F065 ; find block in BAM
BEQ B_CE0B ; block allocated?
PLA ; desired sector
CMP zp7A ; = next free sector?
BNE B_CE1E ; no
JSR S_EDFB ; allocate block in BAM
JMP L_C27E ; done
;
B_CE0B PLA
B_CE0C LDA #$00
STA zp7A ; sector 0
INC zp79 ; next track
LDA zp79 ; track number
CMP V_F11A ; 36, last track number + 1
BCS B_CE23 ; >=, then 'no block'
JSR S_F065 ; find free block in next track
BEQ B_CE0C ; not found, check next track
B_CE1E LDA #$65
JSR S_E781 ; 65, 'no block' next free block
B_CE23 LDA #$65
JSR L_C2B2 ; 65, 'no block' no more free blocks
;
; Read block to buffer
;
S_CE28 JSR S_CEE3 ; open channel, set parameters
JMP S_D5B3 ; read block from disk
;
S_CE2E JSR S_D23F ; set pointer to buffer
LDA (zp9A,X) ; get byte
RTS
;$CE34 -------- Read block from disk
S_CE34 JSR S_CE28 ; open channel, read block
LDA #$00
JSR S_D61B ; set buffer pointer to zero
JSR S_CE2E ; get a byte from the buffer
STA V_0244,Y
LDA #$89 ; set read and write flag
STA $00F3,Y
RTS
;$CE48 -------- B-R block read
JSR S_CE34 ; read block from disk
JSR S_D53F ; prepare byte from buffer
S_CE4E JMP L_C27E ; prepare error message
;
; U1, Block read without changing buffer pointer
;
JSR S_CD5F + 2 ; get parameters of the command
JSR S_CE34 ; read block from disk
LDA V_0244,Y ; end pointer
STA V_023E,Y ; save as data byte
LDA #$FF
STA V_0244,Y ; end pointer to $FF
JMP L_C27E ; done, prepare error message
;
; B-W block write
;
V_CE65 JSR S_CEE3 ; open channel
JSR S_D63B ; set buffer pointer
TAY
DEY
CMP #$02 ; buffer pointer lo less than 2?
BCS B_CE73 ; no
LDY #$01
B_CE73 LDA #$00
JSR S_D61B ; buffer pointer to zero
TYA
JSR S_D10D ; write byte in buffer
TXA
PHA
JSR S_D5B7 ; write block to disk
PLA
TAX
LDY zp7B
JSR S_D541 ; get byte from buffer
JMP L_C27E ; done, error message
;
; U2, Block write without changing buffer pointer
;
V_CE8B JSR S_CD5F + 2 ; get command parameters
JSR S_CEE3 ; open channel
JSR S_D5B7 ; and write block to disk
JMP L_C27E ; done
;
; B-E block execute
;
JSR S_CE28 ; open channel and read block
LDA #$00
STA zp6E ; address low
LDX zp98 ; buffer number
LDA V_F123,X ; buffer address high
STA zp6E+1
JSR S_CEAB ; execute routine
JMP L_C27E ; done
;
S_CEAB JMP ($006E) ; *** Indirect jump to routine
;
; B-P block pointer
;
JSR S_CEC3 ; open channel, get buffer number
LDA zp98 ; buffer number
ASL A ; * 2
TAX ; as index
LDA V_0286 ; pointer value
STA zp9A,X ; save as buffer pointer
JSR S_D23F ; prepare a byte in buffer
JSR S_D541 ; for output
JMP L_C27E ; done
;
; Open channel
;
S_CEC3 LDX zp99
INC zp99
LDA V_0285,X ; buffer number
TAY
DEY
DEY
CPY #$0C ; buffer number smaller than 14?
BCC B_CED6 ; yes
B_CED1 LDA #$70
JMP L_C2B2 ; 70, 'no channel'
;
B_CED6 STA zp7C ; secondary address
JSR S_D1FB ; open channel
BCS B_CED1 ; already allocated, 'no channel'
JSR S_E0CE ; buffer number
STA zp98 ; set
RTS
;$CEE3 -------- Check buffer number and open channel
S_CEE3 JSR S_CEC3 ; check buffer number and open channel
S_CEE6 LDX zp99 ; channel number
LDA V_0285,X ; buffer address
AND #$01
STA zp78 ; drive number
LDA V_0287,X
STA zp7A ; sector
LDA V_0286,X
STA zp79 ; track
JSR S_D6B0 ; track and sector ok?
RTS
;$CEFD -------- Set pointer for REL file
S_CEFD JSR S_CF1B ; record number * record length
JSR S_CF5D ; divide by 254
LDA zp89 ; remainder = pointer in data block
STA zp94 ; data pointer
JSR S_CF60 ; divide by 120 = side-sector number
INC zp94
INC zp94 ; data pointer + 2 (track/sector pointer!)
LDA zp84 ; result of division
STA zp92 ; equals side-sector number
LDA zp89 ; remainder
ASL A ; times 2
CLC
ADC #$10 ; plus 16
STA zp93 ; =pointer in side-sector to data block
RTS
;$CF1B --------
S_CF1B JSR S_CF8F ; erase work storage
STA zp8B
LDX zp7B ; channel number
LDA zpB6,X ; record number lo
STA zp89
LDA zpBC,X ; record number hi
STA zp8A
BNE B_CF30
LDA zp89
BEQ B_CF3B ; record number not zero?
B_CF30 LDA zp89
SEC
SBC #$01 ; then subtract one
STA zp89
BCS B_CF3B
DEC zp8A
B_CF3B LDA zpC8,X ; record length
STA zp6E
B_CF3F LSR zp6E
BCC B_CF46
JSR S_CFA3 ; record number * record length
B_CF46 JSR S_CF9B ; shift register left
LDA zp6E
BNE B_CF3F
LDA zp91
CLC
ADC zp84
STA zp84
BCC B_CF5C ; result in $8B/$8C/$8D
INC zp85
BNE B_CF5C
INC zp86
B_CF5C RTS
;$CF5D -------- Divide by 254
S_CF5D LDA #$FE
DB $2C
; Divide by 120
S_CF60 LDA #$78
BIT V_06A9
STA zp6E ; divisor
LDA #$00
STA zp89
STA zp8A
LDX #$18
B_CF6F ASL zp84
ROL zp85
ROL zp86
ROL zp89
ROL zp8A
LDA zp89
SEC
SBC zp6E
TAY
LDA zp8A
SBC #$00
BCC B_CF8B
INC zp84
STA zp8A
STY zp89
B_CF8B DEX
BNE B_CF6F
RTS
;$CF8F -------- Erase work storage
S_CF8F LDA #$00
STA zp84
STA zp85
STA zp86
RTS
;$CF98 -------- Left shift 3-byte register twice
JSR S_CF9B
; Left shift 3-byte register once
S_CF9B CLC
ROL zp89
ROL zp8A
ROL zp8B
RTS
;$CFA3 -------- Add 3-byte registers
S_CFA3 CLC
LDX #$FD
B_CFA6 LDA zp87,X ; register $84/$85/$86
ADC zp8C,X ; add to register $89/$8a/$8b
STA zp87,X
INX
BNE B_CFA6
RTS
;$CFB0 --------
S_CFB0 LDX #$00
B_CFB2 TXA
STA zpD4,X
INX
CPX #$04
BNE B_CFB2
LDA #$06
STA zpD4,X
RTS
;$CFBF --------
S_CFBF LDY #$04
LDX zp7B ; channel number
L_CFC3 LDA $00D4,Y
STX zpD4,Y
CMP zp7B ; channel number
BEQ B_CFD3
DEY
BMI S_CFB0
TAX
JMP L_CFC3
;
B_CFD3 RTS
;$CFD4 --------
S_CFD4 JSR S_CFBF
LDX zp7B
LDA zpA8,X
BMI B_CFDF
LDA zpAF,X
B_CFDF CMP #$FF
BEQ B_CFFB
LDA zpA8,X
EOR #$80
STA zpA8,X
PHA
LDA zpAF,X
EOR #$80
STA zpAF,X
TAY
PLA
BPL B_CFF5
TYA
B_CFF5 AND #$BF
TAX
JMP S_D6EC
;
B_CFFB LDA zpA8,X
BPL B_D001
LDA zpAF,X
B_D001 AND #$BF
TAY
LDA V_025B,Y
AND #$01
STA zp78
JSR S_D3E4
BPL B_D015
LDA #$70
JMP L_C2B2
;
B_D015 LDX zp7B
ORA #$80
LDY zpA8,X
BPL B_D021
STA zpA8,X
BMI B_D023
B_D021 STA zpAF,X
B_D023 LDA zp79 ; track
PHA
LDA zp7A ; sector
PHA
LDA #$01
STA zp70
LDA zpA8,X
BPL B_D033
LDA zpAF,X
B_D033 AND #$BF
TAY
LDA V_F123,Y
STA zp70+1
LDY #$00
LDA (zp70),Y
STA zp7A
LDA #$00
STA zp70
LDA zpA8,X
BPL B_D04B
LDA zpAF,X
B_D04B AND #$BF
TAY
LDA V_F123,Y
STA zp70+1
LDY #$00
LDA (zp70),Y
STA zp79
BEQ B_D085
JSR S_D235
BEQ B_D06B
JSR S_DEE6
BNE B_D06B
JSR S_D0AB
JMP L_D07C
;
B_D06B LDX zp7B
LDA zpA8,X
EOR #$80
STA zpA8,X
LDA zpAF,X
EOR #$80
STA zpAF,X
JSR S_DF92
L_D07C PLA
STA zp7A ; get sector
PLA
STA zp79 ; and track number
JMP L_D08E
;
B_D085 PLA
STA zp7A ; get back sector
PLA
STA zp79 ; and track number
JSR S_D0AB
L_D08E JSR S_E0CE
TAX
JMP S_D6EC ; and verify
;
B_D095 LDA #$70
JMP L_C2B2 ; 70, 'no channel'
;
S_D09A JSR S_CFBF
JSR S_E0F2
BNE B_D0AA
JSR S_D3E4
BMI B_D095
JSR S_E0FD
B_D0AA RTS
;$D0AB -------- Change buffer
S_D0AB LDX zp7B ; channel number
LDA zpA8,X
EOR #$80
STA zpA8,X
LDA zpAF,X ; rotate bit 7 in table
EOR #$80
STA zpAF,X
RTS
;$D0BA -------- Write data in buffer
S_D0BA LDX #$12 ; channel 18
STX zp7C
JSR S_D217 ; open write channel
JSR S_D235 ; check file type
BCC B_D0CB ; no rel-file
LDA #$20
JSR B_DED8 ; change buffer
B_D0CB LDA zp7C ; secondary address
CMP #$0F ; 15?
BEQ B_D0F4 ; yes
BNE B_D0DB ; no
S_D0D3 LDA zp7D ; secondary address
AND #$8F
CMP #$0F ; greater than 15?
BCS B_D0F4 ; then input buffer
B_D0DB JSR S_D235 ; check file type
BCS B_D0E5 ; rel-file or direct access?
LDA zp7E ; data byte
JMP L_D2F3 ; write in buffer
;
B_D0E5 BNE B_D0EA ; direct access file?
JMP L_E1E6 ; write data byte in rel-file
;
B_D0EA LDA zp7E
JSR S_D10D ; write data byte in buffer
LDY zp7B ; channel number
JMP S_D541 ; prepare next byte for output
;
B_D0F4 LDA #$04 ; channel 4
STA zp7B ; corresponding input buffer
JSR S_D63B ; set buffer pointer
CMP #$2A ; 40
BEQ B_D104 ; buffer end?
LDA zp7E
JSR S_D10D ; write data byte in buffer
B_D104 LDA zp95 ; end flag set?
BEQ B_D109 ; yes
RTS
;$D109 --------
B_D109 INC V_0255 ; set command flag
RTS
;$D10D -------- Write data byte in buffer
S_D10D PHA ; save data byte
JSR S_E0CE ; get buffer number
BPL B_D119 ; associated buffer?
PLA
LDA #$61
JMP L_C2B2 ; 61, 'file not open'
;
B_D119 ASL A ; buffer number times 2
TAX ; as index
PLA ; data byte
STA (zp9A,X) ; write in buffer
INC zp9A,X ; increment buffer pointer
RTS
;$D121 -------- Perform [I] - Initalise command
JSR S_C2BB ; find drive number
JSR S_D15E ; load BAM
JMP L_C27E ; prepare disk status
;
; Read BAM from disk
;
S_D12A JSR S_EF7A
TAY
LDX zpA8,Y
CPX #$FF
BNE B_D148
PHA
JSR S_D3E4
TAX
BPL B_D140
LDA #$70
JSR S_E784 ; 70, 'no channel'
B_D140 PLA
TAY
TXA
ORA #$80
STA $00A8,Y
B_D148 TXA
AND #$0F
STA zp98
LDX #$00
STX zp7A ; sector 0
LDX V_F0C3 ; 18
STX zp79 ; track 18
JSR S_D808 ; transmit parameter to disk controller
LDA #$B0 ; command code 'read block header'
JMP B_D6DF ; transmit to disk controller
;
; Load BAM
;
S_D15E JSR S_EF3C
JSR S_D465
JSR S_D12A ; read block
LDX zp78 ; drive number
LDA #$00
STA V_0251,X ; reset flag for "BAM changed'
JSR L_D6D9
LDA zp98
ASL A
TAX
LDA #$02 ; buffer pointer to $200
STA zp9A,X
LDA (zp9A,X) ; get character from buffer
LDX zp78 ; drive number
STA zp5D,X
LDA #$00
STA zp22,X ; flag for write protect
STA zp5F,X ; flag for read error
;
; Calculate blocks free
;
L_D185 JSR S_EDA5 ; buffer address to $6C/$6D
LDY #$04 ; begin at position 4
LDA #$00
TAX
B_D18D CLC
ADC (zp6C),Y ; add number of free blocks per track
BCC B_D193
INX ; X as hi-byte
B_D193 INY
INY
INY
INY ; plus 4
CPY #$48 ; track 18?
BEQ B_D193 ; then skip
CPY #$90 ; last track number?
BNE B_D18D ; no
PHA ; lo-byte
TXA ; hi-byte
LDX zp78 ; drive number
STA V_02FC,X ; hi-byte to $2FC
PLA ; lo-byte
STA V_02FA,X ; to $2FA
RTS
;$D1AB --------
S_D1AB JSR S_D805 ; parameters to disk controller
JSR S_D1D3 ; read block
JSR S_D6EC ; ok?
JSR S_D247 ; get byte from buffer
STA zp79 ; track
JSR S_D247 ; next byte from buffer
STA zp7A ; sector
RTS
;$D1BF --------
L_D1BF JSR S_D1AB
LDA zp79 ; track
BNE B_D1C7
RTS
;$D1C7 --------
B_D1C7 JSR S_CFD4 ; change buffer
JSR S_D805 ; parameters to disk controller
JSR S_D1D3 ; read block
JMP S_CFD4 ; change buffer
;
; Read block
;
S_D1D3 LDA #$80 ; code for 'read'
BNE B_D1D9
S_D1D7 LDA #$90 ; code for 'write'
B_D1D9 STA V_024D ; save
JSR S_E0CE ; get buffer number
TAX
JSR L_D659 ; get track/sector, read/write block
TXA
PHA
ASL A ; buffer pointer times 2
TAX
LDA #$00
STA zp9A,X ; pointer in buffer to zero
JSR S_D235 ; get file type
CMP #$04 ; rel-file or direct access?
BCS B_D1F8 ; yes
INC zpB6,X
BNE B_D1F8 ; increment block counter
INC zpBC,X
B_D1F8 PLA
TAX
RTS
;$D1FB -------- Open channel for reading
S_D1FB LDA zp7C ; secondary address
CMP #$13 ; 19
BCC B_D203 ; smaller?
AND #$0F
B_D203 CMP #$0F
BNE B_D209
LDA #$10 ; 16
B_D209 TAX
SEC ; pre-set error
LDA V_022B,X ; channel number
BMI B_D216 ; reserved already? then return with Carry set
AND #$0F ; isolate channel nr
STA zp7B ; save as current channel
TAX ; ... to X
CLC ; flag for ok
B_D216 RTS
;$D217 -------- Open channel for write
S_D217 LDA zp7C ; secondary address
CMP #$13 ; 19
BCC B_D21F ; smaller?
AND #$0F
B_D21F TAX
LDA V_022B,X ; channel number
TAY
ASL A
BCC B_D231
BMI B_D233
B_D229 TYA
AND #$0F
STA zp7B
TAX
CLC ; flag for ok
RTS
;$D231 --------
B_D231 BMI B_D229
B_D233 SEC ; flag for channel allocated
RTS
;$D235 -------- Get file type into accu
;
; also returns the Z flag set when REL ($04) type
;
S_D235 LDX zp7B
LDA zpED,X
LSR A
AND #$07
CMP #$04 ; 'REL'?
RTS
;$D23F -------- Get buffer and channel numbers
S_D23F JSR S_E0CE ; get buffer number
ASL A
TAX
LDY zp7B
RTS
;$D247 -------- Get a byte from buffer
S_D247 LDX zp7B ; get buffer and channel number
LDA zpA8,X
BPL B_D24F
LDA zpAF,X
B_D24F AND #$BF
ASL A
TAX
LDY zp7B
LDA V_0244,Y ; end pointer
BEQ B_D26C
LDA (zp9A,X) ; get byte from buffer
PHA
LDA zp9A,X ; buffer pointer
CMP V_0244,Y ; equal end pointer?
BNE B_D268 ; no
LDA #$FF ; buffer pointer to -1
STA zp9A,X
B_D268 PLA ; data byte
INC zp9A,X ; increment buffer pointer
RTS
;$D26C --------
B_D26C LDA (zp9A,X) ; get character from buffer
INC zp9A,X ; increment buffer pointer
RTS
;$D271 -------- Get byte and read next block
S_D271 JSR S_D247 ; get byte from buffer
BNE B_D2E7 ; not last character?
STA zp7E ; save data byte
LDA V_0244,Y ; end pointer
BEQ B_D285 ; yes
LDA #$80
STA $00F3,Y ; READ-flag
LDA zp7E ; data byte
RTS
;$D285 --------
B_D285 JSR S_CFD4 ; change buffer and read next block
LDA #$00
STA zp6E ; set buffer pointer to zero
LDX zp7B ; get channel number
LDA zpA8,X ; buffer number
BPL B_D294
LDA zpAF,X ; buffer number from 2nd table
B_D294 AND #$BF ; erase V bit
ASL A
TAX
LDA zp9B,X ; buffer pointer hi
STA zp8D+1
LDA zp6E
STA zp9A,X ; buffer pointer lo, new value
STA zp8D
JSR S_D247 ; get first byte from buffer
CMP #$00 ; track number zero
BEQ B_D2E8 ; yes, then last block
STA zp79 ; save last track number
JSR S_D247 ; get next byte
STA zp7A ; save as following track
JSR S_CFD4 ; change buffer and read next block
LDX zp7B
LDA zpA8,X
BPL B_D2BB
LDA zpAF,X ; get drive number
B_D2BB AND #$BF ; erase V bit
TAX
LDA V_025B,X ; isolate drive number
AND #$01
STA zp78 ; and save
LDX zp7B
LDA zpA8,X
BPL B_D2CD
LDA zpAF,X
; Transmit parameter to disk controller
B_D2CD AND #$BF
ASL A
TAY
LDA zp79 ; track number
STA $0008,Y ; transmit
LDA zp7A ; sector number
STA $0009,Y ; transmit
LDA zp78 ; drive number
ASL A ; * 2
TAX ; make an index from it
JSR S_D1D3 ; transmit read command
JSR S_CFD4 ; change buffer and read block
LDA zp7E ; get data byte
B_D2E7 RTS
;$D2E8 --------
B_D2E8 JSR S_D247 ; get next byte from buffer
LDY zp7B
STA V_0244,Y ; save as end pointer
LDA zp7E ; get data byte back
RTS
;$D2F3 -------- Write byte in buffer and block
L_D2F3 JSR S_D10D ; byte in buffer
BEQ B_D2F9 ; buffer full?
RTS
;$D2F9 --------
B_D2F9 JSR S_D329 ; get drive number
JSR S_EF89 ; find free block in BAM
LDA #$00
JSR S_D61B ; buffer pointer to zero
LDA zp79
JSR S_D10D ; track number as first byte
LDA zp7A
JSR S_D10D ; sector number as second byte
JSR S_D1D7 ; write block
JSR S_CFD4 ; change buffer
JSR S_D805 ; parameter to disk controller
LDA #$02
JMP S_D61B ; buffer pointer to 2
;
S_D31C STA zp6E
JSR S_D63B ; get buffer pointer
CLC
ADC zp6E
STA zp9A,X ; and increment
STA zp8D
RTS
;$D329 -------- Get drive number
S_D329 JSR S_E0CE ; get drive number
TAX
LDA V_025B,X
AND #$01 ; isolate drive number
STA zp78 ; and save
RTS
;$D335 -------- Find write channel and buffer
S_D335 SEC ; flag for writing
BCS B_D339
;
; Find read channel and buffer
;
S_D338 CLC ; flag for reading
B_D339 PHP ; save
STA zp6E ; buffer number
JSR L_D37D ; close channel
JSR S_D4D1 ; allocate free channel
STA zp7B ; channel number
LDX zp7C ; secondary address
PLP
BCC B_D34B ; read channel?
ORA #$80 ; flag for writing
B_D34B STA V_022B,X ; set
AND #$3F
TAY
LDA #$FF ; default value
STA $00A8,Y
STA $00AF,Y ; write in associated table
STA $00CE,Y
DEC zp6E ; decrement buffer number
BMI B_D37C ; done already?
JSR S_D3E4 ; find buffer
BPL B_D36D ; found?
L_D365 JSR S_D3B0 ; erase flags in table
LDA #$70
JMP L_C2B2 ; 70, 'no channel'
;
B_D36D STA $00A8,Y ; buffer number in table
DEC zp6E ; buffer number
BMI B_D37C ; already done?
JSR S_D3E4 ; find buffer
BMI L_D365 ; not found?
STA $00AF,Y ; buffer number in table
B_D37C RTS
;$D37D -------- Close channel
L_D37D LDA zp7C ; secondary address
CMP #$0F ; 15?
BNE B_D384 ; no
RTS ; else done already
;$D384 --------
B_D384 LDX zp7C
LDA V_022B,X ; channel number
CMP #$FF ; not associated (=free)?
BEQ B_D3AF ; then done
AND #$3F
STA zp7B ; channel number
LDA #$FF
STA V_022B,X ; erase association in table
LDX zp7B
LDA #$00
STA zpF3,X ; erase READ and WRITE flag
JSR S_D3B0 ; free buffer
LDX zp7B ; channel number
LDA #$01 ; set bit 0
B_D3A3 DEX
BMI B_D3A9 ; shift to correct position
ASL A
BNE B_D3A3
B_D3A9 ORA V_0256 ; free in allocation register
STA V_0256
B_D3AF RTS
;$D3B0 -------- Free buffer
S_D3B0 LDX zp7B ; channel number
LDA zpA8,X ; buffer number
CMP #$FF
BEQ B_D3C1 ; not associated?
PHA
LDA #$FF
STA zpA8,X ; erase buffer association
PLA
JSR S_D445 ; erase buffer allocation register
B_D3C1 LDX zp7B ; channel number
LDA zpAF,X
CMP #$FF ; associated in second table?
BEQ B_D3D2 ; no
PHA
LDA #$FF
STA zpAF,X ; erase association
PLA
JSR S_D445 ; erase buffer in allocation register
B_D3D2 LDX zp7B ; channel number
LDA zpCE,X
CMP #$FF ; associated in 3rd table?
BEQ B_D3E3 ; no
PHA
LDA #$FF
STA zpCE,X ; erase association
PLA
JSR S_D445 ; erase buffer in allocation register
B_D3E3 RTS
;$D3E4 -------- Find buffer
S_D3E4 TYA
PHA
LDY #$01
JSR S_D40C
BPL B_D3F9
DEY
JSR S_D40C
BPL B_D3F9
JSR S_D48B
TAX
BMI B_D408
B_D3F9 LDA zp78
STA zp02,X
STA V_025B,X
TXA
ASL A
TAY
LDA #$02
STA $009A,Y
B_D408 PLA
TAY
TXA
RTS
;$D40C --------
S_D40C LDX #$07
B_D40E LDA V_024F,Y
AND V_EE54,X ; erase bit
BEQ B_D41A
DEX
BPL B_D40E
RTS
;$D41A --------
B_D41A LDA V_024F,Y
EOR V_EE54,X ; rotate bit
STA V_024F,Y
TXA ; buffer number
DEY
BMI B_D42A
CLC
ADC #$08
B_D42A TAX ; buffer number
B_D42B RTS
;$D42C --------
L_D42C LDX zp7B
LDA zpA8,X
BMI B_D43B
TXA
CLC
ADC #$07
TAX
LDA zpA8,X
BPL B_D42B
B_D43B CMP #$FF
BEQ B_D42B
PHA
LDA #$FF
STA zpA8,X
PLA
S_D445 AND #$0F
TAY ; buffer number
INY
LDX #$10 ; 16
B_D44B ROR V_0250
ROR V_024F ; rotate 16-bit allocation register
DEY
BNE B_D455
CLC ; erase bit for buffer
B_D455 DEX
BPL B_D44B
RTS
;$D459 -------- Close all channels
S_D459 LDA #$0E ; 14
STA zp7C ; secondary address
B_D45D JSR L_D37D ; close channel
DEC zp7C ; next secondary address
BNE B_D45D
RTS
;$D465 -------- Close all channels of other drives
S_D465 LDA #$0E ; 14
STA zp7C ; secondary address
B_D469 LDX zp7C
LDA V_022B,X ; association table
CMP #$FF ; channel associated?
BEQ B_D486 ; no
AND #$3F
STA zp7B ; channel number
JSR S_E0CE ; get buffer number
TAX
LDA V_025B,X ; drive number
AND #$01 ; isolate
CMP zp78 ; equal to actual drive number
BNE B_D486 ; no
JSR L_D37D ; close channel
B_D486 DEC zp7C ; next channel
BPL B_D469
RTS
;$D48B --------
S_D48B LDA zp6E
PHA
LDY #$00
B_D490 LDX zpD4,Y
LDA zpA8,X
BPL B_D49A
CMP #$FF
BNE B_D4B0
B_D49A TXA
CLC
ADC #$07
TAX
LDA zpA8,X
BPL B_D4A7
CMP #$FF
BNE B_D4B0
B_D4A7 INY
CPY #$05
BCC B_D490
LDX #$FF
BNE B_D4CC
B_D4B0 STX zp6E
AND #$3F
TAX
B_D4B5 LDA zp02,X
BMI B_D4B5
CMP #$02
BCC B_D4C5
LDX zp6E
CPX #$07
BCC B_D49A
BCS B_D4A7
B_D4C5 LDY zp6E
LDA #$FF
STA $00A8,Y
B_D4CC PLA
STA zp6E
TXA
RTS
;$D4D1 -------- Find channel and allocate
S_D4D1 LDY #$00
LDA #$01 ; set bit 0
B_D4D5 BIT V_0256
BNE B_D4E3 ; channel free?
INY
ASL A ; rotate bit to left
BNE B_D4D5 ; all channels checked?
LDA #$70
JMP L_C2B2 ; 70, 'no channel'
;
B_D4E3 EOR #$FF ; rotate bit model
AND V_0256 ; erase bit
STA V_0256 ; allocate channel
TYA
RTS
;$D4ED -------- Get byte for output
S_D4ED JSR S_D1FB ; open channel for reading
JSR S_D4F9 ; get byte in output register
LDX zp7B ; channel number
LDA V_023E,X ; get byte
RTS
;$D4F9 --------
S_D4F9 LDX zp7B ; channel number
LDA zpED,X ; check file type
LSR A
AND #$07
CMP #$04 ; REL?
BNE B_D507 ; no...
JMP L_E25B ; get byte from REL-file
;
B_D507 LDA zp7C ; secondary address
CMP #$0F ; 15
BEQ B_D567 ; yes, read error channel
LDA zpF3,X
AND #$08 ; end flag set?
BNE B_D526 ; no
JSR S_D235 ; check file type
CMP #$07 ; direct access file?
BNE B_D521 ; no
LDA #$89 ; set READ and WRITE flag
STA zpF3,X
JMP L_D531
;
B_D521 LDA #$00
STA zpF3,X ; erase READ and WRITE flag
RTS
;$D526 --------
B_D526 LDA zp7C ; secondary address
BEQ B_D55C ; zero, LOAD?
JSR S_D235 ; check file type
CMP #$04 ; rel-file or direct access?
BCC B_D553 ; no
L_D531 JSR S_D23F ; get buffer and channel number
LDA zp9A,X ; buffer pointer
CMP V_0244,Y ; equal end pointer?
BNE S_D53F ; no
LDA #$00
STA zp9A,X ; buffer pointer to zero
S_D53F INC zp9A,X ; increment buffer pointer
S_D541 LDA (zp9A,X) ; get byte from buffer
STA V_023E,Y ; into output register
LDA zp9A,X ; buffer pointer
CMP V_0244,Y ; equal end pointer?
BNE B_D552 ; no
LDA #$81
STA $00F3,Y ; set flags
B_D552 RTS
;$D553 --------
B_D553 JSR S_D271 ; get byte from buffer
L_D556 LDX zp7B ; channel number
STA V_023E,X ; byte in output register
RTS
;$D55C --------
B_D55C LDA V_0254 ; flag for directory?
BEQ B_D553 ; no
JSR S_EBD4 ; create directory line
JMP L_D556
;
B_D567 JSR S_D63B ; set buffer pointer
CMP #$D4
BNE B_D586
LDA zp8D+1
CMP #$02
BNE B_D586
LDA #$0D ; CR
STA zp7E ; in output register
JSR S_F3F0 ; erase error flags
LDA #$00
JSR S_E800 ; create 'ok' message
DEC zpA6 ; set buffer pointer back
LDA #$80 ; set READ flag
BNE B_D598
B_D586 JSR S_D247 ; get byte from buffer
STA zp7E ; into output register
BNE L_D596
L_D58D LDA #$D4
JSR S_D61B ; set buffer pointer in front of error pointer
LDA #$02
STA zp9B,X ; hi-address
L_D596 LDA #$88 ; set READ flag
B_D598 STA zpF8
LDA zp7E ; data byte
STA V_0243 ; into output register
RTS
;$D5A0 -------- Read next block
S_D5A0 JSR S_E0CE ; get buffer number
ASL A ; times 2
TAX ; make an index of it
LDA #$00
STA zp9A,X ; buffer pointer to zero
LDA (zp9A,X) ; get first byte from buffer
BEQ B_D5B2 ; no block following?
DEC zp9A,X ; buffer pointer to -1
JMP S_D271 ; read next block
;
B_D5B2 RTS
;$D5B3 -------- Read block
S_D5B3 LDA #$80 ; command code for reading
BNE B_D5B9 ; always jump
; Write block
S_D5B7 LDA #$90 ; command code for writing
B_D5B9 ORA zp78 ; drive number
STA V_024D ; save code
LDA zp98
JSR S_D808 ; parameter to disk controller
LDX zp98
JMP L_D6E6 ; execute command
;
; Allocate buffer and read block
;
S_D5C8 LDA #$01
S_D5CA STA V_024A ; file type to sequential
LDA #$11 ; 17
STA zp7C ; secondary address
JSR S_DD7D ; allocate buffer and read block
LDA #$02
JMP S_D61B ; buffer pointer to 2
;
; Allocate new block
;
S_D5D9 LDA #$12 ; 18
STA zp7C ; secondary address
JMP L_DE15 ; allocate new block
;
; Write dir block
;
S_D5E0 JSR S_DF76 ; get track and sector number
LDA #$01
STA zp6E ; a block
LDA zp68 ; save step width 10 for block
PHA ; allocation
LDA #$03
STA zp68
JSR S_EF98 ; find free block in BAM
PLA
STA zp68 ; get step width back
LDA #$00
JSR S_D61B ; buffer pointer to zero
LDA zp79
JSR S_D10D ; track number in buffer
LDA zp7A
JSR S_D10D ; sector number in buffer
JSR S_D1D7 ; write block to disk
JSR S_D6EC ; and verify
LDA #$00
JSR S_D61B ; buffer pointer to zero
B_D60E JSR S_D10D ; fill buffer with zeroes
BNE B_D60E
JSR S_D10D ; zero as following track
LDA #$FF
JMP S_D10D ; $FF as number of bytes
;
; Set buffer pointer
;
S_D61B STA zp6E ; save pointer
JSR S_E0CE ; get buffer number
ASL A ; times 2
TAX
LDA zp9B,X ; buffer pointer hi
STA zp8D+1
LDA zp6E
STA zp9A,X ; buffer pointer lo, new value
STA zp8D
RTS
;$D62D -------- Close internal channel
L_D62D LDA #$11 ; 17
STA zp7C
JSR L_D37D ; close channel
LDA #$12 ; 18
STA zp7C
JMP L_D37D ; close channel
;
; Set buffer pointer
;
S_D63B JSR S_E0CE ; get buffer number
L_D63E ASL A
TAX
LDA zp9B,X ; buffer pointer hi
STA zp8D+1
LDA zp9A,X ; buffer pointer lo
STA zp8D
RTS
;$D649 -------- Get byte from buffer
S_D649 STA zp70 ; pointer lo
JSR S_E0CE ; get buffer number
TAX
LDA V_F123,X ; hi-byte buffer address
STA zp70+1 ; pointer hi
LDY #$00
LDA (zp70),Y ; get byte from buffer
RTS
;$D659 -------- Check track and sector numbers
L_D659 LDA V_025B,X ; command code for disk controller
AND #$01 ; drive number
ORA V_024D ; plus command code
S_D661 PHA ; save
STX zp98 ; buffer number
TXA
ASL A ; times 2
TAX
LDA zp09,X ; sector
STA V_024D ; save
LDA zp08,X ; track
BEQ B_D69B ; 66, 'illegal track or sector'
CMP V_F11A ; 36, highest track number + 1
BCS B_D69B ; 66, 'illegal track or sector'
TAX
PLA ; command code
PHA
AND #$F0
CMP #$90 ; code for writing?
BNE B_D6CB ; no
PLA
PHA
LSR A
BCS B_D687
LDA zp5D
BCC B_D689
B_D687 LDA zp5E
B_D689 BEQ B_D690
CMP V_F118 ; 'A', format marker
BNE L_D6C3 ; 73, 'cbm dos v2.6 tdisk'
B_D690 TXA ; track number
JSR S_F0B6 ; get maximum sector number
CMP V_024D ; compare with sector number
BEQ B_D69B ; equal, then error
BCS B_D6CB ; smaller?
B_D69B JSR S_D6A3 ; get track and sector number
B_D69E LDA #$66
JMP S_E781 ; 66, 'illegal track or sector'
;
; Get track and sector numbers for current job
;
S_D6A3 LDA zp98 ; buffer number
ASL A ; *2
TAX ; as index
LDA zp08,X
STA zp79 ; track
LDA zp09,X
STA zp7A ; sector
RTS
;$D6B0 -------- Check for valid track and sector numbers
S_D6B0 LDA zp79 ; track
BEQ B_D69E ; zero, then error
CMP V_F11A ; 36, maximum track number + 1
BCS B_D69E ; 66, 'illegal track and sector number'
JSR S_F0B6 ; get maximum sector number
CMP zp7A ; sector
BEQ B_D69E
BCC B_D69E ; error
RTS
;$D6C3 -------- DOS mismatch error
L_D6C3 JSR S_D6A3 ; get track and sector number
LDA #$73
JMP S_E781 ; 73, 'cbm dos v2.6 tdisk'
;
B_D6CB LDX zp98 ; buffer number
PLA
STA V_024D ; command code for disk controller
STA V_025B,X ; write in table
STA zp02,X ; and in command register
JMP S_D819
;
; Read block
;
L_D6D9 LDA #$80 ; code for read
BNE B_D6DF ; always jump
; Write block
L_D6DD LDA #$90 ; code for write
B_D6DF ORA zp78 ; drive number
LDX zp98 ; buffer number
S_D6E3 STA V_024D
L_D6E6 LDA V_024D ; command code
JSR S_D661 ; check track and sector
; Verify execution
S_D6EC JSR S_D6F9 ; verify execution
BCS S_D6EC ; wait for end
PHA
LDA #$00
STA V_0298 ; erase error flag
PLA
RTS
;$D6F9 --------
S_D6F9 LDA zp02,X ; command code (bit 7) still in register?
CMP #$02 ; yes
BCC B_D713 ; error-free execution
CMP #$08 ; 8?
BEQ B_D70B ; write protect
CMP #$0B ; 11
BEQ B_D70B ; ID mismatch
CMP #$0F ; 15
BNE B_D715
B_D70B BIT V_0298
BMI B_D713
JMP B_D78A ; create error message
;
B_D713 CLC ; execution ended
RTS
;$D715 -------- Additional attempts for read errors
B_D715 TYA
PHA
LDA zp78 ; drive number
PHA
LDA V_025B,X
AND #$01 ; drive number
STA zp78
JSR L_F3F7 ; set LED flag
JSR S_D7F0 ; read attempt
CMP #$02
BCS B_D72E ; not ok?
JMP L_D7B7 ; done
;
B_D72E LDA V_025B,X ; command code
AND #$F0 ; isolate
PHA
CMP #$90 ; code for write
BNE B_D73F ; no
LDA zp78 ; drive number
ORA #$B8
STA V_025B,X
B_D73F BIT zp69
BVS B_D77C
LDA #$00
STA V_0299 ; counter for searches next to track
STA V_029A
B_D74B LDY V_0299 ; counter
LDA V_029A
SEC
SBC V_F11C + 2,Y ; constants for read attempts
STA V_029A
LDA V_F11C + 2,Y
JSR S_D7C5 ; position head next to track
INC V_0299 ; increment counter
JSR S_D7F0 ; read attempt
CMP #$02 ; return message
BCC B_D770 ; smaller than 2, ok?
LDY V_0299 ; load counter
LDA V_F11C + 2,Y ; get constants
BNE B_D74B ; not yet zero (table end)?
B_D770 LDA V_029A
JSR S_D7C5 ; position head
LDA zp02,X
CMP #$02 ; return message
BCC B_D7A6 ; ok?
B_D77C BIT zp69
BPL B_D78F
B_D780 PLA ; command code
CMP #$90 ; for writing?
BNE B_D78A ; no
ORA zp78 ; drive number
STA V_025B,X ; command code in table
B_D78A LDA zp02,X ; return message
JSR L_E746 ; set error message
B_D78F PLA
BIT V_0298
BMI L_D7B7
PHA
LDA #$C0 ; command code for head positioning
ORA zp78 ; drive number
STA zp02,X ; in command register
JSR S_D819 ; wait for execution
JSR S_D7F0 ; attempt command execution again
CMP #$02 ; return message
BCS B_D780 ; incorrect?
B_D7A6 PLA
CMP #$90 ; command code for writing
BNE L_D7B7 ; no
ORA zp78 ; drive number
STA V_025B,X ; in table
JSR S_D7F0 ; attempt execution again
CMP #$02 ; return message
BCS B_D78A ; error?
L_D7B7 PLA
STA zp78 ; get drive number back
PLA
TAY
LDA zp02,X ; error code
PHA
JSR S_F3F0
PLA
CLC ; end-of-execution flag
RTS
;$D7C5 -------- Move head by half a track
S_D7C5 CMP #$00
BEQ B_D7E1
BMI B_D7D7
B_D7CB LDY #$01
JSR S_D7E2 ; transmit data for head position
SEC
SBC #$01
BNE B_D7CB
BEQ B_D7E1
B_D7D7 LDY #$FF
JSR S_D7E2 ; transmit data for head position
CLC
ADC #$01
BNE B_D7D7
B_D7E1 RTS
;$D7E2 -------- Move head one track in or out
S_D7E2 PHA
TYA
STA zp54
B_D7E6 CMP zp54 ; wait for return message from...
BEQ B_D7E6
LDA #$00 ; ...disk controller
STA zp54
PLA
RTS
;$D7F0 -------- Attempt command execution multiple times
S_D7F0 LDA zp69 ; maximum number of repetitions
AND #$3F
TAY
B_D7F5 LDA V_025B,X ; command
STA zp02,X ; transmit to disk controller
JSR S_D819 ; wait for execution
CMP #$02 ; ok?
BCC B_D804 ; yes
DEY ; decrement counter
BNE B_D7F5 ; attempt again
B_D804 RTS
;$D805 -------- Transmit param to disk controller
S_D805 JSR S_E0CE ; get buffer number
;
S_D808 ASL A ; track number
TAY
LDA zp79 ; track number
STA $0008,Y ; transmit
LDA zp7A ; sector number
STA $0009,Y ; transmit
LDA zp78 ; drive number
ASL A ; times 2
TAX
RTS
;$D819 --------
S_D819 LDA zp02,X ; wait for execution
BMI S_D819
RTS
;$D81E -------- Enter file in dir
S_D81E LDA zp7C ; secondary address
PHA
LDA zp7B ; channel number
PHA
LDA zp7A ; sector number
PHA
LDA zp79 ; track number
PHA ; save
LDA #$11 ; 17
STA zp7C ; as secondary address
JSR S_DF76 ; get track and sector number
LDA V_024A ; file type
PHA ; save
LDA zpE3 ; drive number
AND #$01
STA zp78 ; set
LDX zp98 ; buffer number
EOR V_025B,X
LSR A
BCC B_D84F ; equal drive number?
LDX #$01
STX V_0292 ; pointer in directory
JSR S_C691 ; load dir and find first entry
BEQ B_D86A ; not found?
BNE B_D877 ; found?
B_D84F LDA V_0291 ; sector number in directory
BEQ B_D860 ; equal zero?
CMP zp7A ; equal sector number?
BEQ B_D877 ; yes
STA zp7A ; save sector number
JSR S_D5B3 ; read block
JMP B_D877
;
B_D860 LDA #$01
STA V_0292 ; pointer to one
JSR S_C6FC ; find next entry in directory
BNE B_D877 ; found?
B_D86A JSR S_D5E0 ; write directory block
LDA zp7A ; sector number
STA V_0291
LDA #$02
STA V_0292 ; pointer to 2
B_D877 LDA V_0292
JSR S_D61B ; set buffer pointer
PLA
STA V_024A ; file type
CMP #$04 ; rel-file?
BNE B_D887 ; no
ORA #$80 ; set bit 7
B_D887 JSR S_D10D ; and write in buffer
PLA
STA V_0280 ; following track
JSR S_D10D ; in buffer
PLA
STA V_0285 ; following sector
JSR S_D10D ; in buffer
JSR S_E0CE ; get buffer number
TAY
LDA V_027A ; pointer to drive number
TAX
LDA #$10 ; 16, length of filename
JSR S_C74F ; write filename in buffer
LDY #$10
LDA #$00
B_D8A9 STA (zp8D),Y ; fill with zeroes at position 16
INY
CPY #$1B ; position 27 already?
BCC B_D8A9 ; no
LDA V_024A ; file type
CMP #$04 ; rel-file?
BNE B_D8CA ; no
LDY #$10
LDA V_0259 ; track
STA (zp8D),Y
INY
LDA V_025A ; and sector
STA (zp8D),Y ; the side-sectors in directory entry
INY
LDA V_0258 ; record length
STA (zp8D),Y ; in directory
B_D8CA JSR S_D5B7 ; write block
PLA
STA zp7B ; channel number
TAX
PLA
STA zp7C ; secondary address
LDA V_0291
STA zpD9
STA V_0260,X
LDA V_0292
STA zpDE
STA V_0266,X
LDA V_024A ; file type
STA zpE8
LDA zp78 ; drive number
STA zpE3
RTS
;$D8EE -------- OPEN command, secondary addr 15
L_D8EE LDA zp7C ; secondary address
STA V_024C
JSR S_C39D ; get line length, erase flags
STX V_022A
LDX V_0200 ; first character from buffer
LDA V_024C ; secondary address
BNE B_D92A ; not equal 0 (LOAD)?
; Check '*' Last file
CPX #$2A ; '*'
BNE B_D92A
LDA zp77 ; last track number
BEQ B_D953
STA zp79 ; track number
LDA V_026E ; last drive number
STA zp78 ; drive number
STA zpE3
LDA #$02
STA zpE8 ; set data type to program
LDA V_026F ; last sector number
STA zp7A ; sector
JSR S_DD7D ; allocate buffer, read block
LDA #$04 ; file type
ORA zp78 ; drive number
L_D922 LDX zp7B ; channel number
STA $00ED,Y ; set flag
JMP L_C27E ; done
;
; Check '$' Directory
;
B_D92A CPX #$24 ; '$'
BNE B_D94C ; no
LDA V_024C ; secondary address
BNE B_D936 ; not equal to zero?
JMP L_DB8C ; OPEN $
;
B_D936 JSR S_C2BB ; analyze line to end
LDA V_F0C3 ; 18, directory track
STA zp79 ; track
LDA #$00
STA zp7A ; sector 0
JSR S_DD7D ; allocate buffer, read block
LDA zp78 ; drive number
ORA #$02
JMP L_D922 ; continue as above
;
; Check '#' direct channel
;
B_D94C CPX #$23 ; "#"
BNE B_D962
JMP L_CC76 ; open direct access file
;
B_D953 LDA #$02
STA V_0296 ; file type program
LDA #$00
STA zp78
STA V_028E ; drive 0
JSR S_D15E ; load BAM
B_D962 JSR S_C2CF ; analyze line
BNE B_D96B ; colon found?
LDX #$00
BEQ B_D977
B_D96B TXA ; comma found?
BEQ B_D973 ; no
LDA #$30
JMP L_C2B2 ; 30, 'syntax error'
;
B_D973 DEY
BEQ B_D977
DEY
B_D977 STY V_027A ; pointer to drive number
LDA #$8D ; shift CR
JSR S_C352 ; check command line to end ???
INX
STX V_0278 ; comma counter in file name
JSR S_C3FC ; get drive number
JSR S_C4B7 ; check drive number
JSR S_C582 ; find file entry in directory
LDX #$00 ; default values
STX V_0258 ; record length
STX V_0297
STX V_024A ; file type
INX
CPX V_0277 ; comma before equal sign?
BCS B_D9AD ; no
JSR S_DB40 ; get file type and control mode
INX
CPX V_0277 ; additional comma?
BCS B_D9AD ; no
CPY #$04
BEQ B_D9E8
JSR S_DB40 ; get file type and control method
B_D9AD LDX V_024C
STX zp7C ; secondary address
CPX #$02 ; greater than 2?
BCS B_D9C8 ; yes
STX V_0297 ; 0 or 1 (LOAD or SAVE)
LDA #$40
STA V_02F9
LDA V_024A ; file type
BNE B_D9DE ; not deleted
LDA #$02 ; PRG
STA V_024A ; as file type
B_D9C8 LDA V_024A
BNE B_D9DE
LDA zpE8
AND #$07 ; get file type and command line
STA V_024A
LDA V_0280 ; track number
BNE B_D9DE ; not equal zero?
LDA #$01
STA V_024A ; file type sequential
B_D9DE LDA V_0297 ; control method
CMP #$01 ; 'W'
BEQ B_D9FD ; yes
JMP L_DA77
;
B_D9E8 LDY V_027A,X ; pointer behind second comma
LDA V_0200,Y ; get value
STA V_0258 ; record length
LDA V_0280 ; track number
BNE B_D9AD
LDA #$01 ; 'W'
STA V_0297 ; as second method
BNE B_D9AD
B_D9FD LDA zpE8 ; file type
AND #$80 ; isolate wildcard flag
TAX
BNE B_DA18 ; wildcard in name
LDA #$20
BIT zpE8 ; was file closed?
BEQ B_DA10 ; yes
JSR S_C997 ; byte 0 in buffer and write block
JMP L_DB1A
;
B_DA10 LDA V_0280 ; track number of the first block
BNE B_DA18 ; already existing
JMP L_DB1A
;
B_DA18 LDA V_0200 ; first character from input buffer
CMP #$40 ; '@'?
BEQ B_DA2C ; yes
TXA
BNE B_DA27 ; wildcard set?
LDA #$63
JMP L_C2B2 ; 63, 'file exists'
;
B_DA27 LDA #$33
JMP L_C2B2 ; 33, 'syntax error'
;
; Open a file with overwriting (@)
;
B_DA2C LDA zpE8 ; file type
AND #$07 ; isolate
CMP V_024A
BNE B_DA9C ; file type different?
CMP #$04 ; rel-file?
BEQ B_DA9C ; 64, 'file type mismatch'
JSR L_DE15
LDA zp7B
STA V_0270 ; save channel number
LDA #$11
STA zp7C
JSR S_D1FB ; open read channel
LDA V_0294
JSR S_D61B ; set buffer pointer for directory
LDY #$00
LDA (zp8D),Y ; file type
ORA #$20 ; set bit 5, open file
STA (zp8D),Y
LDY #$1A
LDA zp79 ; track
STA (zp8D),Y
INY
LDA zp7A ; and sector
STA (zp8D),Y ; for open with at-sign
LDX V_0270 ; channel number
LDA zpD9
STA V_0260,X ; pointer to directory block
LDA zpDE
STA V_0266,X
JSR S_DF76 ; get track and sector number
JSR S_D5B7 ; write block
JMP B_DB26 ; prepare track, sector, and drive number
;
L_DA77 LDA V_0280 ; first track number
BNE B_DA81 ; file not erased?
LDA #$62
JMP L_C2B2 ; 62, 'file not found'
;
B_DA81 LDA V_0297 ; control mode
CMP #$03 ; 'M'
BEQ B_DA93 ; yes, then no test of unclosed file
LDA #$20 ; bit 5
BIT zpE8 ; test in file type
BEQ B_DA93 ; not set, ok
LDA #$60
JMP L_C2B2
;
B_DA93 LDA zpE8
AND #$07 ; isolate file type
CMP V_024A
BEQ B_DAA1
B_DA9C LDA #$64
JMP L_C2B2 ; 64, 'file type mismatch'
;
B_DAA1 LDY #$00
STY V_0279
LDX V_0297 ; control mode
CPX #$02 ; 'A', append
BNE B_DAC7 ; no
CMP #$04 ; rel-file?
BEQ B_DA9C
LDA (zp8D),Y
AND #$4F ; "O"
STA (zp8D),Y
LDA zp7C
PHA
LDA #$11
STA zp7C ; channel 17
JSR S_DF76 ; get track and sector number
JSR S_D5B7 ; write block
PLA
STA zp7C ; get channel number back
B_DAC7 JSR S_DAD7
LDA V_0297 ; control mode
CMP #$02
BNE B_DB26
JSR S_DB61
JMP L_C27E ; done
;
; Open file for reading
;
S_DAD7 LDY #$13
LDA (zp8D),Y ; track
STA V_0259
INY
LDA (zp8D),Y ; record length
STA V_025A
INY
LDA (zp8D),Y ; record length
LDX V_0258 ; last record len
STA V_0258
TXA
BEQ B_DAFA
CMP V_0258
BEQ B_DAFA
LDA #$50 ; "P"
JSR L_C2B2 ; 50, 'record not present'
B_DAFA LDX V_0279
LDA V_0280,X ; track
STA zp79
LDA V_0285,X ; sector
STA zp7A
JSR S_DD7D
LDY zp7B
LDX V_0279
LDA zpD9,X
STA V_0260,Y
LDA zpDE,X
STA V_0266,Y
RTS
;$DB1A -------- Open file for writing
L_DB1A LDA zpE3 ; drive number
AND #$01
STA zp78
JSR L_DE15
JSR S_D81E
B_DB26 LDA zp7C ; channel number
CMP #$02
BCS B_DB3D
JSR S_DF79
LDA zp79
STA zp77
LDA zp78
STA V_026E
LDA zp7A
STA V_026F
B_DB3D JMP L_C283
;
; Check file type and control mode
;
S_DB40 LDY V_027A,X ; pointer in command line
LDA V_0200,Y ; get characters from line
LDY #$04
B_DB48 DEY
BMI B_DB53
CMP V_F0F3,Y ; control modes 'R', 'W', 'A', 'M'
BNE B_DB48
STY V_0297 ; save
B_DB53 LDY #$05
B_DB55 DEY
BMI B_DB60
CMP V_F0F6 + 1,Y ; file types 'D','S','P','U','L'
BNE B_DB55
STY V_024A ; save
B_DB60 RTS
;$DB61 -------- Preparation for append
S_DB61 JSR S_CB2E ; open channel to read, get byte
LDA #$80
JSR S_DEE1 ; last byte?
BEQ S_DB61 ; no
JSR S_DFD0 ; get track and sector number
LDX zp7A ; sector number
INX
TXA
BNE B_DB79 ; not $FF?
JSR B_D2F9 ; close buffer, write block
LDA #$02
B_DB79 JSR S_D61B ; buffer pointer to 2
LDX zp7B ; channel number
LDA #$01
STA zpF3,X ; set flag for WRITE
LDA #$80
ORA zp7B
LDX zp7C
STA V_022B,X ; channel number in table
RTS
;$DB8C -------- Open directory
L_DB8C LDA #$0D ; command number 12
STA V_022A
LDA #$00
LDX V_0274
DEX
BEQ B_DBA4
DEX
BNE B_DBBD
LDA L_0201 ; second character
JSR S_C4A5 ; get drive number
BMI B_DBBD ; not a plain number?
B_DBA4 STA zpE3
INC V_0277
INC V_0278
INC V_027A
LDA #$80
STA zpE8 ; set wildcard flag
LDA #$2A ; '*'
STA V_0200 ; as file name in command buffer
STA L_0201
BNE B_DBD5 ; absolute jump
B_DBBD JSR S_C2CF ; test input line to ":"
BNE B_DBC7 ; found?
JSR S_C3C6 ; erase flags
LDY #$03
B_DBC7 DEY
DEY
STY V_027A ; pointer to drive number in command
JSR S_C2EA ; analyze line
JSR S_C480 ; ascertain file type
JSR S_C40A ; get drive number
B_DBD5 JSR S_C4B7 ; initialize drive if necessary
JSR S_C898 ; prepare disk title
JSR S_C582 ; load directory
JSR S_EB0B ; create and prepare directory
JSR S_D247 ; get byte from buffer
LDX zp7B ; channel number
STA V_023E,X ; byte in output register
LDA zp78 ; drive number
STA V_028E ; save as last drive number
ORA #$04
STA zpED,X ; PRG-flag
LDA #$00
STA zpA4 ; set pointer back in input buffer
RTS
;$DBF7 -------- Close routine
S_DBF7 LDA #$00
STA V_02F9
LDA zp7C ; secondary address
BNE B_DC0B ; not zero?
LDA #$00 ; secondary address 0, LOAD
STA V_0254
JSR L_D37D ; close channel
B_DC08 JMP L_D62D ; close internal channels 17 & 18
;
B_DC0B CMP #$0F ; 15
BEQ B_DC23 ; yes, close all channels
JSR L_DC39 ; close file
LDA zp7C ; secondary address
CMP #$02 ; smaller than 2?
BCC B_DC08
LDA V_026C
BNE B_DC20
JMP L_C27E ; termination
;
B_DC20 JMP L_C297
;
B_DC23 LDA #$0E ; 14
STA zp7C ; secondary address
B_DC27 JSR L_DC39 ; close file
DEC zp7C ; next secondary address
BPL B_DC27
LDA V_026C
BNE B_DC36
JMP L_C27E ; termination
;
B_DC36 JMP L_C297
;
; Close file
;
L_DC39 LDX zp7C ; secondary address
LDA V_022B,X ; get channel number
CMP #$FF ; no channel associated?
BNE B_DC43
RTS ; no, then none
;$DC43 --------
B_DC43 AND #$0F ; isolate channel number
STA zp7B
JSR S_D235 ; check data type
CMP #$07 ; direct access?
BEQ B_DC5D ; yes
CMP #$04 ; rel-file?
BEQ B_DC63 ; yes
JSR S_D217 ; channel for writing open
BCS B_DC60 ; no file for writing?
JSR S_DC99 ; write last block
JSR S_DCDC ; write entry in directory and block
B_DC5D JSR S_ED5F ; write BAM
B_DC60 JMP L_D37D ; close channel
;
B_DC63 JSR S_DF2C ; get buffer number, write block
JSR S_CFD4 ; change buffer
JSR S_E306 ; get last side-sector
LDX zp92 ; side-sector number
STX zp72
INC zp72
LDA #$00
STA zp6E+1
STA zp70
LDA zp93
SEC
SBC #$0E ; minus 14 for pointer
STA zp70+1
JSR S_E08C ; calculate block number of file
LDX zp7B ; channel number
LDA zp6E+1
STA zpB6,X ; record number lo
LDA zp70
STA zpBC,X ; record number hi
LDA #$40
JSR S_DEE1 ; bit 6 set?
BEQ B_DC96 ; no
JSR S_DCDC ; enter in directory
B_DC96 JMP L_D37D ; close channel
;
; Write last block
;
S_DC99 LDX zp7B ; channel number
LDA zpB6,X ; record number lo
ORA zpBC,X ; record number hi
BNE B_DCAD ; not zero?
JSR S_D63B ; set buffer pointer
CMP #$02
BNE B_DCAD ; not 2
LDA #$0D ; CR
JSR S_D10D ; in buffer
B_DCAD JSR S_D63B ; set buffer pointer
CMP #$02 ; now equal to 2?
BNE B_DCC3 ; no
JSR S_CFD4 ; change buffer
LDX zp7B ; channel number
LDA zpB6,X ; record number lo
BNE B_DCBF
DEC zpBC,X ; decrement block number hi
B_DCBF DEC zpB6,X ; and block number lo
LDA #$00
B_DCC3 SEC
SBC #$01 ; set pointer
PHA
LDA #$00
JSR S_D61B ; buffer pointer to zero
JSR S_D10D ; write zero in buffer
PLA ; second byte = pointer to end
JSR S_D10D ; write in buffer
JSR S_D1D7 ; write block to disk
JSR S_D6EC ; and verify
JMP S_CFD4 ; change buffer
;
; Directory entry
;
S_DCDC LDX zp7B ; channel number
STX V_0270 ; save
LDA zp7C ; secondary address
PHA ; save
LDA V_0260,X ; sector number in directory
STA zp7A ; set
LDA V_0266,X ; pointer in directory
STA V_0294
LDA zpED,X
AND #$01
STA zp78 ; drive number
LDA V_F0C3 ; 18, directory track
STA zp79 ; set
JSR S_E0CE ; increment buffer number
PHA
STA zp98
JSR S_D5B3 ; read directory block
LDY #$00
LDA V_F123,X ; buffer address
STA zp7F+1
LDA V_0294 ; buffer pointer
STA zp7F
LDA (zp7F),Y ; file type
AND #$20 ; file closed?
BEQ B_DD58 ; yes
JSR S_D235 ; check file type
CMP #$04 ; rel-file?
BEQ L_DD60 ; yes
LDA (zp7F),Y
AND #$8F ; erase bits 4,5, and 6
STA (zp7F),Y ; in file type
INY
LDA (zp7F),Y ; track number
STA zp79
STY zp70
LDY #$1B
LDA (zp7F),Y ; sector number of the file for
PHA ; overwriting
DEY
LDA (zp7F),Y ; track number for overwriting
BNE B_DD3D ; set?
STA zp79 ; set track number
PLA
STA zp7A ; sector number
LDA #$67
JSR S_E781 ; 67, 'illegal track or sector'
B_DD3D PHA
LDA #$00
STA (zp7F),Y ; erase track number
INY
STA (zp7F),Y ; and sector number of the
PLA ; substitute file
LDY zp70
STA (zp7F),Y
INY ; set track & sector number of the new file
LDA (zp7F),Y
STA zp7A
PLA
V_DD50 STA (zp7F),Y
JSR S_C95E ; erase all files
JMP L_DD60
;
B_DD58 LDA (zp7F),Y ; get file type
AND #$0F ; isolate bits 0-3
ORA #$80 ; set bit 7 for closed file
STA (zp7F),Y
L_DD60 LDX V_0270 ; channel number
LDY #$1C ; block number lo
LDA zpB6,X ; in directory entry
STA (zp7F),Y
INY
LDA zpBC,X ; and block number hi
STA (zp7F),Y ; write
PLA ; buffer number
TAX
LDA #$90 ; code for 'writing'
ORA zp78
JSR S_D6E3 ; write block
PLA
STA zp7C ; secondary address
JMP S_D217 ; open channel for writing
;
; Read block, allocate buffer
;
S_DD7D LDA #$01
JSR S_D338 ; find channel and buffer for read
JSR S_DDED ; set pointer
LDA V_024A ; file type
PHA ; save
ASL A
ORA zp78 ; drive number
STA zpED,X
JSR S_D1AB ; read block in buffer
LDX zp7B ; channel number
LDA zp79 ; track
BNE B_DD9C ; following track?
LDA zp7A ; sector
STA V_0244,X ; as end pointer
B_DD9C PLA ; file type
CMP #$04 ; rel-file?
BNE B_DDE0 ; no
LDY zp7C ; secondary address
LDA V_022B,Y ; channel number
ORA #$40
STA V_022B,Y ; set flag for READ and WRITE
LDA V_0258 ; record length
STA zpC8,X
JSR S_D3E4 ; find buffer for side-sector
BPL B_DDB8 ; found?
JMP L_D365 ; 70, 'no channel'
;
B_DDB8 LDX zp7B ; channel number
STA zpCE,X
LDY V_0259
STY zp79 ; track for side-sector
LDY V_025A
STY zp7A ; sector for side-sector
JSR S_D808 ; transmit parameters to disk controller
JSR S_DFAE ; read block
JSR S_D6EC ; and verify
L_DDCF LDX zp7B ; channel number
LDA #$02
STA zpC2,X ; pointer for writing
LDA #$00
JSR S_D61B ; buffer pointer to zero
JSR S_E28E ; find next record
JMP S_DF79 ; get track and sector number
;
B_DDE0 JSR S_D271 ; get byte from buffer
LDX zp7B ; channel number
STA V_023E,X ; byte in output register
LDA #$88 ; set flag for READ
STA zpF3,X
RTS
;$DDED -------- Reset pointer
S_DDED LDX zp7B ; channel number
LDA zpA8,X ; buffer number
ASL A ; times 2
BMI B_DDFA
TAY
LDA #$02
STA $009A,Y ; buffer pointer lo
B_DDFA LDA zpAF,X
ORA #$80 ; set bit 7
STA zpAF,X
ASL A
BMI B_DE09
TAY
LDA #$02
STA $009A,Y ; buffer pointer lo
B_DE09 LDA #$00
STA zpB6,X ; block number lo
STA zpBC,X ; block number hi
LDA #$00
STA V_0244,X ; end pointer
RTS
;$DE15 -------- Construct a new block
L_DE15 JSR S_F014 ; find free sector in BAM
LDA #$01
JSR S_D335 ; open channel
JSR S_D805 ; transmit parameter to disk controller
JSR S_DDED ; reset pointer
LDX zp7B ; channel number
LDA V_024A ; file type
PHA
ASL A
ORA zp78 ; drive number
STA zpED,X ; save as flag
PLA
CMP #$04 ; rel-file?
BEQ B_DE38 ; yes
LDA #$01
STA zpF3,X ; set WRITE flag
RTS
;$DE38 --------
B_DE38 LDY zp7C ; secondary address
LDA V_022B,Y ; channel number in table
AND #$3F ; erase the top two bits
ORA #$40 ; set bit 6
STA V_022B,Y ; READ and WRITE flag
LDA V_0258 ; record length
STA zpC8,X ; in table
JSR S_D3E4 ; find buffer
BPL B_DE51 ; found?
JMP L_D365 ; 70, 'no channel'
;
B_DE51 LDX zp7B ; channel number
STA zpCE,X ; buffer number for side-sector
JSR S_DFFC ; erase buffer
JSR S_EF89 ; find free block in BAM
LDA zp79 ; track
STA V_0259 ; for side-sector
LDA zp7A ; sector
STA V_025A ; for side-sector
LDX zp7B ; channel number
LDA zpCE,X ; buffer number
JSR S_D808 ; transmit parameter to disk controller
LDA #$00
JSR S_E024 ; buffer pointer to zero
LDA #$00
JSR S_DEC8
LDA #$11 ; 17
JSR S_DEC8 ; as end pointer in buffer
LDA #$00 ; zero
JSR S_DEC8 ; as side-sector number in buffer
LDA V_0258 ; record length
JSR S_DEC8 ; in buffer
LDA zp79 ; track number of this block
JSR S_DEC8 ; in buffer
LDA zp7A ; sector number
JSR S_DEC8 ; in buffer
LDA #$10 ; 16
JSR S_E024 ; buffer pointer to 16
JSR S_DF79 ; get track and sector number
LDA zp79 ; track number of the first data block
JSR S_DEC8 ; in buffer
LDA zp7A ; sector number of the first data block
JSR S_DEC8 ; in buffer
JSR S_DFA7 ; write block to disk
JSR S_D6EC ; and check
LDA #$02
JSR S_D61B ; buffer pointer to 2
LDX zp7B ; channel number
SEC
LDA #$00
SBC zpC8,X ; record length
STA zpC2,X ; pointer for writing
JSR S_E41D ; erase buffer
JSR S_DF54 ; write link bytes in buffer
JSR S_DF99 ; write block to disk
JSR S_D6EC ; and check
JSR S_ED5F ; write BAM
JMP L_DDCF ; and done
;
; Write byte in side-sector block
;
S_DEC8 PHA ; save byte
LDX zp7B ; channel number
LDA zpCE,X ; buffer number of the side-sector
JMP B_D119 ; write byte in buffer
;
; Manipulate flags
;
BCC B_DED8
L_DED2 LDX zp7B ; channel number
ORA zpED,X ; set flag
BNE B_DEDE
B_DED8 LDX zp7B ; channel number
EOR #$FF
AND zpED,X ; erase flag
B_DEDE STA zpED,X
RTS
;$DEE1 --------
S_DEE1 LDX zp7B ; channel number
AND zpED,X ; test flag
RTS
;$DEE6 -------- Verify command code for writing
S_DEE6 JSR S_E0CE ; get buffer number
TAX
LDA V_025B,X
AND #$F0 ; isolate command code
CMP #$90 ; code for writing?
RTS
;$DEF2 --------
S_DEF2 LDX #$00
B_DEF4 STX zp70 ; counter for secondary address
LDA V_022B,X ; get channel number from table
CMP #$FF
BNE B_DF05 ; file open?
B_DEFD LDX zp70
INX ; increment counter
CPX #$10 ; smaller than 16?
BCC B_DEF4
RTS
;$DF05 --------
B_DF05 STX zp70
AND #$3F ; isolate channel number
TAY
LDA $00ED,Y
AND #$01 ; isolate drive number
STA zp6E+1
LDX V_0253
LDA zpE3,X
AND #$01 ; isolate drive number
CMP zp6E+1 ; same drive?
BNE B_DEFD ; no
LDA V_0260,Y ; sector number in directory
CMP zpD9,X ; same as file?
BNE B_DEFD ; no
LDA V_0266,Y
CMP zpDE,X ; pointer same?
BNE B_DEFD ; no
CLC
RTS
;$DF2C -------- Write a block of a REL file
S_DF2C JSR S_E0D9 ; get buffer number
BVC B_DF37 ; no rel-file?
JSR S_DF99 ; write block
JSR S_D6EC ; and verify
B_DF37 RTS
;$DF38 -------- Write bytes for following track
S_DF38 JSR S_DF66 ; set buffer pointer
LDA zp79 ; track number
STA (zp8D),Y ; in buffer
INY
LDA zp7A ; sector number
STA (zp8D),Y ; in buffer
JMP S_E240 ; set rel-flag
;
; Get following track and sector numbers
;
S_DF47 JSR S_DF66 ; set buffer pointer
LDA (zp8D),Y ; following track number
STA zp79
INY
LDA (zp8D),Y ; and get sector number
STA zp7A
RTS
;$DF54 -------- Following track for last block
S_DF54 JSR S_DF66 ; set buffer pointer
LDA #$00 ; zero
STA (zp8D),Y ; as track number
INY
LDX zp7B ; channel number
LDA zpC2,X ; pointer in block
TAX
DEX ; minus 1
TXA
STA (zp8D),Y ; as pointer in block
RTS
;$DF66 -------- buffer pointer to zero
S_DF66 JSR S_E0CE ; get buffer number
ASL A ; times 2
TAX
LDA zp9B,X ; buffer pointer hi
STA zp8D+1
LDA #$00
STA zp8D ; buffer pointer lo
LDY #$00
RTS
;$DF76 -------- Get track and sector
S_DF76 JSR S_D1FB ; get channel number
S_DF79 JSR S_E0CE ; get buffer number
STA zp98 ; save
ASL A ; times 2
TAY
LDA $0008,Y ; get track
STA zp79
LDA $0009,Y ; and sector number from disk controller
STA zp7A
RTS
;$DF8B -------- Write
S_DF8B LDA #$90 ; command code for writing
STA V_024D
BNE B_DFBA ; jump always
; --------- Read
S_DF92 LDA #$80 ; command code for reading
STA V_024D
BNE B_DFBA ; jump always
; Write
S_DF99 LDA #$90 ; command code for writing
STA V_024D
BNE B_DFC6 ; jump always
; Read
LDA #$80 ; command code for reading
STA V_024D
BNE B_DFC6 ; jump always
; Write
S_DFA7 LDA #$90 ; command code for writing
STA V_024D
BNE B_DFB0 ; jump always
; Read
S_DFAE LDA #$80 ; command code for reading
B_DFB0 STA V_024D
LDX zp7B ; channel number
LDA zpCE,X ; side-sector buffer number
TAX
BPL B_DFCD ; buffer associated?
B_DFBA JSR S_D805 ; generate header for disk controller
JSR S_E0CE ; get buffer number
TAX
LDA zp78 ; drive number
STA V_025B,X
B_DFC6 JSR S_E250 ; buffer number
JSR S_E0CE ; get buffer number
TAX
B_DFCD JMP L_D659 ; write block
;
; Get following track and sector from buffer
;
S_DFD0 LDA #$00
JSR S_D61B ; buffer pointer to zero
JSR S_D247 ; get byte
STA zp79 ; save as track
JSR S_D247 ; get byte
STA zp7A ; as sector
RTS
;$DFE0 -------- Copy buffer contents
S_DFE0 PHA
LDA #$00
STA zp6E
STA zp70
LDA V_F123,Y ; buffer address Y, hi
STA zp6E+1
LDA V_F123,X ; buffer address X, lo
STA zp70+1
PLA
TAY
DEY
B_DFF4 LDA (zp6E),Y
STA (zp70),Y
DEY
BPL B_DFF4
RTS
;$DFFC -------- Erase buffer Y
S_DFFC TAY ; buffer number
LDA V_F123,Y ; get hi-address
STA zp6E+1
LDA #$00 ; lo-address
STA zp6E
TAY
B_E007 STA (zp6E),Y ; erase buffer
INY
BNE B_E007
RTS
;$E00D -------- Get side-sector number
S_E00D LDA #$00
JSR S_E017 ; buffer pointer to zero
LDY #$02
LDA (zp8D),Y ; byte 2 contains the side-sector number
RTS
;$E017 -------- Set buffer pointer to side-sector
S_E017 STA zp8D ; printer lo
LDX zp7B ; channel number
LDA zpCE,X ; buffer number
TAX
LDA V_F123,X ; buffer address hi
STA zp8D+1 ; set
RTS
;$E024 -------- Buffer pointer for side-sector
S_E024 PHA ; pointer in side-sector
JSR S_E017 ; set buffer pointer
PHA
TXA ; buffer number
ASL A ; times 2
TAX
PLA
STA zp9B,X ; buffer pointer hi
PLA
STA zp9A,X ; buffer pointer lo
RTS
;$E033 -------- Get side sector and buffer pointer
S_E033 JSR S_E0A1 ; is side-sector in buffer?
BMI B_E046 ; no
BVC B_E04D ; ok
LDX zp7B ; channel number
LDA zpCE,X ; buffer number
JSR S_E056 ; read side-sector
JSR S_E0A1 ; and check if in buffer
BPL B_E04D ; yes?
B_E046 JSR S_E306 ; get last side-sector
BIT V_F10E + 1 ; set V bit
RTS
;$E04D --------
B_E04D LDA zp93 ; side-sector and pointer
JSR S_E024 ; set pointer in side-sector
BIT V_F10E ; erase V bit
RTS
;$E056 -------- Read side-sector
S_E056 STA zp98 ; buffer number
LDA #$80 ; command code for reading
BNE B_E060
; Write side-sector
STA zp98 ; buffer number
LDA #$90 ; command code for writing
B_E060 PHA
LDA zpED,X
AND #$01 ; isolate drive number
STA zp78
PLA
ORA zp78 ; command code plus drive number
STA V_024D ; save
LDA (zp8D),Y ; track number
STA zp79
INY
LDA (zp8D),Y ; sector number
STA zp7A
LDA zp98 ; buffer number
JSR S_D808 ; transmit parameter to disk controller
LDX zp98 ; buffer number
JMP L_D6E6 ; transmit command to disk controller
;
; Set buffer pointer in side-sector
;
S_E080 LDX zp7B ; channel number
LDA zpCE,X ; buffer number
JMP L_D63E ; set buffer pointer
;
; Calculate number of blocks in a REL file
;
B_E087 LDA #$78 ; 120 block pointers per side-sector
JSR S_E097 ; add to $6f/$70
S_E08C DEX ; side-sector number
BPL B_E087 ; next side-sector?
LDA zp70+1 ; pointer value in last block
LSR A ; divided by 2
JSR S_E097 ; add to previous sum
LDA zp72 ; number of the side-sector block
S_E097 CLC
ADC zp6E+1
STA zp6E+1 ; add
BCC B_E0A0
INC zp70
B_E0A0 RTS
;$E0A1 -------- Verify side-sector in buffer
S_E0A1 JSR S_E00D ; get side-sector number
CMP zp92 ; = number of necessary block?
BNE B_E0B6 ; no
LDY zp93 ; pointer in side-sector
LDA (zp8D),Y ; track number
BEQ B_E0B2
BIT V_F10E ; erase bits
RTS
;$E0B2 --------
B_E0B2 BIT V_F10E + 2 ; set N-bit
RTS
;$E0B6 --------
B_E0B6 LDA zp92 ; side-sector number
CMP #$06 ; 6 or greater?
BCS B_E0C6 ; yes
ASL A
TAY
LDA #$04
STA zp8D
LDA (zp8D),Y ; track number
BNE B_E0CA
B_E0C6 BIT V_F111 ; set N and V bits
RTS
;$E0CA --------
B_E0CA BIT V_F10E + 1 ; set V bit
RTS
;$E0CE -------- Get buffer number
S_E0CE LDX zp7B ; channel number
LDA zpA8,X ; buffer number
BPL B_E0D6
LDA zpAF,X ; buffer number from second table
B_E0D6 AND #$BF ; erase V bit
RTS
;$E0D9 --------
S_E0D9 LDX zp7B ; channel number
STX V_0257 ; save
LDA zpA8,X ; get buffer number
BPL B_E0EB ; buffer allocated
TXA
CLC
ADC #$07 ; increment number by 7
STA V_0257 ; and save
LDA zpAF,X ; buffer number from table 2
B_E0EB STA zp6E+1
AND #$1F ; erase the highest 3 bits
BIT zp6E+1
RTS
;$E0F2 --------
S_E0F2 LDX zp7B ; channel number
LDA zpA8,X ; buffer number
BMI B_E0FA ; buffer free?
LDA zpAF,X ; buffer number from table 2
B_E0FA CMP #$FF ; free?
RTS
;$E0FD --------
S_E0FD LDX zp7B
ORA #$80
LDY zpA8,X
BPL B_E108
STA zpA8,X
RTS
;$E108 --------
B_E108 STA zpAF,X
RTS
;$E10B -------- Get next record in REL file
S_E10B LDA #$20
JSR B_DED8 ; erase bit 5
LDA #$80
JSR S_DEE1 ; test bit 7
BNE B_E158 ; set?
LDX zp7B ; channel number
INC zpB6,X ; increment record number
BNE B_E11F
INC zpBC,X ; record number hi
B_E11F LDX zp7B ; channel number
LDA zpC2,X ; write pointer
BEQ B_E153 ; zero?
JSR S_D63B ; set buffer pointer
LDX zp7B ; channel number
CMP zpC2,X ; buffer pointer smaller than write pointer
BCC B_E131 ; yes
JSR S_E177 ; write block, read next block
B_E131 LDX zp7B ; channel number
LDA zpC2,X ; write pointer
JSR S_D61B ; set buffer pointer = write pointer
LDA (zp9A,X) ; byte from buffer
STA zp7E ; put in output register
LDA #$20
JSR B_DED8 ; erase bit 5
JSR S_E43F ; add record length to write pointer
S_E144 PHA ; and save
BCC B_E16F ; not yet in last block?
LDA #$00
JSR S_D649 ; get track number
BNE B_E16F ; does block exist?
PLA ; pointer
CMP #$02 ; = 2
BEQ B_E165 ; yes
B_E153 LDA #$80
JSR L_DED2 ; set bit 7
B_E158 JSR S_D23F ; get byte from buffer
LDA zp9A,X ; buffer pointer
STA V_0244,Y ; as end pointer
LDA #$0D ; CR
STA zp7E ; in output register
RTS
;$E165 --------
B_E165 JSR S_E170
LDX zp7B ; channel number
LDA #$00
STA zpC2,X ; write pointer to zero
RTS
;$E16F --------
B_E16F PLA
S_E170 LDX zp7B ; channel number
STA zpC2,X ; set write pointer
JMP L_E2A9
;
; Write block and read next block
;
S_E177 JSR S_D329 ; get drive number
JSR S_DFD0 ; get track and sector number
JSR S_E0D9 ; get bufer number
BVC B_E198 ; no rel-file?
JSR S_DF99 ; write block
JSR S_CFD4 ; change buffer
LDA #$02
JSR S_D61B ; buffer pointer to 2
JSR S_DEE6 ; command code for writing?
BNE B_E1B6 ; no
JSR S_DF92 ; read block
JMP S_D6EC ; and verify
;
B_E198 JSR S_CFD4 ; change buffer
JSR S_DEE6 ; command code for writing?
BNE B_E1A6 ; no
JSR S_DF92 ; read block
JSR S_D6EC ; and verify
B_E1A6 JSR S_DFD0 ; get track and sector number
LDA zp79 ; track
BEQ B_E1B6 ; no following track
JSR S_CFD4 ; change buffer
JSR S_DF92 ; read block
JSR S_CFD4 ; change buffer
B_E1B6 RTS
;$E1B7 -------- Write a byte in a record
S_E1B7 JSR S_E240
JSR S_E0CE ; get buffer number
ASL A ; * 2
TAX ; as index
LDA zp7E ; data byte
STA (zp9A,X) ; write in buffer
LDY zp9A,X ; buffer pointer
INY ; increment
BNE B_E1D1 ; not equal zero?
LDY zp7B ; channel number
LDA $00C2,Y ; write pointer
BEQ B_E1D9 ; equal zero?
LDY #$02 ; buffer pointer to 2
B_E1D1 TYA
LDY zp7B ; channel number
CMP $00C2,Y ; buffer pointer = write pointer?
BNE B_E1DE ; no
B_E1D9 LDA #$20
JMP L_DED2 ; set bit 5
;
B_E1DE INC zp9A,X ; increment buffer pointer
BNE B_E1E5 ; not zero?
JSR S_E177 ; else write block, read next one
B_E1E5 RTS
;$E1E6 -------- Write byte in REL file
L_E1E6 LDA #$A0
JSR S_DEE1 ; test bits 6 & 7
BNE B_E214 ; set?
L_E1ED LDA zp7E ; data byte
JSR S_E1B7 ; write in record
LDA zp95 ; end?
BEQ B_E203 ; yes
RTS
;$E1F7 --------
B_E1F7 LDA #$20
JSR S_DEE1 ; test bit 5
BEQ B_E203 ; not set
LDA #$51 ; 51, 'overflow in record'
STA V_026C ; set error flag
B_E203 JSR L_E22E ; fill remainder with zeroes
JSR S_E28E
LDA V_026C ; error flag set?
BEQ B_E211 ; no
JMP L_C2B2 ; set error message
;
B_E211 JMP L_E7FB ; error free execution
;
B_E214 AND #$80 ; bit 7 set?
BNE B_E21D ; yes
LDA zp95
BEQ B_E1F7 ; end?
RTS
;$E21D --------
B_E21D LDA zp7E ; data byte
PHA
JSR S_E457 ; expand side-sector
PLA
STA zp7E
LDA #$80
JSR B_DED8 ; erase bit 7
JMP L_E1ED ; write byte in file
;
; Fill record with 0s
;
L_E22E LDA #$20
JSR S_DEE1 ; test bit 5
BNE B_E23F ; set?
LDA #$00
STA zp7E ; zero as data byte
JSR S_E1B7 ; write in record
JMP L_E22E ; until record full
;
B_E23F RTS
;$E240 -------- Write buffer number in table
S_E240 LDA #$40
JSR L_DED2 ; set bit 6
JSR S_E0D9 ; get buffer number
ORA #$40 ; set bit 6
LDX V_0257 ; channel number + 7
STA zpA8,X ; write in table
RTS
;$E250 --------
S_E250 JSR S_E0D9 ; get buffer number
AND #$BF ; erase bit 6
LDX V_0257 ; channel number
STA zpA8,X ; write in table
RTS
;$E25B -------- Get byte from REL file
L_E25B LDA #$80
JSR S_DEE1 ; test bit 7
BNE L_E299 ; set?
JSR S_D23F ; get byte from buffer
LDA zp9A,X ; buffer pointer
CMP V_0244,Y ; compare to end pointer
BEQ S_E28E ; equal?
INC zp9A,X ; increment buffer pointer
BNE B_E276 ; not zero?
JSR S_E177 ; write block, read next one
L_E273 JSR S_D23F ; get byte from buffer
B_E276 LDA (zp9A,X)
L_E278 STA V_023E,Y ; in output register
LDA #$89
STA $00F3,Y ; set READ and WRITE flag
LDA zp9A,X ; buffer pointer
CMP V_0244,Y ; compare to end pointer
BEQ B_E288 ; same?
RTS
;$E288 --------
B_E288 LDA #$81
STA $00F3,Y ; set flag for end
RTS
;$E28E --------
S_E28E JSR S_E10B ; find next record
JSR S_D23F ; get buffer and channel number
LDA zp7E ; data byte
JMP L_E278 ; into output register
;
L_E299 LDX zp7B ; channel number
LDA #$0D ; CR
STA V_023E,X ; into output register
LDA #$81
STA zpF3,X ; set flag for end
LDA #$50
JSR L_C2B2 ; 50, 'record not present'
L_E2A9 LDX zp7B ; channel number
LDA zpC2,X ; write pointer
STA zp7F+1 ; save
DEC zp7F+1
CMP #$02 ; equal 2?
BNE B_E2B9 ; no
LDA #$FF
STA zp7F+1
B_E2B9 LDA zpC8,X ; record length
STA zp81
JSR S_D63B ; set buffer pointer
LDX zp7B ; channel number
CMP zp7F+1 ; buffer pointer > write pointer?
BCC B_E2DF
BEQ B_E2DF ; no
JSR S_CFD4 ; change buffer
JSR S_E2ED
BCC B_E2D8
LDX zp7B ; channel number
STA V_0244,X
JMP S_CFD4 ; change buffer
;
B_E2D8 JSR S_CFD4 ; change buffer
LDA #$FF
STA zp7F+1
B_E2DF JSR S_E2ED
BCS B_E2E7
JSR S_D63B ; set buffer pointer
B_E2E7 LDX zp7B ; channel number
STA V_0244,X ; end pointer
RTS
;$E2ED --------
S_E2ED JSR S_DF66 ; buffer pointer to zero
LDY zp7F+1
B_E2F2 LDA (zp8D),Y ; byte from buffer
BNE B_E303 ; not zero?
DEY
CPY #$02
BCC B_E2FF
DEC zp81
BNE B_E2F2
B_E2FF DEC zp81
CLC
RTS
;$E303 --------
B_E303 TYA
SEC
RTS
;$E306 -------- Get last side-sector
S_E306 JSR S_E00D ; get number of the side-sector
STA zp92 ; save
LDA #$04
STA zp8D ; pointer to side-sectors
LDY #$0A
BNE B_E317
B_E313 DEY
DEY
BMI B_E33D
B_E317 LDA (zp8D),Y ; track number of the previous block
BEQ B_E313
TYA
LSR A ; divide by 2
CMP zp92 ; = number of the actual block?
BEQ B_E32A ; yes
STA zp92 ; else save all numbers
LDX zp7B ; channel number
LDA zpCE,X ; buffer number
JSR S_E056 ; read block
B_E32A LDY #$00
STY zp8D ; buffer pointer
LDA (zp8D),Y ; track number
BNE B_E33D ; another block?
INY
LDA (zp8D),Y ; sector number = end pointer
TAY
DEY
STY zp93 ; save end pointer
TYA
JMP S_E024 ; set buffer pointer
;
B_E33D LDA #$67
JSR S_E781 ; 67, 'illegal track or sector'
;
; Perform [P] - Position command
;
JSR S_C39D ; verify lines
LDA L_0201 ; secondary address
STA zp7C
JSR S_D1FB ; find channel number
BCC B_E354 ; found?
LDA #$70
JSR L_C2B2 ; 70, 'no block'
B_E354 LDA #$A0
JSR B_DED8 ; erase bits 6 & 7
JSR S_D235 ; verify if 'REL'-file
BEQ B_E363 ; yes
LDA #$64
JSR L_C2B2 ; 64, 'file type mismatch'
B_E363 LDA zpED,X
AND #$01
STA zp78 ; drive number
LDA V_0202 ; record number lo
STA zpB6,X
LDA V_0203 ; record number hi
STA zpBC,X
LDX zp7B ; channel number
LDA #$89
STA zpF3,X ; READ and WRITE flag
LDA V_0204 ; byte-pointer
BEQ B_E38E ; zero?
SEC
SBC #$01
BEQ B_E38E
CMP zpC8,X ; compare with record length
BCC B_E38E
LDA #$51
STA V_026C ; 51, 'overflow in record'
LDA #$00
B_E38E STA zp91
JSR S_CEFD ; calculate pointer in rel-file
JSR S_E033 ; and read appropriate side-sector
BVC B_E3A0 ; does block exist?
LDA #$80
JSR L_DED2 ; set bit 7
JMP L_E299 ; and 50, 'record not present'
;
B_E3A0 JSR L_E3B0
LDA #$80
JSR S_DEE1 ; test bit 7
BEQ B_E3AD ; not set
JMP L_E299 ; 50, 'record not present'
;
B_E3AD JMP L_C27E ; done
;
L_E3B0 JSR S_E3D7
LDA zp94 ; pointer in rel-file
JSR S_D61B ; set buffer pointer
LDX zp7B ; channel number
LDA zpC8,X ; record length
SEC
SBC zp91 ; minus position
BCS B_E3C4 ; positive?
JMP B_E33D ; 67, 'illegal track or sector'
;
B_E3C4 CLC
ADC zp94 ; add pointer in data block
BCC B_E3CC ; no overflow
ADC #$01 ; plus 2
SEC
B_E3CC JSR S_E144 ; set pointer
JMP L_E273 ; get byte from buffer
;
LDA #$51
JSR L_C2B2 ; 51, 'overflow in record'
S_E3D7 LDA zp8D ; buffer pointer lo
STA zp81+1
LDA zp8D+1 ; buffer pointer hi
STA zp82+1
JSR S_E40B ; compare track and sector
BNE B_E3E5 ; not equal?
RTS
;$E3E5 --------
B_E3E5 JSR S_DF2C
JSR S_DF47
LDA zp79 ; track
BEQ B_E3FD ; no block following?
JSR S_E40E ; compare track and sector number
BNE B_E3FA ; not equal?
JSR S_CFD4 ; change buffer
JMP L_D42C
;
B_E3FA JSR L_D42C
B_E3FD LDY #$00
LDA (zp81+1),Y ; track
STA zp79
INY
LDA (zp81+1),Y ; and sector of the next block
STA zp7A
JMP L_D1BF ; read block
;
S_E40B JSR S_DF79
S_E40E LDY #$00
LDA (zp81+1),Y ; track number
CMP zp79 ; compare
BEQ B_E417
RTS
;$E417 --------
B_E417 INY
LDA (zp81+1),Y ; sector number
CMP zp7A ; compare
RTS
;$E41D -------- Divide data blocks into records
S_E41D JSR S_DF66 ; set buffer pointer
LDY #$02
LDA #$00
B_E424 STA (zp8D),Y ; erase buffer
INY
BNE B_E424
JSR S_E43F ; set pointer to next record
B_E42C STA zpC2,X
TAY
LDA #$FF
STA (zp8D),Y ; $FF as 1st character in record
JSR S_E43F ; set pointer to next record
BCC B_E42C ; done in this block?
BNE B_E43E ; block full?
LDA #$00
STA zpC2,X ; write pointer to zero
B_E43E RTS
;$E43F -------- Set pointer to next record
S_E43F LDX zp7B ; channel number
LDA zpC2,X ; write pointer
SEC
BEQ B_E453 ; equal zero?
CLC
ADC zpC8,X ; add record length
BCC B_E456 ; smaller than 256?
BNE B_E453 ; equal 256?
LDA #$02
BIT V_F10D
RTS
;$E453 --------
B_E453 ADC #$01 ; add two
SEC
B_E456 RTS
;$E457 -------- Expand side-sector
S_E457 JSR S_D329 ; get drive number
JSR S_E306 ; get last side-sector
JSR S_E3D7
JSR S_D09A
LDA zp93
STA zp7F+1
LDA zp92 ; side-sector number
STA zp7F
LDA #$00
STA zp81
LDA #$00
STA zp91
JSR S_CEFD ; calculate side-sector number and pointer
L_E476 JSR S_EDB8 ; number of free blocks
LDY zp7B ; channel number
LDX zpC8,Y ; record length
DEX
TXA
CLC
ADC zp94 ; plus pointer in data block
BCC B_E490
INC zp93
INC zp93 ; increment pointer to end by 2
BNE B_E490
INC zp92 ; increment side-sector number
LDA #$10
STA zp93 ; set pointer to 16
B_E490 LDA zp7F+1
CLC
ADC #$02
JSR S_E024 ; set buffer pointer for side-sector
LDA zp92 ; side-sector number
CMP #$06
BCC B_E4A3 ; smaller than 6?
B_E49E LDA #$52
JSR L_C2B2 ; 52, 'file too large'
B_E4A3 LDA zp93 ; end pointer
SEC
SBC zp7F+1 ; minus last end pointer
BCS B_E4AD
SBC #$0F ; minus 16
CLC
B_E4AD STA zp70+1
LDA zp92 ; side-sector number
SBC zp7F ; minus last side-sector number
STA zp72 ; save
LDX #$00
STX zp6E+1 ; erase sum for calculation
STX zp70
TAX
JSR S_E08C ; calculate block # of rel-file
LDA zp70
BNE B_E4CA
LDX zp6E+1
DEX
BNE B_E4CA
INC zp81
B_E4CA CMP V_0273 ; block number of rel-file
BCC B_E4D8 ; greater than free blocks on disk?
BNE B_E49E ; 52, 'file too large'
LDA V_0272
CMP zp6E+1
BCC B_E49E ; 52, 'file too large'
B_E4D8 LDA #$01
JSR S_D649 ; get byte from buffer
CLC
ADC #$01 ; plus 1
LDX zp7B
STA zpC2,X ; as write pointer
JSR S_EF89 ; find free block in BAM
JSR S_DF38 ; track and sector in buffer
LDA zp81
BNE B_E503 ; only one block needed?
JSR S_DF99 ; write block
B_E4F1 JSR S_CFD4 ; change buffer
JSR S_D805 ; transmit parameter to disk controller
JSR S_EF89 ; find free block in BAM
JSR S_DF38 ; track and sector in buffer
JSR S_E41D ; erase buffer
JMP L_E50F
;
B_E503 JSR S_CFD4 ; change buffer
JSR S_D805 ; transmit parameter to disk controller
JSR S_E41D ; erase buffer
JSR S_DF54 ; zero byte and end pointer in buffer
L_E50F JSR S_DF99 ; write block
JSR S_DF47 ; get track and sector
LDA zp79 ; track
PHA
LDA zp7A ; and sector
PHA ; save
JSR S_DF79 ; get track and sector from disk
LDA zp7A ; controller
PHA
LDA zp79 ; save track and sector
PHA
JSR S_E080 ; set buffer pointer for side-sector
TAX
BNE B_E534 ; pointer not zero?
JSR S_E589 ; write side-sector
LDA #$10
JSR S_E024 ; buffer pointer to 16
INC zp7F ; increment side-sector number
B_E534 PLA
JSR S_DEC8 ; track in side-sector
PLA
JSR S_DEC8 ; sector in side-sector
PLA
STA zp7A ; sector
PLA
STA zp79 ; and get track back
BEQ B_E553 ; no more blocks?
LDA zp7F ; side-sector number
CMP zp92 ; changed?
BNE B_E4F1 ; yes
JSR S_E080 ; set buffer pointer in side-sector
CMP zp93 ; end pointer
BCC B_E4F1 ; smaller?
BEQ B_E503 ; same
B_E553 JSR S_E080 ; set buffer pointer in side-sector
PHA
LDA #$00
JSR S_E017 ; buffer pointer to zero
LDA #$00
TAY
STA (zp8D),Y ; zero as track number
INY
PLA ; end pointer
SEC
SBC #$01 ; minus one
STA (zp8D),Y ; as sector
JSR S_DFA7 ; write block
JSR S_D6EC ; and verify
JSR S_ED5F ; update BAM
JSR S_CEFD ; update pointer for rel-file
JSR S_CFD4 ; change buffer
JSR S_E033 ; right side-sector?
BVS B_E57F ; no
JMP L_E3B0
;
B_E57F LDA #$80
JSR L_DED2 ; set bit 7
LDA #$50
JSR L_C2B2 ; 50, 'record not present'
;
; Write side-sector and allocate new
;
S_E589 JSR S_EF89 ; find free block in BAM
JSR S_CFD4 ; change buffer
JSR S_DF2C ; write block
JSR S_E0CE ; get buffer number
PHA
JSR S_DFFC ; erase buffer
LDX zp7B ; channel number
LDA zpCE,X ; buffer number
TAY
PLA
TAX
LDA #$10 ; 16 bytes of the side-sector
JSR S_DFE0 ; copy in buffer
LDA #$00
JSR S_E017 ; buffer pointer to 0, old side-sector
LDY #$02
LDA (zp8D),Y ; side-sector number
PHA
LDA #$00
JSR S_D61B ; buffer pointer to 0, new side-sector
PLA
CLC
ADC #$01 ; increment side-sector number
STA (zp8D),Y ; and in buffer
ASL A ; times 2
ADC #$04 ; plus 4
STA zp81+1
TAY
SEC
SBC #$02 ; minus 2
STA zp82+1 ; same pointer to old side-sector
LDA zp79 ; track
STA zp7F+1
STA (zp8D),Y ; in buffer
INY
LDA zp7A ; sector
STA zp81
STA (zp8D),Y ; in buffer
LDY #$00
TYA
STA (zp8D),Y ; zero in buffer
INY
LDA #$11 ; 17
STA (zp8D),Y ; number of bytes in block
LDA #$10 ; 16
B_E5DE JSR S_D61B ; buffer pointer to 16
JSR S_DF8B ; write block
JSR S_D6EC ; and verify
LDX zp7B ; channel number
LDA zpCE,X ; buffer number of the side-sector
PHA
JSR S_E0D9 ; get buffer number
LDX zp7B ; channel number
STA zpCE,X ; write in table
PLA
LDX V_0257 ; channel number + 7
STA zpA8,X ; in table
LDA #$00
JSR S_D61B ; buffer pointer to zero
LDY #$00
LDA zp79 ; track
STA (zp8D),Y ; in buffer
INY
LDA zp7A ; sector
STA (zp8D),Y ; in buffer
JMP L_E619
;
B_E60C JSR S_E0CE ; get buffer number
LDX zp7B ; channel number
JSR S_E056 ; read block
LDA #$00
JSR S_D61B ; buffer pointer to zero
L_E619 DEC zp82+1
DEC zp82+1 ; counter for side-sector blocks
LDY zp81+1
LDA zp7F+1 ; track number
STA (zp8D),Y ; in buffer
INY
LDA zp81 ; sector number
STA (zp8D),Y ; in buffer
JSR S_DF99 ; write block
JSR S_D6EC ; and verify
LDY zp82+1 ; counter for side-sector blocks
CPY #$03
BCS B_E60C ; greater than or equal to 3?
JMP S_CFD4 ; change buffer
;
; Error codes and messages
;
DB $00
DB $A0,"OK"
DB $20,$21,$22,$23,$24,$27
DB $D2,$45,$41,$44
DB $89
; $E646
DB $52
; $E647
DB $83
DB " TOO LARGe"
DB $50
DB $8B
DB $06
DB "oVERFLOW"
DB " IN"
DB $8B
DB $25,$28
DB $8A
DB $89
DB $26
DB $8A
DB " PROTECT On"
DB $29
DB $88
DB " ID"
DB $85
DB $30,$31,$32,$33,$34
DB $D3,$59,$4E,$54,$41,$58 ; "Syntax"
DB $89
DB $60
DB $8A
; $E68F
DB $03
DB $84
; $E691
DB $63
DB $83
DB " EXISTs"
DB $64
DB $83
DB " TYPE"
DB $85
DB $65
DB "nO BLOCK"
DB $66,$67
DB "iLLEGAL TRACK OR SECTOR"
DB $61
; $E6C5
DB $83,$06
STY zp39
; $E6C9
DB "b"
; $E6CA
DB $83,$06
; $E6CC
DB $87,$01
; $E6CE
DB $83,"S"
JSR S_4353
; $E6D3
DB "R"
EOR (zp54,X)
; $E6D6
DB "CH"
EOR zpC4
BVS B_E6AA
; $E6DC
DB "O C"
PHA
EOR (zp4E,X)
LSR V_CC45
B_E6E5 ADC (zpC4),Y
EOR #$52 ; "R"
; $E6E9
DB $89,$72
DEY
JSR S_5546
JMP L_73CC
;
; $E6F2
DB $C3,"B"
EOR V_4420
; $E6F7
DB "OS "
LSR zp32,X
ROL V_2036
; $E6FF
DB "T"
V_E700 DB "D"
EOR #$53 ; "S"
DB $CB,$74
CPY zp52
EOR #$56 ; "V"
EOR zp06
JSR S_4552
EOR (zp44,X)
CMP V_C508 + 1,Y
; $E713
DB "R"
; $E714
DB "R"
; $E715
DB "O",$D2,$0A
; $E718
DB $D7,"R"
EOR #$54 ; "T"
CMP zp03
DEC zp49
JMP L_04C5
;
; $E723
DB $CF,"PE"
DEC V_CD05
EOR #$53 ; "S"
EOR V_5441
; $E72E
DB "C",$C8
ASL zpCE
; $E732
DB $4F,$D4,$07
DEC zp4E+1
EOR zp4E,X
CPY zp08
CPY zp49
; $E73D
DB "S",$CB
; $E73F
DB $0B,$D2
EOR zp43
; $E743
DB "OR",$C4
;
; Prepare error number and message
;
L_E746 PHA ; save error code
STX zp98 ; drive number
TXA
ASL A ; times 2
TAX ; as pointer
LDA zp08,X
STA zp79 ; get track
LDA zp09,X
STA zp7A ; and sector number
PLA ; get error code back
AND #$0F ; isolate bits 0-3
BEQ B_E761 ; zero, then 24, 'read error'
CMP #$0F ; 15?
BNE B_E763
LDA #$74 ; 74, 'drive not ready'
BNE B_E769 ; 6
B_E761 LDA #$06
B_E763 ORA #$20 ; add $20
TAX
DEX
DEX ; subtract two (= 36)
TXA
B_E769 PHA ; save error number
LDA V_022A ; number of the disk command
CMP #$00 ; OPEN or VALIDATE?
BNE B_E780 ; no
LDA #$FF
STA V_022A
PLA ; get error number back
JSR S_E806 ; generate error message
JSR S_D15E ; load BAM
JMP S_E784 ; set error message
;
B_E780 PLA
;
; Print error message into error buffer
;
S_E781 JSR S_E806 ; set error message
;
S_E784 JSR S_C2A7 ; erase input buffer
LDA #$00
STA V_02F9 ; erase error flag
JSR L_F3F7 ; turn LED off
JSR L_D62D ; close channels 17 and 18
LDA #$00
STA zpA4 ; input buffer pointer to zero
LDX #$FF
TXS ; initialize stack pointer
LDA zp7D ; secondary address
AND #$0F
STA zp7C
CMP #$0F ; 15?
BEQ B_E7D4 ; yes, command channel
LDA zp5C ; LISTEN active?
BNE B_E7C4 ; yes
LDA zp5B ; TALK active?
BNE B_E7BB ; yes
LDX zp7C ; channel number
LDA V_022B,X ; open channel to this secondary addr
CMP #$FF
BEQ B_E7D4 ; no
AND #$0F
STA zp7B ; channel
JMP L_E7CA
;
; TALK
;
B_E7BB JSR S_D1FB
JSR S_C1CD
JMP L_E7CA
;
; LISTEN
;
B_E7C4 JSR S_D217
JSR S_C1D8
;
L_E7CA JSR S_D235 ; verify file type
CMP #$04 ; file type REL?
BCS B_E7D4 ; yes
JSR L_D37D ; close channel
;
B_E7D4 LDX #$FF ; reset stack pointer
TXS
JMP L_EABD ; jump to main loop
;
; Convert BIN to 2-Ascii (error message buffer)
;
S_E7DA TAX
LDA #$00
SED
L_E7DE CPX #$00
BEQ B_E7E9 ; convert hex to BCD
CLC
ADC #$01
DEX
JMP L_E7DE
;
B_E7E9 CLD
;
; Convert BCD to 2-Ascii (error message buffer)
;
S_E7EA TAX
LSR A
LSR A ; shift hi-nibble down
LSR A
LSR A
JSR S_E7F3 ; convert to ASCII
TXA
S_E7F3 AND #$0F ; erase top 4 bits
ORA #$30 ; add '0'
STA (zpA6),Y ; write in buffer
INY ; increment buffer pointer
RTS
;$E7FB -------- Write OK in buffer
L_E7FB JSR S_F3F0 ; erase error flag
LDA #$00 ; error number 0
;
; Print error on track 00,00 to error buffer
;
S_E800 LDY #$00
STY zp79 ; track 0
STY zp7A ; sector 0
S_E806 LDY #$00 ; buffer pointer
LDX #$D5
STX zpA6 ; pointer $A5/$A6 to $2D5
LDX #$02
STX zpA6+1
JSR S_E7EA ; error number to ASCII and in buffer
LDA #$2C ; ',' comma
STA (zpA6),Y ; write in buffer
INY ; increment buffer pointer
LDA V_02D5 ; first digit of the disk status
STA V_0243 ; in output register
TXA ; error number in accumulator
JSR S_E845 ; error message in buffer
LDA #$2C ; ',' comma
STA (zpA6),Y ; write in buffer
INY ; and increment buffer pointer
LDA zp79 ; track number
JSR S_E7DA ; to ASCII and in buffer
LDA #$2C ; ',' comma
STA (zpA6),Y ; write in buffer
INY ; increment buffer pointer
LDA zp7A ; sector
JSR S_E7DA ; convert to ASCII and in buffer
DEY
TYA
CLC
ADC #$D5
STA V_0249 ; end pointer
INC zpA6
LDA #$88 ; set READ flag
STA zpF8
RTS
;$E845 -------- Write error message string to buffer
S_E845 TAX ; error code to X
LDA zp7F
PHA
LDA zp7F+1 ; preserve pointer $7f/$80
PHA
LDA #$37
STA zp7F
LDA #$E6 ; start of the error messages
STA zp7F+1 ; E637
TXA ; error number in accumulator
LDX #$00
L_E857 CMP (zp7F,X) ; compare with error number in table
BEQ B_E87C
PHA
JSR S_E8B4 ; bit 7 into carry and erase
BCC B_E866 ; not set?
B_E861 JSR S_E8B4 ; bit 7 into carry
BCC B_E861 ; wait for character with bit 7 set
B_E866 LDA zp7F+1
CMP #$E7
BCC B_E874 ; $E746 ...
BNE B_E878
LDA #$46 ; ... check to end of table
CMP zp7F
BCC B_E878
B_E874 PLA
JMP L_E857 ; no, continue
;
B_E878 PLA
JMP L_E88C ; done
;
B_E87C JSR S_E8A6 ; get a character, bit 7 in carry
BCC B_E87C ; wait for character with bit 7 set
B_E881 JSR S_E893 ; and write in buffer
JSR S_E8A6 ; get next character
BCC B_E881 ; wait for character with bit 7 set
JSR S_E893 ; put character in buffer
L_E88C PLA
STA zp7F+1
PLA ; get pointer $7f/$80 back
STA zp7F
RTS
;$E893 -------- Get character and in buffer
S_E893 CMP #$20 ; ' ' blank
BCS B_E8A2 ; greater, then write in buffer
TAX ; save code
LDA #$20 ; blank
STA (zpA6),Y ; write in buffer
INY ; increment buffer pointer
TXA ; code in accumulator
JSR S_E845 ; output previous text
RTS
;$E8A2 --------
B_E8A2 STA (zpA6),Y ; write character in buffer
INY ; and increment pointer
RTS
;$E8A6 -------- Get a char of the error message
S_E8A6 INC zp7F
BNE S_E8AC ; increment pointer
INC zp7F+1
S_E8AC LDA (zp7F,X) ; get character
ASL A ; bit 7 into carry
LDA (zp7F,X) ; get character
AND #$7F ; erase bit 7
RTS
;$E8B4 --------
S_E8B4 JSR S_E8AC ; bit 7 into carry
INC zp7F
BNE B_E8BD ; increment pointer
INC zp7F+1
B_E8BD RTS
;$E8BE -------- Dummy subroutine
L_E8BE RTS
;$E8BF --------
JMP L_E8BE
;
CLI
INC V_0278
INC V_0274
LDA #$2A
STA V_0200
JMP L_E8D9
;
LDA #$01
STA V_027A
JSR S_C3FC
L_E8D9 LDA V_0278
PHA
LDA #$01
STA V_0278
V_E8E2 LDA #$FF
STA zp7F
JSR S_C53A
LDA V_0280
BNE B_E8F3
LDA #$39
JSR L_C2B2
B_E8F3 PLA
STA V_0278
LDA V_0280
STA zp79
LDA V_0285
STA zp7A
LDA #$03
JSR S_D5CA
B_E906 LDA #$00
STA zp7F+1 ; erase checksum
JSR S_E967 ; get byte from file
STA zp81 ; save as start address lo
JSR S_E979 ; from checksum
JSR S_E967 ; get byte from file
STA zp81+1 ; as start address hi
JSR S_E979 ; form checksum
LDA zp7F
BEQ B_E928
LDA zp81
PHA ; save program start address
LDA zp81+1
PHA
LDA #$00
STA zp7F
B_E928 JSR S_E967 ; get byte from file
STA zp82+1 ; save as counter
JSR S_E979 ; form checksum
B_E930 JSR S_E967 ; get byte from file
LDY #$00
STA (zp81),Y ; save as program bytes
JSR S_E979 ; form checksum
LDA zp81
CLC
ADC #$01
STA zp81 ; increment $88/$89
BCC B_E945
INC zp81+1
B_E945 DEC zp82+1 ; decrement pointer
BNE B_E930
JSR S_CB2A ; get next byte
LDA zp7E ; data byte
CMP zp7F+1 ; equal to checksum?
BEQ B_E95A ; yes
JSR S_DF79 ; transmit parameter to disk controller
LDA #$50 ;
JSR S_E781 ; 50, 'record not present'
B_E95A LDA zp95 ; end?
BNE B_E906 ; no, next data block
PLA
STA zp81+1
PLA ; get program start address back
STA zp81
JMP ($0081) ; *** Indirect jump to program
;
S_E967 JSR S_CB2A ; get byte from file
LDA zp95 ; end?
BNE B_E976 ; no
JSR S_DF79 ; transmit parameter to disk controller
LDA #$51
JSR S_E781 ; 51, 'overflow in record'
B_E976 LDA zp7E ; data byte
RTS
;$E979 -------- Generate checksum
S_E979 CLC
ADC zp7F+1
ADC #$00
STA zp7F+1
RTS
;$E981 -------- Blink LED and loop
L_E981 LDX #$00
DB $2C ; BIT $xxxx
L_E984 LDX zp6E ;
TXS ; load X to stack pointer
B_E987 TSX ; read X from stack pointer
B_E988 LDA #$6F
STA zp00 ; set direction of processor port to default
AND #$60 ; drive LED on
STA zp01 ; store #$60 to processor port
TYA
B_E991 CLC
B_E992 ADC #$01
BNE B_E992
DEY
BNE B_E991 ; delay (WAIT)
LDA #$68
STA zp01 ; drive LED off
B_E99D TYA
B_E99E CLC
B_E99F ADC #$01
BNE B_E99F
DEY
BNE B_E99E ; delay (WAIT)
DEX
BPL B_E988 ; flash LED
CPX #$F4
BNE B_E99D
BEQ B_E987
L_E9AF JMP L_E984
;
B_E9B2 JMP L_E981
;
; Drive RESET
;
SEI
CLD
LDY #$00
LDX #$02 ; memory test on zero lap ($02-$FF)
B_E9BB TXA
STA zp00,X
INX
BNE B_E9BB
LDX #$02
B_E9C3 TXA
CMP zp00,X
BNE B_E9B2
B_E9C8 INC zp00,X
INY
BNE B_E9C8
CMP zp00,X
BNE B_E9B2 ; memory test failure (x will be the RAM page nr)?
STY zp00,X ; clear to 0 (zero)
LDA zp00,X ; check
BNE B_E9B2 ; memory test failed...
INX
BNE B_E9C3 ; loop
INC zp6E ; increase blink count
STX zp74+1
LDA #$00 ; ROM checksumgeneration begins
STA zp74
TAY ; Y = A (0)
LDX #$40
CLC
B_E9E6 DEC zp74+1
B_E9E8 ADC (zp74),Y
INY
BNE B_E9E8
DEX
BNE B_E9E6
STA zp61 ; reset count
ADC #$FF
BNE L_E9AF ; ROM checksum correct?
LDA #$01
STA zp74+1
INC zp6E
LDX #$07
B_E9FE TYA
CLC
ADC zp74+1
STA (zp74),Y
INY
BNE B_E9FE
INC zp74+1
DEX
BNE B_E9FE
LDX #$07
B_EA0E DEC zp74+1
B_EA10 DEY
TYA
CLC
ADC zp74+1
CMP (zp74),Y
BNE B_EA2B
EOR #$FF ; reverse all bits
STA (zp74),Y
EOR (zp74),Y ; check
STA (zp74),Y
BNE B_EA2B ; not equal, then jump
TYA
BNE B_EA10
DEX
BNE B_EA0E
BEQ B_EA2E ; always jump
B_EA2B JMP L_E9AF
;
B_EA2E LDX #$FF
STX zp95
TXS ; clear stack pointer
JSR S_C3C6 ; DOS init
JSR S_F13D ; FDC init
LDA #$11
STA zp68
LDA #$05
STA zp69
LDX #$00
LDY #$00
B_EA45 LDA #$00
STA zp9A,X
INX
LDA V_F123,Y
STA zp9A,X
INX
INY
CPY #$05
BNE B_EA45
LDA #$00
STA zp9A,X
INX
LDA #$02
STA zp9A,X
INX
LDA #$D5
STA zp9A,X
INX
LDA #$02
STA zp9A,X
LDA #$FF
LDX #$12
B_EA6C STA V_022B,X
DEX
BPL B_EA6C
LDX #$05
B_EA74 STA zpA8,X
STA zpAF,X
STA zpCE,X
DEX
BPL B_EA74
LDA #$05
STA zpAC
LDA #$06
STA zpAD
LDA #$FF
STA zpAE
STA zpB5
LDA #$05
STA V_023B
LDA #$84
STA V_023A
LDA #$0F
STA V_0256
LDA #$01
STA zpF7
LDA #$88
STA zpF8
LDA #$E0
STA V_024F
LDA #$FF
STA V_0250
LDA #$01
STA zp22
STA zp23
JSR S_CC55
JSR S_CFB0
LDA #$73
JSR S_E800
;
; Main wait loop
;
L_EABD INC zp61 ; count
BNE B_EAC4 ; if not zero, skip next call
JSR S_EADC
B_EAC4 LDA V_4000 ; read I/O port from computer
BPL B_EACC ; 7th bit set?
JSR S_C022 ; yes, then jump
B_EACC LDA V_0255 ; waiting for command?
BEQ L_EABD ; no...
LDA #$00 ; yes
STA V_0255 ; clear command flag
JSR S_C230 ; analyze and execute command
JMP L_EABD ; back to main loop
;
;
;
S_EADC LDA #$0E ; 14
STA zp63 ; as secondary address
LDA #$00
STA zp62 ; job counter
B_EAE4 LDX zp63
LDA V_022B,X ; secondary address
CMP #$FF ; channel associated?
BEQ B_EAEF ; no
INC zp62
B_EAEF DEC zp63
BPL B_EAE4
LDA zp62
BEQ B_EAFE
LDA zp22
BEQ B_EAFE
JSR S_D465
B_EAFE LDX V_026C
BEQ B_EB06
JMP L_F3F7 ; set LED flag
;
B_EB06 LDA zp62
STA zp96
RTS
;$EB0B --------
S_EB0B LDA #$00
STA zp7C
LDA #$01
JSR S_D338
LDA #$00
JSR S_D61B
LDX zp7B
LDA #$00
STA V_0244,X
JSR S_E0CE
TAX
LDA zp78
STA V_025B,X
LDA #$01
JSR S_D10D
LDA #$04
JSR S_D10D
LDA #$01
JSR S_D10D
JSR S_D10D
LDA V_0272
JSR S_D10D
LDA #$00
JSR S_D10D
JSR S_EBC6
JSR S_E0CE
ASL A
TAX
DEC zp9A,X
DEC zp9A,X
LDA #$00
JSR S_D10D
B_EB57 LDA #$01
JSR S_D10D
JSR S_D10D
JSR S_C7AF
BCC B_EB90
LDA V_0272
JSR S_D10D
LDA V_0273
JSR S_D10D
JSR S_EBC6
LDA #$00
JSR S_D10D
BNE B_EB57
L_EB7A JSR S_E0CE
ASL A
TAX
LDA #$00
STA zp9A,X
LDA #$88
LDY zp7B
STA V_0254
STA $00F3,Y
LDA zp7E
RTS
;$EB90 --------
B_EB90 LDA V_0272 ; block number lo
JSR S_D10D ; write in buffer
LDA V_0273 ; block number hi
JSR S_D10D ; in buffer
JSR S_EBC6 ; 'blocks free.' in buffer
JSR S_E0CE ; get buffer number
ASL A
TAX
DEC zp9A,X
DEC zp9A,X ; buffer pointer minus 2
LDA #$00
JSR S_D10D
JSR S_D10D ; three zeroes as program end
JSR S_D10D
JSR S_E0CE ; get buffer number
ASL A ; times 2
TAY
LDA $009A,Y ; buffer pointer
LDX zp7B
STA V_0244,X ; as end marker
DEC V_0244,X
JMP L_EB7A
;
; Transmit dir line
;
S_EBC6 LDY #$00
B_EBC8 LDA V_02B1,Y ; character from buffer
JSR S_D10D ; write in output buffer
INY
CPY #$1B ; 27 characters?
BNE B_EBC8
RTS
;$EBD4 -------- Get byte from buffer
S_EBD4 JSR S_D247 ; get byte
BEQ B_EBDA ; buffer pointer zero?
RTS
;$EBDA --------
B_EBDA STA zp7E ; save data byte
LDY zp7B ; channel number
LDA V_0244,Y ; set end marker
BEQ B_EBEB ; zero (LOAD $)?
LDA #$80
STA $00F3,Y ; set READ flag
LDA zp7E ; data byte
RTS
;$EBEB --------
B_EBEB PHA
JSR B_EB57 ; create directory line in buffer
PLA
RTS
;$EBF1 -------- Perform [V] - Validate command
JSR S_C2BB ; find drive number in input line
JSR S_D15E ; load BAM
LDA #$40
STA V_02F9
JSR S_ED22 ; create new BAM in buffer
LDA #$00
STA V_0292
JSR S_C691 ; load directory, find 1st flag
BNE B_EC46 ; found?
B_EC09 LDA #$00
STA zp7A ; sector 0
LDA V_F0C3 ; 18
STA zp79 ; track 18 for BAM
JSR S_EC52 ; mark directory blocks as allocated
LDA #$00
STA V_02F9
JSR S_ED6A ; write BAM back to disk
JMP L_C27E ; done, prepare disk status
;
B_EC20 INY
LDA (zp8D),Y ; save track
PHA
INY
LDA (zp8D),Y ; and sector
PHA
LDY #$13 ; pointer to side-sector block
LDA (zp8D),Y
BEQ B_EC38 ; no track following?
STA zp79 ; track and
INY
LDA (zp8D),Y
STA zp7A ; sector of 1st side-sector block
JSR S_EC52 ; mark side-sector block as
B_EC38 PLA ; allocated
STA zp7A
PLA ; get track and sector back
STA zp79
JSR S_EC52 ; mark blocks of file as allocated
L_EC41 JSR S_C6E9 ; read next entry in directory
BEQ B_EC09 ; end of directory?
B_EC46 LDY #$00
LDA (zp8D),Y ; file type
BMI B_EC20 ; bit 7 set, file closed?
JSR S_C997 ; file type to zero and write BAM
JMP L_EC41
;
; Allocate file blocks in BAM
;
S_EC52 JSR S_D6B0 ; check track and sector number
JSR S_EDFB ; allocate block in BAM
JSR S_D5C8 ; read next block
L_EC5B LDA #$00
JSR S_D61B ; buffer pointer zero
JSR S_D247 ; get byte from buffer
STA zp79 ; track
JSR S_D247 ; get byte from buffer
STA zp7A ; sector
LDA zp79 ; another block?
BNE B_EC71 ; yes
JMP L_D37D ; close channel
;
B_EC71 JSR S_EDFB ; allocate block in BAM
JSR S_D5A0 ; read next block
JMP L_EC5B ; continue
;
; Perform [N] - New (Format) command
;
JSR S_C3FC ; get drive number
LDA zpE3 ; drive number
BPL B_EC86 ; not clear?
LDA #$33
JMP L_C2B2 ; 33, 'syntax error'
;
B_EC86 AND #$01
STA zp78 ; drive number
TAX
LDY #$00
STY zp5F,X
ASL A ; times 2
TAX
LDY V_027B ; comma position
CPY V_0274 ; compare with end name
BEQ B_ECB3 ; format without ID
LDA V_0200,Y ; first character of ID
STA zp14,X ; save
LDA L_0201,Y ; second character
STA zp15,X
JSR S_D459 ; close all channels
LDA #$01
STA zp79 ; track 1
JSR S_C9A7 ; format disk
JSR S_EE70 ; erase buffer
JMP L_ECC2 ; continue as below
;
B_ECB3 JSR S_D15E ; load BAM
LDX zp78 ; drive number
LDA zp5D,X
CMP V_F118 ; 'A', marker for 1541 format
BEQ L_ECC2 ; ok
JMP L_D6C3 ; 73, 'cbm dos v2.6 tdisk'
;
L_ECC2 JSR S_ED22 ; create BAM
LDA zp98 ; buffer number
TAY
ASL A
TAX
LDA V_F0C6 ; $90, start of disk name
STA zp9A,X ; buffer pointer to name
LDX V_027A
LDA #$1B ; 27
JSR S_C74F ; write filenames in buffer
LDY #$12 ; position 18
LDX zp78 ; drive number
LDA V_F118 ; 'A', 1541 format
STA zp5D,X
TXA
ASL A ; times 2
TAX
LDA zp14,X ; ID, first character
STA (zp8D),Y ; in buffer
INY
LDA zp15,X ; and second character
STA (zp8D),Y ; in buffer
INY
INY
LDA #$32 ; '2'
STA (zp8D),Y ; in buffer
INY
LDA V_F118 ; 'A' 1541 format
STA (zp8D),Y ; in buffer
LDY #$02
STA (zp6C),Y ; and at position 2
LDA V_F0C3 ; 18
STA zp79 ; track number
JSR S_EDFE ; mark block as allocated
LDA #$01 ; 1
STA zp7A ; sector number
JSR S_EDFE ; mark block as allocated
JSR S_ED6A ; write BAM
JSR S_EE70 ; pointer $6D/$6E to buffer, erase buffer
LDY #$01
LDA #$FF
STA (zp6C),Y ; track following is zero
JSR S_D5B7 ; write BAM
DEC zp7A ; decrement sector number, 0
JSR S_D5B3 ; read block
JMP L_C27E ; prepare disk status
;
; Create BAM
;
S_ED22 JSR S_EF3C
LDY #$00
LDA #$12 ; 18
STA (zp6C),Y ; pointer to directory track
INY
TYA ; 1
STA (zp6C),Y ; pointer to directory sector
INY
INY
INY
B_ED32 LDA #$00
STA zp6E
STA zp6E+1 ; 3 bytes = 24 bits for sectors
STA zp70
TYA ; byte position
LSR A
LSR A ; divided by 4 = track number
JSR S_F0B6 ; get number of sectors
STA (zp6C),Y ; and in BAM
INY
TAX
B_ED44 SEC
ROL zp6E
ROL zp6E+1 ; create bit model
ROL zp70
DEX
BNE B_ED44
B_ED4E LDA zp6E,X ; 3 bytes
STA (zp6C),Y ; the BAM in buffer
INY
INX
CPX #$03
BCC B_ED4E
CPY #$90 ; position 144?
BCC B_ED32 ; no, next track
JMP L_D185 ; calculate number of free blocks
;
; Write BAM if needed
;
S_ED5F JSR S_E0CE ; get buffer number
TAX
LDA V_025B,X ; command for disk controller
AND #$01
STA zp78 ; isolate drive number
S_ED6A LDY zp78
LDA V_0251,Y ; BAM-changed flag set?
BNE B_ED72 ; yes
RTS
;$ED72 --------
B_ED72 LDA #$00
STA V_0251,Y ; reset BAM-changed flag
JSR S_EDA5 ; set buffer pointer for BAM
LDA zp78 ; drive number
ASL A ; times 2
PHA
JSR S_EF10 ; verify BAM entry
PLA
CLC
ADC #$01 ; inrement track number
JSR S_EF10 ; verify BAM entry
LDA zp79 ; track
PHA
LDA #$01 ; track 1
STA zp79
B_ED8F ASL A
ASL A ; times 4
STA zp6C
JSR S_F08B ; verify BAM
INC zp79 ; increment track number
LDA zp79
CMP V_F11A ; and compare with max val + 1 = 36
BCC B_ED8F ; ok, next track
PLA
STA zp79 ; get track number back
JMP L_D6DD ; write BAM to disk
;
; Set buffer pointer for BAM
;
S_EDA5 JSR S_EF7A ; get 6 for drive 0
TAX
JSR S_EF4A ; allocate buffer
LDX zp98 ; buffer number
LDA V_F123,X ; buffer address, hi byte
STA zp6C+1
LDA #$00 ; lo byte
STA zp6C ; pointer to $6D/$6E
RTS
;$EDB8 -------- Get number of free blocks for dir
S_EDB8 LDX zp78 ; drive number
LDA V_02FA,X ; number of blocks, lo
STA V_0272
LDA V_02FC,X ; number of blocks, hi
STA V_0273 ; in buffer for directory
RTS
;$EDC7 -------- Mark block as free
JSR S_EE5B + 1 ; set buffer pointer
S_EDCA JSR S_EE3A ; erase bit for sector in BAM
SEC
BNE B_EDF2 ; block already free, then done
LDA (zp6C),Y ; bit model of BAM
ORA V_EE54,X ; set bit X, marker for free
STA (zp6C),Y
JSR S_EDF3 ; set flag for BAM changed
LDY zp6E
CLC
LDA (zp6C),Y
ADC #$01 ; increment number of free blocks/track
STA (zp6C),Y
LDA zp79 ; track
CMP V_F0C3 ; equal to 18?
BEQ B_EE25 ; then skip
INC V_02FA,X ; increment number of free blocks in disk
BNE B_EDF2
INC V_02FC,X ; increment number of blocks hi
B_EDF2 RTS
;$EDF3 -------- Set flag for BAM changed
S_EDF3 LDX zp78 ; drive number
LDA #$01
STA V_0251,X ; flag = 1
RTS
;$EDFB -------- Mark block as allocated
S_EDFB JSR S_EE5B + 1 ; set buffer pointer
S_EDFE JSR S_EE3A ; erase bit for sector in BAM
BEQ B_EE39 ; already allocated, then done
LDA (zp6C),Y
EOR V_EE54,X ; erase bit for block
STA (zp6C),Y
JSR S_EDF3 ; set flag for BAM changed
LDY zp6E
LDA (zp6C),Y
SEC
SBC #$01 ; decrement number of blocks per track
STA (zp6C),Y
LDA zp79 ; track
CMP V_F0C3 ; 18?
BEQ B_EE28
LDA V_02FA,X ; number of free blocks lo
BNE B_EE25
DEC V_02FC,X ; decrement number of free blocks
B_EE25 DEC V_02FA,X
B_EE28 LDA V_02FC,X ; number of free blocks hi
BNE B_EE39 ; more than 255 blocks free?
LDA V_02FA,X ; free blocks lo
CMP #$03
BCS B_EE39 ; smaller than 3?
LDA #$72
JSR S_E806 ; 72, 'disk full'
B_EE39 RTS
;$EE3A -------- Erase bit for sector in BAM entry
S_EE3A JSR S_EE7C ; find BAM field for this track
TYA
STA zp6E
S_EE40 LDA zp7A ; sector
LSR A
LSR A ; divide by 8
LSR A
SEC
ADC zp6E
TAY ; byte number in BAM entry
LDA zp7A ; sector number
AND #$07
TAX ; bit number in BAM entry
LDA (zp6C),Y ; byte in BAM
AND V_EE54,X ; erase bit for corresponding sector
RTS
;$EE54 -------- Powers of 2
V_EE54 DB $01,$02,$04,$08,$10,$20,$40,$80
;$EE5C -------- Write BAM after change
S_EE5C LDA #$FF
BIT $02F9
BEQ B_EE6F
BPL B_EE6F
BVS B_EE6F
LDA #$00
STA V_02F9 ; reset flag
JMP L_D6DD ; write block
;
B_EE6F RTS
;$EE70 -------- Erase BAM buffer
S_EE70 JSR S_EDA5 ; pointer $6c/$6d to BAM buffer
LDY #$00
TYA
B_EE76 STA (zp6C),Y ; erase BAM buffer
INY
B_EE79 BNE B_EE76
RTS
;$EE7C --------
S_EE7C LDA zp6E
PHA
LDA zp6E+1
PHA
LDX zp78 ; drive number
LDA zp5F,X
BEQ B_EE8D ; drive zero?
LDA #$74
JSR S_E784 ; 'drive not ready'
B_EE8D JSR S_EF7A ; get buffer number for BAM
STA zp6E
TXA
ASL A
STA zp6E+1
TAX
LDA zp79 ; track
CMP V_029D,X
BEQ B_EEA9
INX
STX zp6E+1
CMP V_029D,X
BEQ B_EEA9
JSR S_EEC6
B_EEA9 LDA zp6E+1
LDX zp78 ; drive number
STA V_029B,X
ASL A
ASL A ; times 4
CLC
ADC #$A1
STA zp6C
LDA #$02
ADC #$00
STA zp6C+1
LDY #$00
PLA
STA zp6E+1
PLA
STA zp6E
RTS
;$EEC6 --------
S_EEC6 LDX zp6E
JSR S_EF4A
LDA zp78 ; drive number
TAX
ASL A
ORA V_029B,X
EOR #$01
AND #$03
STA zp6E+1
JSR S_EF10
LDA zp98 ; buffer number
ASL A
TAX
LDA zp79 ; track
ASL A
ASL A ; times 4
STA zp9A,X ; equal pointer in BAM field
LDA zp6E+1
ASL A
ASL A
TAY
B_EEEA LDA (zp9A,X)
STA V_02A1,Y
LDA #$00
STA (zp9A,X) ; zero in buffer
INC zp9A,X ; increment buffer pointer
INY
TYA
AND #$03
BNE B_EEEA
LDX zp6E+1
LDA zp79 ; track
STA V_029D,X
LDA V_02F9
BNE B_EF0A
JMP L_D6DD ; write block
;
B_EF0A ORA #$80
STA V_02F9
RTS
;$EF10 --------
S_EF10 TAY
LDA V_029D,Y
BEQ B_EF3B
PHA
LDA #$00
STA V_029D,Y
LDA zp98 ; buffer number
ASL A ; times 2
TAX
PLA
ASL A
ASL A
STA zp9A,X
TYA
ASL A
ASL A
TAY
B_EF29 LDA V_02A1,Y
STA (zp9A,X) ; write in buffer
LDA #$00
STA V_02A1,Y
INC zp9A,X ; increment buffer pointer
INY
TYA
AND #$03
BNE B_EF29
B_EF3B RTS
;$EF3C -------- Clear BAM
S_EF3C LDA zp78 ; drive number
ASL A ; * 2
TAX ; index
LDA #$00
STA V_029D,X
INX
STA V_029D,X
RTS
;$EF4A --------
S_EF4A LDA zpA8,X
CMP #$FF
BNE B_EF75
TXA
PHA
JSR S_D3E4
TAX
BPL B_EF5D
LDA #$70
JSR L_C2B2 ; 70, 'no channel'
B_EF5D STX zp98
PLA
TAY
TXA
ORA #$80
STA $00A8,Y
ASL A
TAX
LDA V_F0C3 ; 18, directory track
STA zp08,X ; save
LDA #$00 ; 0
STA zp09,X ; as sector
JMP L_D6D9 ; write block
;
B_EF75 AND #$0F
STA zp98 ; buffer number
RTS
;$EF7A -------- Get buffer number for BAM
S_EF7A LDA #$06
LDX zp78 ; drive number
BNE B_EF83
CLC
ADC #$07 ; gives 13 for drive 0
B_EF83 RTS
;$EF84 -------- Buffer number for BAM
S_EF84 JSR S_EF7A ; get buffer number
TAX
RTS
;$EF89 -------- Find and allocate free block
S_EF89 JSR S_DF79 ; get track and sector number
LDA #$03
STA zp6E ; counter
LDA #$01
ORA V_02F9
STA V_02F9
S_EF98 LDA zp6E ; save counter
PHA
JSR S_EE7C ; find BAM field for this track
PLA
STA zp6E ; get counter back
LDA (zp6C),Y ; number of free blocks in track
BNE B_EFDE ; blocks still free?
LDA zp79 ; track
CMP V_F0C3 ; 18, directory track?
BEQ B_EFC5 ; yes, 'disk full'
BCC B_EFCA ; smaller, then next lower track
INC zp79 ; increment track number
LDA zp79
CMP V_F11A ; 36, highest track number plus one
BNE S_EF98 ; no, continue searching this track
LDX V_F0C3 ; 18, directory track
DEX ; decrement
STX zp79 ; save as track number
LDA #$00
STA zp7A ; begin with sector number zero
DEC zp6E ; decrement counter
BNE S_EF98 ; not yet zero, then continue
B_EFC5 LDA #$72
JSR L_C2B2 ; 72, 'disk full'
B_EFCA DEC zp79 ; decrement track number
BNE S_EF98 ; not yet 0, continue in this track
LDX V_F0C3 ; 18, directory track
INX ; increment
STX zp79 ; save as track number
LDA #$00
STA zp7A ; begin with sector zero
DEC zp6E ; decrement counter
BNE S_EF98 ; not yet zero, then continue
BEQ B_EFC5 ; else 'disk full'
B_EFDE LDA zp7A ; sector number
CLC
ADC zp68 ; plus step width (10)
STA zp7A ; as new number
LDA zp79 ; track number
JSR S_F0B6 ; get maximum sector number
STA V_024E
STA V_024D ; and save
CMP zp7A ; greater than selected sector number?
BCS B_F000 ; yes
SEC ; else
LDA zp7A ; sector number
SBC V_024E ; minus maximum sector number
STA zp7A ; save as new sector number
BEQ B_F000 ; zero?
DEC zp7A ; else decrement sector number by one
B_F000 JSR S_F065 ; check BAM, find free sector
BEQ B_F008 ; not found?
B_F005 JMP S_EDFB ; allocate block in BAM
;
B_F008 LDA #$00
STA zp7A ; sector zero
JSR S_F065 ; find free sector
BNE B_F005 ; found?
JMP L_F060 ; no, 'dir sector'
;
; Find free sector and allocate
;
S_F014 LDA #$01
ORA V_02F9
STA V_02F9
LDA zp7F
PHA
LDA #$01 ; track counter
STA zp7F
B_F023 LDA V_F0C3 ; 18, directory track
SEC
SBC zp7F ; minus counter
STA zp79 ; save as track number
BCC B_F036 ; result <= zero?
BEQ B_F036 ; then try top half of directory
JSR S_EE7C ; find BAM field for this track
LDA (zp6C),Y ; number of free blocks in this track
BNE B_F051 ; free blocks exist
B_F036 LDA V_F0C3 ; 18, directory track
CLC
ADC zp7F ; plus counter
STA zp79 ; save as track number
INC zp7F ; increment counter
CMP V_F11A ; 36, max track number plus one
BCC B_F04A ; smaller, then ok
LDA #$67
JSR S_E781 ; 67, 'illegal track or sector'
B_F04A JSR S_EE7C ; find BAM field for this track
LDA (zp6C),Y ; number of free blocks?
BEQ B_F023 ; no more free blocks?
B_F051 PLA
STA zp7F
LDA #$00
STA zp7A ; sector 0
JSR S_F065 ; find free sector
BEQ L_F060 ; not found?
JMP S_EDFB ; allocate block in BAM
;
L_F060 LDA #$71
JSR S_E781 ; 71, 'dir error'
; Find free sectors in current track
S_F065 JSR S_EE7C ; find BAM field for this track
TYA ; point to number of free blocks
PHA
JSR S_F08B ; verify BAM
LDA zp79 ; track
JSR S_F0B6 ; get max number of sectors of the track
STA V_024E ; save
PLA
STA zp6E ; save pointer
B_F078 LDA zp7A ; compare sector
CMP V_024E ; with maximum number
BCS B_F088 ; greater than or equal to?
JSR S_EE40 ; get bit number of sector
BNE B_F08A ; sector free?
INC zp7A ; increment sector number
BNE B_F078 ; and check if free
B_F088 LDA #$00 ; no sectors free
B_F08A RTS
;$F08B -------- Verify number of free blocks in BAM
S_F08B LDA zp6E
PHA
LDA #$00
STA zp6E ; counter to zero
LDY V_F0C4 ; 4, number of bytes per track in BAM
DEY
B_F096 LDX #$07
B_F098 LDA (zp6C),Y
AND V_EE54,X ; isolate bit
BEQ B_F0A1
INC zp6E ; increment counter of free sectors
B_F0A1 DEX
BPL B_F098
DEY
BNE B_F096
LDA (zp6C),Y ; compare with number on diskette
CMP zp6E
BNE B_F0B1 ; not equal, then error
PLA
STA zp6E
RTS
;$F0B1 --------
B_F0B1 LDA #$71
JSR S_E781 ; 71, 'dir error'
; Establish number of sectors per track
S_F0B6 LDX V_F118 + 1 ; 4 different values
B_F0B9 CMP V_F118 + 1,X ; track number
DEX
BCS B_F0B9 ; not greater?
V_F0BF LDA V_F114,X ; get number of sectors
RTS ; Dummy subroutine
;$F0C3 --------
; $F0C3
V_F0C3 DB "R"-64
; $F0C4
V_F0C4 DB "D"-64,"D"-64
V_F0C6 BCC B_F0EC + 1
LSR zp49,X
; $F0CA
DB "DM"
; $F0CC
DB "B"
EOR zp50,X
ROL zp43
; $F0D1
DB "R"
; $F0D2
DB "SN"
V_F0D4 CMP V_21F1,X
LDX #$ED
ORA V_424E
CMP (zpE5),Y
ADC V_7A04,X
V_F0E1 CMP (zpEB,X)
CMP (zpC9),Y
V_F0E5 DB $CB,$CD
CPY V_E8E2 + 1
CMP #$CB
B_F0EC CMP #$EC
EOR (zpDD),Y
; $F0F0
DB $1C,$9E,$1C
; $F0F3
V_F0F3 DB "R"
; $F0F4
DB "WA"
V_F0F6 EOR L_5344
BVC B_F14F + 1
V_F0FB JMP L_5344 ; *** Self mod. indirect jump!
;
BVC B_F154 + 1
; $F100
V_F100 DB "R"
V_F101 EOR zp45
; $F103
DB "R"
; $F104
DB "SE"
V_F106 JMP L_4751
;
; $F109
DB "R"
JMP L_0201
;
V_F10D DB $00
; $F10E
V_F10E DB $3F
V_F10F DB $7F
V_F110 DB $BF
; $F111
V_F111 DB $FF,"E"-64,"F"-64
V_F114 ORA (zp12),Y
; $F116
DB "S"-64,"U"-64
V_F118 EOR (zp04,X)
V_F11A BIT zp1E+1
V_F11C ORA V_0112,Y
; $F11F
DB $FF,$FF,$01
BRK
; $F123
V_F123 DB "C"-64,"D"-64
ORA zp06
; $F127
DB "G"-64,"G"-64
V_F129 AND (zp22,X)
; $F12B
DB $23,$24
AND zp26
; $F12F
DB $27,$28
V_F131 AND #$02
; $F133
DB "B"-64
; $F134
DB "D"-64,"F"-64
PHP
PHP
; $F138
DB "K"-64,"S"-64
ASL zp58,X
RTS
;$F13D -------- Init drive
S_F13D LDA #$6F
STA zp00 ; set data direction register
AND #$68
STA zp01 ; peripheral control defaults
LDX #$14
STX V_4002
LDX #$1F
STX V_4005
B_F14F LDA V_4002
AND #$20
B_F154 BNE B_F159
LDA #$08
DB $2C
B_F159 LDA #$09
STA zp66
JSR S_C20D
LDA #$FF
STA zp31
STA zp40
LDA #$01
STA zp22
STA zp23
LDA #$00
STA zp4D
LDY #$12 ; Y = 18
LDA #$01
B_F174 STA $0002,Y ; empty job code buffers
DEY
BPL B_F174
LDA #$00
STA V_4003 ; port A to input (listening to machine...)
LDA V_4002
ORA #$08
AND #$FC
STA V_4002
AND #$F7
STA V_4002
ORA #$08
STA V_4002
CLI ; enable IRQ
RTS
;
;$F195 -------- IRQ routine
;
; An IRQ signal is generated by an 555 astable multivibrator
; every 16650 cycles for approx. 14 cycles long
;
PHA
TXA
PHA
TYA
PHA
TSX
STX zp3A ; save stack pointer
L_F19D LDY #$05
B_F19F LDA $0002,Y ; check job queue for all DOS channels
BMI B_F1CB ; job found?
DEY
BPL B_F19F
LDA zp76 ; drive LED flashing?
BNE B_F1BA ; yes...
LDA zp01
ORA #$08 ; drive LED off
LDY zp96 ; counter for drive led
BEQ B_F1B5 ; timeout?
AND #$F7 ; not, then set drive LED back on
B_F1B5 STA zp01
JMP L_F1C8
;
B_F1BA DEC zp55 ; decrease flash counter
BPL L_F1C8 ; timeout?
LDA #$1E ; reset flash counter
STA zp55
LDA zp01
EOR #$08 ; toggle drive LED
STA zp01
L_F1C8 JMP L_FA41
;
B_F1CB AND #$01
TAX
CMP zp31
BEQ B_F1ED
STA zp31
AND #$01
STA zp32
ROR A
ROR A
ROR A
STA zp38
LDA V_4002
AND #$3F
ORA zp38
STA V_4002
JSR S_FA27
JMP L_FA41
;
B_F1ED LDA zp2B
BMI B_F1F4
ASL A
BPL B_F1F7
B_F1F4 JMP L_FA41
;
B_F1F7 LDA #$20
STA zp2B
LDA zp01
AND #$F7
STA zp01
LDY #$05
STY zp32+1
B_F205 JSR S_F284
BMI B_F224
L_F20A DEC zp32+1
BPL B_F205
LDY zp34
JSR S_F286
LDA zp34+1
STA zp3B
ASL zp3B
LDA #$60
STA zp2B
LDA (zp20),Y
STA zp29
JMP L_FA41
;
B_F224 AND #$01
CMP zp31
BNE L_F20A
LDA zp29
BEQ B_F23E
SEC
LDA (zp20),Y
SBC zp29
BEQ B_F23E
STA zp34+1
LDA zp32+1
STA zp34
JMP L_F20A
;
B_F23E LDX #$04
LDA (zp20),Y
STA zp56
B_F244 CMP V_F118 + 1,X
DEX
BCS B_F244
LDA V_F114,X
STA zp57
TXA
ASL A
ASL A
ASL A
ASL A
ASL A
STA zp38
LDA zp01
AND #$9F
ORA zp38
STA zp01
LDA zp1D
CMP #$40
BEQ B_F26F
CMP #$70
BEQ B_F26C
JMP L_F2A6
;
B_F26C JMP L_FB7A
;
B_F26F LDA zp01
AND #$FC
STA zp01
LDA #$60
STA zp2B
LDA #$A4
STA zp3B
LDA #$01
STA zp29
JMP L_FA12
;
S_F284 LDY zp32+1
S_F286 LDA $0002,Y
PHA
BPL B_F2A0
AND #$78
STA zp1D
TYA
ASL A
ADC #$08
STA zp20
LDA #$00
STA zp20+1
TYA
CLC
ADC #$03
STA zp27+1
B_F2A0 LDY #$00
STY zp27
PLA
RTS
;$F2A6 --------
L_F2A6 LDA #$5A
STA zp3C
B_F2AA JSR L_F560
B_F2AD BIT zp01
BPL B_F2AD
BIT V_4000
LDA V_4001
CMP #$52 ; "R"
BNE B_F2FD
LDY #$00
STA V_0111,Y
INY
B_F2C1 BIT zp01
BPL B_F2C1
BIT V_4000
LDA V_4001
STA V_0111,Y
INY
CPY #$08
BNE B_F2C1
JSR S_F388
LDY #$04
LDA #$00
B_F2DA EOR $0018,Y
DEY
BPL B_F2DA
CMP #$00
BNE B_F314
LDA zp1A
STA zp29
LDA zp1D
CMP #$30
BEQ B_F306
LDA zp14
CMP zp18
BNE B_F311
LDA zp15
CMP zp19
BNE B_F311
JMP L_F319
;
B_F2FD DEC zp3C
BNE B_F2AA
LDA #$02
JSR L_FA12
B_F306 LDA zp18
STA zp14
LDA zp19
STA zp15
L_F30E LDA #$01
DB $2C
B_F311 LDA #$0B
DB $2C
B_F314 LDA #$09
JMP L_FA12
;
L_F319 LDA #$7F
STA zp3D
LDA zp1B
CLC
ADC #$02
CMP zp57
BCC B_F328
SBC zp57
B_F328 STA zp3E
LDX #$05
STX zp32+1
LDX #$FF
B_F330 JSR S_F284
BPL B_F374
STA zp38
AND #$01
CMP zp31
BNE B_F374
LDY #$00
LDA (zp20),Y
CMP zp56
BNE B_F374
LDY #$01
SEC
LDA (zp20),Y
SBC zp3E
BPL B_F351
CLC
ADC zp57
B_F351 CMP zp3D
BCS B_F374
PHA
LDA zp1D
BEQ B_F36F
PLA
CMP #$09
BCC B_F374
CMP #$0C
BCS B_F374
B_F363 STA zp3D
LDA zp32+1
TAX
CLC
ADC #$03
STA zp27+1
BNE B_F374
B_F36F PLA
CMP #$06
BCC B_F363
B_F374 DEC zp32+1
BPL B_F330
TXA
BPL B_F37E
JMP L_FA41
;
B_F37E STX zp32+1
JSR S_F284
LDA zp1D
JMP L_F3FC
;
S_F388 LDA zp27
PHA
LDA zp27+1
PHA
LDA #$11
STA zp27
LDA #$01
STA zp27+1
LDA #$00
STA zp2D
JSR S_F928
LDA zp44
STA zp1A
LDA zp43
STA zp1B
LDA zp42
STA zp1C
JSR S_F928
LDA zp41
STA zp19
LDA zp42
STA zp18
PLA
STA zp27+1
PLA
STA zp27
RTS
;$F3BB --------
S_F3BB LDA zp27+1
STA zp1E+1
LDA #$01
STA zp27+1
LDA #$11
STA zp2D
LDA #$08
STA zp41
LDA zp1C
STA zp42
LDA zp1B
STA zp43
LDA zp1A
STA zp44
JSR S_F80C
LDA zp19
STA zp41
LDA zp18
STA zp42
LDA #$00
STA zp43
STA zp44
JSR S_F80C
LDA zp1E+1
STA zp27+1
RTS
;$F3F0 --------
S_F3F0 LDA #$00
STA V_026C
BEQ B_F3F9
;
; Set LED flag
;
L_F3F7 LDA #$E0
; Set LED flag to accu
B_F3F9 STA zp76 ; drive LED flag for IRQ routine
RTS
;$F3FC --------
L_F3FC CMP #$00
BEQ B_F403
JMP L_F57D
;
B_F403 JSR S_F513
B_F406 BIT zp01
BPL B_F406
LDA V_4001
STA zpFA
AND #$F8
TAX
LDA V_F70C,X
STA zpF9
LDA zpFA
AND #$07
STA zpFA
B_F41D BIT zp01
BPL B_F41D
LDA V_4001
STA zpFB
AND #$C0
ORA zpFA
TAX
LDA V_F70C,X
ORA zpF9
PHA
BNE B_F464
BEQ B_F464
B_F435 BIT zp01
BPL B_F435
LDA V_4001
STA zpFA
AND #$F8
TAX
LDA V_F70C,X
STA zpF9
LDA zpFA
AND #$07
STA zpFA
B_F44C BIT zp01
BPL B_F44C
LDA V_4001
STA zpFB
AND #$C0
ORA zpFA
TAX
LDA V_F70C,X
ORA zpF9
STA (zp27),Y
INY
BEQ B_F4D9
B_F464 LDA zpFB
AND #$3E
TAX
LDA V_F70C,X
STA zpF9
LDA zpFB
AND #$01
STA zpFB
B_F474 BIT zp01
BPL B_F474
LDA V_4001
STA zpFC
AND #$F0
ORA zpFB
TAX
LDA V_F70C + 2,X
ORA zpF9
STA (zp27),Y
INY
LDA zpFC
AND #$0F
STA zpFC
B_F490 BIT zp01
BPL B_F490
LDA V_4001
STA zpFD
AND #$80
ORA zpFC
TAX
LDA V_F71C,X
STA zpF9
LDA zpFD
AND #$7C
TAX
LDA V_F70C + 1,X
ORA zpF9
STA (zp27),Y
INY
LDA zpFD
AND #$03
STA zpFD
B_F4B6 BIT zp01
BPL B_F4B6
LDA V_4001
STA zpFA
AND #$E0
ORA zpFD
TAX
LDA V_F729,X
STA zpF9
LDA zpFA
AND #$1F
TAX
LDA V_F6FF,X
ORA zpF9
STA (zp27),Y
INY
JMP B_F435
;
B_F4D9 LDA zpFB
AND #$3E
TAX
LDA V_F70C,X
STA zpF9
LDA zpFB
AND #$01
STA zpFB
B_F4E9 BIT zp01
BPL B_F4E9
LDA V_4001
AND #$F0
ORA zpFB
TAX
LDA V_F70C + 2,X
ORA zpF9
STA zpFA
PLA
CMP #$07
BNE B_F50B
JSR S_F60A
CMP zpFA
BEQ B_F50E
LDA #$05
DB $2C
B_F50B LDA #$04
DB $2C
B_F50E LDA #$01
JMP L_FA12
;
S_F513 JSR S_F519
JMP L_F560
;
S_F519 LDA zp14
STA zp18
LDA zp15
STA zp19
LDY #$00
LDA (zp20),Y
STA zp1A
INY
LDA (zp20),Y
STA zp1B
LDA #$00
EOR zp18
EOR zp19
EOR zp1A
EOR zp1B
STA zp1C
JSR S_F3BB
LDA #$5A
STA zp3C
B_F53F JSR L_F560
B_F542 LDA V_0111,Y
B_F545 BIT zp01
BPL B_F545
CMP V_4001
BNE B_F554
INY
CPY #$08
BNE B_F542
RTS
;$F554 --------
B_F554 DEC zp3C
BNE B_F53F
LDA #$02
DB $2C
L_F55B LDA #$03
JMP L_FA12
;
L_F560 LDY #$12
B_F562 LDX #$FF
B_F564 LDA V_4002
AND #$40
BEQ B_F574
DEX
BNE B_F564
DEY
BNE B_F562
JMP L_F55B
;
B_F574 LDA V_4001
BIT V_4000
LDY #$00
RTS
;$F57D --------
L_F57D CMP #$10
BEQ B_F584
JMP L_F6BA
;
B_F584 JSR S_F60A
LDA zp01
AND #$10
BNE B_F592
LDA #$08
JMP L_FA12
;
B_F592 JSR S_F8CD + 2
JSR S_F519
LDY #$09
B_F59A BIT zp01
BPL B_F59A
BIT V_4000
DEY
BNE B_F59A
LDA #$FF
STA V_4004
LDA V_4002
AND #$EF
STA V_4002
LDA #$FF
LDY #$05
STA V_4001
BIT V_4000
B_F5BB BIT zp01
BPL B_F5BB
BIT V_4000
DEY
BNE B_F5BB
LDY #$BB
B_F5C7 LDA $0060,Y
B_F5CA BIT zp01
BPL B_F5CA
BIT V_4000
STA V_4001
INY
BNE B_F5C7
B_F5D7 LDA (zp27),Y
B_F5D9 BIT zp01
BPL B_F5D9
BIT V_4000
STA V_4001
INY
BNE B_F5D7
B_F5E6 BIT zp01
BPL B_F5E6
BIT V_4000
LDA V_4002
ORA #$10
STA V_4002
LDA #$00
STA V_4004
JSR S_F618
LDY zp32+1
LDA $0002,Y
EOR #$30
STA $0002,Y
JMP L_F2A6
;
S_F60A LDY #$00
STY zp30
B_F60E LDA (zp27),Y
EOR zp30
STA zp30
INY
BNE B_F60E
RTS
;$F618 --------
S_F618 LDA #$60
STA zp27
LDA zp27+1
STA zp36
LDA #$00
STA zp27+1
STA zp37
LDA #$BB
STA zp2D
STA zp2E
JSR S_F928
LDA zp41
STA zp2F
LDY zp2E
LDA zp42
STA $0060,Y
INY
LDA zp43
STA $0060,Y
INY
LDA zp44
STA $0060,Y
INY
STY zp2E
B_F649 JSR S_F928
LDY zp2E
LDA zp41
STA $0060,Y
INY
LDA zp42
STA $0060,Y
INY
BEQ B_F66C
LDA zp43
STA $0060,Y
INY
LDA zp44
STA $0060,Y
INY
STY zp2E
BNE B_F649
B_F66C LDA zp43
STA (zp27),Y
INY
LDA zp44
STA (zp27),Y
INY
STY zp2E
B_F678 JSR S_F928
LDY zp2E
LDA zp41
STA (zp27),Y
INY
LDA zp42
STA (zp27),Y
INY
LDA zp43
STA (zp27),Y
INY
LDA zp44
STA (zp27),Y
INY
STY zp2E
CPY #$BB
BCC B_F678
LDA #$45 ; "E"
STA zp1E
LDA zp27+1
STA zp1E+1
LDY #$BA
B_F6A1 LDA (zp27),Y
STA (zp1E),Y
DEY
BNE B_F6A1
LDA (zp27),Y
STA (zp1E),Y
LDX #$BB
B_F6AE LDA V_011B,Y
STA (zp27),Y
INY
INX
BNE B_F6AE
STX zp3F
RTS
;$F6BA --------
L_F6BA CMP #$20
BEQ B_F6C1
JMP L_F6F9
;
B_F6C1 JSR S_F60A
JSR S_F8CD + 2
JSR S_F513
LDY #$BB
B_F6CC LDA $0060,Y
B_F6CF BIT zp01 ; wait for byte-ready
BPL B_F6CF
BIT V_4000 ; reset byte-ready signal
EOR V_4001 ; read and ...
BNE B_F6F4 ; ... verify with buffer contents
INY
BNE B_F6CC
B_F6DE LDA (zp27),Y
B_F6E0 BIT zp01 ; wait for byte-ready
BPL B_F6E0
BIT V_4000 ; reset byte-ready signal
EOR V_4001 ; read and ...
BNE B_F6F4 ; ... verify with buffer contents
INY
CPY #$FD ; repeat $FC (252) times
BNE B_F6DE
JMP L_F30E
;
B_F6F4 LDA #$07
JMP L_FA12
;
L_F6F9 JSR S_F519
JMP L_F30E
;
; $F6FF
V_F6FF DB $FF
V_F700 DB $FF,$FF
; $F702
DB $FF,$FF,$FF
; $F705
DB $FF,$FF,$FF
PHP
BRK
ORA (zpFF,X)
; $F70C
V_F70C DB "L"-64
V_F70D DB "D"-64
V_F70E DB "E"-64
; $F70F
DB $FF,$FF,"B"-64
; $F712
DB "C"-64,$FF
; $F714
DB "O"-64,"F"-64,"G"-64
; $F717
DB $FF,"I"-64,"J"-64
; $F71A
DB "K"-64,$FF
V_F71C ORA V_800E
; $F71F
DB $FF,$00,$00
BPL B_F761 + 3
; $F724
DB $FF,$20,$C0
RTS
;$F728 --------
RTI
;$F729 --------
V_F729 LDY #$50 ; "P"
CPX #$FF
; $F72D
DB $FF,$FF,$02
JSR S_3008
; $F733
DB $FF,$FF,$00
B_F736 BEQ B_F736 + 1
RTS
;$F739 --------
B_F739 ORA (zp70,X)
; $F73B
DB $FF,$FF,$FF
BCC B_F742 + 1
LDY #$0C
B_F742 BCS B_F742 + 1
; $F744
DB $FF,$04,$D0
; $F747
B_F747 DB $FF,$E0,$05
; $F74A
DB $80,$FF
B_F74C BCC B_F74C + 1
PHP
; $F74F
DB "L"-64,$FF,"O"-64
ORA #$0D
; $F754
DB $80,$02
; $F756
DB $FF,$FF,$FF
; $F759
DB $03,$FF
; $F75B
DB $FF,$00,$FF
; $F75E
DB $FF,$0F,$FF
; $F761
B_F761 DB $0F,$FF,$FF
B_F763 + 1 BPL B_F76B + 1
; $F766
DB $FF,$FF,$FF
; $F769
DB $07,$00
B_F76B JSR S_FF9F + 1 ; *** Self mod. indirect jump!
; $F76E
DB $FF,$06,$FF
ORA #$FF
; $F773
DB $FF,$C0,$0A
; $F776
DB $FF,$FF,$FF
; $F779
DB $0B,$FF
; $F77B
B_F77B DB $FF,$40,$FF
; $F77E
DB $FF,$07,$FF
ORA $FFFF ;
BVC B_F793 + 1
; $F786
DB $FF,$FF,$FF
; $F789
DB $FF,$10,$30
B_F78C BCS B_F78C + 1
BRK
; $F78F
DB "D"-64,"B"-64
ASL zp0A
B_F793 ASL $FF7E + 2 ;
; $F796
B_F796 DB $FF,$FF,$FF
; $F799
DB $FF,$FF,$FF
JSR S_08FF ;
ORA #$80
BPL B_F763
BVC B_F7D4 + 1
BMI B_F797
BVS B_F739
BCS B_F77B
; $F7AB
DB $FF,$FF,$FF
BRK
ASL A
; $F7B0
DB $FF,$FF,$FF
; $F7B3
DB $FF,$F0,$FF
; $F7B6
DB $FF,$FF,$FF
; $F7B9
DB $FF,$FF,$FF
RTS
;$F7BD --------
; $F7BD
DB $FF,"A"-64,"K"-64
; $F7C0
DB $FF,$FF,$FF
; $F7C3
DB $FF,$70,$FF
; $F7C6
DB $FF,$FF,$FF
; $F7C9
DB $FF,$C0,$F0
B_F7CC BNE B_F7CC + 1
ORA (zp05,X)
; $F7D0
DB "C"-64,"G"-64
; $F7D2
DB "K"-64,$FF
B_F7D4 BCC B_F7D4 + 1
; $F7D6
DB $FF,$FF,$FF
; $F7D9
DB $FF,$FF,$FF
LDY #$FF
; $F7DE
DB "L"-64,"M"-64,$FF
; $F7E1
DB $FF,$FF,$FF
B_F7E4 BCS B_F7E4 + 1
; $F7E6
DB $FF,$FF,$FF
; $F7E9
DB $FF,$40,$60
CPX #$FF
; $F7EE
DB "D"-64,"N"-64
; $F7F0
DB $FF,$FF,$FF
; $F7F3
DB $FF,$D0,$FF
; $F7F6
DB $FF,$FF,$FF
; $F7F9
DB $FF,$FF,$FF
CPX #$FF
ORA zpFF
; $F800
V_F800 DB $FF,$FF,$FF
; $F803
DB $FF,$FF,$FF
; $F806
DB $FF,$FF,$FF
; $F809
DB $FF,"Pp"
;
; Convert 4 binary bytes to 5 GCR bytes
;
S_F80C LDA #$00
STA zp45+1
STA zp49
LDY zp2D
LDA zp41
AND #$F0 ; isolate hi-nibble
LSR A
LSR A
LSR A
LSR A ; and rotate to lower nibble
TAX ; use as index in table
LDA V_F8BF,X
ASL A
ASL A
ASL A ; times 8
STA zp45
LDA zp41
AND #$0F ; isolate lower nibble
TAX ; as index in table
LDA V_F8BF,X
ROR A
ROR zp45+1
ROR A
ROR zp45+1
AND #$07
ORA zp45
STA (zp27),Y ; in buffer
INY ; increment buffer
LDA zp42
AND #$F0 ; isolate upper nibble
LSR A
LSR A
LSR A
LSR A ; shift to upper nibble
TAX ; as index in table
LDA V_F8BF,X
ASL A
ORA zp45+1
STA zp45+1
LDA zp42
AND #$0F ; lower nibble
TAX ; as index
LDA V_F8BF,X
ROL A
ROL A
ROL A
ROL A
STA zp47
ROL A
AND #$01
ORA zp45+1
STA (zp27),Y ; in buffer
INY ; increment buffer
LDA zp43
AND #$F0 ; isolate hi-nibble
LSR A
LSR A
LSR A
LSR A
TAX
LDA V_F8BF,X
CLC
ROR A
ORA zp47
STA (zp27),Y ; in buffer
INY ; increment buffer pointer
ROR A
AND #$80
STA zp48
LDA zp43
AND #$0F ; lower nibble
TAX ; as index
LDA V_F8BF,X
ASL A
ASL A
AND #$7C
ORA zp48
STA zp48
LDA zp44
AND #$F0 ; isolate hi-nibble
LSR A
LSR A
LSR A
LSR A ; shift to lower nibble
TAX ; as index in table
LDA V_F8BF,X
ROR A
ROR zp49
ROR A
ROR zp49
ROR A
ROR zp49
AND #$03
ORA zp48
STA (zp27),Y ; in buffer
INY ; increment buffer pointer
BNE B_F8AF
LDA zp1E+1
STA zp27+1
LDA #$00
STA zp27
B_F8AF LDA zp44
AND #$0F ; lower nibble
TAX ; as index
LDA V_F8BF,X
ORA zp49
STA (zp27),Y ; in buffer
INY ; increment buffer pointer
STY zp2D ; and save
RTS
;$F8BF -------- GCR (5-bit) nybble table
V_F8BF DB $0A,$0B,$12,$13,$0E,$0F,$16,$17
DB $09,$19,$1A,$1B,$0D,$1D,$1E,$15
;
; Convert 260 bytes to 325 bytes group code
;
LDA #$00
STA zp1E
STA zp2E
LDA #$60
STA zp27
LDA #$BB
STA zp2D
STA zp3F
LDA zp27+1
STA zp1E+1
LDA #$00
STA zp27+1
LDA #$07
STA zp41
LDY zp2E
LDA (zp1E),Y
STA zp42
INY
LDA (zp1E),Y
STA zp43
INY
LDA (zp1E),Y
STA zp44
INY
B_F8FC STY zp2E
JSR S_F80C
LDY zp2E
LDA (zp1E),Y
STA zp41
INY
BEQ B_F91B
LDA (zp1E),Y
STA zp42
INY
LDA (zp1E),Y
STA zp43
INY
LDA (zp1E),Y
STA zp44
INY
BNE B_F8FC
B_F91B LDA zp30
STA zp42
LDA #$00
STA zp43
STA zp44
JMP S_F80C
;
; Convert 5 GCR bytes to 4 binary bytes
;
S_F928 LDY zp2D
LDA (zp27),Y
TAX
AND #$F8
STA zp45
TXA
AND #$07
STA zp45+1
INY
BNE B_F93F
LDA zp36
STA zp27+1
LDY zp37
B_F93F LDA (zp27),Y
TAX
AND #$C0
ORA zp45+1
STA zp45+1
TXA
AND #$3E
STA zp47
TXA
AND #$01
STA zp48
INY
LDA (zp27),Y
TAX
AND #$F0
ORA zp48
STA zp48
TXA
AND #$0F
STA zp49
INY
LDA (zp27),Y
TAX
AND #$80
ORA zp49
STA zp49
TXA
AND #$7C
STA zp49+1
TXA
AND #$03
STA zp4B
INY
BNE B_F980
LDA zp36
STA zp27+1
LDY zp37
STY zp27
B_F980 LDA (zp27),Y
TAX
AND #$E0
ORA zp4B
STA zp4B
TXA
AND #$1F
STA zp4C
INY
STY zp2D
LDX zp45
LDA V_F70C,X
LDX zp45+1
ORA V_F70C,X
STA zp41
LDX zp47
LDA V_F70C,X
LDX zp48
ORA V_F70E,X
STA zp42
LDX zp49
LDA V_F71C,X
LDX zp49+1
ORA V_F70D,X
STA zp43
LDX zp4B
LDA V_F729,X
LDX zp4C
ORA V_F6FF,X
STA zp44
RTS
;$F9C2 --------
LDA #$00
STA zp2D
STA zp1E
STA zp2E
LDA #$01
STA zp36
LDA #$1B
STA zp37
LDA zp27+1
STA zp1E+1
JSR S_F928
LDA zp41
STA zp2F
LDY zp2E
LDA zp42
STA (zp1E),Y
INY
LDA zp43
STA (zp1E),Y
INY
LDA zp44
STA (zp1E),Y
INY
B_F9EE STY zp2E
JSR S_F928
LDY zp2E
LDA zp41
STA (zp1E),Y
INY
BEQ B_FA0D
LDA zp42
STA (zp1E),Y
INY
LDA zp43
STA (zp1E),Y
INY
LDA zp44
STA (zp1E),Y
INY
BNE B_F9EE
B_FA0D LDA zp1E+1
STA zp27+1
RTS
;$FA12 --------
L_FA12 LDY zp32+1
STA $0002,Y
LDA zp3F
BEQ B_FA1E
JSR S_F618
B_FA1E JSR S_FA36
LDX zp3A
TXS
JMP L_F19D
;
S_FA27 LDA #$A0
STA zp2B
LDA zp01
ORA #$04
STA zp01
LDA #$A7
STA zp39
RTS
;$FA36 --------
S_FA36 LDA zp2B
ORA #$10
STA zp2B
LDA #$FF
STA zp39
RTS
;$FA41 --------
L_FA41 LDA zp01 ;
AND #$10 ; set write mode
CMP zp24 ; check previous mode, changed?
STA zp24 ;
BNE B_FA51 ; changed...
LDA zpFE
BNE B_FA61
BEQ B_FA71
B_FA51 LDA #$FF
STA zpFE
LDA zp01
ORA #$04 ; set drive motor on
STA zp01
LDA #$01
STA zp22
BNE B_FA71
B_FA61 DEC zpFE
BNE B_FA71
LDA zp2B
CMP #$00
BNE B_FA71
LDA zp01
AND #$FB
STA zp01
B_FA71 LDA zp54
BEQ B_FA88
CMP #$02
BNE B_FA7F
LDA #$00
STA zp54
BEQ B_FA88
B_FA7F STA zp3B
LDA #$02
STA zp54
JMP L_FAC5
;
B_FA88 LDX zp31
BMI B_FA93
LDA zp2B
TAY
CMP #$20
BNE B_FA96
B_FA93 JMP L_FB00
;
B_FA96 DEC zp39
BNE B_FAB5
TYA
BPL B_FAA1
AND #$7F
STA zp2B
B_FAA1 AND #$10
BEQ B_FAB5
LDA zp01
AND #$FB
STA zp01
LDA #$FF
STA zp31
LDA #$00
STA zp2B
BEQ B_FA93
B_FAB5 TYA
AND #$40
BNE B_FABD
JMP L_FB00
;
B_FABD LDA zp4D
BNE B_FADC
LDA zp3B
BEQ B_FAD3
L_FAC5 LDA zp3B
BPL B_FAED
INC zp3B
LDA zp01
SEC
SBC #$01
JMP L_FAF4
;
B_FAD3 LDA #$02
STA zp39
STA zp4D
JMP L_FB00
;
B_FADC DEC zp39
BNE L_FB00
LDA zp2B
AND #$BF
STA zp2B
LDA #$00
STA zp4D
JMP L_FB00
;
B_FAED DEC zp3B
LDA zp01
CLC
ADC #$01
L_FAF4 AND #$03
STA zp3C ; note drive head control state
LDA zp01
AND #$FC
ORA zp3C
STA zp01 ; step motor
L_FB00 PLA
TAY
PLA
TAX
PLA
RTI ; return from interrupt
;$FB06 --------
S_FB06 LDA #$05
STA V_0100
B_FB0B LDX #$1C
JSR $FD87 ; write $1c * 256 GCR gap bytes
LDX #$14 ; counter for repeat, exactly half of the 1541...
LDY #$00 ; .. due to 2x CPU clock frequency
LDA #$FF
STA V_4001 ; $FF to write head
B_FB19 BIT zp01 ; wait for byte-ready
BPL B_FB19
BIT V_4000 ; delete byte-ready signal
DEY
BNE B_FB19
DEX
BNE B_FB19 ; repeat 10240 / 2 times (1541 has X = #$28 !)
JSR $FD79
LDY #$FF
B_FB2B LDX #$FF
B_FB2D LDA V_4002
AND #$40
BEQ B_FB44
DEX
BNE B_FB2D
DEY
BNE B_FB2B
B_FB3A DEC V_0100
BNE B_FB0B
LDA #$02
JMP $FD6F
;
B_FB44 LDY #$00
LDX #$00
B_FB48 LDA V_4002
AND #$40 ; check SYNC
BEQ B_FB48 ; not encountered yet?
B_FB4F LDA V_4002 ; read SYNC
INY
BNE B_FB56 ; Y not zero yet?
INX
B_FB56 AND #$40 ; check SYNC
BNE B_FB4F ; no SYNC found, back
STX V_0102 ; found SYNC, note X and Y count
STY V_0101
LDA #$00
STA zpFF
LDX #$08
B_FB66 LDA V_F129,X
CMP V_0102
BEQ B_FB73
DEX
BPL B_FB66
BMI B_FB3A
B_FB73 LDA V_F131 + 1,X
STA V_0103
RTS
;$FB7A --------
L_FB7A LDA zp40
BPL B_FB99
LDA #$60
STA zp2B
LDA #$01
STA zp29
STA zp40
LDA #$A4
STA zp3B
LDA zp01
AND #$FC ; drive motor off
STA zp01
LDA #$0A
STA zp51
JMP L_FA41
;
B_FB99 LDY #$00
LDA (zp20),Y
CMP zp40
BEQ B_FBA8
LDA zp40
STA (zp20),Y
JMP L_FA41
;
B_FBA8 LDA zp01
AND #$10 ; check write protect sensor
BNE B_FBB3 ; not protected...
LDA #$08
JMP $FD68
;
B_FBB3 LDA zpFF
BPL B_FBBA
JSR S_FB06
B_FBBA LDA V_0103
STA zp4E
CLC
LDA #$03
STA zp20+1
LDA #$00
STA zp20
STA zp53
LDY #$00
B_FBCC LDA #$08
STA (zp20),Y
INY
LDA #$00
STA (zp20),Y
INY
LDA zp53
STA (zp20),Y
INY
LDA zp40
STA (zp20),Y
INY
LDA zp15
STA (zp20),Y
INY
LDA zp14
STA (zp20),Y
INY
LDA #$0F
STA (zp20),Y
INY
STA (zp20),Y
INY
TYA
PHA
LDX #$07
LDA #$00
STA zp30
B_FBFA DEY
LDA (zp20),Y
EOR zp30
STA zp30
DEX
BNE B_FBFA
STA (zp20),Y
PLA
TAY
INC zp53
LDA zp53
CMP zp57
BCC B_FBCC
JSR $FDA9
LDY #$BA
B_FC15 LDA (zp20),Y
LDX #$45 ; "E"
STX zp20
STA (zp20),Y
LDX #$00
STX zp20
DEY
CPY #$FF
BNE B_FC15
LDY #$44 ; "D"
B_FC28 LDA V_011B,Y
STA (zp20),Y
DEY
BPL B_FC28
CLC
LDA #$03
ADC #$02
STA zp27+1
LDA #$00
TAY
B_FC3A STA (zp27),Y
INY
BNE B_FC3A
JSR S_F60A
JSR S_F8CD + 2
LDA #$00
STA zp4E+1
LDX #$03
JSR $FD87 ; write 3 * 256 GCR gap bytes
L_FC4E LDA #$FF
STA V_4001 ; $FF to write head
LDY #$05 ; write 5 pieces of $FF (sync) bytes
B_FC55 BIT zp01 ; wait on byte-ready
BPL B_FC55
BIT V_4000 ; clear byte-ready signal
DEY
BNE B_FC55 ; repeat
LDA #$0A
STA zp50
LDY zp4E+1
B_FC65 BIT zp01 ; wait on byte-ready
BPL B_FC65
BIT V_4000 ; clear byte-ready signal
LDA (zp20),Y
STA V_4001
INY
DEC zp50 ; repeat 10 times
BNE B_FC65
LDY #$09
B_FC78 BIT zp01 ; wait on byte-ready
BPL B_FC78
BIT V_4000 ; clear byte-ready signal
LDA #$55 ; GCR code for inter-sector gap
STA V_4001 ; write to disk
DEY
BNE B_FC78 ; repeat this 9 times
LDA #$FF
LDY #$05
B_FC8B BIT zp01 ; wait on byte-ready
BPL B_FC8B
BIT V_4000 ; clear byte-ready signal
STA V_4001 ; write 5 sync bytes to disk
DEY
BNE B_FC8B
LDY #$BB
B_FC9A BIT zp01
BPL B_FC9A ; wait on byte-ready
BIT V_4000 ; clear byte-ready signal
LDA $0060,Y
STA V_4001 ; write buffer contents to disk
INY
BNE B_FC9A ; repeat $BB (187) times
B_FCAA BIT zp01
BPL B_FCAA ; wait on byte-ready
BIT V_4000 ; clear byte-ready signal
LDA (zp27),Y
STA V_4001 ; write buffer contents to disk
INY
BNE B_FCAA
LDA #$55 ; GAP
LDY zp4E
B_FCBD BIT zp01
BPL B_FCBD ; wait on byte-ready
BIT V_4000 ; clear byte-ready signal
STA V_4001 ; write GCR GAP
DEY
BNE B_FCBD
LDA zp4E+1
CLC
ADC #$0A ; add 10 (interleave)
STA zp4E+1
DEC zp53
BEQ B_FCD8
JMP L_FC4E
;
B_FCD8 BIT zp01 ; wait on byte-ready
BPL B_FCD8
BIT V_4000 ; clear byte-ready signal
B_FCDF BIT zp01
BPL B_FCDF ; wait on byte-ready
BIT V_4000 ; clear byte-ready signal
JSR $FD79
LDA #$C8
STA zp52
B_FCED LDA #$00
STA zp4E+1
LDA zp57
STA zp53
B_FCF5 LDA #$0A
STA zp50
JSR L_F560
LDY zp4E+1
B_FCFE LDA (zp20),Y
B_FD00 BIT zp01 ; wait on byte-ready
BPL B_FD00
BIT V_4000 ; clear byte-ready signal
CMP V_4001 ; verify
BNE $FD1B
INY
DEC zp50
BNE B_FCFE
CLC
LDA zp4E+1
ADC #$0A
STA zp4E+1
JMP $FD24
;
$FD1B DEC zp52
BNE B_FCED
LDA #$06
JMP $FD68
;
$FD24 JSR L_F560
LDY #$BB
$FD29 LDA $0060,Y
$FD2C BIT zp01 ; wait on byte-ready
BPL $FD2C
BIT V_4000 ; clear byte-ready signal
CMP V_4001 ; verify what's read
BNE $FD1B
INY
BNE $FD29
$FD3B LDA (zp27),Y
$FD3D BIT zp01 ; wait on byte-ready
BPL $FD3D
BIT V_4000 ; clear byte-ready signal
CMP V_4001 ; verify
BNE $FD1B
INY
BNE $FD3B
DEC zp53
BNE B_FCF5
INC zp40
LDA zp40
CMP #$24
BCS $FD5B
JMP L_FA41
;
$FD5B LDA #$FF
STA zp40
LDA #$00
STA zp3F
LDA #$01
JMP L_FA12
;
$FD68 DEC zp51
BEQ $FD6F
JMP L_FA41
;
$FD6F LDY #$FF
STY zp40
INY
STY zp3F
JMP L_FA12
;
; Initialise read mode
;
$FD79 LDA V_4002
ORA #$10
STA V_4002 ; set head to read mode
LDA #$00 ; TIA port B to input
STA V_4004
RTS
;$FD87 -------- Write GCR gap bytes ($55) to - erase - current track
$FD87 LDA V_4002
AND #$EF
STA V_4002 ; set head to write mode
LDA #$FF
STA V_4004 ; TIA port B to output
LDA #$55 ; GCR gap byte
STA V_4001 ; write...
LDY #$00
$FD9B BIT zp01 ; wait on byte-ready
BPL $FD9B
BIT V_4000 ; clear byte-ready signal
DEY
BNE $FD9B
DEX
BNE $FD9B ; repeat this 256 * X times
RTS
;$FDA9 -------- Convert header in buffer 0 to GCR code
$FDA9 LDA #$00
STA zp27+1
STA zp1E
STA zp2E
LDA #$BB
STA zp2D
LDA #$60
STA zp27
CLC
LDA #$03
STA zp1E+1 ; source buffer is at $1E/$1F
$FDBE LDY zp2E
LDA (zp1E),Y ; read 4 normal bytes to $41,$42,$43,$44
STA zp41
INY
LDA (zp1E),Y
STA zp42
INY
LDA (zp1E),Y
STA zp43
INY
LDA (zp1E),Y
STA zp44
INY
BEQ $FDDE
STY zp2E
JSR S_F80C
JMP $FDBE
;
$FDDE JMP S_F80C
;
STA (zpFF,X)
; $FDE3
DB $FF,$FF,$FF
; $FDE6
DB $FF,$FF,$FF
; $FDE9
DB $FF,$FF,$FF
; $FDEC
DB $FF,$FF,$FF
; $FDEF
DB $FF,$FF,$FF
; $FDF2
DB $FF,$FF,$FF
; $FDF5
DB $FF,$FF,$FF
; $FDF8
DB $FF,$FF,$FF
; $FDFB
DB $FF,$FF,$FF
; $FDFE
DB $FF,$FF
V_FE00 DB $FF
; $FE01
DB $FF,$FF,$FF
; $FE04
DB $FF,$FF,$FF
; $FE07
DB $FF,$FF,$FF
; $FE0A
DB $FF,$FF,$FF
; $FE0D
DB $FF,$FF,$FF
; $FE10
DB $FF,$FF,$FF
; $FE13
DB $FF,$FF,$FF
; $FE16
DB $FF,$FF,$FF
; $FE19
DB $FF,$FF,$FF
; $FE1C
DB $FF,$FF,$FF
; $FE1F
DB $FF,$FF,$FF
; $FE22
DB $FF,$FF,$FF
; $FE25
DB $FF,$FF,$FF
; $FE28
DB $FF,$FF,$FF
; $FE2B
DB $FF,$FF,$FF
; $FE2E
DB $FF,$FF,$FF
; $FE31
DB $FF,$FF,$FF
; $FE34
DB $FF,$FF,$FF
; $FE37
DB $FF,$FF,$FF
; $FE3A
DB $FF,$FF,$FF
; $FE3D
DB $FF,$FF,$FF
; $FE40
DB $FF,$FF,$FF
; $FE43
DB $FF,$FF,$FF
; $FE46
DB $FF,$FF,$FF
; $FE49
DB $FF,$FF,$FF
; $FE4C
DB $FF,$FF,$FF
; $FE4F
DB $FF,$FF,$FF
; $FE52
DB $FF,$FF,$FF
; $FE55
DB $FF,$FF,$FF
; $FE58
DB $FF,$FF,$FF
; $FE5B
DB $FF,$FF,$FF
; $FE5E
DB $FF,$FF,$FF
; $FE61
DB $FF,$FF,$FF
; $FE64
DB $FF,$FF,$FF
; $FE67
DB $FF,$FF,$FF
; $FE6A
DB $FF,$FF,$FF
; $FE6D
DB $FF,$FF,$FF
; $FE70
DB $FF,$FF,$FF
; $FE73
DB $FF,$FF,$FF
; $FE76
DB $FF,$FF,$FF
; $FE79
DB $FF,$FF,$FF
; $FE7C
DB $FF,$FF,$FF
; $FE7F
DB $FF,$FF,$FF
; $FE82
DB $FF,$FF,$FF
; $FE85
DB $FF,$FF,$FF
; $FE88
DB $FF,$FF,$FF
; $FE8B
DB $FF,$FF,$FF
; $FE8E
DB $FF,$FF,$FF
; $FE91
DB $FF,$FF,$FF
; $FE94
DB $FF,$FF,$FF
; $FE97
DB $FF,$FF,$FF
; $FE9A
DB $FF,$FF,$FF
; $FE9D
DB $FF,$FF,$FF
; $FEA0
DB $FF,$FF,$FF
; $FEA3
DB $FF,$FF,$FF
; $FEA6
DB $FF,$FF,$FF
; $FEA9
DB $FF,$FF,$FF
; $FEAC
DB $FF,$FF,$FF
; $FEAF
DB $FF,$FF,$FF
; $FEB2
DB $FF,$FF,$FF
; $FEB5
DB $FF,$FF,$FF
; $FEB8
DB $FF,$FF,$FF
; $FEBB
DB $FF,$FF,$FF
; $FEBE
DB $FF,$FF,$FF
; $FEC1
DB $FF,$FF,$FF
; $FEC4
DB $FF,$FF,$FF
; $FEC7
DB $FF,$FF,$FF
; $FECA
DB $FF,$FF,$FF
; $FECD
DB $FF,$FF,$FF
; $FED0
DB $FF,$FF,$FF
; $FED3
DB $FF,$FF,$FF
; $FED6
DB $FF,$FF,$FF
; $FED9
DB $FF,$FF,$FF
; $FEDC
DB $FF,$FF,$FF
; $FEDF
DB $FF,$FF,$FF
; $FEE2
DB $FF,$FF,$FF
; $FEE5
DB $FF,$FF,$FF
; $FEE8
DB $FF,$FF,$FF
; $FEEB
DB $FF,$FF,$FF
; $FEEE
DB $FF,$FF,$FF
; $FEF1
DB $FF,$FF,$FF
; $FEF4
DB $FF,$FF,$FF
; $FEF7
DB $FF,$FF,$FF
; $FEFA
DB $FF,$FF,$FF
; $FEFD
DB $FF,$FF,$FF
; $FF00
V_FF00 DB $FF,$FF,$FF
; $FF03
DB $FF,$FF,$FF
; $FF06
DB $FF,$FF,$FF
; $FF09
DB $FF,$FF,$FF
; $FF0C
DB $FF,$FF,$FF
; $FF0F
DB $FF,$FF,$FF
; $FF12
DB $FF,$FF,$FF
; $FF15
DB $FF,$FF,$FF
; $FF18
DB $FF,$FF,$FF
; $FF1B
DB $FF,$FF,$FF
; $FF1E
DB $FF,$FF,$FF
; $FF21
DB $FF,$FF,$FF
; $FF24
DB $FF,$FF,$FF
; $FF27
DB $FF,$FF,$FF
; $FF2A
DB $FF,$FF,$FF
; $FF2D
DB $FF,$FF,$FF
; $FF30
DB $FF,$FF,$FF
; $FF33
DB $FF,$FF,$FF
; $FF36
DB $FF,$FF,$FF
; $FF39
DB $FF,$FF,$FF
; $FF3C
DB $FF,$FF,$FF
; $FF3F
DB $FF,$FF,$FF
; $FF42
DB $FF,$FF,$FF
; $FF45
DB $FF,$FF,$FF
; $FF48
DB $FF,$FF,$FF
; $FF4B
DB $FF,$FF,$FF
; $FF4E
DB $FF,$FF,$FF
; $FF51
DB $FF,$FF,$FF
; $FF54
DB $FF,$FF,$FF
; $FF57
DB $FF,$FF,$FF
; $FF5A
DB $FF,$FF,$FF
; $FF5D
DB $FF,$FF,$FF
; $FF60
DB $FF,$FF,$FF
; $FF63
DB $FF,$FF,$FF
; $FF66
DB $FF,$FF,$FF
; $FF69
DB $FF,$FF,$FF
; $FF6C
DB $FF,$FF,$FF
; $FF6F
DB $FF,$FF,$FF
; $FF72
DB $FF,$FF,$FF
; $FF75
DB $FF,$FF,$FF
; $FF78
DB $FF,$FF,$FF
; $FF7B
DB $FF,$FF,$FF
; $FF7E
DB $FF,$FF,$FF
; $FF81
DB $FF,$FF,$FF
; $FF84
DB $FF,$FF,$FF
; $FF87
DB $FF,$FF,$FF
; $FF8A
DB $FF,$FF,$FF
; $FF8D
DB $FF,$FF,$FF
; $FF90
DB $FF,$FF,$FF
; $FF93
DB $FF,$FF,$FF
; $FF96
DB $FF,$FF,$FF
; $FF99
DB $FF,$FF,$FF
; $FF9C
DB $FF,$FF,$FF
; $FF9F
S_FF9F DB $FF,$FF,$FF
; $FFA2
DB $FF,$FF,$FF
; $FFA5
DB $FF,$FF,$FF
; $FFA8
DB $FF,$FF,$FF
; $FFAB
DB $FF,$FF,$FF
; $FFAE
DB $FF,$FF,$FF
; $FFB1
DB $FF,$FF,$FF
; $FFB4
DB $FF,$FF,$FF
; $FFB7
DB $FF,$FF,$FF
; $FFBA
DB $FF,$FF,$FF
; $FFBD
DB $FF,$FF,$FF
; $FFC0
DB $FF,$FF,$FF
; $FFC3
DB $FF,$FF,$FF
; $FFC6
DB $FF,$FF,$FF
; $FFC9
DB $FF,$FF,$FF
; $FFCC
DB $FF,$FF,$FF
; $FFCF
DB $FF,$FF,$FF
; $FFD2
DB $FF,$FF,$FF
; $FFD5
DB $FF,$FF,$FF
; $FFD8
DB $FF,$FF,$FF
; $FFDB
DB $FF,$FF,$FF
; $FFDE
DB $FF,$FF,$FF
; $FFE1
DB $FF,$FF,$FF
; $FFE4
DB $FF,$FF,$A7,$C9,$3B,$F1,$51,$CE,$8B,$CE,$00,$05
DB $03,$05,$06,$05,$09,$05,$0C,$05,$0F,$05,$39,$EA,$B5,$E9,$95,$F1
; EOF
Letzte Änderung: 2019-01-02 21:40:05
