WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/blkdev/rd.inc

 ;; (C) 2004 Ville Turjanmaa, License: GPL                       ;;
 ;; Addings by M.Lisovin                                         ;;
 ;; LFN support by diamond                                       ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 3500 $
+$Revision: 3555 $
 ; calculate fat chain
 calculatefatchain:
         mov     dword [edi+12], edx
         add     edi, 16
         add     esi, 12
         cmp     edi, RAMDISK_FAT+2856*2;2849 clusters
-   jnz	fcnew
+        jnz     fcnew
-   popad
+        popad
-   ret
+        ret
 restorefatchain:   ; restore fat chain
         mov     word [edi+4], bx
         add     edi, 6
         add     esi, 8
         cmp     edi, RAMDISK+512+4278;4274 bytes - all used FAT
-   jb	fcnew2
+        jb      fcnew2
         mov     esi, RAMDISK+512  ; duplicate fat chain
         mov     edi, RAMDISK+512+0x1200
         mov     ecx, 1069;4274/4
-   cld
+        cld
-   rep	movsd
+        rep movsd
-   popad
+        popad
-   ret
+        ret
 ramdisk_free_space:
 ;---------------------------------------------
+;
 ; returns free space in edi
 ; rewr.by Mihasik
 ;---------------------------------------------
-	push   eax ebx ecx
+        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
+        cld
     rdfs1:
-	repne scasw
+        repne scasw
-	jnz  rdfs2    ;if last cluster not 0
+        jnz     rdfs2 ;if last cluster not 0
-	inc  ebx
+        inc     ebx
-	test	ecx, ecx
+        test    ecx, ecx
-	jnz	rdfs1
+        jnz     rdfs1
     rdfs2:
         shl     ebx, 9;free clusters*512
         mov     edi, ebx
-	pop    ecx ebx eax
+        pop     ecx ebx eax
-	ret
+        ret
         mov     [eax+8], dword '    '
       flr1:
         cmp     [esi], byte '.'
-	jne  flr2
+        jne     flr2
         mov     edi, eax
         add     edi, 7
-	jmp  flr3
+        jmp     flr3
       flr2:
         mov     bl, [esi]
         mov     [edi], bl
       flr3:
-	inc  esi
+        inc     esi
-	inc  edi
+        inc     edi
         mov     ebx, eax
         add     ebx, 11
 ;  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
+        jnz     frfl5
-	inc    ebx
+        inc     ebx
       frfl5:
         test    ecx, ecx;if ecx=0 - set to 1
-	jnz    frfl6
+        jnz     frfl6
-	inc    ecx
+        inc     ecx
       frfl6:
         test    esi, esi        ; return ramdisk root
-	jnz    fr_noroot	;if not root
+        jnz     fr_noroot       ;if not root
         cmp     ebx, 14         ;14 clusters=root dir
-	ja     oorr
+        ja      oorr
         cmp     ecx, 14
-	ja     oorr
+        ja      oorr
-	jmp    fr_do
+        jmp     fr_do
       oorr:
         mov     eax, 5          ;out of root range (fnf)
         xor     ebx, ebx
-	dec    ebx		;0xffffffff
+        dec     ebx             ;0xffffffff
-	ret
+        ret
-      fr_do:			;reading rootdir
+      fr_do:                    ;reading rootdir
         mov     edi, edx
-	dec    ebx
+        dec     ebx
-	push   edx
+        push    edx
         mov     edx, ecx
         add     edx, ebx
         cmp     edx, 15   ;ebx+ecx=14+1
-	pushf
+        pushf
-	jbe    fr_do1
+        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
+        cld
-	rep    movsd
+        rep movsd
-	popf
+        popf
-	pop    edx
+        pop     edx
-	jae    fr_do2
+        jae     fr_do2
         xor     eax, eax; ok read
         xor     ebx, ebx
-	ret
+        ret
-      fr_do2:	     ;if last cluster
+      fr_do2:        ;if last cluster
         mov     eax, 6;end of file
         xor     ebx, ebx
-	ret
+        ret
      fr_noroot:
         sub     esp, 32
-	call   expand_filename
+        call    expand_filename
-	dec    ebx
+        dec     ebx
-	push   eax
+        push    eax
-	push   eax ebx ecx edx esi edi
+        push    eax ebx ecx edx esi edi
-	call   rd_findfile
+        call    rd_findfile
         add     eax, RAMDISK           ;image base
         mov     ebx, [esp+8]
         mov     ecx, 512                ;[esp+4]
         cmp     [esp+16], dword 0       ; wanted cluster ?
-	jne    frfl7
+        jne     frfl7
-	call   memmove
+        call    memmove
         add     [esp+8], dword 512
-	dec    dword [esp+12]		; last wanted cluster ?
+        dec     dword [esp+12]          ; last wanted cluster ?
-	je     frnoread
+        je      frnoread
-	jmp    frfl8
+        jmp     frfl8
       frfl7:
-	dec    dword [esp+16]
+        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
+        jz      frnoread2
         cmp     [esp+24], dword 512     ;eof  - size
-	jb     frnoread
+        jb      frnoread
         sub     [esp+24], dword 512
-	jmp    frnew
+        jmp     frnew
       frnoread2:
         cmp     [esp+16], dword 0       ; eof without read ?
-	je     frnoread
+        je      frnoread
-	pop    edi esi edx ecx
+        pop     edi esi edx ecx
         add     esp, 4
-	pop    ebx     ; ebx <- eax : size of file
+        pop     ebx    ; ebx <- eax : size of file
         add     esp, 36
         mov     eax, 6 ; end of file
-	ret
+        ret
       frnoread:
-	pop    edi esi edx ecx
+        pop     edi esi edx ecx
         add     esp, 4
-	pop    ebx     ; ebx <- eax : size of file
+        pop     ebx    ; ebx <- eax : size of file
         add     esp, 36
         xor     eax, eax;read ok
-	ret
+        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
+        cld
     rd_newsearch:
         mov     esi, eax
         mov     ecx, 11
-	rep    cmpsb
+        rep cmpsb
-	je     rd_ff
+        je      rd_ff
         add     cl, 21
         add     edi, ecx
         cmp     edi, RAMDISK+512*33
-	jb     rd_newsearch
+        jb      rd_newsearch
         mov     eax, 5    ;if file not found - eax=5
         xor     ebx, ebx
-	dec    ebx    ;ebx=0xffffffff and zf=0
+        dec     ebx   ;ebx=0xffffffff and zf=0
      rd_ff:
-	ret
+        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
+        lodsw
-	test	ax, ax
+        test    ax, ax
-	jz	.done
+        jz      .done
-	cmp	ax, 0x80
+        cmp     ax, 0x80
-	jb	.ascii
+        jb      .ascii
-	cmp	ax, 0x401
+        cmp     ax, 0x401
-	jz	.yo1
+        jz      .yo1
-	cmp	ax, 0x451
+        cmp     ax, 0x451
-	jz	.yo2
+        jz      .yo2
-	cmp	ax, 0x410
+        cmp     ax, 0x410
-	jb	.unk
+        jb      .unk
-	cmp	ax, 0x440
+        cmp     ax, 0x440
-	jb	.rus1
+        jb      .rus1
-	cmp	ax, 0x450
+        cmp     ax, 0x450
-	jb	.rus2
+        jb      .rus2
 .unk:
-	mov	al, '_'
+        mov     al, '_'
-	jmp	.doit
+        jmp     .doit
 .yo1:
-	mov	al, 'ð'
+        mov     al, 0xF0 ; 'Ё'
-	jmp	.doit
+        jmp     .doit
 .yo2:
-	mov	al, 'ñ'
+        mov     al, 0xF1 ; 'ё'
-	jmp	.doit
+        jmp     .doit
 .rus1:
 ; 0x410-0x43F -> 0x80-0xAF
-	add	al, 0x70
+        add     al, 0x70
-	jmp	.doit
+        jmp     .doit
 .rus2:
 ; 0x440-0x44F -> 0xE0-0xEF
-	add	al, 0xA0
+        add     al, 0xA0
 .ascii:
 .doit:
-	stosb
+        stosb
-	jmp	uni2ansi_str
+        jmp     uni2ansi_str
 .done:
-	mov	byte [edi], 0
+        mov     byte [edi], 0
-	ret
+        ret
 ansi2uni_char:
 ; convert ANSI character in al to UNICODE character in ax, using cp866 encoding
-	mov	ah, 0
+        mov     ah, 0
 ; 0x00-0x7F - trivial map
-	cmp	al, 0x80
+        cmp     al, 0x80
-	jb	.ret
+        jb      .ret
 ; 0x80-0xAF -> 0x410-0x43F
-	cmp	al, 0xB0
+        cmp     al, 0xB0
-	jae	@f
+        jae     @f
-	add	ax, 0x410-0x80
+        add     ax, 0x410-0x80
 .ret:
-	ret
+        ret
 @@:
 ; 0xE0-0xEF -> 0x440-0x44F
-	cmp	al, 0xE0
+        cmp     al, 0xE0
-	jb	.unk
+        jb      .unk
-	cmp	al, 0xF0
+        cmp     al, 0xF0
-	jae	@f
+        jae     @f
-	add	ax, 0x440-0xE0
+        add     ax, 0x440-0xE0
-	ret
+        ret
 ; 0xF0 -> 0x401
 ; 0xF1 -> 0x451
 @@:
-	cmp	al, 'ð'
+        cmp     al, 0xF0 ; 'Ё'
-	jz	.yo1
+        jz      .yo1
-	cmp	al, 'ñ'
+        cmp     al, 0xF1 ; 'ё'
-	jz	.yo2
+        jz      .yo2
 .unk:
-	mov	al, '_' 	; ah=0
+        mov     al, '_'         ; ah=0
-	ret
+        ret
 .yo1:
-	mov	ax, 0x401
+        mov     ax, 0x401
-	ret
+        ret
 .yo2:
-	mov	ax, 0x451
+        mov     ax, 0x451
-	ret
+        ret
 char_toupper:
 ; convert character to uppercase, using cp866 encoding
 ; in: al=symbol
 ; out: al=converted symbol
-	cmp	al, 'a'
+        cmp     al, 'a'
-	jb	.ret
+        jb      .ret
-	cmp	al, 'z'
+        cmp     al, 'z'
-	jbe	.az
+        jbe     .az
-        cmp     al, 'ñ'
+        cmp     al, 0xF1 ; 'ё'
         jz      .yo1
-	cmp	al, ' '
+        cmp     al, 0xA0 ; 'а'
-	jb	.ret
+        jb      .ret
-	cmp	al, 'à'
+        cmp     al, 0xE0 ; 'р'
 ; 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
+        cmp     byte [edi], 0
-	jz	.no
+        jz      .no
-	cmp	byte [edi], 0xE5
+        cmp     byte [edi], 0xE5
-	jnz	@f
+        jnz     @f
 .no:
-	stc
+        stc
-	ret
+        ret
 @@:
-	cmp	byte [edi+11], 0xF
+        cmp     byte [edi+11], 0xF
-	jz	.longname
+        jz      .longname
-	test	byte [edi+11], 8
+        test    byte [edi+11], 8
-	jnz	.no
+        jnz     .no
-	push	ecx
+        push    ecx
-	push	edi ebp
+        push    edi ebp
-	test	byte [ebp-4], 1
+        test    byte [ebp-4], 1
-	jnz	.unicode_short
+        jnz     .unicode_short
-	mov	eax, [edi]
+        mov     eax, [edi]
-	mov	ecx, [edi+4]
+        mov     ecx, [edi+4]
-	mov	[ebp], eax
+        mov     [ebp], eax
-	mov	[ebp+4], ecx
+        mov     [ebp+4], ecx
-	mov	ecx, 8
+        mov     ecx, 8
 @@:
-	cmp	byte [ebp+ecx-1], ' '
+        cmp     byte [ebp+ecx-1], ' '
-	loope	 @b
+        loope   @b
-	mov	eax, [edi+8]
+        mov     eax, [edi+8]
-	cmp	al, ' '
+        cmp     al, ' '
-	je	.done
+        je      .done
-	shl	eax, 8
+        shl     eax, 8
-	mov	al, '.'
+        mov     al, '.'
-	lea ebp, [ebp+ecx+1]
+        lea     ebp, [ebp+ecx+1]
-	mov	[ebp], eax
+        mov     [ebp], eax
-	mov	ecx, 3
+        mov     ecx, 3
 @@:
