WebSVN – Kolibri OS – Diff – /kernel/branches/gfx_kernel/fs/fat12.inc

     jmp   reserve_flp
   reserve_flp_ok:
     push  eax
-    mov   eax,[0x3000]
+    mov   eax,[CURRENT_TASK]
     shl   eax,5
-    mov   eax,[eax+0x3000+TASKDATA.pid]
+    mov   eax,[eax+CURRENT_TASK+TASKDATA.pid]
     mov   [flp_status],eax
     pop   eax
     cmp    [FDC_Status],0
     jne    fdc_status_error_1
     mov    edi,edx
     dec    ebx
     shl    ebx,9
-    mov    esi,0x8000
+    mov    esi,FLOPPY_BUFF
     add    esi,ebx
     shl    ecx,9
     cld
     rep    movsb
     mov    eax,0 ; ok read
 l.20_1:
     call    ReadSectWithRetr
     cmp    [FDC_Status],0
     jne    fdc_status_error_3_1
     mov     dl,16
-    mov     edi,0xD000
+    mov     edi,FDD_BUFF
     inc     [FDD_Sector]
 l.21_1:
     mov    esi,eax            ;Name of file we want
     mov    ecx,11
     cld
 frfl7_1:
     dec    dword [esp+16]
 frfl8_1:
     mov    edi,[n_sector]
     shl    edi,1            ;find next cluster from FAT
-    add    edi,0x282000
+    add    edi,FLOPPY_FAT
     mov    eax,[edi]
     and    eax,4095
     mov    edi,eax
     mov    [n_sector],edi
     cmp    edi,4095         ;eof  - cluster
     cmp   [root_read],1
     je    unnecessary_root_read
     mov    [FDD_Track],0      ; Öèëèíäð
     mov    [FDD_Head],1      ; Ñòîðîíà
     mov    [FDD_Sector],2      ; Ñåêòîð
-    mov    edi,0x8000
+    mov    edi,FLOPPY_BUFF
     call   SeekTrack
 read_flp_root_1:
     call   ReadSectWithRetr
     cmp    [FDC_Status],0
     jne    unnecessary_root_read
     cmp   [flp_fat],1
     je    unnecessary_flp_fat
     mov    [FDD_Track],0      ; Öèëèíäð
     mov    [FDD_Head],0      ; Ñòîðîíà
     mov    [FDD_Sector],2      ; Ñåêòîð
-    mov    edi,0x8000
+    mov    edi,FLOPPY_BUFF
     call   SeekTrack
 read_flp_fat_1:
     call   ReadSectWithRetr
     cmp    [FDC_Status],0
     jne    unnecessary_flp_fat
     ret
 calculatefatchain_flp:
    pushad
-   mov  esi,0x8000
+   mov  esi,FLOPPY_BUFF
-   mov  edi,0x282000
+   mov  edi,FLOPPY_FAT
  fcnew_1:
    add  edi,4
    mov dword [edi],edx
    add  edi,4
    add  esi,12
-   cmp  edi,0x282000+2856*2   ;2849 clusters
+   cmp  edi,FLOPPY_FAT+2856*2   ;2849 clusters
    jnz  fcnew_1
     jne    fdc_status_error
     call   ReadSectWithRetr
     cmp    [FDC_Status],0
     jne    fdc_status_error
     mov    esi,flp_label
-    mov    edi,0xD000+39
+    mov    edi,FDD_BUFF+39
     mov    ecx,15
     cld
     rep    cmpsb
     je     same_label
     mov    [root_read],0
     mov    [flp_fat],0
 same_label:
-    mov    esi,0xD000+39
+    mov    esi,FDD_BUFF+39
     mov    edi,flp_label
     mov    ecx,15
     cld
     rep    movsb
     popad
     cmp   [root_read],0
     je    unnecessary_root_save
     mov    [FDD_Track],0      ; Öèëèíäð
     mov    [FDD_Head],1      ; Ñòîðîíà
     mov    [FDD_Sector],2      ; Ñåêòîð
-    mov    esi,0x8000
+    mov    esi,FLOPPY_BUFF
     call   SeekTrack
 save_flp_root_1:
     push   esi
     call   take_data_from_application_1
     pop    esi
     je    unnecessary_flp_fat_save
     call   restorefatchain_flp
     mov    [FDD_Track],0      ; Öèëèíäð
     mov    [FDD_Head],0      ; Ñòîðîíà
     mov    [FDD_Sector],2      ; Ñåêòîð
