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/fs.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";
 
dword GLOBAL_FUNC_LIB = 0;
dword G_FUNC_LOAD = 0;
dword G_FUNC_GET = 0;
dword PATH_LIBRARY_LOADING = "/rd/1/lib/library.obj";
 
: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;
}
 
:struct OBJECT
{
	void load(dword dllname);
	dword get(dword fname);
} library;
 
:void OBJECT::load(dword dllname)
{
	dword tmp;
	IF(!GLOBAL_FUNC_LIB)
	{
		$mov eax, 68
		$mov ebx, 19
		ECX=#PATH_LIBRARY_LOADING;
		$int 0x40
		tmp = EAX;
		GLOBAL_FUNC_LIB = tmp;
		tmp+=4;
		G_FUNC_LOAD = DSDWORD[tmp];
		tmp+=8;
		G_FUNC_GET = DSDWORD[tmp];
	}
	G_FUNC_LOAD stdcall(dllname);
}
 
:dword OBJECT::get(dword fname)
{
	dword tmp=fname;
	G_FUNC_GET stdcall(tmp);
	return EAX;
}
 
/*
#define INIT_(name) byte init_#name(){object.load(name);
#define IMPORT(name) name = object.get(name);
#define _INIT return 1;}
*/
 
#endif

Rev 5883	Rev 7219
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/fs.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	dword GLOBAL_FUNC_LIB = 0;	19	dword GLOBAL_FUNC_LIB = 0;
20	dword G_FUNC_LOAD = 0;	20	dword G_FUNC_LOAD = 0;
21	dword G_FUNC_GET = 0;	21	dword G_FUNC_GET = 0;
22	dword PATH_LIBRARY_LOADING = "/rd/1/lib/library.obj";	22	dword PATH_LIBRARY_LOADING = "/rd/1/lib/library.obj";
23		23
24	:inline void error_init(dword text)	24	:inline void error_init(dword text)
25	{	25	{
26	dword TEXT_ERROR = malloc(1024);	26	dword TEXT_ERROR = malloc(1024);
27	sprintf(TEXT_ERROR, "%s `%s`' -E",_TEXT_ERROR_ADD,text);	27	sprintf(TEXT_ERROR, "%s `%s`' -E",_TEXT_ERROR_ADD,text);
28	notify(TEXT_ERROR);	28	notify(TEXT_ERROR);
29	free(TEXT_ERROR);	29	free(TEXT_ERROR);
30	}	30	}
31		31
32	// stdcall with 1 parameter	32	// stdcall with 1 parameter
33	:void dll_Load() {	33	:void dll_Load() {
34	asm {	34	asm {
35	push ebp	35	push ebp
36	mov ebp, esp	36	mov ebp, esp
37	mov esi, SSDWORD[EBP+8]	37	mov esi, SSDWORD[EBP+8]
38	@next_lib:	38	@next_lib:
39	mov edx, DSDWORD[ESI]	39	mov edx, DSDWORD[ESI]
40	or edx, edx	40	or edx, edx
41	jz exit	41	jz exit
42	push esi	42	push esi
43	mov esi, DSDWORD[ESI+4]	43	mov esi, DSDWORD[ESI+4]
44	mov edi, #a_libdir+9	44	mov edi, #a_libdir+9
45		45
46	@loc01:	46	@loc01:
47	lodsb	47	lodsb
48	stosb	48	stosb
49	or al, al	49	or al, al
50	jnz loc01	50	jnz loc01
51		51
52	mov eax, 68	52	mov eax, 68
53	mov ebx, 19	53	mov ebx, 19
54	mov ecx, #a_libdir	54	mov ecx, #a_libdir
55	int 0x40	55	int 0x40
56	or eax, eax	56	or eax, eax
57	jz fail	57	jz fail
58		58
59	push edx	59	push edx
60	push eax	60	push eax
61	call dll_Link	61	call dll_Link
62		62
63	push eax	63	push eax
64	mov eax, DSDWORD[eax]	64	mov eax, DSDWORD[eax]
65	cmp DSDWORD[EAX], '_bil' // somehow this needs to be reversed..	65	cmp DSDWORD[EAX], '_bil' // somehow this needs to be reversed..
66	pop eax	66	pop eax
67	jnz loc02	67	jnz loc02
68		68
69	push DSDWORD[EAX+4]	69	push DSDWORD[EAX+4]
70	call dll_Init	70	call dll_Init
71	@loc02:	71	@loc02:
72		72
73	pop esi	73	pop esi
74	add esi, 8	74	add esi, 8
75	jmp next_lib	75	jmp next_lib
76	@exit:	76	@exit:
77	xor eax, eax	77	xor eax, eax
78	leave	78	leave
79	ret 4	79	ret 4
80		80
81	@fail:	81	@fail:
82	add esp, 4	82	add esp, 4
83	xor eax, eax	83	xor eax, eax
84	inc eax	84	inc eax
85	leave	85	leave
86	ret 4	86	ret 4
87	}	87	}
88	}	88	}
89		89
90	//stdcall with 2 parameters	90	//stdcall with 2 parameters
91	:void dll_Link() {	91	:void dll_Link() {
92	asm {	92	asm {
93	push ebp	93	push ebp
94	mov ebp, esp	94	mov ebp, esp
95	push eax	95	push eax
96	mov esi, SSDWORD[EBP+12]	96	mov esi, SSDWORD[EBP+12]
97	test esi, esi	97	test esi, esi
98	jz done	98	jz done
99	@next:	99	@next:
100	lodsd	100	lodsd
101	test eax, eax	101	test eax, eax
102	jz done	102	jz done
103	push eax	103	push eax
104	push SSDWORD[EBP+8]	104	push SSDWORD[EBP+8]
105	call dll_GetProcAddress	105	call dll_GetProcAddress
106	or eax, eax	106	or eax, eax
107	jz loc03	107	jz loc03
108	mov DSDWORD[esi-4], eax	108	mov DSDWORD[esi-4], eax
109	jmp next	109	jmp next
110	@loc03:	110	@loc03:
111	mov SSDWORD[esp], 0	111	mov SSDWORD[esp], 0
112	@done:	112	@done:
113	pop eax	113	pop eax
114	leave	114	leave
115	ret 8	115	ret 8
116	}	116	}
117	}	117	}
118		118
119		119
120	//stdcall with 1 parameter	120	//stdcall with 1 parameter
121	:void dll_Init() {	121	:void dll_Init() {
122	asm {	122	asm {
123	push ebp	123	push ebp
124	mov ebp, esp	124	mov ebp, esp
125	pushad	125	pushad
126	mov eax, #malloc	126	mov eax, #malloc
127	mov ebx, #free;	127	mov ebx, #free;
128	mov ecx, #realloc;	128	mov ecx, #realloc;
129	mov edx, #dll_Load;	129	mov edx, #dll_Load;
130	call SSDWORD[EBP+8]	130	call SSDWORD[EBP+8]
131	popad	131	popad
132	leave	132	leave
133	ret 4	133	ret 4
134	}	134	}
135	}	135	}
136		136
137		137
138	// stdcall with 2 parameters	138	// stdcall with 2 parameters
139	:void dll_GetProcAddress(){	139	:void dll_GetProcAddress(){
140	asm {	140	asm {
141	push ebp	141	push ebp
142	mov ebp, esp	142	mov ebp, esp
143	mov edx, CSDWORD[EBP+8]	143	mov edx, CSDWORD[EBP+8]
144	xor eax, eax	144	xor eax, eax
145		145
146	@next:	146	@next:
147	or edx, edx	147	or edx, edx
148	jz end	148	jz end
149	cmp CSDWORD[edx], 0	149	cmp CSDWORD[edx], 0
150	jz end	150	jz end
151		151
152	push CSDWORD[EBP+12]	152	push CSDWORD[EBP+12]
153	push CSDWORD[EDX]	153	push CSDWORD[EDX]
154	call dll_StrCmp	154	call dll_StrCmp
155	test eax, eax	155	test eax, eax
156	jz ok	156	jz ok
157	add edx, 8	157	add edx, 8
158	jmp next	158	jmp next
159	@ok:	159	@ok:
160	mov eax, DSDWORD[EDX+4]	160	mov eax, DSDWORD[EDX+4]
161	@end:	161	@end:
162	leave	162	leave
163	ret 8	163	ret 8
164	}	164	}
165	}	165	}
166		166
167		167
168	// stdcall with 2 parameters	168	// stdcall with 2 parameters
169	:void dll_StrCmp() {	169	:void dll_StrCmp() {
170	asm {	170	asm {
171	push ebp	171	push ebp
172	mov ebp, esp	172	mov ebp, esp
173	push esi	173	push esi
174	push edi	174	push edi
175	mov esi, CSDWORD[EBP+8]	175	mov esi, CSDWORD[EBP+8]
176	mov edi, CSDWORD[EBP+12]	176	mov edi, CSDWORD[EBP+12]
177	xor eax, eax	177	xor eax, eax
178	@label1:	178	@label1:
179	lodsb	179	lodsb
180	scasb	180	scasb
181	jne fail	181	jne fail
182	or al, al	182	or al, al
183	jnz label1	183	jnz label1
184	jmp label_ok	184	jmp label_ok
185	@fail:	185	@fail:
186	or eax, -1	186	or eax, -1
187	@label_ok:	187	@label_ok:
188	pop edi	188	pop edi
189	pop esi	189	pop esi
190	leave	190	leave
191	ret 8	191	ret 8
192	}	192	}
193	}	193	}
194		194
195	:int load_dll2(dword dllname, import_table, byte need_init)	195	:int load_dll2(dword dllname, import_table, byte need_init)
196	{	196	{
197	//dword dllentry=0;	197	//dword dllentry=0;
198	// load DLL	198	// load DLL
199	$mov eax, 68	199	$mov eax, 68
200	$mov ebx, 19	200	$mov ebx, 19
201	ECX=dllname;	201	ECX=dllname;
202	$int 0x40	202	$int 0x40
203	$test eax, eax	203	$test eax, eax
204	$jz exit01	204	$jz exit01
205		205
206	// initialize import	206	// initialize import
207	$mov edx,eax	207	$mov edx,eax
208	ESI=import_table;	208	ESI=import_table;
209		209
210	@import_loop01:	210	@import_loop01:
211	$lodsd	211	$lodsd
212	$test eax,eax	212	$test eax,eax
213	$jz import_done01	213	$jz import_done01
214	$push edx	214	$push edx
215	@import_find01:	215	@import_find01:
216	$mov ebx,DSDWORD[EDX]	216	$mov ebx,DSDWORD[EDX]
217	$test ebx, ebx	217	$test ebx, ebx
218	$jz exit01	218	$jz exit01
219	$push eax	219	$push eax
220	@nex101:	220	@nex101:
221	$mov cl,DSBYTE[EAX];	221	$mov cl,DSBYTE[EAX];
222	$cmp cl,DSBYTE[EBX];	222	$cmp cl,DSBYTE[EBX];
223	$jnz import_find_next01	223	$jnz import_find_next01
224	$test cl,cl	224	$test cl,cl
225	$jz import_found01	225	$jz import_found01
226	$inc eax	226	$inc eax
227	$inc ebx	227	$inc ebx
228	$jmp nex101	228	$jmp nex101
229	@import_find_next01:	229	@import_find_next01:
230	$pop eax	230	$pop eax
231	$add edx, 8	231	$add edx, 8
232	$jmp import_find01	232	$jmp import_find01
233	@import_found01:	233	@import_found01:
234	$pop eax	234	$pop eax
235	$mov eax,DSDWORD[edx+4]	235	$mov eax,DSDWORD[edx+4]
236	$mov DSDWORD[esi-4],eax	236	$mov DSDWORD[esi-4],eax
237	$pop edx	237	$pop edx
238		238
239	$jmp import_loop01	239	$jmp import_loop01
240	@import_done01:	240	@import_done01:
241	IF (need_init) dll_Init (DSDWORD[EDX+4]);	241	IF (need_init) dll_Init (DSDWORD[EDX+4]);
242	return 0;	242	return 0;
243	@exit01:	243	@exit01:
244	return -1;	244	return -1;
245	}	245	}
246		246
247	:byte load_dll(dword dllname, import_table, byte need_init)	247	:byte load_dll(dword dllname, import_table, byte need_init)
248	{	248	{
249	if (load_dll2(dllname, import_table, need_init))	249	if (load_dll2(dllname, import_table, need_init))
250	{	250	{
251	error_init(dllname);	251	error_init(dllname);
252	return false;	252	return false;
253	}	253	}
254	return true;	254	return true;
255	}	255	}
256		256
257	:struct OBJECT	257	:struct OBJECT
258	{	258	{
259	void load(dword dllname);	259	void load(dword dllname);
260	dword get(dword fname);	260	dword get(dword fname);
261	} library;	261	} library;
262		262
263	:void OBJECT::load(dword dllname)	263	:void OBJECT::load(dword dllname)
264	{	264	{
265	dword tmp;	265	dword tmp;
266	IF(!GLOBAL_FUNC_LIB)	266	IF(!GLOBAL_FUNC_LIB)
267	{	267	{
268	$mov eax, 68	268	$mov eax, 68
269	$mov ebx, 19	269	$mov ebx, 19
270	ECX=#PATH_LIBRARY_LOADING;	270	ECX=#PATH_LIBRARY_LOADING;
271	$int 0x40	271	$int 0x40
272	tmp = EAX;	272	tmp = EAX;
273	GLOBAL_FUNC_LIB = tmp;	273	GLOBAL_FUNC_LIB = tmp;
274	tmp+=4;	274	tmp+=4;
275	G_FUNC_LOAD = DSDWORD[tmp];	275	G_FUNC_LOAD = DSDWORD[tmp];
276	tmp+=8;	276	tmp+=8;
277	G_FUNC_GET = DSDWORD[tmp];	277	G_FUNC_GET = DSDWORD[tmp];
278	}	278	}
279	G_FUNC_LOAD stdcall(dllname);	279	G_FUNC_LOAD stdcall(dllname);
280	}	280	}
281		281
282	:dword OBJECT::get(dword fname)	282	:dword OBJECT::get(dword fname)
283	{	283	{
284	dword tmp=fname;	284	dword tmp=fname;
285	G_FUNC_GET stdcall(tmp);	285	G_FUNC_GET stdcall(tmp);
286	return EAX;	286	return EAX;
287	}	287	}
288		288
289	/*	289	/*
290	#define INIT_(name) byte init_#name(){object.load(name);	290	#define INIT_(name) byte init_#name(){object.load(name);
291	#define IMPORT(name) name = object.get(name);	291	#define IMPORT(name) name = object.get(name);
292	#define _INIT return 1;}	292	#define _INIT return 1;}
293	*/	293	*/
294		294
295	#endif	295	#endif

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/dll.h – Rev 5883 → 7219