Subversion Repositories Kolibri OS

Rev

Rev 9903 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 9903 Rev 9904
Line 33... Line 33...
33 
 
 33 
 
34 
	tBoolItem = POINTER TO RECORD (List.tItem)
 34 
	tBoolItem = POINTER TO RECORD (List.tItem)
35 
		map: SET;
 35 
		map: SET;
36 
		data: ARRAY boolItemSize OF
 36 
		data: ARRAY boolItemSize OF
37 
			RECORD
 - 
 
38 
				line: Lines.tLine;
 37 
			RECORD
39 
				adr: INTEGER;
 38 
				adr1, adr2: INTEGER;
40 
				val, save: BOOLEAN
 39 
				val1, val2, save: BOOLEAN
41 
			END
 40 
			END
Line 42... Line 41...
42 
	END;
 41 
	END;
43 
 
 42 
 
Line 122... Line 121...
122 
			SYSTEM.PUT(item(tIntItem).adr[i], item(tIntItem).val[i])
 121 
			SYSTEM.PUT(item(tIntItem).adr[i], item(tIntItem).val[i])
123 
		END
 122 
		END
124 
	ELSIF item IS tBoolItem THEN
 123 
	ELSIF item IS tBoolItem THEN
125 
		FOR i := 0 TO boolItemSize - 1 DO
 124 
		FOR i := 0 TO boolItemSize - 1 DO
126 
			IF i IN item(tBoolItem).map THEN
 125 
			IF i IN item(tBoolItem).map THEN
- 
 
 126 
				SYSTEM.PUT(item(tBoolItem).data[i].adr1, item(tBoolItem).data[i].val1);
127 
				SYSTEM.PUT(item(tBoolItem).data[i].adr, item(tBoolItem).data[i].val)
 127 
				SYSTEM.PUT(item(tBoolItem).data[i].adr2, item(tBoolItem).data[i].val2)
128 
			END
 128 
			END
129 
		END
 129 
		END
130 
	END
 130 
	END
131 
END redo;
 131 
END redo;
Line 150... Line 150...
150 
VAR
 150 
VAR
151 
	item: List.tItem;
 151 
	item: List.tItem;
152 
	boolItem: tBoolItem;
 152 
	boolItem: tBoolItem;
153 
	cur: List.tItem;
 153 
	cur: List.tItem;
154 
	i: INTEGER;
 154 
	i: INTEGER;
- 
 
 155 
	line_modified: BOOLEAN;
155 
BEGIN
 156 
BEGIN
156 
	item := CL.Log.first;
 157 
	item := CL.Log.first;
157 
	WHILE item # NIL DO
 158 
	WHILE item # NIL DO
158 
		IF item IS tGuard THEN
 159 
		IF item IS tGuard THEN
159 
			item(tGuard).saved := FALSE
 160 
			item(tGuard).saved := FALSE
Line 165... Line 166...
165 
	cur := CL.guard.prev;
 166 
	cur := CL.guard.prev;
166 
	WHILE cur # NIL DO
 167 
	WHILE cur # NIL DO
167 
		IF cur IS tBoolItem THEN
 168 
		IF cur IS tBoolItem THEN
168 
			boolItem := cur(tBoolItem);
 169 
			boolItem := cur(tBoolItem);
169 
			FOR i := 0 TO boolItemSize - 1 DO
 170 
			FOR i := 0 TO boolItemSize - 1 DO
170 
				IF (i IN boolItem.map) & boolItem.data[i].save &
 171 
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
171 
						boolItem.data[i].line.modified THEN
 172 
					SYSTEM.GET(boolItem.data[i].adr1, line_modified);
- 
 
 173 
					IF line_modified THEN
172 
					EXCL(boolItem.map, i)
 174 
						EXCL(boolItem.map, i)
173 
				END
 175 
					END
174 
			END
 176 
				END
- 
 
 177 
			END
175 
		END;
 178 
		END;
176 
		cur := cur.prev;
 179 
		cur := cur.prev;
177 
		IF boolItem.map = {} THEN
 180 
		IF boolItem.map = {} THEN
178 
			List.delete(CL.Log, boolItem);
 181 
			List.delete(CL.Log, boolItem);
179 
			DISPOSE(boolItem)
 182 
			DISPOSE(boolItem)
