Rev 7107 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed
| Rev 7107 | Rev 7110 | ||
|---|---|---|---|
| Line 17... | Line 17... | ||
| 17 | 17 | ||
| Line 18... | Line 18... | ||
| 18 | MODULE API; |
18 | MODULE API; |
| Line -... | Line 19... | ||
| - | 19 | ||
| 19 | 20 | IMPORT sys := SYSTEM; |
|
| Line 20... | Line 21... | ||
| 20 | IMPORT sys := SYSTEM; |
21 | |
| 21 | 22 | ||
| - | 23 | CONST |
|
| - | 24 | ||
| - | 25 | MAX_SIZE = 16 * 400H; |
|
| - | 26 | HEAP_SIZE = 1 * 100000H; |
|
| - | 27 | ||
| - | 28 | _new = 1; |
|
| - | 29 | _dispose = 2; |
|
| - | 30 | ||
| - | 31 | ||
| Line 22... | Line 32... | ||
| 22 | CONST |
32 | TYPE |
| Line 23... | Line 33... | ||
| 23 | 33 | ||
| 24 | MAX_SIZE = 16 * 400H; |
34 | CRITICAL_SECTION = ARRAY 2 OF INTEGER; |
| - | 35 | ||
| - | 36 | ||
| Line -... | Line 37... | ||
| - | 37 | VAR |
|
| 25 | HEAP_SIZE = 1 * 100000H; |
38 | |
| 26 | 39 | heap, endheap: INTEGER; |
|
| 27 | VAR |
40 | pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER; |
| 28 | 41 | ||
| - | 42 | CriticalSection: CRITICAL_SECTION; |
|
| Line 29... | Line 43... | ||
| 29 | heap, endheap: INTEGER; |
43 | |
| - | 44 | ||
| 30 | pockets: ARRAY MAX_SIZE DIV 32 + 1 OF INTEGER; |
45 | PROCEDURE [stdcall] zeromem* (size, adr: INTEGER); |
| 31 | 46 | BEGIN |
|
| 32 | PROCEDURE [stdcall] zeromem*(size, adr: INTEGER); |
47 | sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F") |
| 33 | BEGIN |
48 | END zeromem; |
| 34 | sys.CODE("578B7D0C8B4D0833C09CFCF3AB9D5F") |
49 | |
| 35 | END zeromem; |
50 | |
| - | 51 | PROCEDURE mem_commit* (adr, size: INTEGER); |
|
| Line 36... | Line 52... | ||
| 36 | 52 | VAR |
|
| - | 53 | tmp: INTEGER; |
|
| - | 54 | BEGIN |
|
| 37 | PROCEDURE mem_commit*(adr, size: INTEGER); |
55 | FOR tmp := adr TO adr + size - 1 BY 4096 DO |
| 38 | VAR tmp: INTEGER; |
56 | sys.PUT(tmp, 0) |
| 39 | BEGIN |
57 | END |
| 40 | FOR tmp := adr TO adr + size - 1 BY 4096 DO |
58 | END mem_commit; |
| 41 | sys.PUT(tmp, 0) |
59 | |
| 42 | END |
60 | |
| 43 | END mem_commit; |
61 | PROCEDURE strncmp* (a, b, n: INTEGER): INTEGER; |
| 44 | 62 | VAR |
|
| 45 | PROCEDURE strncmp*(a, b, n: INTEGER): INTEGER; |
63 | A, B: CHAR; |
| 46 | VAR A, B: CHAR; Res: INTEGER; |
64 | Res: INTEGER; |
| 47 | BEGIN |
65 | BEGIN |
| 48 | Res := 0; |
66 | Res := 0; |
| - | 67 | WHILE n > 0 DO |
|
| 49 | WHILE n > 0 DO |
68 | sys.GET(a, A); INC(a); |
| 50 | sys.GET(a, A); INC(a); |
- | |
| 51 | sys.GET(b, B); INC(b); |
69 | sys.GET(b, B); INC(b); |
| 52 | DEC(n); |
70 | DEC(n); |
| - | 71 | IF A # B THEN |
|
| 53 | IF A # B THEN |
72 | Res := ORD(A) - ORD(B); |
| 54 | Res := ORD(A) - ORD(B); |
73 | n := 0 |
| 55 | n := 0 |
74 | ELSIF A = 0X THEN |
| 56 | ELSIF A = 0X THEN |
75 | n := 0 |
| 57 | n := 0 |
76 | END |
| 58 | END |
77 | END |
| 59 | END |
78 | RETURN Res |
| 60 | RETURN Res |
79 | END strncmp; |
| 61 | END strncmp; |
80 | |
| - | 81 | ||
| 62 | 82 | PROCEDURE [stdcall] sysfunc1* (arg1: INTEGER): INTEGER; |
|
| 63 | PROCEDURE [stdcall] sysfunc1*(arg1: INTEGER): INTEGER; |
83 | BEGIN |
| 64 | BEGIN |
84 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
| 65 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
85 | sys.CODE("CD40"); (* int 40h *) |
| 66 | sys.CODE("CD40"); (* int 40h *) |
86 | sys.CODE("C9"); (* leave *) |
| 67 | sys.CODE("C9"); (* leave *) |
87 | sys.CODE("C20400"); (* ret 04h *) |
| 68 | sys.CODE("C20400"); (* ret 04h *) |
88 | RETURN 0 |
| 69 | RETURN 0 |
89 | END sysfunc1; |
| 70 | END sysfunc1; |
90 | |
| 71 | 91 | ||
| 72 | PROCEDURE [stdcall] sysfunc2*(arg1, arg2: INTEGER): INTEGER; |
92 | PROCEDURE [stdcall] sysfunc2* (arg1, arg2: INTEGER): INTEGER; |
| 73 | BEGIN |
93 | BEGIN |
| - | 94 | sys.CODE("53"); (* push ebx *) |
|
| 74 | sys.CODE("53"); (* push ebx *) |
95 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
| 75 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
96 | sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
| 76 | sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
97 | sys.CODE("CD40"); (* int 40h *) |
| 77 | sys.CODE("CD40"); (* int 40h *) |
98 | sys.CODE("5B"); (* pop ebx *) |
| 78 | sys.CODE("5B"); (* pop ebx *) |
99 | sys.CODE("C9"); (* leave *) |
| 79 | sys.CODE("C9"); (* leave *) |
100 | sys.CODE("C20800"); (* ret 08h *) |
| 80 | sys.CODE("C20800"); (* ret 08h *) |
101 | RETURN 0 |
| 81 | RETURN 0 |
102 | END sysfunc2; |
| 82 | END sysfunc2; |
103 | |
| 83 | 104 | ||
| 84 | PROCEDURE [stdcall] sysfunc3*(arg1, arg2, arg3: INTEGER): INTEGER; |
105 | PROCEDURE [stdcall] sysfunc3* (arg1, arg2, arg3: INTEGER): INTEGER; |
| 85 | BEGIN |
106 | BEGIN |
| 86 | sys.CODE("53"); (* push ebx *) |
107 | sys.CODE("53"); (* push ebx *) |
| Line -... | Line 108... | ||
| - | 108 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
|
| 87 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
109 | sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
| 88 | sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
- | |
| 89 | sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
110 | sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
| - | 111 | sys.CODE("CD40"); (* int 40h *) |
|
| - | 112 | sys.CODE("5B"); (* pop ebx *) |
|
| - | 113 | sys.CODE("C9"); (* leave *) |
|
| - | 114 | sys.CODE("C20C00"); (* ret 0Ch *) |
|
| - | 115 | RETURN 0 |
|
| - | 116 | END sysfunc3; |
|
| - | 117 | ||
| - | 118 | ||
| - | 119 | PROCEDURE [stdcall] sysfunc4* (arg1, arg2, arg3, arg4: INTEGER): INTEGER; |
|
| - | 120 | BEGIN |
|
| - | 121 | sys.CODE("53"); (* push ebx *) |
|
| - | 122 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
|
| - | 123 | sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
|
| - | 124 | sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
|
| - | 125 | sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
|
| - | 126 | sys.CODE("CD40"); (* int 40h *) |
|
| - | 127 | sys.CODE("5B"); (* pop ebx *) |
|
| - | 128 | sys.CODE("C9"); (* leave *) |
|
| - | 129 | sys.CODE("C21000"); (* ret 10h *) |
|
| - | 130 | RETURN 0 |
|
| - | 131 | END sysfunc4; |
|
| - | 132 | ||
| - | 133 | ||
| - | 134 | PROCEDURE [stdcall] sysfunc5* (arg1, arg2, arg3, arg4, arg5: INTEGER): INTEGER; |
|
| - | 135 | BEGIN |
|
| - | 136 | sys.CODE("53"); (* push ebx *) |
|
| - | 137 | sys.CODE("56"); (* push esi *) |
|
| - | 138 | sys.CODE("8B4508"); (* mov eax, [ebp + 08h] *) |
|
| - | 139 | sys.CODE("8B5D0C"); (* mov ebx, [ebp + 0Ch] *) |
|
| - | 140 | sys.CODE("8B4D10"); (* mov ecx, [ebp + 10h] *) |
|
| - | 141 | sys.CODE("8B5514"); (* mov edx, [ebp + 14h] *) |
|
| - | 142 | sys.CODE("8B7518"); (* mov esi, [ebp + 18h] *) |
|
| - | 143 | sys.CODE("CD40"); (* int 40h *) |
|
| 90 | sys.CODE("CD40"); (* int 40h *) |
144 | sys.CODE("5E"); (* pop esi *) |
| - | 145 | sys.CODE("5B"); (* pop ebx *) |
|
| 91 | sys.CODE("5B"); (* pop ebx *) |
146 | sys.CODE("C9"); (* leave *) |
| - | 147 | sys.CODE("C21400"); (* ret 14h *) |
|
| - | 148 | RETURN 0 |
|
| - | 149 | END sysfunc5; |
|
| - | 150 | ||
| - | 151 | ||
| - | 152 | PROCEDURE switch_task; |
|
| - | 153 | VAR |
|
| - | 154 | res: INTEGER; |
|
| - | 155 | BEGIN |
|
| - | 156 | res := sysfunc2(68, 1) |
|
| 92 | sys.CODE("C9"); (* leave *) |
157 | END switch_task; |
| - | 158 | ||
| - | 159 | ||
| - | 160 | PROCEDURE futex_create (ptr: INTEGER): INTEGER; |
|
| - | 161 | RETURN sysfunc3(77, 0, ptr) |
|
| - | 162 | END futex_create; |
|
| - | 163 | ||
| - | 164 | ||
| 93 | sys.CODE("C20C00"); (* ret 0Ch *) |
165 | PROCEDURE futex_wait (futex, value, timeout: INTEGER); |
| - | 166 | VAR |
|
| 94 | RETURN 0 |
167 | res: INTEGER; |
| 95 | END sysfunc3; |
168 | BEGIN |
| - | 169 | res := sysfunc5(77, 2, futex, value, timeout) |
|
| - | 170 | END futex_wait; |
|
| - | 171 | ||
| - | 172 | ||
| 96 | 173 | PROCEDURE futex_wake (futex, number: INTEGER); |
|
| - | 174 | VAR |
|
| - | 175 | res: INTEGER; |
|
| - | 176 | BEGIN |
|
| - | 177 | res := sysfunc4(77, 3, futex, number) |
|
| - | 178 | END futex_wake; |
|
| - | 179 | ||
| - | 180 | ||
| - | 181 | PROCEDURE EnterCriticalSection* (VAR CriticalSection: CRITICAL_SECTION); |
|
| - | 182 | BEGIN |
|
| - | 183 | switch_task; |
|
| - | 184 | futex_wait(CriticalSection[0], 1, 10000); |
|
| - | 185 | CriticalSection[1] := 1 |
|
| - | 186 | END EnterCriticalSection; |
|
| 97 | PROCEDURE _NEW*(size: INTEGER): INTEGER; |
187 | |
| - | 188 | ||
| - | 189 | PROCEDURE LeaveCriticalSection* (VAR CriticalSection: CRITICAL_SECTION); |
|
| - | 190 | BEGIN |
|
| - | 191 | CriticalSection[1] := 0; |
|
| - | 192 | futex_wake(CriticalSection[0], 1) |
|
| - | 193 | END LeaveCriticalSection; |
|
| - | 194 | ||
| 98 | VAR res, idx, temp: INTEGER; |
195 | |
| - | 196 | PROCEDURE InitializeCriticalSection* (VAR CriticalSection: CRITICAL_SECTION); |
|
| 99 | BEGIN |
197 | BEGIN |
| - | 198 | CriticalSection[0] := futex_create(sys.ADR(CriticalSection[1])); |
|
| - | 199 | CriticalSection[1] := 0 |
|
| 100 | IF size <= MAX_SIZE THEN |
200 | END InitializeCriticalSection; |
| 101 | idx := ASR(size, 5); |
201 | |
| - | 202 | ||
| - | 203 | PROCEDURE __NEW (size: INTEGER): INTEGER; |
|
| 102 | res := pockets[idx]; |
204 | VAR |
| 103 | IF res # 0 THEN |
205 | res, idx, temp: INTEGER; |
| - | 206 | BEGIN |
|
| - | 207 | IF size <= MAX_SIZE THEN |
|
| - | 208 | idx := ASR(size, 5); |
|
| - | 209 | res := pockets[idx]; |
|
| - | 210 | IF res # 0 THEN |
|
| 104 | sys.GET(res, pockets[idx]); |
211 | sys.GET(res, pockets[idx]); |
| 105 | sys.PUT(res, size); |
212 | sys.PUT(res, size); |
| 106 | INC(res, 4) |
213 | INC(res, 4) |
| 107 | ELSE |
214 | ELSE |
| 108 | temp := 0; |
215 | temp := 0; |
| - | 216 | IF heap + size >= endheap THEN |
|
| - | 217 | IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN |
|
| - | 218 | temp := sysfunc3(68, 12, HEAP_SIZE) |
|
| - | 219 | ELSE |
|
| - | 220 | temp := 0 |
|
| - | 221 | END; |
|
| - | 222 | IF temp # 0 THEN |
|
| - | 223 | mem_commit(temp, HEAP_SIZE); |
|
| - | 224 | heap := temp; |
|
| - | 225 | endheap := heap + HEAP_SIZE |
|
| - | 226 | ELSE |
|
| - | 227 | temp := -1 |
|
| - | 228 | END |
|
| - | 229 | END; |
|
| - | 230 | IF (heap # 0) & (temp # -1) THEN |
|
| - | 231 | sys.PUT(heap, size); |
|
| - | 232 | res := heap + 4; |
|
| - | 233 | heap := heap + size |
|
| - | 234 | ELSE |
|
| - | 235 | res := 0 |
|
| 109 | IF heap + size >= endheap THEN |
236 | END |
| 110 | IF sysfunc2(18, 16) > ASR(HEAP_SIZE, 10) THEN |
237 | END |
| 111 | temp := sysfunc3(68, 12, HEAP_SIZE) |
238 | ELSE |
| 112 | ELSE |
239 | IF sysfunc2(18, 16) > ASR(size, 10) THEN |
| 113 | temp := 0 |
- | |
| 114 | END; |
- | |
| 115 | IF temp # 0 THEN |
240 | res := sysfunc3(68, 12, size); |
| 116 | mem_commit(temp, HEAP_SIZE); |
241 | IF res # 0 THEN |
| 117 | heap := temp; |
- | |
| 118 | endheap := heap + HEAP_SIZE |
- | |
| 119 | ELSE |
- | |
| 120 | temp := -1 |
242 | mem_commit(res, size); |
| - | 243 | sys.PUT(res, size); |
|
| 121 | END |
244 | INC(res, 4) |
| - | 245 | END |
|
| - | 246 | ELSE |
|
| 122 | END; |
247 | res := 0 |
| - | 248 | END |
|
| - | 249 | END; |
|
| - | 250 | IF res # 0 THEN |
|
| - | 251 | zeromem(ASR(size, 2) - 1, res) |
|
| 123 | IF (heap # 0) & (temp # -1) THEN |
252 | END |
| 124 | sys.PUT(heap, size); |
253 | RETURN res |
| 125 | res := heap + 4; |
254 | END __NEW; |
| 126 | heap := heap + size |
255 | |
| 127 | ELSE |
256 | |
| 128 | res := 0 |
- | |
| 129 | END |
257 | PROCEDURE __DISPOSE (ptr: INTEGER): INTEGER; |
| 130 | END |
258 | VAR |
| 131 | ELSE |
259 | size, idx: INTEGER; |
| - | 260 | BEGIN |
|
| - | 261 | DEC(ptr, 4); |
|
| - | 262 | sys.GET(ptr, size); |
|
| - | 263 | IF size <= MAX_SIZE THEN |
|
| - | 264 | idx := ASR(size, 5); |
|
| - | 265 | sys.PUT(ptr, pockets[idx]); |
|
| - | 266 | pockets[idx] := ptr |
|
| 132 | IF sysfunc2(18, 16) > ASR(size, 10) THEN |
267 | ELSE |
| - | 268 | size := sysfunc3(68, 13, ptr) |
|
| - | 269 | END |
|
| 133 | res := sysfunc3(68, 12, size); |
270 | RETURN 0 |
| 134 | IF res # 0 THEN |
271 | END __DISPOSE; |
| - | 272 | ||
| - | 273 | ||
| 135 | mem_commit(res, size); |
274 | PROCEDURE NEW_DISPOSE (func, arg: INTEGER): INTEGER; |
| - | 275 | VAR |
|
| - | 276 | res: INTEGER; |
|
| 136 | sys.PUT(res, size); |
277 | BEGIN |
| - | 278 | EnterCriticalSection(CriticalSection); |
|
| - | 279 | ||
| - | 280 | IF func = _new THEN |
|
| - | 281 | res := __NEW(arg) |
|
| - | 282 | ELSIF func = _dispose THEN |
|
| 137 | INC(res, 4) |
283 | res := __DISPOSE(arg) |
| - | 284 | END; |
|
| Line 138... | Line 285... | ||
| 138 | END |
285 | |
| 139 | ELSE |
- | |
| 140 | res := 0 |
- | |
| 141 | END |
- | |
| 142 | END; |
- | |
| 143 | IF res # 0 THEN |
- | |
| 144 | zeromem(ASR(size, 2) - 1, res) |
- | |
| 145 | END |
- | |
| 146 | RETURN res |
- | |
| 147 | END _NEW; |
- | |
| 148 | 286 | LeaveCriticalSection(CriticalSection) |
|
| 149 | PROCEDURE _DISPOSE*(ptr: INTEGER): INTEGER; |
- | |
| 150 | VAR size, idx: INTEGER; |
- | |
| 151 | BEGIN |
287 | RETURN res |
| Line -... | Line 288... | ||
| - | 288 | END NEW_DISPOSE; |
|
| 152 | DEC(ptr, 4); |
289 | |
| 153 | sys.GET(ptr, size); |
290 | |
| 154 | IF size <= MAX_SIZE THEN |
291 | PROCEDURE _NEW* (size: INTEGER): INTEGER; |
| 155 | idx := ASR(size, 5); |
292 | RETURN NEW_DISPOSE(_new, size) |
| - | 293 | END _NEW; |
|
| Line 156... | Line 294... | ||
| 156 | sys.PUT(ptr, pockets[idx]); |
294 | |
| 157 | pockets[idx] := ptr |
295 | |
| 158 | ELSE |
296 | PROCEDURE _DISPOSE* (ptr: INTEGER): INTEGER; |
| 159 | size := sysfunc3(68, 13, ptr) |
297 | RETURN NEW_DISPOSE(_dispose, ptr) |
| - | 298 | END _DISPOSE; |
|
| Line 160... | Line 299... | ||
| 160 | END |
299 | |
| - | 300 | ||
| 161 | RETURN 0 |
301 | PROCEDURE ExitProcess* (p1: INTEGER); |
| 162 | END _DISPOSE; |
302 | BEGIN |
| 163 | 303 | p1 := sysfunc1(-1) |
|
| 164 | PROCEDURE ExitProcess*(p1: INTEGER); |
304 | END ExitProcess; |
| - | 305 | ||
| Line 165... | Line 306... | ||
| 165 | BEGIN |
306 | |
| - | 307 | PROCEDURE ExitThread* (p1: INTEGER); |
|
| 166 | p1 := sysfunc1(-1) |
308 | BEGIN |
| 167 | END ExitProcess; |
309 | p1 := sysfunc1(-1) |
| 168 | 310 | END ExitThread; |
|
| 169 | PROCEDURE ExitThread*(p1: INTEGER); |
311 | |
| 170 | BEGIN |
312 | |
| - | 313 | PROCEDURE OutChar (c: CHAR); |
|
| - | 314 | VAR |
|
| - | 315 | res: INTEGER; |
|
| - | 316 | BEGIN |
|
| - | 317 | res := sysfunc3(63, 1, ORD(c)) |
|
| - | 318 | END OutChar; |
|
| - | 319 | ||
| - | 320 | ||
| - | 321 | PROCEDURE DebugMsg* (lpText, lpCaption: INTEGER); |
|
| - | 322 | VAR |
|
| - | 323 | c: CHAR; |
|
| 171 | p1 := sysfunc1(-1) |
324 | BEGIN |
| 172 | END ExitThread; |
325 | IF lpCaption # 0 THEN |
| 173 | 326 | OutChar(0DX); |
|
| 174 | PROCEDURE OutChar(c: CHAR); |
327 | OutChar(0AX); |
| 175 | VAR res: INTEGER; |
328 | REPEAT |
| 176 | BEGIN |
329 | sys.GET(lpCaption, c); |
| 177 | res := sysfunc3(63, 1, ORD(c)) |
330 | IF c # 0X THEN |
| 178 | END OutChar; |
- | |
| 179 | - | ||
| 180 | PROCEDURE DebugMsg*(lpText, lpCaption: INTEGER); |
- | |
| 181 | VAR c: CHAR; |
- | |
| 182 | BEGIN |
- | |
| 183 | IF lpCaption # 0 THEN |
- | |
| 184 | OutChar(0DX); |
- | |
| 185 | OutChar(0AX); |
- | |
| 186 | REPEAT |
- | |
| 187 | sys.GET(lpCaption, c); |
- | |
| 188 | IF c # 0X THEN |
- | |
| 189 | OutChar(c) |
331 | OutChar(c) |
| 190 | END; |
332 | END; |
| 191 | INC(lpCaption) |
333 | INC(lpCaption) |
| 192 | UNTIL c = 0X; |
334 | UNTIL c = 0X; |
| 193 | OutChar(":"); |
335 | OutChar(":"); |
| - | 336 | OutChar(0DX); |
|
| Line 194... | Line 337... | ||
| 194 | OutChar(0DX); |
337 | OutChar(0AX) |
| 195 | OutChar(0AX) |
338 | END; |
| 196 | END; |
339 | REPEAT |
| - | 340 | sys.GET(lpText, c); |
|
| 197 | REPEAT |
341 | IF c # 0X THEN |
| - | 342 | OutChar(c) |
|
| Line 198... | Line 343... | ||
| 198 | sys.GET(lpText, c); |
343 | END; |
| 199 | IF c # 0X THEN |
344 | INC(lpText) |