Subversion Repositories Kolibri OS

(*

    BSD 2-Clause License

    Copyright (c) 2018-2021, Anton Krotov

    All rights reserved.

*)

MODULE CHUNKLISTS;

IMPORT LISTS, WR := WRITER;

CONST

    LENOFBYTECHUNK = 65536;

    LENOFINTCHUNK  = 16384;

TYPE

    ANYLIST = POINTER TO RECORD (LISTS.LIST)

        length: INTEGER

    END;

    BYTELIST* = POINTER TO RECORD (ANYLIST) END;

    BYTECHUNK = POINTER TO RECORD (LISTS.ITEM)

        data:   ARRAY LENOFBYTECHUNK OF BYTE;

        count:  INTEGER

    END;

    INTLIST* = POINTER TO RECORD (ANYLIST) END;

    INTCHUNK = POINTER TO RECORD (LISTS.ITEM)

        data:   ARRAY LENOFINTCHUNK OF INTEGER;

        count:  INTEGER

    END;

PROCEDURE SetByte* (list: BYTELIST; idx: INTEGER; byte: BYTE);

VAR

    chunk: BYTECHUNK;

    item:  LISTS.ITEM;

BEGIN

    ASSERT(idx >= 0);

    ASSERT(list # NIL);

    item := LISTS.getidx(list, idx DIV LENOFBYTECHUNK);

    ASSERT(item # NIL);

    chunk := item(BYTECHUNK);

    idx := idx MOD LENOFBYTECHUNK;

    ASSERT(idx < chunk.count);

    chunk.data[idx] := byte

END SetByte;

PROCEDURE GetByte* (list: BYTELIST; idx: INTEGER): BYTE;

VAR

    chunk: BYTECHUNK;

    item:  LISTS.ITEM;

BEGIN

    ASSERT(idx >= 0);

    ASSERT(list # NIL);

    item := LISTS.getidx(list, idx DIV LENOFBYTECHUNK);

    ASSERT(item # NIL);

    chunk := item(BYTECHUNK);

    idx := idx MOD LENOFBYTECHUNK;

    ASSERT(idx < chunk.count)

    RETURN chunk.data[idx]

END GetByte;

PROCEDURE PushByte* (list: BYTELIST; byte: BYTE);

VAR

    chunk: BYTECHUNK;

BEGIN

    ASSERT(list # NIL);

    chunk := list.last(BYTECHUNK);

    IF chunk.count = LENOFBYTECHUNK THEN

        NEW(chunk);

        chunk.count := 0;

        LISTS.push(list, chunk)

    END;

    chunk.data[chunk.count] := byte;

    INC(chunk.count);

    INC(list.length)

END PushByte;

PROCEDURE PushStr* (list: BYTELIST; str: ARRAY OF CHAR): INTEGER;

VAR

    i, res: INTEGER;

BEGIN

    res := list.length;

    i := 0;

    REPEAT

        PushByte(list, ORD(str[i]));

        INC(i)

    UNTIL str[i - 1] = 0X

    RETURN res

END PushStr;

PROCEDURE GetStr* (list: BYTELIST; pos: INTEGER; VAR str: ARRAY OF CHAR): BOOLEAN;

VAR

    i:   INTEGER;

    res: BOOLEAN;

BEGIN

    res := FALSE;

    i := 0;

    WHILE (pos < list.length) & (i < LEN(str)) & ~res DO

        str[i] := CHR(GetByte(list, pos));

        res := str[i] = 0X;

        INC(pos);

        INC(i)

    END

    RETURN res

END GetStr;

PROCEDURE WriteToFile* (list: BYTELIST);

VAR

    chunk: BYTECHUNK;

BEGIN

    chunk := list.first(BYTECHUNK);

    WHILE chunk # NIL DO

        WR.Write(chunk.data, chunk.count);

        chunk := chunk.next(BYTECHUNK)

    END

END WriteToFile;

PROCEDURE CreateByteList* (): BYTELIST;

VAR

    bytelist: BYTELIST;

    list:     LISTS.LIST;

    chunk:    BYTECHUNK;

BEGIN

    NEW(bytelist);

    list := LISTS.create(bytelist);

    bytelist.length := 0;

    NEW(chunk);

    chunk.count := 0;

    LISTS.push(list, chunk)

    RETURN list(BYTELIST)

END CreateByteList;

PROCEDURE SetInt* (list: INTLIST; idx: INTEGER; int: INTEGER);

VAR

    chunk: INTCHUNK;

    item:  LISTS.ITEM;

BEGIN

    ASSERT(idx >= 0);

    ASSERT(list # NIL);

    item := LISTS.getidx(list, idx DIV LENOFINTCHUNK);

    ASSERT(item # NIL);

    chunk := item(INTCHUNK);

    idx := idx MOD LENOFINTCHUNK;

    ASSERT(idx < chunk.count);

    chunk.data[idx] := int

END SetInt;

PROCEDURE GetInt* (list: INTLIST; idx: INTEGER): INTEGER;

VAR

    chunk: INTCHUNK;

    item:  LISTS.ITEM;

BEGIN

    ASSERT(idx >= 0);

    ASSERT(list # NIL);

    item := LISTS.getidx(list, idx DIV LENOFINTCHUNK);

    ASSERT(item # NIL);

    chunk := item(INTCHUNK);

    idx := idx MOD LENOFINTCHUNK;

    ASSERT(idx < chunk.count)

    RETURN chunk.data[idx]

END GetInt;

PROCEDURE PushInt* (list: INTLIST; int: INTEGER);

VAR

    chunk: INTCHUNK;

BEGIN

    ASSERT(list # NIL);

    chunk := list.last(INTCHUNK);

    IF chunk.count = LENOFINTCHUNK THEN

        NEW(chunk);

        chunk.count := 0;

        LISTS.push(list, chunk)

    END;

    chunk.data[chunk.count] := int;

    INC(chunk.count);

    INC(list.length)

END PushInt;

PROCEDURE CreateIntList* (): INTLIST;

VAR

    intlist:  INTLIST;

    list:     LISTS.LIST;

    chunk:    INTCHUNK;

BEGIN

    NEW(intlist);

    list := LISTS.create(intlist);

    intlist.length := 0;

    NEW(chunk);

    chunk.count := 0;

    LISTS.push(list, chunk)

    RETURN list(INTLIST)

END CreateIntList;

PROCEDURE Length* (list: ANYLIST): INTEGER;

    RETURN list.length

END Length;

END CHUNKLISTS.