-    mov    esi,0x8000
+    mov    esi,FLOPPY_BUFF
     call   SeekTrack
 save_flp_fat_1:
     push   esi
     call   take_data_from_application_1
     pop    esi
 restorefatchain_flp:   ; restore fat chain
    pushad
-   mov  esi,0x282000
+   mov  esi,FLOPPY_FAT
-   mov  edi,0x8000
+   mov  edi,FLOPPY_BUFF
    add  edi,4
    mov word [edi],bx
    add  edi,2
    add  esi,8
-   cmp  edi,0x8000+0x1200     ;4274 bytes - all used FAT
+   cmp  edi,FLOPPY_BUFF+0x1200     ;4274 bytes - all used FAT
    jb   fcnew2_1
-   mov  esi,0x8000           ; duplicate fat chain
+   mov  esi,FLOPPY_BUFF           ; duplicate fat chain
-   mov  edi,0x8000+0x1200
+   mov  edi,FLOPPY_BUFF+0x1200
    mov  ecx,0x1200/4
    cld
 l.20_2:
     call    ReadSectWithRetr
     cmp    [FDC_Status],0
     jne    fdc_status_error_4
     mov     dl,16
-    mov     edi,0xD000
+    mov     edi,FDD_BUFF
     inc     [FDD_Sector]
 l.21_2:
     mov    esi,eax            ;Name of file we want
     mov    ecx,11
     cld
 fifoundd_2_1:
     mov    [edi-11],byte 0xE5    ;mark filename deleted
         movzx   edi, word [edi+0xf] ;edi = cluster
 frnewd_1:
     shl    edi,1            ;find next cluster from FAT
-    add    edi,0x282000
+    add    edi,FLOPPY_FAT
     mov    eax,[edi]
     mov    [edi],word 0x0        ;clear fat chain cluster
     and    eax,4095
     mov    edi,eax
     cmp    edi,dword 4095        ;last cluster ?
     pop    eax
     mov    [save_root_flag],1
     call   read_flp_root
     cmp    [FDC_Status],0
     jne    fdc_status_error_7
-    mov    edi,0x8000   ;Point at directory
+    mov    edi,FLOPPY_BUFF   ;Point at directory
     mov    edx,224 +1
     ; find an empty spot for filename in the root dir
 l20ds_1:
     sub    edx,1
     jz     frnoreadds_1
 l.20_3:
     call    ReadSectWithRetr
     cmp    [FDC_Status],0
     jne    fdc_status_error_7
     mov    dl,16
-    mov    edi,0xD000
+    mov    edi,FDD_BUFF
     inc     [FDD_Sector]
 l.21_3:
     mov    esi,eax            ;Name of file we want
     mov    ecx,11
     cld
 frnewds_2:
     add    ebx,1
     mov    edi,ebx            ; find free cluster in FAT
     shl    edi,1
-    add    edi,0x282000
+    add    edi,FLOPPY_FAT
     mov    eax,[edi]
     and    eax,4095
     jnz    frnewds_2
     mov    [edx],bx         ; save next cluster pos. to prev cl.
    popa
    cmp    [FDC_Status],0
    jne    not_found_file_analyze_flp
    mov ecx,512/32
-   mov ebx,0xD000
+   mov ebx,FDD_BUFF
 adr1_analyze_flp:
    mov esi,edx   ;[esp+16]
    add ebx,32
    loop adr1_analyze_flp
     mov eax,[clust_tmp_flp]
     shl    eax,1            ;find next cluster from FAT
-    add    eax,0x282000
+    add    eax,FLOPPY_FAT
     mov    eax,[eax]
     and    eax,4095
     cmp eax,0x0ff8
     jb  adr56_flp
    popa
    cmp    [FDC_Status],0
    jne    error_found_file_analyze1
    mov ecx,512/32
-   mov ebx,0xD000
+   mov ebx,FDD_BUFF
 adr1_analyze1:
    cmp byte [ebx],0x00
    add ebx,32
    loop adr1_analyze1
    mov eax,[clust_tmp_flp]
    shl    eax,1            ;find next cluster from FAT
