kolibrios/programs/develop/oberon07/Source/STRINGS.ob07

(*
    BSD 2-Clause License

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

MODULE STRINGS;

IMPORT UTILS;


PROCEDURE append* (VAR s1: ARRAY OF CHAR; s2: ARRAY OF CHAR);
VAR
    n1, n2, i, j: INTEGER;

BEGIN
    n1 := LENGTH(s1);
    n2 := LENGTH(s2);

    ASSERT(n1 + n2 < LEN(s1));

    i := 0;
    j := n1;
    WHILE i < n2 DO
        s1[j] := s2[i];
        INC(i);
        INC(j)
    END;

    s1[j] := 0X

END append;


PROCEDURE reverse (VAR s: ARRAY OF CHAR);
VAR
    i, j: INTEGER;
    a, b: CHAR;

BEGIN
    i := 0;
    j := LENGTH(s) - 1;

    WHILE i < j DO
        a := s[i];
        b := s[j];
        s[i] := b;
        s[j] := a;
        INC(i);
        DEC(j)
    END
END reverse;


PROCEDURE IntToStr* (x: INTEGER; VAR str: ARRAY OF CHAR);
VAR
    i, a: INTEGER;
    minus: BOOLEAN;

BEGIN
    IF x = UTILS.minint THEN
        IF UTILS.bit_depth = 32 THEN
            COPY("-2147483648", str)
        ELSIF UTILS.bit_depth = 64 THEN
            COPY("-9223372036854775808", str)
        END

    ELSE

        minus := x < 0;
        IF minus THEN
            x := -x
        END;
        i := 0;
        a := 0;
        REPEAT
            str[i] := CHR(x MOD 10 + ORD("0"));
            x := x DIV 10;
            INC(i)
        UNTIL x = 0;

        IF minus THEN
            str[i] := "-";
            INC(i)
        END;

        str[i] := 0X;
        reverse(str)

    END
END IntToStr;


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

    RETURN n
END hexdgt;


PROCEDURE IntToHex* (x: INTEGER; VAR str: ARRAY OF CHAR; n: INTEGER);
BEGIN
    str[n] := 0X;
    WHILE n > 0 DO
        str[n - 1] := CHR(hexdgt(x MOD 16));
        x := x DIV 16;
        DEC(n)
    END
END IntToHex;


PROCEDURE copy* (src: ARRAY OF CHAR; VAR dst: ARRAY OF CHAR; spos, dpos, count: INTEGER);
BEGIN
    WHILE count > 0 DO
        dst[dpos] := src[spos];
        INC(spos);
        INC(dpos);
        DEC(count)
    END
END copy;


PROCEDURE search* (s: ARRAY OF CHAR; VAR pos: INTEGER; c: CHAR; forward: BOOLEAN);
VAR
    length: INTEGER;

BEGIN
    length := LENGTH(s);

    IF (0 <= pos) & (pos < length) THEN
        IF forward THEN
            WHILE (pos < length) & (s[pos] # c) DO
                INC(pos)
            END;
            IF pos = length THEN
                pos := -1
            END
        ELSE
            WHILE (pos >= 0) & (s[pos] # c) DO
                DEC(pos)
            END
        END
    ELSE
        pos := -1
    END
END search;


PROCEDURE letter* (c: CHAR): BOOLEAN;
    RETURN ("a" <= c) & (c <= "z") OR ("A" <= c) & (c <= "Z") OR (c = "_")
END letter;


PROCEDURE digit* (c: CHAR): BOOLEAN;
    RETURN ("0" <= c) & (c <= "9")
END digit;


PROCEDURE hexdigit* (c: CHAR): BOOLEAN;
    RETURN ("0" <= c) & (c <= "9") OR ("A" <= c) & (c <= "F")
END hexdigit;


PROCEDURE space* (c: CHAR): BOOLEAN;
    RETURN (0X < c) & (c <= 20X)
END space;


PROCEDURE cap (VAR c: CHAR);
BEGIN
    IF ("a" <= c) & (c <= "z") THEN
        c := CHR(ORD(c) - 32)
    END
END cap;


PROCEDURE UpCase* (VAR str: ARRAY OF CHAR);
VAR
    i: INTEGER;

BEGIN
    i := 0;
    WHILE (i < LEN(str)) & (str[i] # 0X) DO
        cap(str[i]);
        INC(i)
    END
END UpCase;


PROCEDURE StrToInt* (str: ARRAY OF CHAR; VAR x: INTEGER): BOOLEAN;
VAR
    i, k: INTEGER;
    res: BOOLEAN;

BEGIN
    res := TRUE;
    i := 0;
    x := 0;
    k := LENGTH(str);
    WHILE i < k DO
        IF digit(str[i]) THEN
            x := x * 10 + ORD(str[i]) - ORD("0")
        ELSE
            i := k;
            res := FALSE
        END;
        INC(i)
    END

    RETURN res
END StrToInt;


PROCEDURE CheckVer (str: ARRAY OF CHAR): BOOLEAN;
VAR
    i, k: INTEGER;
    res: BOOLEAN;

BEGIN
    k := LENGTH(str);
    res := k < LEN(str);

    IF res & digit(str[0]) THEN
        i := 0;
        WHILE (i < k) & digit(str[i]) DO
            INC(i)
        END;
        IF (i < k) & (str[i] = ".") THEN
            INC(i);
            IF i < k THEN
                WHILE (i < k) & digit(str[i]) DO
                    INC(i)
                END
            ELSE
                res := FALSE
            END
        ELSE
            res := FALSE
        END;

        res := res & (i = k)
    ELSE
        res := FALSE
    END

    RETURN res
END CheckVer;


PROCEDURE StrToVer* (str: ARRAY OF CHAR; VAR major, minor: INTEGER): BOOLEAN;
VAR
    i: INTEGER;
    res: BOOLEAN;

BEGIN
    res := CheckVer(str);

    IF res THEN
        i := 0;
        minor := 0;
        major := 0;
        WHILE digit(str[i]) DO
            major := major * 10 + ORD(str[i]) - ORD("0");
            INC(i)
        END;
        INC(i);
        WHILE digit(str[i]) DO
            minor := minor * 10 + ORD(str[i]) - ORD("0");
            INC(i)
        END
    END

    RETURN res
END StrToVer;


PROCEDURE Utf8To16* (src: ARRAY OF CHAR; VAR dst: ARRAY OF WCHAR): INTEGER;
VAR
    i, j, u, srclen, dstlen: INTEGER;
    c: CHAR;

BEGIN
    srclen := LEN(src);
    dstlen := LEN(dst);
    i := 0;
    j := 0;
    WHILE (i < srclen) & (j < dstlen) & (src[i] # 0X) DO
        c := src[i];
        CASE c OF
        |00X..7FX:
            u := ORD(c)

        |0C1X..0DFX:
            u := (ORD(c) - 0C0H) * 64;
            IF i + 1 < srclen THEN
                INC(i);
                INC(u, ORD(src[i]) MOD 64)
            END

        |0E1X..0EFX:
            u := (ORD(c) - 0E0H) * 4096;
            IF i + 1 < srclen THEN
                INC(i);
                INC(u, (ORD(src[i]) MOD 64) * 64)
            END;
            IF i + 1 < srclen THEN
                INC(i);
                INC(u, ORD(src[i]) MOD 64)
            END
(*
        |0F1X..0F7X:
        |0F9X..0FBX:
        |0FDX:
        *)
        ELSE
        END;
        INC(i);
        dst[j] := WCHR(u);
        INC(j)
    END;
    IF j < dstlen THEN
        dst[j] := WCHR(0)
    END

    RETURN j
END Utf8To16;


END STRINGS.