Subversion Repositories Kolibri OS

Rev

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

Rev 9336 Rev 9448
Line 17... Line 17...
17 
    along with CEdit. If not, see .
 17 
    along with CEdit. If not, see .
18 
*)
 18 
*)
Line 19... Line 19...
19 
 
 19 
 
Line 20... Line 20...
20 
MODULE ChangeLog;
 20 
MODULE ChangeLog;
Line 21... Line 21...
21 
 
 21 
 
22 
IMPORT List, Lines, (*API,*) SYSTEM;
 22 
IMPORT List, Lines, API, SYSTEM;
23 
 
 23 
 
24 
TYPE
 24 
TYPE
Line 25... Line 25...
25 
    tIntItem = POINTER TO RECORD (List.tItem)
 25 
    tIntItem = POINTER TO RECORD (List.tItem)
26 
        adr, val: INTEGER
 26 
        adr, val: INTEGER
27 
    END;
 27 
    END;
28 
 
 28 
 
29 
    tBoolItem = POINTER TO RECORD (List.tItem)
 29 
    tBoolItem = POINTER TO RECORD (List.tItem)
30 
        adr: INTEGER; val: BOOLEAN; save: BOOLEAN
 30 
        adr: INTEGER; val: BOOLEAN; save: BOOLEAN
31 
    END;
 31 
    END;
Line 32... Line 32...
32 
(*
 32 
 
33 
    tUntypedPtr = POINTER TO RECORD (List.tItem)
 33 
    tUntypedPtr = POINTER TO RECORD (List.tItem)
34 
        p: INTEGER
 34 
        p: INTEGER
35 
    END;
 35 
    END;
36 
 
 36 
 
37 
    tTypedPtr = POINTER TO RECORD (List.tItem)
 37 
    tTypedPtr = POINTER TO RECORD (List.tItem)
38 
        p: List.tItem
 38 
        p: List.tItem
Line 39... Line 39...
39 
    END;
 39 
    END;
40 
*)
 40 
 
41 
    tGuard* = POINTER TO RECORD (List.tItem)
 41 
    tGuard* = POINTER TO RECORD (List.tItem)
42 
        saved*: BOOLEAN
 42 
        saved*: BOOLEAN
43 
    END;
 43 
    END;
Line 102... Line 102...
102 
 
 102 
 
103 
 
 103 
 
104 
PROCEDURE clear (guard: tGuard);
 104 
PROCEDURE clear (guard: tGuard);
105 
VAR
 - 
 
106 
    item: List.tItem;
 105 
VAR
107 
    (*res: INTEGER;*)
 106 
    item: List.tItem;
108 
BEGIN
 107 
BEGIN
109 
    CL.isLast := TRUE;
 108 
    CL.isLast := TRUE;
110 
    REPEAT
 109 
    REPEAT
111 
        item := List.pop(CL.Log);
 - 
 
112 
        IF item # guard THEN
 - 
 
113 
        (*
 - 
 
114 
            IF item IS tUntypedPtr THEN
 - 
 
115 
                res := API._DISPOSE(item(tUntypedPtr).p)
 - 
 
116 
            ELSIF item IS tTypedPtr THEN
 - 
 
117 
                DISPOSE(item(tTypedPtr).p)
 110 
        item := List.pop(CL.Log);
118 
            END;*)
 111 
        IF item # guard THEN
119 
            DISPOSE(item)
 112 
            DISPOSE(item)
120 
        END
 113 
        END
121 
    UNTIL item = guard;
 114 
    UNTIL item = guard;
Line 251... Line 244...
251 
PROCEDURE changePtr (VAR v: List.tItem; x: List.tItem);
 244 
PROCEDURE changePtr (VAR v: List.tItem; x: List.tItem);
252 
BEGIN
 245 
BEGIN
253 
    changeWord(SYSTEM.ADR(v), SYSTEM.ADR(x))
 246 
    changeWord(SYSTEM.ADR(v), SYSTEM.ADR(x))
254 
END changePtr;
 247 
END changePtr;
Line 255... Line 248...
255 
 
 248 
 
