(*
    BSD 2-Clause License

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

MODULE HEX;

IMPORT WRITER, CHL := CHUNKLISTS, UTILS;


VAR

    chksum: INTEGER;


PROCEDURE Byte (byte: BYTE);
BEGIN
    WRITER.WriteByte(UTILS.hexdgt(byte DIV 16));
    WRITER.WriteByte(UTILS.hexdgt(byte MOD 16));
    INC(chksum, byte)
END Byte;


PROCEDURE Byte4 (a, b, c, d: BYTE);
BEGIN
    Byte(a);
    Byte(b);
    Byte(c);
    Byte(d)
END Byte4;


PROCEDURE NewLine;
BEGIN
    Byte((-chksum) MOD 256);
    chksum := 0;
    WRITER.WriteByte(0DH);
    WRITER.WriteByte(0AH)
END NewLine;


PROCEDURE StartCode;
BEGIN
    WRITER.WriteByte(ORD(":"));
    chksum := 0
END StartCode;


PROCEDURE Data* (mem: ARRAY OF BYTE; idx, cnt: INTEGER);
VAR
    i, len: INTEGER;

BEGIN
    WHILE cnt > 0 DO
        len := MIN(cnt, 16);
        StartCode;
        Byte4(len, idx DIV 256, idx MOD 256, 0);
        FOR i := 1 TO len DO
            Byte(mem[idx]);
            INC(idx)
        END;
        DEC(cnt, len);
        NewLine
    END
END Data;


PROCEDURE ExtLA* (LA: INTEGER);
BEGIN
    ASSERT((0 <= LA) & (LA <= 0FFFFH));
    StartCode;
    Byte4(2, 0, 0, 4);
    Byte(LA DIV 256);
    Byte(LA MOD 256);
    NewLine
END ExtLA;


PROCEDURE Data2* (mem: CHL.BYTELIST; idx, cnt, LA: INTEGER);
VAR
    i, len, offset: INTEGER;

BEGIN
    ExtLA(LA);
    offset := 0;
    WHILE cnt > 0 DO
        ASSERT(offset <= 65536);
        IF offset = 65536 THEN
            INC(LA);
            ExtLA(LA);
            offset := 0
        END;
        len := MIN(cnt, 16);
        StartCode;
        Byte4(len, offset DIV 256, offset MOD 256, 0);
        FOR i := 1 TO len DO
            Byte(CHL.GetByte(mem, idx));
            INC(idx);
            INC(offset)
        END;
        DEC(cnt, len);
        NewLine
    END
END Data2;


PROCEDURE End*;
BEGIN
    StartCode;
    Byte4(0, 0, 0, 1);
    NewLine
END End;


END HEX.