;***********************************************************************;
;*        P c D F S  : PC DISK FILING SYSTEM VOOR BBC BASIC            *;
;*---------------------------------------------------------------------*;
;*    doel           : Disk Filing System MOS EXT ROM voor             *;
;*                     disk I/O op Atom-in-PC BBC Basic                *;
;*---------------------------------------------------------------------*;
;*    filenaam       : pcdfs.asm                                       *;
;*    auteur         : Roland Leurs                                    *;
;*                     The Atomic Development Studio                   *;
;*    ontwikkeld     : juli 1996                                       *;
;*    laatste update : maart 1998                                      *;
;*---------------------------------------------------------------------*;
;*    assembleren    : x6502 pcdfs                                     *;
;*---------------------------------------------------------------------*;
;*    oproep         : automatisch na BREAK                            *;
;***********************************************************************;
                .list on
                org $A000-16

pcheader        .dw     pcheader+16, init
                .dw     0,0,0,0,0,0

                include definiti.inc

;***********************************************************************
;* Initialisatie van PcDFS MOS EXT ROM                                 *
;***********************************************************************

init            .db $BE                 ; herkenningsbyte $BE
                jmp mosextinit          ; entry: spring naar initialisatie
                jmp mosextmsg           ; entry: spring naar message
                .db $2A,<clitab,>clitab ; entry: command line interpreter
                .db $00,$00,$00         ; entry: osbyte uitbreiding
                .db $00,$00,$00         ; entry: osword uitbreiding

mosextinit      ldx #13                 ; laadt index
init_l2         lda fs_tab,x            ; laadt byte uit vector tabel
                sta $212,x              ; schrijf vector
                dex                     ; verlaag index
                bpl init_l2             ; spring indien nog bytes volgen
                lda #0                  ; reset opt
                sta option
close_all       tay                     ; sluit alle open files
                jsr osfind
                rts                     ; that's all folks

fs_tab          .dw osfilev, osargsv, osbgetv, osbputv
                .dw osgbpbv, osfindv, osfscv

mosextmsg       jsr print               ; druk volgende tekst af
                .db "PcDFS 1.01"
                .db 13,10,10,$EA
                rts                     ; einde routine

version         .db "1.00",0            ; versie string


clitab          .db "CAT"       , >cat,         <cat
                .db "CD"        , >cdir,        <cdir
                .db "CHDIR"     , >cdir,        <cdir
                .db "LOAD"      , >load,        <load
                .db "SAVE"      , >save,        <save
                .db "RUN"       , >run,         <run
                .db "/"         , >run,         <run
                .db "OPT"       , >opt,         <opt
                .db "SPOOL"     , >spool,       <spool
                .db "EXEC"      , >exec,        <exec
                .db "ATOM"      , >atom,        <atom
                .db "LIB"       , >lib,         <lib
                .db "PC"        , >msdos,       <msdos
                .db "RESET"     , >reset,       <reset
                .db "TV"        , >tv,          <tv
                .db "MD"        , >mdir,        <mdir
                .db "MKDIR"     , >mdir,        <mdir
                .db "RD"        , >rdir,        <rdir
                .db "RMDIR"     , >rdir,        <rdir
                .db "LOCK"      , >lock,        <lock
                .db "UNLOCK"    , >unlock,      <unlock
                .db "HIDE"      , >hide,        <hide
                .db "UNHIDE"    , >unhide,      <unhide
                .db "DRIVE"     , >drive,       <drive
                .db "DELETE"    , >delete,      <delete
                .db "FIND"      , >find,        <find
                .db "INFO"      , >info,        <info
                .db "COPY"      , >shell,       <shell
                .db "COMMAND"   , >shell,       <shell
                .db "DIR"       , >shell,       <shell
                .db "XCOPY"     , >shell,       <shell
                .db "ERASE"     , >shell,       <shell
                .db "FORMAT"    , >shell,       <shell
                .db "LABEL"     , >shell,       <shell
                .db "RENAME"    , >shell,       <shell
                .db "VOL"       , >shell,       <shell
                .db "DISKCOPY"  , >shell,       <shell
                .dw $FFFF

