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 |