DEADSOFTWARE

GIT / REPO / FRED-BOY
Projects / cpc.git / blob


083c9977a5c89f92fbc11ed1444189e2ee5828f4
[cpc.git] / src / i486 / posix / System / Mod / Kernel.cp
1 MODULE Kernel;
2
3 IMPORT S := SYSTEM, stdlib := C99stdlib, stdio := C99stdio,
4 time := C99time, wctype := C99wctype, sysmman := C99sys_mman,
5 dlfcn := C99dlfcn, types := C99types, fcntl := C99fcntl,
6 unistd := C99unistd, signal := C99signal, setjmp := C99setjmp;
7
8 (* init fpu? *)
9 (* add signal blocking to avoid race conditions in Try/Trap/TrapHandler *)
10 (* add BeepHook for Beep *)
11 (* implement Call using libffi *)
12
13 CONST
14 nameLen* = 256;
15
16 littleEndian* = TRUE;
17 timeResolution* = 1000; (* ticks per second *)
18
19 processor* = 1; (* generic c *)
20
21 objType* = "ocf"; (* file types *)
22 symType* = "osf";
23 docType* = "odc";
24
25 (* loader constants *)
26 done* = 0;
27 fileNotFound* = 1;
28 syntaxError* = 2;
29 objNotFound* = 3;
30 illegalFPrint* = 4;
31 cyclicImport* = 5;
32 noMem* = 6;
33 commNotFound* = 7;
34 commSyntaxError* = 8;
35 moduleNotFound* = 9;
36
37 any = 1000000;
38
39 CX = 1;
40 SP = 4; (* register number of stack pointer *)
41 FP = 5; (* register number of frame pointer *)
42 ML = 3; (* register which holds the module list at program start *)
43
44 strictStackSweep = FALSE;
45 N = 128 DIV 16; (* free lists *)
46
47 (* kernel flags in module desc *)
48 init = 16; dyn = 17; dll = 24; iptrs = 30;
49
50 (* meta interface consts *)
51 mConst = 1; mTyp = 2; mVar = 3; mProc = 4; mField = 5;
52
53 TYPE
54 Name* = ARRAY nameLen OF CHAR;
55 Utf8Name* = ARRAY nameLen OF SHORTCHAR;
56 Command* = PROCEDURE;
57
58 Module* = POINTER TO RECORD [untagged]
59 next-: Module;
60 opts-: SET; (* 0..15: compiler opts, 16..31: kernel flags *)
61 refcnt-: INTEGER; (* <0: module invalidated *)
62 compTime-, loadTime-: ARRAY 6 OF SHORTINT;
63 ext-: INTEGER; (* currently not used *)
64 term-: Command; (* terminator *)
65 nofimps-, nofptrs-: INTEGER;
66 csize-, dsize-, rsize-: INTEGER;
67 code-, data-, refs-: INTEGER;
68 procBase-, varBase-: INTEGER; (* meta base addresses *)
69 names-: POINTER TO ARRAY [untagged] OF SHORTCHAR; (* names[0] = 0X *)
70 ptrs-: POINTER TO ARRAY [untagged] OF INTEGER;
71 imports-: POINTER TO ARRAY [untagged] OF Module;
72 export-: Directory; (* exported objects (name sorted) *)
73 name-: Utf8Name
74 END;
75
76 Type* = POINTER TO RECORD [untagged]
77 (* record: ptr to method n at offset - 4 * (n+1) *)
78 size-: INTEGER; (* record: size, array: #elem, dyn array: 0, proc: sigfp *)
79 mod-: Module;
80 id-: INTEGER; (* name idx * 256 + lev * 16 + attr * 4 + form *)
81 base-: ARRAY 16 OF Type; (* signature if form = ProcTyp *)
82 fields-: Directory; (* new fields (declaration order) *)
83 ptroffs-: ARRAY any OF INTEGER (* array of any length *)
84 END;
85
86 Object* = POINTER TO ObjDesc;
87
88 ObjDesc* = RECORD [untagged]
89 fprint-: INTEGER;
90 offs-: INTEGER; (* pvfprint for record types *)
91 id-: INTEGER; (* name idx * 256 + vis * 16 + mode *)
92 struct-: Type (* id of basic type or pointer to typedesc/signature *)
93 END;
94
95 Directory* = POINTER TO RECORD [untagged]
96 num-: INTEGER; (* number of entries *)
97 obj-: ARRAY any OF ObjDesc (* array of any length *)
98 END;
99
100 Signature* = POINTER TO RECORD [untagged]
101 retStruct-: Type; (* id of basic type or pointer to typedesc or 0 *)
102 num-: INTEGER; (* number of parameters *)
103 par-: ARRAY any OF RECORD [untagged] (* parameters *)
104 id-: INTEGER; (* name idx * 256 + kind *)
105 struct-: Type (* id of basic type or pointer to typedesc *)
106 END
107 END;
108
109 Handler* = PROCEDURE;
110
111 Reducer* = POINTER TO ABSTRACT RECORD
112 next: Reducer
113 END;
114
115 Identifier* = ABSTRACT RECORD
116 typ*: INTEGER;
117 obj-: ANYPTR
118 END;
119
120 TrapCleaner* = POINTER TO ABSTRACT RECORD
121 next: TrapCleaner
122 END;
123
124 TryHandler* = PROCEDURE (a, b, c: INTEGER);
125
126 (* meta extension suport *)
127
128 ItemExt* = POINTER TO ABSTRACT RECORD END;
129
130 ItemAttr* = RECORD
131 obj*, vis*, typ*, adr*: INTEGER;
132 mod*: Module;
133 desc*: Type;
134 ptr*: S.PTR;
135 ext*: ItemExt
136 END;
137
138 Hook* = POINTER TO ABSTRACT RECORD END;
139
140 LoaderHook* = POINTER TO ABSTRACT RECORD (Hook)
141 res*: INTEGER;
142 importing*, imported*, object*: ARRAY 256 OF CHAR
143 END;
144
145 Block = POINTER TO RECORD [untagged]
146 tag: Type;
147 last: INTEGER; (* arrays: last element *)
148 actual: INTEGER; (* arrays: used during mark phase *)
149 first: INTEGER (* arrays: first element *)
150 END;
151
152 FreeBlock = POINTER TO FreeDesc;
153
154 FreeDesc = RECORD [untagged]
155 tag: Type; (* f.tag = ADR(f.size) *)
156 size: INTEGER;
157 next: FreeBlock
158 END;
159
160 Cluster = POINTER TO RECORD [untagged]
161 size: INTEGER; (* total size *)
162 next: Cluster;
163 max: INTEGER (* exe: reserved size, dll: original address *)
164 (* start of first block *)
165 END;
166
167 FList = POINTER TO RECORD
168 next: FList;
169 blk: Block;
170 iptr, aiptr: BOOLEAN
171 END;
172
173 CList = POINTER TO RECORD
174 next: CList;
175 do: Command;
176 trapped: BOOLEAN
177 END;
178
179
180 PtrType = RECORD v: S.PTR END; (* used for array of pointer *)
181 Char8Type = RECORD v: SHORTCHAR END;
182 Char16Type = RECORD v: CHAR END;
183 Int8Type = RECORD v: BYTE END;
184 Int16Type = RECORD v: SHORTINT END;
185 Int32Type = RECORD v: INTEGER END;
186 Int64Type = RECORD v: LONGINT END;
187 BoolType = RECORD v: BOOLEAN END;
188 SetType = RECORD v: SET END;
189 Real32Type = RECORD v: SHORTREAL END;
190 Real64Type = RECORD v: REAL END;
191 ProcType = RECORD v: PROCEDURE END;
192 UPtrType = RECORD v: INTEGER END;
193 StrPtr = POINTER TO ARRAY [untagged] OF SHORTCHAR;
194
195 ArrStrPtr = POINTER TO ARRAY [untagged] OF StrPtr;
196
197 ADDRESS* = types.Pvoid;
198
199 VAR
200 baseStack: INTEGER;
201 root: Cluster;
202 modList-: Module;
203 trapCount-: INTEGER;
204 err-, pc-, sp-, fp-, stack-, val-: INTEGER;
205
206 isTry: BOOLEAN;
207 startEnv: setjmp.sigjmp_buf;
208 tryEnv: setjmp.jmp_buf;
209
210 argc-: INTEGER;
211 argv-: ArrStrPtr;
212 pagesize: unistd.long;
213
214 free: ARRAY N OF FreeBlock; (* free list *)
215 sentinelBlock: FreeDesc;
216 sentinel: FreeBlock;
217 candidates: ARRAY 1024 OF INTEGER;
218 nofcand: INTEGER;
219 allocated: INTEGER; (* bytes allocated on BlackBox heap *)
220 total: INTEGER; (* current total size of BlackBox heap *)
221 used: INTEGER; (* bytes allocated on system heap *)
222 finalizers: FList;
223 hotFinalizers: FList;
224 cleaners: CList;
225 reducers: Reducer;
226 trapStack: TrapCleaner;
227 actual: Module; (* valid during module initialization *)
228
229 trapViewer, trapChecker: Handler;
230 trapped, guarded, secondTrap: BOOLEAN;
231 interrupted: BOOLEAN;
232 static, inDll, terminating: BOOLEAN;
233 restart: Command;
234
235 loader: LoaderHook;
236 loadres: INTEGER;
237
238 wouldFinalize: BOOLEAN;
239
240 watcher*: PROCEDURE (event: INTEGER); (* for debugging *)
241
242 PROCEDURE Erase (adr, words: INTEGER);
243 BEGIN
244 ASSERT(words >= 0, 20);
245 WHILE words > 0 DO
246 S.PUT(adr, 0);
247 INC(adr, 4);
248 DEC(words)
249 END
250 END Erase;
251
252
253 PROCEDURE (VAR id: Identifier) Identified* (): BOOLEAN, NEW, ABSTRACT;
254 PROCEDURE (r: Reducer) Reduce* (full: BOOLEAN), NEW, ABSTRACT;
255 PROCEDURE (c: TrapCleaner) Cleanup*, NEW, EMPTY;
256
257 (* meta extension suport *)
258
259 PROCEDURE (e: ItemExt) Lookup* (name: ARRAY OF CHAR; VAR i: ANYREC), NEW, ABSTRACT;
260 PROCEDURE (e: ItemExt) Index* (index: INTEGER; VAR elem: ANYREC), NEW, ABSTRACT;
261 PROCEDURE (e: ItemExt) Deref* (VAR ref: ANYREC), NEW, ABSTRACT;
262
263 PROCEDURE (e: ItemExt) Valid* (): BOOLEAN, NEW, ABSTRACT;
264 PROCEDURE (e: ItemExt) Size* (): INTEGER, NEW, ABSTRACT;
265 PROCEDURE (e: ItemExt) BaseTyp* (): INTEGER, NEW, ABSTRACT;
266 PROCEDURE (e: ItemExt) Len* (): INTEGER, NEW, ABSTRACT;
267
268 PROCEDURE (e: ItemExt) Call* (OUT ok: BOOLEAN), NEW, ABSTRACT;
269 PROCEDURE (e: ItemExt) BoolVal* (): BOOLEAN, NEW, ABSTRACT;
270 PROCEDURE (e: ItemExt) PutBoolVal* (x: BOOLEAN), NEW, ABSTRACT;
271 PROCEDURE (e: ItemExt) CharVal* (): CHAR, NEW, ABSTRACT;
272 PROCEDURE (e: ItemExt) PutCharVal* (x: CHAR), NEW, ABSTRACT;
273 PROCEDURE (e: ItemExt) IntVal* (): INTEGER, NEW, ABSTRACT;
274 PROCEDURE (e: ItemExt) PutIntVal* (x: INTEGER), NEW, ABSTRACT;
275 PROCEDURE (e: ItemExt) LongVal* (): LONGINT, NEW, ABSTRACT;
276 PROCEDURE (e: ItemExt) PutLongVal* (x: LONGINT), NEW, ABSTRACT;
277 PROCEDURE (e: ItemExt) RealVal* (): REAL, NEW, ABSTRACT;
278 PROCEDURE (e: ItemExt) PutRealVal* (x: REAL), NEW, ABSTRACT;
279 PROCEDURE (e: ItemExt) SetVal* (): SET, NEW, ABSTRACT;
280 PROCEDURE (e: ItemExt) PutSetVal* (x: SET), NEW, ABSTRACT;
281 PROCEDURE (e: ItemExt) PtrVal* (): ANYPTR, NEW, ABSTRACT;
282 PROCEDURE (e: ItemExt) PutPtrVal* (x: ANYPTR), NEW, ABSTRACT;
283 PROCEDURE (e: ItemExt) GetSStringVal* (OUT x: ARRAY OF SHORTCHAR;
284 OUT ok: BOOLEAN), NEW, ABSTRACT;
285 PROCEDURE (e: ItemExt) PutSStringVal* (IN x: ARRAY OF SHORTCHAR;
286 OUT ok: BOOLEAN), NEW, ABSTRACT;
287 PROCEDURE (e: ItemExt) GetStringVal* (OUT x: ARRAY OF CHAR; OUT ok: BOOLEAN), NEW, ABSTRACT;
288 PROCEDURE (e: ItemExt) PutStringVal* (IN x: ARRAY OF CHAR; OUT ok: BOOLEAN), NEW, ABSTRACT;
289
290 (* -------------------- miscellaneous tools -------------------- *)
291
292 PROCEDURE IsUpper* (ch: CHAR): BOOLEAN;
293 BEGIN
294 RETURN wctype.iswupper(ORD(ch)) # 0
295 END IsUpper;
296
297 PROCEDURE Upper* (ch: CHAR): CHAR;
298 BEGIN
299 RETURN CHR(wctype.towupper(ORD(ch)))
300 END Upper;
301
302 PROCEDURE IsLower* (ch: CHAR): BOOLEAN;
303 BEGIN
304 RETURN wctype.iswlower(ORD(ch)) # 0
305 END IsLower;
306
307 PROCEDURE Lower* (ch: CHAR): CHAR;
308 BEGIN
309 RETURN CHR(wctype.towlower(ORD(ch)))
310 END Lower;
311
312 PROCEDURE IsAlpha* (ch: CHAR): BOOLEAN;
313 BEGIN
314 RETURN wctype.iswalpha(ORD(ch)) # 0
315 END IsAlpha;
316
317 PROCEDURE Utf8ToString* (IN in: ARRAY OF SHORTCHAR; OUT out: ARRAY OF CHAR; OUT res: INTEGER);
318 VAR i, j, val, max: INTEGER; ch: SHORTCHAR;
319
320 PROCEDURE FormatError();
321 BEGIN out := in$; res := 2 (*format error*)
322 END FormatError;
323
324 BEGIN
325 ch := in[0]; i := 1; j := 0; max := LEN(out) - 1;
326 WHILE (ch # 0X) & (j < max) DO
327 IF ch < 80X THEN
328 out[j] := ch; INC(j)
329 ELSIF ch < 0E0X THEN
330 val := ORD(ch) - 192;
331 IF val < 0 THEN FormatError; RETURN END ;
332 ch := in[i]; INC(i); val := val * 64 + ORD(ch) - 128;
333 IF (ch < 80X) OR (ch >= 0E0X) THEN FormatError; RETURN END ;
334 out[j] := CHR(val); INC(j)
335 ELSIF ch < 0F0X THEN
336 val := ORD(ch) - 224;
337 ch := in[i]; INC(i); val := val * 64 + ORD(ch) - 128;
338 IF (ch < 80X) OR (ch >= 0E0X) THEN FormatError; RETURN END ;
339 ch := in[i]; INC(i); val := val * 64 + ORD(ch) - 128;
340 IF (ch < 80X) OR (ch >= 0E0X) THEN FormatError; RETURN END ;
341 out[j] := CHR(val); INC(j)
342 ELSE
343 FormatError; RETURN
344 END ;
345 ch := in[i]; INC(i)
346 END;
347 out[j] := 0X;
348 IF ch = 0X THEN res := 0 (*ok*) ELSE res := 1 (*truncated*) END
349 END Utf8ToString;
350
351 PROCEDURE StringToUtf8* (IN in: ARRAY OF CHAR; OUT out: ARRAY OF SHORTCHAR; OUT res: INTEGER);
352 VAR i, j, val, max: INTEGER;
353 BEGIN
354 i := 0; j := 0; max := LEN(out) - 3;
355 WHILE (in[i] # 0X) & (j < max) DO
356 val := ORD(in[i]); INC(i);
357 IF val < 128 THEN
358 out[j] := SHORT(CHR(val)); INC(j)
359 ELSIF val < 2048 THEN
360 out[j] := SHORT(CHR(val DIV 64 + 192)); INC(j);
361 out[j] := SHORT(CHR(val MOD 64 + 128)); INC(j)
362 ELSE
363 out[j] := SHORT(CHR(val DIV 4096 + 224)); INC(j);
364 out[j] := SHORT(CHR(val DIV 64 MOD 64 + 128)); INC(j);
365 out[j] := SHORT(CHR(val MOD 64 + 128)); INC(j)
366 END;
367 END;
368 out[j] := 0X;
369 IF in[i] = 0X THEN res := 0 (*ok*) ELSE res := 1 (*truncated*) END
370 END StringToUtf8;
371
372 PROCEDURE SplitName* (name: ARRAY OF CHAR; VAR head, tail: ARRAY OF CHAR);
373 (* portable *)
374 VAR i, j: INTEGER; ch, lch: CHAR;
375 BEGIN
376 i := 0; ch := name[0];
377 IF ch # 0X THEN
378 REPEAT
379 head[i] := ch; lch := ch; INC(i); ch := name[i]
380 UNTIL (ch = 0X) OR (ch = ".") OR IsUpper(ch) & ~IsUpper(lch);
381 IF ch = "." THEN i := 0; ch := name[0] END;
382 head[i] := 0X; j := 0;
383 WHILE ch # 0X DO tail[j] := ch; INC(i); INC(j); ch := name[i] END;
384 tail[j] := 0X;
385 IF tail = "" THEN tail := head$; head := "" END
386 ELSE head := ""; tail := ""
387 END
388 END SplitName;
389
390 PROCEDURE MakeFileName* (VAR name: ARRAY OF CHAR; type: ARRAY OF CHAR);
391 VAR i, j: INTEGER; ext: ARRAY 8 OF CHAR; ch: CHAR;
392 BEGIN
393 i := 0;
394 WHILE (name[i] # 0X) & (name[i] # ".") DO INC(i) END;
395 IF name[i] = "." THEN
396 IF name[i + 1] = 0X THEN name[i] := 0X END
397 ELSE
398 IF type = "" THEN ext := docType ELSE ext := type$ END;
399 IF i < LEN(name) - LEN(ext$) - 1 THEN
400 name[i] := "."; INC(i); j := 0; ch := ext[0];
401 WHILE ch # 0X DO
402 name[i] := Lower(ch); INC(i); INC(j); ch := ext[j]
403 END;
404 name[i] := 0X
405 END
406 END
407 END MakeFileName;
408
409 PROCEDURE Time* (): LONGINT;
410 VAR res: time.int; tp: time.struct_timespec;
411 BEGIN
412 ASSERT(timeResolution >= 1);
413 ASSERT(timeResolution <= 1000000000);
414 res := time.clock_gettime(time.CLOCK_MONOTONIC, tp);
415 ASSERT(res = 0, 100);
416 RETURN tp.tv_sec * LONG(timeResolution) + tp.tv_nsec DIV LONG(1000000000 DIV timeResolution)
417 END Time;
418
419 PROCEDURE Beep*;
420 (* !!! *)
421 END Beep;
422
423 PROCEDURE SearchProcVar* (var: INTEGER; VAR m: Module; VAR adr: INTEGER);
424 BEGIN
425 adr := var; m := NIL;
426 IF var # 0 THEN
427 m := modList;
428 WHILE (m # NIL) & ((var < m.code) OR (var >= m.code + m.csize)) DO m := m.next END;
429 IF m # NIL THEN DEC(adr, m.code) END
430 END
431 END SearchProcVar;
432
433 (* -------------------- system memory management --------------------- *)
434
435 PROCEDURE AllocMem (size: sysmman.size_t; VAR max: sysmman.size_t): ADDRESS;
436 VAR fd, flags, res: fcntl.int; ptr: ADDRESS;
437 BEGIN
438 max := (size + pagesize - 1) DIV pagesize * pagesize;
439 fd := fcntl.open("/dev/zero", fcntl.O_RDWR, 0);
440 IF fd # -1 THEN
441 flags := sysmman.PROT_READ + sysmman.PROT_WRITE;
442 ptr := sysmman.mmap(0, max, flags, sysmman.MAP_PRIVATE, fd, 0);
443 IF ptr = sysmman.MAP_FAILED THEN ptr := 0 END;
444 res := unistd.close(fd);
445 ASSERT(res = 0, 100)
446 ELSE
447 ptr := 0
448 END;
449 RETURN ptr
450 END AllocMem;
451
452 PROCEDURE FreeMem (adr: ADDRESS; size: sysmman.size_t);
453 VAR res: types.int;
454 BEGIN
455 size := (size + pagesize - 1) DIV pagesize * pagesize;
456 res := sysmman.munmap(adr, size);
457 ASSERT(res = 0, 100)
458 END FreeMem;
459
460 PROCEDURE AllocHeapMem (size: INTEGER; VAR c: Cluster);
461 CONST N = 65536; (* cluster size for dll *)
462 VAR adr, allocated: INTEGER;
463 BEGIN
464 INC(size, 16);
465 ASSERT(size > 0, 100); adr := 0;
466 IF size < N THEN adr := stdlib.malloc(N) END;
467 IF adr = 0 THEN adr := stdlib.malloc(size); allocated := size ELSE allocated := N END;
468 IF adr = 0 THEN c := NIL
469 ELSE
470 c := S.VAL(Cluster, (adr + 15) DIV 16 * 16); c.max := adr;
471 c.size := allocated - (S.VAL(INTEGER, c) - adr);
472 INC(used, c.size); INC(total, c.size)
473 END;
474 ASSERT((adr = 0) OR (adr MOD 16 = 0) & (c.size >= size), 101);
475 (* post: (c = NIL) OR (c MOD 16 = 0) & (c.size >= size) *)
476 END AllocHeapMem;
477
478 PROCEDURE FreeHeapMem (c: Cluster);
479 BEGIN
480 DEC(used, c.size); DEC(total, c.size);
481 stdlib.free(S.VAL(ADDRESS, c.max))
482 END FreeHeapMem;
483
484 PROCEDURE HeapFull (size: INTEGER): BOOLEAN;
485 BEGIN
486 RETURN TRUE
487 END HeapFull;
488
489 PROCEDURE AllocModMem* (descSize, modSize: INTEGER; VAR descAdr, modAdr: INTEGER);
490 BEGIN
491 descAdr := 0; modAdr := 0;
492 descAdr := AllocMem(descSize, descSize);
493 IF descAdr # 0 THEN
494 modAdr := AllocMem(modSize, modSize);
495 IF modAdr = 0 THEN
496 FreeMem(descAdr, descSize)
497 ELSE
498 INC(used, descSize + modSize)
499 END
500 END
501 END AllocModMem;
502
503 PROCEDURE DeallocModMem* (descSize, modSize, descAdr, modAdr: INTEGER);
504 BEGIN
505 FreeMem(descAdr, descSize);
506 FreeMem(modAdr, modSize);
507 DEC(used, descSize + modSize)
508 END DeallocModMem;
509
510 PROCEDURE InvalModMem (modSize, modAdr: INTEGER);
511 BEGIN
512 FreeMem(modAdr, modSize)
513 END InvalModMem;
514
515 PROCEDURE TryRead (from, to, c: INTEGER);
516 VAR i: INTEGER; x: BYTE;
517 BEGIN
518 IF from <= to THEN
519 FOR i := from TO to DO
520 S.GET(i, x)
521 END
522 ELSE
523 FOR i := to TO from BY -1 DO
524 S.GET(i, x)
525 END
526 END;
527 END TryRead;
528
529 PROCEDURE^ Try* (h: TryHandler; a, b, c: INTEGER);
530
531 PROCEDURE IsReadable* (from, to: INTEGER): BOOLEAN;
532 VAR i: INTEGER;
533 BEGIN
534 i := trapCount;
535 Try(TryRead, from, to, 0);
536 RETURN trapCount = i
537 END IsReadable;
538
539 (* --------------------- NEW implementation (portable) -------------------- *)
540
541 PROCEDURE^ NewBlock (size: INTEGER): Block;
542
543 PROCEDURE NewRec* (typ: INTEGER): INTEGER; (* implementation of NEW(ptr) *)
544 VAR size, adr: INTEGER; b: Block; tag: Type; l: FList;
545 BEGIN
546 IF ~ODD(typ) THEN
547 tag := S.VAL(Type, typ);
548 b := NewBlock(tag.size);
549 IF b # NIL THEN
550 b.tag := tag;
551 S.GET(typ - 4, size);
552 IF size # 0 THEN (* record uses a finalizer *)
553 l := S.VAL(FList, S.ADR(b.last)); (* anchor new object! *)
554 l := S.VAL(FList, NewRec(S.TYP(FList))); (* NEW(l) *)
555 l.blk := b; l.next := finalizers; finalizers := l
556 END;
557 adr := S.ADR(b.last)
558 ELSE
559 adr := 0
560 END
561 ELSE
562 HALT(100) (* COM interface pointers not supported *)
563 END;
564 RETURN adr
565 END NewRec;
566
567 PROCEDURE NewArr* (eltyp, nofelem, nofdim: INTEGER): INTEGER; (* impl. of NEW(ptr, dim0, dim1, ...) *)
568 VAR b: Block; size, headSize: INTEGER; t: Type;
569 BEGIN
570 CASE eltyp OF
571 | -1: HALT(100) (* COM interface pointers not supported *)
572 | 0: eltyp := S.ADR(PtrType)
573 | 1: eltyp := S.ADR(Char8Type)
574 | 2: eltyp := S.ADR(Int16Type)
575 | 3: eltyp := S.ADR(Int8Type)
576 | 4: eltyp := S.ADR(Int32Type)
577 | 5: eltyp := S.ADR(BoolType)
578 | 6: eltyp := S.ADR(SetType)
579 | 7: eltyp := S.ADR(Real32Type)
580 | 8: eltyp := S.ADR(Real64Type)
581 | 9: eltyp := S.ADR(Char16Type)
582 | 10: eltyp := S.ADR(Int64Type)
583 | 11: eltyp := S.ADR(ProcType)
584 | 12: HALT(101) (* COM interface pointers not supported *)
585 ELSE
586 ASSERT(~ODD(eltyp), 102) (* COM interface pointers not supported *)
587 END;
588 t := S.VAL(Type, eltyp);
589 headSize := 4 * nofdim + 12;
590 size := headSize + nofelem * t.size;
591 b := NewBlock(size);
592 IF b # NIL THEN
593 b.tag := S.VAL(Type, eltyp + 2); (* tag + array mark *)
594 b.last := S.ADR(b.last) + size - t.size; (* pointer to last elem *)
595 b.first := S.ADR(b.last) + headSize; (* pointer to first elem *)
596 RETURN S.ADR(b.last)
597 ELSE
598 RETURN 0
599 END;
600 END NewArr;
601
602 (* -------------------- handler installation (portable) --------------------- *)
603
604 PROCEDURE ThisFinObj* (VAR id: Identifier): ANYPTR;
605 VAR l: FList;
606 BEGIN
607 ASSERT(id.typ # 0, 100);
608 l := finalizers;
609 WHILE l # NIL DO
610 IF S.VAL(INTEGER, l.blk.tag) = id.typ THEN
611 id.obj := S.VAL(ANYPTR, S.ADR(l.blk.last));
612 IF id.Identified() THEN RETURN id.obj END
613 END;
614 l := l.next
615 END;
616 RETURN NIL
617 END ThisFinObj;
618
619 PROCEDURE InstallReducer* (r: Reducer);
620 BEGIN
621 r.next := reducers; reducers := r
622 END InstallReducer;
623
624 PROCEDURE InstallTrapViewer* (h: Handler);
625 BEGIN
626 trapViewer := h
627 END InstallTrapViewer;
628
629 PROCEDURE InstallTrapChecker* (h: Handler);
630 BEGIN
631 trapChecker := h
632 END InstallTrapChecker;
633
634 PROCEDURE PushTrapCleaner* (c: TrapCleaner);
635 VAR t: TrapCleaner;
636 BEGIN
637 t := trapStack; WHILE (t # NIL) & (t # c) DO t := t.next END;
638 ASSERT(t = NIL, 20);
639 c.next := trapStack; trapStack := c
640 END PushTrapCleaner;
641
642 PROCEDURE PopTrapCleaner* (c: TrapCleaner);
643 VAR t: TrapCleaner;
644 BEGIN
645 t := NIL;
646 WHILE (trapStack # NIL) & (t # c) DO
647 t := trapStack; trapStack := trapStack.next
648 END
649 END PopTrapCleaner;
650
651 PROCEDURE InstallCleaner* (p: Command);
652 VAR c: CList;
653 BEGIN
654 c := S.VAL(CList, NewRec(S.TYP(CList))); (* NEW(c) *)
655 c.do := p; c.trapped := FALSE; c.next := cleaners; cleaners := c
656 END InstallCleaner;
657
658 PROCEDURE RemoveCleaner* (p: Command);
659 VAR c0, c: CList;
660 BEGIN
661 c := cleaners; c0 := NIL;
662 WHILE (c # NIL) & (c.do # p) DO c0 := c; c := c.next END;
663 IF c # NIL THEN
664 IF c0 = NIL THEN cleaners := cleaners.next ELSE c0.next := c.next END
665 END
666 END RemoveCleaner;
667
668 PROCEDURE Cleanup*;
669 VAR c, c0: CList;
670 BEGIN
671 c := cleaners; c0 := NIL;
672 WHILE c # NIL DO
673 IF ~c.trapped THEN
674 c.trapped := TRUE; c.do; c.trapped := FALSE; c0 := c
675 ELSE
676 IF c0 = NIL THEN cleaners := cleaners.next
677 ELSE c0.next := c.next
678 END
679 END;
680 c := c.next
681 END
682 END Cleanup;
683
684 (* -------------------- meta information (portable) --------------------- *)
685
686 PROCEDURE (h: LoaderHook) ThisMod* (IN name: ARRAY OF CHAR): Module, NEW, ABSTRACT;
687
688 PROCEDURE SetLoaderHook*(h: LoaderHook);
689 BEGIN
690 loader := h
691 END SetLoaderHook;
692
693 PROCEDURE InitModule (mod: Module); (* initialize linked modules *)
694 VAR body: Command;
695 BEGIN
696 IF ~(dyn IN mod.opts) & (mod.next # NIL) & ~(init IN mod.next.opts) THEN InitModule(mod.next) END;
697 IF ~(init IN mod.opts) THEN
698 body := S.VAL(Command, mod.code);
699 INCL(mod.opts, init);
700 actual := mod;
701 body(); actual := NIL
702 END
703 END InitModule;
704
705 PROCEDURE ThisLoadedMod* (IN name: ARRAY OF CHAR): Module; (* loaded modules only *)
706 VAR m: Module; res: INTEGER; n: Utf8Name;
707 BEGIN
708 StringToUtf8(name, n, res); ASSERT(res = 0);
709 loadres := done;
710 m := modList;
711 WHILE (m # NIL) & ((m.name # n) OR (m.refcnt < 0)) DO m := m.next END;
712 IF (m # NIL) & ~(init IN m.opts) THEN InitModule(m) END;
713 IF m = NIL THEN loadres := moduleNotFound END;
714 RETURN m
715 END ThisLoadedMod;
716
717 PROCEDURE ThisMod* (IN name: ARRAY OF CHAR): Module;
718 BEGIN
719 IF loader # NIL THEN
720 loader.res := done;
721 RETURN loader.ThisMod(name)
722 ELSE
723 RETURN ThisLoadedMod(name)
724 END
725 END ThisMod;
726
727 PROCEDURE LoadMod* (IN name: ARRAY OF CHAR);
728 VAR m: Module;
729 BEGIN
730 m := ThisMod(name)
731 END LoadMod;
732
733 PROCEDURE GetLoaderResult* (OUT res: INTEGER; OUT importing, imported, object: ARRAY OF CHAR);
734 BEGIN
735 IF loader # NIL THEN
736 res := loader.res;
737 importing := loader.importing$;
738 imported := loader.imported$;
739 object := loader.object$
740 ELSE
741 res := loadres;
742 importing := "";
743 imported := "";
744 object := ""
745 END
746 END GetLoaderResult;
747
748 PROCEDURE ThisObject* (mod: Module; IN name: ARRAY OF CHAR): Object;
749 VAR l, r, m, res: INTEGER; p: StrPtr; n: Utf8Name;
750 BEGIN
751 StringToUtf8(name, n, res); ASSERT(res = 0);
752 l := 0; r := mod.export.num;
753 WHILE l < r DO (* binary search *)
754 m := (l + r) DIV 2;
755 p := S.VAL(StrPtr, S.ADR(mod.names[mod.export.obj[m].id DIV 256]));
756 IF p^ = n THEN RETURN S.VAL(Object, S.ADR(mod.export.obj[m])) END;
757 IF p^ < n THEN l := m + 1 ELSE r := m END
758 END;
759 RETURN NIL
760 END ThisObject;
761
762 PROCEDURE ThisDesc* (mod: Module; fprint: INTEGER): Object;
763 VAR i, n: INTEGER;
764 BEGIN
765 i := 0; n := mod.export.num;
766 WHILE (i < n) & (mod.export.obj[i].id DIV 256 = 0) DO
767 IF mod.export.obj[i].offs = fprint THEN RETURN S.VAL(Object, S.ADR(mod.export.obj[i])) END;
768 INC(i)
769 END;
770 RETURN NIL
771 END ThisDesc;
772
773 PROCEDURE ThisField* (rec: Type; IN name: ARRAY OF CHAR): Object;
774 VAR n, res: INTEGER; p: StrPtr; obj: Object; m: Module; nn: Utf8Name;
775 BEGIN
776 StringToUtf8(name, nn, res); ASSERT(res = 0);
777 m := rec.mod;
778 obj := S.VAL(Object, S.ADR(rec.fields.obj[0])); n := rec.fields.num;
779 WHILE n > 0 DO
780 p := S.VAL(StrPtr, S.ADR(m.names[obj.id DIV 256]));
781 IF p^ = nn THEN RETURN obj END;
782 DEC(n); INC(S.VAL(INTEGER, obj), 16)
783 END;
784 RETURN NIL
785 END ThisField;
786
787 PROCEDURE ThisCommand* (mod: Module; IN name: ARRAY OF CHAR): Command;
788 VAR x: Object; sig: Signature;
789 BEGIN
790 x := ThisObject(mod, name);
791 IF (x # NIL) & (x.id MOD 16 = mProc) THEN
792 sig := S.VAL(Signature, x.struct);
793 IF (sig.retStruct = NIL) & (sig.num = 0) THEN RETURN S.VAL(Command, mod.procBase + x.offs) END
794 END;
795 RETURN NIL
796 END ThisCommand;
797
798 PROCEDURE ThisType* (mod: Module; IN name: ARRAY OF CHAR): Type;
799 VAR x: Object;
800 BEGIN
801 x := ThisObject(mod, name);
802 IF (x # NIL) & (x.id MOD 16 = mTyp) & (S.VAL(INTEGER, x.struct) DIV 256 # 0) THEN
803 RETURN x.struct
804 ELSE
805 RETURN NIL
806 END
807 END ThisType;
808
809 PROCEDURE TypeOf* (IN rec: ANYREC): Type;
810 BEGIN
811 RETURN S.VAL(Type, S.TYP(rec))
812 END TypeOf;
813
814 PROCEDURE LevelOf* (t: Type): SHORTINT;
815 BEGIN
816 RETURN SHORT(t.id DIV 16 MOD 16)
817 END LevelOf;
818
819 PROCEDURE NewObj* (VAR o: S.PTR; t: Type);
820 VAR i: INTEGER;
821 BEGIN
822 IF t.size = -1 THEN o := NIL
823 ELSE
824 i := 0; WHILE t.ptroffs[i] >= 0 DO INC(i) END;
825 IF t.ptroffs[i+1] >= 0 THEN INC(S.VAL(INTEGER, t)) END; (* with interface pointers *)
826 o := S.VAL(S.PTR, NewRec(S.VAL(INTEGER, t))) (* generic NEW *)
827 END
828 END NewObj;
829
830 PROCEDURE GetModName* (mod: Module; OUT name: Name);
831 VAR res: INTEGER;
832 BEGIN
833 Utf8ToString(mod.name, name, res); ASSERT(res = 0)
834 END GetModName;
835
836 PROCEDURE GetObjName* (mod: Module; obj: Object; OUT name: Name);
837 VAR p: StrPtr; res: INTEGER;
838 BEGIN
839 p := S.VAL(StrPtr, S.ADR(mod.names[obj.id DIV 256]));
840 Utf8ToString(p^$, name, res); ASSERT(res = 0)
841 END GetObjName;
842
843 PROCEDURE GetTypeName* (t: Type; OUT name: Name);
844 VAR p: StrPtr; res: INTEGER;
845 BEGIN
846 p := S.VAL(StrPtr, S.ADR(t.mod.names[t.id DIV 256]));
847 Utf8ToString(p^$, name, res); ASSERT(res = 0)
848 END GetTypeName;
849
850 PROCEDURE RegisterMod* (mod: Module);
851 VAR i: INTEGER; epoch: time.time_t; tm: time.struct_tm; ptm: time.Pstruct_tm;
852 BEGIN
853 mod.next := modList; modList := mod; mod.refcnt := 0; INCL(mod.opts, dyn); i := 0;
854 WHILE i < mod.nofimps DO
855 IF mod.imports[i] # NIL THEN INC(mod.imports[i].refcnt) END;
856 INC(i)
857 END;
858 epoch := time.time(NIL);
859 ptm := time.localtime_r(epoch, tm);
860 IF ptm # NIL THEN
861 mod.loadTime[0] := SHORT(tm.tm_year + 1900);
862 mod.loadTime[1] := SHORT(tm.tm_mon + 1);
863 mod.loadTime[2] := SHORT(tm.tm_mday);
864 mod.loadTime[3] := SHORT(tm.tm_hour);
865 mod.loadTime[4] := SHORT(tm.tm_min);
866 mod.loadTime[5] := SHORT(tm.tm_sec)
867 ELSE
868 mod.loadTime[0] := 0;
869 mod.loadTime[1] := 0;
870 mod.loadTime[2] := 0;
871 mod.loadTime[3] := 0;
872 mod.loadTime[4] := 0;
873 mod.loadTime[5] := 0
874 END;
875 IF ~(init IN mod.opts) THEN InitModule(mod) END
876 END RegisterMod;
877
878 PROCEDURE^ Collect*;
879
880 PROCEDURE UnloadMod* (mod: Module);
881 VAR i: INTEGER; t: Command;
882 BEGIN
883 IF mod.refcnt = 0 THEN
884 t := mod.term; mod.term := NIL;
885 IF t # NIL THEN t() END; (* terminate module *)
886 i := 0;
887 WHILE i < mod.nofptrs DO (* release global pointers *)
888 S.PUT(mod.varBase + mod.ptrs[i], 0); INC(i)
889 END;
890 Collect; (* call finalizers *)
891 i := 0;
892 WHILE i < mod.nofimps DO (* release imported modules *)
893 IF mod.imports[i] # NIL THEN DEC(mod.imports[i].refcnt) END;
894 INC(i)
895 END;
896 mod.refcnt := -1;
897 IF dyn IN mod.opts THEN (* release memory *)
898 InvalModMem(mod.data + mod.dsize - mod.refs, mod.refs)
899 END
900 END
901 END UnloadMod;
902
903 (* -------------------- dynamic procedure call --------------------- *)
904
905 PROCEDURE Call* (adr: INTEGER; sig: Signature; IN par: ARRAY OF INTEGER; n: INTEGER): LONGINT;
906 BEGIN
907 HALT(126); (* !!! *)
908 RETURN 0
909 END Call;
910
911 (* -------------------- reference information (portable) --------------------- *)
912
913 PROCEDURE RefCh (VAR ref: INTEGER; OUT ch: SHORTCHAR);
914 BEGIN
915 S.GET(ref, ch); INC(ref)
916 END RefCh;
917
918 PROCEDURE RefNum (VAR ref: INTEGER; OUT x: INTEGER);
919 VAR s, n: INTEGER; ch: SHORTCHAR;
920 BEGIN
921 s := 0; n := 0; RefCh(ref, ch);
922 WHILE ORD(ch) >= 128 DO INC(n, ASH(ORD(ch) - 128, s) ); INC(s, 7); RefCh(ref, ch) END;
923 x := n + ASH(ORD(ch) MOD 64 - ORD(ch) DIV 64 * 64, s)
924 END RefNum;
925
926 PROCEDURE RefName (VAR ref: INTEGER; OUT n: Utf8Name);
927 VAR i: INTEGER; ch: SHORTCHAR;
928 BEGIN
929 i := 0; RefCh(ref, ch);
930 WHILE ch # 0X DO n[i] := ch; INC(i); RefCh(ref, ch) END;
931 n[i] := 0X
932 END RefName;
933
934 PROCEDURE GetRefProc* (VAR ref: INTEGER; OUT adr: INTEGER; OUT name: Utf8Name);
935 VAR ch: SHORTCHAR;
936 BEGIN
937 S.GET(ref, ch);
938 WHILE ch >= 0FDX DO (* skip variables *)
939 INC(ref); RefCh(ref, ch);
940 IF ch = 10X THEN INC(ref, 4) END;
941 RefNum(ref, adr); RefName(ref, name); S.GET(ref, ch)
942 END;
943 WHILE (ch > 0X) & (ch < 0FCX) DO (* skip source refs *)
944 INC(ref); RefNum(ref, adr); S.GET(ref, ch)
945 END;
946 IF ch = 0FCX THEN INC(ref); RefNum(ref, adr); RefName(ref, name)
947 ELSE adr := 0
948 END
949 END GetRefProc;
950
951 PROCEDURE GetRefVar* (VAR ref: INTEGER; OUT mode, form: SHORTCHAR; OUT desc: Type; OUT adr: INTEGER; OUT name: Utf8Name);
952 BEGIN
953 S.GET(ref, mode); desc := NIL;
954 IF mode >= 0FDX THEN
955 mode := SHORT(CHR(ORD(mode) - 0FCH));
956 INC(ref); RefCh(ref, form);
957 IF form = 10X THEN
958 S.GET(ref, desc); INC(ref, 4); form := SHORT(CHR(16 + desc.id MOD 4))
959 END;
960 RefNum(ref, adr); RefName(ref, name)
961 ELSE
962 mode := 0X; form := 0X; adr := 0
963 END
964 END GetRefVar;
965
966 PROCEDURE SourcePos* (mod: Module; codePos: INTEGER): INTEGER;
967 VAR ref, pos, ad, d: INTEGER; ch: SHORTCHAR; name: Utf8Name;
968 BEGIN
969 IF mod # NIL THEN (* mf, 12.02.04 *)
970 ref := mod.refs; pos := 0; ad := 0; S.GET(ref, ch);
971 WHILE ch # 0X DO
972 WHILE (ch > 0X) & (ch < 0FCX) DO (* srcref: {dAdr,dPos} *)
973 INC(ad, ORD(ch)); INC(ref); RefNum(ref, d);
974 IF ad > codePos THEN RETURN pos END;
975 INC(pos, d); S.GET(ref, ch)
976 END;
977 IF ch = 0FCX THEN (* proc: 0FCX,Adr,Name *)
978 INC(ref); RefNum(ref, d); RefName(ref, name); S.GET(ref, ch);
979 IF (d > codePos) & (pos > 0) THEN RETURN pos END
980 END;
981 WHILE ch >= 0FDX DO (* skip variables: Mode, Form, adr, Name *)
982 INC(ref); RefCh(ref, ch);
983 IF ch = 10X THEN INC(ref, 4) END;
984 RefNum(ref, d); RefName(ref, name); S.GET(ref, ch)
985 END
986 END;
987 END;
988 RETURN -1
989 END SourcePos;
990
991 PROCEDURE LoadDll* (IN name: ARRAY OF CHAR; VAR ok: BOOLEAN);
992 VAR h: ADDRESS; file: Utf8Name; res: INTEGER;
993 BEGIN
994 StringToUtf8(name, file, res);
995 IF res = 0 THEN
996 h := dlfcn.dlopen(file, dlfcn.RTLD_LAZY + dlfcn.RTLD_GLOBAL);
997 ok := h # 0
998 ELSE
999 ok := FALSE
1000 END
1001 END LoadDll;
1002
1003 PROCEDURE ThisDllObj* (mode, fprint: INTEGER; IN dll, name: ARRAY OF CHAR): INTEGER;
1004 VAR h, p: ADDRESS; file, sym: Utf8Name; res: INTEGER; err: dlfcn.int;
1005 BEGIN
1006 StringToUtf8(dll, file, res);
1007 IF res = 0 THEN
1008 h := dlfcn.dlopen(file, dlfcn.RTLD_LAZY + dlfcn.RTLD_GLOBAL);
1009 IF h # 0 THEN
1010 StringToUtf8(name, sym, res);
1011 IF res = 0 THEN
1012 p := dlfcn.dlsym(h, sym)
1013 ELSE
1014 p := 0
1015 END;
1016 err := dlfcn.dlclose(h);
1017 ASSERT(err = 0, 100)
1018 ELSE
1019 p := 0
1020 END
1021 ELSE
1022 p := 0
1023 END;
1024 RETURN p
1025 END ThisDllObj;
1026
1027 (* -------------------- garbage collector (portable) --------------------- *)
1028
1029 PROCEDURE Mark (this: Block);
1030 VAR father, son: Block; tag: Type; flag, offset, actual: INTEGER;
1031 BEGIN
1032 IF ~ODD(S.VAL(INTEGER, this.tag)) THEN
1033 father := NIL;
1034 LOOP
1035 INC(S.VAL(INTEGER, this.tag));
1036 flag := S.VAL(INTEGER, this.tag) MOD 4;
1037 tag := S.VAL(Type, S.VAL(INTEGER, this.tag) - flag);
1038 IF flag >= 2 THEN actual := this.first; this.actual := actual
1039 ELSE actual := S.ADR(this.last)
1040 END;
1041 LOOP
1042 offset := tag.ptroffs[0];
1043 IF offset < 0 THEN
1044 INC(S.VAL(INTEGER, tag), offset + 4); (* restore tag *)
1045 IF (flag >= 2) & (actual < this.last) & (offset < -4) THEN (* next array element *)
1046 INC(actual, tag.size); this.actual := actual
1047 ELSE (* up *)
1048 this.tag := S.VAL(Type, S.VAL(INTEGER, tag) + flag);
1049 IF father = NIL THEN RETURN END;
1050 son := this; this := father;
1051 flag := S.VAL(INTEGER, this.tag) MOD 4;
1052 tag := S.VAL(Type, S.VAL(INTEGER, this.tag) - flag);
1053 offset := tag.ptroffs[0];
1054 IF flag >= 2 THEN actual := this.actual ELSE actual := S.ADR(this.last) END;
1055 S.GET(actual + offset, father); S.PUT(actual + offset, S.ADR(son.last));
1056 INC(S.VAL(INTEGER, tag), 4)
1057 END
1058 ELSE
1059 S.GET(actual + offset, son);
1060 IF son # NIL THEN
1061 DEC(S.VAL(INTEGER, son), 4);
1062 IF ~ODD(S.VAL(INTEGER, son.tag)) THEN (* down *)
1063 this.tag := S.VAL(Type, S.VAL(INTEGER, tag) + flag);
1064 S.PUT(actual + offset, father); father := this; this := son;
1065 EXIT
1066 END
1067 END;
1068 INC(S.VAL(INTEGER, tag), 4)
1069 END
1070 END
1071 END
1072 END
1073 END Mark;
1074
1075 PROCEDURE MarkGlobals;
1076 VAR m: Module; i, p: INTEGER;
1077 BEGIN
1078 m := modList;
1079 WHILE m # NIL DO
1080 IF m.refcnt >= 0 THEN
1081 i := 0;
1082 WHILE i < m.nofptrs DO
1083 S.GET(m.varBase + m.ptrs[i], p); INC(i);
1084 IF p # 0 THEN Mark(S.VAL(Block, p - 4)) END
1085 END
1086 END;
1087 m := m.next
1088 END
1089 END MarkGlobals;
1090
1091 PROCEDURE Next (b: Block): Block; (* next block in same cluster *)
1092 VAR size: INTEGER;
1093 BEGIN
1094 S.GET(S.VAL(INTEGER, b.tag) DIV 4 * 4, size);
1095 IF ODD(S.VAL(INTEGER, b.tag) DIV 2) THEN INC(size, b.last - S.ADR(b.last)) END;
1096 RETURN S.VAL(Block, S.VAL(INTEGER, b) + (size + 19) DIV 16 * 16)
1097 END Next;
1098
1099 PROCEDURE CheckCandidates;
1100 (* pre: nofcand > 0 *)
1101 VAR i, j, h, p, end: INTEGER; c: Cluster; blk, next: Block;
1102 BEGIN
1103 (* sort candidates (shellsort) *)
1104 h := 1; REPEAT h := h*3 + 1 UNTIL h > nofcand;
1105 REPEAT h := h DIV 3; i := h;
1106 WHILE i < nofcand DO p := candidates[i]; j := i;
1107 WHILE (j >= h) & (candidates[j-h] > p) DO
1108 candidates[j] := candidates[j-h]; j := j-h
1109 END;
1110 candidates[j] := p; INC(i)
1111 END
1112 UNTIL h = 1;
1113 (* sweep *)
1114 c := root; i := 0;
1115 WHILE c # NIL DO
1116 blk := S.VAL(Block, S.VAL(INTEGER, c) + 12);
1117 end := S.VAL(INTEGER, blk) + (c.size - 12) DIV 16 * 16;
1118 WHILE candidates[i] < S.VAL(INTEGER, blk) DO
1119 INC(i);
1120 IF i = nofcand THEN RETURN END
1121 END;
1122 WHILE S.VAL(INTEGER, blk) < end DO
1123 next := Next(blk);
1124 IF candidates[i] < S.VAL(INTEGER, next) THEN
1125 IF (S.VAL(INTEGER, blk.tag) # S.ADR(blk.last)) (* not a free block *)
1126 & (~strictStackSweep OR (candidates[i] = S.ADR(blk.last))) THEN
1127 Mark(blk)
1128 END;
1129 REPEAT
1130 INC(i);
1131 IF i = nofcand THEN RETURN END
1132 UNTIL candidates[i] >= S.VAL(INTEGER, next)
1133 END;
1134 IF (S.VAL(INTEGER, blk.tag) MOD 4 = 0) & (S.VAL(INTEGER, blk.tag) # S.ADR(blk.last))
1135 & (blk.tag.base[0] = NIL) & (blk.actual > 0) THEN (* referenced interface record *)
1136 Mark(blk)
1137 END;
1138 blk := next
1139 END;
1140 c := c.next
1141 END
1142 END CheckCandidates;
1143
1144 PROCEDURE MarkLocals;
1145 VAR sp, p, min, max: INTEGER; c: Cluster;
1146 BEGIN
1147 sp := S.ADR(sp); nofcand := 0; c := root;
1148 WHILE c.next # NIL DO c := c.next END;
1149 min := S.VAL(INTEGER, root); max := S.VAL(INTEGER, c) + c.size;
1150 WHILE sp < baseStack DO
1151 S.GET(sp, p);
1152 IF (p > min) & (p < max) & (~strictStackSweep OR (p MOD 16 = 0)) THEN
1153 candidates[nofcand] := p; INC(nofcand);
1154 IF nofcand = LEN(candidates) - 1 THEN CheckCandidates; nofcand := 0 END
1155 END;
1156 INC(sp, 4)
1157 END;
1158 candidates[nofcand] := max; INC(nofcand); (* ensure complete scan for interface mark*)
1159 IF nofcand > 0 THEN CheckCandidates END
1160 END MarkLocals;
1161
1162 PROCEDURE MarkFinObj;
1163 VAR f: FList;
1164 BEGIN
1165 wouldFinalize := FALSE;
1166 f := finalizers;
1167 WHILE f # NIL DO
1168 IF ~ODD(S.VAL(INTEGER, f.blk.tag)) THEN wouldFinalize := TRUE END;
1169 Mark(f.blk);
1170 f := f.next
1171 END;
1172 f := hotFinalizers;
1173 WHILE f # NIL DO IF ~ODD(S.VAL(INTEGER, f.blk.tag)) THEN wouldFinalize := TRUE END;
1174 Mark(f.blk);
1175 f := f.next
1176 END
1177 END MarkFinObj;
1178
1179 PROCEDURE CheckFinalizers;
1180 VAR f, g, h, k: FList;
1181 BEGIN
1182 f := finalizers; g := NIL;
1183 IF hotFinalizers = NIL THEN k := NIL
1184 ELSE
1185 k := hotFinalizers;
1186 WHILE k.next # NIL DO k := k.next END
1187 END;
1188 WHILE f # NIL DO
1189 h := f; f := f.next;
1190 IF ~ODD(S.VAL(INTEGER, h.blk.tag)) THEN
1191 IF g = NIL THEN finalizers := f ELSE g.next := f END;
1192 IF k = NIL THEN hotFinalizers := h ELSE k.next := h END;
1193 k := h; h.next := NIL
1194 ELSE g := h
1195 END
1196 END;
1197 h := hotFinalizers;
1198 WHILE h # NIL DO Mark(h.blk); h := h.next END
1199 END CheckFinalizers;
1200
1201 PROCEDURE ExecFinalizer (a, b, c: INTEGER);
1202 VAR f: FList; fin: PROCEDURE(this: ANYPTR);
1203 BEGIN
1204 f := S.VAL(FList, a);
1205 S.GET(S.VAL(INTEGER, f.blk.tag) - 4, fin); (* method 0 *)
1206 IF (fin # NIL) & (f.blk.tag.mod.refcnt >= 0) THEN fin(S.VAL(ANYPTR, S.ADR(f.blk.last))) END;
1207 END ExecFinalizer;
1208
1209 PROCEDURE^ Try* (h: TryHandler; a, b, c: INTEGER); (* COMPILER DEPENDENT *)
1210
1211 PROCEDURE CallFinalizers;
1212 VAR f: FList;
1213 BEGIN
1214 WHILE hotFinalizers # NIL DO
1215 f := hotFinalizers; hotFinalizers := hotFinalizers.next;
1216 Try(ExecFinalizer, S.VAL(INTEGER, f), 0, 0)
1217 END;
1218 wouldFinalize := FALSE
1219 END CallFinalizers;
1220
1221 PROCEDURE Insert (blk: FreeBlock; size: INTEGER); (* insert block in free list *)
1222 VAR i: INTEGER;
1223 BEGIN
1224 blk.size := size - 4; blk.tag := S.VAL(Type, S.ADR(blk.size));
1225 i := MIN(N - 1, (blk.size DIV 16));
1226 blk.next := free[i]; free[i] := blk
1227 END Insert;
1228
1229 PROCEDURE Sweep (dealloc: BOOLEAN);
1230 VAR cluster, last, c: Cluster; blk, next: Block; fblk, b, t: FreeBlock; end, i: INTEGER;
1231 BEGIN
1232 cluster := root; last := NIL; allocated := 0;
1233 i := N;
1234 REPEAT DEC(i); free[i] := sentinel UNTIL i = 0;
1235 WHILE cluster # NIL DO
1236 blk := S.VAL(Block, S.VAL(INTEGER, cluster) + 12);
1237 end := S.VAL(INTEGER, blk) + (cluster.size - 12) DIV 16 * 16;
1238 fblk := NIL;
1239 WHILE S.VAL(INTEGER, blk) < end DO
1240 next := Next(blk);
1241 IF ODD(S.VAL(INTEGER, blk.tag)) THEN
1242 IF fblk # NIL THEN
1243 Insert(fblk, S.VAL(INTEGER, blk) - S.VAL(INTEGER, fblk));
1244 fblk := NIL
1245 END;
1246 DEC(S.VAL(INTEGER, blk.tag)); (* unmark *)
1247 INC(allocated, S.VAL(INTEGER, next) - S.VAL(INTEGER, blk))
1248 ELSIF fblk = NIL THEN
1249 fblk := S.VAL(FreeBlock, blk)
1250 END;
1251 blk := next
1252 END;
1253 IF dealloc & (S.VAL(INTEGER, fblk) = S.VAL(INTEGER, cluster) + 12) THEN (* deallocate cluster *)
1254 c := cluster; cluster := cluster.next;
1255 IF last = NIL THEN root := cluster ELSE last.next := cluster END;
1256 FreeHeapMem(c)
1257 ELSE
1258 IF fblk # NIL THEN Insert(fblk, end - S.VAL(INTEGER, fblk)) END;
1259 last := cluster; cluster := cluster.next
1260 END
1261 END;
1262 (* reverse free list *)
1263 i := N;
1264 REPEAT
1265 DEC(i);
1266 b := free[i]; fblk := sentinel;
1267 WHILE b # sentinel DO t := b; b := t.next; t.next := fblk; fblk := t END;
1268 free[i] := fblk
1269 UNTIL i = 0
1270 END Sweep;
1271
1272 PROCEDURE Collect*;
1273 BEGIN
1274 IF root # NIL THEN
1275 CallFinalizers; (* trap cleanup *)
1276 MarkGlobals;
1277 MarkLocals;
1278 CheckFinalizers;
1279 Sweep(TRUE);
1280 CallFinalizers
1281 END
1282 END Collect;
1283
1284 PROCEDURE FastCollect*;
1285 BEGIN
1286 IF root # NIL THEN
1287 MarkGlobals;
1288 MarkLocals;
1289 MarkFinObj;
1290 Sweep(FALSE)
1291 END
1292 END FastCollect;
1293
1294 PROCEDURE WouldFinalize* (): BOOLEAN;
1295 BEGIN
1296 RETURN wouldFinalize
1297 END WouldFinalize;
1298
1299 (* --------------------- memory allocation (portable) -------------------- *)
1300
1301 PROCEDURE OldBlock (size: INTEGER): FreeBlock; (* size MOD 16 = 0 *)
1302 VAR b, l: FreeBlock; s, i: INTEGER;
1303 BEGIN
1304 s := size - 4;
1305 i := MIN(N - 1, s DIV 16);
1306 WHILE (i # N - 1) & (free[i] = sentinel) DO INC(i) END;
1307 b := free[i]; l := NIL;
1308 WHILE b.size < s DO l := b; b := b.next END;
1309 IF b # sentinel THEN
1310 IF l = NIL THEN free[i] := b.next ELSE l.next := b.next END
1311 ELSE b := NIL
1312 END;
1313 RETURN b
1314 END OldBlock;
1315
1316 PROCEDURE LastBlock (limit: INTEGER): FreeBlock; (* size MOD 16 = 0 *)
1317 VAR b, l: FreeBlock; s, i: INTEGER;
1318 BEGIN
1319 s := limit - 4;
1320 i := 0;
1321 REPEAT
1322 b := free[i]; l := NIL;
1323 WHILE (b # sentinel) & (S.VAL(INTEGER, b) + b.size # s) DO l := b; b := b.next END;
1324 IF b # sentinel THEN
1325 IF l = NIL THEN free[i] := b.next ELSE l.next := b.next END
1326 ELSE b := NIL
1327 END;
1328 INC(i)
1329 UNTIL (b # NIL) OR (i = N);
1330 RETURN b
1331 END LastBlock;
1332
1333 PROCEDURE NewBlock (size: INTEGER): Block;
1334 VAR tsize, a, s: INTEGER; b: FreeBlock; new, c: Cluster; r: Reducer;
1335 BEGIN
1336 ASSERT(size >= 0, 20);
1337 IF size > MAX(INTEGER) - 19 THEN RETURN NIL END;
1338 tsize := (size + 19) DIV 16 * 16;
1339 b := OldBlock(tsize); (* 1) search for free block *)
1340 IF b = NIL THEN
1341 FastCollect; b := OldBlock(tsize); (* 2) collect *)
1342 IF b = NIL THEN
1343 Collect; b := OldBlock(tsize); (* 2a) fully collect *)
1344 END;
1345 IF b = NIL THEN
1346 AllocHeapMem(tsize + 12, new); (* 3) allocate new cluster *)
1347 IF new # NIL THEN
1348 IF (root = NIL) OR (S.VAL(INTEGER, new) < S.VAL(INTEGER, root)) THEN
1349 new.next := root; root := new
1350 ELSE
1351 c := root;
1352 WHILE (c.next # NIL) & (S.VAL(INTEGER, new) > S.VAL(INTEGER, c.next)) DO c := c.next END;
1353 new.next := c.next; c.next := new
1354 END;
1355 b := S.VAL(FreeBlock, S.VAL(INTEGER, new) + 12);
1356 b.size := (new.size - 12) DIV 16 * 16 - 4
1357 ELSE
1358 RETURN NIL (* 4) give up *)
1359 END
1360 END
1361 END;
1362 (* b # NIL *)
1363 a := b.size + 4 - tsize;
1364 IF a > 0 THEN Insert(S.VAL(FreeBlock, S.VAL(INTEGER, b) + tsize), a) END;
1365 IF size > 0 THEN Erase(S.ADR(b.size), (size + 3) DIV 4) END;
1366 INC(allocated, tsize);
1367 RETURN S.VAL(Block, b)
1368 END NewBlock;
1369
1370 PROCEDURE Allocated* (): INTEGER;
1371 BEGIN
1372 RETURN allocated
1373 END Allocated;
1374
1375 PROCEDURE Used* (): INTEGER;
1376 BEGIN
1377 RETURN used
1378 END Used;
1379
1380 PROCEDURE Root* (): INTEGER;
1381 BEGIN
1382 RETURN S.VAL(INTEGER, root)
1383 END Root;
1384
1385 (* -------------------- Trap Handling --------------------- *)
1386
1387 PROCEDURE Start* (code: Command);
1388 VAR res: setjmp.int;
1389 BEGIN
1390 restart := code;
1391 S.GETREG(SP, baseStack);
1392 res := setjmp.sigsetjmp(startEnv, 1);
1393 restart
1394 END Start;
1395
1396 PROCEDURE Quit* (exitCode: INTEGER);
1397 VAR m: Module; term: Command; t: BOOLEAN;
1398 BEGIN
1399 trapViewer := NIL; trapChecker := NIL; restart := NIL;
1400 t := terminating; terminating := TRUE; m := modList;
1401 WHILE m # NIL DO (* call terminators *)
1402 IF ~static OR ~t THEN
1403 term := m.term; m.term := NIL;
1404 IF term # NIL THEN term() END
1405 END;
1406 m := m.next
1407 END;
1408 CallFinalizers;
1409 hotFinalizers := finalizers; finalizers := NIL;
1410 CallFinalizers;
1411 stdlib.exit(exitCode)
1412 END Quit;
1413
1414 PROCEDURE FatalError* (id: INTEGER; str: ARRAY OF CHAR);
1415 VAR res: stdio.int; title: ARRAY 16 OF CHAR; text: ARRAY 256 OF SHORTCHAR;
1416 BEGIN
1417 title := "Error xy";
1418 title[6] := CHR(id DIV 10 + ORD("0"));
1419 title[7] := CHR(id MOD 10 + ORD("0"));
1420 res := unistd.write(2, S.ADR(title), 8);
1421 stdlib.abort
1422 END FatalError;
1423
1424 PROCEDURE DefaultTrapViewer;
1425 VAR out: ARRAY 2048 OF SHORTCHAR; a, b, c, len, ref, end: INTEGER; mod: Module;
1426 modName, name: Name; n: Utf8Name; res: unistd.int;
1427
1428 PROCEDURE WriteString (IN s: ARRAY OF SHORTCHAR);
1429 VAR i: INTEGER;
1430 BEGIN
1431 i := 0;
1432 WHILE (len < LEN(out) - 1) & (s[i] # 0X) DO out[len] := s[i]; INC(i); INC(len) END
1433 END WriteString;
1434
1435 PROCEDURE WriteHex (x, n: INTEGER);
1436 VAR i, y: INTEGER;
1437 BEGIN
1438 IF len + n < LEN(out) THEN
1439 i := len + n - 1;
1440 WHILE i >= len DO
1441 y := x MOD 16; x := x DIV 16;
1442 IF y > 9 THEN y := y + (ORD("A") - ORD("0") - 10) END;
1443 out[i] := SHORT(CHR(y + ORD("0"))); DEC(i)
1444 END;
1445 INC(len, n)
1446 END
1447 END WriteHex;
1448
1449 PROCEDURE WriteLn;
1450 BEGIN
1451 IF len < LEN(out) - 1 THEN out[len] := 0AX; INC(len) END
1452 END WriteLn;
1453
1454 BEGIN
1455 len := 0;
1456 WriteString("====== ");
1457 IF err = 129 THEN WriteString("invalid with")
1458 ELSIF err = 130 THEN WriteString("invalid case")
1459 ELSIF err = 131 THEN WriteString("function without return")
1460 ELSIF err = 132 THEN WriteString("type guard")
1461 ELSIF err = 133 THEN WriteString("implied type guard")
1462 ELSIF err = 134 THEN WriteString("value out of range")
1463 ELSIF err = 135 THEN WriteString("index out of range")
1464 ELSIF err = 136 THEN WriteString("string too long")
1465 ELSIF err = 137 THEN WriteString("stack overflow")
1466 ELSIF err = 138 THEN WriteString("integer overflow")
1467 ELSIF err = 139 THEN WriteString("division by zero")
1468 ELSIF err = 140 THEN WriteString("infinite real result")
1469 ELSIF err = 141 THEN WriteString("real underflow")
1470 ELSIF err = 142 THEN WriteString("real overflow")
1471 ELSIF err = 143 THEN WriteString("undefined real result")
1472 ELSIF err = 144 THEN WriteString("not a number")
1473 ELSIF err = 200 THEN WriteString("keyboard interrupt")
1474 ELSIF err = 201 THEN WriteString("NIL dereference")
1475 ELSIF err = 202 THEN WriteString("illegal instruction: ");
1476 WriteHex(val, 4)
1477 ELSIF err = 203 THEN WriteString("illegal memory read [ad = ");
1478 WriteHex(val, 8); WriteString("]")
1479 ELSIF err = 204 THEN WriteString("illegal memory write [ad = ");
1480 WriteHex(val, 8); WriteString("]")
1481 ELSIF err = 205 THEN WriteString("illegal execution [ad = ");
1482 WriteHex(val, 8); WriteString("]")
1483 ELSIF err = 257 THEN WriteString("out of memory")
1484 ELSIF err = 10001H THEN WriteString("bus error")
1485 ELSIF err = 10002H THEN WriteString("address error")
1486 ELSIF err = 10007H THEN WriteString("fpu error")
1487 ELSIF err < 0 THEN WriteString("exception #"); WriteHex(-err, 2)
1488 ELSE err := err DIV 100 * 256 + err DIV 10 MOD 10 * 16 + err MOD 10;
1489 WriteString("trap #"); WriteHex(err, 3)
1490 END;
1491 WriteString(" ======");
1492 a := pc; b := fp; c := 12;
1493 REPEAT
1494 WriteLn; WriteString("- ");
1495 mod := modList;
1496 WHILE (mod # NIL) & ((a < mod.code) OR (a >= mod.code + mod.csize)) DO mod := mod.next END;
1497 IF mod # NIL THEN
1498 DEC(a, mod.code);
1499 IF mod.refcnt >= 0 THEN
1500 GetModName(mod, modName); WriteString(SHORT(modName)); ref := mod.refs;
1501 REPEAT GetRefProc(ref, end, n) UNTIL (end = 0) OR (a < end);
1502 IF a < end THEN
1503 Utf8ToString(n, name, res); WriteString("."); WriteString(SHORT(name))
1504 END
1505 ELSE
1506 GetModName(mod, modName); WriteString("("); WriteString(SHORT(modName)); WriteString(")")
1507 END;
1508 WriteString(" ")
1509 END;
1510 WriteString("(pc="); WriteHex(a, 8);
1511 WriteString(", fp="); WriteHex(b, 8); WriteString(")");
1512 IF (b >= sp) & (b < stack) THEN
1513 S.GET(b+4, a); (* stacked pc *)
1514 S.GET(b, b); (* dynamic link *)
1515 DEC(c)
1516 ELSE c := 0
1517 END
1518 UNTIL c = 0;
1519 out[len] := 0X;
1520 res := unistd.write(2, S.ADR(out), len)
1521 END DefaultTrapViewer;
1522
1523 PROCEDURE TrapCleanup;
1524 VAR t: TrapCleaner;
1525 BEGIN
1526 WHILE trapStack # NIL DO
1527 t := trapStack; trapStack := trapStack.next; t.Cleanup
1528 END;
1529 IF (trapChecker # NIL) & (err # 128) THEN trapChecker END
1530 END TrapCleanup;
1531
1532 PROCEDURE SetTrapGuard* (on: BOOLEAN);
1533 BEGIN
1534 guarded := on
1535 END SetTrapGuard;
1536
1537 PROCEDURE Try* (h: TryHandler; a, b, c: INTEGER);
1538 VAR oldIsTry: BOOLEAN; oldTryEnv: setjmp.jmp_buf; res: setjmp.int;
1539 BEGIN
1540 oldIsTry := isTry; oldTryEnv := tryEnv;
1541 isTry := TRUE;
1542 res := setjmp._setjmp(tryEnv);
1543 IF res = 0 THEN h(a, b, c) END;
1544 isTry := oldIsTry; tryEnv := oldTryEnv
1545 END Try;
1546
1547 PROCEDURE Trap* (n: INTEGER);
1548 BEGIN
1549 IF trapped THEN
1550 DefaultTrapViewer;
1551 IF ~secondTrap THEN trapped := FALSE; secondTrap := TRUE END
1552 END;
1553 IF n >= 0 THEN err := n
1554 ELSE err := -n + 128
1555 END;
1556 pc := 0; sp := 0; fp := 0; stack := 0; val := 0;
1557 INC(trapCount);
1558 (* !!! InitFPU *)
1559 TrapCleanup;
1560 IF isTry THEN
1561 setjmp._longjmp(tryEnv, 1)
1562 END;
1563 IF err = 128 THEN (* do nothing *)
1564 ELSIF (trapViewer # NIL) & (restart # NIL) & ~trapped & ~guarded THEN
1565 trapped := TRUE; trapViewer()
1566 ELSE DefaultTrapViewer
1567 END;
1568 trapped := FALSE; secondTrap := FALSE;
1569 IF restart # NIL THEN
1570 setjmp.siglongjmp(startEnv, 1)
1571 END;
1572 stdlib.abort
1573 END Trap;
1574
1575 PROCEDURE [ccall] TrapHandler (signo: signal.int; IN info: signal.siginfo_t; context: ADDRESS);
1576 VAR res: signal.int;
1577 BEGIN
1578 IF trapped THEN
1579 DefaultTrapViewer;
1580 IF ~secondTrap THEN trapped := FALSE; secondTrap := TRUE END
1581 END;
1582 err := -signo; pc := 0; sp := 0; fp := 0; stack := baseStack; val := 0;
1583 CASE signo OF
1584 | signal.SIGFPE:
1585 val := info.si_code;
1586 pc := info.info.sigfpe.si_addr;
1587 CASE info.si_code OF
1588 | signal.FPE_INTDIV: err := 139 (* division by zero *)
1589 | signal.FPE_INTOVF: err := 138 (* integer overflow *)
1590 | signal.FPE_FLTDIV: err := 140 (* fpu: division by zero *)
1591 | signal.FPE_FLTOVF: err := 142 (* fpu: overflow *)
1592 | signal.FPE_FLTUND: err := 141 (* fpu: underflow *)
1593 (* !!! | signal.FPE_FLTRES: err := ??? (* fpu: *) *)
1594 | signal.FPE_FLTINV: err := 143 (* val := opcode *) (* fpu: invalid op *)
1595 (* !!! | signal.FPE_FLTSUB: err := ??? (* fpu: *) *)
1596 ELSE (* unknown *)
1597 END
1598 | signal.SIGINT:
1599 val := info.si_code;
1600 err := 200 (* keyboard interrupt *)
1601 | signal.SIGSEGV:
1602 val := info.info.sigsegv.si_addr;
1603 err := 203 (* illigal read *)
1604 | signal.SIGBUS:
1605 val := info.info.sigbus.si_addr;
1606 err := 10001H (* bus error *)
1607 | signal.SIGILL:
1608 pc := info.info.sigill.si_addr;
1609 err := 202; (* illigal instruction *)
1610 IF IsReadable(pc, pc + 4) THEN
1611 S.GET(pc, val)
1612 (* !!! err := halt code *)
1613 END;
1614 ELSE (* unknown *)
1615 END;
1616 INC(trapCount);
1617 (* !!! InitFPU *)
1618 TrapCleanup;
1619 IF isTry THEN
1620 setjmp._longjmp(tryEnv, 1)
1621 END;
1622 IF err = 128 THEN (* do nothing *)
1623 ELSIF (trapViewer # NIL) & (restart # NIL) & ~trapped & ~guarded THEN
1624 trapped := TRUE; trapViewer()
1625 ELSE DefaultTrapViewer
1626 END;
1627 trapped := FALSE; secondTrap := FALSE;
1628 IF restart # NIL THEN
1629 setjmp.siglongjmp(startEnv, 1)
1630 END;
1631 stdlib.abort
1632 END TrapHandler;
1633
1634 (* -------------------- Initialization --------------------- *)
1635
1636 PROCEDURE InstallTrap (signo: signal.int);
1637 VAR act: signal.struct_sigaction; res: signal.int;
1638 BEGIN
1639 act.handler.sa_handler := NIL;
1640 res := signal.sigemptyset(act.sa_mask);
1641 act.sa_flags := signal.SA_NODEFER + signal.SA_SIGINFO;
1642 act.handler.sa_sigaction := TrapHandler;
1643 res := signal.sigaction(signo, act, NIL);
1644 END InstallTrap;
1645
1646 PROCEDURE InstallTrapVectors;
1647 BEGIN
1648 InstallTrap(signal.SIGFPE);
1649 InstallTrap(signal.SIGINT);
1650 InstallTrap(signal.SIGSEGV);
1651 InstallTrap(signal.SIGBUS);
1652 InstallTrap(signal.SIGILL)
1653 END InstallTrapVectors;
1654
1655 PROCEDURE RemoveTrapVectors;
1656 END RemoveTrapVectors;
1657
1658 PROCEDURE Init;
1659 VAR i: INTEGER;
1660 BEGIN
1661 pagesize := unistd.sysconf(unistd._SC_PAGESIZE);
1662
1663 (* init heap *)
1664 allocated := 0; total := 0; used := 0;
1665 sentinelBlock.size := MAX(INTEGER);
1666 sentinel := S.ADR(sentinelBlock);
1667 i := N;
1668 REPEAT DEC(i); free[i] := sentinel UNTIL i = 0;
1669
1670 IF ~inDll THEN
1671 InstallTrapVectors
1672 END;
1673
1674 (* !!! InitFPU *)
1675 IF ~static THEN
1676 InitModule(modList);
1677 IF ~inDll THEN Quit(1) END
1678 END
1679 END Init;
1680
1681 BEGIN
1682 IF modList = NIL THEN (* only once *)
1683 S.GETREG(SP, baseStack);
1684 S.GET(baseStack + 16, argc);
1685 argv := S.VAL(ArrStrPtr, baseStack + 20);
1686 S.GETREG(ML, modList); (* linker loads module list to BX *)
1687 static := init IN modList.opts;
1688 inDll := dll IN modList.opts;
1689 Init
1690 END
1691 CLOSE
1692 IF ~terminating THEN
1693 terminating := TRUE;
1694 Quit(0)
1695 END
1696 END Kernel.
A command line Component Pascal Compiler
[25/02/2024 19:55:35]
DEADSOFTWARE 2012-2024