Subversion Repositories Kolibri OS

; Copyright (c) 2009, 

; All rights reserved.

;

; Redistribution and use in source and binary forms, with or without

; modification, are permitted provided that the following conditions are met:

;       * Redistributions of source code must retain the above copyright

;       notice, this list of conditions and the following disclaimer.

;       * Redistributions in binary form must reproduce the above copyright

;       notice, this list of conditions and the following disclaimer in the

;       documentation and/or other materials provided with the distribution.

;       * Neither the name of the  nor the

;       names of its contributors may be used to endorse or promote products

;       derived from this software without specific prior written permission.

;

; THIS SOFTWARE IS PROVIDED BY Alexey Teplov nickname  ''AS IS'' AND ANY

; EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

; DISCLAIMED. IN NO EVENT SHALL  BE LIABLE FOR ANY

; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

; (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

; ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

; â ýòîé ñåêöèè èäåò ðàçáîð ïàðàìåòðîâ óêàçàòåëü íà ñåêöèþ õðàíèòüñÿ â point_default

;òèïû îøèáîê ïðè îáðàáîòêå ìàêðîñà

;Ìàêðîñ RamdiskFS

;/îïðåäåëåíèå ôëàãîâ â çàïèñè êîðíåâîé äèðåêòîðèè

ATTR_READ_ONLY  equ     0x01

ATTR_HIDDEN     equ     0x02

ATTR_SYSTEM     equ     0x04

ATTR_VOLUME_ID  equ     0x08

ATTR_DIRECTORY  equ     0x10

ATTR_ARCHIVE    equ     0x20

show_error_1    equ     0x1     ;êîí÷èëèñü äàííûå - íå çàïëàíèðîâàííûé êîíåö ñåêöèè

show_error_2    equ     0x2     ;íåò çàâåðøàþùåãî ñèìâîëà â ðàçìåðå ðàì äèñêà.

show_error_3    equ     0x4     ; ðàì äèñê áóäåò èìåòü ðàçìåð =64 êá.

show_error_4    equ     0x8     ;

macro use_parse_def_sect

{

        mov     di, point_default

        push    ini_data_

        pop     es

        mov     si, point_to_point_def

        sub     si, 2

        mov     cx, [si]        ;çàãðóçèì óêàçàòåëü íàñëåäóþùèþ ñåêöèþ

        xor     ax, ax  ;îáíóëèì àx äëÿ î÷èñòêè ôëàãîâ

        sub     cx, di          ;âîò òåïåðü èìååì èñòèíûé ðàçìåð

        mov     save_cx_d, cx   ;ñîõðàíèì çíà÷åíèå cx ñâîåé ïåðåìåííîé

;îáíóëèì ïåðåìåííóþ ôëàãîâ, ýòî íåîáõîäèìî, äëÿ òîãî, ÷òî áû èçáåæàòü îáðàáîòêó ïîâòîðÿþùèõñÿ çíà÷åíèé

        mov     status_flag, ax

;;;;

;ÂÕîä â îáðàáîòêó ïàðñèíãà çíà÷åíèé ñåêöèé. es:di - óêàçàòåëü íà íà÷àëî ñåêöèè cx ðàçìåð ñåêöèè äîñòóïíîé äëÿ ïàðñèíãà

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

;ñîãëàøåíèå íå ðàçðóøàåì bp, es, cs, sp

;use_Loader_Image       ;çàãðóçèòü îáðàç âûøå 1 ìá

use_RamdiskFS

;ïðîâåðÿåòñÿ ñàìûé ïîñëåäíèé.

use_LoaderModule    ;îñîáåííîñòü - ïåðåäàåò óïðàâëåíèå íà çàãðóæåííûé ìîäóëü.

}

macro use_LoaderModule

;êàê âàðèàíò ñåé÷àñ èñïîëüçóåòñÿ ìîäåëü, ïðè çàãðóçêå ìîäóëÿ íà íåãî ïåðåäàåòñÿ óïðàâëåíèå, ðåøåíèå âðåìåíîå

;óïðàâëåíèå áóäåò ïåðåäàâàòüñÿ òîëüêî ïîñëå îáðàáîòêè âñåé ñåêöèè

{

local .found_end_str

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

;îáðàáîòêà êîíñòðóêöèè òèïà LoaderModule=kord/kolibri.ldm

.start_p_LM:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      ._afterLoaderModule     ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'L'

        jnz     .start_p_LM

;ïðîâåðêà íà çíà÷åíèå LoaderModule

;        parse_LoaderModule

        mov     bx, cx

        mov     ax, di

        mov     si, parse_LoaderModule

        mov     cx, parse_LoaderModule_e - parse_LoaderModule

        repe cmpsb

        jnz     .rest_value_loop_LM        ;is not compare

        sub     bx, parse_LoaderModule_e - parse_LoaderModule;correct cx

        add     bx, cx

        mov     cx, bx

        test    status_flag, flag_found_LM              ;îöåíêà ôëàãîâ

        jz      .correct_is_not_set_LM

;       mov     si,found_equal_timeout                          ;ìû íàøëè ÷òî ôëàã óæå óñòàíîâëåí, èíôîðìèðóåì

;       call    printplain

;       jmp     .get_next_str

.correct_is_not_set_LM:

        mov     ax, 0x3d20         ;cut al=' ' ah='='

        repe scasb

        jcxz    .rest_value_loop_LM          ;not found param timeout

        cmp     ah, byte [es:di-1]   ;find '='

        jnz     .rest_value_loop_LM

        repe scasb                 ;cut ' '

        inc     cx

        dec     di

;di óêàçûâàåò íà íà÷àëî áëîêà èíôîðìàöèè, â cx äëèííà äî êîíöà ñåêöèè.

;ïîñëå çàãðóçêè çàíîñèòüñÿ çíà÷åíèå çàíÿòîé ïàìÿòè.

;äëÿ òîãî ÷òî áû çàãðóçèòü ìîäóëü, âîñïîëüçóåìñÿ callback ñåðâèñîì

;îðèãèíàëüíîå ðåøåíèå - ðàçìåñòèì dd ïåðåä ñòðî÷êîé è ïîñëå ñòðî÷êè ðàçìåñòèì byte =0

;ýòî âûãëÿäèò òàê: â ini ôàéëå ñóùåñòâóåò ñòðî÷êà LoaderModule = kord/kernel.loader

;ìû åå ìîäèôèöèðóåì äî òàêîãî ñîñòîÿíèÿ       dw,dw,db'kord/kernel.loader',0 êîíå÷íî ñîõðàíèâ òå çíà÷åíèÿ êîòîðûå ìû çàìåíÿåì

;ñîõðàíèëè ïåâûå 2 word

        push    dword [es:di-6]

        lea     si, [di-6]

        push    word [es:di-2]

        xor     ax, ax

        mov     word [es:di-6], ax      ;âíîñèì íóæíûå çíà÷åíèÿ

;info_real_mode_size ðàçìåð è óêàçàòåëü íà îáëàñòü â êîòîðóþ ìîæíî çàãðóçèòüñÿ

        mov     ax, info_real_mode_size ;0x3000   ;ñëåäóþùèé ñåãìåíò çà äàííûìè

        mov     word [es:di-4], ax

        mov     word [es:di-2], 16      ;êîë-âî áëîêîâ ïî 4 êá =64 êá ò.å. áîëüøå íå ñ÷èòàåì

;;;;;; ïîèñê êîíöà ñòðî÷êè

@@:

        mov     al, byte [es:di]

        cmp     al, ' '

        jz      .found_end_str

        cmp     al, 0xa

        jz      .found_end_str

        cmp     al, 0xd

        jz      .found_end_str

        inc     di

        dec     cx

        jnz     @b

;;;not found äîïóñòèì,÷òî ýòî êîíåö ôàéëà è îí íå èìååò ïðèâû÷íîãî çàâåðåøíèÿ ñòðîêè

.found_end_str:

        push    word [es:di]

        xor     ax, ax

        mov     word [es:di], ax

;        xor     ax,ax   ; function 1 - read file

        mov     di, si  ;file_data

        inc     ax

        push    si

        push    es

        push    es

        pop     ds

        push    cs

        pop     es

        call    far dword [es:loader_callback]

        push    cs

        pop     ds

        pop     es

        pop     si

        test    bx, bx

        jnz     .error_LM

        jmp     far dword [es:si]

.error_LM:

        call    error.LoaderModule

.rest_value_loop_LM:

        mov     di, ax

        mov     cx, bx

        jmp     .start_p_LM

._afterLoaderModule:

}

macro use_RamdiskFS

; ôîðìèðîâàíèå ðàì äèñêà, + îáðàáîòêà âñåãî ñâÿçàííîãî.

{

if DEBUG

local ._not_memory_in_sys

;//////// clear window

        mov     ax, 3

        int     0x10

;\\\\\\\\\ clear window is end

        mov     si, ramdiskFS_st

        call    printplain

end if

; îáíóëèì ðåãèñòð ñîñòîÿíèÿ îøèáîê

        xor     ax, ax

        mov     show_errors_sect, ax

use_free_memory ; óçíàåì êàêîãî îáúåìà ó íàñ äîñòóïíà ïàìÿòü. çíà÷åíèå âîçàðàùàåòñÿ â ax

;óçíàåì ñêîëüêî ó íàñ åñòü ïàìÿòè è ñìîæåì ëè ìû ñôîðìèðîâàòü íóæíîãî ðàçìåðà ðàì äèñê.

use_RamdiskSize ;çíà÷åíèå âîçâðàùàåòñÿ â bx

        cmp     free_ad_memory, bx      ; ðàçìåðíîñòü â êá.

        jbe     ._not_memory_in_sys

        movzx   eax, bx

        shl     eax, 10 ;*1024 = get size in byte

        mov     save_ramdisksize, eax   ; ñîðõàíèì ðàçìåð â byte

get_type_FS     ;ïîëó÷èì òèï ôàéëîâîé ñèñòåìû + ñîçäàäèì åå

._not_memory_in_sys:

if DEBUG

;pause

        xor     ax, ax

        int     0x16

end if

}

macro use_RamdiskSize

{

local .start_p_RS

local .correct_is_not_set_RS

local .CS

local .correct_val_RS

local .correct_size_RS

local .rest_value_loop_RS

local .end_get_RS_ERROR_1

local .end_get_RS_ERROR_2

local ._end_parse_RS

;îáðàáàòûâàåòñÿ ðàçìåð ôîðìèðóåìîãî ðàì äèñêà

;çàãðóçèì íà÷àëî ñåêöèè, ò.ê. áóäåì ïðîñìàòðèâàòü ñ íà÷àëà è âñþ ñåêöèþ

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

.start_p_RS:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      ._end_parse_RS  ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'R'

        jnz     .start_p_RS

;ïðîâåðêà íà çíà÷åíèÿ RamdiskSize

;        parse_RamdiskSize

        mov     bx, cx

        mov     ax, di

        mov     si, parse_RamdiskSize

        mov     cx, parse_RamdiskSize_e - parse_RamdiskSize

        repe cmpsb

        jnz     .rest_value_loop_RS    ;is not compare

        sub     bx, parse_RamdiskSize_e - parse_RamdiskSize;correct cx

        add     bx, cx

        mov     cx, bx

        test    status_flag, flag_found_RS              ;îöåíêà ôëàãîâ

        jz      .correct_is_not_set_RS

;       mov     si,found_equal_timeout                          ;ìû íàøëè ÷òî ôëàã óæå óñòàíîâëåí, èíôîðìèðóåì

;       call    printplain

;       jmp     .get_next_str

.correct_is_not_set_RS:

        mov     ax, 0x3d20         ;cut al=' ' ah='='

        repe scasb

        jcxz    .end_get_RS_ERROR_1          ;not found param

        cmp     ah, byte [es:di-1]   ;find '='

        jnz     .start_p_RS                     ; ïåðåéäåì íà íà÷àëî è ïîïðîáóåì íàéòè åùå ñåêöèþ

        repe scasb                 ;cut ' '

        inc     cx

        dec     di

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

;Òóò íóæíî ïðåîáðàçîâûâàòü ñòðî÷êó â öèôðîâîå çíà÷åíèå.

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

        xor     bx, bx

        mov     cx, 5

@@:

        mov     al, byte [es:di]

        cmp     al, '0'

        jb      .CS

        cmp     al, '9'

        jbe     .correct_val_RS

.CS:

        cmp     al, 'K'

        jz      .correct_size_RS

        jmp     .end_get_RS_ERROR_2

.correct_val_RS:

        imul    bx, 10

        xor     al, 0x30

        add     bl, al

        inc     di

        loop    @b

.correct_size_RS:

;âîçìîæåí 1 âàðèàíò, êîãäà ðàçìåð çàäàí â K êèëëîáàéòàõ

;âíóòðåííûé ôîðìàò äàííûõ ýòî êîë-âî çàïðîùåíîé ïàìÿòè â êá.

        test    bx, bx

        jnz     @f      ;åñëè çíà÷åíèå îòëè÷íî îò 0

;;;;;ñîîáùåíèå îá îøèáêå, ðàçìåð "íàéäåíîãî" áëîêà =0 ìèíèìàëüíî ìû äîëæíû

;óñòàíîâèòü 64 êá ðàçìåð ðàì äèñêà.

        or      show_errors_sect, show_error_3

        mov     bx, 64

@@:

        jmp     ._end_parse_RS

.rest_value_loop_RS:

        mov     di, ax

        mov     cx, bx

        jmp     .start_p_RS

.end_get_RS_ERROR_1:

;ñîîáùåíèå îá îøèáêå - äàííûé ó÷àñòîê êîäà íå áûë êîððåêòíî îáðàáîòàí :(

        or      show_errors_sect, show_error_1

        jmp     ._end_parse_RS

.end_get_RS_ERROR_2:

        or      show_errors_sect, show_error_2

._end_parse_RS:

if DEBUG

        pusha

        movzx   eax, bx

        mov     cx, 0x0a

        mov     di, RamdiskSize_msg

        mov     dword[ds:di], '    '

        mov     word [ds:di+4], '  '

        call    decode

;Show size

        mov     si, RamdiskSize_msg

        call    printplain

        popa

end if

}

macro use_free_memory

{

local _support_function_use_free_memory

;ìàêðîñ äëÿ ïîëó÷åíèÿ îáùåãî ÷èñëà äîñòóïíîé ïàìÿòè â êá, äëÿ ôîðìèðîâàíèÿ ðàì äèñêà çà ïðåäåëàìè 1 ìá.

;èñïîëüçóåòñÿ 0õ88 ôóíêöèÿ 0õ15 ïðåðûâàíèÿ

; åñëè ïîääåðæèâàåòñÿ ôóíêöèÿ, òî â ax çíà÷åíèå â êá, åñëè íåò, òî â ax=0

        mov     ah, 0x88 ;ah,0x88

        int     0x15

        jnc     ._support_function_use_free_memory

        xor     ax, ax

;âîçâðàùàåò â ax ÷èñëî â êá

._support_function_use_free_memory:

        mov     free_ad_memory, ax ; åñëè íå ïîääåðæèâàåòñÿ áèîñîì, òî â ax=0

if DEBUG

        pushad

        movzx   eax, ax

        mov     cx, 0x0a

        mov     di, free_memory_msg

        mov     dword[ds:di], '    '

        mov     word [ds:di+4], '  '

        call    decode

;Show size

        mov     si, free_memory_msg

        call    printplain

        popad

end if

}

macro show_ERRORS

{

}

macro get_type_FS ;ïîëó÷èòü è ñîçäàòü îáðàç äëÿ çàäàííîé RFS.

{

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

.start_g_tpe_RFS:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      ._end_parse_FRS ;._end_get_type_RFS     ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'R'

        jnz     .start_g_tpe_RFS

;ïðîâåðêà íà çíà÷åíèÿ RamdiskSize

;        parse_RamdiskSize

        mov     bx, cx

        mov     ax, di

        mov     si, parse_RamdiskFS

        mov     cx, parse_RamdiskFS_e - parse_RamdiskFS

        repe cmpsb

        jnz     .start_g_tpe_RFS_rest_v    ;is not compare

        sub     bx, parse_RamdiskFS_e - parse_RamdiskFS;correct cx

        add     bx, cx

        mov     cx, bx

        test    status_flag, flag_found_GTRFMS          ;îöåíêà ôëàãîâ

        jz      .correct_is_not_set_FRS

;       mov     si,found_equal_timeout                          ;ìû íàøëè ÷òî ôëàã óæå óñòàíîâëåí, èíôîðìèðóåì

;       call    printplain

;       jmp     .get_next_str

.correct_is_not_set_FRS:

        mov     ax, 0x3d20         ;cut al=' ' ah='='

        repe scasb

        test    cx, cx

        jz      .end_get_FRS_ERROR_1          ;not found param

        cmp     ah, byte [es:di-1]   ;find '='

        jnz     .start_g_tpe_RFS                        ; ïåðåéäåì íà íà÷àëî è ïîïðîáóåì íàéòè åùå ñåêöèþ

        repe scasb                 ;cut ' '

        inc     cx

        dec     di

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

;Òóò íóæíî ïðåîáðàçîâûâàòü ñòðî÷êó â öèôðîâîå çíà÷åíèå.

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

        mov     bx, cx

        mov     ax, di

        mov     si, parse_RFS_FAT

        mov     cx, parse_RFS_FAT_e - parse_RFS_FAT

        repe cmpsb

        jnz     .krfs_cmp          ;is not compare

make_FAT_RamFS  ;ñäåëàòü

if DEBUG

        pusha

        mov     si, make_fat12_RFS_msg

        call    printplain

        popa

end if

        jmp     ._end_parse_FRS

.krfs_cmp:

        mov     cx, bx

        mov     di, ax

        mov     si, parse_RFS_KRFS

        mov     cx, parse_RFS_KRFS_e - parse_RFS_KRFS

        repe cmpsb

;       jnz     @f         ;is not compare

        jmp     ._end_parse_FRS

.start_g_tpe_RFS_rest_v:

        mov     cx, bx

        mov     di, ax

        jmp     .start_g_tpe_RFS

.end_get_FRS_ERROR_1:

;ñîîáùåíèå îá îøèáêå - äàííûé ó÷àñòîê êîäà íå áûë êîððåêòíî îáðàáîòàí :(

        or      show_errors_sect, show_error_1

        jmp     ._end_parse_FRS

.end_get_FRS_ERROR_2:

        or      show_errors_sect, show_error_2

._end_parse_FRS:

if DEBUG

        pusha

        mov     si, get_type_FS_msg

        call    printplain

        popa

end if

}

macro make_FAT_RamFS

{

local .RS1

local .fat12

local .fat16

; ìû äîëæíû ñôîðìèðîâàòü â íà÷àëüíûé îáðàç Ram FS, à ïîòîì çàïèñàòü åãî çà îáëàñòü âûøå 1 ìá..

;äëÿ ñëó÷àÿ ñ FAT12

;       mov     di,fat12_buffer ;ds äîëæåí áûòü = cs

;es:di - óêàçûâàþò íà íà÷àëî áëîêà äëÿ ôîðìèðîâàíèÿ ðàì ôñ.

use_RamdiskSector       ;âîçðàùàåìîå çíà÷åíèå â ax ðàçìåð ñåêòîðà â áàéòàõ

        cmp     ax, 4096;ïî ñïåöèôèêàöèè çíà÷åíèå äîëæíî áûòü â ïðåäåëàõ îò 1 äî 4096

        ja      .RS1

        test    ax, ax

        jnz     @f      ;îøèáêà åñëè ñþäà ïðûãíóëè âñå òàêè ...

.RS1:

        mov     word [fat12_buffer.BPB_BytsPerSec], 512

;;;;;;;;;;ñêàæåì ÷òî ïî äåôîëòó áóäåì þçàòü çíà÷åíèå...

@@:

        mov     word [fat12_buffer.BPB_BytsPerSec], ax;òóò âñå îê

;BPB_SecPerClus êîë-âî ñåêòîðîâ â êëàñòåðå

use_RamdiskCluster      ;âîçðàùàåìîå çíà÷åíèå â al

        cmp     al, 128

        ja      @f

;       test    al,0x1  ;ïðîâåðêà íà êðàòíîñòü )

;       jnz     @f

        mov     byte [fat12_buffer.BPB_SecPerClus], al

        ;incorrect value will be set dafault

;íèæå íåêîððåêòíîå çíà÷åíèå â ò.ê. ðàçìåð êðàòåí 2 è â äèàïàçîíå îò 1 äî 128 âêëþ÷èòåëüíî

; ìû äîëæíû ðóãíóòüñÿ íà ýòî

;@@:    ;mov    byte [fat12_buffer.BPB_SecPerClus],1

;;;;; îïðåäåëåèì êàêàÿ ó íàñ áóäåò èñïîëüçîâàòüñÿ FAT

;ïî óñëîâèþ, fat12<4085<=fat16<65525<=fat32

; fat12_buffer.BPB_BytsPerSec*fat12_buffer.BPB_SecPerClus = êîë-âî ñåêòîðîâ

        movzx   eax, word [fat12_buffer.BPB_BytsPerSec]

        movzx   ebx, byte [fat12_buffer.BPB_SecPerClus]

        imul    ebx, eax;òóò ðàçìåðíîñòü ñåêòîðà

        mov     eax, save_ramdisksize ;ðàçìåð çàïðîøåííîãî ðàì äèñêà â áàéòàõ

        cdq

        idiv    ebx

;;;;;;;; ñåé÷àñ ÷àñòíîå â eax, à îñòàòîê â edx

;ïîëó÷èì êîë-âî ñåêòîðîâ, è ìîæåì óæå îïðåäåëèòü òèï FAT êîòîðóþ íóæíî äåëàòü.

        cmp     eax, 4085

        jb      .fat12

        cmp     eax, 65525

        jb      .fat16

;;;;;;;;;;;;;;;;;;;;;;;; òóò fat32

        mov     set_ramfs, 32   ;óñòàíîâèì òèï ôàéëîâîé ñèñòåìû

        mov     word [fat12_buffer.BPB_RsvdSecCnt], 32

        xor     eax, eax

        mov     word [fat12_buffer.BPB_RootEntCnt], ax

        mov     word [fat12_buffer.BPB_TotSec16], ax

        mov     dword [fat12_buffer.BPB_TotSec32], eax

.fat16: ;fat16

;Äëÿ FAT12 è FAT16 äèñêîâ ýòî ïîëå ñîäåðæèò êîëè÷åñòâî ñåêòîðîâ, à BPB_TotSec32 ðàâíî 0, åñëè çíà÷åíèå <óìåùàåòñÿ> (ìåíüøå 0x10000).

        jmp     $

        mov     set_ramfs, 16   ;óñòàíîâèì òèï ôàéëîâîé ñèñòåìû

        movzx   ebx, byte [fat12_buffer.BPB_SecPerClus]

        imul    eax, ebx

        cmp     eax, 0x10000

        jae     @f

        mov     word [fat12_buffer.BPB_TotSec16], ax

        mov     dword [fat12_buffer.BPB_TotSec32], 0

@@:

;êîëè÷åñòâî ñåêòîðîâ çàíèìàåìîå îäíîé êîïèåé ôàò

;       mov     word [fat12_buffer.BPB_FATSz16],0x9     ;Äëÿ FAT12/FAT16 ýòî êîëè÷åñòâî ñåêòîðîâ îäíîé FAT. ??

;;;; çàïîëíèì BPB_RootEntCnt Äëÿ FAT12 è FAT16 äèñêîâ, ýòî ïîëå ñîäåðæèò ÷èñëî

;32-áàéòíûõ ýëåìåíòîâ êîðíåâîé äèðåêòîðèè. Äëÿ FAT32 äèñêîâ, ýòî ïîëå äîëæíî

;áûòü 0. Ïîêà êîíñòàíòà, íóæíî áóäåò ïîçæå äîäåëàòü.

        mov     eax, root_dir_entry_count

        mov     word [fat12_buffer.BPB_RootEntCnt], ax  ; count of 32-byte dir. entries (224*32 = 14 sectors= 7 kb)

;ïî äîêóìåíòàöèè ðåêîìåíäóþò îòðåçàòü 16 êá äëÿ ðóò äèð íî ýòî î÷ ìíîãî, äàæå äëÿ êîîñ. èìõî äëÿ íà÷àëà õâàòèò è 7 êá

;;;;;;;

;Äëÿ FAT16 ýòî êîëè÷åñòâî ñåêòîðîâ îäíîé FAT. Äëÿ FAT32 ýòî çíà÷åíèå

;ðàâíî 0, à êîëè÷åñòâî ñåêòîðîâ îäíîé FAT ñîäåðæèòñÿ â BPB_FATSz32.

;RootDirSectors = ((BPB_RootEntCnt * 32) + (BPB_BytsPerSec - 1)) / BPB_BytsPerSec;

;TmpVal1 = DskSize - (BPB_ResvdSecCnt + RootDirSectors);

;TmpVal2 = (256 * BPB_SecPerClus) + BPB_NumFATs;

;If(FATType == FAT32)

;    TmpVal2 = TmpVal2 / 2;

;FATSz = (TMPVal1 + (TmpVal2 - 1)) / TmpVal2;

;If(FATType == FAT32) {

;    BPB_FATSz16 = 0;

;    BPB_FATSz32 = FATSz;

;} else {

;    BPB_FATSz16 = LOWORD(FATSz);

;    /* there is no BPB_FATSz32 in a FAT16 BPB */

;}

;=====================================

;RootDirSectors

        movzx   ebx, word [fat12_buffer.BPB_BytsPerSec]

        imul    eax, 32

        add     eax, ebx

        dec     eax

        cdq

        idiv    ebx

;;;;;;;; ñåé÷àñ ÷àñòíîå â eax, à îñòàòîê â edx äëÿ äèñêåòû 1.44 ó íàñ äîëæíî áûòü çíà÷åíèå =14

;BPB_ResvdSecCnt + RootDirSectors

        movzx   ebx, word [fat12_buffer.BPB_RsvdSecCnt]

        add     ebx, eax

;DskSize ó íàñ ýòî çíà÷åíèå óæå ïîëó÷åíî è äîñòóïíî

        movzx   eax, word [fat12_buffer.BPB_TotSec16]   ;äîëæåí áûòü â ñåêòîðàõ

        sub     eax, ebx

;TmpVal1=eax

        shl     edi, 8  ;=edi*256

        movzx   ecx, byte [fat12_buffer.BPB_NumFATs]

        add     edi, ecx

;TmpVal2=edi

        add     eax, edi

        dec     eax

        cdq

        idiv    edi

;FATSz = ñåé÷àñ ÷àñòíîå â eax, à îñòàòîê â edx

        mov     word [fat12_buffer.BPB_FATSz16], ax

.fat12: ;fat12

if DEBUG

; âûâåäåì â îòëàäêå, ÷òî ñîáèðàåìñÿ äåëàòü îáðàç äèñêà c FS=fat12

        pushad

        mov     si, start_making_FAT12_msg

        call    printplain

        popad

end if

;Äëÿ FAT12 è FAT16 äèñêîâ ýòî ïîëå ñîäåðæèò êîëè÷åñòâî ñåêòîðîâ, à BPB_TotSec32 ðàâíî 0, åñëè çíà÷åíèå <óìåùàåòñÿ> (ìåíüøå 0x10000).

        mov     set_ramfs, 12   ;óñòàíîâèì òèï ôàéëîâîé ñèñòåìû

        movzx   ebx, byte [fat12_buffer.BPB_SecPerClus]

        imul    eax, ebx

        cmp     eax, 0x10000

        jae     @f

        mov     word [fat12_buffer.BPB_TotSec16], ax

        mov     dword [fat12_buffer.BPB_TotSec32], 0

@@:

;êîëè÷åñòâî ñåêòîðîâ çàíèìàåìîå îäíîé êîïèåé ôàò

;       mov     word [fat12_buffer.BPB_FATSz16],0x9     ;Äëÿ FAT12/FAT16 ýòî êîëè÷åñòâî ñåêòîðîâ îäíîé FAT. ??

;;;; çàïîëíèì BPB_RootEntCnt Äëÿ FAT12 è FAT16 äèñêîâ, ýòî ïîëå ñîäåðæèò ÷èñëî

;32-áàéòíûõ ýëåìåíòîâ êîðíåâîé äèðåêòîðèè. Äëÿ FAT32 äèñêîâ, ýòî ïîëå äîëæíî

;áûòü 0. Ïîêà êîíñòàíòà, íóæíî áóäåò ïîçæå äîäåëàòü.

        mov     eax, root_dir_entry_count

        mov     word [fat12_buffer.BPB_RootEntCnt], ax  ; count of 32-byte dir. entries (224*32 = 14 sectors= 7 kb)

;ïî äîêóìåíòàöèè ðåêîìåíäóþò îòðåçàòü 16 êá äëÿ ðóò äèð íî ýòî î÷ ìíîãî, äàæå äëÿ êîîñ. èìõî äëÿ íà÷àëà õâàòèò è 7 êá

;;;;;;;

;DskSize(â ñåêòîðàõ)*12 (ðàçìåðíîñòü ôàéëîâîé ñèñòåìû, ò.å ïðåäïîëîæèì ñêîëüêî áèòîâ ïîòðåáóåòñÿ äëÿ àäðåñàöèè ýòîãî îáúåìà) /8 (÷òî ïîëó÷èòü ðàçìåð â áàéòàõ)

;ïîëó÷åííîå ÷èñëî îêðóãëÿåì â áîëüøóþ ñòîðîíó êðàòíîå ñåêòîðó ò.å. 512 áàéò Òàêîé ïîäõîä íå óíèâåðñàëåí, íî ïîêà ïîéäåò

;âîîáùå ó ìåëêîñîôò ýòî âñå ñ÷èòàåòñÿ ðó÷êàìè, íî ìû áóäåì þçàòü òîëüêî ïîä êîîñ ðàì äèñê ñ ôàò12

        movzx   eax, word [fat12_buffer.BPB_TotSec16]

        imul    eax, 12

        shr     eax, 3  ;äåëèì íà 8 íî ò.å. íàì íóæíî äåëèòü åùå è íà 512 èëè áîëåå â çàâèñèìîñòè îò ðàçìåðîâ êëàñòåðà

        movzx   ebx, word [fat12_buffer.BPB_BytsPerSec] ;ðàçìåð ñåêòîðà

        cdq

        idiv    ebx     ;ðàçäåëèì íà ðàçìåð êëàñòåðà

;ñåé÷àñ ó íàñ â eax çíà÷åíèå åãî íóæíî îêðóãëèòü â áîëüøóþ ñòîðîíó êðàòíîìó 512 áàéòàì

;ïðèìåíèì ñëåäóþùåå î÷èñòèì and è äîáàâèì 512 áàéò. òàêèì îáðàçîì âûðàâíèì íà 512 áàéò

;íî ò.ê. âñå ðàâíî äåëèòü íèæíèé êîä íàì íå íóæåí

;       and     eax,0xfff200

;       add     eax,0x200       ;äîáàâèì 512 áàéò        äëÿ 1.44 äèñêåòû èäåàëüíî ïîäõîäèò ))

        inc     ax

;ïî èäåå äîëæíî íà êàæäóþ ôàò òàáëèöó

;ðåçåðâèðîâàòüñÿ 9 ñåêòîðîâ ò.å. ïîëó÷àåòñÿ 2*9=18+1 =19 ñåêòîðîâ ò.å. ðóò äèð íàõîäèòüñÿ íà ñ 20 ñåòîðà ò.å. ñ àäðåñà 0õ2600

;ñåé÷àñ íóæíî âû÷èñëèòü ñêîëüêî áóäåò ñåêòîðîâ çàíèìàòü ôàò ) íóæíî ðàçäåëèòü íà 512