-   add    eax,0x282000
+   add    eax,FLOPPY_FAT
    mov    eax,[eax]
    and    eax,4095
    cmp eax,0x0ff8
    mov [edi],word 0x0fff
    mov eax,[clust_tmp_flp]
    shl    eax,1            ;find next cluster from FAT
-   add    eax,0x282000
+   add    eax,FLOPPY_FAT
-   sub    edi,0x282000
+   sub    edi,FLOPPY_FAT
    mov    [eax],di
    pusha
    mov ecx,512/4
    xor eax,eax
-   mov edi,0xD000
+   mov edi,FDD_BUFF
    cld
    pusha
    call   save_chs_sector
    popa
    cmp    [FDC_Status],0
    jne    error_found_file_analyze1
-   mov    ebx,0xD000
+   mov    ebx,FDD_BUFF
 found_file_analyze1:
     mov    ebx,1
 check_new_flp:
     add    ebx,1
     mov    edi,ebx            ; find free cluster in FAT
     shl    edi,1
-    add    edi,0x282000
+    add    edi,FLOPPY_FAT
     mov    eax,[edi]
     and    eax,4095
     cmp    eax,0x0
     jnz    check_new_flp
         push    esi
         push    edi
         popa
         ret
+uglobal
+; this is for delete support
+fd_prev_sector          dd      ?
+fd_prev_prev_sector     dd      ?
+endg
 flp_root_next:
         cmp     edi, 0xD200-0x20
         jae     @f
         add     edi, 0x20
         ret     ; CF=0
 @@:
 ; read next sector
         inc     dword [eax]
         cmp     dword [eax], 14
+        jae     flp_root_first.readerr
+        push    [fd_prev_sector]
+        pop     [fd_prev_prev_sector]
+        push    eax
+        mov     eax, [eax]
+        add     eax, 19-1
+        mov     [fd_prev_sector], eax
-        jae     flp_root_first.readerr
+        pop     eax
 flp_root_first:
         mov     eax, [eax]
         pusha
         add     eax, 19
         call    read_chs_sector
         popa
         cmp     [FDC_Status], 0
         jnz     .readerr
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         ret     ; CF=0
 .readerr:
         stc
         ret
 flp_rootmem_first:
-        mov     edi, 0x8000
+        mov     edi, FLOPPY_BUFF
         clc
         ret
 flp_rootmem_next:
         add     edi, 0x20
-        cmp     edi, 0x8000+14*0x200
+        cmp     edi, FLOPPY_BUFF+14*0x200
         cmc
 flp_rootmem_next_write:
 flp_rootmem_begin_write:
         add     edi, 0x20
         ret     ; CF=0
 flp_notroot_next_sector:
         push    ecx
         mov     ecx, [eax]
+        push    [fd_prev_sector]
+        pop     [fd_prev_prev_sector]
+        add     ecx, 31
+        mov     [fd_prev_sector], ecx
-        mov     ecx, [ecx*2+0x282000]
+        mov     ecx, [(ecx-31)*2+FLOPPY_FAT]
         and     ecx, 0xFFF
         cmp     ecx, 2849
         jae     flp_notroot_first.err2
         mov     [eax], ecx
         pop     ecx
         jae     .err
         pusha
         add     eax, 31
         call    read_chs_sector
         popa
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         cmp     [FDC_Status], 0
         jnz     .err
         ret     ; CF=0
 .err2:
         pop     ecx
         jmp     flp_notroot_next_sector
 flp_notroot_extend_dir:
 ; find free cluster in FAT
         pusha
         xor     eax, eax
-        mov     edi, 0x282000
+        mov     edi, FLOPPY_FAT
         mov     ecx, 2849
         repnz   scasw
         jnz     .notfound
         mov     word [edi-2], 0xFFF     ; mark as last cluster
-        sub     edi, 0x282000
+        sub     edi, FLOPPY_FAT
         shr     edi, 1
         dec     edi
         mov     eax, [esp+28]
         mov     ecx, [eax]
-        mov     [0x282000+ecx*2], di
+        mov     [FLOPPY_FAT+ecx*2], di
         mov     [eax], edi
         xor     eax, eax
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         mov     ecx, 128
         rep     stosd
         popa
         call    flp_notroot_end_write
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         clc
         ret
 .notfound:
         popa
         stc
         pusha
         call    read_chs_sector
         popa
         cmp     [FDC_Status], 0
         jnz     .err
