Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 3663 $

ERROR_SUCCESS        = 0

ERROR_DISK_BASE      = 1

ERROR_UNSUPPORTED_FS = 2

ERROR_UNKNOWN_FS     = 3

ERROR_PARTITION      = 4

ERROR_FILE_NOT_FOUND = 5

ERROR_END_OF_FILE    = 6

ERROR_MEMORY_POINTER = 7

ERROR_DISK_FULL      = 8

ERROR_FAT_TABLE      = 9 ;deprecated

ERROR_FS_FAIL        = 9

ERROR_ACCESS_DENIED  = 10

ERROR_DEVICE         = 11

image_of_eax EQU esp+32

image_of_ebx EQU esp+20

; System function 70 - files with long names (LFN)

; diamond, 2006

iglobal

; in this table names must be in lowercase

rootdirs:

        db      2,'rd'

        dd      fs_OnRamdisk

        dd      fs_NextRamdisk

        db      7,'ramdisk'

        dd      fs_OnRamdisk

        dd      fs_NextRamdisk

        db      2,'fd'

        dd      fs_OnFloppy

        dd      fs_NextFloppy

        db      10,'floppydisk'

        dd      fs_OnFloppy

        dd      fs_NextFloppy

        db      3,'hd0'

        dd      fs_OnHd0

        dd      fs_NextHd0

        db      3,'hd1'

        dd      fs_OnHd1

        dd      fs_NextHd1

        db      3,'hd2'

        dd      fs_OnHd2

        dd      fs_NextHd2

        db      3,'hd3'

        dd      fs_OnHd3

        dd      fs_NextHd3

;**********************************************

        db      3,'cd0'

        dd      fs_OnCd0

        dd      fs_NextCd

        db      3,'cd1'

        dd      fs_OnCd1

        dd      fs_NextCd

        db      3,'cd2'

        dd      fs_OnCd2

        dd      fs_NextCd

        db      3,'cd3'

        dd      fs_OnCd3

        dd      fs_NextCd

;***********************************************

        db      0

virtual_root_query:

        dd      fs_HasRamdisk

        db      'rd',0

        dd      fs_HasFloppy

        db      'fd',0

        dd      fs_HasHd0

        db      'hd0',0

        dd      fs_HasHd1

        db      'hd1',0

        dd      fs_HasHd2

        db      'hd2',0

        dd      fs_HasHd3

        db      'hd3',0

;**********************************************

        dd      fs_HasCd0

        db      'cd0',0

        dd      fs_HasCd1

        db      'cd1',0

        dd      fs_HasCd2

        db      'cd2',0

        dd      fs_HasCd3

        db      'cd3',0

;**********************************************

        dd      0

fs_additional_handlers:

        dd      biosdisk_handler, biosdisk_enum_root

        dd      dyndisk_handler, dyndisk_enum_root

; add new handlers here

        dd      0

endg

file_system_lfn_protected:

        pushad

        call    protect_from_terminate

        call    file_system_lfn

        call    unprotect_from_terminate

        popad

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

file_system_lfn:

; in: ebx->fileinfo block

; operation codes:

; 0 : read file

; 1 : read folder

; 2 : create/rewrite file

; 3 : write/append to file

; 4 : set end of file

; 5 : get file/directory attributes structure

; 6 : set file/directory attributes structure

; 7 : start application

; 8 : delete file

; 9 : create directory

; parse file name

        lea     esi, [ebx+20]

        lodsb

        test    al, al

        jnz     @f

        mov     esi, [esi]

        lodsb

@@:

        cmp     al, '/'

        jz      .notcurdir

        dec     esi

        mov     ebp, esi

        test    al, al

        jnz     @f

        xor     ebp, ebp

@@:

        mov     esi, [current_slot]

        mov     esi, [esi+APPDATA.cur_dir]

        jmp     .parse_normal

.notcurdir:

        cmp     byte [esi], 0

        jz      .rootdir

        call    process_replace_file_name

.parse_normal:

        cmp     dword [ebx], 7

        jne     @F

        mov     edx, [ebx+4]

        mov     ebx, [ebx+8]

        call    fs_execute; esi+ebp, ebx, edx

        mov     [image_of_eax], eax

        ret

@@:

        mov     edi, rootdirs-8

        xor     ecx, ecx

        push    esi

