ruberon/source/utils/UTILS.ob07

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* = 66;
    Date* = "10-feb-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.