-        lea     eax, [0xD000+ebx+512]
+        lea     eax, [FDD_BUFF+ebx+512]
         neg     ebx
         push    ecx
         cmp     ecx, ebx
         jbe     @f
         mov     ecx, ebx
         add     edx, ecx
         sub     [esp], ecx
         pop     ecx
         xor     ebx, ebx
 .skip:
-        movzx   edi, word [edi*2+0x282000]
+        movzx   edi, word [edi*2+FLOPPY_FAT]
         jmp     .new
 .done:
         mov     ebx, edx
         pop     eax edx ecx edi
         sub     ebx, edx
         pusha
         call    read_chs_sector
         popa
         cmp     [FDC_Status], 0
         jnz     .error
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         push    eax
 .l1:
         call    fat_get_name
         jc      .l2
         cmp     byte [edi+11], 0xF
         inc     eax
         dec     byte [esp+262*2+12]
         jz      .done
         jns     @f
 ; read next sector from FAT
-        mov     eax, [(eax-31-1)*2+0x282000]
+        mov     eax, [(eax-31-1)*2+FLOPPY_FAT]
         and     eax, 0xFFF
         cmp     eax, 0xFF8
         jae     .done
         add     eax, 31
         mov     byte [esp+262*2+12], 0
         pusha
         call    read_chs_sector
         popa
         cmp     [FDC_Status], 0
         jnz     .error
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         push    eax
 .do_bdfe:
         inc     dword [edx+8]   ; new file found
         dec     ebx
         jns     .l2
         inc     eax
         dec     byte [esp+262*2+12]
         jz      .done
         jns     @f
 ; read next sector from FAT
-        mov     eax, [(eax-31-1)*2+0x282000]
+        mov     eax, [(eax-31-1)*2+FLOPPY_FAT]
         and     eax, 0xFFF
         cmp     eax, 0xFF8
         jae     .done
         add     eax, 31
         mov     byte [esp+262*2+12], 0
 fsfrfe:
         mov     eax, 11
         xor     ebx, ebx
         ret
+fs_FloppyCreateFolder:
+        mov     al, 1
+        jmp     fs_FloppyRewrite.common
+fs_FloppyRewrite:
+        xor     eax, eax
-fs_FloppyRewrite:
+.common:
         cmp     byte [esi], 0
         jz      @b
         call    read_flp_fat
         cmp     [FDC_Status], 0
         push    ebp
         push    flp_rootmem_first
         push    flp_rootmem_next
         jmp     .common1
 .noroot:
+        mov     eax, ERROR_ACCESS_DENIED
+        cmp     byte [ebp+1], 0
+        jz      .ret1
 ; check existence
         mov     byte [ebp], 0
         call    fd_find_lfn
         mov     byte [ebp], '/'
         lea     esi, [ebp+1]
         push    flp_notroot_first
         push    flp_notroot_next
 .common1:
         call    fat_find_lfn
         jc      .notfound
-; found; must not be directory
+; found
         test    byte [edi+11], 10h
+        jz      .exists_file
+; found directory; if we are creating directory, return OK,
+;                  if we are creating file, say "access denied"
+        add     esp, 28
+        popad
+        test    al, al
+        mov     eax, ERROR_ACCESS_DENIED
+        jz      @f
+        mov     al, 0
+@@:
+        xor     ebx, ebx
+        ret
+.exists_file:
+; found file; if we are creating directory, return "access denied",
+;             if we are creating file, delete existing file and continue
+        cmp     byte [esp+28+28], 0
         jz      @f
         add     esp, 28
         popad
         mov     eax, ERROR_ACCESS_DENIED
         xor     ebx, ebx
         test    eax, eax
         jz      .done1
 @@:
         cmp     eax, 0xFF8
         jae     .done1
-        lea     edi, [0x282000 + eax*2] ; position in FAT
+        lea     edi, [FLOPPY_FAT + eax*2] ; position in FAT
         xor     eax, eax
         xchg    ax, [edi]
         jmp     @b
 .done1:
         pop     edi
         mov     [edi+24], ax            ; last write date
         mov     [edi+18], ax            ; last access date
         and     word [edi+20], 0        ; high word of cluster
         and     word [edi+26], 0        ; low word of cluster - to be filled
         and     dword [edi+28], 0       ; file size - to be filled