-	rol eax, 8
+        rol     eax, 8
-	cmp al, ' '
+        cmp     al, ' '
-	jne .done
+        jne     .done
-	loop   @b
+        loop    @b
-	dec ebp
+        dec     ebp
 .done:
-	and	byte [ebp+ecx+1], 0   ; CF=0
+        and     byte [ebp+ecx+1], 0   ; CF=0
-	pop	ebp edi ecx
+        pop     ebp edi ecx
-	ret
+        ret
 .unicode_short:
-	mov	ecx, 8
+        mov     ecx, 8
-	push	ecx
+        push    ecx
 @@:
-	mov	al, [edi]
+        mov     al, [edi]
-	inc	edi
+        inc     edi
-	call	ansi2uni_char
+        call    ansi2uni_char
-	mov	[ebp], ax
+        mov     [ebp], ax
-	inc	ebp
+        inc     ebp
-	inc	ebp
+        inc     ebp
-	loop	@b
+        loop    @b
-	pop	ecx
+        pop     ecx
 @@:
-	cmp	word [ebp-2], ' '
+        cmp     word [ebp-2], ' '
-	jnz	@f
+        jnz     @f
-	dec	ebp
+        dec     ebp
-	dec	ebp
+        dec     ebp
-	loop	@b
+        loop    @b
 @@:
-	mov	word [ebp], '.'
+        mov     word [ebp], '.'
-	inc	ebp
+        inc     ebp
-	inc	ebp
+        inc     ebp
-	mov	ecx, 3
+        mov     ecx, 3
-	push	ecx
+        push    ecx
 @@:
-	mov	al, [edi]
+        mov     al, [edi]
-	inc	edi
+        inc     edi
-	call	ansi2uni_char
+        call    ansi2uni_char
-	mov	[ebp], ax
+        mov     [ebp], ax
-	inc	ebp
+        inc     ebp
-	inc	ebp
+        inc     ebp
-	loop	@b
+        loop    @b
-	pop	ecx
+        pop     ecx
 @@:
-	cmp	word [ebp-2], ' '
+        cmp     word [ebp-2], ' '
-	jnz	@f
+        jnz     @f
-	dec	ebp
+        dec     ebp
-	dec	ebp
+        dec     ebp
-	loop	@b
+        loop    @b
-	dec	ebp
+        dec     ebp
-	dec	ebp
+        dec     ebp
 @@:
-	and	word [ebp], 0	; CF=0
+        and     word [ebp], 0   ; CF=0
-	pop	ebp edi ecx
+        pop     ebp edi ecx
-	ret
+        ret
 .longname:
 ; LFN
-	mov	al, byte [edi]
+        mov     al, byte [edi]
-	and	eax, 0x3F
+        and     eax, 0x3F
-	dec	eax
+        dec     eax
-	cmp	al, 20
+        cmp     al, 20
-	jae	.no	; ignore invalid entries
+        jae     .no     ; ignore invalid entries
-	mov	word [ebp+260*2], 0	; force null-terminating for orphans
+        mov     word [ebp+260*2], 0     ; force null-terminating for orphans
-	imul	eax, 13*2
+        imul    eax, 13*2
-	add	ebp, eax
+        add     ebp, eax
-	test	byte [edi], 0x40
+        test    byte [edi], 0x40
-	jz	@f
+        jz      @f
-	mov	word [ebp+13*2], 0
+        mov     word [ebp+13*2], 0
 @@:
-	push	eax
+        push    eax
 ; now copy name from edi to ebp ...
-	mov	eax, [edi+1]
+        mov     eax, [edi+1]
-	mov	[ebp], eax	; symbols 1,2
+        mov     [ebp], eax      ; symbols 1,2
-	mov	eax, [edi+5]
+        mov     eax, [edi+5]
-	mov	[ebp+4], eax	; 3,4
+        mov     [ebp+4], eax    ; 3,4
-	mov	eax, [edi+9]
+        mov     eax, [edi+9]
-	mov	[ebp+8], ax	; 5
+        mov     [ebp+8], ax     ; 5
-	mov	eax, [edi+14]
+        mov     eax, [edi+14]
-	mov	[ebp+10], eax	; 6,7
+        mov     [ebp+10], eax   ; 6,7
-	mov	eax, [edi+18]
+        mov     eax, [edi+18]
-	mov	[ebp+14], eax	; 8,9
+        mov     [ebp+14], eax   ; 8,9
-	mov	eax, [edi+22]
+        mov     eax, [edi+22]
-	mov	[ebp+18], eax	; 10,11
+        mov     [ebp+18], eax   ; 10,11
-	mov	eax, [edi+28]
+        mov     eax, [edi+28]
-	mov	[ebp+22], eax	; 12,13
+        mov     [ebp+22], eax   ; 12,13
 ; ... done
-	pop	eax
+        pop     eax
-	sub	ebp, eax
+        sub     ebp, eax
-	test	eax, eax
+        test    eax, eax
-	jz	@f
+        jz      @f
 ; if this is not first entry, more processing required
-	stc
+        stc
-	ret
+        ret
 @@:
 ; if this is first entry:
-	test	byte [ebp-4], 1
+        test    byte [ebp-4], 1
-	jnz	.ret
+        jnz     .ret
 ; buffer at ebp contains UNICODE name, convert it to ANSI
-	push	esi edi
+        push    esi edi
-	mov	esi, ebp
+        mov     esi, ebp
-	mov	edi, ebp
+        mov     edi, ebp
-	call	uni2ansi_str
+        call    uni2ansi_str
-	pop	edi esi
+        pop     edi esi
 .ret:
-	clc
+        clc
-	ret
+        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
+        push    ebp esi
 .loop:
-	mov	al, [ebp]
+        mov     al, [ebp]
-	inc	ebp
+        inc     ebp
-	call	char_toupper
+        call    char_toupper
-	push	eax
+        push    eax
-	lodsb
+        lodsb
-	call	char_toupper
+        call    char_toupper
-	cmp	al, [esp]
+        cmp     al, [esp]
-	jnz	.done
+        jnz     .done
-	pop	eax
+        pop     eax
-	test	al, al
+        test    al, al
-	jnz	.loop
+        jnz     .loop
-	dec	esi
+        dec     esi
-	pop	eax
+        pop     eax
-	pop	ebp
+        pop     ebp
-	xor	eax, eax	; set ZF flag
+        xor     eax, eax        ; set ZF flag
-	ret
+        ret
 .done:
-	cmp	al, '/'
+        cmp     al, '/'
-	jnz	@f
+        jnz     @f
-	cmp	byte [esp], 0
+        cmp     byte [esp], 0
-	jnz	@f
+        jnz     @f
-	mov	[esp+4], esi
+        mov     [esp+4], esi
 @@:
-	pop	eax
+        pop     eax
-	pop	esi ebp
+        pop     esi ebp
-	ret
+        ret
 fat_time_to_bdfe:
 ; in: eax=FAT time
 ; out: eax=BDFE time
-	push	ecx edx
+        push    ecx edx
-	mov	ecx, eax
+        mov     ecx, eax
-	mov	edx, eax
+        mov     edx, eax
-	shr	eax, 11
+        shr     eax, 11
-	shl	eax, 16 ; hours
+        shl     eax, 16 ; hours
-	and	edx, 0x1F
+        and     edx, 0x1F
-	add	edx, edx
+        add     edx, edx
-	mov	al, dl	; seconds
+        mov     al, dl  ; seconds
-	shr	ecx, 5
+        shr     ecx, 5
-	and	ecx, 0x3F
+        and     ecx, 0x3F
-	mov	ah, cl	; minutes
+        mov     ah, cl  ; minutes
-	pop	edx ecx
+        pop     edx ecx
-	ret
+        ret
 fat_date_to_bdfe:
-	push	ecx edx
+        push    ecx edx
-	mov	ecx, eax
+        mov     ecx, eax
-	mov	edx, eax
+        mov     edx, eax
-	shr	eax, 9
+        shr     eax, 9
-	add	ax, 1980
+        add     ax, 1980
-	shl	eax, 16 ; year
+        shl     eax, 16 ; year
-	and	edx, 0x1F
+        and     edx, 0x1F
-	mov	al, dl	; day
+        mov     al, dl  ; day
-	shr	ecx, 5
+        shr     ecx, 5
-	and	ecx, 0xF
+        and     ecx, 0xF
-	mov	ah, cl	; month
+        mov     ah, cl  ; month
-	pop	edx ecx
+        pop     edx ecx
-	ret
+        ret
 bdfe_to_fat_time:
-	push	edx
+        push    edx
-	mov	edx, eax
+        mov     edx, eax
-	shr	eax, 16
+        shr     eax, 16
-	and	dh, 0x3F
+        and     dh, 0x3F
-	shl	eax, 6
+        shl     eax, 6
-	or	al, dh
+        or      al, dh
-	shr	dl, 1
+        shr     dl, 1
-	and	dl, 0x1F
+        and     dl, 0x1F
-	shl	eax, 5
+        shl     eax, 5
-	or	al, dl
+        or      al, dl
-	pop	edx
+        pop     edx
-	ret
+        ret
 bdfe_to_fat_date:
-	push	edx
+        push    edx
-	mov	edx, eax
+        mov     edx, eax
-	shr	eax, 16
+        shr     eax, 16
-	sub	ax, 1980
+        sub     ax, 1980
-	and	dh, 0xF
+        and     dh, 0xF
-	shl	eax, 4
+        shl     eax, 4
-	or	al, dh
+        or      al, dh
-	and	dl, 0x1F
+        and     dl, 0x1F
-	shl	eax, 5
+        shl     eax, 5
-	or	al, dl
+        or      al, dl
-	pop	edx
+        pop     edx
-	ret
+        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     eax, [ebp-4]
-	mov	[esi+4], eax	; ASCII/UNICODE name
+        mov     [esi+4], eax    ; ASCII/UNICODE name
 fat_entry_to_bdfe2:
-	movzx	eax, byte [edi+11]
+        movzx   eax, byte [edi+11]
-	mov	[esi], eax	; attributes
+        mov     [esi], eax      ; attributes
-	movzx	eax, word [edi+14]
+        movzx   eax, word [edi+14]
-	call	fat_time_to_bdfe
+        call    fat_time_to_bdfe
-	mov	[esi+8], eax	; creation time
+        mov     [esi+8], eax    ; creation time
-	movzx	eax, word [edi+16]
+        movzx   eax, word [edi+16]
-	call	fat_date_to_bdfe
+        call    fat_date_to_bdfe
-	mov	[esi+12], eax	; creation date
+        mov     [esi+12], eax   ; creation date
-	and	dword [esi+16], 0	; last access time is not supported on FAT
+        and     dword [esi+16], 0       ; last access time is not supported on FAT
-	movzx	eax, word [edi+18]
+        movzx   eax, word [edi+18]
-	call	fat_date_to_bdfe
+        call    fat_date_to_bdfe
-	mov	[esi+20], eax	; last access date
+        mov     [esi+20], eax   ; last access date
-	movzx	eax, word [edi+22]
+        movzx   eax, word [edi+22]
-	call	fat_time_to_bdfe
+        call    fat_time_to_bdfe
-	mov	[esi+24], eax	; last write time
+        mov     [esi+24], eax   ; last write time
-	movzx	eax, word [edi+24]
+        movzx   eax, word [edi+24]
-	call	fat_date_to_bdfe
+        call    fat_date_to_bdfe
-	mov	[esi+28], eax	; last write date
+        mov     [esi+28], eax   ; last write date
-	mov	eax, [edi+28]
+        mov     eax, [edi+28]
-	mov	[esi+32], eax	; file size (low dword)
+        mov     [esi+32], eax   ; file size (low dword)
-	xor	eax, eax
+        xor     eax, eax
-	mov	[esi+36], eax	; file size (high dword)
+        mov     [esi+36], eax   ; file size (high dword)
-	test	ebp, ebp
+        test    ebp, ebp
-	jz	.ret
+        jz      .ret
-	push	ecx edi
+        push    ecx edi
-	lea	edi, [esi+40]
+        lea     edi, [esi+40]
-	mov	esi, ebp
+        mov     esi, ebp
-	test	byte [esi-4], 1
+        test    byte [esi-4], 1
-	jz	.ansi
+        jz      .ansi
-	mov	ecx, 260/2
+        mov     ecx, 260/2
-	rep	movsd
+        rep movsd
-	mov	[edi-2], ax
+        mov     [edi-2], ax
 @@:
-	mov	esi, edi
+        mov     esi, edi
-	pop	edi ecx
+        pop     edi ecx
 .ret:
-	ret
+        ret
 .ansi:
-	mov	ecx, 264/4
+        mov     ecx, 264/4
-	rep	movsd
+        rep movsd
-	mov	[edi-1], al
+        mov     [edi-1], al
-	jmp	@b
+        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?
+        test    byte [edi+11], 8        ; volume label?
-	jnz	@f
+        jnz     @f
-	mov	al, [edx]
+        mov     al, [edx]
-	and	al, 0x27
+        and     al, 0x27
-	and	byte [edi+11], 0x10
+        and     byte [edi+11], 0x10
-	or	byte [edi+11], al
+        or      byte [edi+11], al
 @@:
-	mov	eax, [edx+8]
+        mov     eax, [edx+8]
-	call	bdfe_to_fat_time
+        call    bdfe_to_fat_time
-	mov	[edi+14], ax		; creation time
+        mov     [edi+14], ax            ; creation time
-	mov	eax, [edx+12]
+        mov     eax, [edx+12]
-	call	bdfe_to_fat_date
+        call    bdfe_to_fat_date
-	mov	[edi+16], ax		; creation date
+        mov     [edi+16], ax            ; creation date
-	mov	eax, [edx+20]
+        mov     eax, [edx+20]
-	call	bdfe_to_fat_date
+        call    bdfe_to_fat_date
-	mov	[edi+18], ax		; last access date
+        mov     [edi+18], ax            ; last access date
-	mov	eax, [edx+24]
+        mov     eax, [edx+24]
-	call	bdfe_to_fat_time
+        call    bdfe_to_fat_time
-	mov	[edi+22], ax		; last write time
+        mov     [edi+22], ax            ; last write time
-	mov	eax, [edx+28]
+        mov     eax, [edx+28]
-	call	bdfe_to_fat_date
+        call    bdfe_to_fat_date
-	mov	[edi+24], ax		; last write date
+        mov     [edi+24], ax            ; last write date
-	ret
+        ret
 ramdisk_root_first:
-	mov	edi, RAMDISK+512*19
+        mov     edi, RAMDISK+512*19
-	clc
+        clc
-	ret
+        ret
 ramdisk_root_next:
-	add	edi, 0x20
+        add     edi, 0x20
-	cmp	edi, RAMDISK+512*33
+        cmp     edi, RAMDISK+512*33
-	cmc
+        cmc
-	ret
+        ret
 ramdisk_root_extend_dir:
-	stc
+        stc
-	ret
+        ret
 uglobal
 ; this is for delete support
-rd_prev_sector		dd	?
+rd_prev_sector          dd      ?
-rd_prev_prev_sector	dd	?
+rd_prev_prev_sector     dd      ?
 endg
 ramdisk_notroot_next:
-	add	edi, 0x20
+        add     edi, 0x20
-	test	edi, 0x1FF
+        test    edi, 0x1FF
-	jz	ramdisk_notroot_next_sector
+        jz      ramdisk_notroot_next_sector
-	ret	; CF=0
+        ret     ; CF=0
 ramdisk_notroot_next_sector:
-	push	ecx
+        push    ecx
-	mov	ecx, [eax]
+        mov     ecx, [eax]
-	push	[rd_prev_sector]
+        push    [rd_prev_sector]
-	pop	[rd_prev_prev_sector]
+        pop     [rd_prev_prev_sector]
-	mov	[rd_prev_sector], ecx
+        mov     [rd_prev_sector], ecx
-	mov	ecx, [ecx*2+RAMDISK_FAT]
+        mov     ecx, [ecx*2+RAMDISK_FAT]
-	and	ecx, 0xFFF
+        and     ecx, 0xFFF
-	cmp	ecx, 2849
+        cmp     ecx, 2849
-	jae	ramdisk_notroot_first.err2
+        jae     ramdisk_notroot_first.err2
-	mov	[eax], ecx
+        mov     [eax], ecx
-	pop	ecx
+        pop     ecx
 ramdisk_notroot_first:
-	mov	eax, [eax]
+        mov     eax, [eax]
-	cmp	eax, 2
+        cmp     eax, 2
-	jb	.err
+        jb      .err
-	cmp	eax, 2849
+        cmp     eax, 2849
-	jae	.err
+        jae     .err
-	shl	eax, 9
+        shl     eax, 9
-	lea	edi, [eax+(31 shl 9)+RAMDISK]
+        lea     edi, [eax+(31 shl 9)+RAMDISK]
-	clc
+        clc
-	ret
+        ret
 .err2:
-	pop	ecx
+        pop     ecx
 .err:
-	stc
+        stc
-	ret
+        ret
 ramdisk_notroot_next_write:
-	test	edi, 0x1FF
+        test    edi, 0x1FF
-	jz	ramdisk_notroot_next_sector
+        jz      ramdisk_notroot_next_sector
 ramdisk_root_next_write:
-	ret
+        ret
 ramdisk_notroot_extend_dir:
-	pusha
+        pusha
-	xor	eax, eax
+        xor     eax, eax
-	mov	edi, RAMDISK_FAT
+        mov     edi, RAMDISK_FAT
-	mov	ecx, 2849
+        mov     ecx, 2849
-	repnz	scasw
+        repnz scasw
-	jnz	.notfound
+        jnz     .notfound
-	mov	word [edi-2], 0xFFF
+        mov     word [edi-2], 0xFFF
-	sub	edi, RAMDISK_FAT
+        sub     edi, RAMDISK_FAT
-	shr	edi, 1
+        shr     edi, 1
-	dec	edi
+        dec     edi
-	mov	eax, [esp+28]
+        mov     eax, [esp+28]
-	mov	ecx, [eax]
+        mov     ecx, [eax]
-	mov	[RAMDISK_FAT+ecx*2], di
+        mov     [RAMDISK_FAT+ecx*2], di
-	mov	[eax], edi
+        mov     [eax], edi
-	shl	edi, 9
+        shl     edi, 9
-	add	edi, (31 shl 9)+RAMDISK
+        add     edi, (31 shl 9)+RAMDISK
-	mov	[esp], edi
+        mov     [esp], edi
-	xor	eax, eax
+        xor     eax, eax
-	mov	ecx, 128
+        mov     ecx, 128
-	rep	stosd
+        rep stosd
-	popa
+        popa
-	clc
+        clc
-	ret
+        ret
 .notfound:
-	popa
+        popa
-	stc
+        stc
-	ret
+        ret
 rd_find_lfn:
 ; in: esi+ebp -> name
 ; out: CF=1 - file not found
 ;      else CF=0 and edi->direntry
-	push	esi edi
+        push    esi edi
-	push	0
+        push    0
-	push	ramdisk_root_first
+        push    ramdisk_root_first
-	push	ramdisk_root_next
+        push    ramdisk_root_next
 .loop:
-	call	fat_find_lfn
+        call    fat_find_lfn
-	jc	.notfound
+        jc      .notfound
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jz	.found
+        jz      .found
 .continue:
-	test	byte [edi+11], 10h
+        test    byte [edi+11], 10h
-	jz	.notfound
+        jz      .notfound
-	movzx	eax, word [edi+26]
+        movzx   eax, word [edi+26]
-	mov	[esp+8], eax
+        mov     [esp+8], eax
-	mov	dword [esp+4], ramdisk_notroot_first
+        mov     dword [esp+4], ramdisk_notroot_first
-	mov	dword [esp], ramdisk_notroot_next
+        mov     dword [esp], ramdisk_notroot_next
-	test	eax, eax
+        test    eax, eax
-	jnz	.loop
+        jnz     .loop
-	mov	dword [esp+4], ramdisk_root_first
+        mov     dword [esp+4], ramdisk_root_first
-	mov	dword [esp], ramdisk_notroot_next
+        mov     dword [esp], ramdisk_notroot_next
-	jmp	.loop
+        jmp     .loop
 .notfound:
-	add	esp, 12
+        add     esp, 12
-	pop	edi esi
+        pop     edi esi
-	stc
+        stc
-	ret
+        ret
 .found:
-	test	ebp, ebp
+        test    ebp, ebp
 ;  ret ebx = bytes read or 0xffffffff file not found
 ;      eax = 0 ok read or other = errormsg
+;
 ;--------------------------------------------------------------
 fs_RamdiskRead:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jnz	@f
+        jnz     @f
-	or	ebx, -1
+        or      ebx, -1
-	mov	eax, 10 	; access denied
+        mov     eax, 10         ; access denied
-	ret
+        ret
 @@:
-	push	edi
+        push    edi
-	call	rd_find_lfn
+        call    rd_find_lfn
-	jnc	.found
+        jnc     .found
-	pop	edi
+        pop     edi
-	or	ebx, -1
+        or      ebx, -1
-	mov	eax, 5		; file not found
+        mov     eax, 5          ; file not found
-	ret
+        ret
 .found:
-	test	ebx, ebx
+        test    ebx, ebx
-	jz	.l1
+        jz      .l1
-	cmp	dword [ebx+4], 0
+        cmp     dword [ebx+4], 0
-	jz	@f
+        jz      @f
-	xor	ebx, ebx
+        xor     ebx, ebx
 .reteof:
-	mov	eax, 6		; EOF
+        mov     eax, 6          ; EOF
-	pop	edi
+        pop     edi
-	ret
+        ret
 @@:
-	mov	ebx, [ebx]
+        mov     ebx, [ebx]
 .l1:
-	push	ecx edx
+        push    ecx edx
-	push	0
+        push    0
-	mov	eax, [edi+28]
+        mov     eax, [edi+28]
-	sub	eax, ebx
+        sub     eax, ebx
-	jb	.eof
+        jb      .eof
-	cmp	eax, ecx
+        cmp     eax, ecx
-	jae	@f
+        jae     @f
-	mov	ecx, eax
+        mov     ecx, eax
-	mov	byte [esp], 6		; EOF
+        mov     byte [esp], 6           ; EOF
 @@:
-	movzx	edi, word [edi+26]	; cluster
+        movzx   edi, word [edi+26]      ; cluster
 .new:
-	jecxz	.done
+        jecxz   .done
-	test	edi, edi
+        test    edi, edi
-	jz	.eof
+        jz      .eof
-	cmp	edi, 0xFF8
+        cmp     edi, 0xFF8
-	jae	.eof
+        jae     .eof
-	lea	eax, [edi+31]		; bootsector+2*fat+filenames
+        lea     eax, [edi+31]           ; bootsector+2*fat+filenames
-	shl	eax, 9			; *512
+        shl     eax, 9                  ; *512
-	add	eax, RAMDISK	       ; image base
+        add     eax, RAMDISK           ; image base
 ; now eax points to data of cluster
-	sub	ebx, 512
+        sub     ebx, 512
-	jae	.skip
+        jae     .skip
-	lea	eax, [eax+ebx+512]
+        lea     eax, [eax+ebx+512]
-	neg	ebx
+        neg     ebx
-	push	ecx
+        push    ecx
-	cmp	ecx, ebx
+        cmp     ecx, ebx
-	jbe	@f
+        jbe     @f
-	mov	ecx, ebx
+        mov     ecx, ebx
 @@:
-	mov	ebx, edx
+        mov     ebx, edx
-	call	memmove
+        call    memmove
-	add	edx, ecx
+        add     edx, ecx
-	sub	[esp], ecx
+        sub     [esp], ecx
-	pop	ecx
+        pop     ecx
-	xor	ebx, ebx
+        xor     ebx, ebx
 .skip:
-	movzx	edi, word [edi*2+RAMDISK_FAT]	   ; find next cluster from FAT
+        movzx   edi, word [edi*2+RAMDISK_FAT]      ; find next cluster from FAT
-	jmp	.new
+        jmp     .new
 .eof:
-	mov	ebx, edx
+        mov     ebx, edx
-	pop	eax edx ecx
+        pop     eax edx ecx
-	sub	ebx, edx
+        sub     ebx, edx
-	jmp	.reteof
+        jmp     .reteof
 .done:
-	mov	ebx, edx
+        mov     ebx, edx
-	pop	eax edx ecx edi
+        pop     eax edx ecx edi
-	sub	ebx, edx
+        sub     ebx, edx
-	ret
+        ret
 ;----------------------------------------------------------------
+;
 ;  fs_RamdiskReadFolder - LFN variant for reading sys floppy folder
 ;  ret ebx = size or 0xffffffff file not found
 ;      eax = 0 ok read or other = errormsg
+;
 ;--------------------------------------------------------------
 fs_RamdiskReadFolder:
-	push	edi
+        push    edi
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jz	.root
+        jz      .root
-	call	rd_find_lfn
+        call    rd_find_lfn
-	jnc	.found
+        jnc     .found
-	pop	edi
+        pop     edi
-	or	ebx, -1
+        or      ebx, -1
-	mov	eax, ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
-	ret
+        ret
 .found:
-	test	byte [edi+11], 0x10
+        test    byte [edi+11], 0x10
-	jnz	.found_dir
+        jnz     .found_dir
-	pop	edi
+        pop     edi
-	or	ebx, -1
+        or      ebx, -1
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	ret
+        ret
 .found_dir:
-	movzx	eax, word [edi+26]
+        movzx   eax, word [edi+26]
-	add	eax, 31
+        add     eax, 31
-	push	0
+        push    0
-	jmp	.doit
+        jmp     .doit
 .root:
-	mov	eax, 19
+        mov     eax, 19
-	push	14
+        push    14
 .doit:
-	push	esi ecx ebp
+        push    esi ecx ebp
-	sub	esp, 262*2	; reserve space for LFN
+        sub     esp, 262*2      ; reserve space for LFN
-	mov	ebp, esp
+        mov     ebp, esp
-	push	dword [ebx+4]	; for fat_get_name: read ANSI/UNICODE names
+        push    dword [ebx+4]   ; for fat_get_name: read ANSI/UNICODE names
-	mov	ebx, [ebx]
+        mov     ebx, [ebx]
 ; init header
-	push	eax ecx
+        push    eax ecx
-	mov	edi, edx
+        mov     edi, edx
-	mov	ecx, 32/4
+        mov     ecx, 32/4
-	xor	eax, eax
+        xor     eax, eax
-	rep	stosd
+        rep stosd
-	mov	byte [edx], 1	; version
+        mov     byte [edx], 1   ; version
-	pop	ecx eax
+        pop     ecx eax
-	mov	esi, edi	; esi points to block of data of folder entry (BDFE)
+        mov     esi, edi        ; esi points to block of data of folder entry (BDFE)
 .main_loop:
-	mov	edi, eax
+        mov     edi, eax
-	shl	edi, 9
+        shl     edi, 9
-	add	edi, RAMDISK
+        add     edi, RAMDISK
-	push	eax
+        push    eax
 .l1:
-	call	fat_get_name
+        call    fat_get_name
-	jc	.l2
+        jc      .l2
-	cmp	byte [edi+11], 0xF
+        cmp     byte [edi+11], 0xF
-	jnz	.do_bdfe
+        jnz     .do_bdfe
-	add	edi, 0x20
+        add     edi, 0x20
-	test	edi, 0x1FF
+        test    edi, 0x1FF
-	jnz	.do_bdfe
+        jnz     .do_bdfe
-	pop	eax
+        pop     eax
-	inc	eax
+        inc     eax
-	dec	byte [esp+262*2+16]
+        dec     byte [esp+262*2+16]
-	jz	.done
+        jz      .done
-	jns	@f
+        jns     @f
 ; read next sector from FAT
-	mov	eax, [(eax-31-1)*2+RAMDISK_FAT]
+        mov     eax, [(eax-31-1)*2+RAMDISK_FAT]
-	and	eax, 0xFFF
+        and     eax, 0xFFF
-	cmp	eax, 0xFF8
+        cmp     eax, 0xFF8
-	jae	.done
+        jae     .done
-	add	eax, 31
+        add     eax, 31
-	mov	byte [esp+262*2+16], 0
+        mov     byte [esp+262*2+16], 0
 @@:
-	mov	edi, eax
+        mov     edi, eax
-	shl	edi, 9
+        shl     edi, 9
-	add	edi, RAMDISK
+        add     edi, RAMDISK
-	push	eax
+        push    eax
 .do_bdfe:
-	inc	dword [edx+8]	; new file found
+        inc     dword [edx+8]   ; new file found
-	dec	ebx
+        dec     ebx
-	jns	.l2
+        jns     .l2
-	dec	ecx
+        dec     ecx
-	js	.l2
+        js      .l2
-	inc	dword [edx+4]  ; new file block copied
+        inc     dword [edx+4]  ; new file block copied
-	call	fat_entry_to_bdfe
+        call    fat_entry_to_bdfe
 .l2:
-	add	edi, 0x20
+        add     edi, 0x20
-	test	edi, 0x1FF
+        test    edi, 0x1FF
-	jnz	.l1
+        jnz     .l1
-	pop	eax
+        pop     eax
-	inc	eax
+        inc     eax
-	dec	byte [esp+262*2+16]
+        dec     byte [esp+262*2+16]
-	jz	.done
+        jz      .done
-	jns	@f
+        jns     @f
 ; read next sector from FAT
-	mov	eax, [(eax-31-1)*2+RAMDISK_FAT]
+        mov     eax, [(eax-31-1)*2+RAMDISK_FAT]
-	and	eax, 0xFFF
+        and     eax, 0xFFF
-	cmp	eax, 0xFF8
+        cmp     eax, 0xFF8
-	jae	.done
+        jae     .done
-	add	eax, 31
+        add     eax, 31
-	mov	byte [esp+262*2+16], 0
+        mov     byte [esp+262*2+16], 0
 @@:
-	jmp	.main_loop
+        jmp     .main_loop
 .done:
-	add	esp, 262*2+4
+        add     esp, 262*2+4
-	pop	ebp
+        pop     ebp
-	mov	ebx, [edx+4]
+        mov     ebx, [edx+4]
-	xor	eax, eax
+        xor     eax, eax
-	dec	ecx
+        dec     ecx
-	js	@f
+        js      @f
-	mov	al, ERROR_END_OF_FILE
+        mov     al, ERROR_END_OF_FILE
 @@:
-	pop	ecx esi edi edi
+        pop     ecx esi edi edi
-	ret
+        ret
 iglobal
 label fat_legal_chars byte
 ; 0 = not allowed
 ; 1 = allowed only in long names
 ; 3 = allowed
-	times 32 db 0
+        times 32 db 0
 ;                 ! " # $ % & ' ( ) * + , - . /
-	db	1,3,0,3,3,3,3,3,3,3,0,1,1,3,3,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
+        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
+        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
+        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
+        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
+        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
+        push    esi
-	xor	eax, eax
+        xor     eax, eax
 @@:
-	lodsb
+        lodsb
-	test	al, al
+        test    al, al
-	jz	.done
+        jz      .done
-	cmp	al, 80h
+        cmp     al, 80h
-	jae	.big
+        jae     .big
-	test	[fat_legal_chars+eax], 1
+        test    [fat_legal_chars+eax], 1
-	jnz	@b
+        jnz     @b
 .err:
-	pop	esi
+        pop     esi
-	clc
+        clc
-	ret
+        ret
 .big:
 ; 0x80-0xAF, 0xE0-0xEF
-	cmp	al, 0xB0
+        cmp     al, 0xB0
-	jb	@b
+        jb      @b
-	cmp	al, 0xE0
+        cmp     al, 0xE0
-	jb	.err
+        jb      .err
-	cmp	al, 0xF0
+        cmp     al, 0xF0
-	jb	@b
+        jb      @b
-	jmp	.err
+        jmp     .err
 .done:
-	sub	esi, [esp]
+        sub     esi, [esp]
-	cmp	esi, 257
+        cmp     esi, 257
-	pop	esi
+        pop     esi
-	ret
+        ret
 fat_next_short_name:
 ; in: edi->8+3 name
 ; out: name corrected
 ;      CF=1 <=> error
-	pushad
+        pushad
-	mov	ecx, 8
+        mov     ecx, 8
-	mov	al, '~'
+        mov     al, '~'
-	std
+        std
-	push	edi
+        push    edi
-	add	edi, 7
+        add     edi, 7
-	repnz	scasb
+        repnz scasb
-	pop	edi
+        pop     edi
-	cld
+        cld
-	jz	.tilde
+        jz      .tilde
 ; tilde is not found, insert "~1" at end
-	add	edi, 6
+        add     edi, 6
-	cmp	word [edi], '  '
+        cmp     word [edi], '  '
-	jnz	.insert_tilde
+        jnz     .insert_tilde
 @@:
         dec     edi
-	cmp	byte [edi], ' '
+        cmp     byte [edi], ' '
-	jz	@b
+        jz      @b
-	inc	edi
+        inc     edi
 .insert_tilde:
-	mov	word [edi], '~1'
+        mov     word [edi], '~1'
-	popad
+        popad
-	clc
+        clc
-	ret
+        ret
 .tilde:
-	push	edi
+        push    edi
-	add	edi, 7
+        add     edi, 7
-	xor	ecx, ecx
+        xor     ecx, ecx
 @@:
 ; after tilde may be only digits and trailing spaces
-	cmp	byte [edi], '~'
+        cmp     byte [edi], '~'
-	jz	.break
+        jz      .break
-	cmp	byte [edi], ' '
+        cmp     byte [edi], ' '
-	jz	.space
+        jz      .space
-	cmp	byte [edi], '9'
+        cmp     byte [edi], '9'
-	jnz	.found
+        jnz     .found
-	dec	edi
+        dec     edi
-	jmp	@b
+        jmp     @b
 .space:
-	dec	edi
+        dec     edi
-	inc	ecx
+        inc     ecx
-	jmp	@b
+        jmp     @b
 .found:
-	inc	byte [edi]
+        inc     byte [edi]
-	add	dword [esp], 8
+        add     dword [esp], 8
-	jmp	.zerorest
+        jmp     .zerorest
 .break:
-	jecxz	.noplace
+        jecxz   .noplace
-	inc	edi
+        inc     edi
-	mov	al, '1'
+        mov     al, '1'
 @@:
-	xchg	al, [edi]
+        xchg    al, [edi]
-	inc	edi
+        inc     edi
-	cmp	al, ' '
+        cmp     al, ' '
-	mov	al, '0'
+        mov     al, '0'
-	jnz	@b
+        jnz     @b
 .succ:
-	pop	edi
+        pop     edi
-	popad
+        popad
-	clc
+        clc
-	ret
+        ret
 .noplace:
-	dec	edi
+        dec     edi
-	cmp	edi, [esp]
+        cmp     edi, [esp]
-	jz	.err
+        jz      .err
-	add	dword [esp], 8
+        add     dword [esp], 8
-	mov	word [edi], '~1'
+        mov     word [edi], '~1'
-	inc	edi
+        inc     edi
-	inc	edi
+        inc     edi
 @@:
-	mov	byte [edi], '0'
+        mov     byte [edi], '0'
 .zerorest:
-	inc	edi
+        inc     edi
-	cmp	edi, [esp]
+        cmp     edi, [esp]
-	jb	@b
+        jb      @b
-	pop	edi
+        pop     edi
-	popad
+        popad
-	;clc    ; automatically
+        ;clc    ; automatically
-	ret
+        ret
 .err:
-	pop	edi
+        pop     edi
-	popad
+        popad
-	stc
+        stc
-	ret
+        ret
 fat_gen_short_name:
 ; in: esi->long name
 ;     edi->buffer (8+3=11 chars)
 ; out: buffer filled
-	pushad
+        pushad
-	mov	eax, '    '
+        mov     eax, '    '
-	push	edi
+        push    edi
-	stosd
+        stosd
-	stosd
+        stosd
-	stosd
+        stosd
-	pop	edi
+        pop     edi
-	xor	eax, eax
+        xor     eax, eax
-	push	8
+        push    8
-	pop	ebx
+        pop     ebx
-	lea	ecx, [edi+8]
+        lea     ecx, [edi+8]
 .loop:
-	lodsb
+        lodsb
-	test	al, al
+        test    al, al
-	jz	.done
+        jz      .done
-	call	char_toupper
+        call    char_toupper
-	cmp	al, ' '
+        cmp     al, ' '
-	jz	.space
+        jz      .space
-	cmp	al, 80h
+        cmp     al, 80h
-	ja	.big
+        ja      .big
-	test	[fat_legal_chars+eax], 2
+        test    [fat_legal_chars+eax], 2
-	jnz	.symbol
+        jnz     .symbol
 .inv_symbol:
-	mov	al, '_'
+        mov     al, '_'
-	or	bh, 1
+        or      bh, 1
 .symbol:
-	cmp	al, '.'
+        cmp     al, '.'
-	jz	.dot
+        jz      .dot
 .normal_symbol:
-	dec	bl
+        dec     bl
-	jns	.store
+        jns     .store
-	mov	bl, 0
+        mov     bl, 0
 .space:
-	or	bh, 1
+        or      bh, 1
-	jmp	.loop
+        jmp     .loop
 .store:
-	stosb
+        stosb
-	jmp	.loop
+        jmp     .loop
 .big:
-	cmp	al, 0xB0
+        cmp     al, 0xB0
-	jb	.normal_symbol
+        jb      .normal_symbol
-	cmp	al, 0xE0
+        cmp     al, 0xE0
-	jb	.inv_symbol
+        jb      .inv_symbol
-	cmp	al, 0xF0
+        cmp     al, 0xF0
-	jb	.normal_symbol
+        jb      .normal_symbol
-	jmp	.inv_symbol
+        jmp     .inv_symbol
 .dot:
-	test	bh, 2
+        test    bh, 2
-	jz	.firstdot
+        jz      .firstdot
-	pop	ebx
+        pop     ebx
-	add	ebx, edi
+        add     ebx, edi
-	sub	ebx, ecx
+        sub     ebx, ecx
-	push	ebx
+        push    ebx
-	cmp	ebx, ecx
+        cmp     ebx, ecx
-	jb	@f
+        jb      @f
-	pop	ebx
+        pop     ebx
-	push	ecx
+        push    ecx
 @@:
-	cmp	edi, ecx
+        cmp     edi, ecx
-	jbe	.skip
+        jbe     .skip
 @@:
-	dec	edi
+        dec     edi
-	mov	al, [edi]
+        mov     al, [edi]
-	dec	ebx
+        dec     ebx
-	mov	[ebx], al
+        mov     [ebx], al
-	mov	byte [edi], ' '
+        mov     byte [edi], ' '
-	cmp	edi, ecx
+        cmp     edi, ecx
-	ja	@b
+        ja      @b
 .skip:
-	mov	bh, 3
+        mov     bh, 3
-	jmp	@f
+        jmp     @f
 .firstdot:
-	cmp	bl, 8
+        cmp     bl, 8
-	jz	.space
+        jz      .space
-	push	edi
+        push    edi
-	or	bh, 2
+        or      bh, 2
 @@:
-	mov	edi, ecx
+        mov     edi, ecx
-	mov	bl, 3
+        mov     bl, 3
-	jmp	.loop
+        jmp     .loop
 .done:
-	test	bh, 2
+        test    bh, 2
-	jz	@f
+        jz      @f
-	pop	edi
+        pop     edi
 @@:
-	lea	edi, [ecx-8]
+        lea     edi, [ecx-8]
-	test	bh, 1
+        test    bh, 1
-	jz	@f
+        jz      @f
-	call	fat_next_short_name
+        call    fat_next_short_name
 @@:
-	popad
+        popad
-	ret
+        ret
 ;  ret ebx = number of written bytes
 ;      eax = 0 ok read or other = errormsg
+;
 ;--------------------------------------------------------------
 @@:
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 fs_RamdiskCreateFolder:
-	mov	al, 1		; create folder
+        mov     al, 1           ; create folder
-	jmp	fs_RamdiskRewrite.common
+        jmp     fs_RamdiskRewrite.common
 fs_RamdiskRewrite:
-	xor	eax, eax	; create file
+        xor     eax, eax        ; create file
 .common:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jz	@b
+        jz      @b
-	pushad
+        pushad
-	xor	edi, edi
+        xor     edi, edi
-	push	esi
+        push    esi
-	test	ebp, ebp
+        test    ebp, ebp
-	jz	@f
+        jz      @f
-	mov	esi, ebp
+        mov     esi, ebp
 @@:
-	lodsb
+        lodsb
-	test	al, al
+        test    al, al
-	jz	@f
+        jz      @f
-	cmp	al, '/'
+        cmp     al, '/'
-	jnz	@b
+        jnz     @b
-	lea	edi, [esi-1]
+        lea     edi, [esi-1]
-	jmp	@b
+        jmp     @b
 @@:
-	pop	esi
+        pop     esi
-	test	edi, edi
+        test    edi, edi
-	jnz	.noroot
+        jnz     .noroot
-	test	ebp, ebp
+        test    ebp, ebp
-	jnz	.hasebp
+        jnz     .hasebp
-	push	ramdisk_root_extend_dir
+        push    ramdisk_root_extend_dir
-	push	ramdisk_root_next_write
+        push    ramdisk_root_next_write
-	push	edi
+        push    edi
-	push	ramdisk_root_first
+        push    ramdisk_root_first
-	push	ramdisk_root_next
+        push    ramdisk_root_next
-	jmp	.common1
+        jmp     .common1
 .hasebp:
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	cmp	byte [ebp], 0
+        cmp     byte [ebp], 0
-	jz	.ret1
+        jz      .ret1
-	push	ebp
+        push    ebp
-	xor	ebp, ebp
+        xor     ebp, ebp
-	call	rd_find_lfn
+        call    rd_find_lfn
-	pop	esi
+        pop     esi
-	jc	.notfound0
+        jc      .notfound0
-	jmp	.common0
+        jmp     .common0
 .noroot:
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	cmp	byte [edi+1], 0
+        cmp     byte [edi+1], 0
-	jz	.ret1
+        jz      .ret1
 ; check existence
-	mov	byte [edi], 0
+        mov     byte [edi], 0
-	push	edi
+        push    edi
-	call	rd_find_lfn
+        call    rd_find_lfn
-	pop	esi
+        pop     esi
-	mov	byte [esi], '/'
+        mov     byte [esi], '/'
-	jnc	@f
+        jnc     @f
 .notfound0:
-	mov	eax, ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
 .ret1:
-	mov	[esp+28], eax
+        mov     [esp+28], eax
-	popad
+        popad
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 @@:
-	inc	esi
+        inc     esi
 .common0:
-	test	byte [edi+11], 0x10	; must be directory
+        test    byte [edi+11], 0x10     ; must be directory
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	jz	.ret1
+        jz      .ret1
-	movzx	ebp, word [edi+26]	; ebp=cluster
+        movzx   ebp, word [edi+26]      ; ebp=cluster
-	mov	eax, ERROR_FAT_TABLE
+        mov     eax, ERROR_FAT_TABLE
-	cmp	ebp, 2
+        cmp     ebp, 2
-	jb	.ret1
+        jb      .ret1
-	cmp	ebp, 2849
+        cmp     ebp, 2849
-	jae	.ret1
+        jae     .ret1
-	push	ramdisk_notroot_extend_dir
+        push    ramdisk_notroot_extend_dir
-	push	ramdisk_notroot_next_write
+        push    ramdisk_notroot_next_write
-	push	ebp
+        push    ebp
-	push	ramdisk_notroot_first
+        push    ramdisk_notroot_first
-	push	ramdisk_notroot_next
+        push    ramdisk_notroot_next
 .common1:
-	call	fat_find_lfn
+        call    fat_find_lfn
-	jc	.notfound
+        jc      .notfound
 ; found
-	test	byte [edi+11], 10h
+        test    byte [edi+11], 10h
-	jz	.exists_file
+        jz      .exists_file
 ; found directory; if we are creating directory, return OK,
 ;                  if we are creating file, say "access denied"
-	add	esp, 20
+        add     esp, 20
-	popad
+        popad
-	test	al, al
+        test    al, al
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	jz	@f
+        jz      @f
-	mov	al, 0
+        mov     al, 0
 @@:
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        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
+        cmp     byte [esp+20+28], 0
-	jz	@f
+        jz      @f
-	add	esp, 20
+        add     esp, 20
-	popad
+        popad
-	mov	eax, ERROR_ACCESS_DENIED
+        mov     eax, ERROR_ACCESS_DENIED
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 @@:
 ; delete FAT chain
-	push	edi
+        push    edi
-	xor	eax, eax
+        xor     eax, eax
-	mov	dword [edi+28], eax	; zero size
+        mov     dword [edi+28], eax     ; zero size
-	xchg	ax, word [edi+26]	; start cluster
+        xchg    ax, word [edi+26]       ; start cluster
-	test	eax, eax
+        test    eax, eax
-	jz	.done1
+        jz      .done1
 @@:
-	cmp	eax, 0xFF8
+        cmp     eax, 0xFF8
-	jae	.done1
+        jae     .done1
-	lea	edi, [RAMDISK_FAT + eax*2] ; position in FAT
+        lea     edi, [RAMDISK_FAT + eax*2] ; position in FAT
-	xor	eax, eax
+        xor     eax, eax
-	xchg	ax, [edi]
+        xchg    ax, [edi]
-	jmp	@b
+        jmp     @b
 .done1:
-	pop	edi
+        pop     edi
-	call	get_time_for_file
+        call    get_time_for_file
-	mov	[edi+22], ax
+        mov     [edi+22], ax
-	call	get_date_for_file
+        call    get_date_for_file
-	mov	[edi+24], ax
+        mov     [edi+24], ax
-	mov	[edi+18], ax
+        mov     [edi+18], ax
-	or	byte [edi+11], 20h	; set 'archive' attribute
+        or      byte [edi+11], 20h      ; set 'archive' attribute
-	jmp	.doit
+        jmp     .doit
 .notfound:
 ; file is not found; generate short name
-	call	fat_name_is_legal
+        call    fat_name_is_legal
-	jc	@f
+        jc      @f
-	add	esp, 20
+        add     esp, 20
-	popad
+        popad
-	mov	eax, ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 @@:
-	sub	esp, 12
+        sub     esp, 12
-	mov	edi, esp
+        mov     edi, esp
-	call	fat_gen_short_name
+        call    fat_gen_short_name
 .test_short_name_loop:
-	push	esi edi ecx
+        push    esi edi ecx
-	mov	esi, edi
+        mov     esi, edi
-	lea	eax, [esp+12+12+8]
+        lea     eax, [esp+12+12+8]
-	mov	[eax], ebp
+        mov     [eax], ebp
-	call	dword [eax-4]
+        call    dword [eax-4]
-	jc	.found
+        jc      .found
 .test_short_name_entry:
-	cmp	byte [edi+11], 0xF
+        cmp     byte [edi+11], 0xF
-	jz	.test_short_name_cont
+        jz      .test_short_name_cont
-	mov	ecx, 11
+        mov     ecx, 11
-	push	esi edi
+        push    esi edi
-	repz	cmpsb
+        repz cmpsb
-	pop	edi esi
+        pop     edi esi
-	jz	.short_name_found
+        jz      .short_name_found
 .test_short_name_cont:
-	lea	eax, [esp+12+12+8]
+        lea     eax, [esp+12+12+8]
-	call	dword [eax-8]
+        call    dword [eax-8]
-	jnc	.test_short_name_entry
+        jnc     .test_short_name_entry
-	jmp	.found
+        jmp     .found
 .short_name_found:
-	pop	ecx edi esi
+        pop     ecx edi esi
-	call	fat_next_short_name
+        call    fat_next_short_name
-	jnc	.test_short_name_loop
+        jnc     .test_short_name_loop
 .disk_full:
-	add	esp, 12+20
+        add     esp, 12+20
-	popad
+        popad
-	mov	eax, ERROR_DISK_FULL
+        mov     eax, ERROR_DISK_FULL
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 .found:
-	pop	ecx edi esi
+        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, '~'
+        mov     al, '~'
-	push	ecx edi
+        push    ecx edi
-	mov	ecx, 8
+        mov     ecx, 8
-	repnz	scasb
+        repnz scasb
-	push	1
+        push    1
-	pop	eax	; 1 entry
+        pop     eax     ; 1 entry
-	jnz	.notilde
+        jnz     .notilde
 ; we need ceil(strlen(esi)/13) additional entries = floor((strlen(esi)+12+13)/13) total
-	xor	eax, eax
+        xor     eax, eax
 @@:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jz	@f