************************************************************************
;* Diverse hulproutines                                                *
;***********************************************************************

; zet semafoor voor pc communicatie
zetsem          pha                     ; save accu
                lda #$1B                ; laadt osbyte code
zetsem1         jsr osbyte
                bcc zetsem1             ; blijf dit doen totdat toegang vrij
                pla                     ; herstel accu
                rts                     ; einde routine

wissem          php                     ; save processor status
                pha                     ; save accu
                lda #$1A                ; reset semafoor
                jsr osbyte              ; einde routine
                pla                     ; herstel accu
                plp                     ; herstel status
                rts                     ; einde routine

commando        pha                     ; save commando nummer
                lda #0                  ; stuur $00 byte
                jsr oszendbyte          ; naar pc
                pla                     ; haal commando nummer weer op
                jmp oszendbyte          ; stuur naar pc

; skip spaties in command line buffer
skipspace0      iny                     ; verhoog command line pointer
skipspace1      lda clbuffer,y          ; lees karakter
                cmp #' '                ; test op spatie
                beq skipspace0          ; volgende lezen bij spatie
                rts                     ; anders einde routine

savepar         sta par_a               ; zet parameters in call werkruimte
                stx par_x
                sty par_y
                rts

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

adres           lda #0                  ; clear adres
                sta zp
                sta zp+1
                jsr skipspace1          ; zet pointer naar volgend karakter
adres1          lda clbuffer,y          ; lees karakter uit opdrachtregel
                cmp #$0D                ; test op einde getal
                beq adres3
                cmp #' '
                beq adres3
                jsr ascii2nibble        ; bepaal hex waarde
                pha                     ; save getal
                ldx #3                  ; laadt teller
adres2          asl zp                  ; schuif adres 4 maal links
                rol zp+1
                dex                     ; verlaag teller
                bpl adres2
                pla                     ; haal getal terug
                ora zp                  ; voeg toe aan adres
                sta zp
                iny                     ; verhoog index
                bne adres1              ; volgende digit verwerken
adres3          lda zp                  ; test of adres gegeven is
                ora zp+1                ; via Z-flag (1=geen adres)
                rts

clearparblk     ldx #$11                ; laadt teller
                lda #0                  ; laadt waarde
clear1          sta cfsbuffer,x         ; clear byte
                dex                     ; verlaag teller
                bpl clear1              ; spring indien nog adressen volgen
                lda #$FF                ; byte 6 moet $FF zijn ivm *load
                sta cfsbuffer+6
                rts                     ; einde routine

fnaam2cfsbuf    ldx #0                  ; reset pointer
fnaam1          lda clbuffer,y          ; lees karakter van command line
                cmp #$0D                ; test op einde regel
                beq fnaamerror          ; spring indien geen naam gegeven
                cmp #' '                ; test op spatie
                bne fnaam2              ; spring indien een normaal teken
                iny                     ; verhoog index
                bne fnaam1
fnaam2          cmp #'"'                ; test op aanhalingstekens
                beq cfsbuf3             ; spring bij naam tussen quotes
                bne cfsbuf1             ; springt zonder quotes
fnaamerror      jmp err_name            ; genereer naam error
cfsbuf1         lda clbuffer,y          ; lees naam uit command line
                cmp #' '                ; test op einde van naam
                beq cfsbuf2             ; spring bij einde dmv spatie
                cmp #$0D
                beq cfsbuf2             ; spring bij einde regel
                sta cfsbuffer+30,x      ; zet teken in cfsbuffer
                inx                     ; verhoog pointers
                iny
                bne cfsbuf1             ; spring altijd
cfsbuf2         lda #$0D                ; sluit string af
                sta cfsbuffer+30,x
                cpx #0                  ; is lengte van filenaam 0?
                beq fnaamerror          ; dan is dat niet juist...
                lda #<(cfsbuffer+30)    ; zet adres van filenaam in par.blok
                sta cfsbuffer
                lda #>(cfsbuffer+30)
                sta cfsbuffer+1
                rts                     ; einde routine
