(*
    BSD 2-Clause License

    Copyright (c) 2018-2023, Anton Krotov
    All rights reserved.
*)

MODULE UTILS;

IMPORT HOST;


CONST

    slash* = HOST.slash;
    eol* = HOST.eol;

    bit_depth* = HOST.bit_depth;
    maxint* = HOST.maxint;
    minint* = HOST.minint;

    min32* = -2147483647-1;
    max32* =  2147483647;

    vMajor* = 1;
    vMinor* = 64;
    Date* = "22-jan-2023";

    FILE_EXT* = ".ob07";
    RTL_NAME* = "RTL";

    MAX_GLOBAL_SIZE* = 1600000000;


VAR

    time*: INTEGER;

    maxreal*, inf*: REAL;

    target*:

      RECORD

          bit_depth*,
          maxInt*,
          minInt*,
          maxSet*,
          maxHex*:    INTEGER;

          maxReal*:   REAL

      END;

    bit_diff*: INTEGER;


PROCEDURE FileRead* (F: INTEGER; VAR Buffer: ARRAY OF CHAR; bytes: INTEGER): INTEGER;
    RETURN HOST.FileRead(F, Buffer, bytes)
END FileRead;


PROCEDURE FileWrite* (F: INTEGER; Buffer: ARRAY OF BYTE; bytes: INTEGER): INTEGER;
    RETURN HOST.FileWrite(F, Buffer, bytes)
END FileWrite;


PROCEDURE FileCreate* (FName: ARRAY OF CHAR): INTEGER;
    RETURN HOST.FileCreate(FName)
END FileCreate;


PROCEDURE FileClose* (F: INTEGER);
BEGIN
    HOST.FileClose(F)
END FileClose;


PROCEDURE FileOpen* (FName: ARRAY OF CHAR): INTEGER;
    RETURN HOST.FileOpen(FName)
END FileOpen;


PROCEDURE chmod* (FName: ARRAY OF CHAR);
BEGIN
    HOST.chmod(FName)
END chmod;


PROCEDURE GetArg* (i: INTEGER; VAR str: ARRAY OF CHAR);
BEGIN
    HOST.GetArg(i, str)
END GetArg;


PROCEDURE Exit* (code: INTEGER);
BEGIN
    HOST.ExitProcess(code)
END Exit;


PROCEDURE GetTickCount* (): INTEGER;
    RETURN HOST.GetTickCount()
END GetTickCount;


PROCEDURE OutChar* (c: CHAR);
BEGIN
    HOST.OutChar(c)
END OutChar;


PROCEDURE splitf* (x: REAL; VAR a, b: INTEGER): INTEGER;
    RETURN HOST.splitf(x, a, b)
END splitf;


PROCEDURE d2s* (x: REAL): INTEGER;
    RETURN HOST.d2s(x)
END d2s;


PROCEDURE isRelative* (path: ARRAY OF CHAR): BOOLEAN;
    RETURN HOST.isRelative(path)
END isRelative;


PROCEDURE GetCurrentDirectory* (VAR path: ARRAY OF CHAR);
BEGIN
    HOST.GetCurrentDirectory(path)
END GetCurrentDirectory;


PROCEDURE UnixTime* (): INTEGER;
    RETURN HOST.UnixTime()
END UnixTime;


PROCEDURE SetBitDepth* (BitDepth: INTEGER; Double: BOOLEAN);
BEGIN
    ASSERT((BitDepth = 16) OR (BitDepth = 32) OR (BitDepth = 64));
    bit_diff := bit_depth - BitDepth;
    ASSERT(bit_diff >= 0);

    target.bit_depth := BitDepth;
    target.maxSet    := BitDepth - 1;
    target.maxHex    := BitDepth DIV 4;
    target.minInt    := ASR(minint, bit_diff);
    target.maxInt    := ASR(maxint, bit_diff);

    IF Double THEN
        target.maxReal := maxreal
    ELSE
        target.maxReal := 1.9;
        PACK(target.maxReal, 127)
    END
END SetBitDepth;


PROCEDURE Byte* (n: INTEGER; idx: INTEGER): BYTE;
    RETURN ASR(n, 8 * idx) MOD 256
END Byte;


PROCEDURE Align* (VAR bytes: INTEGER; align: INTEGER): BOOLEAN;
BEGIN
    INC(bytes, (-bytes) MOD align)
    RETURN bytes >= 0
END Align;


PROCEDURE Long* (value: INTEGER): INTEGER;
    RETURN ASR(LSL(value, bit_diff), bit_diff)
END Long;


PROCEDURE Short* (value: INTEGER): INTEGER;
    RETURN LSR(LSL(value, bit_diff), bit_diff)
END Short;


PROCEDURE Log2* (x: INTEGER): INTEGER;
VAR
    n: INTEGER;

BEGIN
    n := 0;
    WHILE ~ODD(x) DO
        x := x DIV 2;
        INC(n)
    END;

    IF x # 1 THEN
        n := -1
    END

    RETURN n
END Log2;


PROCEDURE hexdgt* (n: BYTE): BYTE;
BEGIN
    IF n < 10 THEN
        INC(n, ORD("0"))
    ELSE
        INC(n, ORD("A") - 10)
    END

    RETURN n
END hexdgt;


BEGIN
    time := HOST.GetTickCount();
    inf := HOST.inf;
    maxreal := HOST.maxreal
END UTILS.