+        jz      @f
-	inc	esi
+        inc     esi
-	inc	eax
+        inc     eax
-	jmp	@b
+        jmp     @b
 @@:
-	sub	esi, eax
+        sub     esi, eax
-	add	eax, 12+13
+        add     eax, 12+13
-	mov	ecx, 13
+        mov     ecx, 13
-	push	edx
+        push    edx
-	cdq
+        cdq
-	div	ecx
+        div     ecx
-	pop	edx
+        pop     edx
 .notilde:
-	push	-1
+        push    -1
-	push	-1
+        push    -1
 ; find  successive entries in directory
-	xor	ecx, ecx
+        xor     ecx, ecx
-	push	eax
+        push    eax
-	lea	eax, [esp+12+8+12+8]
+        lea     eax, [esp+12+8+12+8]
-	mov	[eax], ebp
+        mov     [eax], ebp
-	call	dword [eax-4]
+        call    dword [eax-4]
-	pop	eax
+        pop     eax
 .scan_dir:
-	cmp	byte [edi], 0
+        cmp     byte [edi], 0
-	jz	.free
+        jz      .free
-	cmp	byte [edi], 0xE5
+        cmp     byte [edi], 0xE5
-	jz	.free
+        jz      .free
-	xor	ecx, ecx
+        xor     ecx, ecx
 .scan_cont:
-	push	eax
+        push    eax
-	lea	eax, [esp+12+8+12+8]
+        lea     eax, [esp+12+8+12+8]
-	call	dword [eax-8]
+        call    dword [eax-8]
-	pop	eax
+        pop     eax
-	jnc	.scan_dir
+        jnc     .scan_dir
-	push	eax
+        push    eax
-	lea	eax, [esp+12+8+12+8]
+        lea     eax, [esp+12+8+12+8]
-	call	dword [eax+8]		; extend directory
+        call    dword [eax+8]           ; extend directory
-	pop	eax
+        pop     eax
-	jnc	.scan_dir
+        jnc     .scan_dir
-	add	esp, 8+8+12+20
+        add     esp, 8+8+12+20
-	popad
+        popad
-	mov	eax, ERROR_DISK_FULL
+        mov     eax, ERROR_DISK_FULL
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 .free:
-	test	ecx, ecx
+        test    ecx, ecx
-	jnz	@f
+        jnz     @f
-	mov	[esp], edi
+        mov     [esp], edi
-	mov	ecx, [esp+8+8+12+8]
+        mov     ecx, [esp+8+8+12+8]
-	mov	[esp+4], ecx
+        mov     [esp+4], ecx
-	xor	ecx, ecx
+        xor     ecx, ecx
 @@:
-	inc	ecx
+        inc     ecx
-	cmp	ecx, eax
+        cmp     ecx, eax
+        jb      .scan_cont
+; found!
+; If creating a directory, allocate one data cluster now and fail immediately
+; if this is impossible. This prevents from creating an invalid directory entry
+; on a full disk.
+; yup, the argument is quite non-intuitive... but what should I do if
+; the entire function uses such arguments? BTW, it refers to al from pushad,
+; which in turn is filled with 0 in fs_RamdiskRewrite and 1 in fs_RamdiskCreateFolder.
+        push    esi ecx
+        cmp     byte [esp+24+12+20+28], 0
+        jz      .no.preallocate.folder.data
+        mov     ecx, 2849
+        mov     edi, RAMDISK_FAT
+        xor     eax, eax
+        repnz scasw
+        jz      @f
+        add     esp, 24
+        jmp     .disk_full
+@@:
-	jb	.scan_cont
+        mov     [esp+24+12+20+20], edi  ; store the cluster somewhere
-; found!
-; calculate name checksum
+.no.preallocate.folder.data:
-	push	esi ecx
+; calculate name checksum
-	mov	esi, [esp+8+8]
+        mov     esi, [esp+8+8]
-	mov	ecx, 11
+        mov     ecx, 11
-	xor	eax, eax
+        xor     eax, eax
 @@:
-	ror	al, 1
+        ror     al, 1
-	add	al, [esi]
+        add     al, [esi]
-	inc	esi
+        inc     esi
-	loop	@b
+        loop    @b
-	pop	ecx esi
+        pop     ecx esi
-	pop	edi
+        pop     edi
-	pop	dword [esp+8+12+8]
+        pop     dword [esp+8+12+8]
 ; edi points to last entry in free chunk
-	dec	ecx
+        dec     ecx
-	jz	.nolfn
+        jz      .nolfn
-	push	esi
+        push    esi
-	push	eax
+        push    eax
-	mov	al, 40h
+        mov     al, 40h
 .writelfn:
-	or	al, cl
+        or      al, cl
-	mov	esi, [esp+4]
+        mov     esi, [esp+4]
-	push	ecx
+        push    ecx
-	dec	ecx
+        dec     ecx
-	imul	ecx, 13
+        imul    ecx, 13
-	add	esi, ecx
+        add     esi, ecx
-	stosb
+        stosb
-	mov	cl, 5
+        mov     cl, 5
-	call	.read_symbols
+        call    .read_symbols
-	mov	ax, 0xF
+        mov     ax, 0xF
-	stosw
+        stosw
-	mov	al, [esp+4]
+        mov     al, [esp+4]
-	stosb
+        stosb
-	mov	cl, 6
+        mov     cl, 6
-	call	.read_symbols
+        call    .read_symbols
-	xor	eax, eax
+        xor     eax, eax
-	stosw
+        stosw
-	mov	cl, 2
+        mov     cl, 2
-	call	.read_symbols
+        call    .read_symbols
-	pop	ecx
+        pop     ecx
-	lea	eax, [esp+8+8+12+8]
+        lea     eax, [esp+8+8+12+8]
-	call	dword [eax+4]	; next write
+        call    dword [eax+4]   ; next write
-	xor	eax, eax
+        xor     eax, eax
-	loop	.writelfn
+        loop    .writelfn
-	pop	eax
+        pop     eax
-	pop	esi
+        pop     esi
 .nolfn:
-	xchg	esi, [esp]
+        xchg    esi, [esp]
-	mov	ecx, 11
+        mov     ecx, 11
-	rep	movsb
+        rep movsb
-	mov	word [edi], 20h 	; attributes
+        mov     word [edi], 20h         ; attributes
-	sub	edi, 11
+        sub     edi, 11
-	pop	esi ecx
+        pop     esi ecx
-	add	esp, 12
+        add     esp, 12
-	mov	byte [edi+13], 0	; tenths of a second at file creation time
+        mov     byte [edi+13], 0        ; tenths of a second at file creation time
-	call	get_time_for_file
+        call    get_time_for_file
-	mov	[edi+14], ax		; creation time
+        mov     [edi+14], ax            ; creation time
-	mov	[edi+22], ax		; last write time
+        mov     [edi+22], ax            ; last write time
-	call	get_date_for_file
+        call    get_date_for_file
-	mov	[edi+16], ax		; creation date
+        mov     [edi+16], ax            ; creation date
-	mov	[edi+24], ax		; last write date
+        mov     [edi+24], ax            ; last write date
-	mov	[edi+18], ax		; last access date
+        mov     [edi+18], ax            ; last access date
-	and	word [edi+20], 0	; high word of cluster
+        and     word [edi+20], 0        ; high word of cluster
-	and	word [edi+26], 0	; low word of cluster - to be filled
+        and     word [edi+26], 0        ; low word of cluster - to be filled
-	and	dword [edi+28], 0	; file size - to be filled
+        and     dword [edi+28], 0       ; file size - to be filled
-	cmp	byte [esp+20+28], 0
+        cmp     byte [esp+20+28], 0
-	jz	.doit
+        jz      .doit
 ; create directory
-	mov	byte [edi+11], 10h	   ; attributes: folder
+        mov     byte [edi+11], 10h         ; attributes: folder
+        mov     ecx, 32*2
+        mov     edx, edi
+        push    edx
+        push    ecx
+        push    edi
+        add     edi, 26         ; edi points to low word of cluster
+        push    edi
-	mov	ecx, 32*2
+        mov     edi, [esp+16+20+20]
-	mov	edx, edi
+        jmp     .doit2
 .doit:
-	push	edx
+        push    edx
-	push	ecx
+        push    ecx
-	push	edi
+        push    edi
-	add	edi, 26 	; edi points to low word of cluster
+        add     edi, 26         ; edi points to low word of cluster
-	push	edi
+        push    edi
-	jecxz	.done
+        jecxz   .done
-	mov	ecx, 2849
+        mov     ecx, 2849
-	mov	edi, RAMDISK_FAT
+        mov     edi, RAMDISK_FAT
 .write_loop:
 ; allocate new cluster
-	xor	eax, eax
+        xor     eax, eax
-	repnz	scasw
+        repnz scasw
+        jnz     .disk_full2
-	jnz	.disk_full2
+.doit2:
-	dec	edi
+        dec     edi
-	dec	edi
+        dec     edi
     ;    lea     eax, [edi-(RAMDISK_FAT)]
-	mov eax, edi
+        mov     eax, edi
-	sub eax, RAMDISK_FAT
+        sub     eax, RAMDISK_FAT
-	shr	eax, 1			; eax = cluster
+        shr     eax, 1                  ; eax = cluster
-	mov	word [edi], 0xFFF	; mark as last cluster
+        mov     word [edi], 0xFFF       ; mark as last cluster
-	xchg	edi, [esp]
+        xchg    edi, [esp]
-	stosw
+        stosw
-	pop	edi
+        pop     edi
-	push	edi
+        push    edi
-	inc	ecx
+        inc     ecx
 ; write data
-	cmp	byte [esp+16+20+28], 0
+        cmp     byte [esp+16+20+28], 0
-	jnz	.writedir
+        jnz     .writedir
-	shl	eax, 9
+        shl     eax, 9
-	add	eax, RAMDISK+31*512
+        add     eax, RAMDISK+31*512
 .writefile:
-	mov	ebx, edx
+        mov     ebx, edx
-	xchg	eax, ebx
+        xchg    eax, ebx
-	push	ecx
+        push    ecx
-	mov	ecx, 512
+        mov     ecx, 512
-	cmp	dword [esp+12], ecx
+        cmp     dword [esp+12], ecx
-	jae	@f
+        jae     @f
-	mov	ecx, [esp+12]
+        mov     ecx, [esp+12]
 @@:
-	call	memmove
+        call    memmove
-	add	edx, ecx
+        add     edx, ecx
-	sub	[esp+12], ecx
+        sub     [esp+12], ecx
-	pop	ecx
+        pop     ecx
-	jnz	.write_loop
+        jnz     .write_loop
 .done:
-	mov	ebx, edx
+        mov     ebx, edx
-	pop	edi edi ecx edx
+        pop     edi edi ecx edx
-	sub	ebx, edx
+        sub     ebx, edx
-	mov	[edi+28], ebx
+        mov     [edi+28], ebx
-	add	esp, 20
+        add     esp, 20
-	mov	[esp+16], ebx
+        mov     [esp+16], ebx
-	popad
+        popad
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret
 .disk_full2:
-	mov	ebx, edx
+        mov     ebx, edx
-	pop	edi edi ecx edx
+        pop     edi edi ecx edx
-	sub	ebx, edx
+        sub     ebx, edx
-	mov	[edi+28], ebx
+        mov     [edi+28], ebx
-	add	esp, 20
+        add     esp, 20
-	mov	[esp+16], ebx
+        mov     [esp+16], ebx
-	popad
+        popad
-	push	ERROR_DISK_FULL
+        push    ERROR_DISK_FULL
-	pop	eax
+        pop     eax
-	ret
+        ret
 .writedir:
