Subversion Repositories Kolibri OS

Rev

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

Rev 8728 Rev 9050
Line 40... Line 40...
40 
*)
 40 
*)
41 
    tGuard* = POINTER TO RECORD (List.tItem)
 41 
    tGuard* = POINTER TO RECORD (List.tItem)
Line 42... Line 42...
42 
 
 42 
 
Line 43... Line -...
43 
    END;
 - 
 
44 
 
 43 
    END;
45 
 
 44 
 
46 
VAR
 45 
    tLog* = POINTER TO RECORD
47 
    Log*: List.tList;
 46 
        Log*: List.tList;
- 
 
 47 
        guard: tGuard;
- 
 
 48 
        isLast: BOOLEAN
- 
 
 49 
    END;
- 
 
 50 
 
- 
 
 51 
 
Line 48... Line 52...
48 
    guard: tGuard;
 52 
VAR
49 
    isLast: BOOLEAN;
 53 
    CL*: tLog;
50 
 
 54 
 
51 
 
 55 
 
52 
PROCEDURE isLastGuard* (guard: tGuard): BOOLEAN;
 56 
PROCEDURE isLastGuard* (guard: tGuard): BOOLEAN;
53 
VAR
 57 
VAR
54 
    item: List.tItem;
 58 
    item: List.tItem;
55 
    res: BOOLEAN;
 59 
    res: BOOLEAN;
56 
BEGIN
 60 
BEGIN
57 
    IF guard # NIL THEN
 61 
    IF guard # NIL THEN
58 
        item := Log.last;
 62 
        item := CL.Log.last;
59 
        WHILE ~(item IS tGuard) DO
 63 
        WHILE ~(item IS tGuard) DO
Line 70... Line 74...
70 
PROCEDURE isFirstGuard* (guard: tGuard): BOOLEAN;
 74 
PROCEDURE isFirstGuard* (guard: tGuard): BOOLEAN;
71 
VAR
 75 
VAR
72 
    item: List.tItem;
 76 
    item: List.tItem;
73 
BEGIN
 77 
