WebSVN – Kolibri OS – Diff – /programs/cmm/lib/dll.h


#ifndef INCLUDE_DLL_H
#define INCLUDE_DLL_H
#print "[include ]\n"
 
#ifndef INCLUDE_FILESYSTEM_H
#include "../lib/file_system.h"
#endif
 
#ifdef LANG_RUS
	#define _TEXT_ERROR_ADD "'è¨¡ª  ¯à¨ § £àã§ª¥ ¡¨¡«¨®â¥ª¨"
#elif LANG_EST
	#define _TEXT_ERROR_ADD "'Viga teegi laadimisel"
#else
	#define _TEXT_ERROR_ADD "'Error while loading library"
#endif
 
char a_libdir[43]  = "/sys/lib/\0";
 
:inline void error_init(dword text)
{
	dword TEXT_ERROR = malloc(1024);
	sprintf(TEXT_ERROR, "%s `%s`' -E",_TEXT_ERROR_ADD,text);
	notify(TEXT_ERROR);
	free(TEXT_ERROR);
}
 
// stdcall with 1 parameter
void dll_Load() {
asm {
        push    ebp
        mov     ebp, esp
        mov     esi, SSDWORD[EBP+8]
		@next_lib:    
        mov     edx, DSDWORD[ESI]
        or      edx, edx
        jz      exit
        push    esi
        mov     esi, DSDWORD[ESI+4]
        mov     edi, #a_libdir+9
 
@loc01: 
        lodsb
        stosb
        or      al, al
        jnz     loc01
 
        mov     eax, 68
        mov     ebx, 19
        mov     ecx, #a_libdir
        int     0x40
        or      eax, eax
        jz      fail
 
        push    edx
        push    eax
        call    dll_Link
 
        push    eax
        mov     eax, DSDWORD[eax]
        cmp     DSDWORD[EAX], '_bil'    // somehow this needs to be reversed..
        pop     eax
        jnz     loc02
 
        push    DSDWORD[EAX+4]
        call    dll_Init
@loc02:
 
        pop     esi
        add     esi, 8
        jmp     next_lib
@exit:
	xor     eax, eax
        leave
        ret     4
        
@fail:        
        add     esp, 4
        xor     eax, eax
        inc     eax
        leave
        ret     4
    }
}
 
//stdcall with 2 parameters
void dll_Link() {
asm {
        push    ebp
        mov     ebp, esp
        push    eax
        mov     esi, SSDWORD[EBP+12]
        test    esi, esi
        jz      done
@next:        
        lodsd
        test    eax, eax
        jz      done
        push    eax
        push    SSDWORD[EBP+8]
        call    dll_GetProcAddress
        or      eax, eax
        jz      loc03
        mov     DSDWORD[esi-4], eax
        jmp     next
@loc03: 
        mov     SSDWORD[esp], 0
@done:
        pop     eax
        leave
        ret     8
    }
}
 
 
//stdcall with 1 parameter
void dll_Init() {
asm {
        push    ebp
        mov     ebp, esp
        pushad
        mov     eax, #malloc
        mov     ebx, #free;
        mov     ecx, #realloc;
        mov     edx, #dll_Load;
        call    SSDWORD[EBP+8]
        popad
        leave
        ret     4
    }
}
 
 
// stdcall with 2 parameters
void dll_GetProcAddress(){
asm {
        push    ebp
        mov     ebp, esp
        mov     edx, CSDWORD[EBP+8]
        xor     eax, eax
 
@next:        
        or      edx, edx
        jz      end
        cmp     CSDWORD[edx], 0
        jz      end
 
        push    CSDWORD[EBP+12]
        push    CSDWORD[EDX]
        call    dll_StrCmp
        test    eax, eax
        jz      ok
        add     edx, 8
        jmp     next
@ok:
        mov     eax, DSDWORD[EDX+4]
@end:
        leave
        ret     8
    }
}
 
 
// stdcall with 2 parameters
void dll_StrCmp() {
asm {
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     esi, CSDWORD[EBP+8]
        mov     edi, CSDWORD[EBP+12]
        xor     eax, eax
@label1:
        lodsb
        scasb
        jne     fail
        or      al, al
        jnz     label1
        jmp     label_ok
@fail:
        or      eax, -1
@label_ok:
        pop     edi
        pop     esi
        leave
        ret     8
    }
}
 
