Subversion Repositories Kolibri OS

Rev

Rev 9674 | Rev 9903 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 9674 Rev 9902
Line 1... Line 1...
1 
(*
 1 
(*
2 
    Copyright 2021, 2022 Anton Krotov
 2 
    Copyright 2021-2023 Anton Krotov
Line 3... Line 3...
3 
 
 3 
 
Line 4... Line 4...
4 
    This file is part of CEdit.
 4 
    This file is part of CEdit.
5 
 
 5 
 
Line 21... Line 21...
21 
 
 21 
 
Line 22... Line 22...
22 
IMPORT List, Lines, API, SYSTEM;
 22 
IMPORT List, Lines, API, SYSTEM;
23 
 
 23 
 
- 
 
 24 
TYPE
24 
TYPE
 25 
    tIntItem = POINTER TO RECORD (List.tItem)
25 
    tIntItem = POINTER TO RECORD (List.tItem)
 26 
    	cnt: INTEGER;
Line 26... Line 27...
26 
        adr, val: INTEGER
 27 
    	adr, val: ARRAY 8 OF INTEGER
27 
    END;
 28 
    END;
28 
 
 29 
 
29 
    tBoolItem = POINTER TO RECORD (List.tItem)
 30 
    tBoolItem = POINTER TO RECORD (List.tItem)
30 
        line: Lines.tLine;
 31 
        line: Lines.tLine;
Line 31... Line 32...
31 
        adr: INTEGER;
 32 
        adr: INTEGER;
32 
        val, save: BOOLEAN
 33 
        val, save: BOOLEAN
- 
 
 34 
    END;
33 
    END;
 35 
 
Line 34... Line 36...
34 
 
 36 
    tUntypedPtr = POINTER TO RECORD (List.tItem)
- 
 
 37 
    	cnt: INTEGER;
35 
    tUntypedPtr = POINTER TO RECORD (List.tItem)
 38 
    	p: ARRAY 64 OF INTEGER
36 
        p: INTEGER
 39 
    END;
Line 37... Line 40...
37 
    END;
 40 
 
38 
 
 41 
    tTypedPtr = POINTER TO RECORD (List.tItem)
39 
    tTypedPtr = POINTER TO RECORD (List.tItem)
 42 
    	cnt: INTEGER;
Line 40... Line 43...
40 
        p: List.tItem
 43 
    	p: ARRAY 64 OF List.tItem
41 
    END;
 44 
    END;
42 
 
 45 
 
43 
    tGuard* = POINTER TO RECORD (List.tItem)
 46 
    tGuard* = POINTER TO RECORD (List.tItem)
44 
        saved*: BOOLEAN
 47 
        saved*: BOOLEAN
Line 101... Line 104...
101 
    CL.isLast := isLastGuard(_guard)
 104 
    CL.isLast := isLastGuard(_guard)
102 
END setGuard;
 105 
END setGuard;
Line 103... Line 106...
103 
 
 106 
 
- 
 
 107 
 
- 
 
 108 
PROCEDURE redo* (item: List.tItem);
104 
 
 109 
VAR
105 
PROCEDURE redo* (item: List.tItem);
 110 
	i: INTEGER;
- 
 
 111 
BEGIN
106 
BEGIN
 112 
	IF item IS tIntItem THEN
- 
 
 113 
		FOR i := 0 TO item(tIntItem).cnt - 1 DO
107 
    IF item IS tIntItem THEN
 114 
			SYSTEM.PUT(item(tIntItem).adr[i], item(tIntItem).val[i])
108 
        SYSTEM.PUT(item(tIntItem).adr, item(tIntItem).val)
 115 
		END
109 
    ELSIF item IS tBoolItem THEN
 116 
	ELSIF item IS tBoolItem THEN
110 
        SYSTEM.PUT(item(tBoolItem).adr, item(tBoolItem).val)
 117 
		SYSTEM.PUT(item(tBoolItem).adr, item(tBoolItem).val)
Line 161... Line 168...
161 
 
 168 
 
162 
 
 169 
 
163 
PROCEDURE changeWord (adrV, adrX: INTEGER);
 170 
PROCEDURE changeWord (adrV, adrX: INTEGER);
- 
 
 171 
VAR
164 
VAR
 172 
	item: tIntItem;
165 
    item: tIntItem;
 - 
 
166 
BEGIN
 - 
 
167 
    NEW(item);
 - 
 
168 
    item.adr := adrV;
 173 
	cur: List.tItem;
169 
    SYSTEM.GET(adrX, item.val);
 174 
BEGIN
170 
    IF ~CL.isLast THEN
 175 
	IF ~CL.isLast THEN
- 
 
 176 
		clear(CL.guard)
- 
 
 177 
	END;
- 
 
 178 
	cur := CL.Log.last;
- 
 
 179 
	WHILE (cur # NIL) & ~(cur IS tGuard) & ~(cur IS tIntItem) DO
- 
 
 180 
		cur := cur.prev
- 
 
 181 
	END;
- 
 
 182 
	IF (cur IS tIntItem) & (cur(tIntItem).cnt < LEN(cur(tIntItem).adr)) THEN
- 
 
 183 
		item := cur(tIntItem)
- 
 
 184 
	ELSE
171 
        clear(CL.guard)
 185 
		NEW(item);
- 
 
 186 
		item.cnt := 0;
- 
 
 187 
		List.append(CL.Log, item)
- 
 
 188 
	END;
- 
 
 189 
	item.adr[item.cnt] := adrV;
172 
    END;
 190 
	SYSTEM.GET(adrX, item.val[item.cnt]);
Line 173... Line 191...
173 
    List.append(CL.Log, item)
 191 
	INC(item.cnt)
174 
END changeWord;
 192 
END changeWord;
Line 264... Line 282...
264 
 
 282 
 
265 
PROCEDURE typedPtr (p: List.tItem);
 283 
PROCEDURE typedPtr (p: List.tItem);
266 
VAR
 284 
VAR
267 
    item: tTypedPtr;
 285 
	item: tTypedPtr;
- 
 
 286 
BEGIN
- 
 
 287 
	item := CL.TPointers.last(tTypedPtr);
268 
BEGIN
 288 
	IF (item = NIL) OR (item.cnt = LEN(item.p)) THEN
269 
    NEW(item);
 289 
		NEW(item);
270 
    item.p := p;
 290 
		item.cnt := 0;
- 
 
 291 
		List.append(CL.TPointers, item)
- 
 
 292 
	END;
- 
 
 293 
	item.p[item.cnt] := p;
271 
    List.append(CL.Pointers, item)
 294 
	INC(item.cnt)
Line 272... Line 295...
272 
END typedPtr;
 295 
END typedPtr;
273 
 
 296 
 
274 
 
 297 
 
275 
PROCEDURE untypedPtr (p: INTEGER);
 298 
PROCEDURE untypedPtr (p: INTEGER);
- 
 
 299 
VAR
- 
 
 300 
	item: tUntypedPtr;
276 
VAR
 301 
BEGIN
277 
    item: tUntypedPtr;
 302 
	item := CL.UPointers.last(tUntypedPtr);
278 
BEGIN
 303 
	IF (item = NIL) OR (item.cnt = LEN(item.p)) THEN
- 
 
 304 
		NEW(item);
- 
 
 305 
		item.cnt := 0;
- 
 
 306 
		List.append(CL.UPointers, item)
279 
    NEW(item);
 307 
	END;
Line 280... Line 308...
280 
    item.p := p;
 308 
	item.p[item.cnt] := p;
281 
    List.append(CL.Pointers, item)
 309 
	INC(item.cnt)
282 
END untypedPtr;
 310 
END untypedPtr;
283 
 
 311 
 
Line 284... Line 312...
284 
 
 312 
 
285 
PROCEDURE set* (_CL: tLog);
 313 
PROCEDURE setLog* (_CL: tLog);
286 
BEGIN
 314 
BEGIN
Line 295... Line 323...
295 
    NEW(newLog);
 323 
    NEW(newLog);
296 
    newLog.guard := NIL;
 324 
    newLog.guard := NIL;
297 
    newLog.first := NIL;
 325 
    newLog.first := NIL;
298 
    newLog.isLast := TRUE;
 326 
    newLog.isLast := TRUE;
299 
    newLog.Log := List.create(NIL);
 327 
    newLog.Log := List.create(NIL);
- 
 
 328 
    newLog.TPointers := List.create(NIL);
300 
    newLog.Pointers := List.create(NIL);
 329 
    newLog.UPointers := List.create(NIL);
301 
    CL := newLog;
 330 
    CL := newLog;
302 
    Lines.setMaxLength(maxLength)
 331 
    Lines.setMaxLength(maxLength)
303 
    RETURN newLog
 332 
    RETURN newLog
304 
END create;
 333 
END create;
Line 305... Line 334...
305 
 
 334 
 
306 
 
 335 
 
307 
PROCEDURE destroy* (VAR log: tLog);
 336 
PROCEDURE destroy* (VAR log: tLog);
308 
VAR
 337 
VAR
309 
	item: List.tItem;
 338 
	item: List.tItem;
310 
	res: INTEGER;
 339 
	res, i: INTEGER;
311 
BEGIN
 340 
BEGIN
312 
	IF log # NIL THEN
 341 
	IF log # NIL THEN
313 
		item := List.pop(log.Log);
 342 
		item := List.pop(log.Log);
314 
		WHILE item # NIL DO
 343 
		WHILE item # NIL DO
315 
			DISPOSE(item);
 344 
			DISPOSE(item);
316 
			item := List.pop(log.Log)
 345 
			item := List.pop(log.Log)
Line 317... Line 346...
317 
		END;
 346 
		END;
- 
 
 347 
		DISPOSE(log.Log);
- 
 
 348 
 
- 
 
 349 
		item := List.pop(log.TPointers);
- 
 
 350 
		WHILE item # NIL DO
- 
 
 351 
			FOR i := 0 TO item(tTypedPtr).cnt - 1 DO
- 
 
 352 
				DISPOSE(item(tTypedPtr).p[i])
- 
 
 353 
			END;
- 
 
 354 
			DISPOSE(item);
- 
 
 355 
			item := List.pop(log.TPointers)
- 
 
 356 
		END;
318 
		DISPOSE(log.Log);
 357 
		DISPOSE(log.TPointers);
319 
 
 358 
 
320 
		item := List.pop(log.Pointers);
 359 
		item := List.pop(log.UPointers);
321 
		WHILE item # NIL DO
 - 
 
322 
            IF item IS tUntypedPtr THEN
 - 
 
323 
                res := API._DISPOSE(item(tUntypedPtr).p)
 360 
		WHILE item # NIL DO
324 
            ELSIF item IS tTypedPtr THEN
 361 
			FOR i := 0 TO item(tUntypedPtr).cnt - 1 DO
325 
                DISPOSE(item(tTypedPtr).p)
 362 
				res := API._DISPOSE(item(tUntypedPtr).p[i])
326 
            END;
 363 
			END;
327 
			DISPOSE(item);
 364 
			DISPOSE(item);
Line 328... Line 365...
328 
			item := List.pop(log.Pointers)
 365 
			item := List.pop(log.UPointers)
329 
		END;
 366 
		END;
330 
		DISPOSE(log.Pointers);
 367 
		DISPOSE(log.UPointers);