+        cmp     byte [esp+28+28], 0
+        jz      .doit
+; create directory
+        mov     byte [edi+11], 10h      ; attributes: folder
+        mov     ecx, 32*2
+        mov     edx, edi
 .doit:
         lea     eax, [esp+8]
         call    dword [eax+12]  ; flush directory
         push    ecx
         push    edi
         push    0
         mov     esi, edx
+        test    ecx, ecx
-        jecxz   .done
+        jz      .done
         mov     ecx, 2849
-        mov     edi, 0x282000
+        mov     edi, FLOPPY_FAT
         push    0       ; first cluster
 .write_loop:
 ; allocate new cluster
         xor     eax, eax
         repnz   scasw
         mov     al, ERROR_DISK_FULL
         jnz     .ret
         dec     edi
         dec     edi
-        lea     eax, [edi-0x282000]
+        lea     eax, [edi-(FLOPPY_FAT)]
         shr     eax, 1                  ; eax = cluster
         mov     word [edi], 0xFFF       ; mark as last cluster
         xchg    edi, [esp+4]
         cmp     dword [esp], 0
         jz      .first
         mov     ecx, 512
         cmp     dword [esp+20], ecx
         jae     @f
         mov     ecx, [esp+20]
 @@:
+        mov     edi, FDD_BUFF
+        cmp     byte [esp+24+28+28], 0
+        jnz     .writedir
         push    ecx
-        mov     edi, 0xD000
         rep     movsb
         pop     ecx
+.writedircont:
         push    ecx
         sub     ecx, 512
         neg     ecx
         push    eax
         xor     eax, eax
 .diskerr:
         sub     esi, ecx
         mov     eax, 11
         pop     edi ecx
         jmp     .ret
+.writedir:
+        push    ecx
+        mov     ecx, 32/4
+        push    ecx esi
+        rep     movsd
+        pop     esi ecx
+        mov     dword [edi-32], '.   '
+        mov     dword [edi-32+4], '    '
+        mov     dword [edi-32+8], '    '
+        mov     byte [edi-32+11], 10h
+        mov     word [edi-32+26], ax
+        push    esi
+        rep     movsd
+        pop     esi
+        mov     dword [edi-32], '..  '
+        mov     dword [edi-32+4], '    '
+        mov     dword [edi-32+8], '    '
+        mov     byte [edi-32+11], 10h
+        mov     ecx, [esp+28+8]
+        mov     word [edi-32+26], cx
+        pop     ecx
+        jmp     .writedircont
 ;----------------------------------------------------------------
+;
 ;  fs_FloppyWrite - LFN variant for writing to floppy
 ; now ebx=start pos, ecx=end pos, both lie inside file
         sub     ecx, ebx
         jz      .ret
         call    SetUserInterrupts
 .write_loop:
+; skip unmodified sectors
+        cmp     dword [esp], 0x200
+        jb      .modify
+        sub     ebx, 0x200
+        jae     .skip
+        add     ebx, 0x200
+.modify:
         lea     eax, [edi+31]   ; current sector
 ; get length of data in current sector
         push    ecx
         sub     ebx, 0x200
         jb      .hasdata
         push    eax ecx edi
         xor     eax, eax
         mov     ecx, 0x200
         sub     ecx, [esp+4+12]
         jbe     @f
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         add     edi, [esp+4+12]
         rep     stosb
 @@:
 ; zero uninitialized data in the last sector
         mov     ecx, 0x200
         sub     ecx, esi
         jbe     @f
-        mov     edi, 0xD000
+        mov     edi, FDD_BUFF
         add     edi, esi
         rep     stosb
 @@:
         pop     edi ecx eax
 ; copy new data
         push    eax
         mov     eax, edx
         neg     ebx
         jecxz   @f
-        add     ebx, 0xD000+0x200
+        add     ebx, FDD_BUFF+0x200
         call    memmove
         xor     ebx, ebx
 @@:
         pop     eax
 ; save sector
         jnz     .device_err2
         add     edx, ecx
         sub     [esp], ecx
         pop     ecx
         jz      .done
+.skip:
 .next_cluster:
-        movzx   edi, word [edi*2+0x282000]
+        movzx   edi, word [edi*2+FLOPPY_FAT]
         sub     esi, 0x200
         jae     @f
         xor     esi, esi
 @@:
         sub     dword [esp], 0x200
         mov     ecx, [edi+28]
         jecxz   .zero_size
 @@:
         sub     ecx, 0x200
         jbe     @f
