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


#ifndef INCLUDE_DLL_H
#define INCLUDE_DLL_H
 
char a_libdir[43]  = "/sys/lib/\0";
 
:inline void error_init(dword text)
{
	dword l,ll;
	dword TEXT_ERROR = malloc(1024);
	#ifdef LANG_RUS
		strcpy(TEXT_ERROR,"'è¨¡ª  ¯à¨ § £àã§ª¥ ¡¨¡«¨®â¥ª¨ `");
	#elif LANG_EST
		strcpy(TEXT_ERROR,"'Viga teegi laadimisel `");
	#else
		strcpy(TEXT_ERROR,"'Error while loading library `");
	#endif
	ll = strlen(TEXT_ERROR);
	strcpy(TEXT_ERROR+ll,text);
	l = strlen(text);
	strncpy(TEXT_ERROR+ll+l,"`' -E",4);
	notify(TEXT_ERROR);
	free(TEXT_ERROR);
	ExitProcess();
}
 
// 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, #mem_Alloc
        mov     ebx, #mem_Free;
        mov     ecx, #mem_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;
		//error_init(dllname);
}
 
 
#endif



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

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/dll.h – Rev 5576 → 5598