kolibrios/programs/develop/cedit/SRC/ChangeLog.ob07

(*
    Copyright 2021-2023 Anton Krotov

    This file is part of CEdit.

    CEdit is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    CEdit is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with CEdit. If not, see <http://www.gnu.org/licenses/>.
*)

MODULE ChangeLog;

IMPORT List, Lines, API, SYSTEM;

CONST
	boolItemSize = 8;
	fillMap = {0..boolItemSize-1};

TYPE
	tIntItem = POINTER TO RECORD (List.tItem)
		cnt: INTEGER;
		adr, val: ARRAY 8 OF INTEGER
	END;

	tBoolItem = POINTER TO RECORD (List.tItem)
		map: SET;
		data: ARRAY boolItemSize OF
			RECORD
				line: Lines.tLine;
				adr: INTEGER;
				val, save: BOOLEAN
			END
	END;

	tUntypedPtr = POINTER TO RECORD (List.tItem)
		cnt: INTEGER;
		p: ARRAY 64 OF INTEGER
	END;

	tTypedPtr = POINTER TO RECORD (List.tItem)
		cnt: INTEGER;
		p: ARRAY 64 OF List.tItem
	END;

	tGuard* = POINTER TO RECORD (List.tItem)
		saved*: BOOLEAN
	END;

	tLog* = POINTER TO RECORD
		Log*, TPointers, UPointers: List.tList;
		guard, first: tGuard;
		isLast: BOOLEAN
	END;


VAR
	CL*: tLog;


PROCEDURE isLastGuard* (guard: tGuard): BOOLEAN;
VAR
	item: List.tItem;
	res: BOOLEAN;
BEGIN
	IF guard # NIL THEN
		item := CL.Log.last;
		WHILE ~(item IS tGuard) DO
			item := item.prev
		END;
		res := guard = item
	ELSE
		res := TRUE
	END
	RETURN res
END isLastGuard;


PROCEDURE getFirstGuard (): tGuard;
VAR
	item: List.tItem;
BEGIN
	item := CL.Log.first;
	WHILE ~(item IS tGuard) DO
		item := item.next
	END
	RETURN item(tGuard)
END getFirstGuard;


