Subversion Repositories Kolibri OS

Rev

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

Rev 8097 Rev 8859
Line 1... Line 1...
1 
(*
 1 
(*
2 
    BSD 2-Clause License
 2 
    BSD 2-Clause License
Line 3... Line 3...
3 
 
 3 
 
4 
    Copyright (c) 2018-2020, Anton Krotov
 4 
    Copyright (c) 2018-2021, Anton Krotov
5 
    All rights reserved.
 5 
    All rights reserved.
Line 6... Line 6...
6 
*)
 6 
*)
Line 44... Line 44...
44 
    END;
 44 
    END;
Line 45... Line 45...
45 
 
 45 
 
46 
 
 46 
 
47 
PROCEDURE SetByte* (list: BYTELIST; idx: INTEGER; byte: BYTE);
 - 
 
48 
VAR
 47 
PROCEDURE SetByte* (list: BYTELIST; idx: INTEGER; byte: BYTE);
- 
 
 48 
VAR
Line 49... Line 49...
49 
    ChunkNum: INTEGER;
 49 
    chunk: BYTECHUNK;
50 
    chunk:    BYTECHUNK;
 50 
    item:  LISTS.ITEM;
51 
 
 51 
 
Line -... Line 52...
- 
 
 52 
BEGIN
- 
 
 53 
    ASSERT(idx >= 0);
