***********************************************************************;
;*        P c D F S  : PC DISK FILING SYSTEM VOOR DE ELECTRON          *;
;*---------------------------------------------------------------------*;
;*    doel           : Sidewayrom om via een verbinding met een pc een *;
;*                     disk systeem te creeren voor de Acorn Electron  *;
;*---------------------------------------------------------------------*;
;*    filenaam       : pcdfs.asm                                       *;
;*    auteur         : Roland Leurs                                    *;
;*                     The Atomic Development Studio                   *;
;*    ontwikkeld     : juli 1996                                       *;
;*    laatste update :                                                 *;
;*---------------------------------------------------------------------*;
;*    assembleren    : x6502 pcdfs                                     *;
;*---------------------------------------------------------------------*;
;*    oproep         : automatisch na BREAK                            *;
;***********************************************************************;

; declaratie werkruimte in zeropage
zp              equ $A0                 ; pcdfs routine werkruimte -  8 bytes
comwork         equ $A8                 ; command werkruimte       -  8 bytes
work            equ $B0                 ; pcdfs call werkruimte    -  16 bytes
par_a           equ $B0                 ;   A-register
par_x           equ $B1                 ;   X-register
par_y           equ $B2                 ;   Y-register
handle          equ $B3                 ;   msdos file handle
parm            equ $B1                 ;   adres parameterblock
comline         equ $B4                 ;   adres van commandline
option          equ $B6                 ; *OPT1 parameter
spoolhandle     equ $B7                 ; handle voor spoolfile
exechandle      equ $B8                 ; handle voor execfile
header          equ $C0                 ; pcdfs file header        -  16 bytes
h_addr          equ $C0                 ;   load address low word
h_exec          equ $C2                 ;   exec address low word
h_len           equ $C4                 ;   file length
h_addrx         equ $C8                 ;   load address high word
h_execx         equ $CA                 ;   exec address high word
h_free          equ $CC                 ;   reserved
library         equ $9C0                ; Library directory         - 63 bytes
cfsbuffer       equ $A00                ; CFS buffer               - 128 bytes

oswrch          equ $FFF4               ; write character       !! ATOM !!
osrdch          equ $FFE3               ; read character        !! ATOM !!
osnewl          equ $FFED               ; write newline         !! ATOM !!
osbyte          equ $FFF4               ; osbyte call

                org $2000

; Sidewayrom header

romheader       .db 0,0,0               ; (no) language entry
                jmp service             ; service entry
                .db $82                 ; rom type byte
                .db copyright-romheader ; pointer to copyright string
                .db 1                   ; binairy version number
                .db "PcDFS"             ; title string
                .db 0                   ; zero byte
version         .db "1.00"              ; version string
                .db 0                   ; zero byte
copyright       .db "(C) Atomic Development Studio"
                .db 0                   ; copyright string
                .dw 0,0                 ; relocation address

                include transfer.bus    ; communicatie module
                include service.inc
                include osfile.inc
                include osargs.inc
                include osfind.inc
                include osgbpb.inc
                include osfsc.inc
                include error.inc

; Algemene routines

print           pla                     ; haal retouradres van stack
                sta zp
                pla
                sta zp+1
                ldy #0                  ; reset index
print1          inc zp                  ; verhoog tekstpointer
                bne print2
                inc zp+1
print2          lda (zp),y              ; lees karakter
                bmi print3              ; spring indien einde van tekst
                jsr oswrch              ; druk teken af
                jmp print1              ; spring voor volgend teken
print3          jmp (zp)                ; einde routine
             
savepar         sta par_a               ; zet parameters in call werkruimte
                stx par_x
                sty par_y
                rts

commando        pha                     ; save commandonummer
                lda #$00                ; stuur commando naar pc
                jsr zendbyte
                pla                     ; haal commandonummer terug
                jmp zendbyte            ; stuur naar pc en einde routine

filenaam        ldy #1                  ; zet pointer
filenaam0       lda (parm),y            ; kopieer adres filenaam naar zp
                sta zp,y
                dey
                bpl filenaam0
filenaam1       ldy #0                  ; reset pointer
filenaam2       lda (zp),y              ; lees karakter
                cmp #$0D                ; test op einde string
                beq filenaam3           ; spring indien einde naam
                jsr zendbyte            ; stuur karakter naar pc
                iny
                bne filenaam2           ; spring voor volgend karakter
filenaam3       lda #$00                ; laadt code voor einde filenaam
                jmp zendbyte            ; stuur naar pc en einde routine

headerptr       lda #$43                ; zet pointer naar begin van bestand
                jsr commando
                lda handle              ; stuur file handle naar pc
                jsr zendbyte
                lda #0                  ; stuur pointer naar pc
                jsr zendbyte
                jsr zendbyte
                jsr zendbyte
                jsr zendbyte
                jsr zendbyte            ; stuur offset code naar pc
                ldy #5                  ; lees vijf resultaat bytes
headerptr1      jsr leesbyte            ; lees byte, doe er niets mee
                dey                     ; verlaag teller
                bne headerptr1          ; spring indien nog bytes volgen
                rts                     ; einde routine

