Rev 7693 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 7693 | Rev 7696 | ||
---|---|---|---|
Line 1... | Line 1... | ||
1 | (* |
1 | (* |
2 | BSD 2-Clause License |
2 | BSD 2-Clause License |
Line 3... | Line 3... | ||
3 | 3 | ||
4 | Copyright (c) 2018, 2019, Anton Krotov |
4 | Copyright (c) 2018-2019, Anton Krotov |
5 | All rights reserved. |
5 | All rights reserved. |
Line 6... | Line 6... | ||
6 | *) |
6 | *) |
Line 19... | Line 19... | ||
19 | DLL_PROCESS_ATTACH = 1; |
19 | DLL_PROCESS_ATTACH = 1; |
20 | DLL_THREAD_ATTACH = 2; |
20 | DLL_THREAD_ATTACH = 2; |
21 | DLL_THREAD_DETACH = 3; |
21 | DLL_THREAD_DETACH = 3; |
22 | DLL_PROCESS_DETACH = 0; |
22 | DLL_PROCESS_DETACH = 0; |
Line 23... | Line 23... | ||
23 | 23 | ||
24 | SIZE_OF_DWORD = 4; |
24 | WORD = bit_depth DIV 8; |
Line 25... | Line 25... | ||
25 | MAX_SET = 31; |
25 | MAX_SET = bit_depth - 1; |
Line 26... | Line 26... | ||
26 | 26 | ||
Line 33... | Line 33... | ||
33 | 33 | ||
Line 34... | Line 34... | ||
34 | VAR |
34 | VAR |
35 | 35 | ||
- | 36 | name: INTEGER; |
|
Line 36... | Line 37... | ||
36 | name: INTEGER; |
37 | types: INTEGER; |
37 | types: INTEGER; |
38 | bits: ARRAY MAX_SET + 1 OF INTEGER; |
38 | 39 | ||
39 | dll: RECORD |
40 | dll: RECORD |
40 | process_detach, |
41 | process_detach, |
Line 41... | Line 42... | ||
41 | thread_detach, |
42 | thread_detach, |
Line 42... | Line 43... | ||
42 | thread_attach: DLL_ENTRY |
43 | thread_attach: DLL_ENTRY |
43 | END; |
44 | END; |
44 | 45 | ||
45 | fini: PROC; |
- | |
46 | - | ||
47 | - | ||
48 | PROCEDURE [stdcall] _move* (bytes, source, dest: INTEGER); |
- | |
49 | BEGIN |
- | |
50 | SYSTEM.CODE( |
- | |
51 | - | ||
52 | 08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
- | |
53 | 085H, 0C0H, (* test eax, eax *) |
- | |
54 | 07EH, 019H, (* jle L *) |
- | |
55 | 0FCH, (* cld *) |
- | |
56 | 057H, (* push edi *) |
- | |
57 | 056H, (* push esi *) |
- | |
58 | 08BH, 075H, 00CH, (* mov esi, dword [ebp + 12] *) |
- | |
59 | 08BH, 07DH, 010H, (* mov edi, dword [ebp + 16] *) |
- | |
60 | 089H, 0C1H, (* mov ecx, eax *) |
- | |
61 | 0C1H, 0E9H, 002H, (* shr ecx, 2 *) |
- | |
62 | 0F3H, 0A5H, (* rep movsd *) |
- | |
63 | 089H, 0C1H, (* mov ecx, eax *) |
- | |
64 | 083H, 0E1H, 003H, (* and ecx, 3 *) |
- | |
65 | 0F3H, 0A4H, (* rep movsb *) |
- | |
66 | 05EH, (* pop esi *) |
- | |
67 | 05FH (* pop edi *) |
- | |
68 | (* L: *) |
- | |
69 | ) |
- | |
70 | END _move; |
- | |
71 | 46 | fini: PROC; |
|
72 | 47 | ||
73 | PROCEDURE [stdcall] _move2* (bytes, dest, source: INTEGER); |
48 | |
74 | BEGIN |
49 | PROCEDURE [stdcall] _move* (bytes, dest, source: INTEGER); |
75 | SYSTEM.CODE( |
50 | BEGIN |
Line 90... | Line 65... | ||
90 | 0F3H, 0A4H, (* rep movsb *) |
65 | 0F3H, 0A4H, (* rep movsb *) |
91 | 05EH, (* pop esi *) |
66 | 05EH, (* pop esi *) |
92 | 05FH (* pop edi *) |
67 | 05FH (* pop edi *) |
93 | (* L: *) |
68 | (* L: *) |
94 | ) |
69 | ) |
95 | END _move2; |
70 | END _move; |
Line 96... | Line 71... | ||
96 | 71 | ||
97 | 72 | ||
98 | PROCEDURE [stdcall] _arrcpy* (base_size, len_dst, dst, len_src, src: INTEGER): BOOLEAN; |
73 | PROCEDURE [stdcall] _arrcpy* (base_size, len_dst, dst, len_src, src: INTEGER): BOOLEAN; |
Line 99... | Line 74... | ||
99 | VAR |
74 | VAR |
100 | res: BOOLEAN; |
75 | res: BOOLEAN; |
101 | 76 | ||
102 | BEGIN |
77 | BEGIN |
103 | IF len_src > len_dst THEN |
78 | IF len_src > len_dst THEN |
104 | res := FALSE |
79 | res := FALSE |
105 | ELSE |
80 | ELSE |
Line 106... | Line 81... | ||
106 | _move(len_src * base_size, src, dst); |
81 | _move(len_src * base_size, dst, src); |
107 | res := TRUE |
82 | res := TRUE |
Line 108... | Line 83... | ||
108 | END |
83 | END |
109 | 84 | ||
110 | RETURN res |
85 | RETURN res |
111 | END _arrcpy; |
86 | END _arrcpy; |
Line 112... | Line 87... | ||
112 | 87 | ||
113 | 88 | ||
Line 142... | Line 117... | ||
142 | b := MAX_SET |
117 | b := MAX_SET |
143 | END; |
118 | END; |
144 | IF a < 0 THEN |
119 | IF a < 0 THEN |
145 | a := 0 |
120 | a := 0 |
146 | END; |
121 | END; |
147 | a := LSR(ASR(ROR(1, 1), b - a), MAX_SET - b) |
122 | a := LSR(ASR(minint, b - a), MAX_SET - b) |
148 | ELSE |
123 | ELSE |
149 | a := 0 |
124 | a := 0 |
150 | END |
125 | END |
Line 151... | Line 126... | ||
151 | 126 | ||
152 | RETURN a |
127 | RETURN a |
Line 153... | Line 128... | ||
153 | END _set; |
128 | END _set; |
- | 129 | ||
- | 130 | ||
- | 131 | PROCEDURE [stdcall] _set1* (a: INTEGER): INTEGER; |
|
- | 132 | BEGIN |
|
- | 133 | IF ASR(a, 5) = 0 THEN |
|
- | 134 | SYSTEM.GET(SYSTEM.ADR(bits[0]) + a * WORD, a) |
|
154 | 135 | ELSE |
|
155 | 136 | a := 0 |
|
Line 156... | Line 137... | ||
156 | PROCEDURE [stdcall] _set2* (a, b: INTEGER): INTEGER; |
137 | END |
157 | RETURN _set(b, a) |
138 | RETURN a |
158 | END _set2; |
139 | END _set1; |
159 | - | ||
160 | 140 | ||
161 | PROCEDURE [stdcall] divmod (a, b: INTEGER; VAR mod: INTEGER): INTEGER; |
141 | |
162 | BEGIN |
142 | PROCEDURE [stdcall] _divmod* (y, x: INTEGER); (* (x div y) -> eax; (x mod y) -> edx *) |
163 | SYSTEM.CODE( |
143 | BEGIN |
- | 144 | SYSTEM.CODE( |
|
164 | 145 | 053H, (* push ebx *) |
|
165 | 08BH, 045H, 008H, (* mov eax, dword [ebp + 8] *) |
146 | 08BH, 045H, 00CH, (* mov eax, dword [ebp + 12] *) (* eax <- x *) |
166 | 08BH, 04DH, 00CH, (* mov ecx, dword [ebp + 12] *) |
147 | 031H, 0D2H, (* xor edx, edx *) |
- | 148 | 085H, 0C0H, (* test eax, eax *) |
|
- | 149 | 074H, 018H, (* je L2 *) |
|
167 | 031H, 0D2H, (* xor edx, edx *) |
150 | 07FH, 002H, (* jg L1 *) |
168 | 085H, 0C0H, (* test eax, eax *) |
151 | 0F7H, 0D2H, (* not edx *) |
- | 152 | (* L1: *) |
|
169 | 07DH, 002H, (* jge L1 *) |
153 | 089H, 0C3H, (* mov ebx, eax *) |
- | 154 | 08BH, 04DH, 008H, (* mov ecx, dword [ebp + 8] *) (* ecx <- y *) |
|
- | 155 | 0F7H, 0F9H, (* idiv ecx *) |
|
170 | 0F7H, 0D2H, (* not edx *) |
156 | 085H, 0D2H, (* test edx, edx *) |
- | 157 | 074H, 009H, (* je L2 *) |
|
- | 158 | 031H, 0CBH, (* xor ebx, ecx *) |
|
171 | (* L1: *) |
159 | 085H, 0DBH, (* test ebx, ebx *) |
172 | 0F7H, 0F9H, (* idiv ecx *) |
160 | 07DH, 003H, (* jge L2 *) |
173 | 08BH, 04DH, 010H, (* mov ecx, dword [ebp + 16] *) |
- | |
174 | 089H, 011H, (* mov dword [ecx], edx *) |
- | |
175 | 0C9H, (* leave *) |
161 | 048H, (* dec eax *) |
176 | 0C2H, 00CH, 000H (* ret 12 *) |
- | |
177 | ) |
- | |
178 | - | ||
179 | RETURN 0 |
- | |
180 | END divmod; |
- | |
181 | - | ||
182 | - | ||
183 | PROCEDURE [stdcall] _div2* (x, y: INTEGER): INTEGER; |
- | |
184 | VAR |
- | |
185 | div, mod: INTEGER; |
- | |
186 | - | ||
187 | BEGIN |
- | |
188 | div := divmod(x, y, mod); |
- | |
189 | IF (mod # 0) & ((x < 0) & (y > 0) OR (x > 0) & (y < 0)) THEN |
- | |
190 | DEC(div) |
- | |
191 | END |
- | |
192 | - | ||
193 | RETURN div |
- | |
194 | END _div2; |
- | |
195 | - | ||
196 | - | ||
197 | PROCEDURE [stdcall] _mod2* (x, y: INTEGER): INTEGER; |
- | |
198 | VAR |
- | |
199 | div, mod: INTEGER; |
- | |
200 | - | ||
201 | BEGIN |
- | |
202 | div := divmod(x, y, mod); |
- | |
203 | IF (mod # 0) & ((x < 0) & (y > 0) OR (x > 0) & (y < 0)) THEN |
- | |
204 | INC(mod, y) |
- | |
205 | END |
- | |
206 | - | ||
207 | RETURN mod |
- | |
208 | END _mod2; |
- | |
209 | - | ||
210 | - | ||
211 | PROCEDURE [stdcall] _div* (b, a: INTEGER): INTEGER; |
- | |
212 | RETURN _div2(a, b) |
- | |
213 | END _div; |
- | |
Line 214... | Line 162... | ||
214 | 162 | 001H, 0CAH, (* add edx, ecx *) |
|
215 | 163 | (* L2: *) |
|
216 | PROCEDURE [stdcall] _mod* (b, a: INTEGER): INTEGER; |
164 | 05BH (* pop ebx *) |
217 | RETURN _mod2(a, b) |
165 | ) |
218 | END _mod; |
166 | END _divmod; |
219 | 167 | ||
220 | 168 | ||
221 | PROCEDURE [stdcall] _new* (t, size: INTEGER; VAR ptr: INTEGER); |
169 | PROCEDURE [stdcall] _new* (t, size: INTEGER; VAR ptr: INTEGER); |
Line 222... | Line 170... | ||
222 | BEGIN |
170 | BEGIN |
223 | ptr := API._NEW(size); |
171 | ptr := API._NEW(size); |
224 | IF ptr # 0 THEN |
172 | IF ptr # 0 THEN |
225 | SYSTEM.PUT(ptr, t); |
173 | SYSTEM.PUT(ptr, t); |
226 | INC(ptr, SIZE_OF_DWORD) |
174 | INC(ptr, WORD) |
227 | END |
175 | END |
Line 228... | Line 176... | ||
228 | END _new; |
176 | END _new; |
229 | 177 | ||
230 | 178 | ||
231 | PROCEDURE [stdcall] _dispose* (VAR ptr: INTEGER); |
- | |
232 | BEGIN |
179 | PROCEDURE [stdcall] _dispose* (VAR ptr: INTEGER); |
233 | IF ptr # 0 THEN |
180 | BEGIN |
234 | ptr := API._DISPOSE(ptr - SIZE_OF_DWORD) |
181 | IF ptr # 0 THEN |
235 | END |
182 | ptr := API._DISPOSE(ptr - WORD) |
236 | END _dispose; |
183 | END |
237 | 184 | END _dispose; |
|
238 | 185 | ||
239 | PROCEDURE [stdcall] _length* (len, str: INTEGER): INTEGER; |
186 | |
240 | BEGIN |
187 | PROCEDURE [stdcall] _length* (len, str: INTEGER); |
241 | SYSTEM.CODE( |
188 | BEGIN |
242 | 189 | SYSTEM.CODE( |
|
243 | 08BH, 045H, 00CH, (* mov eax, dword [ebp + 0Ch] *) |
- | |
244 | 08BH, 04DH, 008H, (* mov ecx, dword [ebp + 08h] *) |
- | |
245 | 048H, (* dec eax *) |
190 | 08BH, 045H, 00CH, (* mov eax, dword [ebp + 0Ch] *) |
246 | (* L1: *) |
- | |
247 | 040H, (* inc eax *) |
- | |
248 | 080H, 038H, 000H, (* cmp byte [eax], 0 *) |
191 | 08BH, 04DH, 008H, (* mov ecx, dword [ebp + 08h] *) |
Line 249... | Line 192... | ||
249 | 074H, 003H, (* jz L2 *) |
192 | 048H, (* dec eax *) |
250 | 0E2H, 0F8H, (* loop L1 *) |
193 | (* L1: *) |
251 | 040H, (* inc eax *) |
194 | 040H, (* inc eax *) |
252 | (* L2: *) |
- | |
253 | 02BH, 045H, 00CH, (* sub eax, dword [ebp + 0Ch] *) |
195 | 080H, 038H, 000H, (* cmp byte [eax], 0 *) |
254 | 0C9H, (* leave *) |
196 | 074H, 003H, (* jz L2 *) |
255 | 0C2H, 008H, 000H (* ret 08h *) |
197 | 0E2H, 0F8H, (* loop L1 *) |
256 | ) |
198 | 040H, (* inc eax *) |
257 | 199 | (* L2: *) |
|
Line 275... | Line 217... | ||
275 | 0E2H, 0F6H, (* loop L1 *) |
217 | 0E2H, 0F6H, (* loop L1 *) |
276 | 040H, (* inc eax *) |
218 | 040H, (* inc eax *) |
277 | 040H, (* inc eax *) |
219 | 040H, (* inc eax *) |
278 | (* L2: *) |
220 | (* L2: *) |
279 | 02BH, 045H, 00CH, (* sub eax, dword [ebp + 0Ch] *) |
221 | 02BH, 045H, 00CH, (* sub eax, dword [ebp + 0Ch] *) |
280 | 0D1H, 0E8H, (* shr eax, 1 *) |
222 | 0D1H, 0E8H (* shr eax, 1 *) |
281 | 0C9H, (* leave *) |
- | |
282 | 0C2H, 008H, 000H (* ret 08h *) |
- | |
283 | ) |
223 | ) |
284 | - | ||
285 | RETURN 0 |
- | |
286 | END _lengthw; |
224 | END _lengthw; |
Line 287... | Line 225... | ||
287 | 225 | ||
288 | - | ||
289 | PROCEDURE strncmp (a, b, n: INTEGER): INTEGER; |
- | |
290 | VAR |
- | |
291 | A, B: CHAR; |
- | |
292 | res: INTEGER; |
226 | |
293 | 227 | PROCEDURE [stdcall] strncmp (a, b, n: INTEGER): INTEGER; |
|
- | 228 | BEGIN |
|
294 | BEGIN |
229 | SYSTEM.CODE( |
- | 230 | 056H, (* push esi *) |
|
295 | res := minint; |
231 | 057H, (* push edi *) |
- | 232 | 053H, (* push ebx *) |
|
296 | WHILE n > 0 DO |
233 | 08BH, 075H, 008H, (* mov esi, dword[ebp + 8]; esi <- a *) |
- | 234 | 08BH, 07DH, 00CH, (* mov edi, dword[ebp + 12]; edi <- b *) |
|
- | 235 | 08BH, 05DH, 010H, (* mov ebx, dword[ebp + 16]; ebx <- n *) |
|
297 | SYSTEM.GET(a, A); INC(a); |
236 | 031H, 0C9H, (* xor ecx, ecx *) |
- | 237 | 031H, 0D2H, (* xor edx, edx *) |
|
- | 238 | 0B8H, |
|
- | 239 | 000H, 000H, 000H, 080H, (* mov eax, minint *) |
|
- | 240 | (* L1: *) |
|
- | 241 | 085H, 0DBH, (* test ebx, ebx *) |
|
298 | SYSTEM.GET(b, B); INC(b); |
242 | 07EH, 017H, (* jle L3 *) |
299 | DEC(n); |
243 | 08AH, 00EH, (* mov cl, byte[esi] *) |
- | 244 | 08AH, 017H, (* mov dl, byte[edi] *) |
|
- | 245 | 046H, (* inc esi *) |
|
- | 246 | 047H, (* inc edi *) |
|
- | 247 | 04BH, (* dec ebx *) |
|
- | 248 | 039H, 0D1H, (* cmp ecx, edx *) |
|
- | 249 | 074H, 006H, (* je L2 *) |
|
- | 250 | 089H, 0C8H, (* mov eax, ecx *) |
|
300 | IF A # B THEN |
251 | 029H, 0D0H, (* sub eax, edx *) |
- | 252 | 0EBH, 006H, (* jmp L3 *) |
|
301 | res := ORD(A) - ORD(B); |
253 | (* L2: *) |
302 | n := 0 |
254 | 085H, 0C9H, (* test ecx, ecx *) |
303 | ELSIF A = 0X THEN |
255 | 075H, 0E7H, (* jne L1 *) |
- | 256 | 031H, 0C0H, (* xor eax, eax *) |
|
- | 257 | (* L3: *) |
|
- | 258 | 05BH, (* pop ebx *) |
|
- | 259 | 05FH, (* pop edi *) |
|
304 | res := 0; |
260 | 05EH, (* pop esi *) |
305 | n := 0 |
261 | 05DH, (* pop ebp *) |
306 | END |
262 | 0C2H, 00CH, 000H (* ret 12 *) |
307 | END |
263 | ) |
Line 308... | Line 264... | ||
308 | RETURN res |
264 | RETURN 0 |
309 | END strncmp; |
- | |
310 | - | ||
311 | - | ||
312 | PROCEDURE strncmpw (a, b, n: INTEGER): INTEGER; |
- | |
313 | VAR |
265 | END strncmp; |
314 | A, B: WCHAR; |
266 | |
- | 267 | ||
315 | res: INTEGER; |
268 | PROCEDURE [stdcall] strncmpw (a, b, n: INTEGER): INTEGER; |
- | 269 | BEGIN |
|
- | 270 | SYSTEM.CODE( |
|
316 | 271 | 056H, (* push esi *) |
|
317 | BEGIN |
272 | 057H, (* push edi *) |
- | 273 | 053H, (* push ebx *) |
|
- | 274 | 08BH, 075H, 008H, (* mov esi, dword[ebp + 8]; esi <- a *) |
|
318 | res := minint; |
275 | 08BH, 07DH, 00CH, (* mov edi, dword[ebp + 12]; edi <- b *) |
- | 276 | 08BH, 05DH, 010H, (* mov ebx, dword[ebp + 16]; ebx <- n *) |
|
- | 277 | 031H, 0C9H, (* xor ecx, ecx *) |
|
- | 278 | 031H, 0D2H, (* xor edx, edx *) |
|
319 | WHILE n > 0 DO |
279 | 0B8H, |
320 | SYSTEM.GET(a, A); INC(a, 2); |
280 | 000H, 000H, 000H, 080H, (* mov eax, minint *) |
- | 281 | (* L1: *) |
|
- | 282 | 085H, 0DBH, (* test ebx, ebx *) |
|
- | 283 | 07EH, 01BH, (* jle L3 *) |
|
- | 284 | 066H, 08BH, 00EH, (* mov cx, word[esi] *) |
|
- | 285 | 066H, 08BH, 017H, (* mov dx, word[edi] *) |
|
- | 286 | 046H, (* inc esi *) |
|
- | 287 | 046H, (* inc esi *) |
|
- | 288 | 047H, (* inc edi *) |
|
- | 289 | 047H, (* inc edi *) |
|
- | 290 | 04BH, (* dec ebx *) |
|
- | 291 | 039H, 0D1H, (* cmp ecx, edx *) |
|
321 | SYSTEM.GET(b, B); INC(b, 2); |
292 | 074H, 006H, (* je L2 *) |
- | 293 | 089H, 0C8H, (* mov eax, ecx *) |
|
322 | DEC(n); |
294 | 029H, 0D0H, (* sub eax, edx *) |
323 | IF A # B THEN |
295 | 0EBH, 006H, (* jmp L3 *) |
324 | res := ORD(A) - ORD(B); |
296 | (* L2: *) |
- | 297 | 085H, 0C9H, (* test ecx, ecx *) |
|
- | 298 | 075H, 0E3H, (* jne L1 *) |
|
- | 299 | 031H, 0C0H, (* xor eax, eax *) |
|
- | 300 | (* L3: *) |
|
325 | n := 0 |
301 | 05BH, (* pop ebx *) |
326 | ELSIF A = 0X THEN |
302 | 05FH, (* pop edi *) |
327 | res := 0; |
303 | 05EH, (* pop esi *) |
328 | n := 0 |
304 | 05DH, (* pop ebp *) |
Line 329... | Line 305... | ||
329 | END |
305 | 0C2H, 00CH, 000H (* ret 12 *) |
330 | END |
306 | ) |
Line 505... | Line 481... | ||
505 | 481 | ||
506 | 482 | ||
507 | PROCEDURE [stdcall] _is* (t0, p: INTEGER): INTEGER; |
483 | PROCEDURE [stdcall] _is* (t0, p: INTEGER): INTEGER; |
508 | BEGIN |
484 | BEGIN |
509 | IF p # 0 THEN |
485 | IF p # 0 THEN |
510 | SYSTEM.GET(p - SIZE_OF_DWORD, p); |
486 | SYSTEM.GET(p - WORD, p); |
Line 511... | Line 487... | ||
511 | SYSTEM.GET(t0 + p + types, p) |
487 | SYSTEM.GET(t0 + p + types, p) |
512 | END |
488 | END |
Line 524... | Line 500... | ||
524 | 500 | ||
525 | PROCEDURE [stdcall] _guard* (t0, p: INTEGER): INTEGER; |
501 | PROCEDURE [stdcall] _guard* (t0, p: INTEGER): INTEGER; |
526 | BEGIN |
502 | BEGIN |
527 | SYSTEM.GET(p, p); |
503 | SYSTEM.GET(p, p); |
528 | IF p # 0 THEN |
504 | IF p # 0 THEN |
529 | SYSTEM.GET(p - SIZE_OF_DWORD, p); |
505 | SYSTEM.GET(p - WORD, p); |
530 | SYSTEM.GET(t0 + p + types, p) |
506 | SYSTEM.GET(t0 + p + types, p) |
531 | ELSE |
507 | ELSE |
532 | p := 1 |
508 | p := 1 |
Line 565... | Line 541... | ||
565 | 541 | ||
566 | RETURN res |
542 | RETURN res |
Line 567... | Line -... | ||
567 | END _dllentry; |
- | |
568 | - | ||
569 | - | ||
570 | PROCEDURE SetDll* (process_detach, thread_detach, thread_attach: DLL_ENTRY); |
- | |
571 | BEGIN |
- | |
572 | dll.process_detach := process_detach; |
- | |
573 | dll.thread_detach := thread_detach; |
- | |
574 | dll.thread_attach := thread_attach |
- | |
575 | END SetDll; |
543 | END _dllentry; |
576 | 544 | ||
577 | 545 | ||
578 | PROCEDURE [stdcall] _exit* (code: INTEGER); |
546 | PROCEDURE [stdcall] _exit* (code: INTEGER); |
Line 594... | Line 562... | ||
594 | FOR i := 0 TO tcount - 1 DO |
562 | FOR i := 0 TO tcount - 1 DO |
595 | FOR j := 0 TO tcount - 1 DO |
563 | FOR j := 0 TO tcount - 1 DO |
596 | t0 := i; t1 := j; |
564 | t0 := i; t1 := j; |
Line 597... | Line 565... | ||
597 | 565 | ||
598 | WHILE (t1 # 0) & (t1 # t0) DO |
566 | WHILE (t1 # 0) & (t1 # t0) DO |
599 | SYSTEM.GET(_types + t1 * SIZE_OF_DWORD, t1) |
567 | SYSTEM.GET(_types + t1 * WORD, t1) |
Line 600... | Line 568... | ||
600 | END; |
568 | END; |
601 | 569 | ||
602 | SYSTEM.PUT8(i * tcount + j + types, ORD(t0 = t1)) |
570 | SYSTEM.PUT8(i * tcount + j + types, ORD(t0 = t1)) |
Line -... | Line 571... | ||
- | 571 | END |
|
- | 572 | END; |
|
- | 573 | ||
- | 574 | j := 1; |
|
- | 575 | FOR i := 0 TO MAX_SET DO |
|
- | 576 | bits[i] := j; |
|
603 | END |
577 | j := LSL(j, 1) |
Line 604... | Line 578... | ||
604 | END; |
578 | END; |
605 | 579 | ||
606 | name := modname; |
580 | name := modname; |
Line 619... | Line 593... | ||
619 | fini |
593 | fini |
620 | END |
594 | END |
621 | END _sofinit; |
595 | END _sofinit; |
Line -... | Line 596... | ||
- | 596 | ||
- | 597 | ||
- | 598 | PROCEDURE SetDll* (process_detach, thread_detach, thread_attach: DLL_ENTRY); |
|
- | 599 | BEGIN |
|
- | 600 | dll.process_detach := process_detach; |
|
- | 601 | dll.thread_detach := thread_detach; |
|
- | 602 | dll.thread_attach := thread_attach |
|
- | 603 | END SetDll; |
|
622 | 604 | ||
623 | 605 | ||
624 | PROCEDURE SetFini* (ProcFini: PROC); |
606 | PROCEDURE SetFini* (ProcFini: PROC); |
625 | BEGIN |
607 | BEGIN |