cfsbuf3         iny                     ; verhoog index
cfsbuf4         lda clbuffer,y          ; lees karakter uit command line
                cmp #$0D                ; test op einde regel
                beq fnaamerror          ; niet netjes afgesloten
                cmp #'"'                ; test op quote
                bne cfsbuf5             ; spring indien geen "
                iny                     ; verhoog index
                lda clbuffer,y          ; lees volgend teken
                cmp #'"'                ; nogmaals een "
                bne cfsbuf2             ; spring bij einde naam
cfsbuf5         sta cfsbuffer+30,x      ; zet teken in cfsbuffer
                inx                     ; verhoog pointers
                iny
                bne cfsbuf4             ; spingt altijd
                
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
                jmp wissem              ; einde routine

************************************************************************
;* Commando's                                                          *
;***********************************************************************

cat             ldy #>clbuffer          ; laadt high byte cli; x=lb
                lda #5                  ; laadt osfsc call nummer
                jmp osfscv              ; voer call uit

opt             jsr skipspace0          ; lees teken
                and #$0F                ;
                tax                     ; zet option nummer in x
                jsr skipspace0          ; lees komma
                cmp #','
                bne opt_err             ; spring indien geen komma
                jsr skipspace0          ; lees optie
                and #$0F
                tay                     ; zet option waarde in y
                lda #$8B                ; zet optie via osfsc 0
                jmp osbyte              ; einde routine
opt_err         jmp err_badcom          ; syntax of optie fout

load            jsr clearparblk         ; clear parameter block in cfsbuffer
                jsr fnaam2cfsbuf        ; zet filenaam en adres in par.block
                jsr adres               ; test of er een adres gegeven is
                beq load1               ; spring als geen adres gegeven is
                lda zp                  ; zet adres in parameter block
                sta cfsbuffer+$2
                lda zp+1
                sta cfsbuffer+$3
                lda #0                  ; geef aan dat adres gegeven is
                sta cfsbuffer+$6
load1           lda #$FF                ; laadt parameters voor load functie
load_it         pha                     ; save accu
                jsr skipspace1          ; test op einde regel
                cmp #$0D
                bne save_err            ; syntax error als niet einde regel
                pla                     ; herstel accu
                ldx #<cfsbuffer
                ldy #>cfsbuffer
                jmp osfile              ; laadt de file en einde routine

save_err        jmp err_syntax          ; geef syntax error

save            jsr clearparblk         ; clear parameter block in cfsbuffer
                jsr fnaam2cfsbuf        ; zet filenaam en adres in par.block
                jsr adres               ; lees begin adres van datablok
                beq save_err            ; spring indien geen adres gegeven
                lda zp                  ; zet adres als load adres
                sta cfsbuffer+$2
                sta cfsbuffer+$6
                sta cfsbuffer+$A
                lda zp+1
                sta cfsbuffer+$3
                sta cfsbuffer+$7
                sta cfsbuffer+$B
                jsr adres               ; lees eind adres van datablok
                beq save_err
                lda zp                  ; zet adres als eindadres
                sta cfsbuffer+$E
                lda zp+1
                sta cfsbuffer+$F
                jsr adres               ; kijk of er een exec adres is
                beq save_it             ; spring indien geen exec adres
                lda zp                  ; zet adres als execadres
                sta cfsbuffer+$6
                lda zp+1
                sta cfsbuffer+$7
save_it         lda #0                  ; laadt functienummer voor osfile
                beq load_it             ; voer functie uit en einde commando

run             jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                ldx cfsbuffer           ; laadt adres van filenaam
                ldy cfsbuffer+1
                lda #4
                jmp osfsc               ; doe dat via osfsc routine

spool           lda spoolhandle         ; test of spoolfile al open is
                beq splopen             ; spring indien niet open
                tay                     ; handle naar y register
                lda #0                  ; sluit de spoolfile
                sta spoolhandle
                jmp osfind

splopen         jsr fnaam2cfsbuf        ; zet filenaam in buffer
                ldx cfsbuffer           ; laadt adres
                ldy cfsbuffer+1
                lda #$80                ; file openen voor schrijven
                jsr osfind              ; open de file
                sta spoolhandle         ; zet handle
                rts                     ; einde routine

