Subversion Repositories Kolibri OS

Rev

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

Rev 9902 Rev 9903
Line 19... Line 19...
19 
 
 19 
 
Line 20... Line 20...
20 
MODULE ChangeLog;
 20 
MODULE ChangeLog;
Line -... Line 21...
- 
 
 21 
 
- 
 
 22 
IMPORT List, Lines, API, SYSTEM;
- 
 
 23 
 
- 
 
 24 
CONST
21 
 
 25 
	boolItemSize = 8;
22 
IMPORT List, Lines, API, SYSTEM;
 26 
	fillMap = {0..boolItemSize-1};
23 
 
 27 
 
24 
TYPE
 28 
TYPE
25 
    tIntItem = POINTER TO RECORD (List.tItem)
 29 
	tIntItem = POINTER TO RECORD (List.tItem)
Line 26... Line 30...
26 
    	cnt: INTEGER;
 30 
		cnt: INTEGER;
- 
 
 31 
		adr, val: ARRAY 8 OF INTEGER
- 
 
 32 
	END;
- 
 
 33 
 
27 
    	adr, val: ARRAY 8 OF INTEGER
 34 
	tBoolItem = POINTER TO RECORD (List.tItem)
28 
    END;
 35 
		map: SET;
29 
 
 36 
		data: ARRAY boolItemSize OF
- 
 
 37 
			RECORD
30 
    tBoolItem = POINTER TO RECORD (List.tItem)
 38 
				line: Lines.tLine;
Line 31... Line 39...
31 
        line: Lines.tLine;
 39 
				adr: INTEGER;
32 
        adr: INTEGER;
 40 
				val, save: BOOLEAN
33 
        val, save: BOOLEAN
 41 
			END
Line 112... Line 120...
112 
	IF item IS tIntItem THEN
 120 
	IF item IS tIntItem THEN
113 
		FOR i := 0 TO item(tIntItem).cnt - 1 DO
 121 
		FOR i := 0 TO item(tIntItem).cnt - 1 DO
114 
			SYSTEM.PUT(item(tIntItem).adr[i], item(tIntItem).val[i])
 122 
			SYSTEM.PUT(item(tIntItem).adr[i], item(tIntItem).val[i])
115 
		END
 123 
		END
116 
	ELSIF item IS tBoolItem THEN
 124 
	ELSIF item IS tBoolItem THEN
- 
 
 125 
		FOR i := 0 TO boolItemSize - 1 DO
- 
 
 126 
			IF i IN item(tBoolItem).map THEN
117 
		SYSTEM.PUT(item(tBoolItem).adr, item(tBoolItem).val)
 127 
				SYSTEM.PUT(item(tBoolItem).data[i].adr, item(tBoolItem).data[i].val)
- 
 
 128 
			END
- 
 
 129 
		END
118 
	END
 130 
	END
119 
END redo;
 131 
END redo;
Line 120... Line 132...
120 
 
 132 
 
Line 137... Line 149...
137 
PROCEDURE save* (guard: tGuard);
 149 
PROCEDURE save* (guard: tGuard);
138 
VAR
 150 
VAR
139 
	item: List.tItem;
 151 
	item: List.tItem;
140 
	boolItem: tBoolItem;
 152 
	boolItem: tBoolItem;
141 
	cur: List.tItem;
 153 
	cur: List.tItem;
142 
	del: BOOLEAN;
 154 
	i: INTEGER;
143 
BEGIN
 155 
BEGIN
144 
    item := CL.Log.first;
 156 
	item := CL.Log.first;
145 
    WHILE item # NIL DO
 157 
	WHILE item # NIL DO
146 
        IF item IS tGuard THEN
 158 
		IF item IS tGuard THEN
147 
            item(tGuard).saved := FALSE
 159 
			item(tGuard).saved := FALSE
Line 152... Line 164...
152 
 
 164 
 
153 
    cur := CL.guard.prev;
 165 
	cur := CL.guard.prev;
154 
    WHILE cur # NIL DO
 166 
	WHILE cur # NIL DO
155 
        IF cur IS tBoolItem THEN
 167 
		IF cur IS tBoolItem THEN
- 
 
 168 
			boolItem := cur(tBoolItem);
156 
            boolItem := cur(tBoolItem);
 169 
			FOR i := 0 TO boolItemSize - 1 DO
