WebSVN – Kolibri OS – Diff – /kernel/trunk/blkdev/rd.inc


$Revision: 527 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;; RAMDISK functions                                            ;;
;; (C) 2004 Ville Turjanmaa, License: GPL                       ;;
;; Addings by M.Lisovin                                         ;;
;; LFN support by diamond                                       ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; calculate fat chain
 
calculatefatchain:
 
   pushad
 
   mov  esi,RAMDISK+512
   mov  edi,RAMDISK_FAT
 
 fcnew:
   mov  eax,dword [esi]
   mov  ebx,dword [esi+4]
   mov  ecx,dword [esi+8]
   mov  edx,ecx
   shr  edx,4   ;8 ok
   shr  dx,4    ;7 ok
   xor  ch,ch
   shld ecx,ebx,20 ;6 ok
   shr  cx,4     ;5 ok
   shld ebx,eax,12
   and  ebx,0x0fffffff  ;4 ok
   shr  bx,4    ;3 ok
   shl  eax,4
   and  eax,0x0fffffff  ;2 ok
   shr  ax,4  ;1 ok
   mov  dword [edi],eax
   mov  dword [edi+4],ebx
   mov  dword [edi+8],ecx
   mov  dword [edi+12],edx
   add  edi,16
   add  esi,12
 
   cmp  edi,RAMDISK_FAT+2856*2   ;2849 clusters
   jnz  fcnew
 
   popad
   ret
 
 
restorefatchain:   ; restore fat chain
 
   pushad
 
   mov  esi,RAMDISK_FAT
   mov  edi,RAMDISK+512
 
  fcnew2:
   mov  eax,dword [esi]
   mov  ebx,dword [esi+4]
   shl  ax,4
   shl  eax,4
   shl  bx,4
   shr  ebx,4
   shrd eax,ebx,8
   shr  ebx,8
   mov  dword [edi],eax
   mov  word [edi+4],bx
   add  edi,6
   add  esi,8
 
   cmp  edi,RAMDISK+512+4278     ;4274 bytes - all used FAT
   jb   fcnew2
 
   mov  esi,RAMDISK+512           ; duplicate fat chain
   mov  edi,RAMDISK+512+0x1200
   mov  ecx,1069        ;4274/4
   cld
   rep  movsd
 
   popad
   ret
 
 
ramdisk_free_space:
;---------------------------------------------
;
; returns free space in edi
; rewr.by Mihasik
;---------------------------------------------
 
        push   eax ebx ecx
 
        mov  edi,RAMDISK_FAT ;start of FAT
        xor  ax,ax    ;Free cluster=0x0000 in FAT
        xor  ebx,ebx  ;counter
        mov  ecx,2849 ;2849 clusters
        cld
    rdfs1:
        repne scasw
        jnz  rdfs2    ;if last cluster not 0
        inc  ebx
        test    ecx, ecx
        jnz     rdfs1
    rdfs2:
        shl  ebx,9    ;free clusters*512
        mov  edi,ebx
 
        pop    ecx ebx eax
        ret
 
 
expand_filename:
;---------------------------------------------
;
; exapand filename with '.' to 11 character
; eax - pointer to filename
;---------------------------------------------
 
        push esi edi ebx
 
        mov  edi,esp                  ; check for '.' in the name
        add  edi,12+8
 
        mov  esi,eax
 
        mov  eax,edi
        mov  [eax+0],dword '    '
        mov  [eax+4],dword '    '
        mov  [eax+8],dword '    '
 
      flr1:
 
        cmp  [esi],byte '.'
        jne  flr2
        mov  edi,eax
        add  edi,7
        jmp  flr3
 
      flr2:
 
        mov  bl,[esi]
        mov  [edi],bl
 
      flr3:
 
        inc  esi
        inc  edi
 
        mov  ebx,eax
        add  ebx,11
 
        cmp  edi,ebx
        jbe  flr1
 
        pop  ebx edi esi
        ret
 
fileread:
;----------------------------------------------------------------
;
;  fileread - sys floppy
;
;  eax  points to filename 11 chars
;  ebx  first wanted block       ; 1+ ; if 0 then set to 1
;  ecx  number of blocks to read ; 1+ ; if 0 then set to 1
;  edx  mem location to return data
;  esi  length of filename 12*X 0=root
;
;  ret ebx = size or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
        test   ebx,ebx ;if ebx=0 - set to 1
        jnz    frfl5
        inc    ebx
      frfl5:
        test   ecx,ecx ;if ecx=0 - set to 1
        jnz    frfl6
        inc    ecx
      frfl6:
        test   esi,esi          ; return ramdisk root
        jnz    fr_noroot        ;if not root
        cmp    ebx,14           ;14 clusters=root dir
        ja     oorr
        cmp    ecx,14
        ja     oorr
        jmp    fr_do
      oorr:
        mov    eax,5            ;out of root range (fnf)
        xor    ebx,ebx
        dec    ebx              ;0xffffffff
        ret
 
      fr_do:                    ;reading rootdir
        mov    edi,edx
        dec    ebx
        push   edx
        mov    edx,ecx
        add    edx,ebx
        cmp    edx,15     ;ebx+ecx=14+1
        pushf
        jbe    fr_do1
        sub    edx,14
        sub    ecx,edx
      fr_do1:
        shl    ebx,9
        mov    esi,RAMDISK+512*19
        add    esi,ebx
        shl    ecx,7
        cld
        rep    movsd
        popf
        pop    edx
        jae    fr_do2
        xor    eax,eax ; ok read
        xor    ebx,ebx
        ret
      fr_do2:        ;if last cluster
        mov    eax,6  ;end of file
        xor    ebx,ebx
        ret
 
     fr_noroot:
 
        sub    esp,32
        call   expand_filename
 
        dec    ebx
 
        push   eax
 
        push   eax ebx ecx edx esi edi
        call   rd_findfile
        je     fifound
        add    esp,32+28   ;if file not found
        ret
 
     fifound:
 
        mov    ebx,[edi-11+28]          ;file size
        mov    [esp+20],ebx
        mov    [esp+24],ebx
        add    edi,0xf
        movzx  eax,word [edi]
        mov    edi,eax                  ;edi=cluster
 
      frnew:
 
        add    eax,31                   ;bootsector+2*fat+filenames
        shl    eax,9                    ;*512
        add    eax,RAMDISK             ;image base
        mov    ebx,[esp+8]
        mov    ecx,512                  ;[esp+4]
 
        cmp    [esp+16],dword 0         ; wanted cluster ?
        jne    frfl7
        call   memmove
        add    [esp+8],dword 512
        dec    dword [esp+12]           ; last wanted cluster ?
        je     frnoread
        jmp    frfl8
      frfl7:
        dec    dword [esp+16]
      frfl8:
        movzx  eax,word [edi*2+RAMDISK_FAT]        ; find next cluster from FAT
        mov    edi,eax
        cmp    edi,4095                 ;eof  - cluster
        jz     frnoread2
 
        cmp    [esp+24],dword 512       ;eof  - size
        jb     frnoread
        sub    [esp+24],dword 512
 
        jmp    frnew
 
      frnoread2:
 
        cmp    [esp+16],dword 0         ; eof without read ?
        je     frnoread
 
        pop    edi esi edx ecx
        add    esp,4
        pop    ebx     ; ebx <- eax : size of file
        add    esp,36
        mov    eax,6   ; end of file
        ret
 
      frnoread:
 
        pop    edi esi edx ecx
        add    esp,4
        pop    ebx     ; ebx <- eax : size of file
        add    esp,36
        xor    eax,eax  ;read ok
        ret
 
filedelete:
;--------------------------------------------
;
; filedelete - sys floppy
; in:
; eax -  pointer to filename 11 chars
;
; out:
; eax - 0 = successful, 5 = file not found
;
;--------------------------------------------
 
        sub    esp,32
        call   expand_filename
 
        push   eax ebx ecx edx esi edi
 
        call   rd_findfile
        je     fifoundd
        pop    edi esi edx ecx ebx eax ;file not found
        add    esp,32
        mov    eax,5
        ret
 
     fifoundd:
 
        mov    [edi-11],byte 0xE5       ;mark filename deleted
        add    edi,0xf
        movzx  eax,word [edi]
        mov    edi,eax                  ;edi = cluster
 
      frnewd:
 
        shl    edi,1                    ;find next cluster from FAT
        add    edi,RAMDISK_FAT
        movzx  eax,word [edi]
        mov    [edi],word 0x0           ;clear fat chain cluster
        mov    edi,eax
        cmp    edi,dword 0xff8          ;last cluster ?
        jb     frnewd
 
        pop    edi esi edx ecx ebx eax
        add    esp,32
        xor    eax,eax       ; file found
        ret
 
 
 
filesave:
;----------------------------------------------------------
;
; filesave - sys floppy
;
; eax points to filename 11 chars
;
;        eax      ; pointer to file name
;        ebx      ; buffer
;        ecx      ; count to write in bytes
;        edx      ; 0 create new , 1 append
;
;-----------------------------------------------------------
 
        sub  esp,32
        call expand_filename
        test edx,edx
        jnz  fsdel
        pusha
        call filedelete
        popa
 
      fsdel:
 
        call   ramdisk_free_space
        cmp    ecx,edi
        jbe    rd_do_save
        add    esp,32
        mov    eax,8    ;disk full
        ret
 
      rd_do_save:
 
        push   eax ebx ecx edx esi edi
 
        mov    edi,RAMDISK+512*18+512  ;Point at directory
        mov    edx,224 +1
        ; find an empty spot for filename in the root dir
     l20ds:
        dec    edx
        jz     frnoreadds
     l21ds:
        cmp    [edi],byte 0xE5
        jz     fifoundds
        cmp    [edi],byte 0x0
        jz     fifoundds
        add    edi,32                   ; Advance to next entry
        jmp    l20ds
     fifoundds:
 
        push   edi                      ; move the filename to root dir
        mov    esi,[esp+4+20]
        mov    ecx,11
        cld
        rep    movsb
        pop    edi
        mov    edx,edi
        add    edx,11+0xf               ; edx <- cluster save position
        mov    ebx,[esp+12]             ; save file size
        mov    [edi+28],ebx
        mov    [edi+11],byte 0x20       ; attribute
; Ivan Poddubny 11/12/2003:
call get_date_for_file   ; from FAT32.INC
mov [edi+24],ax          ; date
call get_time_for_file   ; from FAT32.INC
mov [edi+22],ax          ; time
; End
        mov    edi,RAMDISK_FAT            ;pointer to first cluster
        mov    ecx,2849
        cld
      frnewds:
        xor    ax,ax
        repne  scasw
        mov    ebx,2848
        sub    ebx,ecx
        mov    [edx],bx                 ; save next cluster pos. to prev cl.
        mov    edx,edi                  ; next save pos abs mem add
        dec    edx
        dec    edx
        call   fdc_filesave
        pusha                           ; move save to floppy cluster
        add    ebx,31
        shl    ebx,9
        add    ebx,RAMDISK
        mov    eax,[esp+32+16]
        mov    ecx,512
        call   memmove
        popa
 
        mov    eax,[esp+12]
        cmp    eax,512
        jbe    flnsa
        sub    eax,512
        mov    [esp+12],eax
        add     dword [esp+16], 512
        jmp    frnewds
 
     flnsa:
        mov    [edi-2],word 4095          ; mark end of file - last cluster
 
      frnoreadds:
 
        pop    edi esi edx ecx ebx eax
        add    esp,32
 
