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


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

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/blkdev/rd.inc – Rev 848 → 2971