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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/dll.h @ 3436 – Rev 7768 → 7984