;        pusha
;        cli
;        call   fdc_commitfile
;        sti
;        popa
 
        xor    eax,eax ;ok write
        ret
 
   rd_findfile:
   ;by Mihasik
   ;IN: eax - pointer to filename OUT: filestring+11 in edi or notZero in flags and fnf in eax,ebx
 
        mov    edi,RAMDISK+512*18+512  ;Point at directory
        cld
    rd_newsearch:
        mov    esi,eax
        mov    ecx,11
        rep    cmpsb
        je     rd_ff
        add    cl,21
        add    edi,ecx
        cmp    edi,RAMDISK+512*33
        jb     rd_newsearch
        mov    eax,5      ;if file not found - eax=5
        xor    ebx,ebx
        dec    ebx    ;ebx=0xffffffff and zf=0
     rd_ff:
        ret
 
; \begin{diamond}
 
uni2ansi_str:
; convert UNICODE zero-terminated string to ASCII-string (codepage 866)
; in: esi->source, edi->buffer (may be esi=edi)
; destroys: eax,esi,edi
        lodsw
        test    ax, ax
        jz      .done
        cmp     ax, 0x80
        jb      .ascii
        cmp     ax, 0x401
        jz      .yo1
        cmp     ax, 0x451
        jz      .yo2
        cmp     ax, 0x410
        jb      .unk
        cmp     ax, 0x440
        jb      .rus1
        cmp     ax, 0x450
        jb      .rus2
.unk:
        mov     al, '_'
        jmp     .doit
.yo1:
        mov     al, 'ð'
        jmp     .doit
.yo2:
        mov     al, 'ñ'
        jmp     .doit
.rus1:
; 0x410-0x43F -> 0x80-0xAF
        add     al, 0x70
        jmp     .doit
.rus2:
; 0x440-0x44F -> 0xE0-0xEF
        add     al, 0xA0
.ascii:
.doit:
        stosb
        jmp     uni2ansi_str
.done:
        mov     byte [edi], 0
        ret
 
ansi2uni_char:
; convert ANSI character in al to UNICODE character in ax, using cp866 encoding
        mov     ah, 0
; 0x00-0x7F - trivial map
        cmp     al, 0x80
        jb      .ret
; 0x80-0xAF -> 0x410-0x43F
        cmp     al, 0xB0
        jae     @f
        add     ax, 0x410-0x80
.ret:
        ret
@@:
; 0xE0-0xEF -> 0x440-0x44F
        cmp     al, 0xE0
        jb      .unk
        cmp     al, 0xF0
        jae     @f
        add     ax, 0x440-0xE0
        ret
; 0xF0 -> 0x401
; 0xF1 -> 0x451
@@:
        cmp     al, 'ð'
        jz      .yo1
        cmp     al, 'ñ'
        jz      .yo2
.unk:
        mov     al, '_'         ; ah=0
        ret
.yo1:
        mov     ax, 0x401
        ret
.yo2:
        mov     ax, 0x451
        ret
 
char_toupper:
; convert character to uppercase, using cp866 encoding
; in: al=symbol
; out: al=converted symbol
        cmp     al, 'a'
        jb      .ret
        cmp     al, 'z'
        jbe     .az
        cmp     al, ' '
        jb      .ret
        cmp     al, 'à'
        jb      .rus1
        cmp     al, 'ï'
        ja      .ret
; 0xE0-0xEF -> 0x90-0x9F
        sub     al, 'à'-''
.ret:
        ret
.rus1:
; 0xA0-0xAF -> 0x80-0x8F
.az:
        and     al, not 0x20
        ret
 
fat_get_name:
; in: edi->FAT entry
; out: CF=1 - no valid entry
; else CF=0 and ebp->ASCIIZ-name
; (maximum length of filename is 255 (wide) symbols without trailing 0,
;  but implementation requires buffer 261 words)
; destroys eax
        cmp     byte [edi], 0
        jz      .no
        cmp     byte [edi], 0xE5
        jnz     @f
.no:
        stc
        ret
@@:
        cmp     byte [edi+11], 0xF
        jz      .longname
        test    byte [edi+11], 8
        jnz     .no
        push    ecx
        push    edi ebp
        test    byte [ebp-4], 1
        jnz     .unicode_short
 
        mov     eax, [edi]
        mov     ecx, [edi+4]
        mov     [ebp], eax
        mov     [ebp+4], ecx
 
        mov     ecx, 8
@@:
        cmp     byte [ebp+ecx-1], ' '
        loope    @b
 
        mov     eax, [edi+8]
        cmp     al, ' '
        je      .done
        shl     eax, 8
        mov     al, '.'
 
        lea ebp, [ebp+ecx+1]
        mov     [ebp], eax
        mov     ecx, 3
@@:
        rol eax, 8
        cmp al, ' '
        jne .done
        loop   @b
        dec ebp
.done:
        and     byte [ebp+ecx+1], 0   ; CF=0
        pop     ebp edi ecx
        ret
.unicode_short:
        mov     ecx, 8
        push    ecx
@@:
        mov     al, [edi]
        inc     edi
        call    ansi2uni_char
        mov     [ebp], ax
        inc     ebp
        inc     ebp
        loop    @b
        pop     ecx
@@:
        cmp     word [ebp-2], ' '
        jnz     @f
        dec     ebp
        dec     ebp
        loop    @b
@@:
        mov     word [ebp], '.'
        inc     ebp
        inc     ebp
        mov     ecx, 3
        push    ecx
@@:
        mov     al, [edi]
        inc     edi
        call    ansi2uni_char
        mov     [ebp], ax
        inc     ebp
        inc     ebp
        loop    @b
        pop     ecx
@@:
        cmp     word [ebp-2], ' '
        jnz     @f
        dec     ebp
        dec     ebp
        loop    @b
        dec     ebp
        dec     ebp
@@:
        and     word [ebp], 0	; CF=0
        pop     ebp edi ecx
        ret
.longname:
; LFN
        mov     al, byte [edi]
        and     eax, 0x3F
        dec     eax
        cmp     al, 20
        jae     .no     ; ignore invalid entries
        mov     word [ebp+260*2], 0     ; force null-terminating for orphans
        imul    eax, 13*2
        add     ebp, eax
        test    byte [edi], 0x40
        jz      @f
        mov     word [ebp+13*2], 0
@@:
        push    eax
; now copy name from edi to ebp ...
        mov     eax, [edi+1]
        mov     [ebp], eax      ; symbols 1,2
        mov     eax, [edi+5]
        mov     [ebp+4], eax	; 3,4
        mov     eax, [edi+9]
        mov     [ebp+8], ax	; 5
        mov     eax, [edi+14]
        mov     [ebp+10], eax	; 6,7
        mov     eax, [edi+18]
        mov     [ebp+14], eax	; 8,9
        mov     eax, [edi+22]
        mov     [ebp+18], eax	; 10,11
        mov     eax, [edi+28]
        mov     [ebp+22], eax	; 12,13
; ... done
        pop     eax
        sub     ebp, eax
        test    eax, eax
        jz      @f
; if this is not first entry, more processing required
        stc
        ret
@@:
; if this is first entry:
        test    byte [ebp-4], 1
        jnz     .ret
; buffer at ebp contains UNICODE name, convert it to ANSI
        push    esi edi
        mov     esi, ebp
        mov     edi, ebp
        call    uni2ansi_str
        pop     edi esi
.ret:
        clc
        ret
 
fat_compare_name:
; compares ASCIIZ-names, case-insensitive (cp866 encoding)
; in: esi->name, ebp->name
; out: if names match: ZF=1 and esi->next component of name
;      else: ZF=0, esi is not changed
; destroys eax
        push    ebp esi
.loop:
        mov     al, [ebp]
        inc     ebp
        call    char_toupper
        push    eax
        lodsb
        call    char_toupper
        cmp     al, [esp]
        jnz     .done
        pop     eax
        test    al, al
        jnz     .loop
        dec     esi
        pop     eax
        pop     ebp
        xor     eax, eax	; set ZF flag
        ret
.done:
        cmp     al, '/'
        jnz     @f
        cmp     byte [esp], 0
        jnz     @f
        mov     [esp+4], esi
@@:
        pop     eax
        pop     esi ebp
        ret
 
fat_time_to_bdfe:
; in: eax=FAT time
; out: eax=BDFE time
        push    ecx edx
        mov     ecx, eax
        mov     edx, eax
        shr     eax, 11
        shl     eax, 16	; hours
        and     edx, 0x1F
        add     edx, edx
        mov     al, dl	; seconds
        shr     ecx, 5
        and     ecx, 0x3F
        mov     ah, cl	; minutes
        pop     edx ecx
        ret
 
fat_date_to_bdfe:
        push    ecx edx
        mov     ecx, eax
        mov     edx, eax
        shr     eax, 9
        add     ax, 1980
        shl     eax, 16	; year
        and     edx, 0x1F
        mov     al, dl	; day
        shr     ecx, 5
        and     ecx, 0xF
        mov     ah, cl	; month
        pop     edx ecx
        ret
 
bdfe_to_fat_time:
        push    edx
        mov     edx, eax
        shr     eax, 16
        and     dh, 0x3F
        shl     eax, 6
        or      al, dh
        shr     dl, 1
        and     dl, 0x1F
        shl     eax, 5
        or      al, dl
        pop     edx
        ret
 
bdfe_to_fat_date:
        push    edx
        mov     edx, eax
        shr     eax, 16
        sub     ax, 1980
        and     dh, 0xF
        shl     eax, 4
        or      al, dh
        and     dl, 0x1F
        shl     eax, 5
        or      al, dl
        pop     edx
        ret
 
fat_entry_to_bdfe:
; convert FAT entry at edi to BDFE (block of data of folder entry) at esi, advance esi
; destroys eax
        mov     eax, [ebp-4]
        mov     [esi+4], eax	; ASCII/UNICODE name
fat_entry_to_bdfe2:
        movzx   eax, byte [edi+11]
        mov     [esi], eax	; attributes
        movzx   eax, word [edi+14]
        call    fat_time_to_bdfe
        mov     [esi+8], eax	; creation time
        movzx   eax, word [edi+16]
        call    fat_date_to_bdfe
        mov     [esi+12], eax	; creation date
        and     dword [esi+16], 0	; last access time is not supported on FAT
        movzx   eax, word [edi+18]
        call    fat_date_to_bdfe
        mov     [esi+20], eax	; last access date
        movzx   eax, word [edi+22]
        call    fat_time_to_bdfe
        mov     [esi+24], eax	; last write time
        movzx   eax, word [edi+24]
        call    fat_date_to_bdfe
        mov     [esi+28], eax	; last write date
        mov     eax, [edi+28]
        mov     [esi+32], eax	; file size (low dword)
        xor     eax, eax
        mov     [esi+36], eax	; file size (high dword)
        test    ebp, ebp
        jz      .ret
        push    ecx edi
        lea     edi, [esi+40]
        mov     esi, ebp
        test    byte [esi-4], 1
        jz      .ansi
        mov     ecx, 260/2
        rep     movsd
        mov     [edi-2], ax
