Subversion Repositories Kolibri OS

;; LFN support by diamond                                               ;;

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     ; CF already cleared

        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]

.succ:

        pop     edi

        popad

        clc

        ret

.break:

        jecxz   .noplace

        inc     edi

        mov     al, '1'

@@:

        xchg    al, [edi]

        inc     edi

        cmp     al, ' '

        mov     al, '0'

        jnz     @b

        jmp     .succ

.noplace:

        dec     edi

        cmp     edi, [esp]

        jz      .err

        add     dword [esp], 8

        mov     word [edi], '~1'

        inc     edi

        inc     edi

@@:

        mov     byte [edi], '0'

        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     edi, ecx

        jbe     .skip

@@:

        dec     edi

        mov     al, ' '

        xchg    al, [edi]

        dec     ebx

        mov     [ebx], al

        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 sys floppy

;

;  esi  points to filename

;  ebx  ignored (reserved)

;  ecx  number of bytes to write, 0+

;  edx  mem location to data

;

;  ret ebx = number of written bytes

;      eax = 0 ok read or other = errormsg

;

;--------------------------------------------------------------

@@:

        mov     eax, ERROR_ACCESS_DENIED

        xor     ebx, ebx

        ret

fs_RamdiskRewrite:

        cmp     byte [esi], 0

        jz      @b

; ramdisk doesn't support folders

        push    esi

@@:

        lodsb

        test    al, al

        jz      @f

        cmp     al, '/'

        jnz     @b

        pop     esi

.err5:

        mov     eax, 5  ; file not found

        xor     ebx, ebx

        ret

@@:

        pop     esi

; check existence

        push    edi

        call    rd_find_lfn

        jc      .notfound

; found, 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, [0x280000 + 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

        pop     edi

        jmp     .err5

@@:

        sub     esp, 12

        mov     edi, esp

        call    fat_gen_short_name

.test_short_name_loop:

        push    esi ecx

        mov     esi, 0x100000+512*19

.test_short_name_entry:

        cmp     byte [esi+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:

        add     esi, 20h

        cmp     esi, 0x100000+512*33

        jb      .test_short_name_entry

        pop     ecx esi

        jmp     .found

.short_name_found:

        call    fat_next_short_name

        pop     ecx esi

        jnc     .test_short_name_loop

.disk_full:

        add     esp, 12

        pop     edi

        mov     eax, ERROR_DISK_FULL

        xor     ebx, ebx

        ret

.found:

; 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:

; find  successive entries in directory

        xor     ecx, ecx

        mov     edi, 0x100000+512*19

.scan_dir:

        cmp     byte [edi], 0

        jz      .free

        cmp     byte [edi], 0xE5

        jz      .free

        xor     ecx, ecx

.scan_cont:

        add     edi, 0x20

        cmp     edi, 0x100000+512*33

        jb      .scan_dir

        pop     edi ecx

        jmp     .disk_full

.free:

        inc     ecx

        cmp     ecx, eax

        jb      .scan_cont

; found!

; calculate name checksum

        push    esi ecx

        mov     esi, [esp+8]

        mov     ecx, 11

        xor     eax, eax

@@:

        ror     al, 1

        add     al, [esi]

        inc     esi

        loop    @b

        pop     ecx esi

; edi points to last entry in free chunk

        dec     ecx

        jz      .nolfn

        push    esi

        push    edi

.writelfn:

        sub     edi, 20h

        push    ecx eax

        mov     eax, [esp+8]

        sub     eax, edi

        shr     eax, 5

        cmp     ecx, 1

        jnz     @f

        or      al, 40h

@@:

        stosb

        mov     cl, 5

        call    .read_symbols

        mov     ax, 0xF

        stosw

        pop     eax

        stosb

        push    eax

        mov     cl, 6

        call    .read_symbols

        xor     eax, eax

        stosw

        mov     cl, 2

        call    .read_symbols

        pop     eax ecx

        sub     edi, 0x20

        loop    .writelfn

        pop     edi

        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

.doit:

        push    ecx edx

        push    ecx

        push    edi

        add     edi, 26         ; edi points to low word of cluster

        push    edi

        jecxz   .done

        mov     ecx, 2849

        mov     edi, 0x280000

.write_loop:

; allocate new cluster

        xor     eax, eax

        repnz   scasw

        jnz     .disk_full2

        dec     edi

        dec     edi

        lea     eax, [edi-0x280000]

        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

        shl     eax, 9

        add     eax, 0x100000+31*512

        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 ecx

        sub     ebx, edx

        mov     [edi+28], ebx

        pop     edi

        xor     eax, eax

        ret

.disk_full2:

        mov     ebx, edx

        pop     edi edi ecx edx ecx

        sub     ebx, edx

        mov     [edi+28], ebx

        pop     edi

        push    ERROR_DISK_FULL

        pop     eax

        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