LINUX386.Files.Mod.txt

MODULE Files;  (*NW 11.1.86 / 22.9.93 / 25.5.95 / 25.12.95 / 15.8.2013*)
  IMPORT SYSTEM, Kernel, FileDir;

  (*A file consists of a sequence of pages. The first page
    contains the header. Part of the header is the page table, an array
    of disk addresses to the pages. A file is referenced through riders.
    A rider indicates a current position and refers to a file*)

  CONST MaxBufs    = 4;
      SS        = FileDir.SectorSize;

  TYPE  DiskAdr = INTEGER;
      File*    = POINTER TO FileDesc;
      Buffer  = POINTER TO BufferRecord;

    Rider* =
      RECORD eof*: BOOLEAN;
        res*: INTEGER;
        file: File;
        apos, bpos: INTEGER;
        buf: Buffer
      END ;

    FileDesc =
      RECORD next: INTEGER; (*list of files invisible to the GC*)
        nofbufs, aleng, bleng: INTEGER;
        modH, registered: BOOLEAN;
        firstbuf: Buffer;
        sechint: INTEGER; (*linux file descriptor*)
        name: FileDir.FileName;
        date: INTEGER;
        ext:  ARRAY FileDir.ExTabSize OF File; (*keep for symbol file compatibility*)
        sec: ARRAY FileDir.SecTabSize OF INTEGER (*device/inode, pad*)
      END ;

    BufferRecord =
      RECORD apos, lim: INTEGER;
        mod: BOOLEAN;
        next: Buffer;
        data: FileDir.DataSector
      END ;

    (*aleng * SS + bleng = length (including header)
      apos * SS + bpos = current position
      0 <= bpos <= lim <= SS
      0 <= apos <= aleng < PgTabSize
      (apos < aleng) & (lim = SS) OR (apos = aleng) *)

  VAR root: INTEGER (*File*);  (*list of open files*)
    syscall1: PROCEDURE (eax: INTEGER): INTEGER;
    syscall2: PROCEDURE (eax, ebx: INTEGER): INTEGER;
    syscall3: PROCEDURE (eax, ebx, ecx: INTEGER): INTEGER;
    syscall4: PROCEDURE (eax, ebx, ecx, edx: INTEGER): INTEGER;
    syscall5: PROCEDURE (eax, ebx, ecx, edx, esi: INTEGER): INTEGER;
    syscall6: PROCEDURE (eax, ebx, ecx, edx, esi, edi: INTEGER): INTEGER;

  PROCEDURE UnixToClock(t: INTEGER): INTEGER;
    VAR z, era, y, doe, yoe, doy, mp, second, minute, hour, day, month, year: INTEGER;
  BEGIN
    z := (t DIV 86400) + 719468;
    IF z >= 0 THEN era := z DIV 146097 ELSE era := (z - 146096) DIV 146097 END;
    doe := z - era*146097;
    yoe := (doe - doe DIV 1460 + doe DIV 36524 - doe DIV 146096) DIV 365;
    doy := doe - (365*yoe + yoe DIV 4 - yoe DIV 100);
    mp := (5*doy + 2) DIV 153;
    y := yoe + era*400;
    day := doy - (153*mp + 2) DIV 5 + 1;
    IF mp < 10 THEN month := mp + 3 ELSE month := mp - 9 END;
    IF month <= 2 THEN year := y + 1 ELSE year := y END;
    year := year MOD 100;
    hour := t DIV 3600 MOD 24;
    minute := t DIV 60 MOD 60;
    second := t MOD 60;
    RETURN ((((year*10H + month)*20H + day)*20H + hour)*40H + minute)*40H + second
  END UnixToClock;

  PROCEDURE Decimal (VAR s: ARRAY OF CHAR; j, x: INTEGER);
    VAR i: INTEGER; x0: LONGINT; a: ARRAY 12 OF CHAR;
  BEGIN
    IF ROR(x, 31) = 1 THEN a := "8463847412-"; i := 12
    ELSE i := 0;
      IF x < 0 THEN x0 := -x ELSE x0 := x END;
      REPEAT
        a[i] := CHR(x0 MOD 10 + 30H); x0 := x0 DIV 10; INC(i)
      UNTIL x0 = 0;
      IF x < 0 THEN a[i] := "-"; INC(i) END
    END;
    REPEAT DEC(i); s[j] := a[i]; INC(j) UNTIL i = 0; s[j] := 0X
  END Decimal;

  PROCEDURE ThisFile(id: ARRAY OF INTEGER): File; (*get existing file by device/inode pair*)
    VAR f: File;
  BEGIN
    f := SYSTEM.VAL(File, root);
    WHILE (f # NIL) & ((f.sec[0] # id[0]) OR (f.sec[1] # id[1]) OR (f.sec[2] # id[2]) OR (f.sec[3] # id[3])) DO
      f := SYSTEM.VAL(File, f.next)
    END;
    RETURN f
  END ThisFile;

  PROCEDURE Check(s: ARRAY OF CHAR;
        VAR name: FileDir.FileName; VAR res: INTEGER);
    VAR i: INTEGER; ch: CHAR;
  BEGIN ch := s[0]; i := 0;
    IF (ch >= "A") & (ch <= "Z") OR (ch >= "a") & (ch <= "z") THEN
      REPEAT name[i] := ch; INC(i); ch := s[i]
      UNTIL ~((ch >= "0") & (ch <= "9") OR (ch >= "A") & (ch <= "Z")
        OR (ch >= "a") & (ch <= "z") OR (ch = ".")) OR (i = FileDir.FnLength);
      IF i = FileDir.FnLength THEN res := 4
      ELSIF ch = 0X THEN res := 0;
        WHILE i < FileDir.FnLength DO name[i] := 0X; INC(i) END
      ELSE res := 5
      END
    ELSIF ch = 0X THEN name[0] := 0X; res := -1
    ELSE res := 3
    END
  END Check;

  PROCEDURE Old*(name: ARRAY OF CHAR): File;
    VAR res, fd: INTEGER;
      f: File;
      buf: Buffer;
      ST: ARRAY 24 OF INTEGER;
      namebuf: FileDir.FileName;
  BEGIN f := NIL; Check(name, namebuf, res);
    IF res = 0 THEN
      REPEAT res := syscall3(195, SYSTEM.ADR(namebuf), SYSTEM.ADR(ST)) UNTIL res # -4; (*stat64*)
      IF res = 0 THEN ST[2] := ST[22]; ST[3] := ST[23]; f := ThisFile(ST) END ;
      IF f = NIL THEN (*file not yet present*)
        REPEAT fd := syscall4(5, SYSTEM.ADR(namebuf), 2, 0) UNTIL fd # -4; (*open(name,O_RDWR)*)
        IF fd >= 0 THEN
          REPEAT res := syscall3(197, fd, SYSTEM.ADR(ST)) UNTIL res # -4; (*fstat64*)
          IF (res = 0) & (ST[12] = 0) & (ST[11] >= 0) THEN (*valid size*)
            ST[2] := ST[22]; ST[3] := ST[23]; f := ThisFile(ST);
            IF f = NIL THEN (*file not yet present*)
              NEW(buf); buf.apos := 0; buf.next := buf; buf.mod := FALSE;
              REPEAT res := syscall6(180, fd, SYSTEM.ADR(buf.data), SS, 0, 0) UNTIL res # -4; (*pread64*)
              IF (res = SS) OR (res = ST[11]) THEN (*readable*)
                NEW(f); f.aleng := ST[11] DIV SS; f.bleng := ST[11] MOD SS; f.date := UnixToClock(ST[20]);
                IF f.aleng = 0 THEN buf.lim := f.bleng ELSE buf.lim := SS END ;
                f.firstbuf := buf; f.nofbufs := 1; f.name := namebuf; f.registered := TRUE;
                f.sec[0] := ST[0]; f.sec[1] := ST[1]; f.sec[2] := ST[22]; f.sec[3] := ST[23];
                f.sechint := fd; f.modH := FALSE; f.next := root; root := SYSTEM.VAL(INTEGER, f)
              ELSE res := syscall2(6, fd) (*close*)
              END
            ELSE res := syscall2(6, fd) (*close*)
            END
          ELSE res := syscall2(6, fd) (*close*)
          END
        END
      END
    END ;
    RETURN f
  END Old;

  PROCEDURE New*(name: ARRAY OF CHAR): File;
    VAR res, fd, flags: INTEGER;
      f: File;
      buf: Buffer;
      ST: ARRAY 24 OF INTEGER;
      namebuf: FileDir.FileName;
  BEGIN f := NIL; Check(name, namebuf, res);
    IF res <= 0 THEN (*open(namebuf,flags,O_IRUGO|O_IWUGO)*)
      flags := 410002H; IF res = -1 THEN INC(flags, 80H) END; (*O_RDWR O_TMPFILE [O_EXCL]*)
      REPEAT fd := syscall4(5, SYSTEM.ADR("."), flags, 1B6H) UNTIL fd # -4; 
      IF fd >= 0 THEN
        REPEAT res := syscall3(197, fd, SYSTEM.ADR(ST)) UNTIL res # -4; (*fstat64*)
        IF res = 0 THEN
          NEW(buf); buf.apos := 0; buf.mod := TRUE; buf.lim := 0; buf.next := buf;
          NEW(f); f.aleng := 0; f.bleng := 0; f.modH := TRUE;
          f.registered := FALSE; f.date := UnixToClock(ST[21]);
          f.firstbuf := buf; f.nofbufs := 1; f.name := namebuf; f.sechint := fd;
          f.sec[0] := ST[0]; f.sec[1] := ST[1]; f.sec[2] := ST[22]; f.sec[3] := ST[23];
          f.next := root; root := SYSTEM.VAL(INTEGER, f)
        ELSE res := syscall2(6, fd) (*close*)
        END
      END
    END ;
    RETURN f
  END New;

  PROCEDURE ReadBuf(f: File; buf: Buffer; pos: INTEGER);
    VAR res: INTEGER;
  BEGIN
    REPEAT (*pread64*)
      res := syscall6(180, f.sechint, SYSTEM.ADR(buf.data), SS, pos * SS, 0)
    UNTIL res # -4;
    ASSERT(res >= 0); buf.lim := res;
    ASSERT((res = SS) OR (res = f.bleng));
    buf.apos := pos; buf.mod := FALSE
  END ReadBuf;

  PROCEDURE WriteBuf(f: File; buf: Buffer);
    VAR res, size: INTEGER;
  BEGIN size := buf.apos * SS + buf.lim;
    IF size > f.aleng * SS + f.bleng THEN (*extend file*)
      REPEAT res := syscall3(93, f.sechint, size) UNTIL res # -4; (*ftruncate*)
      ASSERT(res = 0)
    END;
    REPEAT (*pwrite64*)
      res := syscall6(181, f.sechint, SYSTEM.ADR(buf.data), buf.lim, buf.apos * SS, 0)
    UNTIL res # -4;
    ASSERT(res = buf.lim);
    f.modH := TRUE; buf.mod := FALSE
  END WriteBuf;

  PROCEDURE Buf(f: File; pos: INTEGER): Buffer;
    VAR buf: Buffer;
  BEGIN buf := f.firstbuf;
    WHILE (buf.apos # pos) & (buf.next # f.firstbuf) DO buf := buf.next END ;
    IF buf.apos # pos THEN buf := NIL END ;
    RETURN buf
  END Buf;

  PROCEDURE GetBuf(f: File; pos: INTEGER): Buffer;
    VAR buf: Buffer;
  BEGIN buf := f.firstbuf;
    WHILE (buf.apos # pos) & (buf.next # f.firstbuf) DO buf := buf.next END ;
    IF buf.apos # pos THEN 
      IF f.nofbufs < MaxBufs THEN  (*allocate new buffer*)
        NEW(buf); buf.next := f.firstbuf.next; f.firstbuf.next := buf; INC(f.nofbufs)
      ELSE (*reuse a buffer*) f.firstbuf := buf;
        IF buf.mod THEN WriteBuf(f, buf) END
      END ;
      IF pos <= f.aleng THEN ReadBuf(f, buf, pos) ELSE buf.apos := pos; buf.lim := 0; buf.mod := FALSE END
    END ;
    RETURN buf
  END GetBuf;

  PROCEDURE Unbuffer(f: File);
    VAR res: INTEGER;
      buf: Buffer;
  BEGIN buf := f.firstbuf;
    REPEAT
      IF buf.mod THEN WriteBuf(f, buf) END ;
      buf := buf.next
    UNTIL buf = f.firstbuf;
    IF f.modH THEN
      REPEAT res := syscall2(118, f.sechint) UNTIL res # -4; (*fsync*)
      ASSERT(res = 0); f.modH := FALSE
    END
  END Unbuffer;

  PROCEDURE Register*(f: File);
    VAR res, time: INTEGER; fd, temp: ARRAY 32 OF CHAR;
  BEGIN
    IF (f # NIL) & (f.name[0] # 0X) THEN
      Unbuffer(f);
      IF ~f.registered THEN
        fd := "/proc/self/fd/"; Decimal(fd, 14, f.sechint); res := 0;
        REPEAT (*linkat(AT_FDCWD, "/proc/self/fd/xxx", AT_FDCWD, f.name, AT_SYMLINK_FOLLOW)*)
          res := syscall6(303, -100, SYSTEM.ADR(fd), -100, SYSTEM.ADR(f.name), 400H)
        UNTIL res # -4;
        IF res = -17 THEN (*EEXIST*)
          time := Kernel.Time();
          REPEAT (*register under temp name*)
            temp := ".tmp"; Decimal(temp, 4, time MOD 10000); INC(time);
            REPEAT (*linkat(AT_FDCWD, "/proc/self/fd/xxx", AT_FDCWD, f.name, AT_SYMLINK_FOLLOW)*)
              res := syscall6(303, -100, SYSTEM.ADR(fd), -100, SYSTEM.ADR(temp), 400H)
            UNTIL res # -4
          UNTIL res # -17;
          ASSERT(res = 0);
          REPEAT res := syscall3(38, SYSTEM.ADR(temp), SYSTEM.ADR(f.name)) UNTIL res # -4; (*rename*)
          IF res # 0 THEN (*cleanup*)
            REPEAT res := syscall2(10, SYSTEM.ADR(temp)) UNTIL res # -4; (*unlink*)
            ASSERT(FALSE)
          END
        END;
        ASSERT(res = 0);
        f.registered := TRUE;
        REPEAT res := syscall2(118, f.sechint) UNTIL res # -4; (*fsync*)
        ASSERT(res = 0)
      END
    END
  END Register;

  PROCEDURE Close*(f: File);
  BEGIN
    IF f # NIL THEN Unbuffer(f) END
  END Close;

  PROCEDURE Purge*(f: File);
    VAR res: INTEGER;
  BEGIN
    IF f # NIL THEN f.aleng := 0; f.bleng := 0;
      REPEAT res := syscall3(93, f.sechint, 0) UNTIL res # -4; (*ftruncate*)
      ASSERT(res = 0)
    END
  END Purge;

  PROCEDURE Delete*(name: ARRAY OF CHAR; VAR res: INTEGER);
    VAR res0: INTEGER;
        namebuf: FileDir.FileName;
  BEGIN Check(name, namebuf, res);
    IF res = 0 THEN
      REPEAT res0 := syscall2(10, SYSTEM.ADR(name)) UNTIL res0 # -4; (*unlink*)
      IF res0 # 0 THEN res := 2 END
    END
  END Delete;

  PROCEDURE Rename*(old, new: ARRAY OF CHAR; VAR res: INTEGER);
    VAR res0: INTEGER;
        oldbuf, newbuf: FileDir.FileName;
  BEGIN Check(old, oldbuf, res);
    IF res = 0 THEN
      Check(new, newbuf, res);
      IF res = 0 THEN
        REPEAT res0 := syscall3(38, SYSTEM.ADR(oldbuf), SYSTEM.ADR(newbuf)) UNTIL res0 # -4; (*rename*)
        IF res0 # 0 THEN res := 2 END
      END
    END
  END Rename;

  PROCEDURE Length*(f: File): INTEGER;
  BEGIN RETURN f.aleng * SS + f.bleng
  END Length;

  PROCEDURE Date*(f: File): INTEGER;
  BEGIN RETURN f.date
  END Date;

  (*---------------------------Read---------------------------*)

  PROCEDURE Set*(VAR r: Rider; f: File; pos: INTEGER);
    VAR a, b: INTEGER;
  BEGIN  r.eof := FALSE; r.res := 0;
    IF f # NIL THEN
      IF pos < 0 THEN a := 0; b := 0
      ELSIF pos < f.aleng * SS + f.bleng THEN
        a := pos DIV SS; b := pos MOD SS;
      ELSE a := f.aleng; b := f.bleng
      END ;
      r.file := f; r.apos := a; r.bpos := b; r.buf := f.firstbuf
    ELSE r.file:= NIL
    END
  END Set;

  PROCEDURE Pos*(VAR r: Rider): INTEGER;
  BEGIN RETURN r.apos * SS + r.bpos
  END Pos;

  PROCEDURE Base*(VAR r: Rider): File;
  BEGIN RETURN r.file
  END Base;

  PROCEDURE ReadByte*(VAR r: Rider; VAR x: BYTE);
    VAR buf: Buffer;
  BEGIN
    IF r.apos # r.buf.apos THEN r.buf := GetBuf(r.file, r.apos) END ;
    IF r.bpos < r.buf.lim THEN x := r.buf.data[r.bpos]; INC(r.bpos)
    ELSIF r.apos < r.file.aleng THEN
      INC(r.apos); buf := Buf(r.file, r.apos);
      IF buf = NIL THEN
        IF r.buf.mod THEN WriteBuf(r.file, r.buf) END ;
        ReadBuf(r.file, r.buf, r.apos)
      ELSE r.buf := buf
      END ;
      x := r.buf.data[0]; r.bpos := 1
    ELSE x := 0; r.eof := TRUE
    END
  END ReadByte;

  PROCEDURE ReadBytes*(VAR r: Rider; VAR x: ARRAY OF BYTE; n: INTEGER);
    VAR i: INTEGER;
  BEGIN i := 0;  (*this implementation is to be improved*)
    WHILE i < n DO ReadByte(r, x[i]); INC(i) END
  END ReadBytes;

  PROCEDURE Read*(VAR r: Rider; VAR ch: CHAR);
    VAR buf: Buffer;  (*same as ReadByte*)
  BEGIN
    IF r.apos # r.buf.apos THEN r.buf := GetBuf(r.file, r.apos) END ;
    IF r.bpos < r.buf.lim THEN ch := CHR(r.buf.data[r.bpos]); INC(r.bpos)
    ELSIF r.apos < r.file.aleng THEN
      INC(r.apos); buf := Buf(r.file, r.apos);
      IF buf = NIL THEN
        IF r.buf.mod THEN WriteBuf(r.file, r.buf) END ;
        ReadBuf(r.file, r.buf, r.apos)
      ELSE r.buf := buf
      END ;
      ch := CHR(r.buf.data[0]); r.bpos := 1
    ELSE ch := 0X; r.eof := TRUE
    END
  END Read;

  PROCEDURE ReadInt*(VAR R: Rider; VAR x: INTEGER);
    VAR x0, x1, x2, x3: BYTE;
  BEGIN ReadByte(R, x0); ReadByte(R, x1); ReadByte(R, x2); ReadByte(R, x3);
    x := ((x3 * 100H + x2) * 100H + x1) * 100H + x0
  END ReadInt;

  PROCEDURE ReadSet*(VAR R: Rider; VAR s: SET);
    VAR n: INTEGER;
  BEGIN ReadInt(R, SYSTEM.VAL(INTEGER, s))
  END ReadSet;

  PROCEDURE ReadReal*(VAR R: Rider; VAR x: REAL);
    VAR n: INTEGER;
  BEGIN ReadInt(R, SYSTEM.VAL(INTEGER, x))
  END ReadReal;

  PROCEDURE ReadString*(VAR R: Rider; VAR x: ARRAY OF CHAR);
    VAR i: INTEGER; ch: CHAR;
  BEGIN i := 0; Read(R, ch);
    WHILE ch # 0X DO
      IF i < LEN(x)-1 THEN x[i] := ch; INC(i) END ;
      Read(R, ch)
    END ;
    x[i] := 0X
  END ReadString;

  PROCEDURE ReadNum*(VAR R: Rider; VAR x: INTEGER);
    VAR n, y: INTEGER; b: BYTE;
  BEGIN n := 32; y := 0; ReadByte(R, b);
    WHILE b >= 80H DO y := ROR(y + b-80H, 7); DEC(n, 7); ReadByte(R, b) END ;
    IF n <= 4 THEN x := ROR(y + b MOD 10H, 4) ELSE x := ASR(ROR(y + b, 7), n-7) END
  END ReadNum;
        
  (*---------------------------Write---------------------------*)

  PROCEDURE WriteByte*(VAR r: Rider; x: BYTE);
    VAR f: File; buf: Buffer;
  BEGIN
    IF r.apos # r.buf.apos THEN r.buf := GetBuf(r.file, r.apos); END ;
    IF r.bpos >= r.buf.lim THEN
      IF r.bpos < SS THEN
        INC(r.buf.lim); INC(r.file.bleng); r.file.modH := TRUE
      ELSE f := r.file; WriteBuf(f, r.buf); INC(r.apos); buf := Buf(r.file, r.apos);
        IF buf = NIL THEN
          IF r.apos <= f.aleng THEN ReadBuf(f, r.buf, r.apos)
          ELSE r.buf.apos := r.apos; r.buf.lim := 1; f.aleng := f.aleng + 1; f.bleng := 1; f.modH := TRUE;
          END
        ELSE r.buf := buf
        END ;
        r.bpos := 0
      END
    END ;
    r.buf.data[r.bpos] := x; INC(r.bpos); r.buf.mod := TRUE
  END WriteByte;

  PROCEDURE WriteBytes*(VAR r: Rider; x: ARRAY OF BYTE; n: INTEGER);
    VAR i: INTEGER;
  BEGIN i := 0; (*this implementation is to be improed*)
    WHILE i < n DO WriteByte(r, x[i]); INC(i) END
  END WriteBytes;

  PROCEDURE Write*(VAR r: Rider; ch: CHAR);
    VAR f: File; buf: Buffer;
  BEGIN (*same as WriteByte*)
    IF r.apos # r.buf.apos THEN r.buf := GetBuf(r.file, r.apos); END ;
    IF r.bpos >= r.buf.lim THEN
      IF r.bpos < SS THEN
        INC(r.buf.lim); INC(r.file.bleng); r.file.modH := TRUE
      ELSE f := r.file; WriteBuf(f, r.buf); INC(r.apos); buf := Buf(r.file, r.apos);
        IF buf = NIL THEN
          IF r.apos <= f.aleng THEN ReadBuf(f, r.buf, r.apos)
          ELSE r.buf.apos := r.apos; r.buf.lim := 1; f.aleng := f.aleng + 1; f.bleng := 1; f.modH := TRUE;
          END
        ELSE r.buf := buf
        END ;
        r.bpos := 0
      END
    END ;
    r.buf.data[r.bpos] := ORD(ch); INC(r.bpos); r.buf.mod := TRUE
  END Write;

  PROCEDURE WriteInt*(VAR R: Rider; x: INTEGER);
  BEGIN WriteByte(R, x MOD 100H);
    WriteByte(R, x DIV 100H MOD 100H);
    WriteByte(R, x DIV 10000H MOD 100H);
    WriteByte(R, x DIV 1000000H MOD 100H)
  END WriteInt;

  PROCEDURE WriteSet*(VAR R: Rider; s: SET);
  BEGIN WriteInt(R, ORD(s))
  END WriteSet;

  PROCEDURE WriteReal*(VAR R: Rider; x: REAL);
  BEGIN  WriteInt(R, ORD(x))
  END WriteReal;

  PROCEDURE WriteString*(VAR R: Rider; x: ARRAY OF CHAR);
    VAR i: INTEGER; ch: CHAR;
  BEGIN i := 0;
    REPEAT ch := x[i]; Write(R, ch); INC(i) UNTIL ch = 0X
  END WriteString;

  PROCEDURE WriteNum*(VAR R: Rider; x: INTEGER);
  BEGIN
    WHILE (x < -40H) OR (x >= 40H) DO WriteByte(R, x MOD 80H + 80H); x := ASR(x, 7) END ;
    WriteByte(R, x MOD 80H)
  END WriteNum;

  (*---------------------------System use---------------------------*)

  PROCEDURE Init*;
  BEGIN root := 0; Kernel.Init; FileDir.Init;
    SYSTEM.PUT(SYSTEM.ADR(syscall1), SYSTEM.ADR($8B442404 CD80 C20400 6690 90$));
    SYSTEM.PUT(SYSTEM.ADR(syscall2), SYSTEM.ADR($8B442408 8B5C2404 CD80 C20800 6690 90$));
    SYSTEM.PUT(SYSTEM.ADR(syscall3), SYSTEM.ADR($8B44240C 8B5C2408 8B4C2404 CD80 C20C00 6690 90$));
    SYSTEM.PUT(SYSTEM.ADR(syscall4), SYSTEM.ADR($8B442410 8B5C240C 8B4C2408 8B542404 CD80 C21000 6690 90$));
    SYSTEM.PUT(SYSTEM.ADR(syscall5), SYSTEM.ADR($8B442414 8B5C2410 8B4C240C 8B542408 8B742404 CD80 C21400 6690 90$));
    SYSTEM.PUT(SYSTEM.ADR(syscall6), SYSTEM.ADR($8B442418 8B5C2414 8B4C2410 8B54240C 8B742408 8B7C2404 CD80 C21800 6690 90$))
  END Init;

  PROCEDURE RestoreList*; (*after mark phase of garbage collection*)
    VAR f, f0: INTEGER;

    PROCEDURE mark(f: INTEGER): INTEGER;
      VAR m: INTEGER;
    BEGIN
      IF f = 0 THEN m := -1 ELSE SYSTEM.GET(f-4, m) END ;
      RETURN m
    END mark;

    PROCEDURE close(p: INTEGER);
      VAR f: File;
    BEGIN f := SYSTEM.VAL(File, p); p := syscall2(6, f.sechint)
    END close;

  BEGIN (*field "next" has offset 0*)
    WHILE mark(root) = 0 DO close(root); SYSTEM.GET(root, root) END ;
    f := root;
    WHILE f # 0 DO
      f0 := f; SYSTEM.GET(f0, f0);
      WHILE mark(f0) = 0 DO close(f0); SYSTEM.GET(f0, f0) END;
      SYSTEM.PUT(f, f0); f := f0
    END
  END RestoreList;

END Files.