.scan1:

        pop     esi

        add     edi, ecx

        scasd

        scasd

        mov     cl, byte [edi]

        test    cl, cl

        jz      .notfound_try

        inc     edi

        push    esi

@@:

        lodsb

        or      al, 20h

        scasb

        loopz   @b

        jnz     .scan1

        lodsb

        cmp     al, '/'

        jz      .found1

        test    al, al

        jnz     .scan1

        pop     eax

; directory /xxx

.maindir:

        mov     esi, [edi+4]

.maindir_noesi:

        cmp     dword [ebx], 1

        jnz     .access_denied

        xor     eax, eax

        mov     ebp, [ebx+12]                   ;количество блоков для считывания

        mov     edx, [ebx+16]                   ;куда записывать рузельтат

    ;    add     edx, std_application_base_address

        push    dword [ebx+4]   ; first block

        mov     ebx, [ebx+8]    ; flags

; ebx=flags, [esp]=first block, ebp=number of blocks, edx=return area, esi='Next' handler

        mov     edi, edx

        push    ecx

        mov     ecx, 32/4

        rep stosd

        pop     ecx

        mov     byte [edx], 1   ; version

.maindir_loop:

        call    esi

        jc      .maindir_done

        inc     dword [edx+8]

        dec     dword [esp]

        jns     .maindir_loop

        dec     ebp

        js      .maindir_loop

        inc     dword [edx+4]

        mov     dword [edi], 0x10       ; attributes: folder

        mov     dword [edi+4], 1        ; name type: UNICODE

        push    eax

        xor     eax, eax

        add     edi, 8

        push    ecx

        mov     ecx, 40/4-2

        rep stosd

        pop     ecx

        pop     eax

        push    eax edx

; convert number in eax to decimal UNICODE string

        push    edi

        push    ecx

        push    -'0'

        mov     ecx, 10

@@:

        xor     edx, edx

        div     ecx

        push    edx

        test    eax, eax

        jnz     @b

@@:

        pop     eax

        add     al, '0'

        stosb

        test    bl, 1           ; UNICODE name?

        jz      .ansi2

        mov     byte [edi], 0

        inc     edi

.ansi2:

        test    al, al

        jnz     @b

        mov     byte [edi-1], 0

        pop     ecx

        pop     edi

; UNICODE name length is 520 bytes, ANSI - 264

        add     edi, 520

        test    bl, 1

        jnz     @f

        sub     edi, 520-264

@@:

        pop     edx eax

        jmp     .maindir_loop

.maindir_done:

        pop     eax

        mov     ebx, [edx+4]

        xor     eax, eax

        dec     ebp

        js      @f

        mov     al, ERROR_END_OF_FILE

@@:

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

; directory /

.rootdir:

        cmp     dword [ebx], 1  ; read folder?

        jz      .readroot

.access_denied:

        mov     dword [image_of_eax], 10      ; access denied

        ret

.readroot:

; virtual root folder - special handler

        mov     esi, virtual_root_query

        mov     ebp, [ebx+12]

        mov     edx, [ebx+16]

    ;    add     edx, std_application_base_address

        push    dword [ebx+4]   ; first block

        mov     ebx, [ebx+8]    ; flags

        xor     eax, eax

; eax=0, [esp]=first block, ebx=flags, ebp=number of blocks, edx=return area

        mov     edi, edx

        mov     ecx, 32/4

        rep stosd

        mov     byte [edx], 1   ; version

.readroot_loop:

        cmp     dword [esi], eax

        jz      .readroot_done_static

        call    dword [esi]

        add     esi, 4

        test    eax, eax

        jnz     @f

.readroot_next:

        or      ecx, -1

        xchg    esi, edi

        repnz scasb

        xchg    esi, edi

        jmp     .readroot_loop

@@:

        xor     eax, eax

        inc     dword [edx+8]

        dec     dword [esp]

        jns     .readroot_next

        dec     ebp

        js      .readroot_next

        inc     dword [edx+4]

        mov     dword [edi], 0x10       ; attributes: folder

        mov     dword [edi+4], ebx      ; name type: UNICODE

        add     edi, 8

        mov     ecx, 40/4-2

        rep stosd

        push    edi