Line 242... Line 245...
242 
	WHILE (cur # NIL) & ~(cur IS tGuard) DO
 245 
	WHILE (cur # NIL) & ~(cur IS tGuard) DO
243 
		IF cur IS tBoolItem THEN
 246 
		IF cur IS tBoolItem THEN
244 
			boolItem := cur(tBoolItem);
 247 
			boolItem := cur(tBoolItem);
245 
			FOR i := 0 TO boolItemSize - 1 DO
 248 
			FOR i := 0 TO boolItemSize - 1 DO
246 
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
 249 
				IF (i IN boolItem.map) & boolItem.data[i].save THEN
- 
 
 250 
					SYSTEM.PUT(boolItem.data[i].adr1, ~boolItem.data[i].val1);
247 
					SYSTEM.PUT(boolItem.data[i].adr, ~boolItem.data[i].val);
 251 
					SYSTEM.PUT(boolItem.data[i].adr2, ~boolItem.data[i].val2);
248 
					EXCL(boolItem.map, i)
 252 
					EXCL(boolItem.map, i)
249 
				END
 253 
				END
250 
			END
 254 
			END
251 
		END;
 255 
		END;
252 
		cur := cur.prev;
 256 
		cur := cur.prev;
Line 256... Line 260...
256 
		END
 260 
		END
257 
	END
 261 
	END
258 
END delCurSaved;
 262 
END delCurSaved;
Line 259... Line 263...
259 
 
 263 
 
260 
 
 264 
 
261 
PROCEDURE _changeBool (fn2: BOOLEAN; line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
 265 
PROCEDURE changeBool (save: BOOLEAN; VAR v1: BOOLEAN; x1: BOOLEAN; VAR v2: BOOLEAN; x2: BOOLEAN);
262 
VAR
 266 
VAR
263 
	item: tBoolItem;
 267 
	item: tBoolItem;
264 
	cur: List.tItem;
 268 
	cur: List.tItem;
265 
	i: INTEGER;
 269 
	i: INTEGER;
266 
BEGIN
 270 
BEGIN
267 
	IF fn2 THEN
 271 
	IF save THEN
268 
		cur := CL.guard.prev
 272 
		cur := CL.guard.prev
269 
	ELSE
 273 
	ELSE
270 
		IF ~CL.isLast THEN
 274 
		IF ~CL.isLast THEN
271 
			clear(CL.guard)
 275 
			clear(CL.guard)
272 
		END;
 276 
		END;
Line 273... Line 277...
273 
		cur := CL.Log.last
 277 
		cur := CL.Log.last
274 
	END;
 278 
	END;
275 
 
 279 
 
276 
	WHILE (cur # NIL) & ~(cur IS tGuard) &
 280 
	WHILE (cur # NIL) & ~(cur IS tGuard) &
277 
			(~(cur IS tBoolItem) OR (cur(tBoolItem).map = fillMap)) DO
 281 
			( ~(cur IS tBoolItem) (*OR (cur(tBoolItem).map = fillMap)*) ) DO
278 
		cur := cur.prev
 282 
		cur := cur.prev
279 
	END;
 283 
	END;
280 
	IF (cur IS tBoolItem) & (cur(tBoolItem).map # fillMap) THEN
 284 
	IF (cur IS tBoolItem) & (cur(tBoolItem).map # fillMap) THEN
281 
		item := cur(tBoolItem)
 285 
		item := cur(tBoolItem)
282 
	ELSE
 286 
	ELSE
283 
		NEW(item);
 287 
		NEW(item);
284 
		item.map := {};
 288 
		item.map := {};
285 
		IF fn2 THEN
 289 
		IF save THEN
286 
			List.insert(CL.Log, CL.guard.prev, item)
 290 
			List.insert(CL.Log, CL.guard.prev, item)
287 
		ELSE
 291 
		ELSE
Line 288... Line 292...
288 
			List.append(CL.Log, item)
 292 
			List.append(CL.Log, item)
289 
		END
 293 
		END
290 
	END;
 294 
	END;
- 
 
 295 
 
291 
 
 296 
	i := 0;
292 
	i := 0;
 297 
	WHILE i < boolItemSize DO
293 
	WHILE i < boolItemSize DO
 298 
		IF ~(i IN item.map) THEN
294 
		IF ~(i IN item.map) THEN
 299 
			item.data[i].adr1 := SYSTEM.ADR(v1);
295 
			item.data[i].line := line;
 300 
			item.data[i].val1 := x1;
296 
			item.data[i].adr := SYSTEM.ADR(v);
 301 
			item.data[i].adr2 := SYSTEM.ADR(v2);
297 
			item.data[i].val := x;
 302 
			item.data[i].val2 := x2;
298 
			item.data[i].save := fn2;
 303 
			item.data[i].save := save;
299 
			INCL(item.map, i);
 304 
			INCL(item.map, i);
300 
			i := boolItemSize
 - 
 
301 
		END;
 - 
 
302 
		INC(i)
 - 
 
303 
	END
 - 
 
304 
END _changeBool;
 - 
 
305 
 
 - 
 
306 
 
 305 
			i := boolItemSize
Line 307... Line -...
307 
PROCEDURE changeBool (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
 - 
 
308 
BEGIN
 - 
 
309 
	_changeBool(FALSE, line, v, x)
 - 
 
310 
END changeBool;
 - 
 
311 
 
 - 
 
312 
 
 - 
 
313 
PROCEDURE changeBool2 (line: Lines.tLine; VAR v: BOOLEAN; x: BOOLEAN);
 306 
		END;
314 
BEGIN
 307 
		INC(i)
315 
	_changeBool(TRUE, line, v, x)
 308 
	END
316 
END changeBool2;
 309 
END changeBool;
Line 419... Line 412...
419 
END destroy;
 412 
END destroy;
Line 420... Line 413...
420 
 
 413 
 
421 
 
 414 
 
422 
BEGIN
 415 
BEGIN
423 
	List.init(changeInt, changePtr);
 416 
	List.init(changeInt, changePtr);
424 
	Lines.init(changeInt, changePtr, changeBool, changeBool2, typedPtr, untypedPtr)
 417 
	Lines.init(changeInt, changePtr, changeBool, typedPtr, untypedPtr)