MODULE unix;    (* connect to unix host *)
IMPORT SYSTEM, _unix;
(* provide some Oberon friendly POSIX without need for SYSTEM *)

CONST   RTLD_LAZY* = 1;
                O_RDONLY* = 0;
                O_NEWFILE* = 0C2H;  (* O_RDWR | O_CREAT | O_EXCL *)
                (* O_RDONLY=0, O_WRONLY=1, O_RDWR=2, O_CREAT=0x40, O_EXCL=0x80, O_TRUNC=0x200 *)
                FD_SETSIZE* = 1024;   (* fd for select() must be smaller than FD_SETSIZE *)
                BIT_DEPTH* = _unix.BIT_DEPTH;
                LEN_FD_SET = FD_SETSIZE DIV BIT_DEPTH;

TYPE
        timespec* = RECORD
                tv_sec*, tv_usec* :INTEGER
        END;
        fd_set* = POINTER TO RECORD   (* for select() *)
                bits* :ARRAY LEN_FD_SET OF SET   (* 1024 bits *)
        END;

VAR
        dlopen* :PROCEDURE [linux] (name, flags :INTEGER) :INTEGER;
        dlsym* :PROCEDURE [linux] (p, name :INTEGER) :INTEGER;
        dlclose* :PROCEDURE [linux] (p :INTEGER) :INTEGER;
        close* :PROCEDURE [linux] (fd :INTEGER) :INTEGER;
        exit* :PROCEDURE [linux] (n :INTEGER);
        malloc* :PROCEDURE [linux] (sz :INTEGER) :INTEGER;

PROCEDURE open* (path :ARRAY OF CHAR; flag, perm :INTEGER) :INTEGER;
BEGIN RETURN _unix._open (SYSTEM.ADR(path[0]), flag, perm) END open;

PROCEDURE read* (fd :INTEGER; VAR buf :ARRAY OF BYTE; len :INTEGER) :INTEGER;
BEGIN RETURN _unix._read (fd, SYSTEM.ADR(buf[0]), len) END read;

PROCEDURE readByte* (fd :INTEGER; VAR n :BYTE) :INTEGER;
BEGIN RETURN _unix._read (fd, SYSTEM.ADR(n), 1) END readByte;

PROCEDURE write* (fd :INTEGER; buf :ARRAY OF BYTE; len :INTEGER) :INTEGER;
BEGIN RETURN _unix._write (fd, SYSTEM.ADR(buf[0]), len) END write;

PROCEDURE writeByte* (fd :INTEGER; n :BYTE) :INTEGER;
BEGIN RETURN _unix._write (fd, SYSTEM.ADR(n), 1) END writeByte;


PROCEDURE FD_ZERO* (VAR selectSet :fd_set);
VAR i :INTEGER;
BEGIN FOR i := 0 TO LEN_FD_SET-1 DO selectSet.bits[i] := {} END END FD_ZERO;

PROCEDURE FD_SET* (fd :INTEGER; VAR selectSet :fd_set);   (* set fd bit in a select() fd_set *)
BEGIN INCL(selectSet.bits[fd DIV BIT_DEPTH], fd MOD BIT_DEPTH)
END FD_SET;

PROCEDURE select* (cnt :INTEGER; readfds, writefds, exceptfds :fd_set; timeout :timespec) :INTEGER;
VAR n1, n2, n3 :INTEGER;
BEGIN
        n1 := 0; IF readfds # NIL THEN n1 := SYSTEM.ADR (readfds.bits[0]) END;
        n2 := 0; IF writefds # NIL THEN n2 := SYSTEM.ADR (writefds.bits[0]) END;
        n3 := 0; IF exceptfds # NIL THEN n3 := SYSTEM.ADR (exceptfds.bits[0]) END;
RETURN _unix._select (cnt, n1, n2, n3, SYSTEM.ADR(timeout))
END select;


PROCEDURE finish*;
BEGIN _unix.finish; END finish;

BEGIN
        dlopen := _unix._dlopen;
        dlsym := _unix._dlsym;
        dlclose := _unix._dlclose;
        close := _unix._close;
        exit := _unix._exit;
        malloc := _unix._malloc;
END unix.