BEGIN
74 
    ASSERT(guard # NIL);
 78 
    ASSERT(guard # NIL);
75 
    item := Log.first;
 79 
    item := CL.Log.first;
76 
    WHILE ~(item IS tGuard) DO
 80 
    WHILE ~(item IS tGuard) DO
77 
        item := item.next
 81 
        item := item.next
78 
    END
 82 
    END
79 
    RETURN guard = item
 83 
    RETURN guard = item
80 
END isFirstGuard;
 84 
END isFirstGuard;
Line 81... Line 85...
81 
 
 85 
 
82 
 
 86 
 
83 
PROCEDURE setGuard* (_guard: tGuard);
 87 
PROCEDURE setGuard* (_guard: tGuard);
84 
BEGIN
 88 
BEGIN
85 
    guard := _guard;
 89 
    CL.guard := _guard;
Line 86... Line 90...
86 
    isLast := isLastGuard(_guard)
 90 
    CL.isLast := isLastGuard(_guard)
87 
END setGuard;
 91 
END setGuard;
Line 100... Line 104...
100 
PROCEDURE clear (guard: tGuard);
 104 
PROCEDURE clear (guard: tGuard);
101 
VAR
 105 
VAR
102 
    item: List.tItem;
 106 
    item: List.tItem;
103 
    (*res: INTEGER;*)
 107 
    (*res: INTEGER;*)
104 
BEGIN
 108 
BEGIN
105 
    isLast := TRUE;
 109 
    CL.isLast := TRUE;
106 
    REPEAT
 110 
    REPEAT
107 
        item := List.pop(Log);
 111 
        item := List.pop(CL.Log);
108 
        IF item # guard THEN
 112 
        IF item # guard THEN
109 
        (*
 113 
        (*
110 
            IF item IS tUntypedPtr THEN
 114 
            IF item IS tUntypedPtr THEN
111 
                res := API._DISPOSE(item(tUntypedPtr).p)
 115 
                res := API._DISPOSE(item(tUntypedPtr).p)
112 
            ELSIF item IS tTypedPtr THEN
 116 
            ELSIF item IS tTypedPtr THEN
113 
                DISPOSE(item(tTypedPtr).p)
 117 
                DISPOSE(item(tTypedPtr).p)
114 
            END;*)
 118 
            END;*)
115 
            DISPOSE(item)
 119 
            DISPOSE(item)
116 
        END
 120 
        END
117 
    UNTIL item = guard;
 121 
    UNTIL item = guard;
118 
    List.append(Log, item)
 122 
    List.append(CL.Log, item)
119 
END clear;
 123 
END clear;
Line 120... Line 124...
120 
 
 124 
 
121 
 
 125 
 
122 
PROCEDURE changeWord (adrV, adrX: INTEGER);
 126 
PROCEDURE changeWord (adrV, adrX: INTEGER);
123 
VAR
 127 
VAR
124 
    item: tIntItem;
 128 
    item: tIntItem;
125 
BEGIN
 129 
BEGIN
126 
    NEW(item);
 130 
    NEW(item);
127 
    item.adr := adrV;
 131 
    item.adr := adrV;
128 
    SYSTEM.GET(adrX, item.val);
 132 
    SYSTEM.GET(adrX, item.val);
129 
    IF ~isLast THEN
 133 
    IF ~CL.isLast THEN
130 
        clear(guard)
 134 
        clear(CL.guard)
131 
    END;
 135 
    END;
Line 132... Line 136...
132 
    List.append(Log, item)
 136 
    List.append(CL.Log, item)
133 
END changeWord;
 137 
END changeWord;
134 
 
 138 
 
135 
 
 139 
 
136 
PROCEDURE changeBool (VAR v: BOOLEAN; x: BOOLEAN);
 140 
PROCEDURE changeBool (VAR v: BOOLEAN; x: BOOLEAN);
137 
VAR
 141 
VAR
138 
    item: tBoolItem;
 142 
    item: tBoolItem;
139 
BEGIN
 143 
BEGIN
140 
    NEW(item);
 144 
    NEW(item);
141 
    item.adr := SYSTEM.ADR(v);
 145 
    item.adr := SYSTEM.ADR(v);
142 
    item.val := x;
 146 
    item.val := x;
143 
    IF ~isLast THEN
 147 
    IF ~CL.isLast THEN
Line 144... Line 148...
144 
        clear(guard)
 148 
        clear(CL.guard)
145 
    END;
 149 
    END;
Line 177... Line 181...
177 
    item.p := p;
 181 
    item.p := p;
178 
    List.append(Log, item)
 182 
    List.append(Log, item)
179 
END untypedPtr;
 183 
END untypedPtr;
180 
*)
 184 
*)
Line -... Line 185...
- 
 
 185 
 
- 
 
 186 
PROCEDURE set* (_CL: tLog);
- 
 
 187 
BEGIN
- 
 
 188 
    CL := _CL
- 
 
 189 
END set;
- 
 
 190 
 
- 
 
 191 
 
- 
 
 192 
PROCEDURE create* (VAR maxLength: INTEGER): tLog;
- 
 
 193 
VAR
- 
 
 194 
    newLog: tLog;
- 
 
 195 
BEGIN
- 
 
 196 
    NEW(newLog);
- 
 
 197 
    newLog.guard := NIL;
- 
 
 198 
    newLog.isLast := TRUE;
- 
 
 199 
    newLog.Log := List.create(NIL);
- 
 
 200 
    CL := newLog;
- 
 
 201 
    Lines.setMaxLength(maxLength)
- 
 
 202 
    RETURN newLog
- 
 
 203 
END create;
- 
 
 204 
 
181 
 
 205 
 
182 
BEGIN
 - 
 
183 
    guard := NIL;
 - 
 
184 
    isLast := TRUE;
 206 
BEGIN
185 
    List.init(changeInt, changePtr);
 207 
    List.init(changeInt, changePtr);
186 
    Lines.init(changeInt, changePtr, changeBool(*, typedPtr, untypedPtr*));
 - 
 
187 
    Log := List.create(NIL)
 208 
    Lines.init(changeInt, changePtr, changeBool(*, typedPtr, untypedPtr*))
188 
END ChangeLog.
 209 
END ChangeLog.