;FATSz = ñåé÷àñ ÷àñòíîå â eax

        mov     word [fat12_buffer.BPB_FATSz16], ax

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

get_firstDataSector ;ïîëó÷èòü ñìåùåíèå äî äàííûõ

;ñîçäàäèì ïåâóþ çàïèñü â ôàò ïî îïðåäåëåííîìó àäðåñó.

first_create_fat_table

;çàêèíèì BPB ôàéëîâîé ñèñòåìû çà 1 ìá.

use_BPB_RAM

;

;êîïèðîâàíèå ôàéëà.

use_RamdiskFile

;;;; âû÷èñëÿåì óêàçàòåëü íà êîðíåâóþ äèð FirstRootDirSecNum = BPB_ResvdSecCnt + (BPB_NumFATs * BPB_FATSz16);

;       movzx   ebx, [fat12_buffer.BPB_NumFATs]

;       movzx   eax,ax

;       imul    eax,ebx

;eax=(BPB_NumFATs * BPB_FATSz16)

;       inc     eax

; BPB_ResvdSecCnt çíà÷åíèå òîëüêî 1 äëÿ fat12/16

;â eax óêàçàòåëü íà root dir. äëÿ äèñêåòû fat12 äîëæíî ïîëó÷èòüñÿ ïðè êîë-âî êîïèé fat 1  = 1+ (1*1) =2 èëè 3

