Subversion Repositories Kolibri OS

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.