exec            jsr fnaam2cfsbuf        ; zet filenaam in buffer
                ldx cfsbuffer           ; laadt adres
                ldy cfsbuffer+1
                lda #$40                ; file openen voor lezen
                jsr osfind              ; open de file
                sta exechandle          ; zet handle
                rts                     ; einde routine

atom            lda schaduwbyte         ; zet write protect uit
                and #$BF
                sta systemlatch
                sta $1FFD               ; disable bbc mosrom
                jsr zetsem              ; wacht op pc communicatie
                lda #$5B                ; genereer reset
                jsr commando
                lda #$5D
                jmp oszendbyte          ; exit bbc omgeving . . .

lib             ldx #0                  ; reset pointer
                jsr skipspace1          ; lees teken van command line
                cmp #$0D                ; test op lege parameter
                beq lib2                ; spring indien leeg.
lib1            jsr skipspace1          ; lees teken van command line
                sta library,x           ; zet in library path
                inx                     ; verhoog pointer
                iny
                cmp #$0D                ; test op einde string
                bne lib1                ; spring als nog tekens volgen
                rts
lib2            lda library,x           ; lees teken van library path
                jsr oswrch              ; druk af
                inx                     ; verhoog index
                cmp #$0D                ; test op einde string
                bne lib2                ; spring indien nog tekens volgen
                jmp osnewl              ; einde routine

reset           jsr zetsem              ; zet semafoor
                lda #$5B                ; zet reset type #2 (soft reset)
                jsr commando
                lda #$5C
                jsr oszendbyte
                lda #2
                jsr oszendbyte
                lda #$5B                ; geef reset commando aan pc
                jsr commando
                lda #$5D
                jmp oszendbyte          ; en krijg een reset

cdir            jsr skipspace1          ; lees eerste teken <> spatie
                sta cfsbuffer+30
                cmp #$0D                ; test op lege string
                beq cdir1               ; spring indien leeg
                jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
cdir1           jsr zetsem              ; zet semafoor
                lda #$0E                ; geef chdir command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq cdir2
                jmp msdoserror
cdir2           jsr leesbyte            ; test of er nog tekst volgt
                beq cdir6               ; spring als er geen tekst meer volgt
                jsr leesbyte            ; lees drive code
                clc                     ; maak er een letter van
                adc #'@'  
                ldy #$00                ; reset pointer
                sta cfsbuffer,y         ; zet drive letter in string buffer
                iny                     ; verhoog pointer
                lda #':'                ; idem voor :\
                sta cfsbuffer,y
                iny
                lda #'\'  
                sta cfsbuffer,y
                iny
cdir3           jsr leesbyte            ; lees teken van actuele directory
                beq cdir4
                sta cfsbuffer,y
                iny
                jmp cdir3
cdir4           lda #$0D                ; sluit string af
                sta cfsbuffer,y
                jsr wissem              ; wis semafoor
                ldy #$00
cdir5           lda cfsbuffer,y         ; druk directory af
                iny
                jsr oswrch
                cmp #$0D
                bne cdir5
cdir6           jsr wissem              ; wis semafoor
                jmp osnewl              ; geef cr/lf en einde routine

rdir            jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$0F                ; geef rmdir command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq rdir2               ; spring indien geen foutmelding
                jmp msdoserror
rdir2           jsr leesbyte            ; read dummy
                jmp wissem              ; einde routine

mdir            jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$10                ; geef mkdir command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq rdir2               ; spring indien geen foutmelding
                jmp msdoserror

delete          tya                     ; save pointer naar filespec
                pha
                jsr fnaam2cfsbuf        ; zet filespec in cfsbuffer
                lda option              ; lees optie
                cmp #2                  ; vragen om bevestiging?
                bne delete0             ; nee, dan meteen alles wegpleuren
                jsr inforegel
                jsr print               ; Stel de vraag
                .db "Delete files ?",$EA
                jsr osrdch              ; lees antwoord
                pha                     ; even opslaan
                jsr oswrch              ; druk antwoord af
                jsr osnewl              ; cursor naar volgende regel
                pla
                cmp #'Y'                ; bevestigend antwoord?
                beq delete0             ; nee, dan niets doen
                pla                     ; haal pointer van stack
                jmp delete1             ; spring naar einde routine