if DEBUG

        pusha

;       mov     ax,point_default

;        mov     ax,cx

        mov     cx, 0x0a

        mov     di, show_db1

;        mov     dword[ds:di],'    '

;       mov     word [ds:di+4],'  '

        call    decode

;Show size

        mov     si, show_db1

        call    printplain

;

;       xor     ax,ax

;       int     0x16

        popa

end if

}

macro use_RamdiskSector

{

;äëÿ íåêîòîðûõ FS áóäåò èãíîðèðîâàòüñÿ

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

.start_RamdiskSector:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      .end_RamdiskSector      ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'R'

        jnz     .start_RamdiskSector

;ïðîâåðêà íà çíà÷åíèÿ RamdiskSize

;        parse_RamdiskSize

        mov     bx, cx

        mov     ax, di

        mov     si, parse_RamdiskSector

        mov     cx, parse_RamdiskSector_e - parse_RamdiskSector

        repe cmpsb

        jnz     .RamdiskSector_rest_val    ;is not compare

        sub     bx, parse_RamdiskSector_e - parse_RamdiskSector;correct cx

        add     bx, cx

        mov     cx, bx

        test    status_flag, flag_found_RamdiskSector           ;îöåíêà ôëàãîâ

        jz      .correct_is_not_set_RamdiskSector

;       mov     si,found_equal_timeout                          ;ìû íàøëè ÷òî ôëàã óæå óñòàíîâëåí, èíôîðìèðóåì

;       call    printplain

;       jmp     .get_next_str

.correct_is_not_set_RamdiskSector:

        mov     ax, 0x3d20         ;cut al=' ' ah='='

        repe scasb

        jcxz    .end_get_RamS_ERROR_1          ;not found param

        cmp     ah, byte [es:di-1]   ;find '='

        jnz     .start_RamdiskSector                    ; ïåðåéäåì íà íà÷àëî è ïîïðîáóåì íàéòè åùå ñåêöèþ

        repe scasb                 ;cut ' '

        inc     cx

        dec     di

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

        xor     bx, bx

        mov     cx, 4

@@:

        movzx   ax, byte [es:di]

        cmp     al, '0'

        jb      .end_RamdiskSector

        cmp     al, '9'

        ja      .end_RamdiskSector

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

        imul    bx, 10

        xor     al, 0x30

        add     bx, ax

        inc     di

        loop    @b

        jmp     .end_RamdiskSector

.RamdiskSector_rest_val:

        mov     cx, bx

        mov     di, ax

        jmp     .start_RamdiskSector

.end_get_RamS_ERROR_1:

.end_RamdiskSector:

        mov     ax, bx

if DEBUG

        pusha

        movzx   eax, bx;save_cx_d;point_default

        mov     cx, 0x0a

        mov     di, RamdiskSector_msg

        mov     dword[ds:di], '    '

        mov     dword [ds:di+4], '    '

        call    decode

;Show size

        mov     si, RamdiskSector_msg

        call    printplain

        popa

end if

;       pop     di

;       pop     es

}

