~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Sapphire / s / chunk
1 ;
2 ; chunk.s
3 ;
4 ; Loading and management of options chunks (MDW)
5 ;
6 ; © 1995-1998 Straylight
7 ;
8
9 ;----- Licensing note -------------------------------------------------------
10 ;
11 ; This file is part of Straylight's Sapphire library.
12 ;
13 ; Sapphire is free software; you can redistribute it and/or modify
14 ; it under the terms of the GNU General Public License as published by
15 ; the Free Software Foundation; either version 2, or (at your option)
16 ; any later version.
17 ;
18 ; Sapphire is distributed in the hope that it will be useful,
19 ; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ; GNU General Public License for more details.
22 ;
23 ; You should have received a copy of the GNU General Public License
24 ; along with Sapphire. If not, write to the Free Software Foundation,
25 ; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26
27 ;----- Standard header ------------------------------------------------------
28
29 GET libs:header
30 GET libs:swis
31
32 GET libs:stream
33
34 ;----- External dependencies ------------------------------------------------
35
36 GET sapphire:alloc
37 GET sapphire:fastMove
38 GET sapphire:flex
39 GET sapphire:string
40
41 GET sapphire:xfer.xsave
42
43 ;----- Main code ------------------------------------------------------------
44
45 AREA |Sapphire$$Code|,CODE,READONLY
46
47 ; --- chunk_create ---
48 ;
49 ; On entry: --
50 ;
51 ; On exit: R0 == chunk file handle
52 ; May return an error
53 ;
54 ; Use: Creates a new chunk file structure and returns a handle to
55 ; it.
56
57 EXPORT chunk_create
58 chunk_create ROUT
59
60 STMFD R13!,{R14} ;Save a register
61 MOV R0,#cBase__size ;Get the size of the block
62 BL alloc ;Try to allocate the block
63 BLCS alloc_error ;If it failed, get error
64 MOVCC R14,#0 ;Otherwise make list empty
65 STRCC R14,[R0,#cBase__list] ;By clearing the link
66 LDMFD R13!,{R14} ;Restore link register
67 BICCCS PC,R14,#V_flag ;If OK, return without error
68 ORRCSS PC,R14,#V_flag ;Else return the error
69
70 LTORG
71
72 ; --- chunk_destroy ---
73 ;
74 ; On entry: R0 == chunk file handle
75 ;
76 ; On exit: --
77 ;
78 ; Use: Removes a chunk file structure from memory. Chunk data in
79 ; flex blocks is freed; chunk claimers who free flex blocks
80 ; should clear the anchors to 0.
81
82 EXPORT chunk_destroy
83 chunk_destroy ROUT
84
85 STMFD R13!,{R0-R2,R14} ;Save some registers
86 MOV R2,R0 ;Look after the chunk base
87 LDR R1,[R2,#0] ;Load the first chunk block
88
89 00chunk_destroy MOVS R0,R1 ;Is this the end of the list?
90 BEQ %f00chunk_destroy ;Yes -- stop the loop
91 LDR R14,[R0,#0] ;Load the flex anchor
92 CMP R14,#0 ;Is there a block here?
93 BLNE flex_free ;Yes -- free it then
94 LDR R1,[R0,#cLink__next] ;Load the next block
95 BL free ;Free this block
96 B %b00chunk_destroy ;And loop back
97
98 00chunk_destroy MOV R0,R2 ;Point to the chunk base
99 BL free ;Don't need that any more
100 LDMFD R13!,{R0-R2,PC}^ ;Return to caller
101
102 LTORG
103
104 ; --- chunk_claim ---
105 ;
106 ; On entry: R0 == chunk file handle
107 ; R1 == pointer to chunk name
108 ; R2 == pointer to saver routine, or 0 for none, or -1 for no
109 ; change
110 ; R3 == R10 value to pass to saver
111 ; R4 == R12 value to pass to saver
112 ;
113 ; On exit: R1 == chunk handle/anchor
114 ; CS if the chunk already existed
115 ; May return an error
116 ;
117 ; Use: Claims a chunk, installing a save handler for it. The chunk
118 ; handle returned is actually the address of a flex anchor for
119 ; the chunk's data (use flex_size to find the block's size).
120 ; If the save handle is 0, the data in the flex block (which
121 ; may be modified) is saved directly from the block. Otherwise
122 ; the save routine is expected to save its data, using xsave.
123 ;
124 ; The anchor is followed by 3 unused words -- you can use them
125 ; for whatever you want.
126 ;
127 ; Warning: this routine may move flex blocks.
128
129 EXPORT chunk_claim
130 chunk_claim ROUT
131
132 BIC R14,R14,#V_flag ;Clear V and hope...
133 STMFD R13!,{R0,R5,R6,R14} ;Save some registers
134 SUB R5,R0,#cLink__next ;Look after the handle
135
136 00chunk_claim LDR R6,[R5,#cLink__next] ;Load the next pointer
137 CMP R6,#0 ;Is this the very end?
138 BEQ %f00chunk_claim ;Yes -- create a new chunk
139 ADD R0,R6,#cLink__name ;Point to the chunk's name
140 BL str_icmp ;Compare the names
141 MOVNE R5,R6 ;No match -- move on
142 BNE %b00chunk_claim ;Loop back to start
143
144 ; --- Found a matching chunk ---
145
146 CMP R2,#-1 ;Do we change the saver?
147 ADDNE R14,R6,#cLink__saver ;No -- point to saver info
148 STMNEIA R14,{R2-R4} ;And stuff the values in
149 MOV R1,R6 ;Point to the anchor
150 LDMFD R13!,{R0,R5,R6,R14} ;Restore registers
151 ORRS PC,R14,#C_flag ;And return to caller
152
153 ; --- No match -- create a new chunk ---
154
155 00chunk_claim MOV R0,#cLink__size ;Get the block size I need
156 BL alloc ;Try to allocate the memory
157 BLCS alloc_error ;If it failed, get error
158 BCS %99chunk_claim ;And return the failure
159 MOV R6,R0 ;Get the chunk handle
160 ADD R0,R6,#cLink__name ;Point to the name field
161 BL str_cpy ;Fill in the new name
162
163 ; --- Allocate an empty flex block for it ---
164
165 MOV R1,#0 ;Allocate no memory
166 MOV R0,R6 ;Point to the anchor
167 BL flex_alloc ;Allocate the block
168 BLCS alloc_error ;If it failed, get error
169 BCS %98chunk_claim ;And tidy up on the way out
170
171 ; --- Fill in the rest of the chunk ---
172
173 MOV R14,#0 ;Fill in the next field
174 STR R14,[R6,#cLink__next] ;Clear the next pointer
175 STR R6,[R5,#cLink__next] ;And link in the new chunk
176 STR R14,[R6,#cLink__flags] ;Clear flags initially
177 CMP R2,#-1 ;Do we change the saver?
178 MOVEQ R2,#0 ;No -- then leave none there
179 ADD R14,R6,#cLink__saver ;Point to saver info
180 STMIA R14,{R2-R4} ;And stuff the values in
181
182 MOV R1,R6 ;Point to the anchor
183 LDMFD R13!,{R0,R5,R6,R14} ;Restore registers
184 BICS PC,R14,#C_flag ;And return to caller
185
186 ; --- Tidy up on the way out ---
187
188 98chunk_claim MOV R5,R0 ;Look after the error
189 MOV R0,R6 ;Point to new chunk block
190 BL free ;Free the block
191 MOV R0,R5 ;Get the error pointer back
192
193 99chunk_claim ADD R13,R13,#4 ;Don't restore R0 on exit
194 LDMFD R13!,{R5,R6,R14} ;Restore registers
195 ORRS PC,R14,#V_flag ;And return the error
196
197 LTORG
198
199 ; --- chunk_makeBinary ---
200 ;
201 ; On entry: R0 == chunk file handle
202 ; R1 == chunk handle
203 ;
204 ; On exit: --
205 ;
206 ; Use: Marks a given chunk as containing binary data.
207
208 EXPORT chunk_makeBinary
209 chunk_makeBinary ROUT
210
211 STMFD R13!,{R14} ;Save a register
212 LDR R14,[R1,#cLink__flags] ;Load the flags word
213 ORR R14,R14,#clFlag__binary ;Set the binary flag
214 STR R14,[R1,#cLink__flags] ;Save the flags back again
215 LDMFD R13!,{PC}^ ;And return to caller
216
217 LTORG
218
219 ; --- chunk_read ---
220 ;
221 ; On entry: R0 == chunk file handle
222 ; R1 == address of a flex anchor
223 ;
224 ; On exit: May return an error
225 ;
226 ; Use: Merges the data contained in the flex block with that already
227 ; in the chunk file. If the chunk file is empty, this is
228 ; equivalent to a load. Data from the flex block is appended
229 ; to chunks already loaded where appropriate.
230 ;
231 ; Warning: this routine may move flex blocks.
232
233 EXPORT chunk_read
234 chunk_read ROUT
235
236 STMFD R13!,{R0-R9,R14} ;Save some registers
237 LDR R8,[R1,#0] ;Load the block address
238 MOV R7,R0 ;Look after the chunk handle
239 MOV R0,R1 ;Point to the anchor
240 BL flex_size ;Read the block's size
241 ADD R9,R8,R0 ;And find the limit pointer
242
243 ; --- Find the first chunk ---
244 ;
245 ; There'll probably be some comments at the top -- we don't
246 ; care about them.
247
248 10chunk_read MOV R2,#&0A ;Say this is a new line
249 00chunk_read CMP R8,R9 ;Have we reached the end?
250 BCS %90chunk_read ;Yes -- nothing to read
251 LDRB R1,[R8],#1 ;Load the next byte
252 CMP R2,#&0A ;Is this a new line?
253 CMPEQ R1,#'[' ;And is this a chunk start?
254 MOVNE R2,R1 ;No -- stash previous char
255 BNE %b00chunk_read ;And skip back for more
256
257 ; --- Read the next chunk ---
258
259 MOV R2,R11 ;Copy name to scratchpad
260 00chunk_read CMP R8,R9 ;Reached the end yet?
261 BCS %90chunk_read ;Yes -- ignore bogus header
262 LDRB R1,[R8],#1 ;Get a byte of name
263 CMP R1,#']' ;Is it the end of it?
264 MOVEQ R1,#0 ;Yes -- terminate the name
265 STRB R1,[R2],#1 ;Store this byte away
266 BNE %b00chunk_read ;Keep on going to the end
267 STRB R1,[R11,#19] ;Make sure name's <12 chars
268
269 ; --- Ignore the rest of this line ---
270
271 MOV R3,#0 ;Clear size just in case
272 00chunk_read CMP R8,R9 ;Reached the end yet?
273 BCS %f05chunk_read ;Yes -- stop here then
274 LDRB R1,[R8],#1 ;Load the next byte out
275 CMP R1,#&0A ;Is this the end of the line?
276 BNE %b00chunk_read ;No -- skip back then
277
278 ; --- Work out how big the chunk is ---
279
280 AND R0,R8,#3 ;Get the non-word-alignedness
281 BIC R1,R8,#3 ;And round down nicely
282 LDMIA R1,{R2-R4} ;Load next two fullwords
283 MOVS R0,R0,LSL #3 ;Turn bytes into bits
284 RSB R14,R0,#32 ;And work out other shift
285 MOVNE R2,R2,LSR R0 ;Shift down lowest word
286 ORRNE R2,R2,R3,LSL R14 ;Copy in bottom of next word
287 MOVNE R3,R3,LSR R0 ;Shift rest of this one down
288 ORRNE R3,R3,R4,LSL R14 ;Copy in bottom of top word
289
290 LDR R14,=chunk__binMark ;Is this the binary marker?
291 CMP R2,R14 ;Is this a binary chunk?
292 MOVNE R5,#0 ;No -- don't set any flags
293 MOVEQ R5,#clFlag__binary ;Yes -- set the binary flag
294 BNE %f00chunk_read ;No -- search for next chunk
295
296 ADD R8,R8,#8 ;Skip past those two words
297 ADD R8,R8,R3 ;And move on to end of chunk
298 B %f05chunk_read ;And skip on (size in R3)
299
300 ; --- Now search for a new chunk ---
301
302 00chunk_read MOV R3,#0 ;No bytes counted so far
303 00chunk_read CMP R8,R9 ;Reached the end yet?
304 BCS %f05chunk_read ;Yes -- stop here then
305 LDRB R0,[R8],#1 ;Load the next byte
306 CMP R1,#&0A ;Is this a new line?
307 CMPEQ R0,#'[' ;And is this a new chunk?
308 ADDNE R3,R3,#1 ;No -- bump the counter
309 MOVNE R1,R0 ;Remember the last character
310 BNE %b00chunk_read ;And go back found
311
312 SUB R8,R8,#1 ;Go back to the newline char
313
314 ; --- Now claim a chunk for us ---
315
316 05chunk_read MOV R0,R7 ;Get the chunk handle
317 MOV R1,R11 ;Point to the chunk's name
318 MOV R2,#-1 ;Don't care about savers
319 FSAVE "R8,R9" ;Stash flex pointers
320 BL chunk_claim ;Claim this block please
321 BVS %99chunk_read ;It failed -- tidy up
322 MOV R6,R1 ;Look after the link block
323
324 LDR R14,[R6,#cLink__flags] ;Load the flags word
325 ORR R14,R14,R5 ;Set any flags we need
326 STR R14,[R6,#cLink__flags] ;Save the flags back again
327
328 ; --- Grow the flex block and copy ---
329
330 MOV R0,R6 ;Point to the anchor
331 BL flex_size ;Read the block's size
332 MOV R5,R0 ;Look after this
333 ADD R1,R0,R3 ;Add on a little size
334 MOV R0,R6 ;Point to the anchor again
335 BL flex_extend ;Make the block bigger
336 BLCS alloc_error ;If it failed, moan a lot
337 BCS %99chunk_read ;And go off in a huff
338
339 LDR R0,[R6,#0] ;Load the block base
340 ADD R0,R0,R5 ;Find the destination addr
341 FLOAD "R8,R9" ;Reload my saved pointers
342 SUB R1,R8,R3 ;Reclaim my data
343 MOV R2,R3 ;Set the amount to copy
344 BL fastMove ;And copy it all across
345
346 ; --- That's done -- now do the rest ---
347
348 B %10chunk_read ;Go back to the top again
349
350 ; --- We made it -- huzzah! ---
351
352 90chunk_read LDMFD R13!,{R0-R9,R14} ;Restore registers
353 BICS PC,R14,#V_flag ;And return with no error
354
355 ; --- Something went awry ---
356
357 99chunk_read
358 FLOAD "R8,R9" ;Restore regs from flex stack
359 ADD R13,R13,#4 ;Don't restore R0 on exit
360 LDMFD R13!,{R1-R9,R14} ;Restore registers
361 ORRS PC,R14,#V_flag ;And return the error
362
363 LTORG
364
365 ; --- chunk_enum ---
366 ;
367 ; On entry: R0 == chunk file handle
368 ; R1 == 0 for first call or continuation value
369 ;
370 ; On exit: CC if this isn't over yet, and
371 ; R1 == continuation value for next call
372 ; R2 == pointer to chunk name
373 ; else CS and
374 ; R1 == 0
375 ; R2 preserved
376 ;
377 ; Use: Allows you to enumerate the chunks in a chunk file structure.
378
379 EXPORT chunk_enum
380 chunk_enum ROUT
381
382 CMP R1,#0 ;Is this a new call?
383 SUBEQ R1,R0,#cLink__next ;Yes -- set up continuation
384 LDR R1,[R1,#cLink__next] ;Move onto the next block
385 CMP R1,#0 ;Is this at the end?
386 ADDNE R2,R1,#cLink__name ;No -- point to the name
387 BICNES PC,R14,#C_flag ;And return OK
388 ORREQS PC,R14,#C_flag ;Otherwise say it's over
389
390 LTORG
391
392 ; --- chunk_save ---
393 ;
394 ; On entry: R0 == chunk file handle
395 ;
396 ; On exit: May return an error
397 ;
398 ; Use: Saves a chunk file to xsave's current output.
399
400 EXPORT chunk_save
401 chunk_save ROUT
402
403 STMFD R13!,{R0-R4,R10,R12,R14} ;Save a few registers
404 LDR R4,[R0,#0] ;Load the list base
405 05chunk_save CMP R4,#0 ;Is there nothing to do?
406 BEQ %90chunk_save ;That's OK -- do nothing then
407
408 ; --- Write out this chunk's name ---
409
410 MOV R0,#'[' ;Output a `[' character
411 BL xsave_byte ;Write that OK
412 BVS %99chunk_save ;Die if that went wrong
413
414 ADD R1,R4,#cLink__name ;Point to the name
415 00chunk_save LDRB R0,[R1],#1 ;Load the next byte
416 CMP R0,#0 ;Is this the end yet?
417 MOVEQ R0,#']' ;Yes -- write terminator
418 BL xsave_byte ;Write that out
419 BVS %99chunk_save ;Die if that went wrong
420 BNE %b00chunk_save ;And if there's more, do it
421
422 ; --- Write any necessary preamble ---
423
424 MOV R0,#&0A ;Start a new line
425 BL xsave_byte ;Write the newline byte
426 BVS %99chunk_save ;Die if that went wrong
427
428 LDR R14,[R4,#cLink__flags] ;Load the flags word
429 TST R14,#clFlag__binary ;Is this block binary?
430 LDRNE R0,=chunk__binMark ;Yes -- write a bin marker
431 BLNE xsave_word ;Yes -- write a whole word
432 BVS %99chunk_save ;Die if that went wrong
433
434 ; --- Now work out how to write this block ---
435
436 ADD R14,R4,#cLink__saver ;Point to saver info
437 LDMIA R14,{R2,R10,R12} ;Load that lot out
438 CMP R2,#0 ;Is this a real saver?
439 BEQ %10chunk_save ;No -- skip on then
440 MOV R0,R4 ;Point to the anchor
441 MOV R14,PC ;Set up return address
442 MOV PC,R2 ;And call the saver
443 LDRVC R4,[R4,#cLink__next] ;Find the next block
444 BVC %05chunk_save ;And loop back to the start
445 BVS %99chunk_save ;Die if that went wrong
446
447 ; --- We must save the chunk ourselves ---
448
449 10chunk_save LDR R14,[R4,#cLink__flags] ;Load the flags word
450 TST R14,#clFlag__binary ;Is this block binary?
451
452 MOV R0,R4 ;If OK, get flex anchor
453 BL flex_size ;Find the block's size
454 BLNE xsave_word ;If binary, write that out
455 MOVVC R1,R0 ;Look after that
456 LDRVC R0,[R4,#0] ;Load the flex base address
457 BLVC xsave_block ;And write out the whole lot
458 BVS %99chunk_save ;Die if anything went wrong
459 MOVNE R0,#&0A ;Write a final line end
460 BLNE xsave_byte ;Just to make sure
461 BLNE xsave_byte ;Leave blank line under bin
462 LDRVC R4,[R4,#cLink__next] ;Find the next block
463 BVC %05chunk_save ;And loop back to the start
464 BVS %99chunk_save ;Die if anything went wrong
465
466 ; --- Finished writing the file ---
467
468 90chunk_save LDMFD R13!,{R0-R4,R10,R12,R14} ;Restore registers
469 BICS PC,R14,#V_flag ;Return error-free
470
471 ; --- Something got messed up ---
472
473 99chunk_save ADD R13,R13,#4 ;Don't restore R0
474 LDMFD R13!,{R1-R4,R10,R12,R14} ;Restore other registers
475 ORRS PC,R14,#V_flag ;And return the error
476
477 LTORG
478
479 ;----- Data structures ------------------------------------------------------
480
481 ; --- Chunk base ---
482
483 ^ 0
484 cBase__list # 4 ;List of chunks
485 cBase__size # 0
486
487 ; --- Chunk link blocks ---
488
489 ^ 0
490 cLink__anchor # 4 ;Anchor for flex block
491 cLink__userData # 12 ;12 bytes of user data
492 cLink__next # 4 ;Link to next block
493 cLink__flags # 4 ;Interesting things
494 cLink__name # 20 ;Name of this chunk
495 cLink__saver # 12 ;Saver routine for chunk
496 cLink__size # 0
497
498 ; --- Flags ---
499
500 clFlag__binary EQU (1<<0) ;Chunk contains binary data
501
502 ; --- Other magic values ---
503
504 chunk__binMark EQU &6E694200 ;Magic word for binary data
505
506 ;----- That's all, folks ----------------------------------------------------
507
508 END
The Straylight Source Distribution (obsolete software for RISC OS)