256 
(*
 249 
 
257 
PROCEDURE typedPtr (p: List.tItem);
 250 
PROCEDURE typedPtr (p: List.tItem);
258 
VAR
 251 
VAR
259 
    item: tTypedPtr;
 252 
    item: tTypedPtr;
260 
BEGIN
 253 
BEGIN
261 
    NEW(item);
 254 
    NEW(item);
262 
    item.p := p;
 255 
    item.p := p;
263 
    List.append(Log, item)
 256 
    List.append(CL.Pointers, item)
Line 264... Line 257...
264 
END typedPtr;
 257 
END typedPtr;
265 
 
 258 
 
266 
 
 259 
 
267 
PROCEDURE untypedPtr (p: INTEGER);
 260 
PROCEDURE untypedPtr (p: INTEGER);
268 
VAR
 261 
VAR
269 
    item: tUntypedPtr;
 262 
    item: tUntypedPtr;
270 
BEGIN
 263 
BEGIN
271 
    NEW(item);
 264 
    NEW(item);
272 
    item.p := p;
 265 
    item.p := p;
Line 273... Line 266...
273 
    List.append(Log, item)
 266 
    List.append(CL.Pointers, item)
274 
END untypedPtr;
 267 
END untypedPtr;
275 
*)
 268 
 
276 
 
 269 
 
Line 286... Line 279...
286 
BEGIN
 279 
BEGIN
287 
    NEW(newLog);
 280 
    NEW(newLog);
288 
    newLog.guard := NIL;
 281 
    newLog.guard := NIL;
289 
    newLog.isLast := TRUE;
 282 
    newLog.isLast := TRUE;
290 
    newLog.Log := List.create(NIL);
 283 
    newLog.Log := List.create(NIL);
- 
 
 284 
    newLog.Pointers := List.create(NIL);
291 
    CL := newLog;
 285 
    CL := newLog;
292 
    Lines.setMaxLength(maxLength)
 286 
    Lines.setMaxLength(maxLength)
293 
    RETURN newLog
 287 
    RETURN newLog
294 
END create;
 288 
END create;
Line -... Line 289...
- 
 
 289 
 
- 
 
 290 
 
- 
 
 291 
PROCEDURE destroy* (VAR log: tLog);
- 
 
 292 
VAR
- 
 
 293 
	item: List.tItem;
- 
 
 294 
	res: INTEGER;
- 
 
 295 
BEGIN
- 
 
 296 
	IF log # NIL THEN
- 
 
 297 
		item := List.pop(log.Log);
- 
 
 298 
		WHILE item # NIL DO
- 
 
 299 
			DISPOSE(item);
- 
 
 300 
			item := List.pop(log.Log)
- 
 
 301 
		END;
- 
 
 302 
		DISPOSE(log.Log);
- 
 
 303 
 
- 
 
 304 
		item := List.pop(log.Pointers);
- 
 
 305 
		WHILE item # NIL DO
- 
 
 306 
            IF item IS tUntypedPtr THEN
- 
 
 307 
                res := API._DISPOSE(item(tUntypedPtr).p)
- 
 
 308 
            ELSIF item IS tTypedPtr THEN
- 
 
 309 
                DISPOSE(item(tTypedPtr).p)
- 
 
 310 
            END;
- 
 
 311 
			DISPOSE(item);
- 
 
 312 
			item := List.pop(log.Pointers)
- 
 
 313 
		END;
- 
 
 314 
		DISPOSE(log.Pointers);
- 
 
 315 
 
- 
 
 316 
		DISPOSE(log)
- 
 
 317 
	END
- 
 
 318 
END destroy;
295 
 
 319 
 
296 
 
 320 
 
297 
BEGIN
 321 
BEGIN
298 
    List.init(changeInt, changePtr);
 322 
    List.init(changeInt, changePtr);
299 
    Lines.init(changeInt, changePtr, changeBool, changeBool2(*, typedPtr, untypedPtr*))
 323 
    Lines.init(changeInt, changePtr, changeBool, changeBool2, typedPtr, untypedPtr)