macro use_RamdiskCluster

{

;äëÿ íåêîòîðûõ FS áóäåò èãíîðèðîâàòüñÿ

;       push    es

;       push    di

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

;       push    ini_data_

;       pop     es

.start_RamdiskCluster:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      .end_RamdiskCluster     ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'R'

        jnz     .start_RamdiskCluster

;ïðîâåðêà íà çíà÷åíèÿ RamdiskSize

;        parse_RamdiskSize

        mov     bx, cx

        mov     ax, di

        mov     si, parse_RamdiskCluster

        mov     cx, parse_RamdiskCluster_e - parse_RamdiskCluster

        repe cmpsb

        jnz     .RamdiskCluster_rest_val           ;is not compare

        sub     bx, parse_RamdiskCluster_e - parse_RamdiskCluster;correct cx

        add     bx, cx

        mov     cx, bx

        test    status_flag, flag_found_RamdiskCluster          ;îöåíêà ôëàãîâ

        jz      .correct_is_not_set_RamdiskCluster

;       mov     si,found_equal_timeout                          ;ìû íàøëè ÷òî ôëàã óæå óñòàíîâëåí, èíôîðìèðóåì

;       call    printplain

;       jmp     .get_next_str

.correct_is_not_set_RamdiskCluster:

        mov     ax, 0x3d20         ;cut al=' ' ah='='

        repe scasb

        jcxz    .end_get_RamSC_ERROR_1          ;not found param

        cmp     ah, byte [es:di-1]   ;find '='

        jnz     .start_RamdiskCluster                   ; ïåðåéäåì íà íà÷àëî è ïîïðîáóåì íàéòè åùå ñåêöèþ

        repe scasb                 ;cut ' '

        inc     cx

        dec     di

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

@@:

        movzx   ax, byte [es:di]

        cmp     al, '0'

        jb      .end_RamdiskCluster

        cmp     al, '9'

        ja      .end_RamdiskCluster

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

        xor     al, 0x30

        jmp     .end_RamdiskCluster

.RamdiskCluster_rest_val:

        mov     cx, bx

        mov     di, ax

        jmp     .start_RamdiskCluster

.end_get_RamSC_ERROR_1:

.end_RamdiskCluster:

if DEBUG

        pusha

        mov     cx, 0x0a

        mov     di, RamdiskCluster_msg

;        mov     word[ds:di],'  '

        call    decode

;Show size

        mov     si, RamdiskCluster_msg

        call    printplain

        popa

end if

}