int load_dll2(dword dllname, import_table, byte need_init)
{
   //dword dllentry=0;
// load DLL
        $mov     eax, 68
        $mov     ebx, 19
        ECX=dllname;
        $int     0x40
        $test    eax, eax
        $jz      exit01
 
// initialize import
        $mov     edx,eax
        ESI=import_table;
 
@import_loop01:
        $lodsd
        $test    eax,eax
        $jz      import_done01
        $push    edx
@import_find01:
        $mov     ebx,DSDWORD[EDX]
        $test    ebx, ebx
        $jz      exit01
        $push    eax
@nex101:
        $mov     cl,DSBYTE[EAX];
        $cmp     cl,DSBYTE[EBX];
        $jnz     import_find_next01
        $test    cl,cl
        $jz      import_found01
        $inc     eax
        $inc     ebx
        $jmp     nex101
@import_find_next01:
        $pop     eax
        $add     edx, 8
        $jmp     import_find01
@import_found01:
        $pop     eax
        $mov     eax,DSDWORD[edx+4]
        $mov     DSDWORD[esi-4],eax
        $pop     edx
       
        $jmp     import_loop01
@import_done01:
        IF (need_init) dll_Init (DSDWORD[EDX+4]);
        return 0;
@exit01:
        return -1;
}
 
byte load_dll(dword dllname, import_table, byte need_init)
{
	if (load_dll2(dllname, import_table, need_init))
	{
		error_init(dllname);
		return false;
	}
	return true;
}
 
 
#endif

