340 lines
7.1 KiB
Plaintext
340 lines
7.1 KiB
Plaintext
(*
|
|
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. |