-	mov	edi, eax
+        mov     edi, eax
-	shl	edi, 9
+        shl     edi, 9
-	add	edi, RAMDISK+31*512
+        add     edi, RAMDISK+31*512
-	mov	esi, edx
+        mov     esi, edx
-	mov	ecx, 32/4
+        mov     ecx, 32/4
-	push	ecx
+        push    ecx
-	rep	movsd
+        rep movsd
-	mov	dword [edi-32], '.   '
+        mov     dword [edi-32], '.   '
-	mov	dword [edi-32+4], '    '
+        mov     dword [edi-32+4], '    '
-	mov	dword [edi-32+8], '    '
+        mov     dword [edi-32+8], '    '
-	mov	byte [edi-32+11], 10h
+        mov     byte [edi-32+11], 10h
-	mov	word [edi-32+26], ax
+        mov     word [edi-32+26], ax
-	mov	esi, edx
+        mov     esi, edx
-	pop	ecx
+        pop     ecx
-	rep	movsd
+        rep movsd
-	mov	dword [edi-32], '..  '
+        mov     dword [edi-32], '..  '
-	mov	dword [edi-32+4], '    '
+        mov     dword [edi-32+4], '    '
-	mov	dword [edi-32+8], '    '
+        mov     dword [edi-32+8], '    '
-	mov	byte [edi-32+11], 10h
+        mov     byte [edi-32+11], 10h
-	mov	eax, [esp+16+8]
+        mov     eax, [esp+16+8]
-	mov	word [edi-32+26], ax
+        mov     word [edi-32+26], ax
-	xor	eax, eax
+        xor     eax, eax
-	mov	ecx, (512-32*2)/4
+        mov     ecx, (512-32*2)/4
-	rep	stosd
+        rep stosd
-	pop	edi edi ecx edx
+        pop     edi edi ecx edx
-	add	esp, 20
+        add     esp, 20
-	popad
+        popad
-	xor	eax, eax
+        xor     eax, eax
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 .read_symbol:
-	or	ax, -1
+        or      ax, -1
-	test	esi, esi
+        test    esi, esi
-	jz	.retFFFF
+        jz      .retFFFF
-	lodsb
+        lodsb
-	test	al, al
+        test    al, al
-	jnz	ansi2uni_char
+        jnz     ansi2uni_char
-	xor	eax, eax
+        xor     eax, eax
-	xor	esi, esi
+        xor     esi, esi
 .retFFFF:
-	ret
+        ret
 .read_symbols:
-	call	.read_symbol
+        call    .read_symbol
 ;  ret ebx = bytes written (maybe 0)
 ;      eax = 0 ok write or other = errormsg
+;
 ;--------------------------------------------------------------
 @@:
-	push	ERROR_ACCESS_DENIED
+        push    ERROR_ACCESS_DENIED
 fs_RamdiskWrite.ret0:
-	pop	eax
+        pop     eax
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 fs_RamdiskWrite:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jz	@b
+        jz      @b
-	pushad
+        pushad
-	call	rd_find_lfn
+        call    rd_find_lfn
-	jnc	.found
+        jnc     .found
-	popad
+        popad
-	push	ERROR_FILE_NOT_FOUND
+        push    ERROR_FILE_NOT_FOUND
-	jmp	.ret0
+        jmp     .ret0
 .found:
 ; must not be directory
-	test	byte [edi+11], 10h
+        test    byte [edi+11], 10h
-	jz	@f
+        jz      @f
-	popad
+        popad
-	push	ERROR_ACCESS_DENIED
+        push    ERROR_ACCESS_DENIED
-	jmp	.ret0
+        jmp     .ret0
 @@:
 ; FAT does not support files larger than 4GB
-	test	ebx, ebx
+        test    ebx, ebx
-	jz	.l1
+        jz      .l1
-	cmp	dword [ebx+4], 0
+        cmp     dword [ebx+4], 0
-	jz	@f
+        jz      @f
 .eof:
-	popad
+        popad
-	push	ERROR_END_OF_FILE
+        push    ERROR_END_OF_FILE
-	jmp	.ret0
+        jmp     .ret0
 @@:
-	mov	ebx, [ebx]
+        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
+        call    fat_update_datetime
 ; extend file if needed
-	add	ecx, ebx
+        add     ecx, ebx
-	jc	.eof	; FAT does not support files larger than 4GB
+        jc      .eof    ; FAT does not support files larger than 4GB
-	push	0	; return value=0
+        push    0       ; return value=0
-	cmp	ecx, [edi+28]
+        cmp     ecx, [edi+28]
-	jbe	.length_ok
+        jbe     .length_ok
-	cmp	ecx, ebx
+        cmp     ecx, ebx
-	jz	.length_ok
+        jz      .length_ok
-	call	ramdisk_extend_file
+        call    ramdisk_extend_file
-	jnc	.length_ok
+        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
+        mov     [esp], eax
-	cmp	al, ERROR_DISK_FULL
+        cmp     al, ERROR_DISK_FULL
-	jz	.disk_full
+        jz      .disk_full
-	pop	eax
+        pop     eax
-	mov	[esp+28], eax
+        mov     [esp+28], eax
-	popad
+        popad
-	xor	ebx, ebx
+        xor     ebx, ebx
-	ret
+        ret
 .disk_full:
 ; correct number of bytes to write
-	mov	ecx, [edi+28]
+        mov     ecx, [edi+28]
-	cmp	ecx, ebx
+        cmp     ecx, ebx
-	ja	.length_ok
+        ja      .length_ok
 .ret:
-	pop	eax
+        pop     eax
-	mov	[esp+28], eax	; eax=return value
+        mov     [esp+28], eax   ; eax=return value
-	sub	edx, [esp+20]
+        sub     edx, [esp+20]
-	mov	[esp+16], edx	; ebx=number of written bytes
+        mov     [esp+16], edx   ; ebx=number of written bytes
-	popad
+        popad
-	ret
+        ret
 .length_ok:
 ; now ebx=start pos, ecx=end pos, both lie inside file
-	sub	ecx, ebx
+        sub     ecx, ebx
-	jz	.ret
+        jz      .ret
-	movzx	edi, word [edi+26]	; starting cluster
+        movzx   edi, word [edi+26]      ; starting cluster
 .write_loop:
-	sub	ebx, 0x200
+        sub     ebx, 0x200
-	jae	.next_cluster
+        jae     .next_cluster
-	push	ecx
+        push    ecx
-	neg	ebx
+        neg     ebx
-	cmp	ecx, ebx
+        cmp     ecx, ebx
-	jbe	@f
+        jbe     @f
-	mov	ecx, ebx
+        mov     ecx, ebx
 @@:
-	mov	eax, edi
+        mov     eax, edi
-	shl	eax, 9
+        shl     eax, 9
-	add	eax, RAMDISK+31*512+0x200
+        add     eax, RAMDISK+31*512+0x200
-	sub	eax, ebx
+        sub     eax, ebx
-	mov	ebx, eax
+        mov     ebx, eax
-	mov	eax, edx
+        mov     eax, edx
-	call	memmove
+        call    memmove
-	xor	ebx, ebx
+        xor     ebx, ebx
-	add	edx, ecx
+        add     edx, ecx
-	sub	[esp], ecx
+        sub     [esp], ecx
-	pop	ecx
+        pop     ecx
-	jz	.ret
+        jz      .ret
 .next_cluster:
-	movzx	edi, word [edi*2+RAMDISK_FAT]
+        movzx   edi, word [edi*2+RAMDISK_FAT]
-	jmp	.write_loop
+        jmp     .write_loop
 ramdisk_extend_file.zero_size:
-	xor	eax, eax
+        xor     eax, eax
-	jmp	ramdisk_extend_file.start_extend
+        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
+        push    ecx
 ; find the last cluster of file
-	movzx	eax, word [edi+26]	; first cluster
+        movzx   eax, word [edi+26]      ; first cluster
-	mov	ecx, [edi+28]
+        mov     ecx, [edi+28]
-	jecxz	.zero_size
+        jecxz   .zero_size
 @@:
-	sub	ecx, 0x200
+        sub     ecx, 0x200
-	jbe	@f
+        jbe     @f
-	mov	eax, [eax*2+RAMDISK_FAT]
+        mov     eax, [eax*2+RAMDISK_FAT]
-	and	eax, 0xFFF
+        and     eax, 0xFFF
-	jz	.fat_err
+        jz      .fat_err
-	cmp	eax, 0xFF8
+        cmp     eax, 0xFF8
-	jb	@b
+        jb      @b
 .fat_err:
-	pop	ecx
+        pop     ecx
-	push	ERROR_FAT_TABLE
+        push    ERROR_FAT_TABLE
-	pop	eax
+        pop     eax
-	stc
+        stc
-	ret
+        ret
 @@:
-	push	eax
+        push    eax
-	mov	eax, [eax*2+RAMDISK_FAT]
+        mov     eax, [eax*2+RAMDISK_FAT]
-	and	eax, 0xFFF
+        and     eax, 0xFFF
-	cmp	eax, 0xFF8
+        cmp     eax, 0xFF8
-	pop	eax
+        pop     eax
-	jb	.fat_err
+        jb      .fat_err
 ; set length to full number of sectors and make sure that last sector is zero-padded
-	sub	[edi+28], ecx
+        sub     [edi+28], ecx
-	push	eax edi
+        push    eax edi
-	mov	edi, eax
+        mov     edi, eax
-	shl	edi, 9
+        shl     edi, 9
-	lea	edi, [edi+RAMDISK+31*512+0x200+ecx]
+        lea     edi, [edi+RAMDISK+31*512+0x200+ecx]
-	neg	ecx
+        neg     ecx
-	xor	eax, eax
+        xor     eax, eax
-	rep	stosb
+        rep stosb
-	pop	edi eax
+        pop     edi eax
 .start_extend:
-	pop	ecx
+        pop     ecx
 ; now do extend
-	push	edx esi
+        push    edx esi
-	mov	esi, RAMDISK_FAT+2*2	   ; start scan from cluster 2
+        mov     esi, RAMDISK_FAT+2*2       ; start scan from cluster 2
-	mov	edx, 2847		; number of clusters to scan
+        mov     edx, 2847               ; number of clusters to scan
 .extend_loop:
-	cmp	[edi+28], ecx
+        cmp     [edi+28], ecx
-	jae	.extend_done
+        jae     .extend_done
 ; add new sector
-	push	ecx
+        push    ecx
-	mov	ecx, edx
+        mov     ecx, edx
-	push	edi
+        push    edi
-	mov	edi, esi
+        mov     edi, esi
-	jecxz	.disk_full
+        jecxz   .disk_full
-	push	eax
+        push    eax
-	xor	eax, eax
+        xor     eax, eax
-	repnz	scasw
+        repnz scasw
-	pop	eax
+        pop     eax
-	jnz	.disk_full
+        jnz     .disk_full
-	mov	word [edi-2], 0xFFF
+        mov     word [edi-2], 0xFFF
-	mov	esi, edi
+        mov     esi, edi
-	mov	edx, ecx
+        mov     edx, ecx
-	sub	edi, RAMDISK_FAT
+        sub     edi, RAMDISK_FAT
-	shr	edi, 1
+        shr     edi, 1
-	dec	edi	; now edi=new cluster
+        dec     edi     ; now edi=new cluster
-	test	eax, eax
+        test    eax, eax
-	jz	.first_cluster
+        jz      .first_cluster
-	mov	[RAMDISK_FAT+eax*2], di
+        mov     [RAMDISK_FAT+eax*2], di
-	jmp	@f
+        jmp     @f
 .first_cluster:
-	pop	eax	; eax->direntry
+        pop     eax     ; eax->direntry
-	push	eax
+        push    eax
-	mov	[eax+26], di
+        mov     [eax+26], di
 @@:
-	push	edi
+        push    edi
-	shl	edi, 9
+        shl     edi, 9
-	add	edi, RAMDISK+31*512
+        add     edi, RAMDISK+31*512
-	xor	eax, eax
+        xor     eax, eax
-	mov	ecx, 512/4
+        mov     ecx, 512/4
-	rep	stosd
+        rep stosd
-	pop	eax	; eax=new cluster
+        pop     eax     ; eax=new cluster
-	pop	edi	; edi->direntry
+        pop     edi     ; edi->direntry
-	pop	ecx	; ecx=required size
+        pop     ecx     ; ecx=required size
-	add	dword [edi+28], 0x200
+        add     dword [edi+28], 0x200
-	jmp	.extend_loop
+        jmp     .extend_loop
 .extend_done:
-	mov	[edi+28], ecx
+        mov     [edi+28], ecx
-	pop	esi edx
+        pop     esi edx
-	xor	eax, eax	; CF=0
+        xor     eax, eax        ; CF=0
-	ret
+        ret
 .disk_full:
-	pop	edi ecx
+        pop     edi ecx
-	pop	esi edx
+        pop     esi edx
-	stc
+        stc
-	push	ERROR_DISK_FULL
+        push    ERROR_DISK_FULL
-	pop	eax
+        pop     eax
-	ret
+        ret
 fat_update_datetime:
