Subversion Repositories Kolibri OS

(*

    BSD 2-Clause License

    Copyright (c) 2019, Anton Krotov

    All rights reserved.

*)

MODULE HOST;

IMPORT SYSTEM, API, RTL;

CONST

    slash* = "/";

    OS* = "LINUX";

    bit_depth* = RTL.bit_depth;

    maxint* = RTL.maxint;

    minint* = RTL.minint;

VAR

    argc: INTEGER;

    eol*: ARRAY 2 OF CHAR;

PROCEDURE ExitProcess* (code: INTEGER);

BEGIN

    API.exit(code)

END ExitProcess;

PROCEDURE GetArg* (n: INTEGER; VAR s: ARRAY OF CHAR);

VAR

    i, len, ptr: INTEGER;

    c: CHAR;

BEGIN

    i := 0;

    len := LEN(s) - 1;

    IF (n < argc) & (len > 0) THEN

        SYSTEM.GET(API.MainParam + (n + 1) * SYSTEM.SIZE(INTEGER), ptr);

        REPEAT

            SYSTEM.GET(ptr, c);

            s[i] := c;

            INC(i);

            INC(ptr)

        UNTIL (c = 0X) OR (i = len)

    END;

    s[i] := 0X

END GetArg;

PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);

VAR

    n: INTEGER;

BEGIN

    GetArg(0, path);

    n := LENGTH(path) - 1;

    WHILE path[n] # slash DO

        DEC(n)

    END;

    path[n + 1] := 0X

END GetCurrentDirectory;

PROCEDURE ReadFile (F: INTEGER; VAR Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;

    RETURN API.fread(SYSTEM.ADR(Buffer[0]), 1, bytes, F)

END ReadFile;

PROCEDURE WriteFile (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;

    RETURN API.fwrite(SYSTEM.ADR(Buffer[0]), 1, bytes, F)

END WriteFile;

PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;

VAR

    res: INTEGER;

BEGIN

    res := ReadFile(F, Buffer, bytes);

    IF res <= 0 THEN

        res := -1

    END

    RETURN res

END FileRead;

PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;

VAR

    res: INTEGER;

BEGIN

    res := WriteFile(F, Buffer, bytes);

    IF res <= 0 THEN

        res := -1

    END

    RETURN res

END FileWrite;

PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;

    RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("wb"))

END FileCreate;

PROCEDURE FileClose* (File: INTEGER);

BEGIN

    File := API.fclose(File)

END FileClose;

PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;

    RETURN API.fopen(SYSTEM.ADR(FName[0]), SYSTEM.SADR("rb"))

END FileOpen;

PROCEDURE OutChar* (c: CHAR);

BEGIN

    API.putc(c)

END OutChar;

PROCEDURE GetTickCount* (): INTEGER;

VAR

    tp:  API.TP;

    res: INTEGER;

BEGIN

    IF API.clock_gettime(0, tp) = 0 THEN

        res := tp[0] * 100 + tp[1] DIV 10000000

    ELSE

        res := 0

    END

    RETURN res

END GetTickCount;

PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;

    RETURN path[0] # slash

END isRelative;

PROCEDURE now* (VAR year, month, day, hour, min, sec: INTEGER);

END now;

PROCEDURE UnixTime* (): INTEGER;

    RETURN API.time(0)

END UnixTime;

PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;

VAR

    res: INTEGER;

BEGIN

    a := 0;

    b := 0;

    SYSTEM.MOVE(SYSTEM.ADR(x), SYSTEM.ADR(a), 4);

    SYSTEM.MOVE(SYSTEM.ADR(x) + 4, SYSTEM.ADR(b), 4);

    SYSTEM.GET(SYSTEM.ADR(x), res)

    RETURN res

END splitf;

BEGIN

    eol := 0AX;

    SYSTEM.GET(API.MainParam, argc)

END HOST.