@@:

        lodsb

        stosb

        test    bl, 1

        jz      .ansi

        mov     byte [edi], 0

        inc     edi

.ansi:

        test    eax, eax

        jnz     @b

        pop     edi

        add     edi, 520

        test    bl, 1

        jnz     .readroot_loop

        sub     edi, 520-264

        jmp     .readroot_loop

.readroot_done_static:

        mov     esi, fs_additional_handlers-8

        sub     esp, 16

.readroot_ah_loop:

        add     esi, 8

        cmp     dword [esi], 0

        jz      .readroot_done

        xor     eax, eax

.readroot_ah_loop2:

        push    edi

        lea     edi, [esp+4]

        call    dword [esi+4]

        pop     edi

        test    eax, eax

        jz      .readroot_ah_loop

        inc     dword [edx+8]

        dec     dword [esp+16]

        jns     .readroot_ah_loop2

        dec     ebp

        js      .readroot_ah_loop2

        push    eax

        xor     eax, eax

        inc     dword [edx+4]

        mov     dword [edi], 0x10       ; attributes: folder

        mov     dword [edi+4], ebx

        add     edi, 8

        mov     ecx, 40/4-2

        rep stosd

        push    esi edi

        lea     esi, [esp+12]

@@:

        lodsb

        stosb

        test    bl, 1

        jz      .ansi3

        mov     byte [edi], 0

        inc     edi

.ansi3:

        test    al, al

        jnz     @b

        pop     edi esi eax

        add     edi, 520

        test    bl, 1

        jnz     .readroot_ah_loop2

        sub     edi, 520-264

        jmp     .readroot_ah_loop2

.readroot_done:

        add     esp, 16

        pop     eax

        mov     ebx, [edx+4]

        xor     eax, eax

        dec     ebp

        js      @f

        mov     al, ERROR_END_OF_FILE

@@:

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

.notfound_try:

        mov     edi, fs_additional_handlers

@@:

        cmp     dword [edi], 0

        jz      .notfound

        call    dword [edi]

        scasd

        scasd

        jmp     @b

.notfound:

        mov     dword [image_of_eax], ERROR_FILE_NOT_FOUND

        and     dword [image_of_ebx], 0

        ret

.notfounda:

        cmp     edi, esp

        jnz     .notfound

        call    dword [edi+4]

        add     esp, 16

        jmp     .notfound

.found1:

        pop     eax

        cmp     byte [esi], 0

        jz      .maindir

.found2:

; read partition number

        xor     ecx, ecx

        xor     eax, eax

@@:

        lodsb

        cmp     al, '/'

        jz      .done1

        test    al, al

        jz      .done1

        sub     al, '0'

        cmp     al, 9

        ja      .notfounda

        lea     ecx, [ecx*5]

        lea     ecx, [ecx*2+eax]

        jmp     @b

.done1:

        jecxz   .notfounda

        test    al, al

        jnz     @f

        dec     esi

@@:

        cmp     byte [esi], 0

        jnz     @f

        test    ebp, ebp

        jz      @f

        mov     esi, ebp

        xor     ebp, ebp

@@:

; now [edi] contains handler address, ecx - partition number,

; esi points to ASCIIZ string - rest of name

        jmp     dword [edi]

; handlers for devices

; in: ecx = 0 => query virtual directory /xxx

; in: ecx = partition number

;     esi -> relative (for device) name

;     ebx -> fileinfo

;     ebp = 0 or pointer to rest of name from folder addressed by esi

; out: [image_of_eax]=image of eax, [image_of_ebx]=image of ebx

fs_OnRamdisk:

        cmp     ecx, 1

        jnz     file_system_lfn.notfound

        mov     eax, [ebx]

        cmp     eax, fs_NumRamdiskServices

        jae     .not_impl

        mov     ecx, [ebx+12]

        mov     edx, [ebx+16]

   ;     add     edx, std_application_base_address

        add     ebx, 4

        call    dword [fs_RamdiskServices + eax*4]

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

.not_impl:

        mov     dword [image_of_eax], 2       ; not implemented

        ret

fs_NotImplemented:

        mov     eax, 2

        ret