-	call	get_time_for_file
+        call    get_time_for_file
-	mov	[edi+22], ax		; last write time
+        mov     [edi+22], ax            ; last write time
-	call	get_date_for_file
+        call    get_date_for_file
-	mov	[edi+24], ax		; last write date
+        mov     [edi+24], ax            ; last write date
-	mov	[edi+18], ax		; last access date
+        mov     [edi+18], ax            ; last access date
+;
 ;  ret eax = 0 ok or other = errormsg
+;
 ;--------------------------------------------------------------
 fs_RamdiskSetFileEnd:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jnz	@f
+        jnz     @f
 .access_denied:
-	push	ERROR_ACCESS_DENIED
+        push    ERROR_ACCESS_DENIED
-	jmp	.ret
+        jmp     .ret
 @@:
-	push	edi
+        push    edi
-	call	rd_find_lfn
+        call    rd_find_lfn
-	jnc	@f
+        jnc     @f
-	pop	edi
+        pop     edi
-	push	ERROR_FILE_NOT_FOUND
+        push    ERROR_FILE_NOT_FOUND
 .ret:
-	pop	eax
+        pop     eax
-	ret
+        ret
 @@:
 ; must not be directory
-	test	byte [edi+11], 10h
+        test    byte [edi+11], 10h
-	jz	@f
+        jz      @f
-	pop	edi
+        pop     edi
-	jmp	.access_denied
+        jmp     .access_denied
 @@:
 ; file size must not exceed 4Gb
-	cmp	dword [ebx+4], 0
+        cmp     dword [ebx+4], 0
-	jz	@f
+        jz      @f
-	pop	edi
+        pop     edi
-	push	ERROR_END_OF_FILE
+        push    ERROR_END_OF_FILE
-	jmp	.ret
+        jmp     .ret
 @@:
 ; set file modification date/time to current
-	call	fat_update_datetime
+        call    fat_update_datetime
-	mov	eax, [ebx]
+        mov     eax, [ebx]
-	cmp	eax, [edi+28]
+        cmp     eax, [edi+28]
-	jb	.truncate
+        jb      .truncate
-	ja	.expand
+        ja      .expand
-	pop	edi
+        pop     edi
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret
 .expand:
-	push	ecx
+        push    ecx
-	mov	ecx, eax
+        mov     ecx, eax
-	call	ramdisk_extend_file
+        call    ramdisk_extend_file
-	pop	ecx
+        pop     ecx
-	pop	edi
+        pop     edi
-	ret
+        ret
 .truncate:
-	mov	[edi+28], eax
+        mov     [edi+28], eax
-	push	ecx
+        push    ecx
-	movzx	ecx, word [edi+26]
+        movzx   ecx, word [edi+26]
-	test	eax, eax
+        test    eax, eax
-	jz	.zero_size
+        jz      .zero_size
 ; find new last sector
 @@:
-	sub	eax, 0x200
+        sub     eax, 0x200
-	jbe	@f
+        jbe     @f
-	movzx	ecx, word [RAMDISK_FAT+ecx*2]
+        movzx   ecx, word [RAMDISK_FAT+ecx*2]
-	jmp	@b
+        jmp     @b
 @@:
 ; zero data at the end of last sector
-	push	ecx
+        push    ecx
-	mov	edi, ecx
+        mov     edi, ecx
-	shl	edi, 9
+        shl     edi, 9
-	lea	edi, [edi+RAMDISK+31*512+eax+0x200]
+        lea     edi, [edi+RAMDISK+31*512+eax+0x200]
-	mov	ecx, eax
+        mov     ecx, eax
-	neg	ecx
+        neg     ecx
-	xor	eax, eax
+        xor     eax, eax
-	rep	stosb
+        rep stosb
-	pop	ecx
+        pop     ecx
 ; terminate FAT chain
-	lea	ecx, [RAMDISK_FAT+ecx+ecx]
+        lea     ecx, [RAMDISK_FAT+ecx+ecx]
-	push	dword [ecx]
+        push    dword [ecx]
-	mov	word [ecx], 0xFFF
+        mov     word [ecx], 0xFFF
-	pop	ecx
+        pop     ecx
-	and	ecx, 0xFFF
+        and     ecx, 0xFFF
-	jmp	.delete
+        jmp     .delete
 .zero_size:
-	and	word [edi+26], 0
+        and     word [edi+26], 0
 .delete:
 ; delete FAT chain starting with ecx
 ; mark all clusters as free
-	cmp	ecx, 0xFF8
+        cmp     ecx, 0xFF8
-	jae	.deleted
+        jae     .deleted
-	lea	ecx, [RAMDISK_FAT+ecx+ecx]
+        lea     ecx, [RAMDISK_FAT+ecx+ecx]
-	push	dword [ecx]
+        push    dword [ecx]
-	and	word [ecx], 0
+        and     word [ecx], 0
-	pop	ecx
+        pop     ecx
-	and	ecx, 0xFFF
+        and     ecx, 0xFFF
-	jmp	.delete
+        jmp     .delete
 .deleted:
-	pop	ecx
+        pop     ecx
-	pop	edi
+        pop     edi
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret
 fs_RamdiskGetFileInfo:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jnz	@f
+        jnz     @f
-	mov	eax, 2	; unsupported
+        mov     eax, 2  ; unsupported
-	ret
+        ret
 @@:
-	push	edi
+        push    edi
-	call	rd_find_lfn
+        call    rd_find_lfn
 fs_GetFileInfo_finish:
-	jnc	@f
+        jnc     @f
-	pop	edi
+        pop     edi
-	mov	eax, ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
-	ret
+        ret
 @@:
-	push	esi ebp
+        push    esi ebp
-	xor	ebp, ebp
+        xor     ebp, ebp
-	mov	esi, edx
+        mov     esi, edx
-	and	dword [esi+4], 0
+        and     dword [esi+4], 0
-	call	fat_entry_to_bdfe2
+        call    fat_entry_to_bdfe2
-	pop	ebp esi
+        pop     ebp esi
-	pop	edi
+        pop     edi
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret
 fs_RamdiskSetFileInfo:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jnz	@f
+        jnz     @f
-	mov	eax, 2	; unsupported
+        mov     eax, 2  ; unsupported
-	ret
+        ret
 @@:
-	push	edi
+        push    edi
-	call	rd_find_lfn
+        call    rd_find_lfn
-	jnc	@f
+        jnc     @f
-	pop	edi
+        pop     edi
-	mov	eax, ERROR_FILE_NOT_FOUND
+        mov     eax, ERROR_FILE_NOT_FOUND
-	ret
+        ret
 @@:
-	call	bdfe_to_fat_entry
+        call    bdfe_to_fat_entry
-	pop	edi
+        pop     edi
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret
 ;----------------------------------------------------------------
+;
 ;  ret  eax = 0 ok or other = errormsg
+;
 ;--------------------------------------------------------------
 fs_RamdiskDelete:
-	cmp	byte [esi], 0
+        cmp     byte [esi], 0
-	jnz	@f
+        jnz     @f
 ; cannot delete root!
 .access_denied:
-	push	ERROR_ACCESS_DENIED
+        push    ERROR_ACCESS_DENIED
 .pop_ret:
-	pop	eax
+        pop     eax
-	ret
+        ret
 @@:
-	and	[rd_prev_sector], 0
+        and     [rd_prev_sector], 0
-	and	[rd_prev_prev_sector], 0
+        and     [rd_prev_prev_sector], 0
-	push	edi
+        push    edi
-	call	rd_find_lfn
+        call    rd_find_lfn
-	jnc	.found
+        jnc     .found
-	pop	edi
+        pop     edi
-	push	ERROR_FILE_NOT_FOUND
+        push    ERROR_FILE_NOT_FOUND
-	jmp	.pop_ret
+        jmp     .pop_ret
 .found:
-	cmp	dword [edi], '.   '
+        cmp     dword [edi], '.   '
-	jz	.access_denied2
+        jz      .access_denied2
-	cmp	dword [edi], '..  '
+        cmp     dword [edi], '..  '
-	jz	.access_denied2
+        jz      .access_denied2
-	test	byte [edi+11], 10h
+        test    byte [edi+11], 10h
-	jz	.dodel
+        jz      .dodel
 ; we can delete only empty folders!
-	movzx	eax, word [edi+26]
+        movzx   eax, word [edi+26]
-	push	ebx
+        push    ebx
-	mov	ebx, eax
+        mov     ebx, eax
-	shl	ebx, 9
+        shl     ebx, 9
-	add	ebx, RAMDISK + 31*0x200 + 2*0x20
+        add     ebx, RAMDISK + 31*0x200 + 2*0x20
 .checkempty:
-	cmp	byte [ebx], 0
+        cmp     byte [ebx], 0
-	jz	.empty
+        jz      .empty
-	cmp	byte [ebx], 0xE5
+        cmp     byte [ebx], 0xE5
-	jnz	.notempty
+        jnz     .notempty
-	add	ebx, 0x20
+        add     ebx, 0x20
-	test	ebx, 0x1FF
+        test    ebx, 0x1FF
-	jnz	.checkempty
+        jnz     .checkempty
-	movzx	eax, word [RAMDISK_FAT + eax*2]
+        movzx   eax, word [RAMDISK_FAT + eax*2]
-	test	eax, eax
+        test    eax, eax
-	jz	.empty
+        jz      .empty
-	mov	ebx, eax
+        mov     ebx, eax
-	shl	ebx, 9
+        shl     ebx, 9
-	add	ebx, RAMDISK + 31*0x200
+        add     ebx, RAMDISK + 31*0x200
-	jmp	.checkempty
+        jmp     .checkempty
 .notempty:
-	pop	ebx
+        pop     ebx
 .access_denied2:
-	pop	edi
+        pop     edi
-	jmp	.access_denied
+        jmp     .access_denied
 .empty:
-	pop	ebx
+        pop     ebx
 .dodel:
-	movzx	eax, word [edi+26]
+        movzx   eax, word [edi+26]
 ; delete folder entry
-	mov	byte [edi], 0xE5
+        mov     byte [edi], 0xE5
 ; delete LFN (if present)
 .lfndel:
-	test	edi, 0x1FF
+        test    edi, 0x1FF
-	jnz	@f
+        jnz     @f
-	cmp	[rd_prev_sector], 0
+        cmp     [rd_prev_sector], 0
-	jz	@f
+        jz      @f
-	cmp	[rd_prev_sector], -1
+        cmp     [rd_prev_sector], -1
-	jz	.lfndone
+        jz      .lfndone
-	mov	edi, [rd_prev_sector]
+        mov     edi, [rd_prev_sector]
-	push	[rd_prev_prev_sector]
+        push    [rd_prev_prev_sector]
-	pop	[rd_prev_sector]
+        pop     [rd_prev_sector]
-	or	[rd_prev_prev_sector], -1
+        or      [rd_prev_prev_sector], -1
-	shl	edi, 9
+        shl     edi, 9
-	add	edi, RAMDISK + 31*0x200 + 0x200
+        add     edi, RAMDISK + 31*0x200 + 0x200
 @@:
-	sub	edi, 0x20
+        sub     edi, 0x20
-	cmp	byte [edi], 0xE5
+        cmp     byte [edi], 0xE5
-	jz	.lfndone
+        jz      .lfndone
-	cmp	byte [edi+11], 0xF
+        cmp     byte [edi+11], 0xF
-	jnz	.lfndone
+        jnz     .lfndone
-	mov	byte [edi], 0xE5
+        mov     byte [edi], 0xE5
-	jmp	.lfndel
+        jmp     .lfndel
 .lfndone:
 ; delete FAT chain
         cmp     eax, 2
         jb      .done
         cmp     eax, 0xFF8
         jae     .done
-	lea	eax, [RAMDISK_FAT + eax*2]
+        lea     eax, [RAMDISK_FAT + eax*2]
-	push	dword [eax]
+        push    dword [eax]
-	and	word [eax], 0
+        and     word [eax], 0
-	pop	eax
+        pop     eax
-	and	eax, 0xFFF
+        and     eax, 0xFFF
-	jmp	.lfndone
+        jmp     .lfndone
 .done:
-	pop	edi
+        pop     edi
-	xor	eax, eax
+        xor     eax, eax
-	ret
+        ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/blkdev/rd.inc – Rev 3500 → 3555