(*
Copyright 2021, 2022 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;
TYPE
tIntItem = POINTER TO RECORD (List.tItem)
adr, val: INTEGER
END;
tBoolItem = POINTER TO RECORD (List.tItem)
line: Lines.tLine;
adr: INTEGER;
val, save: BOOLEAN
END;
tUntypedPtr = POINTER TO RECORD (List.tItem)
p: INTEGER
END;
tTypedPtr = POINTER TO RECORD (List.tItem)
p: List.tItem
END;
tGuard* = POINTER TO RECORD (List.tItem)
saved*: BOOLEAN
END;
tLog* = POINTER TO RECORD
Log*, Pointers*: 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);
BEGIN
IF item IS tIntItem THEN
SYSTEM.PUT(item(tIntItem).adr, item(tIntItem).val)
ELSIF item IS tBoolItem THEN
SYSTEM.PUT(item(tBoolItem).adr, item(tBoolItem).val)
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;
del: BOOLEAN;
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);
del := boolItem.save & boolItem.line.modified
ELSE
del := FALSE
END;
cur := cur.prev;
IF del THEN
List.delete(CL.Log, boolItem);
DISPOSE(boolItem)
END
END
END save;
PROCEDURE changeWord (adrV, adrX: INTEGER);
VAR
item: tIntItem;
BEGIN
NEW(item);
item.adr := adrV;
SYSTEM.GET(adrX, item.val);
IF ~CL.isLast THEN
clear(CL.guard)
END;
List.append(CL.Log, item)
END changeWord;
PROCEDURE changeBool (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
VAR
item: tBoolItem;
BEGIN
NEW(item);
item.line := line;
item.adr := SYSTEM.ADR(v);
item.val := x;
item.save := FALSE;
IF ~CL.isLast THEN
clear(CL.guard)
END;
List.append(CL.Log, item)
END changeBool;
PROCEDURE delSaved*;
VAR
boolItem: tBoolItem;
cur: List.tItem;
del: BOOLEAN;
BEGIN
cur := CL.guard.next;
WHILE cur # NIL DO
IF cur IS tBoolItem THEN
boolItem := cur(tBoolItem);
del := boolItem.save
ELSE
del := FALSE
END;
cur := cur.next;
IF del THEN
List.delete(CL.Log, boolItem);
DISPOSE(boolItem)
END
END
END delSaved;
PROCEDURE delCurSaved*;
VAR
boolItem: tBoolItem;
cur: List.tItem;
del: BOOLEAN;
BEGIN
cur := CL.guard.prev;
WHILE (cur # NIL) & ~(cur IS tGuard) DO
IF cur IS tBoolItem THEN
boolItem := cur(tBoolItem);
del := boolItem.save
ELSE
del := FALSE
END;
cur := cur.prev;
IF del THEN
SYSTEM.PUT(boolItem.adr, ~boolItem.val);
List.delete(CL.Log, boolItem);
DISPOSE(boolItem)
END
END
END delCurSaved;
PROCEDURE changeBool2 (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
VAR
item: tBoolItem;
BEGIN
NEW(item);
item.line := line;
item.adr := SYSTEM.ADR(v);
item.val := x;
item.save := TRUE;
List.insert(CL.Log, CL.guard.prev, item)
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
NEW(item);
item.p := p;
List.append(CL.Pointers, item)
END typedPtr;
PROCEDURE untypedPtr (p: INTEGER);
VAR
item: tUntypedPtr;
BEGIN
NEW(item);
item.p := p;
List.append(CL.Pointers, item)
END untypedPtr;
PROCEDURE set* (_CL: tLog);
BEGIN
CL := _CL
END set;
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.Pointers := List.create(NIL);
CL := newLog;
Lines.setMaxLength(maxLength)
RETURN newLog
END create;
PROCEDURE destroy* (VAR log: tLog);
VAR
item: List.tItem;
res: 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.Pointers);
WHILE item # NIL DO
IF item IS tUntypedPtr THEN
res := API._DISPOSE(item(tUntypedPtr).p)
ELSIF item IS tTypedPtr THEN
DISPOSE(item(tTypedPtr).p)
END;
DISPOSE(item);
item := List.pop(log.Pointers)
END;
DISPOSE(log.Pointers);
DISPOSE(log)
END
END destroy;
BEGIN
List.init(changeInt, changePtr);
Lines.init(changeInt, changePtr, changeBool, changeBool2, typedPtr, untypedPtr)
END ChangeLog.