@@:
        mov     esi, edi
        pop     edi ecx
.ret:
        ret
.ansi:
        mov     ecx, 264/4
        rep     movsd
        mov     [edi-1], al
        jmp     @b
 
bdfe_to_fat_entry:
; convert BDFE at edx to FAT entry at edi
; destroys eax
; attributes byte
        test    byte [edi+11], 8        ; volume label?
        jnz     @f
        mov     al, [edx]
        and     al, 0x27
        and     byte [edi+11], 0x10
        or      byte [edi+11], al
@@:
        mov     eax, [edx+8]
        call    bdfe_to_fat_time
        mov     [edi+14], ax            ; creation time
        mov     eax, [edx+12]
        call    bdfe_to_fat_date
        mov     [edi+16], ax            ; creation date
        mov     eax, [edx+20]
        call    bdfe_to_fat_date
        mov     [edi+18], ax            ; last access date
        mov     eax, [edx+24]
        call    bdfe_to_fat_time
        mov     [edi+22], ax            ; last write time
        mov     eax, [edx+28]
        call    bdfe_to_fat_date
        mov     [edi+24], ax            ; last write date
        ret
 
ramdisk_root_first:
        mov     edi, RAMDISK+512*19
        clc
        ret
ramdisk_root_next:
        add     edi, 0x20
        cmp     edi, RAMDISK+512*33
        cmc
        ret
 
ramdisk_root_extend_dir:
        stc
        ret
 
uglobal
; this is for delete support
rd_prev_sector          dd      ?
rd_prev_prev_sector     dd      ?
endg
 
ramdisk_notroot_next:
        add     edi, 0x20
        test    edi, 0x1FF
        jz      ramdisk_notroot_next_sector
        ret     ; CF=0
ramdisk_notroot_next_sector:
        push    ecx
        mov     ecx, [eax]
        push    [rd_prev_sector]
        pop     [rd_prev_prev_sector]
        mov     [rd_prev_sector], ecx
        mov     ecx, [ecx*2+RAMDISK_FAT]
        and     ecx, 0xFFF
        cmp     ecx, 2849
        jae     ramdisk_notroot_first.err2
        mov     [eax], ecx
        pop     ecx
ramdisk_notroot_first:
        mov     eax, [eax]
        cmp     eax, 2
        jb      .err
        cmp     eax, 2849
        jae     .err
        shl     eax, 9
        lea     edi, [eax+(31 shl 9)+RAMDISK]
        clc
        ret
.err2:
        pop     ecx
.err:
        stc
        ret
ramdisk_notroot_next_write:
        test    edi, 0x1FF
        jz      ramdisk_notroot_next_sector
ramdisk_root_next_write:
        ret
 
ramdisk_notroot_extend_dir:
        pusha
        xor     eax, eax
        mov     edi, RAMDISK_FAT
        mov     ecx, 2849
        repnz   scasw
        jnz     .notfound
        mov     word [edi-2], 0xFFF
        sub     edi, RAMDISK_FAT
        shr     edi, 1
        dec     edi
        mov     eax, [esp+28]
        mov     ecx, [eax]
        mov     [RAMDISK_FAT+ecx*2], di
        mov     [eax], edi
        shl     edi, 9
        add     edi, (31 shl 9)+RAMDISK
        mov     [esp], edi
        xor     eax, eax
        mov     ecx, 128
        rep     stosd
        popa
        clc
        ret
.notfound:
        popa
        stc
        ret
 
rd_find_lfn:
; in: esi+ebp -> name
; out: CF=1 - file not found
;      else CF=0 and edi->direntry
        push    esi edi
        push    0
        push    ramdisk_root_first
        push    ramdisk_root_next
.loop:
        call    fat_find_lfn
        jc      .notfound
        cmp     byte [esi], 0
        jz      .found
.continue:
        test    byte [edi+11], 10h
        jz      .notfound
        movzx   eax, word [edi+26]
        mov     [esp+8], eax
        mov     dword [esp+4], ramdisk_notroot_first
        mov     dword [esp], ramdisk_notroot_next
        jmp     .loop
.notfound:
        add     esp, 12
        pop     edi esi
        stc
        ret
.found:
        test    ebp, ebp
        jz      @f
        mov     esi, ebp
        xor     ebp, ebp
        jmp     .continue
@@:
        mov     eax, [esp+8]
        add     esp, 16         ; CF=0
        pop     esi
        ret
 
;----------------------------------------------------------------
;
;  fs_RamdiskRead - LFN variant for reading sys floppy
;
;  esi  points to filename
;  ebx  pointer to 64-bit number = first wanted byte, 0+
;       may be ebx=0 - start from first byte
;  ecx  number of bytes to read, 0+
;  edx  mem location to return data
;
;  ret ebx = bytes read or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_RamdiskRead:
        cmp     byte [esi], 0
        jnz     @f
        or      ebx, -1
        mov     eax, 10         ; access denied
        ret
@@:
        push    edi
        call    rd_find_lfn
        jnc     .found
        pop     edi
        or      ebx, -1
        mov     eax, 5          ; file not found
        ret
.found:
        test    ebx, ebx
        jz      .l1
        cmp     dword [ebx+4], 0
        jz      @f
        xor     ebx, ebx
.reteof:
        mov     eax, 6          ; EOF
        pop     edi
        ret
@@:
        mov     ebx, [ebx]
.l1:
        push    ecx edx
        push    0
        mov     eax, [edi+28]
        sub     eax, ebx
        jb      .eof
        cmp     eax, ecx
        jae     @f
        mov     ecx, eax
        mov     byte [esp], 6           ; EOF
@@:
        movzx   edi, word [edi+26]	; cluster
.new:
        jecxz   .done
        test    edi, edi
        jz      .eof
        cmp     edi, 0xFF8
        jae     .eof
        lea     eax, [edi+31]           ; bootsector+2*fat+filenames
        shl     eax, 9                  ; *512
        add     eax, RAMDISK           ; image base
; now eax points to data of cluster
        sub     ebx, 512
        jae     .skip
        lea     eax, [eax+ebx+512]
        neg     ebx
        push    ecx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        mov     ebx, edx
        call    memmove
        add     edx, ecx
        sub     [esp], ecx
        pop     ecx
        xor     ebx, ebx
.skip:
        movzx   edi, word [edi*2+RAMDISK_FAT]      ; find next cluster from FAT
        jmp     .new
.eof:
        mov     ebx, edx
        pop     eax edx ecx
        sub     ebx, edx
        jmp     .reteof
.done:
        mov     ebx, edx
        pop     eax edx ecx edi
        sub     ebx, edx
        ret
 
;----------------------------------------------------------------
;
;  fs_RamdiskReadFolder - LFN variant for reading sys floppy folder
;
;  esi  points to filename; only root is folder on ramdisk
;  ebx  pointer to structure 32-bit number = first wanted block
;                          & flags (bitfields)
; flags: bit 0: 0=ANSI names, 1=UNICODE names
;  ecx  number of blocks to read, 0+
;  edx  mem location to return data
;
;  ret ebx = size or 0xffffffff file not found
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
fs_RamdiskReadFolder:
        push    edi
        cmp     byte [esi], 0
        jz      .root
        call    rd_find_lfn
        jnc     .found
        pop     edi
        or      ebx, -1
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
.found:
        test    byte [edi+11], 0x10
        jnz     .found_dir
        pop     edi
        or      ebx, -1
        mov     eax, ERROR_ACCESS_DENIED
        ret
.found_dir:
        movzx   eax, word [edi+26]
        add     eax, 31
        push    0
        jmp     .doit
.root:
        mov     eax, 19
        push    14
.doit:
        push    esi ecx ebp
        sub     esp, 262*2      ; reserve space for LFN
        mov     ebp, esp
        push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE names
        mov     ebx, [ebx]
; init header
        push    eax ecx
        mov     edi, edx
        mov     ecx, 32/4
        xor     eax, eax
        rep     stosd
        mov     byte [edx], 1   ; version
        pop     ecx eax
        mov     esi, edi        ; esi points to block of data of folder entry (BDFE)
.main_loop:
        mov     edi, eax
        shl     edi, 9
        add     edi, RAMDISK
        push    eax
.l1:
        call    fat_get_name
        jc      .l2
        cmp     byte [edi+11], 0xF
        jnz     .do_bdfe
        add     edi, 0x20
        test    edi, 0x1FF
        jnz     .do_bdfe
        pop     eax
        inc     eax
        dec     byte [esp+262*2+16]
        jz      .done
        jns     @f
; read next sector from FAT
        mov     eax, [(eax-31-1)*2+RAMDISK_FAT]
        and     eax, 0xFFF
        cmp     eax, 0xFF8
        jae     .done
        add     eax, 31
        mov     byte [esp+262*2+16], 0
@@:
        mov     edi, eax
        shl     edi, 9
        add     edi, RAMDISK
        push    eax
.do_bdfe:
        inc     dword [edx+8]   ; new file found
        dec     ebx
        jns     .l2
        dec     ecx
        js      .l2
        inc     dword [edx+4]  ; new file block copied
        call    fat_entry_to_bdfe
.l2:
        add     edi, 0x20
        test    edi, 0x1FF
        jnz     .l1
        pop     eax
        inc     eax
        dec     byte [esp+262*2+16]
        jz      .done
        jns     @f
; read next sector from FAT
        mov     eax, [(eax-31-1)*2+RAMDISK_FAT]
        and     eax, 0xFFF
        cmp     eax, 0xFF8
        jae     .done
        add     eax, 31
        mov     byte [esp+262*2+16], 0
@@:
        jmp     .main_loop
.done:
        add     esp, 262*2+4
        pop     ebp
        mov     ebx, [edx+4]
        xor     eax, eax
        dec     ecx
        js      @f
        mov     al, ERROR_END_OF_FILE
@@:
        pop     ecx esi edi edi
        ret
 
iglobal
label fat_legal_chars byte
; 0 = not allowed
; 1 = allowed only in long names
; 3 = allowed
        times 32 db 0
;                 ! " # $ % & ' ( ) * + , - . /
        db      1,3,0,3,3,3,3,3,3,3,0,1,1,3,3,0
;               0 1 2 3 4 5 6 7 8 9 : ; < = > ?
        db      3,3,3,3,3,3,3,3,3,3,0,1,0,1,0,0
;               @ A B C D E F G H I J K L M N O
        db      3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
;               P Q R S T U V W X Y Z [ \ ] ^ _
        db      3,3,3,3,3,3,3,3,3,3,3,1,0,1,3,3
