567 lines
13 KiB
Plaintext
567 lines
13 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 Lines;
|
|
|
|
IMPORT
|
|
List, SYSTEM, API, Utils;
|
|
|
|
CONST
|
|
WCHAR_SIZE = 2;
|
|
SPACE* = 20X;
|
|
TAB* = 9X;
|
|
NUL* = 0FDD0X;
|
|
TAB1* = 0FDD1X;
|
|
|
|
TYPE
|
|
|
|
tLine* = POINTER TO RECORD (List.tItem)
|
|
ptr: INTEGER;
|
|
length*: INTEGER;
|
|
modified*, saved*, temp, label*: BOOLEAN;
|
|
cin*, cout*, pos*: INTEGER
|
|
END;
|
|
|
|
PmovInt = PROCEDURE (VAR v: INTEGER; x: INTEGER);
|
|
PmovBool = PROCEDURE (line: tLine; VAR v: BOOLEAN; x: BOOLEAN);
|
|
PmovPtr = PROCEDURE (VAR v: List.tItem; x: List.tItem);
|
|
|
|
PTypedPtr = PROCEDURE (p: List.tItem);
|
|
PUntypedPtr = PROCEDURE (p: INTEGER);
|
|
|
|
tVector* = POINTER TO RECORD
|
|
size, data: INTEGER
|
|
END;
|
|
|
|
tVectorItem = tLine;
|
|
|
|
fConvert* = PROCEDURE (VAR c: WCHAR): BOOLEAN;
|
|
|
|
|
|
VAR
|
|
|
|
_movInt: PmovInt;
|
|
_movBool, _movBool2: PmovBool;
|
|
_movPtr: PmovPtr;
|
|
_typedPtr: PTypedPtr;
|
|
_untypedPtr: PUntypedPtr;
|
|
|
|
pMaxLength, tab*: INTEGER;
|
|
tabs*: BOOLEAN;
|
|
|
|
|
|
PROCEDURE createVector* (size: INTEGER): tVector;
|
|
VAR
|
|
res: tVector;
|
|
BEGIN
|
|
IF size > 0 THEN
|
|
NEW(res);
|
|
res.size := size;
|
|
IF size < 4096 THEN
|
|
size := 4096
|
|
END;
|
|
res.data := API._NEW(size*SYSTEM.SIZE(tVectorItem));
|
|
IF res.data = 0 THEN
|
|
DISPOSE(res)
|
|
END
|
|
ELSE
|
|
res := NIL
|
|
END
|
|
RETURN res
|
|
END createVector;
|
|
|
|
|
|
PROCEDURE destroyVector* (VAR vector: tVector);
|
|
BEGIN
|
|
IF vector # NIL THEN
|
|
IF vector.data # 0 THEN
|
|
vector.data := API._DISPOSE(vector.data)
|
|
END;
|
|
DISPOSE(vector)
|
|
END
|
|
END destroyVector;
|
|
|
|
|
|
PROCEDURE setVectorItem* (vector: tVector; idx: INTEGER; item: tVectorItem);
|
|
BEGIN
|
|
ASSERT(vector # NIL);
|
|
ASSERT((0 <= idx) & (idx < vector.size));
|
|
SYSTEM.PUT(vector.data + idx*SYSTEM.SIZE(tVectorItem), item)
|
|
END setVectorItem;
|
|
|
|
|
|
PROCEDURE getVectorItem* (vector: tVector; idx: INTEGER): tVectorItem;
|
|
VAR
|
|
res: tVectorItem;
|
|
BEGIN
|
|
ASSERT(vector # NIL);
|
|
ASSERT((0 <= idx) & (idx < vector.size));
|
|
SYSTEM.GET(vector.data + idx*SYSTEM.SIZE(tVectorItem), res)
|
|
RETURN res
|
|
END getVectorItem;
|
|
|
|
|
|
PROCEDURE movInt (VAR v: INTEGER; x: INTEGER);
|
|
BEGIN
|
|
_movInt(v, x)
|
|
END movInt;
|
|
|
|
|
|
PROCEDURE movBool (line: tLine; VAR v: BOOLEAN; x: BOOLEAN);
|
|
BEGIN
|
|
_movBool(line, v, x)
|
|
END movBool;
|
|
|
|
|
|
PROCEDURE movBool2 (line: tLine; VAR v: BOOLEAN; x: BOOLEAN);
|
|
BEGIN
|
|
_movBool2(line, v, x)
|
|
END movBool2;
|
|
|
|
|
|
PROCEDURE movPtr (VAR v: List.tItem; x: List.tItem);
|
|
BEGIN
|
|
_movPtr(v, x)
|
|
END movPtr;
|
|
|
|
|
|
PROCEDURE malloc (size: INTEGER): INTEGER;
|
|
VAR
|
|
maxLength: INTEGER;
|
|
BEGIN
|
|
ASSERT(pMaxLength # 0);
|
|
SYSTEM.GET(pMaxLength, maxLength);
|
|
IF size > maxLength THEN
|
|
SYSTEM.PUT(pMaxLength, size)
|
|
END;
|
|
size := size*WCHAR_SIZE + 4;
|
|
INC(size, (-size) MOD 32)
|
|
RETURN API._NEW(size)
|
|
END malloc;
|
|
|
|
|
|
PROCEDURE free (line: tLine; newPtr: INTEGER);
|
|
BEGIN
|
|
IF line.ptr # 0 THEN
|
|
IF line.temp THEN
|
|
line.ptr := API._DISPOSE(line.ptr)
|
|
ELSE
|
|
line.ptr := 0
|
|
END
|
|
END;
|
|
IF ~line.temp THEN
|
|
movInt(line.ptr, newPtr);
|
|
IF newPtr # 0 THEN
|
|
_untypedPtr(newPtr)
|
|
END
|
|
END;
|
|
line.ptr := newPtr
|
|
END free;
|
|
|
|
|
|
PROCEDURE create* (temp: BOOLEAN): tLine;
|
|
VAR
|
|
line: tLine;
|
|
BEGIN
|
|
NEW(line);
|
|
line.label := FALSE;
|
|
ASSERT(line # NIL);
|
|
IF ~temp THEN
|
|
_typedPtr(line)
|
|
END;
|
|
line.next := NIL;
|
|
line.prev := NIL;
|
|
IF ~temp THEN
|
|
movPtr(line.next, NIL);
|
|
movPtr(line.prev, NIL)
|
|
END;
|
|
line.ptr := malloc(1);
|
|
ASSERT(line.ptr # 0);
|
|
IF ~temp THEN
|
|
_untypedPtr(line.ptr);
|
|
movInt(line.ptr, line.ptr)
|
|
END;
|
|
SYSTEM.PUT16(line.ptr, 0);
|
|
line.length := 0;
|
|
IF ~temp THEN
|
|
movInt(line.length, 0)
|
|
END;
|
|
line.temp := temp;
|
|
line.modified := FALSE;
|
|
line.saved := FALSE;
|
|
IF ~temp THEN
|
|
movBool(line, line.modified, FALSE);
|
|
movBool(line, line.saved, FALSE)
|
|
END;
|
|
line.cin := 0;
|
|
line.cout := 0;
|
|
line.pos := 0
|
|
RETURN line
|
|
END create;
|
|
|
|
|
|
PROCEDURE destroy* (VAR line: tLine);
|
|
BEGIN
|
|
IF line.temp THEN
|
|
free(line, 0);
|
|
DISPOSE(line)
|
|
ELSE
|
|
line := NIL
|
|
END
|
|
END destroy;
|
|
|
|
|
|
PROCEDURE resize* (line: tLine; size: INTEGER);
|
|
BEGIN
|
|
ASSERT(line.temp);
|
|
IF size > 0 THEN
|
|
line.ptr := API._DISPOSE(line.ptr);
|
|
size := size*WCHAR_SIZE + 4;
|
|
INC(size, (-size) MOD 32);
|
|
line.ptr := API._NEW(size)
|
|
ELSE
|
|
destroy(line)
|
|
END
|
|
END resize;
|
|
|
|
|
|
PROCEDURE getChar* (line: tLine; i: INTEGER): WCHAR;
|
|
VAR
|
|
res: WCHAR;
|
|
BEGIN
|
|
IF i >= line.length THEN
|
|
res := 0X
|
|
ELSE
|
|
SYSTEM.GET(line.ptr + i*WCHAR_SIZE, res)
|
|
END
|
|
RETURN res
|
|
END getChar;
|
|
|
|
|
|
PROCEDURE tabWidth (line: tLine; pos: INTEGER): INTEGER;
|
|
VAR
|
|
n: INTEGER;
|
|
BEGIN
|
|
n := pos;
|
|
IF getChar(line, pos) = TAB THEN
|
|
INC(pos);
|
|
WHILE getChar(line, pos) = TAB1 DO
|
|
INC(pos)
|
|
END
|
|
END
|
|
RETURN pos - n
|
|
END tabWidth;
|
|
|
|
|
|
PROCEDURE save* (line: tLine);
|
|
BEGIN
|
|
IF ~line.temp THEN
|
|
movBool2(line, line.saved, TRUE);
|
|
movBool2(line, line.modified, FALSE)
|
|
END;
|
|
line.modified := FALSE;
|
|
line.saved := TRUE
|
|
END save;
|
|
|
|
|
|
PROCEDURE isSpace* (c: WCHAR): BOOLEAN;
|
|
RETURN (c = SPACE) OR (c = TAB) OR (c = TAB1)
|
|
END isSpace;
|
|
|
|
|
|
PROCEDURE trimLength* (line: tLine): INTEGER;
|
|
VAR
|
|
i: INTEGER;
|
|
BEGIN
|
|
i := line.length - 1;
|
|
WHILE (i >= 0) & isSpace(getChar(line, i)) DO
|
|
DEC(i)
|
|
END
|
|
RETURN i + 1
|
|
END trimLength;
|
|
|
|
|
|
PROCEDURE getPChar* (line: tLine; i: INTEGER): INTEGER;
|
|
RETURN line.ptr + i*WCHAR_SIZE
|
|
END getPChar;
|
|
|
|
|
|
PROCEDURE setChar* (line: tLine; i: INTEGER; c: WCHAR);
|
|
BEGIN
|
|
SYSTEM.PUT(line.ptr + i*WCHAR_SIZE, c)
|
|
END setChar;
|
|
|
|
|
|
PROCEDURE move* (src, dst: tLine);
|
|
BEGIN
|
|
SYSTEM.MOVE(src.ptr, dst.ptr, (MIN(src.length, dst.length) + 1)*WCHAR_SIZE)
|
|
END move;
|
|
|
|
|
|
PROCEDURE delChar* (line: tLine; pos: INTEGER);
|
|
VAR
|
|
ptr: INTEGER;
|
|
BEGIN
|
|
IF pos < line.length THEN
|
|
ptr := malloc(line.length);
|
|
ASSERT(ptr # 0);
|
|
IF ~line.temp THEN
|
|
movInt(line.length, line.length - 1)
|
|
END;
|
|
DEC(line.length);
|
|
SYSTEM.MOVE(line.ptr, ptr, pos*WCHAR_SIZE);
|
|
SYSTEM.MOVE(line.ptr + pos*WCHAR_SIZE + WCHAR_SIZE, ptr + pos*WCHAR_SIZE, (line.length - pos)*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr + line.length*WCHAR_SIZE, 0);
|
|
free(line, ptr)
|
|
END
|
|
END delChar;
|
|
|
|
|
|
PROCEDURE insert* (line: tLine; pos: INTEGER; c: WCHAR);
|
|
VAR
|
|
ptr: INTEGER;
|
|
BEGIN
|
|
ptr := malloc(line.length + 2);
|
|
ASSERT(ptr # 0);
|
|
SYSTEM.MOVE(line.ptr, ptr, pos*WCHAR_SIZE);
|
|
SYSTEM.PUT(ptr + pos*WCHAR_SIZE, c);
|
|
SYSTEM.MOVE(line.ptr + pos*WCHAR_SIZE, ptr + pos*WCHAR_SIZE + WCHAR_SIZE, (line.length - pos)*WCHAR_SIZE);
|
|
IF ~line.temp THEN
|
|
movInt(line.length, line.length + 1)
|
|
END;
|
|
INC(line.length);
|
|
SYSTEM.PUT16(ptr + line.length*WCHAR_SIZE, 0);
|
|
free(line, ptr)
|
|
END insert;
|
|
|
|
|
|
PROCEDURE _insert2* (line1: tLine; pos: INTEGER; line2: tLine);
|
|
VAR
|
|
ptr: INTEGER;
|
|
BEGIN
|
|
IF line2.length > 0 THEN
|
|
ptr := malloc(line1.length + line2.length + 1);
|
|
ASSERT(ptr # 0);
|
|
SYSTEM.MOVE(line1.ptr, ptr, pos*WCHAR_SIZE);
|
|
SYSTEM.MOVE(line2.ptr, ptr + pos*WCHAR_SIZE, line2.length*WCHAR_SIZE);
|
|
SYSTEM.MOVE(line1.ptr + pos*WCHAR_SIZE, ptr + (pos + line2.length)*WCHAR_SIZE, (line1.length - pos)*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr + (line1.length + line2.length)*WCHAR_SIZE, 0);
|
|
IF ~line1.temp THEN
|
|
movInt(line1.length, line1.length + line2.length)
|
|
END;
|
|
IF ~line2.temp THEN
|
|
movInt(line2.length, 0)
|
|
END;
|
|
INC(line1.length, line2.length);
|
|
free(line1, ptr)
|
|
END
|
|
END _insert2;
|
|
|
|
|
|
PROCEDURE insert2* (line1: tLine; pos: INTEGER; line2: tLine);
|
|
BEGIN
|
|
_insert2(line1, pos, line2);
|
|
IF line2.length > 0 THEN
|
|
line2.length := 0;
|
|
free(line2, 0)
|
|
END
|
|
END insert2;
|
|
|
|
|
|
PROCEDURE insert3* (line: tLine; pos, n: INTEGER);
|
|
VAR
|
|
ptr: INTEGER;
|
|
BEGIN
|
|
IF n > 0 THEN
|
|
ptr := malloc(line.length + n + 1);
|
|
ASSERT(ptr # 0);
|
|
SYSTEM.MOVE(line.ptr, ptr, pos*WCHAR_SIZE);
|
|
SYSTEM.MOVE(line.ptr + pos*WCHAR_SIZE, ptr + (pos + n)*WCHAR_SIZE, (line.length - pos)*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr + (line.length + n)*WCHAR_SIZE, 0);
|
|
IF ~line.temp THEN
|
|
movInt(line.length, line.length + n)
|
|
END;
|
|
INC(line.length, n);
|
|
free(line, ptr)
|
|
END
|
|
END insert3;
|
|
|
|
|
|
PROCEDURE delCharN* (line: tLine; pos, n: INTEGER);
|
|
VAR
|
|
ptr: INTEGER;
|
|
BEGIN
|
|
IF n > 0 THEN
|
|
ptr := malloc(line.length - n + 1);
|
|
ASSERT(ptr # 0);
|
|
SYSTEM.MOVE(line.ptr, ptr, pos*WCHAR_SIZE);
|
|
SYSTEM.MOVE(line.ptr + (pos + n)*WCHAR_SIZE, ptr + pos*WCHAR_SIZE, (line.length - pos - n)*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr + (line.length - n)*WCHAR_SIZE, 0);
|
|
IF ~line.temp THEN
|
|
movInt(line.length, line.length - n)
|
|
END;
|
|
DEC(line.length, n);
|
|
free(line, ptr)
|
|
END
|
|
END delCharN;
|
|
|
|
|
|
PROCEDURE fixTabs (line: tLine);
|
|
VAR
|
|
i, n, k: INTEGER;
|
|
BEGIN
|
|
i := 0;
|
|
WHILE i < line.length DO
|
|
n := tabWidth(line, i);
|
|
IF n # 0 THEN
|
|
k := tab - i MOD tab;
|
|
IF n > k THEN
|
|
delCharN(line, i + 1, n - k)
|
|
ELSIF n < k THEN
|
|
DEC(k, n);
|
|
insert3(line, i + 1, k);
|
|
WHILE k > 0 DO
|
|
setChar(line, i + 1, TAB1);
|
|
INC(i);
|
|
DEC(k)
|
|
END
|
|
END
|
|
END;
|
|
INC(i)
|
|
END
|
|
END fixTabs;
|
|
|
|
|
|
PROCEDURE modify* (line: tLine);
|
|
BEGIN
|
|
IF ~line.temp THEN
|
|
movBool(line, line.modified, TRUE);
|
|
movBool(line, line.saved, FALSE)
|
|
END;
|
|
line.modified := TRUE;
|
|
line.saved := FALSE;
|
|
fixTabs(line)
|
|
END modify;
|
|
|
|
|
|
PROCEDURE wrap* (line, nextLine: tLine; pos: INTEGER);
|
|
VAR
|
|
ptr1, ptr2: INTEGER;
|
|
n: INTEGER;
|
|
BEGIN
|
|
ptr1 := malloc(pos + 1);
|
|
ASSERT(ptr1 # 0);
|
|
n := line.length - pos;
|
|
ptr2 := malloc(n + 1);
|
|
ASSERT(ptr2 # 0);
|
|
SYSTEM.MOVE(line.ptr, ptr1, pos*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr1 + pos*WCHAR_SIZE, 0);
|
|
SYSTEM.MOVE(line.ptr + pos*WCHAR_SIZE, ptr2, n*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr2 + n*WCHAR_SIZE, 0);
|
|
IF ~line.temp THEN
|
|
movInt(line.length, pos)
|
|
END;
|
|
IF ~nextLine.temp THEN
|
|
movInt(nextLine.length, n)
|
|
END;
|
|
line.length := pos;
|
|
nextLine.length := n;
|
|
free(line, ptr1);
|
|
free(nextLine, ptr2)
|
|
END wrap;
|
|
|
|
|
|
PROCEDURE copy* (line: tLine);
|
|
VAR
|
|
ptr: INTEGER;
|
|
BEGIN
|
|
ptr := malloc(line.length + 1);
|
|
ASSERT(ptr # 0);
|
|
SYSTEM.MOVE(line.ptr, ptr, line.length*WCHAR_SIZE);
|
|
SYSTEM.PUT16(ptr + line.length*WCHAR_SIZE, 0);
|
|
free(line, ptr)
|
|
END copy;
|
|
|
|
|
|
PROCEDURE convert* (line: tLine; pos1, pos2: INTEGER; func: fConvert): BOOLEAN;
|
|
VAR
|
|
i: INTEGER;
|
|
modified: BOOLEAN;
|
|
c: WCHAR;
|
|
BEGIN
|
|
ASSERT(func # NIL);
|
|
modified := FALSE;
|
|
i := pos2;
|
|
WHILE i >= pos1 DO
|
|
c := getChar(line, i);
|
|
IF func(c) THEN
|
|
modified := TRUE
|
|
END;
|
|
DEC(i)
|
|
END;
|
|
|
|
IF modified THEN
|
|
copy(line);
|
|
i := pos2;
|
|
WHILE i >= pos1 DO
|
|
c := getChar(line, i);
|
|
IF func(c) THEN
|
|
setChar(line, i, c)
|
|
END;
|
|
DEC(i)
|
|
END;
|
|
modify(line)
|
|
END
|
|
RETURN modified
|
|
END convert;
|
|
|
|
|
|
PROCEDURE init* (movInt: PmovInt; movPtr: PmovPtr; movBool, movBool2: PmovBool; typedPtr: PTypedPtr; untypedPtr: PUntypedPtr);
|
|
BEGIN
|
|
_movInt := movInt;
|
|
_movPtr := movPtr;
|
|
_movBool := movBool;
|
|
_movBool2 := movBool2;
|
|
_typedPtr := typedPtr;
|
|
_untypedPtr := untypedPtr;
|
|
END init;
|
|
|
|
|
|
PROCEDURE setMaxLength* (VAR maxLength: INTEGER);
|
|
BEGIN
|
|
pMaxLength := SYSTEM.ADR(maxLength)
|
|
END setMaxLength;
|
|
|
|
|
|
PROCEDURE setTabs* (_tab: INTEGER);
|
|
BEGIN
|
|
IF _tab = 0 THEN
|
|
_tab := 4
|
|
END;
|
|
tabs := _tab > 0;
|
|
tab := ABS(_tab);
|
|
IF tab > 32 THEN
|
|
tab := 32
|
|
END
|
|
END setTabs;
|
|
|
|
|
|
BEGIN
|
|
pMaxLength := 0
|
|
END Lines. |