fs_RamdiskServices:

        dd      fs_RamdiskRead

        dd      fs_RamdiskReadFolder

        dd      fs_RamdiskRewrite

        dd      fs_RamdiskWrite

        dd      fs_RamdiskSetFileEnd

        dd      fs_RamdiskGetFileInfo

        dd      fs_RamdiskSetFileInfo

        dd      0

        dd      fs_RamdiskDelete

        dd      fs_RamdiskCreateFolder

fs_NumRamdiskServices = ($ - fs_RamdiskServices)/4

fs_OnFloppy:

        cmp     ecx, 2

        ja      file_system_lfn.notfound

        mov     eax, [ebx]

        cmp     eax, fs_NumFloppyServices

        jae     fs_OnRamdisk.not_impl

        call    reserve_flp

        mov     [flp_number], cl

        mov     ecx, [ebx+12]

        mov     edx, [ebx+16]

   ;     add     edx, std_application_base_address

        add     ebx, 4

        call    dword [fs_FloppyServices + eax*4]

        and     [flp_status], 0

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

fs_FloppyServices:

        dd      fs_FloppyRead

        dd      fs_FloppyReadFolder

        dd      fs_FloppyRewrite

        dd      fs_FloppyWrite

        dd      fs_FloppySetFileEnd

        dd      fs_FloppyGetFileInfo

        dd      fs_FloppySetFileInfo

        dd      0

        dd      fs_FloppyDelete

        dd      fs_FloppyCreateFolder

fs_NumFloppyServices = ($ - fs_FloppyServices)/4

fs_OnHd0:

        call    reserve_hd1

        mov     [hdbase], 0x1F0

        mov     [hdid], 0

        push    1

        jmp     fs_OnHd

fs_OnHd1:

        call    reserve_hd1

        mov     [hdbase], 0x1F0

        mov     [hdid], 0x10

        push    2

        jmp     fs_OnHd

fs_OnHd2:

        call    reserve_hd1

        mov     [hdbase], 0x170

        mov     [hdid], 0

        push    3

        jmp     fs_OnHd

fs_OnHd3:

        call    reserve_hd1

        mov     [hdbase], 0x170

        mov     [hdid], 0x10

        push    4

fs_OnHd:

        call    reserve_hd_channel

        pop     eax

        mov     [hdpos], eax

        cmp     ecx, 0x100

        jae     fs_OnHdAndBd.nf

        cmp     cl, [DRIVE_DATA+1+eax]

fs_OnHdAndBd:

        jbe     @f

.nf:

        call    free_hd_channel

        and     [hd1_status], 0

        mov     dword [image_of_eax], 5       ; not found

        ret

@@:

        mov     [known_part], ecx ;     mov     [fat32part], ecx

        push    ebx esi

        call    choice_necessity_partition_1

        pop     esi ebx

        mov     ecx, [ebx+12]

        mov     edx, [ebx+16]

    ;    add     edx, std_application_base_address

        mov     eax, [ebx]

        cmp     eax, fs_NumHdServices

        jae     .not_impl

        add     ebx, 4

        call    dword [fs_HdServices + eax*4]

        call    free_hd_channel

        and     [hd1_status], 0

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

.not_impl:

        call    free_hd_channel

        and     [hd1_status], 0

        mov     dword [image_of_eax], 2       ; not implemented

        ret

fs_HdServices:

        dd      fs_HdRead

        dd      fs_HdReadFolder

        dd      fs_HdRewrite

        dd      fs_HdWrite

        dd      fs_HdSetFileEnd

        dd      fs_HdGetFileInfo

        dd      fs_HdSetFileInfo

        dd      0

        dd      fs_HdDelete

        dd      fs_HdCreateFolder

fs_NumHdServices = ($ - fs_HdServices)/4

;*******************************************************

fs_OnCd0:

        call    reserve_cd

        mov     [ChannelNumber], 1

        mov     [DiskNumber], 0

        push    6

        push    1

        jmp     fs_OnCd

fs_OnCd1:

        call    reserve_cd

        mov     [ChannelNumber], 1

        mov     [DiskNumber], 1

        push    4

        push    2

        jmp     fs_OnCd

fs_OnCd2:

        call    reserve_cd

        mov     [ChannelNumber], 2

        mov     [DiskNumber], 0

        push    2

        push    3

        jmp     fs_OnCd

fs_OnCd3:

        call    reserve_cd

        mov     [ChannelNumber], 2

        mov     [DiskNumber], 1

        push    0

        push    4

