ruberon/source/PATHS.ob07

MODULE PATHS;

IMPORT STRINGS, UTILS IN "./utils/UTILS.ob07";


CONST

    slash = UTILS.slash;

    PATHLEN = 2048;


TYPE

    PATH* = ARRAY PATHLEN OF CHAR;


PROCEDURE split* (fname: ARRAY OF CHAR; VAR path, name, ext: ARRAY OF CHAR);
    VAR
        pos1, pos2, len: INTEGER;

    BEGIN
        len := LENGTH(fname);
        pos1 := len - 1;
        pos2 := pos1;
        STRINGS.search(fname, pos1, slash, FALSE);
        STRINGS.search(fname, pos2,   ".", FALSE);

        path := fname;
        path[pos1 + 1] := 0X;

        IF (pos2 = -1) OR (pos2 < pos1) THEN
            pos2 := len
        END;

        INC(pos1);

        STRINGS.copy(fname, name, pos1, 0, pos2 - pos1);
        name[pos2 - pos1] := 0X;
        STRINGS.copy(fname, ext, pos2, 0, len - pos2);
        ext[len - pos2] := 0X
    END split;


PROCEDURE RelPath* (absolute, relative: ARRAY OF CHAR; VAR res: ARRAY OF CHAR);
    VAR
        i, j: INTEGER;
        error: BOOLEAN;

    BEGIN
        COPY(absolute, res);
        i := LENGTH(res) - 1;
        WHILE (i >= 0) & (res[i] # slash) DO
            DEC(i)
        END;

        INC(i);
        res[i] := 0X;

        error := FALSE;
        j := 0;
        WHILE (relative[j] = ".") & (relative[j + 1] = slash) DO
            INC(j, 2)
        ELSIF relative[j] = slash DO
            INC(j)
        END;

        WHILE ~error & (relative[j] # 0X) DO
            IF (relative[j] = ".") & (relative[j + 1] = ".") & (relative[j + 2] = slash) & (i > 0) & (res[i - 1] = slash) THEN
                DEC(i, 2);
                WHILE (i >= 0) & (res[i] # slash) DO
                    DEC(i)
                END;
                IF i < 0 THEN
                    error := TRUE
                ELSE
                    INC(i);
                    INC(j, 3)
                END
            ELSE
                res[i] := relative[j];
                INC(i);
                INC(j)
            END
        END;

        IF error THEN
            COPY(relative, res)
        ELSE
            res[i] := 0X
        END

    END RelPath;


PROCEDURE DelSlashes* (VAR path: ARRAY OF CHAR);
    VAR
        i, j, k: INTEGER;
        c: CHAR;

    BEGIN
        i := 0;
        j := 0;
        k := 0;
        REPEAT
            c := path[j];
            INC(j);
            IF c = slash THEN
                INC(k)
            ELSE
                k := 0
            END;
            IF k <= 1 THEN
                path[i] := c;
                INC(i)
            END
        UNTIL c = 0X;

        i := 0;
        j := 0;
        REPEAT
            c := path[j];
            INC(j);
            path[i] := c;
            INC(i);
            IF (c = slash) & (path[j] = ".") & (path[j + 1] = slash) THEN
                INC(j, 2)
            END
        UNTIL c = 0X
    END DelSlashes;


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


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


END PATHS.