/kernel/trunk/core/dll.inc |
---|
1,7 → 1,7 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License. ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
901,7 → 901,7 |
align 4 |
proc load_library stdcall, file_name:dword |
locals |
fullname rb 260 |
fullname dd ? |
fileinfo rb 40 |
coff dd ? |
img_base dd ? |
908,19 → 908,17 |
endl |
; resolve file name |
stdcall kernel_alloc, maxPathLength |
mov [fullname], eax |
mov ebx, [file_name] |
lea edi, [fullname+1] |
mov byte [edi-1], '/' |
stdcall get_full_file_name, edi, 259 |
test al, al |
stdcall get_full_file_name, eax, maxPathLength |
test eax, eax |
jz .fail |
; scan for required DLL in list of already loaded for this process, |
; ignore timestamp |
cli |
mov esi, [current_process] |
lea edi, [fullname] |
mov edi, [fullname] |
mov ebx, [esi+PROC.dlls_list_ptr] |
test ebx, ebx |
jz .not_in_process |
942,12 → 940,16 |
sub eax, [ecx+DLLDESCR.defaultbase] |
add eax, [esi+HDLL.base] |
sti |
push eax |
stdcall kernel_free, [fullname] |
pop eax |
ret |
.next_in_process: |
mov esi, [esi+HDLL.fd] |
jmp .scan_in_process |
.not_in_process: |
; scan in full list, compare timestamp |
sti |
lea eax, [fileinfo] |
1182,11 → 1184,11 |
mov [esi+DLLDESCR.bk], eax |
mov [eax+DLLDESCR.fd], esi |
.dll_already_loaded: |
stdcall kernel_free, [fullname] |
inc [esi+DLLDESCR.refcount] |
push esi |
call init_heap |
pop esi |
mov edi, [esi+DLLDESCR.size] |
stdcall user_alloc_at, [esi+DLLDESCR.defaultbase], edi |
test eax, eax |
1255,6 → 1257,7 |
add eax, [img_base] |
sti |
ret |
.fail_and_free_data: |
stdcall kernel_free, [esi+DLLDESCR.data] |
.fail_and_free_dll: |
1263,8 → 1266,10 |
.fail_and_free_coff: |
stdcall kernel_free, [coff] |
.fail: |
stdcall kernel_free, [fullname] |
xor eax, eax |
ret |
.fail_and_free_user: |
stdcall user_free, [img_base] |
.fail_and_dereference: |
/kernel/trunk/core/ext_lib.inc |
---|
5,17 → 5,22 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;============================================================================ |
; |
; External kernel dependencies (libraries) loading |
; |
;============================================================================ |
; External kernel dependencies (libraries) loading. |
; The code currently does not work, requires correcting dll.inc. |
$Revision$ |
if 0 |
; The code currently does not work. Kill "if 0/end if" only after correcting |
; to current kernel (dll.inc). |
iglobal |
tmp_file_name_size dd 1 |
endg |
uglobal |
tmp_file_name_table dd ? |
s_libname rb 64 |
def_val_1 db ? |
endg |
macro library [name,fname] |
{ |
forward |
327,7 → 332,145 |
ret |
endp |
uglobal |
s_libname db 64 dup (0) |
endg |
proc load_file_parse_table |
stdcall kernel_alloc, 0x1000 |
mov [tmp_file_name_table], eax |
mov edi, eax |
mov esi, sysdir_name |
mov ecx, 128/4 |
rep movsd |
invoke ini.enum_keys, conf_fname, conf_path_sect, get_every_key |
mov eax, [tmp_file_name_table] |
mov [full_file_name_table], eax |
mov eax, [tmp_file_name_size] |
mov [full_file_name_table.size], eax |
ret |
endp |
proc get_every_key stdcall, f_name, sec_name, key_name |
mov esi, [key_name] |
mov ecx, esi |
cmp byte [esi], '/' |
jnz @f |
inc esi |
@@: |
mov edi, [tmp_file_name_size] |
shl edi, 7 |
cmp edi, 0x1000 |
jae .stop_parse |
add edi, [tmp_file_name_table] |
lea ebx, [edi+64] |
@@: |
cmp edi, ebx |
jae .skip_this_key |
lodsb |
test al, al |
jz @f |
or al, 20h |
stosb |
jmp @b |
.stop_parse: |
xor eax, eax |
ret |
@@: |
stosb |
invoke ini.get_str, [f_name], [sec_name], ecx, ebx, 64, def_val_1 |
cmp byte [ebx], '/' |
jnz @f |
lea esi, [ebx+1] |
mov edi, ebx |
mov ecx, 63 |
rep movsb |
@@: |
push ebp |
mov ebp, [tmp_file_name_table] |
mov ecx, [tmp_file_name_size] |
jecxz .noreplace |
mov eax, ecx |
dec eax |
shl eax, 7 |
add ebp, eax |
.replace_loop: |
mov edi, ebx |
mov esi, ebp |
@@: |
lodsb |
test al, al |
jz .doreplace |
mov dl, [edi] |
inc edi |
test dl, dl |
jz .replace_loop_cont |
or dl, 20h |
cmp al, dl |
jz @b |
jmp .replace_loop_cont |
.doreplace: |
cmp byte [edi], 0 |
jz @f |
cmp byte [edi], '/' |
jnz .replace_loop_cont |
@@: |
lea esi, [ebp+64] |
call .replace |
jc .skip_this_key2 |
.replace_loop_cont: |
sub ebp, 128 |
loop .replace_loop |
.noreplace: |
pop ebp |
inc [tmp_file_name_size] |
.skip_this_key: |
xor eax, eax |
inc eax |
ret |
.skip_this_key2: |
pop ebp |
jmp .skip_this_key |
endp |
proc get_every_key.replace |
; in: ebx->destination, esi->first part of name, edi->second part of name |
; maximum length is 64 bytes |
; out: CF=1 <=> overflow |
sub esp, 64 ; allocate temporary buffer in stack |
push esi |
lea esi, [esp+4] ; esi->tmp buffer |
xchg esi, edi ; edi->tmp buffer, esi->source |
@@: ; save second part of name to temporary buffer |
lodsb |
stosb |
test al, al |
jnz @b |
pop esi |
mov edi, ebx |
@@: ; copy first part of name to destination |
lodsb |
test al, al |
jz @f |
stosb |
jmp @b |
@@: ; restore second part of name from temporary buffer to destination |
lea edx, [ebx+64] ; limit of destination |
mov esi, esp |
@@: |
cmp edi, edx |
jae .overflow |
lodsb |
stosb |
test al, al |
jnz @b |
add esp, 64 ; CF is cleared |
ret |
.overflow: ; name is too long |
add esp, 64 |
stc |
ret |
endp |
end if |
/kernel/trunk/core/taskman.inc |
---|
1,7 → 1,7 |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
;; ;; |
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License ;; |
;; Copyright (C) KolibriOS team 2004-2016. All rights reserved. ;; |
;; Distributed under terms of the GNU General Public License. ;; |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
41,6 → 41,7 |
img_size rd 1 |
filename_size rd 1 |
cmdline_size rd 1 |
path_string rd 1 |
ends |
macro _clear_ op |
66,43 → 67,39 |
xor ebx, ebx |
fs_execute_from_sysdir_param: |
xor edx, edx |
align 4 |
proc fs_execute |
; ebx - cmdline |
; edx - flags |
; ebp - full filename |
locals |
filename rd 1 |
cmdline rd 1 |
flags rd 1 |
slot rd 1 |
slot_base rd 1 |
;app header data |
hdr_cmdline rd 1 ;0x00 |
hdr_path rd 1 ;0x04 |
hdr_eip rd 1 ;0x08 |
hdr_esp rd 1 ;0x0C |
hdr_edata rd 1 ;0x10 |
hdr_emem rd 1 ;0x14 |
file_base rd 1 ;0x18 |
file_size rd 1 ;0x1c |
filename_size rd 1 ;0x20 |
cmdline_size rd 1 ;0x24 |
hdr_cmdline rd 1 |
hdr_path rd 1 |
hdr_eip rd 1 |
hdr_esp rd 1 |
hdr_edata rd 1 |
hdr_emem rd 1 |
file_base rd 1 |
file_size rd 1 |
filename_size rd 1 |
cmdline_size rd 1 |
path_string rd 1 |
endl |
mov eax, [ebp] |
mov [flags], edx |
mov [cmdline], ebx |
mov [filename], eax |
stdcall kernel_alloc, maxPathLength |
mov [path_string], eax |
mov ebx, [ebp] |
stdcall get_full_file_name, eax, maxPathLength |
test eax, eax |
jz .err_file |
mov eax, [filename] |
stdcall load_file, eax |
stdcall load_file, [path_string] |
mov esi, -ERROR_FILE_NOT_FOUND |
test eax, eax |
jz .err_file |
109,7 → 106,6 |
mov [file_base], eax |
mov [file_size], ebx |
lea ebx, [hdr_cmdline] |
call test_app_header |
mov esi, -0x1F |
117,7 → 113,6 |
jz .err_hdr |
call lock_application_table |
call alloc_thread_slot |
mov esi, -0x20 ; too many processes |
test eax, eax |
127,50 → 122,40 |
shl eax, 8 |
lea edi, [SLOT_BASE+eax] |
mov [slot_base], edi |
;clean extended information about process |
mov ecx, 256/4 |
xor eax, eax |
cld |
rep stosd |
; write application name |
stdcall strrchr, [filename], '/' ; now eax points to name without path |
lea esi, [eax+1] |
test eax, eax |
jnz @F |
mov esi, [filename] |
stdcall strrchr, [path_string], '/' |
lea esi, [eax+1] ; -> name without path |
mov ecx, 11 |
mov edi, [slot_base] |
@@: |
mov ecx, 11 ; 11 chars for name! 8 - is old value! |
mov edi, [slot_base] |
.copy_process_name_loop: |
lodsb |
call utf8to16 |
call uni2ansi_char |
cmp al, '.' |
jz .copy_process_name_done |
jz @f |
test al, al |
jz .copy_process_name_done |
jz @f |
stosb |
loop .copy_process_name_loop |
loop @b |
.copy_process_name_done: |
@@: |
mov edi, [cmdline] |
xor eax, eax |
test edi, edi |
jz @F |
jz @f |
mov ecx, 65535 |
call _strnlen |
cmp eax, 256 |
jb @F |
jb @f |
lea ebx, [eax+1] |
add [hdr_emem], ebx |
@@: |
mov [cmdline_size], eax |
stdcall create_process, [hdr_emem] |
mov esi, -30; no memory |
test eax, eax |
jz .err_hdr |
177,43 → 162,30 |
mov ebx, [sys_proc+LHEAD.prev] |
__list_add eax, ebx, sys_proc |
mov ebx, [hdr_emem] |
mov [eax+PROC.mem_used], ebx |
mov ebx, [slot_base] |
mov [ebx+APPDATA.process], eax |
lea edx, [ebx+APPDATA.list] |
lea ecx, [eax+PROC.thr_list] |
list_add_tail edx, ecx |
mov esi, sizeof.APP_HDR |
add esi, [cmdline_size] |
mov edi, [filename] |
mov ecx, 1023 |
mov edi, [path_string] |
mov ecx, maxPathLength |
call _strnlen |
add esi, eax |
mov [filename_size], eax |
stdcall kernel_alloc, esi |
mov eax, [cmdline_size] |
add eax, sizeof.APP_HDR |
stdcall kernel_alloc, eax |
mov [ebx+APPDATA.exec_params], eax |
mov edi, eax |
lea esi, [hdr_cmdline] |
mov ecx, sizeof.APP_HDR/4 |
rep movsd |
mov esi, [filename] |
mov ecx, [filename_size] |
rep movsb |
mov ecx, [cmdline_size] |
mov esi, [cmdline] |
rep movsb |
lea eax, [hdr_cmdline] |
stdcall set_app_params , [slot], eax, [flags] |
mov eax, [process_number] ;set result |
call unlock_application_table |
ret |
220,10 → 192,10 |
.err_0: |
call unlock_application_table |
.err_hdr: |
stdcall kernel_free, [file_base] |
.err_file: |
stdcall kernel_free, [path_string] |
mov eax, esi |
ret |
endp |
848,96 → 820,48 |
align 4 |
common_app_entry: |
mov ebp, [current_slot] |
mov ebp, [ebp+APPDATA.exec_params] |
test ebp, ebp |
jz .exit |
stdcall map_process_image, [ebp+APP_HDR._emem],\ |
[ebp+APP_HDR.img_base], [ebp+APP_HDR.img_size] |
xor eax, eax |
mov esi, [ebp+APP_HDR.path_string] |
mov edi, [ebp+APP_HDR.path] |
lea esi, [ebp+sizeof.APP_HDR] |
push esi |
test edi, edi |
jz @f |
mov ecx, [ebp+APP_HDR.filename_size] |
test edi, edi |
jnz .copy_filename |
add esi, ecx |
jmp .check_cmdline |
.copy_full_path: |
mov esi, [current_slot] |
mov esi, [esi+APPDATA.cur_dir] |
mov ebx, 1023 |
mov al, '/' |
stosb |
.copy_path: |
dec ebx |
jz .finish_path |
lodsb |
stosb |
test al, al |
jnz .copy_path |
mov byte [edi-1], '/' |
cmp ecx, ebx |
jbe @F |
mov ecx, ebx |
rep movsb |
mov byte [edi], 0 |
@@: |
lea esi, [ebp+sizeof.APP_HDR] |
xor eax, eax |
rep movsb |
stosb |
jmp .check_cmdline |
.finish_path: |
xor eax, eax |
stosb |
jmp .check_cmdline |
.copy_filename: |
cmp byte [esi], '/' |
jne .copy_full_path |
rep movsb |
stosb |
.check_cmdline: |
call kernel_free |
mov edi, [ebp+APP_HDR.cmdline] |
mov ecx, [ebp+APP_HDR.cmdline_size] |
test edi, edi |
jz .check_tls_header |
lea esi, [ebp+sizeof.APP_HDR] |
mov ecx, [ebp+APP_HDR.cmdline_size] |
cmp ecx, 256 |
jb .copy_cmdline |
mov edi, [ebp+APP_HDR._emem] |
add edi, 4095 |
and edi, -4096 |
sub edi, ecx |
dec edi |
cmp word [6], '00' |
jne @F |
jne @f |
mov [APP_HEADER_00_.i_param], edi |
jmp .copy_cmdline |
@@: |
mov [APP_HEADER_01_.i_param], edi |
.copy_cmdline: |
rep movsb |
stosb |
mov byte [edi], 0 |
.check_tls_header: |
cmp word [6], '02' |
jne .cleanup |
call init_heap |
stdcall user_alloc, 4096 |
mov edx, [current_slot] |
mov [edx+APPDATA.tls_base], eax |
mov [tls_data_l+2], ax |
946,11 → 870,9 |
mov [tls_data_l+7], ah |
mov dx, app_tls |
mov fs, dx |
.cleanup: |
stdcall free_kernel_space, [ebp+APP_HDR.img_base] |
stdcall kernel_free, ebp |
mov ebx, [current_slot] |
cmp [ebx+APPDATA.debugger_slot], 0 |
je .exit |
1018,11 → 940,11 |
mov [SLOT_BASE+APPDATA.saved_esp0+ebx], eax |
push ebx |
stdcall kernel_alloc, 0x1000 |
stdcall kernel_alloc, maxPathLength |
pop ebx |
mov esi, [current_slot] |
mov esi, [esi+APPDATA.cur_dir] |
mov ecx, 0x1000/4 |
mov ecx, maxPathLength/4 |
mov edi, eax |
mov [ebx+SLOT_BASE+APPDATA.cur_dir], eax |
rep movsd |
/kernel/trunk/docs/sysfuncr.txt |
---|
3385,7 → 3385,8 |
Параметры: |
* eax = 68 - номер функции |
* ebx = 19 - номер подфункции |
* ecx = указатель на ASCIIZ-строку с полным путём к DLL |
* ecx = указатель на строку с путём к DLL, |
правила формирования строки указаны в описании функции 70. |
Возвращаемое значение: |
* eax = 0 - неудача |
* иначе eax = указатель на таблицу экспорта DLL |
3897,9 → 3898,12 |
или |
* +20 = +0x14: byte: 0 |
* +21 = +0x15: dword: указатель на строку |
Для ввода текста в кодировке UTF-16LE нужно расположить в начале строки |
байт со значением 2, иначе будет использоваться кодировка cp866. |
Чувствительность к регистру букв зависит от файловой системы. |
Можно указать кодировку, поместив в начале строки байт со значениями: |
* 1 = cp866 |
* 2 = UTF-16LE |
* 3 = UTF-8 |
иначе будет использоваться кодировка cp866. |
Формат строки: |
/base/number/dir1/dir2/.../dirn/file, |
где base/number идентифицирует устройство, на котором ищется файл: |
/kernel/trunk/docs/sysfuncs.txt |
---|
3348,7 → 3348,8 |
Parameters: |
* eax = 68 - function number |
* ebx = 19 - subfunction number |
* ecx = pointer to ASCIIZ-string with the full path to DLL |
* ecx = pointer to the string with path to DLL, |
rules of path forming can be found in function 70 description. |
Returned value: |
* eax = 0 - failed |
* otherwise eax = pointer to DLL export table |
3852,8 → 3853,12 |
or |
* +20 = +0x14: byte: 0 |
* +21 = +0x15: dword: pointer to string |
You may set encoding to UTF-16LE by starting the string with a byte with value 2, |
otherwise will be used cp866. Case sensitivity depends on filesystem. |
Case sensitivity depends on filesystem. |
To set the encoding, put at the start of the string a byte with next values: |
* 1 = cp866 |
* 2 = UTF-16LE |
* 3 = UTF-8 |
otherwise will be used cp866. |
Format of filename: |
/base/number/dir1/dir2/.../dirn/file, |
where base/number identifies device, on which file is located: |
/kernel/trunk/fs/fs_lfn.inc |
---|
56,8 → 56,21 |
jnz @f |
mov ebp, [ebx+21] |
@@: |
cmp word [ebp], '/' |
jz .rootdir |
cmp byte [ebp], 4 |
jnc @f |
cmp byte [ebp], 0 |
jz @f |
cmp word [ebp+1], '/' |
jnz @f |
cmp byte [ebp], 2 |
jnz .rootdir |
cmp word [ebp+3], 0 |
jz .rootdir |
@@: |
cmp dword[ebx], 7 ; start application |
jne @f |
jnz @f |
mov edx, [ebx+4] |
mov ebx, [ebx+8] |
call fs_execute ; ebp, ebx, edx |
65,25 → 78,16 |
ret |
@@: |
cmp word [ebp], '/' |
jz .rootdir |
cmp byte [ebp], 2 |
jnz @f |
cmp dword[ebp+1], '/' |
jz .rootdir |
@@: |
stdcall kernel_alloc, maxPathLength |
push ebx |
mov ebx, ebp |
mov ebp, eax |
push maxPathLength |
push eax |
call get_full_file_name |
stdcall get_full_file_name, eax, maxPathLength |
pop ebx |
test eax, eax |
jz .notfound |
mov esi, ebp |
mov ax, [ebp] |
lea esi, [ebp+2] |
mov ax, [esi] |
or ax, 2020h |
cmp ax, 'cd' |
jz .CD |
496,11 → 500,13 |
mov ebx, ecx |
get_full_file_name: |
; in: ebx -> file name, [esp+4] -> destination, [esp+8] = max length |
; out: eax=0 -> out of length |
; out: UTF-8 string, eax=0 -> out of length |
push ebp ebx |
cmp byte [ebx], 0 |
jz .set_relative |
mov esi, ebx |
cmp byte [ebx], 2 |
jnz @f |
cmp byte [ebx], 4 |
jnc @f |
inc esi |
@@: |
cmp byte [esi], '/' |
513,6 → 519,10 |
call process_replace_file_name |
mov edi, [esp+12] |
mov ecx, [esp+16] |
mov al, 3 |
mov ah, '/' |
stosw |
sub ecx, 2 |
test ebp, ebp |
jz .absolute |
@@: |
525,12 → 535,23 |
dec edi |
.absolute: |
cmp byte [ebx], 2 |
jz @f |
jz .utf16 |
cmp byte [ebx], 3 |
jz .utf8 |
call cp866toUTF8_string |
jns .ret |
jmp .fail |
@@: |
.utf8: |
dec ecx |
js .fail |
lodsb |
stosb |
test al, al |
jz .ret |
jmp .utf8 |
.utf16: |
call UTF16to8_string |
jns .ret |
.fail: |
550,7 → 571,12 |
dec esi |
mov edi, [esp+12] |
jecxz .fail |
cmp byte [ebx], 2 |
cmp byte [ebx], 0 |
jz .set_ok |
cmp byte [ebx], 4 |
jnc .relative |
inc ebx |
cmp byte [ebx-1], 2 |
jz .relative16 |
.relative: |
cmp byte [ebx], 0 |
/kernel/trunk/fs/parse_fn.inc |
---|
7,54 → 7,43 |
$Revision$ |
iglobal |
; pointer to memory for path replace table, |
; size of one record is 128 bytes: 64 bytes for search pattern + 64 bytes for replace string |
; start with one entry: sys -> <sysdir> |
full_file_name_table dd sysdir_name |
.size dd 1 |
tmp_file_name_size dd 1 |
endg |
uglobal |
; Parser_params will initialize: sysdir_name = "sys", sysdir_path = <sysdir> |
sysdir_name rb 64 |
sysdir_name rb 64 ; 'sys',0 |
sysdir_path rb 64 |
sysdir_name1 rb 64 |
sysdir_path1 rb 64 |
; for example: |
;dir_name1 db 'KolibriOS',0 |
; rb 64-8 |
;dir_path1 db 'HD0/1',0 |
; rb 64-6 |
endg |
; Example: |
; align 64 |
; sysdir_name1 db 'KolibriOS',0 |
; align 64 |
; sysdir_path1 db 'HD0/1',0 |
uglobal |
tmp_file_name_table dd ? |
endg |
; use bx_from_load and init system directory /sys |
proc Parser_params |
locals |
buff db 4 dup(?) ; for test cd |
buff rb 4 ; for test cd |
endl |
mov eax, [OS_BASE+0x10000+bx_from_load] |
mov ecx, sysdir_path |
mov [ecx-64], dword 'sys' |
cmp al, 'r'; if ram disk |
mov [ecx-2], byte 3 |
mov [ecx-1], byte '/' |
cmp al, 'r' ; ram disk |
jnz @f |
mov [ecx], dword 'RD/?' |
mov [ecx+3], byte ah |
mov [ecx+4], byte 0 |
ret |
@@: |
cmp al, 'm'; if ram disk |
jnz @f |
mov [ecx], dword 'CD?/'; if cd disk {m} |
cmp al, 'm' |
jnz .hard_disk |
mov [ecx], dword 'CD?/' |
mov [ecx+4], byte '1' |
mov [ecx+5], dword '/KOL' |
mov [ecx+9], dword 'IBRI' |
63,7 → 52,7 |
mov [ecx+2], byte ah |
inc ah |
cmp ah, '5' |
je .not_found_cd |
je @f |
lea edx, [buff] |
pushad |
stdcall read_file, read_firstapp, edx, 0, 4 |
70,173 → 59,20 |
popad |
cmp [edx], dword 'MENU' |
jne .next_cd |
jmp .ok |
@@: |
ret |
@@: |
sub al, 49 |
mov [ecx], dword 'HD?/'; if hard disk |
.hard_disk: |
sub al, '1' |
mov [ecx], dword 'HD?/' |
mov [ecx+2], byte al |
mov [ecx+4], byte ah |
mov [ecx+5], dword '/KOL' |
mov [ecx+9], dword 'IBRI' |
mov [ecx+13], byte 0 |
.ok: |
.not_found_cd: |
ret |
endp |
proc load_file_parse_table |
stdcall kernel_alloc, 0x1000 |
mov [tmp_file_name_table], eax |
mov edi, eax |
mov esi, sysdir_name |
mov ecx, 128/4 |
rep movsd |
invoke ini.enum_keys, conf_fname, conf_path_sect, get_every_key |
mov eax, [tmp_file_name_table] |
mov [full_file_name_table], eax |
mov eax, [tmp_file_name_size] |
mov [full_file_name_table.size], eax |
ret |
endp |
uglobal |
def_val_1 db 0 |
endg |
proc get_every_key stdcall, f_name, sec_name, key_name |
mov esi, [key_name] |
mov ecx, esi |
cmp byte [esi], '/' |
jnz @f |
inc esi |
@@: |
mov edi, [tmp_file_name_size] |
shl edi, 7 |
cmp edi, 0x1000 |
jae .stop_parse |
add edi, [tmp_file_name_table] |
lea ebx, [edi+64] |
@@: |
cmp edi, ebx |
jae .skip_this_key |
lodsb |
test al, al |
jz @f |
or al, 20h |
stosb |
jmp @b |
@@: |
stosb |
invoke ini.get_str, [f_name], [sec_name], ecx, ebx, 64, def_val_1 |
cmp byte [ebx], '/' |
jnz @f |
lea esi, [ebx+1] |
mov edi, ebx |
mov ecx, 63 |
rep movsb |
@@: |
push ebp |
mov ebp, [tmp_file_name_table] |
mov ecx, [tmp_file_name_size] |
jecxz .noreplace |
mov eax, ecx |
dec eax |
shl eax, 7 |
add ebp, eax |
.replace_loop: |
mov edi, ebx |
mov esi, ebp |
@@: |
lodsb |
test al, al |
jz .doreplace |
mov dl, [edi] |
inc edi |
test dl, dl |
jz .replace_loop_cont |
or dl, 20h |
cmp al, dl |
jz @b |
jmp .replace_loop_cont |
.doreplace: |
cmp byte [edi], 0 |
jz @f |
cmp byte [edi], '/' |
jnz .replace_loop_cont |
@@: |
lea esi, [ebp+64] |
call .replace |
jc .skip_this_key2 |
.replace_loop_cont: |
sub ebp, 128 |
loop .replace_loop |
.noreplace: |
pop ebp |
inc [tmp_file_name_size] |
.skip_this_key: |
xor eax, eax |
inc eax |
ret |
.skip_this_key2: |
pop ebp |
jmp .skip_this_key |
.stop_parse: |
xor eax, eax |
ret |
endp |
proc get_every_key.replace |
; in: ebx->destination, esi->first part of name, edi->second part of name |
; maximum length is 64 bytes |
; out: CF=1 <=> overflow |
; 1) allocate temporary buffer in stack |
sub esp, 64 |
; 2) save second part of name to temporary buffer |
push esi |
lea esi, [esp+4] ; esi->tmp buffer |
xchg esi, edi ; edi->tmp buffer, esi->source |
@@: |
lodsb |
stosb |
test al, al |
jnz @b |
; 3) copy first part of name to destination |
pop esi |
mov edi, ebx |
@@: |
lodsb |
test al, al |
jz @f |
stosb |
jmp @b |
@@: |
; 4) restore second part of name from temporary buffer to destination |
; (may cause overflow) |
lea edx, [ebx+64] ; limit of destination |
mov esi, esp |
@@: |
cmp edi, edx |
jae .overflow |
lodsb |
stosb |
test al, al |
jnz @b |
; all is OK |
add esp, 64 ; CF is cleared |
ret |
.overflow: |
; name is too long |
add esp, 64 |
stc |
ret |
endp |
cp866toUpper: |
; convert cp866 character in al to uppercase |
cmp al, 'a' |
/kernel/trunk/kernel.asm |
---|
1198,7 → 1198,7 |
mov dword [edx+APPDATA.fd_obj], eax |
mov dword [edx+APPDATA.bk_obj], eax |
mov dword [edx+APPDATA.cur_dir], sysdir_path |
mov dword [edx+APPDATA.cur_dir], sysdir_path-2 |
mov [edx + APPDATA.process], sys_proc |
/kernel/trunk/kernel32.inc |
---|
26,8 → 26,6 |
include "core/apic.inc" |
include "core/timers.inc" |
include "core/clipboard.inc" |
include "core/conf_lib.inc" |
include "core/ext_lib.inc" ; load external library |
include "boot/shutdown.inc" ; kernel shutdown |
67,4 → 65,6 |
include "network/stack.inc" |
include "imports.inc" ; list of external functions |
; include "imports.inc" |
; include "core/ext_lib.inc" |
; include "core/conf_lib.inc" |