fs_OnCd:

        call    reserve_cd_channel

        pop     eax

        mov     [cdpos], eax

        pop     eax

        cmp     ecx, 0x100

        jae     .nf

        push    ecx ebx

        mov     cl, al

        mov     bl, [DRIVE_DATA+1]

        shr     bl, cl

        test    bl, 2

        pop     ebx ecx

        jnz     @f

.nf:

        call    free_cd_channel

        and     [cd_status], 0

        mov     dword [image_of_eax], 5       ; not found

        ret

@@:

        mov     ecx, [ebx+12]

        mov     edx, [ebx+16]

    ;    add     edx, std_application_base_address

        mov     eax, [ebx]

        cmp     eax, fs_NumCdServices

        jae     .not_impl

        add     ebx, 4

        call    dword [fs_CdServices + eax*4]

        call    free_cd_channel

        and     [cd_status], 0

        mov     [image_of_eax], eax

        mov     [image_of_ebx], ebx

        ret

.not_impl:

        call    free_cd_channel

        and     [cd_status], 0

        mov     dword [image_of_eax], 2       ; not implemented

        ret

fs_CdServices:

        dd      fs_CdRead

        dd      fs_CdReadFolder

        dd      fs_NotImplemented

        dd      fs_NotImplemented

        dd      fs_NotImplemented

        dd      fs_CdGetFileInfo

        dd      fs_NotImplemented

        dd      0

        dd      fs_NotImplemented

        dd      fs_NotImplemented

fs_NumCdServices = ($ - fs_CdServices)/4

;*******************************************************

fs_HasRamdisk:

        mov     al, 1   ; we always have ramdisk

        ret

fs_HasFloppy:

        cmp     byte [DRIVE_DATA], 0

        setnz   al

        ret

fs_HasHd0:

        test    byte [DRIVE_DATA+1], 01000000b

        setnz   al

        ret

fs_HasHd1:

        test    byte [DRIVE_DATA+1], 00010000b

        setnz   al

        ret

fs_HasHd2:

        test    byte [DRIVE_DATA+1], 00000100b

        setnz   al

        ret

fs_HasHd3:

        test    byte [DRIVE_DATA+1], 00000001b

        setnz   al

        ret

;*******************************************************

fs_HasCd0:

        test    byte [DRIVE_DATA+1], 10000000b

        setnz   al

        ret

fs_HasCd1:

        test    byte [DRIVE_DATA+1], 00100000b

        setnz   al

        ret

fs_HasCd2:

        test    byte [DRIVE_DATA+1], 00001000b

        setnz   al

        ret

fs_HasCd3:

        test    byte [DRIVE_DATA+1], 00000010b

        setnz   al

        ret

;*******************************************************

; fs_NextXXX functions:

; in: eax = partition number, from which start to scan

; out: CF=1 => no more partitions

;      CF=0 => eax=next partition number

fs_NextRamdisk:

; we always have /rd/1

        test    eax, eax

        stc

        jnz     @f

        mov     al, 1

        clc

@@:

        ret

fs_NextFloppy:

; we have /fd/1 iff (([DRIVE_DATA] and 0xF0) != 0) and /fd/2 iff (([DRIVE_DATA] and 0x0F) != 0)

        test    byte [DRIVE_DATA], 0xF0

        jz      .no1

        test    eax, eax

        jnz     .no1

        inc     eax

        ret     ; CF cleared

.no1:

        test    byte [DRIVE_DATA], 0x0F

        jz      .no2

        cmp     al, 2

        jae     .no2

        mov     al, 2

        clc

        ret

.no2:

        stc

        ret

; on hdx, we have partitions from 1 to [0x40002+x]

fs_NextHd0:

        push    0

        jmp     fs_NextHd

fs_NextHd1:

        push    1

        jmp     fs_NextHd

fs_NextHd2:

        push    2

        jmp     fs_NextHd

fs_NextHd3:

        push    3

fs_NextHd:

        pop     ecx

        movzx   ecx, byte [DRIVE_DATA+2+ecx]

        cmp     eax, ecx

        jae     fs_NextFloppy.no2

        inc     eax

        clc

        ret

;*******************************************************

fs_NextCd:

; we always have /cdX/1

        test    eax, eax

        stc

        jnz     @f

        mov     al, 1

        clc