-        mov     eax, [eax*2+0x282000]
+        mov     eax, [eax*2+FLOPPY_FAT]
         and     eax, 0xFFF
         jz      .fat_err
         cmp     eax, 0xFF8
         jb      @b
 .fat_err:
         pop     eax
         stc
         ret
 @@:
         push    eax
-        mov     eax, [eax*2+0x282000]
+        mov     eax, [eax*2+FLOPPY_FAT]
         and     eax, 0xFFF
         cmp     eax, 0xFF8
         pop     eax
         jb      .fat_err
 ; set length to full number of sectors
         sub     [edi+28], ecx
 .start_extend:
         pop     ecx
 ; now do extend
         push    edx esi
-        mov     esi, 0x282000+2*2       ; start scan from cluster 2
+        mov     esi, FLOPPY_FAT+2*2       ; start scan from cluster 2
         mov     edx, 2847               ; number of clusters to scan
 .extend_loop:
         cmp     [edi+28], ecx
         jae     .extend_done
 ; add new sector
         pop     eax
         jnz     .disk_full
         mov     word [edi-2], 0xFFF
         mov     esi, edi
         mov     edx, ecx
-        sub     edi, 0x282000
+        sub     edi, FLOPPY_FAT
         shr     edi, 1
         dec     edi     ; now edi=new cluster
         test    eax, eax
         jz      .first_cluster
-        mov     [0x282000+eax*2], di
+        mov     [FLOPPY_FAT+eax*2], di
         jmp     @f
 .first_cluster:
         pop     eax             ; eax->direntry
         push    eax
         mov     [eax+26], di
         jnz     .err_next
 .noread:
         mov     ecx, [esp+4]
         neg     ecx
         push    edi
-        mov     edi, 0xD000+0x200
+        mov     edi, FDD_BUFF+0x200
         add     edi, [esp+8]
         xor     eax, eax
         mov     [esp+8], eax
         rep     stosb
         pop     edi
 .err_next:
         mov     byte [esp], 11
 .next_cluster:
         sub     dword [esp+12], 0x200
         jbe     .expand_done
-        movzx   edi, word [0x282000+edi*2]
+        movzx   edi, word [FLOPPY_FAT+edi*2]
         jmp     .zero_loop
 .expand_done:
         pop     eax ecx ecx edi edi
         jmp     .doret
 .truncate:
         jz      .zero_size
 ; find new last sector
 @@:
         sub     eax, 0x200
         jbe     @f
-        movzx   ecx, word [0x282000+ecx*2]
+        movzx   ecx, word [FLOPPY_FAT+ecx*2]
         jmp     @b
 @@:
 ; we will zero data at the end of last sector - remember it
         push    ecx
 ; terminate FAT chain
-        lea     ecx, [0x282000+ecx+ecx]
+        lea     ecx, [FLOPPY_FAT+ecx+ecx]
         push    dword [ecx]
         mov     word [ecx], 0xFFF
         pop     ecx
         and     ecx, 0xFFF
         jmp     .delete
 .delete:
 ; delete FAT chain starting with ecx
 ; mark all clusters as free
         cmp     ecx, 0xFF8
         jae     .deleted
-        lea     ecx, [0x282000+ecx+ecx]
+        lea     ecx, [FLOPPY_FAT+ecx+ecx]
         push    dword [ecx]
         and     word [ecx], 0
         pop     ecx
         and     ecx, 0xFFF
         jmp     .delete
         jz      .truncate_done
         call    SetUserInterrupts
         pusha
         call    read_chs_sector
         popa
-        add     edi, 0xD000
+        add     edi, FDD_BUFF
-        mov     ecx, 0xD000+0x200
+        mov     ecx, FDD_BUFF+0x200
         sub     ecx, edi
         push    eax
         xor     eax, eax
         rep     stosb
         pop     eax
         jz      @f
         mov     al, 11
 @@:
         ret
 if 0
 ;----------------------------------------------------------------
+;
 ;  fs_FloppyExecute - LFN variant for executing from floppy
+;
         add     eax, 31
         call    read_chs_sector
         cmp     [FDC_Status], 0
         jnz     .err
         pop     edi
