| Line 1... |
Line 1... |
| 1 |
(* |
1 |
(* |
| 2 |
Copyright 2016, 2018 Anton Krotov |
2 |
BSD 2-Clause License |
| Line 3... |
Line -... |
| 3 |
|
- |
|
| 4 |
This program is free software: you can redistribute it and/or modify |
- |
|
| 5 |
it under the terms of the GNU Lesser General Public License as published by |
3 |
|
| 6 |
the Free Software Foundation, either version 3 of the License, or |
4 |
Copyright (c) 2018, 2019, Anton Krotov |
| 7 |
(at your option) any later version. |
- |
|
| 8 |
|
- |
|
| 9 |
This program is distributed in the hope that it will be useful, |
- |
|
| 10 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
- |
|
| 11 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
- |
|
| 12 |
GNU Lesser General Public License for more details. |
- |
|
| 13 |
|
- |
|
| 14 |
You should have received a copy of the GNU Lesser General Public License |
- |
|
| 15 |
along with this program. If not, see . |
5 |
All rights reserved. |
| Line 16... |
Line 6... |
| 16 |
*) |
6 |
*) |
| Line 17... |
Line 7... |
| 17 |
|
7 |
|
| - |
|
8 |
MODULE KOSAPI; |
| - |
|
9 |
|
| - |
|
10 |
IMPORT SYSTEM; |
| Line 18... |
Line 11... |
| 18 |
MODULE KOSAPI; |
11 |
|
| Line 19... |
Line -... |
| 19 |
|
- |
|
| Line -... |
Line 12... |
| - |
|
12 |
|
| - |
|
13 |
TYPE |
| - |
|
14 |
|
| - |
|
15 |
STRING = ARRAY 1024 OF CHAR; |
| - |
|
16 |
|
| - |
|
17 |
|
| - |
|
18 |
VAR |
| - |
|
19 |
|
| - |
|
20 |
DLL_INIT: PROCEDURE [stdcall] (entry: INTEGER); |
| - |
|
21 |
|
| - |
|
22 |
imp_error*: RECORD |
| - |
|
23 |
|
| 20 |
IMPORT sys := SYSTEM; |
24 |
proc*, lib*: STRING; |
| 21 |
|
25 |
error*: INTEGER |
| - |
|
26 |
|
| 22 |
TYPE STRING = ARRAY 1024 OF CHAR; |
27 |
END; |
| 23 |
|
28 |
|
| 24 |
VAR DLL_INIT: PROCEDURE [stdcall] (entry: INTEGER); |
29 |
|
| 25 |
|
30 |
PROCEDURE [stdcall-] sysfunc1* (arg1: INTEGER): INTEGER; |
| - |
|
31 |
BEGIN |
| 26 |
PROCEDURE [stdcall] sysfunc1*(arg1: INTEGER): INTEGER; |
32 |
SYSTEM.CODE( |
| 27 |
BEGIN |
33 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| Line -... |
Line 34... |
| - |
|
34 |
0CDH, 040H, (* int 64 *) |
| 28 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
35 |
0C9H, (* leave *) |
| 29 |
sys.CODE("CD40"); (* int 40h *) |
36 |
0C2H, 004H, 000H (* ret 4 *) |
| - |
|
37 |
) |
| 30 |
sys.CODE("C9"); (* leave *) |
38 |
RETURN 0 |
| 31 |
sys.CODE("C20400"); (* ret 04h *) |
39 |
END sysfunc1; |
| 32 |
RETURN 0 |
40 |
|
| 33 |
END sysfunc1; |
41 |
|
| 34 |
|
42 |
PROCEDURE [stdcall-] sysfunc2* (arg1, arg2: INTEGER): INTEGER; |
| 35 |
PROCEDURE [stdcall] sysfunc2*(arg1, arg2: INTEGER): INTEGER; |
43 |
BEGIN |
| 36 |
BEGIN |
44 |
SYSTEM.CODE( |
| - |
|
45 |
053H, (* push ebx *) |
| 37 |
sys.CODE("53"); (* push ebx *) |
46 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 38 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
47 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| Line -... |
Line 48... |
| - |
|
48 |
0CDH, 040H, (* int 64 *) |
| 39 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
49 |
05BH, (* pop ebx *) |
| 40 |
sys.CODE("CD40"); (* int 40h *) |
50 |
0C9H, (* leave *) |
| - |
|
51 |
0C2H, 008H, 000H (* ret 8 *) |
| 41 |
sys.CODE("5B"); (* pop ebx *) |
52 |
) |
| 42 |
sys.CODE("C9"); (* leave *) |
53 |
RETURN 0 |
| 43 |
sys.CODE("C20800"); (* ret 08h *) |
54 |
END sysfunc2; |
| 44 |
RETURN 0 |
55 |
|
| 45 |
END sysfunc2; |
56 |
|
| 46 |
|
57 |
PROCEDURE [stdcall-] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER; |
| 47 |
PROCEDURE [stdcall] sysfunc3*(arg1, arg2, arg3: INTEGER): INTEGER; |
58 |
BEGIN |
| 48 |
BEGIN |
59 |
SYSTEM.CODE( |
| - |
|
60 |
053H, (* push ebx *) |
| 49 |
sys.CODE("53"); (* push ebx *) |
61 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 50 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
62 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| Line -... |
Line 63... |
| - |
|
63 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| 51 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
64 |
0CDH, 040H, (* int 64 *) |
| 52 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
65 |
05BH, (* pop ebx *) |
| - |
|
66 |
0C9H, (* leave *) |
| 53 |
sys.CODE("CD40"); (* int 40h *) |
67 |
0C2H, 00CH, 000H (* ret 12 *) |
| 54 |
sys.CODE("5B"); (* pop ebx *) |
68 |
) |
| 55 |
sys.CODE("C9"); (* leave *) |
69 |
RETURN 0 |
| 56 |
sys.CODE("C20C00"); (* ret 0Ch *) |
70 |
END sysfunc3; |
| 57 |
RETURN 0 |
71 |
|
| 58 |
END sysfunc3; |
72 |
|
| 59 |
|
73 |
PROCEDURE [stdcall-] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER; |
| 60 |
PROCEDURE [stdcall] sysfunc4*(arg1, arg2, arg3, arg4: INTEGER): INTEGER; |
74 |
BEGIN |
| 61 |
BEGIN |
75 |
SYSTEM.CODE( |
| - |
|
76 |
053H, (* push ebx *) |
| 62 |
sys.CODE("53"); (* push ebx *) |
77 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 63 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
78 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| Line -... |
Line 79... |
| - |
|
79 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| 64 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
80 |
08BH, 055H, 014H, (* mov edx, dword [ebp + 20] *) |
| 65 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
81 |
0CDH, 040H, (* int 64 *) |
| - |
|
82 |
05BH, (* pop ebx *) |
| 66 |
sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
83 |
0C9H, (* leave *) |
| 67 |
sys.CODE("CD40"); (* int 40h *) |
84 |
0C2H, 010H, 000H (* ret 16 *) |
| 68 |
sys.CODE("5B"); (* pop ebx *) |
85 |
) |
| 69 |
sys.CODE("C9"); (* leave *) |
86 |
RETURN 0 |
| 70 |
sys.CODE("C21000"); (* ret 10h *) |
87 |
END sysfunc4; |
| 71 |
RETURN 0 |
88 |
|
| 72 |
END sysfunc4; |
89 |
|
| 73 |
|
90 |
PROCEDURE [stdcall-] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER; |
| 74 |
PROCEDURE [stdcall] sysfunc5*(arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER; |
91 |
BEGIN |
| 75 |
BEGIN |
92 |
SYSTEM.CODE( |
| 76 |
sys.CODE("53"); (* push ebx *) |
93 |
053H, (* push ebx *) |
| 77 |
sys.CODE("56"); (* push esi *) |
94 |
056H, (* push esi *) |
| - |
|
95 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 78 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
96 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| 79 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
97 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| Line -... |
Line 98... |
| - |
|
98 |
08BH, 055H, 014H, (* mov edx, dword [ebp + 20] *) |
| 80 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
99 |
08BH, 075H, 018H, (* mov esi, dword [ebp + 24] *) |
| 81 |
sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
100 |
0CDH, 040H, (* int 64 *) |
| - |
|
101 |
05EH, (* pop esi *) |
| 82 |
sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *) |
102 |
05BH, (* pop ebx *) |
| 83 |
sys.CODE("CD40"); (* int 40h *) |
103 |
0C9H, (* leave *) |
| 84 |
sys.CODE("5E"); (* pop esi *) |
104 |
0C2H, 014H, 000H (* ret 20 *) |
| 85 |
sys.CODE("5B"); (* pop ebx *) |
105 |
) |
| 86 |
sys.CODE("C9"); (* leave *) |
106 |
RETURN 0 |
| 87 |
sys.CODE("C21400"); (* ret 14h *) |
107 |
END sysfunc5; |
| 88 |
RETURN 0 |
108 |
|
| 89 |
END sysfunc5; |
109 |
|
| 90 |
|
110 |
PROCEDURE [stdcall-] sysfunc6* (arg1, arg2, arg3, arg4, arg5, arg6: INTEGER): INTEGER; |
| 91 |
PROCEDURE [stdcall] sysfunc6*(arg1, arg2, arg3, arg4, arg5, arg6: INTEGER): INTEGER; |
111 |
BEGIN |
| 92 |
BEGIN |
112 |
SYSTEM.CODE( |
| 93 |
sys.CODE("53"); (* push ebx *) |
113 |
053H, (* push ebx *) |
| 94 |
sys.CODE("56"); (* push esi *) |
114 |
056H, (* push esi *) |
| 95 |
sys.CODE("57"); (* push edi *) |
115 |
057H, (* push edi *) |
| 96 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
116 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| - |
|
117 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| 97 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
118 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| 98 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
119 |
08BH, 055H, 014H, (* mov edx, dword [ebp + 20] *) |
| Line -... |
Line 120... |
| - |
|
120 |
08BH, 075H, 018H, (* mov esi, dword [ebp + 24] *) |
| 99 |
sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
121 |
08BH, 07DH, 01CH, (* mov edi, dword [ebp + 28] *) |
| 100 |
sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *) |
122 |
0CDH, 040H, (* int 64 *) |
| - |
|
123 |
05FH, (* pop edi *) |
| 101 |
sys.CODE("8B7D1C"); (* mov edi, [ebp + 1Ch] *) |
124 |
05EH, (* pop esi *) |
| 102 |
sys.CODE("CD40"); (* int 40h *) |
125 |
05BH, (* pop ebx *) |
| 103 |
sys.CODE("5F"); (* pop edi *) |
126 |
0C9H, (* leave *) |
| 104 |
sys.CODE("5E"); (* pop esi *) |
127 |
0C2H, 018H, 000H (* ret 24 *) |
| 105 |
sys.CODE("5B"); (* pop ebx *) |
128 |
) |
| 106 |
sys.CODE("C9"); (* leave *) |
129 |
RETURN 0 |
| 107 |
sys.CODE("C21800"); (* ret 18h *) |
130 |
END sysfunc6; |
| 108 |
RETURN 0 |
131 |
|
| 109 |
END sysfunc6; |
132 |
|
| 110 |
|
133 |
PROCEDURE [stdcall-] sysfunc7* (arg1, arg2, arg3, arg4, arg5, arg6, arg7: INTEGER): INTEGER; |
| 111 |
PROCEDURE [stdcall] sysfunc7*(arg1, arg2, arg3, arg4, arg5, arg6, arg7: INTEGER): INTEGER; |
134 |
BEGIN |
| 112 |
BEGIN |
135 |
SYSTEM.CODE( |
| 113 |
sys.CODE("53"); (* push ebx *) |
136 |
053H, (* push ebx *) |
| 114 |
sys.CODE("56"); (* push esi *) |
137 |
056H, (* push esi *) |
| 115 |
sys.CODE("57"); (* push edi *) |
138 |
057H, (* push edi *) |
| 116 |
sys.CODE("55"); (* push ebp *) |
139 |
055H, (* push ebp *) |
| 117 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
140 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 118 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
141 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| - |
|
142 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| 119 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
143 |
08BH, 055H, 014H, (* mov edx, dword [ebp + 20] *) |
| 120 |
sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
144 |
08BH, 075H, 018H, (* mov esi, dword [ebp + 24] *) |
| Line -... |
Line 145... |
| - |
|
145 |
08BH, 07DH, 01CH, (* mov edi, dword [ebp + 28] *) |
| 121 |
sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *) |
146 |
08BH, 06DH, 020H, (* mov ebp, dword [ebp + 32] *) |
| 122 |
sys.CODE("8B7D1C"); (* mov edi, [ebp + 1Ch] *) |
147 |
0CDH, 040H, (* int 64 *) |
| - |
|
148 |
05DH, (* pop ebp *) |
| 123 |
sys.CODE("8B6D20"); (* mov ebp, [ebp + 20h] *) |
149 |
05FH, (* pop edi *) |
| 124 |
sys.CODE("CD40"); (* int 40h *) |
150 |
05EH, (* pop esi *) |
| 125 |
sys.CODE("5D"); (* pop ebp *) |
151 |
05BH, (* pop ebx *) |
| 126 |
sys.CODE("5F"); (* pop edi *) |
152 |
0C9H, (* leave *) |
| 127 |
sys.CODE("5E"); (* pop esi *) |
153 |
0C2H, 01CH, 000H (* ret 28 *) |
| 128 |
sys.CODE("5B"); (* pop ebx *) |
154 |
) |
| 129 |
sys.CODE("C9"); (* leave *) |
155 |
RETURN 0 |
| 130 |
sys.CODE("C21C00"); (* ret 1Ch *) |
156 |
END sysfunc7; |
| 131 |
RETURN 0 |
157 |
|
| - |
|
158 |
|
| 132 |
END sysfunc7; |
159 |
PROCEDURE [stdcall-] sysfunc22* (arg1, arg2: INTEGER; VAR res2: INTEGER): INTEGER; |
| 133 |
|
160 |
BEGIN |
| Line -... |
Line 161... |
| - |
|
161 |
SYSTEM.CODE( |
| 134 |
PROCEDURE [stdcall] sysfunc22*(arg1, arg2: INTEGER; VAR res2: INTEGER): INTEGER; |
162 |
053H, (* push ebx *) |
| - |
|
163 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 135 |
BEGIN |
164 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| - |
|
165 |
0CDH, 040H, (* int 64 *) |
| 136 |
sys.CODE("53"); (* push ebx *) |
166 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| 137 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
167 |
089H, 019H, (* mov dword [ecx], ebx *) |
| 138 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
168 |
05BH, (* pop ebx *) |
| 139 |
sys.CODE("CD40"); (* int 40h *) |
169 |
0C9H, (* leave *) |
| 140 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
170 |
0C2H, 00CH, 000H (* ret 12 *) |
| Line -... |
Line 171... |
| - |
|
171 |
) |
| 141 |
sys.CODE("8919"); (* mov [ecx], ebx *) |
172 |
RETURN 0 |
| - |
|
173 |
END sysfunc22; |
| 142 |
sys.CODE("5B"); (* pop ebx *) |
174 |
|
| - |
|
175 |
|
| 143 |
sys.CODE("C9"); (* leave *) |
176 |
PROCEDURE mem_commit (adr, size: INTEGER); |
| 144 |
sys.CODE("C20C00"); (* ret 0Ch *) |
177 |
VAR |
| 145 |
RETURN 0 |
178 |
tmp: INTEGER; |
| 146 |
END sysfunc22; |
179 |
|
| 147 |
|
180 |
BEGIN |
| 148 |
PROCEDURE mem_commit(adr, size: INTEGER); |
181 |
FOR tmp := adr TO adr + size - 1 BY 4096 DO |
| 149 |
VAR tmp: INTEGER; |
182 |
SYSTEM.PUT(tmp, 0) |
| 150 |
BEGIN |
183 |
END |
| 151 |
FOR tmp := adr TO adr + size - 1 BY 4096 DO |
184 |
END mem_commit; |
| 152 |
sys.PUT(tmp, 0) |
185 |
|
| 153 |
END |
186 |
|
| 154 |
END mem_commit; |
187 |
PROCEDURE [stdcall] malloc* (size: INTEGER): INTEGER; |
| 155 |
|
188 |
VAR |
| Line -... |
Line 189... |
| - |
|
189 |
ptr: INTEGER; |
| 156 |
PROCEDURE [stdcall] malloc*(size: INTEGER): INTEGER; |
190 |
|
| 157 |
VAR ptr: INTEGER; |
191 |
BEGIN |
| 158 |
BEGIN |
192 |
SYSTEM.CODE(060H); (* pusha *) |
| 159 |
sys.CODE("60"); (* pusha *) |
193 |
IF sysfunc2(18, 16) > ASR(size, 10) THEN |
| 160 |
IF sysfunc2(18, 16) > ASR(size, 10) THEN |
194 |
ptr := sysfunc3(68, 12, size); |
| 161 |
ptr := sysfunc3(68, 12, size); |
195 |
IF ptr # 0 THEN |
| 162 |
IF ptr # 0 THEN |
196 |
mem_commit(ptr, size) |
| 163 |
mem_commit(ptr, size) |
197 |
END |
| 164 |
END |
198 |
ELSE |
| Line -... |
Line 199... |
| - |
|
199 |
ptr := 0 |
| 165 |
ELSE |
200 |
END; |
| 166 |
ptr := 0 |
201 |
SYSTEM.CODE(061H) (* popa *) |
| 167 |
END; |
202 |
RETURN ptr |
| 168 |
sys.CODE("61") (* popa *) |
203 |
END malloc; |
| 169 |
RETURN ptr |
204 |
|
| 170 |
END malloc; |
205 |
|
| 171 |
|
206 |
PROCEDURE [stdcall] free* (ptr: INTEGER): INTEGER; |
| Line -... |
Line 207... |
| - |
|
207 |
BEGIN |
| 172 |
PROCEDURE [stdcall] free*(ptr: INTEGER): INTEGER; |
208 |
SYSTEM.CODE(060H); (* pusha *) |
| 173 |
BEGIN |
209 |
IF ptr # 0 THEN |
| 174 |
sys.CODE("60"); (* pusha *) |
210 |
ptr := sysfunc3(68, 13, ptr) |
| 175 |
IF ptr # 0 THEN |
211 |
END; |
| - |
|
212 |
SYSTEM.CODE(061H) (* popa *) |
| 176 |
ptr := sysfunc3(68, 13, ptr) |
213 |
RETURN 0 |
| 177 |
END; |
214 |
END free; |
| 178 |
sys.CODE("61") (* popa *) |
215 |
|
| 179 |
RETURN 0 |
216 |
|
| 180 |
END free; |
217 |
PROCEDURE [stdcall] realloc* (ptr, size: INTEGER): INTEGER; |
| Line -... |
Line 218... |
| - |
|
218 |
BEGIN |
| 181 |
|
219 |
SYSTEM.CODE(060H); (* pusha *) |
| - |
|
220 |
ptr := sysfunc4(68, 20, size, ptr); |
| 182 |
PROCEDURE [stdcall] realloc*(ptr, size: INTEGER): INTEGER; |
221 |
SYSTEM.CODE(061H) (* popa *) |
| - |
|
222 |
RETURN ptr |
| 183 |
BEGIN |
223 |
END realloc; |
| 184 |
sys.CODE("60"); (* pusha *) |
224 |
|
| 185 |
ptr := sysfunc4(68, 20, size, ptr); |
225 |
|
| 186 |
sys.CODE("61") (* popa *) |
226 |
PROCEDURE AppAdr (): INTEGER; |
| Line -... |
Line 227... |
| - |
|
227 |
VAR |
| 187 |
RETURN ptr |
228 |
buf: ARRAY 1024 OF CHAR; |
| - |
|
229 |
a: INTEGER; |
| 188 |
END realloc; |
230 |
|
| - |
|
231 |
BEGIN |
| 189 |
|
232 |
a := sysfunc3(9, SYSTEM.ADR(buf), -1); |
| 190 |
PROCEDURE AppAdr(): INTEGER; |
233 |
SYSTEM.GET(SYSTEM.ADR(buf) + 22, a) |
| 191 |
VAR |
234 |
RETURN a |
| 192 |
buf: ARRAY 1024 OF CHAR; |
235 |
END AppAdr; |
| Line -... |
Line 236... |
| - |
|
236 |
|
| 193 |
a: INTEGER; |
237 |
|
| 194 |
BEGIN |
238 |
PROCEDURE GetCommandLine* (): INTEGER; |
| - |
|
239 |
VAR |
| 195 |
a := sysfunc3(9, sys.ADR(buf), -1); |
240 |
param: INTEGER; |
| 196 |
sys.GET(sys.ADR(buf) + 22, a) |
241 |
|
| 197 |
RETURN a |
242 |
BEGIN |
| 198 |
END AppAdr; |
243 |
SYSTEM.GET(28 + AppAdr(), param) |
| 199 |
|
244 |
RETURN param |
| 200 |
PROCEDURE GetCommandLine*(): INTEGER; |
245 |
END GetCommandLine; |
| 201 |
VAR param: INTEGER; |
246 |
|
| 202 |
BEGIN |
247 |
|
| 203 |
sys.GET(28 + AppAdr(), param) |
248 |
PROCEDURE GetName* (): INTEGER; |
| 204 |
RETURN param |
249 |
VAR |
| - |
|
250 |
name: INTEGER; |
| 205 |
END GetCommandLine; |
251 |
|
| Line -... |
Line 252... |
| - |
|
252 |
BEGIN |
| 206 |
|
253 |
SYSTEM.GET(32 + AppAdr(), name) |
| - |
|
254 |
RETURN name |
| 207 |
PROCEDURE GetName*(): INTEGER; |
255 |
END GetName; |
| - |
|
256 |
|
| Line 208... |
Line 257... |
| 208 |
VAR name: INTEGER; |
257 |
|
| - |
|
258 |
PROCEDURE [stdcall] dll_init2 (arg1, arg2, arg3, arg4, arg5: INTEGER); |
| 209 |
BEGIN |
259 |
BEGIN |
| - |
|
260 |
SYSTEM.CODE( |
| 210 |
sys.GET(32 + AppAdr(), name) |
261 |
060H, (* pusha *) |
| 211 |
RETURN name |
262 |
08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
| 212 |
END GetName; |
263 |
08BH, 05DH, 00CH, (* mov ebx, dword [ebp + 12] *) |
| 213 |
|
264 |
08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
| 214 |
PROCEDURE [stdcall] dll_init2(arg1, arg2, arg3, arg4, arg5: INTEGER); |
265 |
08BH, 055H, 014H, (* mov edx, dword [ebp + 20] *) |
| 215 |
BEGIN |
266 |
08BH, 075H, 018H, (* mov esi, dword [ebp + 24] *) |
| 216 |
sys.CODE("60"); (* pusha *) |
267 |
0FFH, 0D6H, (* call esi *) |
| - |
|
268 |
061H, (* popa *) |
| 217 |
sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
269 |
0C9H, (* leave *) |
| 218 |
sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
270 |
0C2H, 014H, 000H (* ret 20 *) |
| Line -... |
Line 271... |
| - |
|
271 |
) |
| 219 |
sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
272 |
END dll_init2; |
| 220 |
sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
273 |
|
| 221 |
sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *) |
274 |
|
| 222 |
sys.CODE("FFD6"); (* call esi *) |
275 |
PROCEDURE GetProcAdr* (name: ARRAY OF CHAR; lib: INTEGER): INTEGER; |
| 223 |
sys.CODE("61"); (* popa *) |
276 |
VAR |
| 224 |
sys.CODE("C9"); (* leave *) |
277 |
cur, procname, adr: INTEGER; |
| 225 |
sys.CODE("C21400"); (* ret 14h *) |
278 |
|
| 226 |
END dll_init2; |
279 |
|
| 227 |
|
280 |
PROCEDURE streq (str1, str2: INTEGER): BOOLEAN; |
| 228 |
PROCEDURE GetProcAdr*(name: ARRAY OF CHAR; lib: INTEGER): INTEGER; |
281 |
VAR |
| 229 |
VAR cur, procname, adr: INTEGER; |
282 |
c1, c2: CHAR; |
| 230 |
|
283 |
|
| - |
|
284 |
BEGIN |
| 231 |
PROCEDURE streq(str1, str2: INTEGER): BOOLEAN; |
285 |
REPEAT |
| 232 |
VAR c1, c2: CHAR; |
286 |
SYSTEM.GET(str1, c1); |
| Line -... |
Line 287... |
| - |
|
287 |
SYSTEM.GET(str2, c2); |
| 233 |
BEGIN |
288 |
INC(str1); |
| - |
|
289 |
INC(str2) |
| 234 |
REPEAT |
290 |
UNTIL (c1 # c2) OR (c1 = 0X) |
| - |
|
291 |
|
| 235 |
sys.GET(str1, c1); |
292 |
RETURN c1 = c2 |
| 236 |
sys.GET(str2, c2); |
293 |
END streq; |
| 237 |
INC(str1); |
294 |
|
| 238 |
INC(str2) |
295 |
|
| 239 |
UNTIL (c1 # c2) OR (c1 = 0X) |
296 |
BEGIN |
| 240 |
RETURN c1 = c2 |
297 |
adr := 0; |
| 241 |
END streq; |
298 |
IF (lib # 0) & (name # "") THEN |
| 242 |
|
299 |
cur := lib; |
| 243 |
BEGIN |
300 |
REPEAT |
| 244 |
adr := 0; |
301 |
SYSTEM.GET(cur, procname); |
| Line 245... |
Line -... |
| 245 |
IF (lib # 0) & (name # "") THEN |
- |
|
| 246 |
cur := lib; |
- |
|
| 247 |
REPEAT |
- |
|
| 248 |
sys.GET(cur, procname); |
- |
|
| Line 249... |
Line 302... |
| 249 |
INC(cur, 8) |
302 |
INC(cur, 8) |
| - |
|
303 |
UNTIL (procname = 0) OR streq(procname, SYSTEM.ADR(name[0])); |
| 250 |
UNTIL (procname = 0) OR streq(procname, sys.ADR(name[0])); |
304 |
IF procname # 0 THEN |
| 251 |
IF procname # 0 THEN |
305 |
SYSTEM.GET(cur - 4, adr) |
| 252 |
sys.GET(cur - 4, adr) |
306 |
END |
| 253 |
END |
307 |
END |
| 254 |
END |
308 |
|
| 255 |
RETURN adr |
309 |
RETURN adr |
| 256 |
END GetProcAdr; |
310 |
END GetProcAdr; |
| Line -... |
Line 311... |
| - |
|
311 |
|
| - |
|
312 |
|
| - |
|
313 |
PROCEDURE init (dll: INTEGER); |
| - |
|
314 |
VAR |
| - |
|
315 |
lib_init: INTEGER; |
| - |
|
316 |
|
| - |
|
317 |
BEGIN |
| 257 |
|
318 |
lib_init := GetProcAdr("lib_init", dll); |
| 258 |
PROCEDURE init(dll: INTEGER); |
319 |
IF lib_init # 0 THEN |
| 259 |
VAR lib_init: INTEGER; |
320 |
DLL_INIT(lib_init) |
| 260 |
BEGIN |
321 |
END; |
| 261 |
lib_init := GetProcAdr("lib_init", dll); |
322 |
lib_init := GetProcAdr("START", dll); |
| 262 |
IF lib_init # 0 THEN |
323 |
IF lib_init # 0 THEN |
| 263 |
DLL_INIT(lib_init) |
324 |
DLL_INIT(lib_init) |
| 264 |
END; |
325 |
END |
| 265 |
lib_init := GetProcAdr("START", dll); |
326 |
END init; |
| 266 |
IF lib_init # 0 THEN |
327 |
|
| 267 |
DLL_INIT(lib_init) |
328 |
|
| 268 |
END; |
329 |
PROCEDURE GetStr (adr, i: INTEGER; VAR str: STRING); |
| 269 |
END init; |
330 |
VAR |
| 270 |
|
331 |
c: CHAR; |
| 271 |
PROCEDURE [stdcall] dll_Load(import_table: INTEGER): INTEGER; |
332 |
BEGIN |
| 272 |
VAR imp, lib, exp, proc, res: INTEGER; |
333 |
REPEAT |
| 273 |
fail, done: BOOLEAN; |
334 |
SYSTEM.GET(adr, c); INC(adr); |
| 274 |
procname, libname: STRING; |
335 |
str[i] := c; INC(i) |
| - |
|
336 |
UNTIL c = 0X |
| - |
|
337 |
END GetStr; |
| - |
|
338 |
|
| 275 |
|
339 |
|
| 276 |
PROCEDURE GetStr(adr, i: INTEGER; VAR str: STRING); |
340 |
PROCEDURE [stdcall] dll_Load* (import_table: INTEGER): INTEGER; |
| 277 |
VAR c: CHAR; |
341 |
VAR |
| 278 |
BEGIN |
342 |
imp, lib, exp, proc, res: INTEGER; |
| 279 |
REPEAT |
343 |
fail, done: BOOLEAN; |
| 280 |
sys.GET(adr, c); INC(adr); |
344 |
procname, libname: STRING; |
| 281 |
str[i] := c; INC(i) |
345 |
|
| 282 |
UNTIL c = 0X |
346 |
BEGIN |
| 283 |
END GetStr; |
347 |
SYSTEM.CODE(060H); (* pusha *) |
| 284 |
|
348 |
fail := FALSE; |
| - |
|
349 |
done := FALSE; |
| - |
|
350 |
res := 0; |
| - |
|
351 |
libname := "/rd/1/lib/"; |
| - |
|
352 |
REPEAT |
| 285 |
BEGIN |
353 |
SYSTEM.GET(import_table, imp); |
| 286 |
sys.CODE("60"); (* pusha *) |
354 |
IF imp # 0 THEN |
| 287 |
fail := FALSE; |
355 |
SYSTEM.GET(import_table + 4, lib); |
| 288 |
done := FALSE; |
356 |
GetStr(lib, 10, libname); |
| 289 |
res := 0; |
357 |
exp := sysfunc3(68, 19, SYSTEM.ADR(libname[0])); |
| Line 319... |
Line 387... |
| 319 |
UNTIL done; |
387 |
UNTIL done; |
| 320 |
IF fail THEN |
388 |
IF fail THEN |
| 321 |
res := 1 |
389 |
res := 1 |
| 322 |
END; |
390 |
END; |
| 323 |
import_table := res; |
391 |
import_table := res; |
| 324 |
sys.CODE("61") (* popa *) |
392 |
SYSTEM.CODE(061H) (* popa *) |
| 325 |
RETURN import_table |
393 |
RETURN import_table |
| 326 |
END dll_Load; |
394 |
END dll_Load; |
| Line -... |
Line 395... |
| - |
|
395 |
|
| 327 |
|
396 |
|
| 328 |
PROCEDURE [stdcall] dll_Init(entry: INTEGER); |
397 |
PROCEDURE [stdcall] dll_Init (entry: INTEGER); |
| 329 |
BEGIN |
398 |
BEGIN |
| 330 |
sys.CODE("60"); (* pusha *) |
399 |
SYSTEM.CODE(060H); (* pusha *) |
| 331 |
IF entry # 0 THEN |
400 |
IF entry # 0 THEN |
| 332 |
dll_init2(sys.ADR(malloc), sys.ADR(free), sys.ADR(realloc), sys.ADR(dll_Load), entry) |
401 |
dll_init2(SYSTEM.ADR(malloc), SYSTEM.ADR(free), SYSTEM.ADR(realloc), SYSTEM.ADR(dll_Load), entry) |
| 333 |
END; |
402 |
END; |
| 334 |
sys.CODE("61"); (* popa *) |
403 |
SYSTEM.CODE(061H); (* popa *) |
| Line -... |
Line 404... |
| - |
|
404 |
END dll_Init; |
| 335 |
END dll_Init; |
405 |
|
| - |
|
406 |
|
| 336 |
|
407 |
PROCEDURE LoadLib* (name: ARRAY OF CHAR): INTEGER; |
| - |
|
408 |
VAR |
| 337 |
PROCEDURE LoadLib*(name: ARRAY OF CHAR): INTEGER; |
409 |
Lib: INTEGER; |
| 338 |
VAR Lib: INTEGER; |
410 |
|
| 339 |
BEGIN |
411 |
BEGIN |
| 340 |
DLL_INIT := dll_Init; |
412 |
DLL_INIT := dll_Init; |
| 341 |
Lib := sysfunc3(68, 19, sys.ADR(name[0])); |
413 |
Lib := sysfunc3(68, 19, SYSTEM.ADR(name[0])); |
| 342 |
IF Lib # 0 THEN |
414 |
IF Lib # 0 THEN |
| 343 |
init(Lib) |
415 |
init(Lib) |
| 344 |
END |
416 |
END |
| Line -... |
Line 417... |
| - |
|
417 |
RETURN Lib |
| - |
|
418 |
END LoadLib; |
| - |
|
419 |
|
| - |
|
420 |
|
| - |
|
421 |
PROCEDURE _init*; |
| - |
|
422 |
BEGIN |
| - |
|
423 |
DLL_INIT := dll_Init; |
| - |
|
424 |
imp_error.lib := ""; |
| - |
|
425 |
imp_error.proc := ""; |
| - |
|
426 |
imp_error.error := 0 |
| 345 |
RETURN Lib |
427 |
END _init; |
| 346 |
END LoadLib; |
428 |
|