@@:

        ret

;*******************************************************

; Additional FS handlers.

; This handler gets the control each time when fn 70 is called

; with unknown item of root subdirectory.

; in: esi -> name

;     ebp = 0 or rest of name relative to esi

; out: if the handler processes path, he must not return in file_system_lfn,

;      but instead pop return address and return directly to the caller

;      otherwise simply return

; here we test for /bd/... - BIOS disks

biosdisk_handler:

        cmp     [NumBiosDisks], 0

        jz      .ret

        mov     al, [esi]

        or      al, 20h

        cmp     al, 'b'

        jnz     .ret

        mov     al, [esi+1]

        or      al, 20h

        cmp     al, 'd'

        jnz     .ret

        push    esi

        inc     esi

        inc     esi

        cmp     byte [esi], '0'

        jb      .ret2

        cmp     byte [esi], '9'

        ja      .ret2

        xor     edx, edx

@@:

        lodsb

        test    al, al

        jz      .ok

        cmp     al, '/'

        jz      .ok

        sub     al, '0'

        cmp     al, 9

        ja      .ret2

        lea     edx, [edx*5]

        lea     edx, [edx*2+eax]

        jmp     @b

.ret2:

        pop     esi

.ret:

        ret

.ok:

        cmp     al, '/'

        jz      @f

        dec     esi

@@:

        add     dl, 80h

        xor     ecx, ecx

@@:

        cmp     dl, [BiosDisksData+ecx*4]

        jz      .ok2

        inc     ecx

        cmp     ecx, [NumBiosDisks]

        jb      @b

        jmp     .ret2

.ok2:

        add     esp, 8

        test    al, al

        jnz     @f

        mov     esi, fs_BdNext

        jmp     file_system_lfn.maindir_noesi

@@:

        push    ecx

        push    ecx

        push    biosdisk_cleanup

        push    fs_OnBd

        mov     edi, esp

        jmp     file_system_lfn.found2

fs_BdNext:

        cmp     eax, [BiosDiskPartitions+ecx*4]

        inc     eax

        cmc

biosdisk_cleanup:

        ret

fs_OnBd:

        pop     edx edx edx edx

; edx = disk number, ecx = partition number

; esi+ebp = name

        call    reserve_hd1

        add     edx, 0x80

        mov     [hdpos], edx

        cmp     ecx, [BiosDiskPartitions+(edx-0x80)*4]

        jmp     fs_OnHdAndBd

; This handler is called when virtual root is enumerated

; and must return all items which can be handled by this.

; It is called several times, first time with eax=0

; in: eax = 0 for first call, previously returned value for subsequent calls

; out: eax = 0 => no more items

;      eax != 0 => buffer pointed to by edi contains name of item

; here we enumerate existing BIOS disks /bd

biosdisk_enum_root:

        cmp     eax, [NumBiosDisks]

        jae     .end

        push    eax

        movzx   eax, byte [BiosDisksData+eax*4]

        sub     al, 80h

        push    eax

        mov     al, 'b'

        stosb

        mov     al, 'd'

        stosb

        pop     eax

        cmp     al, 10

        jae     .big

        add     al, '0'

        stosb

        mov     byte [edi], 0

        pop     eax

        inc     eax

        ret

.end:

        xor     eax, eax

        ret

.big:

        push    ecx edx

        push    -'0'

        mov     ecx, 10

@@:

        xor     edx, edx

        div     ecx

        push    edx

        test    eax, eax

        jnz     @b

        xchg    eax, edx

@@:

        pop     eax

        add     al, '0'

        stosb

        jnz     @b

        pop     edx ecx

        pop     eax

        inc     eax

        ret

process_replace_file_name:

; in

; esi - path with filename(f.70)

;

; out

; ebp - full filename

        mov     ebp, [full_file_name_table]

        mov     edi, [full_file_name_table.size]

        dec     edi

        shl     edi, 7

        add     edi, ebp

.loop:

        cmp     edi, ebp

        jb      .notfound

        push    esi edi

@@:

        cmp     byte [edi], 0

        jz      .dest_done

        lodsb

        test    al, al

        jz      .cont

        or      al, 20h

        scasb

        jz      @b

        jmp     .cont