-        mov     esi, 0xD000
+        mov     esi, FDD_BUFF
         push    edi
         mov     ecx, 512/4
         rep     movsd
         mov     eax, [esp+28]
         mov     ecx, [eax]
         rep     stosb
         pop     eax
 @@:
         mov     [eax], ecx
         mov     edx, [eax+4]
-        mov     dx, [edx*2+0x282000]
+        mov     dx, [edx*2+FLOPPY_FAT]
         mov     [eax+4], dx     ; high word is already zero
         popad
         xor     eax, eax
         ret
 .eof:
         ret
 .err:
         popad
         mov     eax, 11
         ret
+end if
+;----------------------------------------------------------------
+;
+;  fs_FloppyDelete - delete file or empty folder from floppy
+;
+;  esi  points to filename
+;
+;  ret  eax = 0 ok or other = errormsg
+;
+;--------------------------------------------------------------
+fs_FloppyDelete:
+        call    read_flp_fat
+        cmp     [FDC_Status], 0
+        jz      @f
+        push    11
+        jmp     .pop_ret
+@@:
+        cmp     byte [esi], 0
+        jnz     @f
+; cannot delete root!
+.access_denied:
+        push    ERROR_ACCESS_DENIED
+.pop_ret:
+        pop     eax
+        ret
+@@:
+        and     [fd_prev_sector], 0
+        and     [fd_prev_prev_sector], 0
+        push    edi
+        call    fd_find_lfn
+        jnc     .found
+        pop     edi
+        push    ERROR_FILE_NOT_FOUND
+        jmp     .pop_ret
+.found:
+        cmp     dword [edi], '.   '
+        jz      .access_denied2
+        cmp     dword [edi], '..  '
+        jz      .access_denied2
+        test    byte [edi+11], 10h
+        jz      .dodel
+; we can delete only empty folders!
+        push    eax
+        movzx   eax, word [edi+26]
+        push    ebx
+        pusha
+        add     eax, 31
+        call    read_chs_sector
+        popa
+        mov     ebx, FDD_BUFF + 2*0x20
+.checkempty:
+        cmp     byte [ebx], 0
+        jz      .empty
+        cmp     byte [ebx], 0xE5
+        jnz     .notempty
+        add     ebx, 0x20
+        cmp     ebx, FDD_BUFF + 0x200
+        jb      .checkempty
+        movzx   eax, word [FLOPPY_FAT + eax*2]
+        pusha
+        add     eax, 31
+        call    read_chs_sector
+        popa
+        mov     ebx, FDD_BUFF
+        jmp     .checkempty
+.notempty:
+        pop     ebx
+        pop     eax
+.access_denied2:
+        pop     edi
+        jmp     .access_denied
+.empty:
+        pop     ebx
+        pop     eax
+        pusha
+        call    read_chs_sector
+        popa
+.dodel:
+        push    eax
+        movzx   eax, word [edi+26]
+        xchg    eax, [esp]
+; delete folder entry
+        mov     byte [edi], 0xE5
+; delete LFN (if present)
+.lfndel:
+        cmp     edi, FDD_BUFF
+        ja      @f
+        cmp     [fd_prev_sector], 0
+        jz      .lfndone
+        push    [fd_prev_sector]
+        push    [fd_prev_prev_sector]
+        pop     [fd_prev_sector]
+        and     [fd_prev_prev_sector], 0
+        pusha
+        call    save_chs_sector
+        popa
+        pop     eax
+        pusha
+        call    read_chs_sector
+        popa
+        mov     edi, FDD_BUFF+0x200
+@@:
+        sub     edi, 0x20
+        cmp     byte [edi], 0xE5
+        jz      .lfndone
+        cmp     byte [edi+11], 0xF
+        jnz     .lfndone
+        mov     byte [edi], 0xE5
+        jmp     .lfndel
+.lfndone:
+        pusha
+        call    save_chs_sector
+        popa
+; delete FAT chain
+        pop     eax
+        test    eax, eax
+        jz      .done
+@@:
+        lea     eax, [FLOPPY_FAT + eax*2]
+        push    dword [eax]
+        and     word [eax], 0
+        pop     eax
+        and     eax, 0xFFF
+        jnz     @b
+.done:
+        call    save_flp_fat
+        pop     edi
+        xor     eax, eax
+        ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/gfx_kernel/fs/fat12.inc – Rev 133 → 384