PROCEDURE isFirstGuard* (guard: tGuard): BOOLEAN;
BEGIN
	ASSERT(guard # NIL);
	IF CL.first = NIL THEN
		CL.first := getFirstGuard()
	END
	RETURN guard = CL.first
END isFirstGuard;


PROCEDURE setGuard* (_guard: tGuard);
BEGIN
	CL.guard := _guard;
	CL.isLast := isLastGuard(_guard)
END setGuard;


PROCEDURE redo* (item: List.tItem);
VAR
	i: INTEGER;
BEGIN
	IF item IS tIntItem THEN
		FOR i := 0 TO item(tIntItem).cnt - 1 DO
			SYSTEM.PUT(item(tIntItem).adr[i], item(tIntItem).val[i])
		END
	ELSIF item IS tBoolItem THEN
		FOR i := 0 TO boolItemSize - 1 DO
			IF i IN item(tBoolItem).map THEN
				SYSTEM.PUT(item(tBoolItem).data[i].adr, item(tBoolItem).data[i].val)
			END
		END
	END
END redo;


PROCEDURE clear (guard: tGuard);
VAR
	item: List.tItem;
BEGIN
	CL.isLast := TRUE;
	REPEAT
		item := List.pop(CL.Log);
		IF item # guard THEN
			DISPOSE(item)
		END
	UNTIL item = guard;
	List.append(CL.Log, item)
END clear;


PROCEDURE save* (guard: tGuard);
VAR
	item: List.tItem;
	boolItem: tBoolItem;
	cur: List.tItem;
	i: INTEGER;
BEGIN
	item := CL.Log.first;
	WHILE item # NIL DO
		IF item IS tGuard THEN
			item(tGuard).saved := FALSE
		END;
		item := item.next
	END;
	guard.saved := TRUE;

	cur := CL.guard.prev;
	WHILE cur # NIL DO
		IF cur IS tBoolItem THEN
			boolItem := cur(tBoolItem);
			FOR i := 0 TO boolItemSize - 1 DO
				IF (i IN boolItem.map) & boolItem.data[i].save &
						boolItem.data[i].line.modified THEN
					EXCL(boolItem.map, i)
				END
			END
		END;
		cur := cur.prev;
		IF boolItem.map = {} THEN
			List.delete(CL.Log, boolItem);
			DISPOSE(boolItem)
		END
	END
END save;


PROCEDURE changeWord (adrV, adrX: INTEGER);
VAR
	item: tIntItem;
	cur: List.tItem;
BEGIN
	IF ~CL.isLast THEN
		clear(CL.guard)
	END;
	cur := CL.Log.last;
	WHILE (cur # NIL) & ~(cur IS tGuard) & ~(cur IS tIntItem) DO
		cur := cur.prev
	END;
	IF (cur IS tIntItem) & (cur(tIntItem).cnt < LEN(cur(tIntItem).adr)) THEN
		item := cur(tIntItem)
	ELSE
		NEW(item);
		item.cnt := 0;
		List.append(CL.Log, item)
	END;
	item.adr[item.cnt] := adrV;
	SYSTEM.GET(adrX, item.val[item.cnt]);
	INC(item.cnt)
END changeWord;


PROCEDURE delSaved*;
VAR
	boolItem: tBoolItem;
	cur: List.tItem;
	i: INTEGER;
BEGIN
	cur := CL.guard.next;
	WHILE cur # NIL DO
		IF cur IS tBoolItem THEN
			boolItem := cur(tBoolItem);
			FOR i := 0 TO boolItemSize - 1 DO
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
					EXCL(boolItem.map, i)
				END
			END
		END;
		cur := cur.next;
		IF boolItem.map = {} THEN
			List.delete(CL.Log, boolItem);
			DISPOSE(boolItem)
		END
	END
END delSaved;


PROCEDURE delCurSaved*;
VAR
	boolItem: tBoolItem;
	cur: List.tItem;
	i: INTEGER;
BEGIN
	cur := CL.guard.prev;
	WHILE (cur # NIL) & ~(cur IS tGuard) DO
		IF cur IS tBoolItem THEN
			boolItem := cur(tBoolItem);
			FOR i := 0 TO boolItemSize - 1 DO
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
					SYSTEM.PUT(boolItem.data[i].adr, ~boolItem.data[i].val);
					EXCL(boolItem.map, i)
				END
			END
		END;
		cur := cur.prev;
		IF boolItem.map = {} THEN
			List.delete(CL.Log, boolItem);
			DISPOSE(boolItem)
		END
	END
END delCurSaved;


PROCEDURE _changeBool (fn2: BOOLEAN; line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
VAR
	item: tBoolItem;
	cur: List.tItem;
	i: INTEGER;
BEGIN
	IF fn2 THEN
		cur := CL.guard.prev
	ELSE
		IF ~CL.isLast THEN
			clear(CL.guard)
		END;
		cur := CL.Log.last
	END;

	WHILE (cur # NIL) & ~(cur IS tGuard) &
			(~(cur IS tBoolItem) OR (cur(tBoolItem).map = fillMap)) DO
		cur := cur.prev
	END;
	IF (cur IS tBoolItem) & (cur(tBoolItem).map # fillMap) THEN
		item := cur(tBoolItem)
	ELSE
		NEW(item);
		item.map := {};
		IF fn2 THEN
			List.insert(CL.Log, CL.guard.prev, item)
		ELSE
			List.append(CL.Log, item)
		END
	END;

	i := 0;
	WHILE i < boolItemSize DO
		IF ~(i IN item.map) THEN
			item.data[i].line := line;
			item.data[i].adr := SYSTEM.ADR(v);
			item.data[i].val := x;
			item.data[i].save := fn2;
			INCL(item.map, i);
			i := boolItemSize
		END;
		INC(i)
	END
END _changeBool;


PROCEDURE changeBool (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
BEGIN
	_changeBool(FALSE, line, v, x)
END changeBool;


PROCEDURE changeBool2 (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
BEGIN
	_changeBool(TRUE, line, v, x)
END changeBool2;


PROCEDURE changeInt* (VAR v: INTEGER; x: INTEGER);
BEGIN
	changeWord(SYSTEM.ADR(v), SYSTEM.ADR(x))
END changeInt;


PROCEDURE changePtr (VAR v: List.tItem; x: List.tItem);
BEGIN
	changeWord(SYSTEM.ADR(v), SYSTEM.ADR(x))
END changePtr;


PROCEDURE typedPtr (p: List.tItem);
VAR
	item: tTypedPtr;
BEGIN
	item := CL.TPointers.last(tTypedPtr);
	IF (item = NIL) OR (item.cnt = LEN(item.p)) THEN
		NEW(item);
		item.cnt := 0;
		List.append(CL.TPointers, item)
	END;
	item.p[item.cnt] := p;
	INC(item.cnt)
END typedPtr;


PROCEDURE untypedPtr (p: INTEGER);
VAR
	item: tUntypedPtr;
BEGIN
	item := CL.UPointers.last(tUntypedPtr);
	IF (item = NIL) OR (item.cnt = LEN(item.p)) THEN
		NEW(item);
		item.cnt := 0;
		List.append(CL.UPointers, item)
	END;
	item.p[item.cnt] := p;
	INC(item.cnt)
END untypedPtr;


PROCEDURE setLog* (_CL: tLog);
BEGIN
	CL := _CL
END setLog;


PROCEDURE create* (VAR maxLength: INTEGER): tLog;
VAR
	newLog: tLog;
BEGIN
	NEW(newLog);
	newLog.guard := NIL;
	newLog.first := NIL;
	newLog.isLast := TRUE;
	newLog.Log := List.create(NIL);
	newLog.TPointers := List.create(NIL);
	newLog.UPointers := List.create(NIL);
	CL := newLog;
	Lines.setMaxLength(maxLength)
	RETURN newLog
END create;


PROCEDURE destroy* (VAR log: tLog);
VAR
	item: List.tItem;
	res, i: INTEGER;
BEGIN
	IF log # NIL THEN
		item := List.pop(log.Log);
		WHILE item # NIL DO
			DISPOSE(item);
			item := List.pop(log.Log)
		END;
		DISPOSE(log.Log);

		item := List.pop(log.TPointers);
		WHILE item # NIL DO
			FOR i := 0 TO item(tTypedPtr).cnt - 1 DO
				DISPOSE(item(tTypedPtr).p[i])
			END;
			DISPOSE(item);
			item := List.pop(log.TPointers)
		END;
		DISPOSE(log.TPointers);

		item := List.pop(log.UPointers);
		WHILE item # NIL DO
			FOR i := 0 TO item(tUntypedPtr).cnt - 1 DO
				res := API._DISPOSE(item(tUntypedPtr).p[i])
			END;
			DISPOSE(item);
			item := List.pop(log.UPointers)
		END;
		DISPOSE(log.UPointers);

		DISPOSE(log)
	END
END destroy;


BEGIN
	List.init(changeInt, changePtr);
	Lines.init(changeInt, changePtr, changeBool, changeBool2, typedPtr, untypedPtr)
END ChangeLog.