.dest_done:

        cmp     byte [esi], 0

        jz      .found

        cmp     byte [esi], '/'

        jnz     .cont

        inc     esi

        jmp     .found

.cont:

        pop     edi esi

        sub     edi, 128

        jmp     .loop

.found:

        pop     edi eax

        mov     ebp, esi

        cmp     byte [esi], 0

        lea     esi, [edi+64]

        jnz     .ret

.notfound:

        xor     ebp, ebp

.ret:

        ret

uglobal

lock_flag_for_f30_3 rb 1

endg

sys_current_directory:

;       mov     esi, [current_slot]

;       mov     esi, [esi+APPDATA.cur_dir]

;       mov     edx, esi

;get length string of appdata.cur_dir

        mov     eax, [current_slot]

        mov     edi, [eax+APPDATA.cur_dir]

        dec     ebx

        jz      .set

        dec     ebx

        jz      .get

        dec     ebx

        jz      .mount_additional_directory

        ret

.mount_additional_directory:

; sysfunction 30.2: [for app] eax=30,ebx=3,ecx->dir name+dir path (128)

; for our code: nothing

; check lock of the function

        cmp     [lock_flag_for_f30_3], 1

        je      @f

        mov     esi, ecx

        mov     edi, sysdir_name1

; copying fake directory name

        mov     ecx, 63

        cld

        rep     movsb

; terminator of name, in case if we get the inlet trash

        inc     esi

        xor     eax, eax

        stosb

; copying real directory path for mounting

        mov     ecx, 63

        rep     movsb

; terminator of name, in case if we get the inlet trash

        xor     eax, eax

        stosb

; increase the pointer of inputs for procedure "process_replace_file_name"

        mov     [full_file_name_table.size], 2

; block the ability to call f.30.3 because for one session is necessary

; for us only once

        mov     [lock_flag_for_f30_3], 1

@@:

        ret

.get:

; sysfunction 30.2: [for app] eax=30,ebx=2,ecx->buffer,edx=len

; for our code: ebx->buffer,ecx=len

max_cur_dir     equ     0x1000

        mov     ebx, edi

        push    ecx

        push    edi

        xor     eax, eax

        mov     ecx, max_cur_dir

        repne scasb             ;find zerro at and string

        jnz     .error          ; no zero in cur_dir: internal error, should not happen

        sub     edi, ebx        ;lenght for copy

        inc     edi

        mov     [esp+32+8], edi ;return in eax

        cmp     edx, edi

        jbe     @f

        mov     edx, edi

@@:

;source string

        pop     esi

;destination string

        pop     edi

        cmp     edx, 1

        jbe     .ret

        mov     al, '/'         ;start string with '/'

        stosb

        mov     ecx, edx

        rep movsb               ;copy string

.ret:

        ret

.error:

        add     esp, 8

        or      dword [esp+32], -1      ;error not found zerro at string ->[eax+APPDATA.cur_dir]

        ret

.set:

; sysfunction 30.1: [for app] eax=30,ebx=1,ecx->string

; for our code: ebx->string to set

; use generic resolver with APPDATA.cur_dir as destination

        push    max_cur_dir     ;0x1000

        push    edi     ;destination

        mov     ebx, ecx

        call    get_full_file_name

        ret

; in: ebx = file name, [esp+4] = destination, [esp+8] = sizeof destination

; destroys all registers except ebp,esp

get_full_file_name:

        push    ebp

        mov     esi, [current_slot]

        mov     esi, [esi+APPDATA.cur_dir]

        mov     edx, esi

@@:

        inc     esi

        cmp     byte [esi-1], 0

        jnz     @b

        dec     esi

        cmp     byte [ebx], '/'

        jz      .set_absolute

; string gives relative path

        mov     edi, [esp+8]    ; destination

.relative:

        cmp     byte [ebx], 0

        jz      .set_ok

        cmp     word [ebx], '.'

        jz      .set_ok

        cmp     word [ebx], './'

        jnz     @f

        add     ebx, 2

        jmp     .relative

@@:

        cmp     word [ebx], '..'

        jnz     .doset_relative

        cmp     byte [ebx+2], 0

        jz      @f

        cmp     byte [ebx+2], '/'

        jnz     .doset_relative

@@:

        dec     esi

        cmp     byte [esi], '/'

        jnz     @b