delete0         pla                     ; herlaadt pointer in commandline
                tay
                jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$11                ; geef delete command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq delete1
                jmp msdoserror
delete1         jmp wissem

lock            jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$12                ; geef lock command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq comend
                jmp msdoserror

unlock          jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$13                ; geef unlock command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq comend
                jmp error

hide            jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$16                ; geef hide command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq comend
file_err        jmp msdoserror

unhide          jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
                jsr zetsem              ; zet semafoor
                lda #$17                ; geef unhide command aan pc
                jsr commando
                lda #<(cfsbuffer+30)    ; zet adres van cfsbuffer in zp
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1           ; geef directory aan pc
                jsr leesbyte            ; lees resultaat
                beq comend
                jmp msdoserror

comend          jsr wissem              ; reset semafoor
                lda option              ; laadt option byte
                cmp #2                  ; file info laten zien?
                bne comend1             ; nee, dan springen
                jsr inforegel           ; laat file info zien
comend1         rts                     ; einde commando

drive           lda clbuffer,y          ; lees eerste teken niet zijnde spatie
                cmp #' '
                bne drive2
                iny
                bne drive
drive1          lda #15                 ; genereer foutmelding
                jmp msdoserror
drive2          pha                     ; save accu
                pha
                jsr zetsem              ; zet semafoor
                lda #$0E                ; geef chdir commando om te testen
                jsr commando            ;   of drive bestaat
                pla                     ; haal accu terug
                jsr zendbyte            ; stuur naar pc
                lda #':'                ; stuur : naar pc
                jsr zendbyte
                lda #0                  ; sluit string af
                jsr zendbyte
                jsr leesbyte            ; lees resultaat
                bne drive1
drive3          jsr leesbyte            ; lees rest van directory
                bne drive3              ; maar doe er niets mee
                pla                     ; herstel nieuwe driveletter
                cmp #'A'                ; test op geldige letter
                bmi drive1
                cmp #'Z'+1
                bpl drive1
                pha
                lda #$14                ; geef commando aan pc
                jsr commando
                sec                     ; zet carry voor aftrekken
                pla
                sbc #'A'
                jsr zendbyte
drive4          jmp wissem              ; semafoor resetten en einde routine

msdos           lda clbuffer,y          ; lees eerste karakter <> spatie
                iny
                cmp #' '  
                beq msdos
                cmp #$0D
                beq exit
                dey
                tya     
                tax
                jmp shell+2             ; voer shell commando uit
exit            jsr print               ; druk melding af
                .db "BBC Basic is shutting down ... ",$EA
                jsr zetsem              ; zet semafoor
                lda #$15                ; sluit terminal programma af
                jsr commando            ; en exit
                jsr wissem              ; reset semafoor
tv              rts                     ; BBC Basic werkt gewoon door

shell           ldx #$00                ; reset pointer
                lda #59
                jsr commando            ; geef shell commando
shell1          lda clbuffer,x
                cmp #$0D
                beq shell2              ; lees karakter
                jsr zendbyte
                inx
                bne shell1              ; als niet $0D dan naar pc sturen
shell2          lda #$00
                jsr zendbyte
                jmp wissem

find            jsr skipspace1          ; lees eerste teken <> spatie
                sta cfsbuffer+30
                cmp #$0D                ; test op lege string
                beq find1               ; spring indien leeg
                jsr fnaam2cfsbuf        ; zet filenaam in cfsbuffer
find1           ldx #<(cfsbuffer+30)    ; laadt adres van filenaam
                ldy #>(cfsbuffer+30)
                lda cfsbuffer+30        ; test op lege string
                cmp #$0D
                beq fnext               ; spring naar findnext
                lda #$10                ; laadt functiecode voor findfirst
                bne ffirst              ; spring altijd
fnext           lda #$20                ; laadt functiecode voor findnext
ffirst          jsr osfind              ; voer functie uit
info_end        rts                     ; einde routine