macro use_Loader_Image

;ïðåäíàçíà÷åí äëÿ çàãðóçêè îáðàçîâ âûøå 1 Ìá.

;ïåðâîíà÷àëüíàÿ âåðñèÿ çàãðóæàåò îáðàç äèñêåòû 1.44 ìá

{

local .start_p_LI

local .exit

local .error_LI

local .rest_value_loop

local .found_end_str

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

;îáðàáîòêà êîíñòðóêöèè òèïà LoaderModule=kord/kolibri.ldm

.start_p_LI:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      .exit   ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'L'

        jnz     .start_p_LI

;ïðîâåðêà íà çíà÷åíèå LoaderModule

;        parse_LoaderModule

        mov     bx, cx

        mov     ax, di

        mov     si, parse_LoaderImage

        mov     cx, parse_LoaderImage_e - parse_LoaderImage

        repe cmpsb

        jnz     .rest_value_loop           ;is not compare

        sub     bx, parse_LoaderImage_e - parse_LoaderImage;correct cx

        add     bx, cx

        mov     cx, bx

;       test    status_flag,flag_found_LM               ;îöåíêà ôëàãîâ

;       jz      .correct_is_not_set_LI

;       mov     si,found_equal_timeout                          ;ìû íàøëè ÷òî ôëàã óæå óñòàíîâëåí, èíôîðìèðóåì

;       call    printplain

;       jmp     .get_next_str

;.correct_is_not_set_LI:

        mov     ax, 0x3d20         ;cut al=' ' ah='='

        repe scasb

        jcxz    .rest_value_loop_LI          ;not found param timeout

        cmp     ah, byte [es:di-1]   ;find '='

        jnz     .rest_value_loop_LI

        repe scasb                 ;cut ' '

        inc     cx

        dec     di

;di óêàçûâàåò íà íà÷àëî áëîêà èíôîðìàöèè, â cx äëèííà äî êîíöà ñåêöèè.

;ïîñëå çàãðóçêè çàíîñèòüñÿ çíà÷åíèå çàíÿòîé ïàìÿòè.

;äëÿ òîãî ÷òî áû çàãðóçèòü ìîäóëü, âîñïîëüçóåìñÿ callback ñåðâèñîì

;îðèãèíàëüíîå ðåøåíèå - ðàçìåñòèì dd ïåðåä ñòðî÷êîé è ïîñëå ñòðî÷êè ðàçìåñòèì byte =0

;ýòî âûãëÿäèò òàê: â ini ôàéëå ñóùåñòâóåò ñòðî÷êà LoaderModule = kord/kernel.loader

;ìû åå ìîäèôèöèðóåì äî òàêîãî ñîñòîÿíèÿ       dw,dw,db'kord/kernel.loader',0 êîíå÷íî ñîõðàíèâ òå çíà÷åíèÿ êîòîðûå ìû çàìåíÿåì

;ñîõðàíèëè ïåâûå 2 word

        push    dword [es:di-6]

        lea     si, [di-6]

        push    word [es:di-2]

        xor     ax, ax

        mov     word [es:di-6], ax      ;âíîñèì íóæíûå çíà÷åíèÿ

;info_real_mode_size ðàçìåð è óêàçàòåëü íà îáëàñòü â êîòîðóþ ìîæíî çàãðóçèòüñÿ

        mov     ax, info_real_mode_size ;0x3000   ;ñëåäóþùèé ñåãìåíò çà äàííûìè

        mov     word [es:di-4], ax

        mov     word [es:di-2], 16      ;êîë-âî áëîêîâ ïî 4 êá =64 êá ò.å. áîëüøå íå ñ÷èòàåì

;;;;;; ïîèñê êîíöà ñòðî÷êè

@@:

        mov     al, byte [es:di]

        cmp     al, ' '

        jz      .found_end_str

        cmp     al, 0xa

        jz      .found_end_str

        cmp     al, 0xd

        jz      .found_end_str

        inc     di

        dec     cx

        jnz     @b

;;;not found äîïóñòèì,÷òî ýòî êîíåö ôàéëà è îí íå èìååò ïðèâû÷íîãî çàâåðåøíèÿ ñòðîêè

.found_end_str:

; ÷òåíèå áëîêà ïî 64 êá â ñåãìåíò è çàáðàñûâàíèå åãî âûøå 1 ìá.

        push    word [es:di]

        xor     ax, ax

        mov     word [es:di], ax

;        xor     ax,ax   ; function 1 - read file

        mov     di, si  ;file_data

        inc     ax

        push    si

        push    es

        call    far dword [loader_callback]

        push    cs

        pop     ds

        pop     es

        pop     si

        test    bx, bx

        jnz     .error_LM

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; çàáðàñûâàíèå áëîêà â 64 êá âûøå 1 ìá.

        mov     si, table_15_87

        push    es

        push    ds

        pop     es

        mov     cx, 256*18

        mov     ah, 0x87

        int     0x15

        pop     es

        pop     dx cx

        test    ah, ah

        jmp     far dword [es:si]

.rest_value_loop:

        mov     di, ax

        mov     cx, bx

        jmp     .start_p_LI

.exit:

}