;               ` a b c d e f g h i j k l m n o
        db      3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3
;               p q r s t u v w x y z { | } ~
        db      3,3,3,3,3,3,3,3,3,3,3,3,0,3,3,0
endg
 
fat_name_is_legal:
; in: esi->(long) name
; out: CF set <=> legal
; destroys eax
        push    esi
        xor     eax, eax
@@:
        lodsb
        test    al, al
        jz      .done
        cmp     al, 80h
        jae     .big
        test    [fat_legal_chars+eax], 1
        jnz     @b
.err:
        pop     esi
        clc
        ret
.big:
; 0x80-0xAF, 0xE0-0xEF
        cmp     al, 0xB0
        jb      @b
        cmp     al, 0xE0
        jb      .err
        cmp     al, 0xF0
        jb      @b
        jmp     .err
.done:
        sub     esi, [esp]
        cmp     esi, 257
        pop     esi
        ret
 
fat_next_short_name:
; in: edi->8+3 name
; out: name corrected
;      CF=1 <=> error
        pushad
        mov     ecx, 8
        mov     al, '~'
        std
        push    edi
        add     edi, 7
        repnz   scasb
        pop     edi
        cld
        jz      .tilde
; tilde is not found, insert "~1" at end
        add     edi, 6
        cmp     word [edi], '  '
        jnz     .insert_tilde
@@:     dec     edi
        cmp     byte [edi], ' '
        jz      @b
        inc     edi
.insert_tilde:
        mov     word [edi], '~1'
        popad
        clc
        ret
.tilde:
        push    edi
        add     edi, 7
        xor     ecx, ecx
@@:
; after tilde may be only digits and trailing spaces
        cmp     byte [edi], '~'
        jz      .break
        cmp     byte [edi], ' '
        jz      .space
        cmp     byte [edi], '9'
        jnz     .found
        dec     edi
        jmp     @b
.space:
        dec     edi
        inc     ecx
        jmp     @b
.found:
        inc     byte [edi]
        add     dword [esp], 8
        jmp     .zerorest
.break:
        jecxz   .noplace
        inc     edi
        mov     al, '1'
@@:
        xchg    al, [edi]
        inc     edi
        cmp     al, ' '
        mov     al, '0'
        jnz     @b
.succ:
        pop     edi
        popad
        clc
        ret
.noplace:
        dec     edi
        cmp     edi, [esp]
        jz      .err
        add     dword [esp], 8
        mov     word [edi], '~1'
        inc     edi
        inc     edi
@@:
        mov     byte [edi], '0'
.zerorest:
        inc     edi
        cmp     edi, [esp]
        jb      @b
        pop     edi
        popad
        ;clc    ; automatically
        ret
.err:
        pop     edi
        popad
        stc
        ret
 
fat_gen_short_name:
; in: esi->long name
;     edi->buffer (8+3=11 chars)
; out: buffer filled
        pushad
        mov     eax, '    '
        push    edi
        stosd
        stosd
        stosd
        pop     edi
        xor     eax, eax
        push    8
        pop     ebx
        lea     ecx, [edi+8]
.loop:
        lodsb
        test    al, al
        jz      .done
        call    char_toupper
        cmp     al, ' '
        jz      .space
        cmp     al, 80h
        ja      .big
        test    [fat_legal_chars+eax], 2
        jnz     .symbol
.inv_symbol:
        mov     al, '_'
        or      bh, 1
.symbol:
        cmp     al, '.'
        jz      .dot
.normal_symbol:
        dec     bl
        jns     .store
        mov     bl, 0
.space:
        or      bh, 1
        jmp     .loop
.store:
        stosb
        jmp     .loop
.big:
        cmp     al, 0xB0
        jb      .normal_symbol
        cmp     al, 0xE0
        jb      .inv_symbol
        cmp     al, 0xF0
        jb      .normal_symbol
        jmp     .inv_symbol
.dot:
        test    bh, 2
        jz      .firstdot
        pop     ebx
        add     ebx, edi
        sub     ebx, ecx
        push    ebx
        cmp     ebx, ecx
        jb      @f
        pop     ebx
        push    ecx
@@:
        cmp     edi, ecx
        jbe     .skip
@@:
        dec     edi
 
        mov     al, [edi]
        dec     ebx
        mov     [ebx], al
        mov     byte [edi], ' '
        cmp     edi, ecx
        ja      @b
.skip:
        mov     bh, 3
        jmp     @f
.firstdot:
        cmp     bl, 8
        jz      .space
        push    edi
        or      bh, 2
@@:
        mov     edi, ecx
        mov     bl, 3
        jmp     .loop
.done:
        test    bh, 2
        jz      @f
        pop     edi
@@:
        lea     edi, [ecx-8]
        test    bh, 1
        jz      @f
        call    fat_next_short_name
@@:
        popad
        ret
 
;----------------------------------------------------------------
;
;  fs_RamdiskRewrite - LFN variant for writing ramdisk
;  fs_RamdiskCreateFolder - create folder on ramdisk
;
;  esi  points to file/folder name
;  ebx  ignored (reserved)
;  ecx  number of bytes to write, 0+ (ignored for folders)
;  edx  mem location to data (ignored for folders)
;
;  ret ebx = number of written bytes
;      eax = 0 ok read or other = errormsg
;
;--------------------------------------------------------------
@@:
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
 
fs_RamdiskCreateFolder:
        mov     al, 1           ; create folder
        jmp     fs_RamdiskRewrite.common
 
fs_RamdiskRewrite:
        xor     eax, eax        ; create file
.common:
        cmp     byte [esi], 0
        jz      @b
        pushad
        xor     edi, edi
        push    esi
        test    ebp, ebp
        jz      @f
        mov     esi, ebp
@@:
        lodsb
        test    al, al
        jz      @f
        cmp     al, '/'
        jnz     @b
        lea     edi, [esi-1]
        jmp     @b
@@:
        pop     esi
        test    edi, edi
        jnz     .noroot
        test    ebp, ebp
        jnz     .hasebp
        push    ramdisk_root_extend_dir
        push    ramdisk_root_next_write
        push    edi
        push    ramdisk_root_first
        push    ramdisk_root_next
        jmp     .common1
.hasebp:
        mov     eax, ERROR_ACCESS_DENIED
        cmp     byte [ebp], 0
        jz      .ret1
        push    ebp
        xor     ebp, ebp
        call    rd_find_lfn
        pop     esi
        jc      .notfound0
        jmp     .common0
.noroot:
        mov     eax, ERROR_ACCESS_DENIED
        cmp     byte [edi+1], 0
        jz      .ret1
; check existence
        mov     byte [edi], 0
        push    edi
        call    rd_find_lfn
        pop     esi
        mov     byte [esi], '/'
        jnc     @f
.notfound0:
        mov     eax, ERROR_FILE_NOT_FOUND
.ret1:
        mov     [esp+28], eax
        popad
        xor     ebx, ebx
        ret
@@:
        inc     esi
.common0:
        test    byte [edi+11], 0x10     ; must be directory
        mov     eax, ERROR_ACCESS_DENIED
        jz      .ret1
        movzx   ebp, word [edi+26]      ; ebp=cluster
        mov     eax, ERROR_FAT_TABLE
        cmp     ebp, 2
        jb      .ret1
        cmp     ebp, 2849
        jae     .ret1
        push    ramdisk_notroot_extend_dir
        push    ramdisk_notroot_next_write
        push    ebp
        push    ramdisk_notroot_first
        push    ramdisk_notroot_next
.common1:
        call    fat_find_lfn
        jc      .notfound
; 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, 20
        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+20+28], 0
        jz      @f
        add     esp, 20
        popad
        mov     eax, ERROR_ACCESS_DENIED
        xor     ebx, ebx
        ret
@@:
; delete FAT chain
        push    edi
        xor     eax, eax
        mov     dword [edi+28], eax     ; zero size
        xchg    ax, word [edi+26]       ; start cluster
        test    eax, eax
        jz      .done1
@@:
        cmp     eax, 0xFF8
        jae     .done1
        lea     edi, [RAMDISK_FAT + eax*2] ; position in FAT
        xor     eax, eax
        xchg    ax, [edi]
        jmp     @b
.done1:
        pop     edi
        call    get_time_for_file
        mov     [edi+22], ax
        call    get_date_for_file
        mov     [edi+24], ax
        mov     [edi+18], ax
        or      byte [edi+11], 20h      ; set 'archive' attribute
        jmp     .doit
.notfound:
; file is not found; generate short name
        call    fat_name_is_legal
        jc      @f
        add     esp, 20
        popad
        mov     eax, ERROR_FILE_NOT_FOUND
        xor     ebx, ebx
        ret
@@:
        sub     esp, 12
        mov     edi, esp
        call    fat_gen_short_name
.test_short_name_loop:
        push    esi edi ecx
        mov     esi, edi
        lea     eax, [esp+12+12+8]
        mov     [eax], ebp
        call    dword [eax-4]
        jc      .found
.test_short_name_entry:
        cmp     byte [edi+11], 0xF
        jz      .test_short_name_cont
        mov     ecx, 11
        push    esi edi
        repz    cmpsb
        pop     edi esi
        jz      .short_name_found
.test_short_name_cont:
        lea     eax, [esp+12+12+8]
        call    dword [eax-8]
        jnc     .test_short_name_entry
        jmp     .found
.short_name_found:
        pop     ecx edi esi
        call    fat_next_short_name
        jnc     .test_short_name_loop
.disk_full:
        add     esp, 12+20
        popad
        mov     eax, ERROR_DISK_FULL
        xor     ebx, ebx
        ret
.found:
        pop     ecx edi esi
; now find space in directory
; we need to save LFN <=> LFN is not equal to short name <=> generated name contains '~'
        mov     al, '~'
        push    ecx edi
        mov     ecx, 8
        repnz   scasb
        push    1
        pop     eax     ; 1 entry
        jnz     .notilde
; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
        xor     eax, eax
@@:
        cmp     byte [esi], 0
        jz      @f
        inc     esi
        inc     eax
        jmp     @b
@@:
        sub     esi, eax
        add     eax, 12+13
        mov     ecx, 13
        push    edx
        cdq
        div     ecx
        pop     edx
.notilde:
        push    -1
        push    -1
; find  successive entries in directory
        xor     ecx, ecx
        push    eax
        lea     eax, [esp+12+8+12+8]
        mov     [eax], ebp
        call    dword [eax-4]
        pop     eax
.scan_dir:
        cmp     byte [edi], 0
        jz      .free
        cmp     byte [edi], 0xE5
        jz      .free
        xor     ecx, ecx
.scan_cont:
        push    eax
        lea     eax, [esp+12+8+12+8]
        call    dword [eax-8]
        pop     eax
        jnc     .scan_dir
        push    eax
        lea     eax, [esp+12+8+12+8]
        call    dword [eax+8]           ; extend directory
        pop     eax
        jnc     .scan_dir
        add     esp, 8+8+12+20
        popad
        mov     eax, ERROR_DISK_FULL
        xor     ebx, ebx
        ret
.free:
        test    ecx, ecx
        jnz     @f
        mov     [esp], edi
        mov     ecx, [esp+8+8+12+8]
        mov     [esp+4], ecx
        xor     ecx, ecx
@@:
        inc     ecx
        cmp     ecx, eax
        jb      .scan_cont
; found!
; calculate name checksum
        push    esi ecx
        mov     esi, [esp+8+8]
        mov     ecx, 11
        xor     eax, eax
@@:
        ror     al, 1
        add     al, [esi]
        inc     esi
        loop    @b
        pop     ecx esi
        pop     edi
        pop     dword [esp+8+12+8]
; edi points to last entry in free chunk
        dec     ecx
        jz      .nolfn
        push    esi
        push    eax
        mov     al, 40h
.writelfn:
        or      al, cl
        mov     esi, [esp+4]
        push    ecx
        dec     ecx
        imul    ecx, 13
        add     esi, ecx
        stosb
        mov     cl, 5
        call    .read_symbols
        mov     ax, 0xF
        stosw
        mov     al, [esp+4]
        stosb
        mov     cl, 6
        call    .read_symbols
        xor     eax, eax
        stosw
        mov     cl, 2
        call    .read_symbols
        pop     ecx
        lea     eax, [esp+8+8+12+8]
        call    dword [eax+4]   ; next write
        xor     eax, eax
        loop    .writelfn
        pop     eax
        pop     esi
.nolfn:
        xchg    esi, [esp]
        mov     ecx, 11
        rep     movsb
        mov     word [edi], 20h         ; attributes
        sub     edi, 11
        pop     esi ecx
        add     esp, 12
        mov     byte [edi+13], 0        ; tenths of a second at file creation time
        call    get_time_for_file
        mov     [edi+14], ax            ; creation time
        mov     [edi+22], ax            ; last write time
        call    get_date_for_file
        mov     [edi+16], ax            ; creation date
        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+20+28], 0
        jz      .doit
; create directory
        mov     byte [edi+11], 10h         ; attributes: folder
        mov     ecx, 32*2
        mov     edx, edi
.doit:
        push    edx
        push    ecx
        push    edi
        add     edi, 26         ; edi points to low word of cluster
        push    edi
        jecxz   .done
        mov     ecx, 2849
        mov     edi, RAMDISK_FAT
.write_loop:
; allocate new cluster
        xor     eax, eax
        repnz   scasw
        jnz     .disk_full2
        dec     edi
        dec     edi
 
    ;    lea     eax, [edi-(RAMDISK_FAT)]
 
        mov eax, edi
        sub eax, RAMDISK_FAT
 
        shr     eax, 1                  ; eax = cluster
        mov     word [edi], 0xFFF       ; mark as last cluster
        xchg    edi, [esp]
        stosw
        pop     edi
        push    edi
        inc     ecx
; write data
        cmp     byte [esp+16+20+28], 0
        jnz     .writedir
        shl     eax, 9
        add     eax, RAMDISK+31*512
.writefile:
        mov     ebx, edx
        xchg    eax, ebx
        push    ecx
        mov     ecx, 512
        cmp     dword [esp+12], ecx
        jae     @f
        mov     ecx, [esp+12]
@@:
        call    memmove
        add     edx, ecx
        sub     [esp+12], ecx
        pop     ecx
        jnz     .write_loop
.done:
        mov     ebx, edx
        pop     edi edi ecx edx
        sub     ebx, edx
        mov     [edi+28], ebx
        add     esp, 20
        mov     [esp+16], ebx
        popad
        xor     eax, eax
        ret
.disk_full2:
        mov     ebx, edx
        pop     edi edi ecx edx
        sub     ebx, edx
        mov     [edi+28], ebx
        add     esp, 20
        mov     [esp+16], ebx
        popad
        push    ERROR_DISK_FULL
        pop     eax
        ret
.writedir:
        mov     edi, eax
        shl     edi, 9
        add     edi, RAMDISK+31*512
        mov     esi, edx
        mov     ecx, 32/4
        push    ecx
        rep     movsd
        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
        mov     esi, edx
        pop     ecx
        rep     movsd
        mov     dword [edi-32], '..  '
        mov     dword [edi-32+4], '    '
        mov     dword [edi-32+8], '    '
        mov     byte [edi-32+11], 10h
        mov     eax, [esp+16+8]
        mov     word [edi-32+26], ax
        xor     eax, eax
        mov     ecx, (512-32*2)/4
        rep     stosd
        pop     edi edi ecx edx
        add     esp, 20
        popad
        xor     eax, eax
        xor     ebx, ebx
        ret
 
.read_symbol:
        or      ax, -1
        test    esi, esi
        jz      .retFFFF
        lodsb
        test    al, al
        jnz     ansi2uni_char
        xor     eax, eax
        xor     esi, esi
.retFFFF:
        ret
 
.read_symbols:
        call    .read_symbol
        stosw
        loop    .read_symbols
        ret
 
;----------------------------------------------------------------
;
;  fs_RamdiskWrite - LFN variant for writing to sys floppy
;
;  esi  points to filename
;  ebx  pointer to 64-bit number = first wanted byte, 0+
;       may be ebx=0 - start from first byte
;  ecx  number of bytes to write, 0+
;  edx  mem location to data
;
;  ret ebx = bytes written (maybe 0)
;      eax = 0 ok write or other = errormsg
;
;--------------------------------------------------------------
@@:
        push    ERROR_ACCESS_DENIED
fs_RamdiskWrite.ret0:
        pop     eax
        xor     ebx, ebx
        ret
 
fs_RamdiskWrite:
        cmp     byte [esi], 0
        jz      @b
        pushad
        call    rd_find_lfn
        jnc     .found
        popad
        push    ERROR_FILE_NOT_FOUND
        jmp     .ret0
.found:
; must not be directory
        test    byte [edi+11], 10h
        jz      @f
        popad
        push    ERROR_ACCESS_DENIED
        jmp     .ret0
@@:
; FAT does not support files larger than 4GB
        test    ebx, ebx
        jz      .l1
        cmp     dword [ebx+4], 0
        jz      @f
.eof:
        popad
        push    ERROR_END_OF_FILE
        jmp     .ret0
@@:
        mov     ebx, [ebx]
.l1:
; now edi points to direntry, ebx=start byte to write,
; ecx=number of bytes to write, edx=data pointer
        call    fat_update_datetime
 
; extend file if needed
        add     ecx, ebx
        jc      .eof    ; FAT does not support files larger than 4GB
        push    0       ; return value=0
        cmp     ecx, [edi+28]
        jbe     .length_ok
        cmp     ecx, ebx
        jz      .length_ok
        call    ramdisk_extend_file
        jnc     .length_ok
; ramdisk_extend_file can return two error codes: FAT table error or disk full.
; First case is fatal error, in second case we may write some data
        mov     [esp], eax
        cmp     al, ERROR_DISK_FULL
        jz      .disk_full
        pop     eax
        mov     [esp+28], eax
        popad
        xor     ebx, ebx
        ret
.disk_full:
; correct number of bytes to write
        mov     ecx, [edi+28]
        cmp     ecx, ebx
        ja      .length_ok
.ret:
        pop     eax
        mov     [esp+28], eax   ; eax=return value
        sub     edx, [esp+20]
        mov     [esp+16], edx   ; ebx=number of written bytes
        popad
        ret
.length_ok:
; now ebx=start pos, ecx=end pos, both lie inside file
        sub     ecx, ebx
        jz      .ret
        movzx   edi, word [edi+26]      ; starting cluster
.write_loop:
        sub     ebx, 0x200
        jae     .next_cluster
        push    ecx
        neg     ebx
        cmp     ecx, ebx
        jbe     @f
        mov     ecx, ebx
@@:
        mov     eax, edi
        shl     eax, 9
        add     eax, RAMDISK+31*512+0x200
        sub     eax, ebx
        mov     ebx, eax
        mov     eax, edx
        call    memmove
        xor     ebx, ebx
        add     edx, ecx
        sub     [esp], ecx
        pop     ecx
        jz      .ret
.next_cluster:
        movzx   edi, word [edi*2+RAMDISK_FAT]
        jmp     .write_loop
 
ramdisk_extend_file.zero_size:
        xor     eax, eax
        jmp     ramdisk_extend_file.start_extend
 
; extends file on ramdisk to given size, new data area is filled by 0
; in: edi->direntry, ecx=new size
; out: CF=0 => OK, eax=0
;      CF=1 => error, eax=code (ERROR_FAT_TABLE or ERROR_DISK_FULL)
ramdisk_extend_file:
        push    ecx
; find the last cluster of file
        movzx   eax, word [edi+26]      ; first cluster
        mov     ecx, [edi+28]
        jecxz   .zero_size
@@:
        sub     ecx, 0x200
        jbe     @f
        mov     eax, [eax*2+RAMDISK_FAT]
        and     eax, 0xFFF
        jz      .fat_err
        cmp     eax, 0xFF8
        jb      @b
.fat_err:
        pop     ecx
        push    ERROR_FAT_TABLE
        pop     eax
        stc
        ret
@@:
        push    eax
        mov     eax, [eax*2+RAMDISK_FAT]
        and     eax, 0xFFF
        cmp     eax, 0xFF8
        pop     eax
        jb      .fat_err
; set length to full number of sectors and make sure that last sector is zero-padded
        sub     [edi+28], ecx
        push    eax edi
        mov     edi, eax
        shl     edi, 9
        lea     edi, [edi+RAMDISK+31*512+0x200+ecx]
        neg     ecx
        xor     eax, eax
        rep     stosb
        pop     edi eax
.start_extend:
        pop     ecx
; now do extend
        push    edx esi
        mov     esi, RAMDISK_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
        push    ecx
        mov     ecx, edx
        push    edi
        mov     edi, esi
        jecxz   .disk_full
        push    eax
        xor     eax, eax
        repnz   scasw
        pop     eax
        jnz     .disk_full
        mov     word [edi-2], 0xFFF
        mov     esi, edi
        mov     edx, ecx
        sub     edi, RAMDISK_FAT
        shr     edi, 1
        dec     edi     ; now edi=new cluster
        test    eax, eax
        jz      .first_cluster
        mov     [RAMDISK_FAT+eax*2], di
        jmp     @f
.first_cluster:
        pop     eax     ; eax->direntry
        push    eax
        mov     [eax+26], di
@@:
        push    edi
        shl     edi, 9
        add     edi, RAMDISK+31*512
        xor     eax, eax
        mov     ecx, 512/4
        rep     stosd
        pop     eax     ; eax=new cluster
        pop     edi     ; edi->direntry
        pop     ecx     ; ecx=required size
        add     dword [edi+28], 0x200
        jmp     .extend_loop
.extend_done:
        mov     [edi+28], ecx
        pop     esi edx
        xor     eax, eax        ; CF=0
        ret
.disk_full:
        pop     edi ecx
        pop     esi edx
        stc
        push    ERROR_DISK_FULL
        pop     eax
        ret
 
fat_update_datetime:
        call    get_time_for_file
        mov     [edi+22], ax            ; last write time
        call    get_date_for_file
        mov     [edi+24], ax            ; last write date
        mov     [edi+18], ax            ; last access date
        ret
 
;----------------------------------------------------------------
;
;  fs_RamdiskSetFileEnd - set end of file on ramdisk
;
;  esi  points to filename
;  ebx  points to 64-bit number = new file size
;  ecx  ignored (reserved)
;  edx  ignored (reserved)
;
;  ret eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
fs_RamdiskSetFileEnd:
        cmp     byte [esi], 0
        jnz     @f
.access_denied:
        push    ERROR_ACCESS_DENIED
        jmp     .ret
@@:
        push    edi
        call    rd_find_lfn
        jnc     @f
        pop     edi
        push    ERROR_FILE_NOT_FOUND
.ret:
        pop     eax
        ret
@@:
; must not be directory
        test    byte [edi+11], 10h
        jz      @f
        pop     edi
        jmp     .access_denied
@@:
; file size must not exceed 4Gb
        cmp     dword [ebx+4], 0
        jz      @f
        pop     edi
        push    ERROR_END_OF_FILE
        jmp     .ret
@@:
; set file modification date/time to current
        call    fat_update_datetime
        mov     eax, [ebx]
        cmp     eax, [edi+28]
        jb      .truncate
        ja      .expand
        pop     edi
        xor     eax, eax
        ret
.expand:
        push    ecx
        mov     ecx, eax
        call    ramdisk_extend_file
        pop     ecx
        pop     edi
        ret
.truncate:
        mov     [edi+28], eax
        push    ecx
        movzx   ecx, word [edi+26]
        test    eax, eax
        jz      .zero_size
; find new last sector
@@:
        sub     eax, 0x200
        jbe     @f
        movzx   ecx, word [RAMDISK_FAT+ecx*2]
        jmp     @b
@@:
; zero data at the end of last sector
        push    ecx
        mov     edi, ecx
        shl     edi, 9
        lea     edi, [edi+RAMDISK+31*512+eax+0x200]
        mov     ecx, eax
        neg     ecx
        xor     eax, eax
        rep     stosb
        pop     ecx
; terminate FAT chain
        lea     ecx, [RAMDISK_FAT+ecx+ecx]
        push    dword [ecx]
        mov     word [ecx], 0xFFF
        pop     ecx
        and     ecx, 0xFFF
        jmp     .delete
.zero_size:
        and     word [edi+26], 0
.delete:
; delete FAT chain starting with ecx
; mark all clusters as free
        cmp     ecx, 0xFF8
        jae     .deleted
        lea     ecx, [RAMDISK_FAT+ecx+ecx]
        push    dword [ecx]
        and     word [ecx], 0
        pop     ecx
        and     ecx, 0xFFF
        jmp     .delete
.deleted:
        pop     ecx
        pop     edi
        xor     eax, eax
        ret
 
fs_RamdiskGetFileInfo:
        cmp     byte [esi], 0
        jnz     @f
        mov     eax, 2  ; unsupported
        ret
@@:
        push    edi
        call    rd_find_lfn
fs_GetFileInfo_finish:
        jnc     @f
        pop     edi
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
@@:
        push    esi ebp
        xor     ebp, ebp
        mov     esi, edx
        and     dword [esi+4], 0
        call    fat_entry_to_bdfe2
        pop     ebp esi
        pop     edi
        xor     eax, eax
        ret
 
fs_RamdiskSetFileInfo:
        cmp     byte [esi], 0
        jnz     @f
        mov     eax, 2  ; unsupported
        ret
@@:
        push    edi
        call    rd_find_lfn
        jnc     @f
        pop     edi
        mov     eax, ERROR_FILE_NOT_FOUND
        ret
@@:
        call    bdfe_to_fat_entry
        pop     edi
        xor     eax, eax
        ret
 
;----------------------------------------------------------------
;
;  fs_RamdiskDelete - delete file or empty folder from ramdisk
;
;  esi  points to filename
;
;  ret  eax = 0 ok or other = errormsg
;
;--------------------------------------------------------------
fs_RamdiskDelete:
        cmp     byte [esi], 0
        jnz     @f
; cannot delete root!
.access_denied:
        push    ERROR_ACCESS_DENIED
.pop_ret:
        pop     eax
        ret
@@:
        and     [rd_prev_sector], 0
        and     [rd_prev_prev_sector], 0
        push    edi
        call    rd_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!
        movzx   eax, word [edi+26]
        push    ebx
        mov     ebx, eax
        shl     ebx, 9
        add     ebx, RAMDISK + 31*0x200 + 2*0x20
.checkempty:
        cmp     byte [ebx], 0
        jz      .empty
        cmp     byte [ebx], 0xE5
        jnz     .notempty
        add     ebx, 0x20
        test    ebx, 0x1FF
        jnz     .checkempty
        movzx   eax, word [RAMDISK_FAT + eax*2]
        test    eax, eax
        jz      .empty
        mov     ebx, eax
        shl     ebx, 9
        add     ebx, RAMDISK + 31*0x200
        jmp     .checkempty
.notempty:
        pop     ebx
.access_denied2:
        pop     edi
        jmp     .access_denied
.empty:
        pop     ebx
.dodel:
        movzx   eax, word [edi+26]
; delete folder entry
        mov     byte [edi], 0xE5
; delete LFN (if present)
.lfndel:
        test    edi, 0x1FF
        jnz     @f
        cmp     [rd_prev_sector], 0
        jz      @f
        cmp     [rd_prev_sector], -1
        jz      .lfndone
        mov     edi, [rd_prev_sector]
        push    [rd_prev_prev_sector]
        pop     [rd_prev_sector]
        or      [rd_prev_prev_sector], -1
        shl     edi, 9
        add     edi, RAMDISK + 31*0x200 + 0x200
@@:
        sub     edi, 0x20
        cmp     byte [edi], 0xE5
        jz      .lfndone
        cmp     byte [edi+11], 0xF
        jnz     .lfndone
        mov     byte [edi], 0xE5
        jmp     .lfndel
.lfndone:
; delete FAT chain
        test    eax, eax
        jz      .done
        lea     eax, [RAMDISK_FAT + eax*2]
        push    dword [eax]
        and     word [eax], 0
        pop     eax
        and     eax, 0xFFF
        jmp     .lfndone
.done:
        pop     edi
        xor     eax, eax
        ret
 
; \end{diamond}

Rev 521	Rev 527
1	$Revision: 521 $	1	$Revision: 527 $
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3	;; ;;	3	;; ;;
4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
5	;; Distributed under terms of the GNU General Public License ;;	5	;; Distributed under terms of the GNU General Public License ;;
6	;; ;;	6	;; ;;
7	;; RAMDISK functions ;;	7	;; RAMDISK functions ;;
8	;; (C) 2004 Ville Turjanmaa, License: GPL ;;	8	;; (C) 2004 Ville Turjanmaa, License: GPL ;;
9	;; Addings by M.Lisovin ;;	9	;; Addings by M.Lisovin ;;
10	;; LFN support by diamond ;;	10	;; LFN support by diamond ;;
11	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	11	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
12		12
13	; calculate fat chain	13	; calculate fat chain
14		14
15	calculatefatchain:	15	calculatefatchain:
16		16
17	pushad	17	pushad
18		18
19	mov esi,RAMDISK+512	19	mov esi,RAMDISK+512
20	mov edi,RAMDISK_FAT	20	mov edi,RAMDISK_FAT
21		21
22	fcnew:	22	fcnew:
23	mov eax,dword [esi]	23	mov eax,dword [esi]
24	mov ebx,dword [esi+4]	24	mov ebx,dword [esi+4]
25	mov ecx,dword [esi+8]	25	mov ecx,dword [esi+8]
26	mov edx,ecx	26	mov edx,ecx
27	shr edx,4 ;8 ok	27	shr edx,4 ;8 ok
28	shr dx,4 ;7 ok	28	shr dx,4 ;7 ok
29	xor ch,ch	29	xor ch,ch
30	shld ecx,ebx,20 ;6 ok	30	shld ecx,ebx,20 ;6 ok
31	shr cx,4 ;5 ok	31	shr cx,4 ;5 ok
32	shld ebx,eax,12	32	shld ebx,eax,12
33	and ebx,0x0fffffff ;4 ok	33	and ebx,0x0fffffff ;4 ok
34	shr bx,4 ;3 ok	34	shr bx,4 ;3 ok
35	shl eax,4	35	shl eax,4
36	and eax,0x0fffffff ;2 ok	36	and eax,0x0fffffff ;2 ok
37	shr ax,4 ;1 ok	37	shr ax,4 ;1 ok
38	mov dword [edi],eax	38	mov dword [edi],eax
39	mov dword [edi+4],ebx	39	mov dword [edi+4],ebx
40	mov dword [edi+8],ecx	40	mov dword [edi+8],ecx
41	mov dword [edi+12],edx	41	mov dword [edi+12],edx
42	add edi,16	42	add edi,16
43	add esi,12	43	add esi,12
44		44
45	cmp edi,RAMDISK_FAT+2856*2 ;2849 clusters	45	cmp edi,RAMDISK_FAT+2856*2 ;2849 clusters
46	jnz fcnew	46	jnz fcnew
47		47
48	popad	48	popad
49	ret	49	ret
50		50
51		51
52	restorefatchain: ; restore fat chain	52	restorefatchain: ; restore fat chain
53		53
54	pushad	54	pushad
55		55
56	mov esi,RAMDISK_FAT	56	mov esi,RAMDISK_FAT
57	mov edi,RAMDISK+512	57	mov edi,RAMDISK+512
58		58
59	fcnew2:	59	fcnew2:
60	mov eax,dword [esi]	60	mov eax,dword [esi]
61	mov ebx,dword [esi+4]	61	mov ebx,dword [esi+4]
62	shl ax,4	62	shl ax,4
63	shl eax,4	63	shl eax,4
64	shl bx,4	64	shl bx,4
65	shr ebx,4	65	shr ebx,4
66	shrd eax,ebx,8	66	shrd eax,ebx,8
67	shr ebx,8	67	shr ebx,8
68	mov dword [edi],eax	68	mov dword [edi],eax
69	mov word [edi+4],bx	69	mov word [edi+4],bx
70	add edi,6	70	add edi,6
71	add esi,8	71	add esi,8
72		72
73	cmp edi,RAMDISK+512+4278 ;4274 bytes - all used FAT	73	cmp edi,RAMDISK+512+4278 ;4274 bytes - all used FAT
74	jb fcnew2	74	jb fcnew2
75		75
76	mov esi,RAMDISK+512 ; duplicate fat chain	76	mov esi,RAMDISK+512 ; duplicate fat chain
77	mov edi,RAMDISK+512+0x1200	77	mov edi,RAMDISK+512+0x1200
78	mov ecx,1069 ;4274/4	78	mov ecx,1069 ;4274/4
79	cld	79	cld
80	rep movsd	80	rep movsd
81		81
82	popad	82	popad
83	ret	83	ret
84		84
85		85
86	ramdisk_free_space:	86	ramdisk_free_space:
87	;---------------------------------------------	87	;---------------------------------------------
88	;	88	;
89	; returns free space in edi	89	; returns free space in edi
90	; rewr.by Mihasik	90	; rewr.by Mihasik
91	;---------------------------------------------	91	;---------------------------------------------
92		92
93	push eax ebx ecx	93	push eax ebx ecx
94		94
95	mov edi,RAMDISK_FAT ;start of FAT	95	mov edi,RAMDISK_FAT ;start of FAT
96	xor ax,ax ;Free cluster=0x0000 in FAT	96	xor ax,ax ;Free cluster=0x0000 in FAT
97	xor ebx,ebx ;counter	97	xor ebx,ebx ;counter
98	mov ecx,2849 ;2849 clusters	98	mov ecx,2849 ;2849 clusters
99	cld	99	cld
100	rdfs1:	100	rdfs1:
101	repne scasw	101	repne scasw
102	jnz rdfs2 ;if last cluster not 0	102	jnz rdfs2 ;if last cluster not 0
103	inc ebx	103	inc ebx
104	test ecx, ecx	104	test ecx, ecx
105	jnz rdfs1	105	jnz rdfs1
106	rdfs2:	106	rdfs2:
107	shl ebx,9 ;free clusters*512	107	shl ebx,9 ;free clusters*512
108	mov edi,ebx	108	mov edi,ebx
109		109
110	pop ecx ebx eax	110	pop ecx ebx eax
111	ret	111	ret
112		112
113		113
114	expand_filename:	114	expand_filename:
115	;---------------------------------------------	115	;---------------------------------------------
116	;	116	;
117	; exapand filename with '.' to 11 character	117	; exapand filename with '.' to 11 character
118	; eax - pointer to filename	118	; eax - pointer to filename
119	;---------------------------------------------	119	;---------------------------------------------
120		120
121	push esi edi ebx	121	push esi edi ebx
122		122
123	mov edi,esp ; check for '.' in the name	123	mov edi,esp ; check for '.' in the name
124	add edi,12+8	124	add edi,12+8
125		125
126	mov esi,eax	126	mov esi,eax
127		127
128	mov eax,edi	128	mov eax,edi
129	mov [eax+0],dword ' '	129	mov [eax+0],dword ' '
130	mov [eax+4],dword ' '	130	mov [eax+4],dword ' '
131	mov [eax+8],dword ' '	131	mov [eax+8],dword ' '
132		132
133	flr1:	133	flr1:
134		134
135	cmp [esi],byte '.'	135	cmp [esi],byte '.'
136	jne flr2	136	jne flr2
137	mov edi,eax	137	mov edi,eax
138	add edi,7	138	add edi,7
139	jmp flr3	139	jmp flr3
140		140
141	flr2:	141	flr2:
142		142
143	mov bl,[esi]	143	mov bl,[esi]
144	mov [edi],bl	144	mov [edi],bl
145		145
146	flr3:	146	flr3:
147		147
148	inc esi	148	inc esi
149	inc edi	149	inc edi
150		150
151	mov ebx,eax	151	mov ebx,eax
152	add ebx,11	152	add ebx,11
153		153
154	cmp edi,ebx	154	cmp edi,ebx
155	jbe flr1	155	jbe flr1
156		156
157	pop ebx edi esi	157	pop ebx edi esi
158	ret	158	ret
159		159
160	fileread:	160	fileread:
161	;----------------------------------------------------------------	161	;----------------------------------------------------------------
162	;	162	;
163	; fileread - sys floppy	163	; fileread - sys floppy
164	;	164	;
165	; eax points to filename 11 chars	165	; eax points to filename 11 chars
166	; ebx first wanted block ; 1+ ; if 0 then set to 1	166	; ebx first wanted block ; 1+ ; if 0 then set to 1
167	; ecx number of blocks to read ; 1+ ; if 0 then set to 1	167	; ecx number of blocks to read ; 1+ ; if 0 then set to 1
168	; edx mem location to return data	168	; edx mem location to return data
169	; esi length of filename 12*X 0=root	169	; esi length of filename 12*X 0=root
170	;	170	;
171	; ret ebx = size or 0xffffffff file not found	171	; ret ebx = size or 0xffffffff file not found
172	; eax = 0 ok read or other = errormsg	172	; eax = 0 ok read or other = errormsg
173	;	173	;
174	;--------------------------------------------------------------	174	;--------------------------------------------------------------
175	test ebx,ebx ;if ebx=0 - set to 1	175	test ebx,ebx ;if ebx=0 - set to 1
176	jnz frfl5	176	jnz frfl5
177	inc ebx	177	inc ebx
178	frfl5:	178	frfl5:
179	test ecx,ecx ;if ecx=0 - set to 1	179	test ecx,ecx ;if ecx=0 - set to 1
180	jnz frfl6	180	jnz frfl6
181	inc ecx	181	inc ecx
182	frfl6:	182	frfl6:
183	test esi,esi ; return ramdisk root	183	test esi,esi ; return ramdisk root
184	jnz fr_noroot ;if not root	184	jnz fr_noroot ;if not root
185	cmp ebx,14 ;14 clusters=root dir	185	cmp ebx,14 ;14 clusters=root dir
186	ja oorr	186	ja oorr
187	cmp ecx,14	187	cmp ecx,14
188	ja oorr	188	ja oorr
189	jmp fr_do	189	jmp fr_do
190	oorr:	190	oorr:
191	mov eax,5 ;out of root range (fnf)	191	mov eax,5 ;out of root range (fnf)
192	xor ebx,ebx	192	xor ebx,ebx
193	dec ebx ;0xffffffff	193	dec ebx ;0xffffffff
194	ret	194	ret
195		195
196	fr_do: ;reading rootdir	196	fr_do: ;reading rootdir
197	mov edi,edx	197	mov edi,edx
198	dec ebx	198	dec ebx
199	push edx	199	push edx
200	mov edx,ecx	200	mov edx,ecx
201	add edx,ebx	201	add edx,ebx
202	cmp edx,15 ;ebx+ecx=14+1	202	cmp edx,15 ;ebx+ecx=14+1
203	pushf	203	pushf
204	jbe fr_do1	204	jbe fr_do1
205	sub edx,14	205	sub edx,14
206	sub ecx,edx	206	sub ecx,edx
207	fr_do1:	207	fr_do1:
208	shl ebx,9	208	shl ebx,9
209	mov esi,RAMDISK+512*19	209	mov esi,RAMDISK+512*19
210	add esi,ebx	210	add esi,ebx
211	shl ecx,7	211	shl ecx,7
212	cld	212	cld
213	rep movsd	213	rep movsd
214	popf	214	popf
215	pop edx	215	pop edx
216	jae fr_do2	216	jae fr_do2
217	xor eax,eax ; ok read	217	xor eax,eax ; ok read
218	xor ebx,ebx	218	xor ebx,ebx
219	ret	219	ret
220	fr_do2: ;if last cluster	220	fr_do2: ;if last cluster
221	mov eax,6 ;end of file	221	mov eax,6 ;end of file
222	xor ebx,ebx	222	xor ebx,ebx
223	ret	223	ret
224		224
225	fr_noroot:	225	fr_noroot:
226		226
227	sub esp,32	227	sub esp,32
228	call expand_filename	228	call expand_filename
229		229
230	dec ebx	230	dec ebx
231		231
232	push eax	232	push eax
233		233
234	push eax ebx ecx edx esi edi	234	push eax ebx ecx edx esi edi
235	call rd_findfile	235	call rd_findfile
236	je fifound	236	je fifound
237	add esp,32+28 ;if file not found	237	add esp,32+28 ;if file not found
238	ret	238	ret
239		239
240	fifound:	240	fifound:
241		241
242	mov ebx,[edi-11+28] ;file size	242	mov ebx,[edi-11+28] ;file size
243	mov [esp+20],ebx	243	mov [esp+20],ebx
244	mov [esp+24],ebx	244	mov [esp+24],ebx
245	add edi,0xf	245	add edi,0xf
246	movzx eax,word [edi]	246	movzx eax,word [edi]
247	mov edi,eax ;edi=cluster	247	mov edi,eax ;edi=cluster
248		248
249	frnew:	249	frnew:
250		250
251	add eax,31 ;bootsector+2*fat+filenames	251	add eax,31 ;bootsector+2*fat+filenames
252	shl eax,9 ;*512	252	shl eax,9 ;*512
253	add eax,RAMDISK ;image base	253	add eax,RAMDISK ;image base
254	mov ebx,[esp+8]	254	mov ebx,[esp+8]
255	mov ecx,512 ;[esp+4]	255	mov ecx,512 ;[esp+4]
256		256
257	cmp [esp+16],dword 0 ; wanted cluster ?	257	cmp [esp+16],dword 0 ; wanted cluster ?
258	jne frfl7	258	jne frfl7
259	call memmove	259	call memmove
260	add [esp+8],dword 512	260	add [esp+8],dword 512
261	dec dword [esp+12] ; last wanted cluster ?	261	dec dword [esp+12] ; last wanted cluster ?
262	je frnoread	262	je frnoread
263	jmp frfl8	263	jmp frfl8
264	frfl7:	264	frfl7:
265	dec dword [esp+16]	265	dec dword [esp+16]
266	frfl8:	266	frfl8:
267	movzx eax,word [edi*2+RAMDISK_FAT] ; find next cluster from FAT	267	movzx eax,word [edi*2+RAMDISK_FAT] ; find next cluster from FAT
268	mov edi,eax	268	mov edi,eax
269	cmp edi,4095 ;eof - cluster	269	cmp edi,4095 ;eof - cluster
270	jz frnoread2	270	jz frnoread2
271		271
272	cmp [esp+24],dword 512 ;eof - size	272	cmp [esp+24],dword 512 ;eof - size
273	jb frnoread	273	jb frnoread
274	sub [esp+24],dword 512	274	sub [esp+24],dword 512
275		275
276	jmp frnew	276	jmp frnew
277		277
278	frnoread2:	278	frnoread2:
279		279
280	cmp [esp+16],dword 0 ; eof without read ?	280	cmp [esp+16],dword 0 ; eof without read ?
281	je frnoread	281	je frnoread
282		282
283	pop edi esi edx ecx	283	pop edi esi edx ecx
284	add esp,4	284	add esp,4
285	pop ebx ; ebx <- eax : size of file	285	pop ebx ; ebx <- eax : size of file
286	add esp,36	286	add esp,36
287	mov eax,6 ; end of file	287	mov eax,6 ; end of file
288	ret	288	ret
289		289
290	frnoread:	290	frnoread:
291		291
292	pop edi esi edx ecx	292	pop edi esi edx ecx
293	add esp,4	293	add esp,4
294	pop ebx ; ebx <- eax : size of file	294	pop ebx ; ebx <- eax : size of file
295	add esp,36	295	add esp,36
296	xor eax,eax ;read ok	296	xor eax,eax ;read ok
297	ret	297	ret
298		298
299	filedelete:	299	filedelete:
300	;--------------------------------------------	300	;--------------------------------------------
301	;	301	;
302	; filedelete - sys floppy	302	; filedelete - sys floppy
303	; in:	303	; in:
304	; eax - pointer to filename 11 chars	304	; eax - pointer to filename 11 chars
305	;	305	;
306	; out:	306	; out:
307	; eax - 0 = successful, 5 = file not found	307	; eax - 0 = successful, 5 = file not found
308	;	308	;
309	;--------------------------------------------	309	;--------------------------------------------
310		310
311	sub esp,32	311	sub esp,32
312	call expand_filename	312	call expand_filename
313		313
314	push eax ebx ecx edx esi edi	314	push eax ebx ecx edx esi edi
315		315
316	call rd_findfile	316	call rd_findfile
317	je fifoundd	317	je fifoundd
318	pop edi esi edx ecx ebx eax ;file not found	318	pop edi esi edx ecx ebx eax ;file not found
319	add esp,32	319	add esp,32
320	mov eax,5	320	mov eax,5
321	ret	321	ret
322		322
323	fifoundd:	323	fifoundd:
324		324
325	mov [edi-11],byte 0xE5 ;mark filename deleted	325	mov [edi-11],byte 0xE5 ;mark filename deleted
326	add edi,0xf	326	add edi,0xf
327	movzx eax,word [edi]	327	movzx eax,word [edi]
328	mov edi,eax ;edi = cluster	328	mov edi,eax ;edi = cluster
329		329
330	frnewd:	330	frnewd:
331		331
332	shl edi,1 ;find next cluster from FAT	332	shl edi,1 ;find next cluster from FAT
333	add edi,RAMDISK_FAT	333	add edi,RAMDISK_FAT
334	movzx eax,word [edi]	334	movzx eax,word [edi]
335	mov [edi],word 0x0 ;clear fat chain cluster	335	mov [edi],word 0x0 ;clear fat chain cluster
336	mov edi,eax	336	mov edi,eax
337	cmp edi,dword 0xff8 ;last cluster ?	337	cmp edi,dword 0xff8 ;last cluster ?
338	jb frnewd	338	jb frnewd
339		339
340	pop edi esi edx ecx ebx eax	340	pop edi esi edx ecx ebx eax
341	add esp,32	341	add esp,32
342	xor eax,eax ; file found	342	xor eax,eax ; file found
343	ret	343	ret
344		344
345		345
346		346
347	filesave:	347	filesave:
348	;----------------------------------------------------------	348	;----------------------------------------------------------
349	;	349	;
350	; filesave - sys floppy	350	; filesave - sys floppy
351	;	351	;
352	; eax points to filename 11 chars	352	; eax points to filename 11 chars
353	;	353	;
354	; eax ; pointer to file name	354	; eax ; pointer to file name
355	; ebx ; buffer	355	; ebx ; buffer
356	; ecx ; count to write in bytes	356	; ecx ; count to write in bytes
357	; edx ; 0 create new , 1 append	357	; edx ; 0 create new , 1 append
358	;	358	;
359	;-----------------------------------------------------------	359	;-----------------------------------------------------------
360		360
361	sub esp,32	361	sub esp,32
362	call expand_filename	362	call expand_filename
363	test edx,edx	363	test edx,edx
364	jnz fsdel	364	jnz fsdel
365	pusha	365	pusha
366	call filedelete	366	call filedelete
367	popa	367	popa
368		368
369	fsdel:	369	fsdel:
370		370
371	call ramdisk_free_space	371	call ramdisk_free_space
372	cmp ecx,edi	372	cmp ecx,edi
373	jbe rd_do_save	373	jbe rd_do_save
374	add esp,32	374	add esp,32
375	mov eax,8 ;disk full	375	mov eax,8 ;disk full
376	ret	376	ret
377		377
378	rd_do_save:	378	rd_do_save:
379		379
380	push eax ebx ecx edx esi edi	380	push eax ebx ecx edx esi edi
381		381
382	mov edi,RAMDISK+512*18+512 ;Point at directory	382	mov edi,RAMDISK+512*18+512 ;Point at directory
383	mov edx,224 +1	383	mov edx,224 +1
384	; find an empty spot for filename in the root dir	384	; find an empty spot for filename in the root dir
385	l20ds:	385	l20ds:
386	dec edx	386	dec edx
387	jz frnoreadds	387	jz frnoreadds
388	l21ds:	388	l21ds:
389	cmp [edi],byte 0xE5	389	cmp [edi],byte 0xE5
390	jz fifoundds	390	jz fifoundds
391	cmp [edi],byte 0x0	391	cmp [edi],byte 0x0
392	jz fifoundds	392	jz fifoundds
393	add edi,32 ; Advance to next entry	393	add edi,32 ; Advance to next entry
394	jmp l20ds	394	jmp l20ds
395	fifoundds:	395	fifoundds:
396		396
397	push edi ; move the filename to root dir	397	push edi ; move the filename to root dir
398	mov esi,[esp+4+20]	398	mov esi,[esp+4+20]
399	mov ecx,11	399	mov ecx,11
400	cld	400	cld
401	rep movsb	401	rep movsb
402	pop edi	402	pop edi
403	mov edx,edi	403	mov edx,edi
404	add edx,11+0xf ; edx <- cluster save position	404	add edx,11+0xf ; edx <- cluster save position
405	mov ebx,[esp+12] ; save file size	405	mov ebx,[esp+12] ; save file size
406	mov [edi+28],ebx	406	mov [edi+28],ebx
407	mov [edi+11],byte 0x20 ; attribute	407	mov [edi+11],byte 0x20 ; attribute
408	; Ivan Poddubny 11/12/2003:	408	; Ivan Poddubny 11/12/2003:
409	call get_date_for_file ; from FAT32.INC	409	call get_date_for_file ; from FAT32.INC
410	mov [edi+24],ax ; date	410	mov [edi+24],ax ; date
411	call get_time_for_file ; from FAT32.INC	411	call get_time_for_file ; from FAT32.INC
412	mov [edi+22],ax ; time	412	mov [edi+22],ax ; time
413	; End	413	; End
414	mov edi,RAMDISK_FAT ;pointer to first cluster	414	mov edi,RAMDISK_FAT ;pointer to first cluster
415	mov ecx,2849	415	mov ecx,2849
416	cld	416	cld
417	frnewds:	417	frnewds:
418	xor ax,ax	418	xor ax,ax
419	repne scasw	419	repne scasw
420	mov ebx,2848	420	mov ebx,2848
421	sub ebx,ecx	421	sub ebx,ecx
422	mov [edx],bx ; save next cluster pos. to prev cl.	422	mov [edx],bx ; save next cluster pos. to prev cl.
423	mov edx,edi ; next save pos abs mem add	423	mov edx,edi ; next save pos abs mem add
424	dec edx	424	dec edx
425	dec edx	425	dec edx
426	call fdc_filesave	426	call fdc_filesave
427	pusha ; move save to floppy cluster	427	pusha ; move save to floppy cluster
428	add ebx,31	428	add ebx,31
429	shl ebx,9	429	shl ebx,9
430	add ebx,RAMDISK	430	add ebx,RAMDISK
431	mov eax,[esp+32+16]	431	mov eax,[esp+32+16]
432	mov ecx,512	432	mov ecx,512
433	call memmove	433	call memmove
434	popa	434	popa
435		435
436	mov eax,[esp+12]	436	mov eax,[esp+12]
437	cmp eax,512	437	cmp eax,512
438	jbe flnsa	438	jbe flnsa
439	sub eax,512	439	sub eax,512
440	mov [esp+12],eax	440	mov [esp+12],eax
441	add dword [esp+16], 512	441	add dword [esp+16], 512
442	jmp frnewds	442	jmp frnewds
443		443
444	flnsa:	444	flnsa:
445	mov [edi-2],word 4095 ; mark end of file - last cluster	445	mov [edi-2],word 4095 ; mark end of file - last cluster
446		446
447	frnoreadds:	447	frnoreadds:
448		448
449	pop edi esi edx ecx ebx eax	449	pop edi esi edx ecx ebx eax
450	add esp,32	450	add esp,32
451		451
452	; pusha	452	; pusha
453	; cli	453	; cli
454	; call fdc_commitfile	454	; call fdc_commitfile
455	; sti	455	; sti
456	; popa	456	; popa
457		457
458	xor eax,eax ;ok write	458	xor eax,eax ;ok write
459	ret	459	ret
460		460
461	rd_findfile:	461	rd_findfile:
462	;by Mihasik	462	;by Mihasik
463	;IN: eax - pointer to filename OUT: filestring+11 in edi or notZero in flags and fnf in eax,ebx	463	;IN: eax - pointer to filename OUT: filestring+11 in edi or notZero in flags and fnf in eax,ebx
464		464
465	mov edi,RAMDISK+512*18+512 ;Point at directory	465	mov edi,RAMDISK+512*18+512 ;Point at directory
466	cld	466	cld
467	rd_newsearch:	467	rd_newsearch:
468	mov esi,eax	468	mov esi,eax
469	mov ecx,11	469	mov ecx,11
470	rep cmpsb	470	rep cmpsb
471	je rd_ff	471	je rd_ff
472	add cl,21	472	add cl,21
473	add edi,ecx	473	add edi,ecx
474	cmp edi,RAMDISK+512*33	474	cmp edi,RAMDISK+512*33
475	jb rd_newsearch	475	jb rd_newsearch
476	mov eax,5 ;if file not found - eax=5	476	mov eax,5 ;if file not found - eax=5
477	xor ebx,ebx	477	xor ebx,ebx
478	dec ebx ;ebx=0xffffffff and zf=0	478	dec ebx ;ebx=0xffffffff and zf=0
479	rd_ff:	479	rd_ff:
480	ret	480	ret
481		481
482	; \begin{diamond}	482	; \begin{diamond}
483		483
484	uni2ansi_str:	484	uni2ansi_str:
485	; convert UNICODE zero-terminated string to ASCII-string (codepage 866)	485	; convert UNICODE zero-terminated string to ASCII-string (codepage 866)
486	; in: esi->source, edi->buffer (may be esi=edi)	486	; in: esi->source, edi->buffer (may be esi=edi)
487	; destroys: eax,esi,edi	487	; destroys: eax,esi,edi
488	lodsw	488	lodsw
489	test ax, ax	489	test ax, ax
490	jz .done	490	jz .done
491	cmp ax, 0x80	491	cmp ax, 0x80
492	jb .ascii	492	jb .ascii
493	cmp ax, 0x401	493	cmp ax, 0x401
494	jz .yo1	494	jz .yo1
495	cmp ax, 0x451	495	cmp ax, 0x451
496	jz .yo2	496	jz .yo2
497	cmp ax, 0x410	497	cmp ax, 0x410
498	jb .unk	498	jb .unk
499	cmp ax, 0x440	499	cmp ax, 0x440
500	jb .rus1	500	jb .rus1

Subversion Repositories Kolibri OS

(root)/kernel/trunk/blkdev/rd.inc – Rev 521 → 527