Rev 5676	Rev 5690
1	#ifndef INCLUDE_DLL_H	1	#ifndef INCLUDE_DLL_H
2	#define INCLUDE_DLL_H	2	#define INCLUDE_DLL_H
3	#print "[include ]\n"	3	#print "[include ]\n"
4		4
5	#ifndef INCLUDE_FILESYSTEM_H	5	#ifndef INCLUDE_FILESYSTEM_H
6	#include "../lib/file_system.h"	6	#include "../lib/file_system.h"
7	#endif	7	#endif
8		8
9	#ifdef LANG_RUS	9	#ifdef LANG_RUS
10	#define _TEXT_ERROR_ADD "'è¨¡ª ¯à¨ § £àã§ª¥ ¡¨¡«¨®â¥ª¨"	10	#define _TEXT_ERROR_ADD "'è¨¡ª ¯à¨ § £àã§ª¥ ¡¨¡«¨®â¥ª¨"
11	#elif LANG_EST	11	#elif LANG_EST
12	#define _TEXT_ERROR_ADD "'Viga teegi laadimisel"	12	#define _TEXT_ERROR_ADD "'Viga teegi laadimisel"
13	#else	13	#else
14	#define _TEXT_ERROR_ADD "'Error while loading library"	14	#define _TEXT_ERROR_ADD "'Error while loading library"
15	#endif	15	#endif
16		16
17	char a_libdir[43] = "/sys/lib/\0";	17	char a_libdir[43] = "/sys/lib/\0";
18		18
19	:inline void error_init(dword text)	19	:inline void error_init(dword text)
20	{	20	{
21	dword TEXT_ERROR = malloc(1024);	21	dword TEXT_ERROR = malloc(1024);
22	sprintf("%s `%s`' -E",_TEXT_ERROR_ADD,text);	22	sprintf(TEXT_ERROR, "%s `%s`' -E",_TEXT_ERROR_ADD,text);
23	notify(TEXT_ERROR);	23	notify(TEXT_ERROR);
24	free(TEXT_ERROR);	24	free(TEXT_ERROR);
25	}	25	}
26		26
27	// stdcall with 1 parameter	27	// stdcall with 1 parameter
28	void dll_Load() {	28	void dll_Load() {
29	asm {	29	asm {
30	push ebp	30	push ebp
31	mov ebp, esp	31	mov ebp, esp
32	mov esi, SSDWORD[EBP+8]	32	mov esi, SSDWORD[EBP+8]
33	@next_lib:	33	@next_lib:
34	mov edx, DSDWORD[ESI]	34	mov edx, DSDWORD[ESI]
35	or edx, edx	35	or edx, edx
36	jz exit	36	jz exit
37	push esi	37	push esi
38	mov esi, DSDWORD[ESI+4]	38	mov esi, DSDWORD[ESI+4]
39	mov edi, #a_libdir+9	39	mov edi, #a_libdir+9
40		40
41	@loc01:	41	@loc01:
42	lodsb	42	lodsb
43	stosb	43	stosb
44	or al, al	44	or al, al
45	jnz loc01	45	jnz loc01
46		46
47	mov eax, 68	47	mov eax, 68
48	mov ebx, 19	48	mov ebx, 19
49	mov ecx, #a_libdir	49	mov ecx, #a_libdir
50	int 0x40	50	int 0x40
51	or eax, eax	51	or eax, eax
52	jz fail	52	jz fail
53		53
54	push edx	54	push edx
55	push eax	55	push eax
56	call dll_Link	56	call dll_Link
57		57
58	push eax	58	push eax
59	mov eax, DSDWORD[eax]	59	mov eax, DSDWORD[eax]
60	cmp DSDWORD[EAX], '_bil' // somehow this needs to be reversed..	60	cmp DSDWORD[EAX], '_bil' // somehow this needs to be reversed..
61	pop eax	61	pop eax
62	jnz loc02	62	jnz loc02
63		63
64	push DSDWORD[EAX+4]	64	push DSDWORD[EAX+4]
65	call dll_Init	65	call dll_Init
66	@loc02:	66	@loc02:
67		67
68	pop esi	68	pop esi
69	add esi, 8	69	add esi, 8
70	jmp next_lib	70	jmp next_lib
71	@exit:	71	@exit:
72	xor eax, eax	72	xor eax, eax
73	leave	73	leave
74	ret 4	74	ret 4
75		75
76	@fail:	76	@fail:
77	add esp, 4	77	add esp, 4
78	xor eax, eax	78	xor eax, eax
79	inc eax	79	inc eax
80	leave	80	leave
81	ret 4	81	ret 4
82	}	82	}
83	}	83	}
84		84
85	//stdcall with 2 parameters	85	//stdcall with 2 parameters
86	void dll_Link() {	86	void dll_Link() {
87	asm {	87	asm {
88	push ebp	88	push ebp
89	mov ebp, esp	89	mov ebp, esp
90	push eax	90	push eax
91	mov esi, SSDWORD[EBP+12]	91	mov esi, SSDWORD[EBP+12]
92	test esi, esi	92	test esi, esi
93	jz done	93	jz done
94	@next:	94	@next:
95	lodsd	95	lodsd
96	test eax, eax	96	test eax, eax
97	jz done	97	jz done
98	push eax	98	push eax
99	push SSDWORD[EBP+8]	99	push SSDWORD[EBP+8]
100	call dll_GetProcAddress	100	call dll_GetProcAddress
101	or eax, eax	101	or eax, eax
102	jz loc03	102	jz loc03
103	mov DSDWORD[esi-4], eax	103	mov DSDWORD[esi-4], eax
104	jmp next	104	jmp next
105	@loc03:	105	@loc03:
106	mov SSDWORD[esp], 0	106	mov SSDWORD[esp], 0
107	@done:	107	@done:
108	pop eax	108	pop eax
109	leave	109	leave
110	ret 8	110	ret 8
111	}	111	}
112	}	112	}
113		113
114		114
115	//stdcall with 1 parameter	115	//stdcall with 1 parameter
116	void dll_Init() {	116	void dll_Init() {
117	asm {	117	asm {
118	push ebp	118	push ebp
119	mov ebp, esp	119	mov ebp, esp
120	pushad	120	pushad
121	mov eax, #malloc	121	mov eax, #malloc
122	mov ebx, #free;	122	mov ebx, #free;
123	mov ecx, #realloc;	123	mov ecx, #realloc;
124	mov edx, #dll_Load;	124	mov edx, #dll_Load;
125	call SSDWORD[EBP+8]	125	call SSDWORD[EBP+8]
126	popad	126	popad
127	leave	127	leave
128	ret 4	128	ret 4
129	}	129	}
130	}	130	}
131		131
132		132
133	// stdcall with 2 parameters	133	// stdcall with 2 parameters
134	void dll_GetProcAddress(){	134	void dll_GetProcAddress(){
135	asm {	135	asm {
136	push ebp	136	push ebp
137	mov ebp, esp	137	mov ebp, esp
138	mov edx, CSDWORD[EBP+8]	138	mov edx, CSDWORD[EBP+8]
139	xor eax, eax	139	xor eax, eax
140		140
141	@next:	141	@next:
142	or edx, edx	142	or edx, edx
143	jz end	143	jz end
144	cmp CSDWORD[edx], 0	144	cmp CSDWORD[edx], 0
145	jz end	145	jz end
146		146
147	push CSDWORD[EBP+12]	147	push CSDWORD[EBP+12]
148	push CSDWORD[EDX]	148	push CSDWORD[EDX]
149	call dll_StrCmp	149	call dll_StrCmp
150	test eax, eax	150	test eax, eax
151	jz ok	151	jz ok
152	add edx, 8	152	add edx, 8
153	jmp next	153	jmp next
154	@ok:	154	@ok:
155	mov eax, DSDWORD[EDX+4]	155	mov eax, DSDWORD[EDX+4]
156	@end:	156	@end:
157	leave	157	leave
158	ret 8	158	ret 8
159	}	159	}
160	}	160	}
161		161
162		162
163	// stdcall with 2 parameters	163	// stdcall with 2 parameters
164	void dll_StrCmp() {	164	void dll_StrCmp() {
165	asm {	165	asm {
166	push ebp	166	push ebp
167	mov ebp, esp	167	mov ebp, esp
168	push esi	168	push esi
169	push edi	169	push edi
170	mov esi, CSDWORD[EBP+8]	170	mov esi, CSDWORD[EBP+8]
171	mov edi, CSDWORD[EBP+12]	171	mov edi, CSDWORD[EBP+12]
172	xor eax, eax	172	xor eax, eax
173	@label1:	173	@label1:
174	lodsb	174	lodsb
175	scasb	175	scasb
176	jne fail	176	jne fail
177	or al, al	177	or al, al
178	jnz label1	178	jnz label1
179	jmp label_ok	179	jmp label_ok
180	@fail:	180	@fail:
181	or eax, -1	181	or eax, -1
182	@label_ok:	182	@label_ok:
183	pop edi	183	pop edi
184	pop esi	184	pop esi
185	leave	185	leave
186	ret 8	186	ret 8
187	}	187	}
188	}	188	}
189		189
190	int load_dll2(dword dllname, import_table, byte need_init)	190	int load_dll2(dword dllname, import_table, byte need_init)
191	{	191	{
192	//dword dllentry=0;	192	//dword dllentry=0;
193	// load DLL	193	// load DLL
194	$mov eax, 68	194	$mov eax, 68
195	$mov ebx, 19	195	$mov ebx, 19
196	ECX=dllname;	196	ECX=dllname;
197	$int 0x40	197	$int 0x40
198	$test eax, eax	198	$test eax, eax
199	$jz exit01	199	$jz exit01
200		200
201	// initialize import	201	// initialize import
202	$mov edx,eax	202	$mov edx,eax
203	ESI=import_table;	203	ESI=import_table;
204		204
205	@import_loop01:	205	@import_loop01:
206	$lodsd	206	$lodsd
207	$test eax,eax	207	$test eax,eax
208	$jz import_done01	208	$jz import_done01
209	$push edx	209	$push edx
210	@import_find01:	210	@import_find01:
211	$mov ebx,DSDWORD[EDX]	211	$mov ebx,DSDWORD[EDX]
212	$test ebx, ebx	212	$test ebx, ebx
213	$jz exit01	213	$jz exit01
214	$push eax	214	$push eax
215	@nex101:	215	@nex101:
216	$mov cl,DSBYTE[EAX];	216	$mov cl,DSBYTE[EAX];
217	$cmp cl,DSBYTE[EBX];	217	$cmp cl,DSBYTE[EBX];
218	$jnz import_find_next01	218	$jnz import_find_next01
219	$test cl,cl	219	$test cl,cl
220	$jz import_found01	220	$jz import_found01
221	$inc eax	221	$inc eax
222	$inc ebx	222	$inc ebx
223	$jmp nex101	223	$jmp nex101
224	@import_find_next01:	224	@import_find_next01:
225	$pop eax	225	$pop eax
226	$add edx, 8	226	$add edx, 8
227	$jmp import_find01	227	$jmp import_find01
228	@import_found01:	228	@import_found01:
229	$pop eax	229	$pop eax
230	$mov eax,DSDWORD[edx+4]	230	$mov eax,DSDWORD[edx+4]
231	$mov DSDWORD[esi-4],eax	231	$mov DSDWORD[esi-4],eax
232	$pop edx	232	$pop edx
233		233
234	$jmp import_loop01	234	$jmp import_loop01
235	@import_done01:	235	@import_done01:
236	IF (need_init) dll_Init (DSDWORD[EDX+4]);	236	IF (need_init) dll_Init (DSDWORD[EDX+4]);
237	return 0;	237	return 0;
238	@exit01:	238	@exit01:
239	return -1;	239	return -1;
240	}	240	}
241		241
242	byte load_dll(dword dllname, import_table, byte need_init)	242	byte load_dll(dword dllname, import_table, byte need_init)
243	{	243	{
244	if (load_dll2(dllname, import_table, need_init))	244	if (load_dll2(dllname, import_table, need_init))
245	{	245	{
246	error_init(dllname);	246	error_init(dllname);
247	return false;	247	return false;
248	}	248	}
249	return true;	249	return true;
250	}	250	}
251		251
252		252
253	#endif	253	#endif

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/dll.h – Rev 5676 → 5690