loadheader      jsr headerptr           ; zet file pointer aan begin van header
                lda #$61                ; stuur commando: record lezen
                jsr commando
                lda #$00
                jsr zendbyte
                lda handle              ; stuur handle naar pc
                jsr zendbyte
                lda #16                 ; aantal te lezen bytes
                jsr zendbyte
                lda #00
                jsr zendbyte
                jsr leesbyte            ; lees resultaat
                bne headererror         ; spring indien iets fout gegaan is
                jsr leesbyte            ; lees aantal gelezen bytes (moet 16 zijn)
                tay                     ; zet lsb in teller ( =16 )
                jsr leesbyte 
                tax                     ; zet msb in pointer ( =0 )
loadhdr1        jsr leesbyte            ; lees data
                sta header,x            ; berg op in geheugen
                inx                     ; verhoog geheugen pointer
                dey                     ; verlaag teller
                bne loadhdr1            ; spring als er nog bytes volgen
                rts                     ; header is gelezen, einde routine

saveheader      jsr headerptr           ; zet file pointer aan begin van header
                lda #$61                ; stuur commando: record schrijven
                jsr commando
                lda #$01
                jsr zendbyte
                lda handle              ; stuur handle naar pc
                jsr zendbyte
                lda #16                 ; aantal te schrijven bytes
                jsr zendbyte
                lda #00
                jsr zendbyte
                tax                     ; reset pointer
savehdr1        lda header,x            ; lees header data uit geheugen
                jsr zendbyte            ; stuur naar pc
                inx                     ; verhoog geheugen pointer
                cpx #16                 ; alle bytes gehad?
                bne savehdr1            ; spring als er nog bytes volgen
                jsr leesbyte            ; lees error code
                bne headererror         ; spring bij fout
                jsr leesbyte            ; lees aantal naar disk geschreven bytes
                tax                     ; low byte naar x register
                jsr leesbyte
                cpx #16                 ; aantal gelezen bytes moet 16 zijn
                bne headerdiskfull      ; minder dan 16 bytes betekent disk vol
                rts                     ; header is geschreven, einde routine

headererror     jmp msdoserror          ; spring naar file i/o handler
headerdiskfull  jmp err_diskfull        ; spring naar file i/o handler

makeheader      lsr work+14             ; lees operatie type
                bcc rewrite1            ; spring als load address niet wijzigt
                ldy #2                  ; zet index
                lda (parm),y            ; kopieer load address naar header
                sta h_addr              
                iny
                lda (parm),y
                sta h_addr+1
                iny
                lda (parm),y
                sta h_addrx
                iny
                lda (parm),y
                sta h_addrx+1
rewrite1        lsr work+14             ; test op volgend operatie type
                bcc rewrite2            ; spring als exec address niet wijzigt
                ldy #6                  ; zet index
                lda (parm),y            ; kopieer exec address naar header
                sta h_exec
                iny
                lda (parm),y
                sta h_exec+1
                iny
                lda (parm),y
                sta h_execx
                iny
                lda (parm),y
                sta h_execx+1
rewrite2        rts                     ; einde routine

par2zp          ldy #12                 ; laadt pointer
par2zp1         lda (parm),y            ; lees parameter byte
                sta zp+3,y              ; zet in zeropage
                dey                     ; verlaag pointer
                bpl par2zp1             ; spring indien nog bytes volgen
                rts                     ; einde subroutine

zp2par          ldy #12                 ; laadt pointer
zp2par1         lda zp+3,y              ; lees byte uit zeropage
                sta (parm),y            ; zet in parameterblok
                dey                     ; verlaag pointer
                bpl zp2par1             ; spring indien nog bytes volgen
                rts

ascii2nibble    cmp #'0'                ; vergelijk met '0'
                bcc a2n_error           ; indien kleiner geen geldig digit
                cmp #'9'+1              ; vergelijk met '9+1'
                bcc a2n_l1              ; indien kleiner dan geldig digit
                and #$DF                ; maak hexadecimale digit
                sbc #$07
                bcc a2n_error           ; error als kleiner dan 'A'
                cmp #$40                ; test op 'F'
                bcs a2n_error           ; indien groter geen geldig digit
a2n_l1          sec                     ; zet carry voor aftrekken
                sbc #'0'                ; trek er ascii '0' af
                rts                     ; einde routine

a2n_error       jmp err_badhex          ; geneer foutmelding

msdoscall       lda #$22                ; commando: PC INT21h aanroep
                jsr commando
                ldx #0                  ; reset index
msdoscall1      lda zp,x                ; lees register waarde
                jsr zendbyte            ; stuur naar pc
                inx                     ; verhoog index
                cpx #8                  ; 8 bytes oversturen
                bne msdoscall1          ; spring voor volgend byte
                ldx #0                  ; reset index
msdoscall2      jsr leesbyte            ; lees resultaat registers
                sta zp,x                ; zet in zeropage
                inx                     ; verhoog index
                cpx #8                  ; 8 bytes lezen
                bne msdoscall2          ; spring voor volgend byte
                rts                     ; einde routine