52 
BEGIN
 54 
    ASSERT(list # NIL);
53 
    ASSERT(idx >= 0);
 55 
 
54 
    ASSERT(list # NIL);
 - 
 
55 
 
 - 
 
56 
    ChunkNum := idx DIV LENOFBYTECHUNK;
 - 
 
57 
    idx      := idx MOD LENOFBYTECHUNK;
 - 
 
58 
 
 - 
 
59 
    chunk := list.first(BYTECHUNK);
 - 
 
60 
 
 - 
 
61 
    WHILE (chunk # NIL) & (ChunkNum > 0) DO
 - 
 
62 
        chunk := chunk.next(BYTECHUNK);
 - 
 
63 
        DEC(ChunkNum)
 56 
    item := LISTS.getidx(list, idx DIV LENOFBYTECHUNK);
64 
    END;
 - 
 
65 
 
 57 
    ASSERT(item # NIL);
66 
    ASSERT(chunk # NIL);
 58 
    chunk := item(BYTECHUNK);
Line 67... Line 59...
67 
    ASSERT(idx < chunk.count);
 59 
    idx := idx MOD LENOFBYTECHUNK;
68 
 
 60 
    ASSERT(idx < chunk.count);
69 
    chunk.data[idx] := byte
 - 
 
70 
END SetByte;
 61 
    chunk.data[idx] := byte
- 
 
 62 
END SetByte;
Line 71... Line 63...
71 
 
 63 
 
72 
 
 64 
 
73 
PROCEDURE GetByte* (list: BYTELIST; idx: INTEGER): BYTE;
 65 
PROCEDURE GetByte* (list: BYTELIST; idx: INTEGER): BYTE;
Line -... Line 66...
- 
 
 66 
VAR
- 
 
 67 
    chunk: BYTECHUNK;
74 
VAR
 68 
    item:  LISTS.ITEM;
75 
    ChunkNum: INTEGER;
 69 
 
76 
    chunk:    BYTECHUNK;
 - 
 
77 
 
 - 
 
78 
BEGIN
 - 
 
79 
    ASSERT(idx >= 0);
 - 
 
80 
    ASSERT(list # NIL);
 - 
 
81 
 
 - 
 
82 
    ChunkNum := idx DIV LENOFBYTECHUNK;
 - 
 
83 
    idx      := idx MOD LENOFBYTECHUNK;
 - 
 
84 
 
 - 
 
85 
    chunk := list.first(BYTECHUNK);
 70 
BEGIN
86 
 
 - 
 
87 
    WHILE (chunk # NIL) & (ChunkNum > 0) DO
 71 
    ASSERT(idx >= 0);
88 
        chunk := chunk.next(BYTECHUNK);
 72 
    ASSERT(list # NIL);
Line 89... Line 73...
89 
        DEC(ChunkNum)
 73 
 
Line 185... Line 169...
185 
END CreateByteList;
 169 
END CreateByteList;
Line 186... Line 170...
186 
 
 170 
 
187 
 
 171 
 
188 
PROCEDURE SetInt* (list: INTLIST; idx: INTEGER; int: INTEGER);
 - 
 
189 
VAR
 172 
PROCEDURE SetInt* (list: INTLIST; idx: INTEGER; int: INTEGER);
- 
 
 173 
VAR
Line 190... Line 174...
190 
    ChunkNum: INTEGER;
 174 
    chunk: INTCHUNK;
191 
    chunk:    INTCHUNK;
 175 
    item:  LISTS.ITEM;
192 
 
 176 
 
Line -... Line 177...
- 
 
 177 
BEGIN
- 
 
 178 
    ASSERT(idx >= 0);
193 
BEGIN
 179 
    ASSERT(list # NIL);
194 
    ASSERT(idx >= 0);
 180 
 
195 
    ASSERT(list # NIL);
 - 
 
196 
 
 - 
 
197 
    ChunkNum := idx DIV LENOFINTCHUNK;
 - 
 
198 
    idx      := idx MOD LENOFINTCHUNK;
 - 
 
199 
 
 - 
 
200 
    chunk := list.first(INTCHUNK);
 - 
 
201 
 
 - 
 
202 
    WHILE (chunk # NIL) & (ChunkNum > 0) DO
 - 
 
203 
        chunk := chunk.next(INTCHUNK);
 - 
 
204 
        DEC(ChunkNum)
 181 
    item := LISTS.getidx(list, idx DIV LENOFINTCHUNK);
205 
    END;
 - 
 
206 
 
 182 
    ASSERT(item # NIL);
207 
    ASSERT(chunk # NIL);
 183 
    chunk := item(INTCHUNK);
Line 208... Line 184...
208 
    ASSERT(idx < chunk.count);
 184 
    idx := idx MOD LENOFINTCHUNK;
- 
 
 185 
    ASSERT(idx < chunk.count);
209 
 
 186 
    chunk.data[idx] := int
210 
    chunk.data[idx] := int
 - 
 
211 
END SetInt;
 187 
END SetInt;
- 
 
 188 
 
Line 212... Line 189...
212 
 
 189 
 
213 
 
 190 
PROCEDURE GetInt* (list: INTLIST; idx: INTEGER): INTEGER;
214 
PROCEDURE GetInt* (list: INTLIST; idx: INTEGER): INTEGER;
 191 
 
Line -... Line 192...
- 
 
 192 
VAR
- 
 
 193 
    chunk: INTCHUNK;
215 
VAR
 194 
    item:  LISTS.ITEM;
216 
    ChunkNum: INTEGER;
 195 
 
217 
    chunk:    INTCHUNK;
 - 
 
218 
 
 - 
 
219 
BEGIN
 - 
 
220 
    ASSERT(idx >= 0);
 - 
 
221 
    ASSERT(list # NIL);
 - 
 
222 
 
 - 
 
223 
    ChunkNum := idx DIV LENOFINTCHUNK;
 - 
 
224 
    idx      := idx MOD LENOFINTCHUNK;
 - 
 
225 
 
 - 
 
226 
    chunk := list.first(INTCHUNK);
 196 
BEGIN
227 
 
 - 
 
228 
    WHILE (chunk # NIL) & (ChunkNum > 0) DO
 197 
    ASSERT(idx >= 0);
229 
        chunk := chunk.next(INTCHUNK);
 198 
    ASSERT(list # NIL);
Line 230... Line 199...
230 
        DEC(ChunkNum)
 199