info            jsr fnaam2cfsbuf        ; lees filespec
                jsr print               ; druk onderstaande regel af
                .db "Filename      Load Exec Length   Attrib",$0D,$0A,$EA
		lda #'='		; laadt "onderlijnteken"
                ldx #39                 ; laadt teller
info0   	jsr oswrch		; druk teken af
                dex                     ; verlaag teller
		bne info0
		jsr osnewl		; cursor naar volgende regel
inforegel       ldx #-1                 ; reset pointer
info1           inx                     ; verhoog pointer
                lda cfsbuffer+30,x      ; zoek einde van filespec
                cmp #$0D
                bne info1
info2           dex                     ; zoek einde van pad aanduiding
                lda cfsbuffer+30,x
                cmp #'\'                ; dus een backslash
                beq info3
                cmp #':'
                beq info3               ; of een dubbele punt
                cpx #0                  ; of zelfs geen pad
                bne info2               ; of zelfs geen pad
                dex
info3           inx                     ; zet pointer achter het pad
                stx comwork             ; berg pointer naar einde pad op
		lda #$10		; voer findfirst uit
                ldx #<(cfsbuffer+30)    ; laadt adres van filespec
                ldy #>(cfsbuffer+30)
info4           jsr osfind
		lda cfsbuffer		; test of file gevonden is
		bne info_end		; spring indien geen file gevonden
                lda cfsbuffer+1         ; laadt attribuut
                and #$18                ; volume en directories overslaan
                beq info4a
                jmp info13
info4a          sta count               ; reset regelteller
                ldy #$0A                ; zet index naar filenaam in DTA
                ldx comwork             ; zet pointer naar einde van pad
info5           lda cfsbuffer,y         ; lees karakter van filenaam
                sta cfsbuffer+30,x      ; zet als filenaam
		cmp #$0D		; test op einde van naam
                beq info6               ; spring bij einde naam
		jsr oswrch		; zet letter op scherm
                inc count               ; verhoog regelteller
                inx                     ; verhoog pointer
                iny                     ; verhoog index
                bne info5               ; spring altijd
info6           lda #' '                ; vul aan tot 15 spaties
                jsr oswrch              ; druk spatie af
                inc count               ; verhoog teller
                lda count               ; laadt teller
                cmp #14                 ; 14 posities verder?
                bne info6

info7           jsr zetsem              ; zet semafoor
                lda #$18                ; opvragen file info
                jsr commando
                lda #<(cfsbuffer+30)    ; stuur filenaam naar pc
                sta zp
                lda #>(cfsbuffer+30)
                sta zp+1
                jsr filenaam1
                jsr leesbyte            ; lees resultaat
                beq info8
                jmp msdoserror
info8           ldx #0                  ; reset teller
info9           jsr leesbyte            ; lees file informatie
                sta header,x            ; zet in zeropage
                inx                     ; verhoog teller
                cpx #21                 ; 21 bytes lezen
                bne info9               ; spring indien niet alles gelezen
                lda h_addr+1            ; druk load adres af
                jsr prthex
                lda h_addr
                jsr prthex
                lda #' '                ; druk spatie af
                jsr oswrch
                lda h_exec+1            ; druk exec adres af
                jsr prthex
                lda h_exec
                jsr prthex
                lda #' '                ; druk spatie af
                jsr oswrch
                ldx #3                  ; druk lengte af
info10          lda h_len,x             ; lees byte
                jsr prthex              ; druk af
                dex                     ; verlaag teller
                bpl info10              ; spring indien nog bytes volgen
                lda #' '                ; print spatie
                jsr oswrch
                lsr header+$10          ; laadt attribuut
                bcc info11
                lda #'R'                ; read only
                jsr oswrch
info11          lsr header+$10
                bcc info12
                lda #'H'                ; hidden
                jsr oswrch
info12          jsr wissem              ; wis semafoor
                jsr osnewl              ; cursor naar volgende regel
info13          lda #$20                ; zoek volgende file
                jmp info4
                              

;************************************************************************
;* Overige service routines                                            *
;***********************************************************************

                include osfile.inc
                include osargs.inc
                include osfind.inc
                include osgbpb.inc
                include osfsc.inc
                include error.inc