macro name_in_root_fat

;ìàêðîñ, êîòîðûé çàïèñûâàåò èíôîðìàöèþ î çàãðóæåííîì ôàéëå â êîðíåâóþ ôàò òàáëèöó

{

}

macro use_RamdiskFile

{

;çàãðóçêà ôàéëîâ ñ èñïîëüçîâàíèå callback ñåðâèñà ïåðâè÷íîãî çàãðóç÷èêà

;èñïîëüçóåòñÿ òîëüêî äëÿ çàãðóçêè íåîáõîäèìûõ è íåáîëüøèõ ôàéëîâ, ò.ê. äîñòàòî÷íî ìåäëåííî ðàáîòàåò

;äëÿ çàãðóçêè èñïîëüçóåò 0õ87 ôóíêöèþ int 0x15 ïðåðûâàíèÿ - çàãðóçêà áëîêîâ äàííûõ äî 64 êá âûøå 1 ìá

local   .start_loop

local   ._end

local   .rest_value_loop

local   .error

        mov     di, point_default  ;restore value

        mov     cx, save_cx_d

        mov     data_offset, 0  ;clean offset

;îáðàáîòêà êîíñòðóêöèè òèïà LoaderModule=kord/kolibri.ldm

.start_loop:

        call    get_firs_sym    ;get first symbol on new line

        test    cx, cx

        jz      ._end   ;íåòó? íó ëàäíî - ñëåäóþùåå çíà÷åíèå òîãäà )

        cmp     al, 'R'

        jnz     .start_loop

;ïðîâåðêà íà çíà÷åíèå RamdiskFile

        mov     bx, cx