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

        mov     ax,di

        mov     si,parse_RamdiskFile

        mov     cx,parse_RamdiskFile_e - parse_RamdiskFile

        repe    cmpsb

        jnz     .rest_value_loop           ;is not compare

        sub     bx,parse_RamdiskFile_e - parse_RamdiskFile ;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

        test    ecx,ecx

        jz      .rest_value_loop   ;not found param timeout

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

        jnz     .rest_value_loop

        repe    scasb              ;cut ' '

        inc     cx

        dec     di

        mov     save_di_RAMDISK,di

        mov     save_cx_RAMDISK,cx