157 
            del := boolItem.save & boolItem.line.modified
 170 
				IF (i IN boolItem.map) & boolItem.data[i].save &
158 
        ELSE
 171 
						boolItem.data[i].line.modified THEN
- 
 
 172 
					EXCL(boolItem.map, i)
- 
 
 173 
				END
159 
            del := FALSE
 174 
			END
160 
        END;
 175 
		END;
161 
        cur := cur.prev;
 176 
		cur := cur.prev;
162 
        IF del THEN
 177 
		IF boolItem.map = {} THEN
163 
            List.delete(CL.Log, boolItem);
 178 
			List.delete(CL.Log, boolItem);
164 
            DISPOSE(boolItem)
 179 
			DISPOSE(boolItem)
165 
        END
 180 
		END
166 
    END
 181 
	END
Line 190... Line 205...
190 
	SYSTEM.GET(adrX, item.val[item.cnt]);
 205 
	SYSTEM.GET(adrX, item.val[item.cnt]);
191 
	INC(item.cnt)
 206 
	INC(item.cnt)
192 
END changeWord;
 207 
END changeWord;
Line 193... Line -...
193 
 
 - 
 
194 
 
 - 
 
195 
PROCEDURE changeBool (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
 - 
 
196 
VAR
 - 
 
197 
    item: tBoolItem;
 - 
 
198 
BEGIN
 - 
 
199 
    NEW(item);
 - 
 
200 
    item.line := line;
 - 
 
201 
    item.adr := SYSTEM.ADR(v);
 - 
 
202 
    item.val := x;
 - 
 
203 
    item.save := FALSE;
 - 
 
204 
    IF ~CL.isLast THEN
 - 
 
205 
        clear(CL.guard)
 - 
 
206 
    END;
 - 
 
207 
    List.append(CL.Log, item)
 - 
 
208 
END changeBool;
 - 
 
209 
 
 208 
 
210 
 
 209 
 
211 
PROCEDURE delSaved*;
 210 
PROCEDURE delSaved*;
212 
VAR
 211 
VAR
213 
    boolItem: tBoolItem;
 212 
	boolItem: tBoolItem;
214 
    cur: List.tItem;
 213 
	cur: List.tItem;
215 
    del: BOOLEAN;
 214 
	i: INTEGER;
216 
BEGIN
 215 
BEGIN
217 
    cur := CL.guard.next;
 216 
	cur := CL.guard.next;
218 
    WHILE cur # NIL DO
 217 
	WHILE cur # NIL DO
219 
        IF cur IS tBoolItem THEN
 218 
		IF cur IS tBoolItem THEN
220 
            boolItem := cur(tBoolItem);
 219 
			boolItem := cur(tBoolItem);
221 
            del := boolItem.save
 220 
			FOR i := 0 TO boolItemSize - 1 DO
- 
 
 221 
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
- 
 
 222 
					EXCL(boolItem.map, i)
222 
        ELSE
 223 
				END
223 
            del := FALSE
 224 
			END
224 
        END;
 225 
		END;
225 
        cur := cur.next;
 226 
		cur := cur.next;
226 
        IF del THEN
 227 
		IF boolItem.map = {} THEN
227 
            List.delete(CL.Log, boolItem);
 228 
			List.delete(CL.Log, boolItem);
228 
            DISPOSE(boolItem)
 229 
			DISPOSE(boolItem)
229 
        END
 230 
		END
Line 233... Line 234...
233 
 
 234 
 
234 
PROCEDURE delCurSaved*;
 235 
PROCEDURE delCurSaved*;
235 
VAR
 236 
VAR
236 
    boolItem: tBoolItem;
 237 
	boolItem: tBoolItem;
237 
    cur: List.tItem;
 238 
	cur: List.tItem;
238 
    del: BOOLEAN;
 239 
	i: INTEGER;
239 
BEGIN
 240 
BEGIN
240 
    cur := CL.guard.prev;
 241 
	cur := CL.guard.prev;
241 
    WHILE (cur # NIL) & ~(cur IS tGuard) DO
 242 
	WHILE (cur # NIL) & ~(cur IS tGuard) DO
242 
        IF cur IS tBoolItem THEN
 243 
		IF cur IS tBoolItem THEN
243 
            boolItem := cur(tBoolItem);
 244 
			boolItem := cur(tBoolItem);
244 
            del := boolItem.save
 245 
			FOR i := 0 TO boolItemSize - 1 DO
- 
 
 246 
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
245 
        ELSE
 247 
					SYSTEM.PUT(boolItem.data[i].adr, ~boolItem.data[i].val);
- 
 
 248 
					EXCL(boolItem.map, i)
- 
 
 249 
				END
246 
            del := FALSE
 250 
			END
247 
        END;
 251 
		END;
248 
        cur := cur.prev;
 252 
		cur := cur.prev;
249 
        IF del THEN
 - 
 
250 
            SYSTEM.PUT(boolItem.adr, ~boolItem.val);
 253 
		IF boolItem.map = {} THEN
251 
            List.delete(CL.Log, boolItem);
 254 
			List.delete(CL.Log, boolItem);
252 
            DISPOSE(boolItem)
 255 
			DISPOSE(boolItem)
253 
        END
 256 
		END
254 
    END
 257 
	END
Line 255... Line 258...
255 
END delCurSaved;
 258 
END delCurSaved;
256 
 
 259 
 
257 
 
 260 
 
- 
 
 261 
PROCEDURE _changeBool (fn2: BOOLEAN; line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
- 
 
 262 
VAR
258 
PROCEDURE changeBool2 (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
 263 
	item: tBoolItem;
- 
 
 264 
	cur: List.tItem;
- 
 
 265 
	i: INTEGER;
- 
 
 266 
BEGIN
- 
 
 267 
	IF fn2 THEN
- 
 
 268 
		cur := CL.guard.prev
- 
 
 269 
	ELSE
- 
 
 270 
		IF ~CL.isLast THEN
- 
 
 271 
			clear(CL.guard)
- 
 
 272 
		END;
- 
 
 273 
		cur := CL.Log.last
- 
 
 274 
	END;
- 
 
 275 
 
- 
 
 276 
	WHILE (cur # NIL) & ~(cur IS tGuard) &
- 
 
 277 
			(~(cur IS tBoolItem) OR (cur(tBoolItem).map = fillMap)) DO
- 
 
 278 
		cur := cur.prev
- 
 
 279 
	END;
259 
VAR
 280 
	IF (cur IS tBoolItem) & (cur(tBoolItem).map # fillMap) THEN
260 
    item: tBoolItem;
 - 
 
261 
BEGIN
 - 
 
262 
    NEW(item);
 281 
		item := cur(tBoolItem)
263 
    item.line := line;
 282 
	ELSE
264 
    item.adr := SYSTEM.ADR(v);
 283 
		NEW(item);
- 
 
 284 
		item.map := {};
- 
 
 285 
		IF fn2 THEN
- 
 
 286 
			List.insert(CL.Log, CL.guard.prev, item)
- 
 
 287 
		ELSE
- 
 
 288 
			List.append(CL.Log, item)
- 
 
 289 
		END
- 
 
 290 
	END;
- 
 
 291 
 
- 
 
 292 
	i := 0;
- 
 
 293 
	WHILE i < boolItemSize DO
- 
 
 294 
		IF ~(i IN item.map) THEN
- 
 
 295 
			item.data[i].line := line;
- 
 
 296 
			item.data[i].adr := SYSTEM.ADR(v);
- 
 
 297 
			item.data[i].val := x;
- 
 
 298 
			item.data[i].save := fn2;
- 
 
 299 
			INCL(item.map, i);
- 
 
 300 
			i := boolItemSize
- 
 
 301 
		END;
- 
 
 302 
		INC(i)
- 
 
 303 
	END
- 
 
 304 
END _changeBool;
- 
 
 305 
 
- 
 
 306 
 
- 
 
 307 
PROCEDURE changeBool (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
- 
 
 308 
BEGIN
- 
 
 309 
	_changeBool(FALSE, line, v, x)
- 
 
 310 
END changeBool;
- 
 
 311 
 
- 
 
 312 
 
265 
    item.val := x;
 313 
PROCEDURE changeBool2 (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
Line 266... Line 314...
266 
    item.save := TRUE;
 314 
BEGIN
267 
    List.insert(CL.Log, CL.guard.prev, item)
 315 
	_changeBool(TRUE, line, v, x)