~mdw / ssr / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial revision
[ssr] / StraySrc / Libraries / Sapphire / xfer / s / xsave
1 ;
2 ; xfer.xsave.s
3 ;
4 ; Simplified saving with coroutines (MDW)
5 ;
6 ; © 1994 Straylight
7 ;
8
9 ;----- Standard header ------------------------------------------------------
10
11 GET libs:header
12 GET libs:swis
13
14 ;----- External dependencies ------------------------------------------------
15
16 GET sapphire:alloc
17 GET sapphire:coRoutine
18 GET sapphire:fastMove
19 GET sapphire:sapphire
20
21 ;----- How it all works -----------------------------------------------------
22 ;
23 ; xsave attempts to unify the two saving routines you have to give (the saver
24 ; and the sender) and provide the same interface to both. For data sending
25 ; through RAM transfer, this has to be done using coroutines, but this is
26 ; fairly invisible to you.
27 ;
28 ; There are two main routines, xsave_save and xsave_send which start save
29 ; jobs. They take a pointer to a save routine with R10 and R12 pointers.
30 ; xsave_save also takes a pointer to a filename. The actual save routine
31 ; should be the same for both.
32 ;
33 ; Saving of data is done with the call xsave_block. This just writes out
34 ; a block of data somehow. All the other routines are special interfaces to
35 ; xsave_block.
36
37 ;----- How the error handling works -----------------------------------------
38 ;
39 ; The really tricky bit is passing of errors during a RAM transfer.
40 ; Errors can be returned at two places -- in the user code (e.g. running out
41 ; of memory) and by save's cunning message handling if the receiver dies.
42 ; All errors must be handled by user code, to release claimed memory etc.
43 ;
44 ; The error gets passed along a path like this:
45 ;
46 ; Error created by user code
47 ;
48 ; user code --> xsave__startCo --> xsave_failed
49 ;
50 ; Error created by remote receiver
51 ;
52 ; xsave_failed --> xsave__write --> user code --> xsave__startCo
53
54 ;----- Main code ------------------------------------------------------------
55
56 AREA |Sapphire$$Code|,CODE,READONLY
57
58 ; --- xsave_save ---
59 ;
60 ; On entry: R0 == pointer to saver routine
61 ; R1 == R10 value to pass to saver
62 ; R2 == R12 value to pass to saver
63 ; R3 == pointer to filename to save to
64 ; R4 == filetype of file to save
65 ;
66 ; On exit: May return an error
67 ;
68 ; Use: Calls a generalised saver routine to write data to a file.
69
70 EXPORT xsave_save
71 xsave_save ROUT
72
73 STMFD R13!,{R0-R5,R10,R12,R14} ;Save lots of registers
74 WSPACE xsave__wSpace ;Find my workspace address
75
76 ; --- First, try to allocate a buffer ---
77
78 BL xsave__setBuff ;Allocate the buffer nicely
79 BVS %99xsave_save ;If we couldn't, tidy up
80
81 ; --- Set up the file for writing ---
82
83 MOV R1,R3 ;Point at the file name
84 MOV R0,#&8F ;Lots of errors, no path
85 SWI XOS_Find ;Try to open the file
86 BVS %98xsave_save ;Tidy up if it wouldn't open
87 STR R0,xsave__file ;Save the file handle away
88
89 ; --- Set up flags and let rip ---
90
91 LDR R14,xsave__flags ;Load my current flags word
92 AND R14,R14,#xsFlag__inited ;Only leave inited flag
93 STR R14,xsave__flags ;Save the flags back again
94
95 LDMIA R13,{R0,R10,R12} ;Load the arguments out
96 ADDS R0,R0,#0 ;Clear overflow and carry
97 MOV R14,PC ;Set up the return address
98 MOV PC,R0 ;And call the saver routine
99 WSPACE xsave__wSpace ;Restore my workspace ptr
100 BVS %97xsave_save ;Tidy up if it failed
101
102 ; --- Write the remainder of the file ---
103
104 ADR R14,xsave__buffer ;Point to the buffer info
105 LDMIA R14,{R0,R1} ;Load buffer addr and size
106 BL xsave__write ;Write it out to the file
107 BVS %97xsave_save ;Tidy up if it failed
108
109 ; --- Close the file and set the filetype ---
110
111 MOV R0,#0 ;Close an open file
112 LDR R1,xsave__file ;Get the file handle ready
113 SWI OS_Find ;Close it
114
115 MOV R0,#18 ;Set file type
116 MOV R1,R3 ;Point to the filename
117 MOV R2,R4 ;And get the filetype
118 SWI OS_File ;And set the filetype
119
120 ; --- Get rid of the buffer and return ---
121
122 BL xsave__loseBuff ;Free up the buffer space
123 LDMFD R13!,{R0-R5,R10,R12,R14} ;Unstack all the registers
124 BICS PC,R14,#V_flag ;And return to caller
125
126 ; --- Tidy up after various catastrophes ---
127
128 97xsave_save MOV R10,R0 ;Keep the error pointer
129 MOV R0,#0 ;Close an open file
130 LDR R1,xsave__file ;Get the file handle ready
131 SWI OS_Find ;Close it
132 MOV R0,#6 ;Delete the file now
133 MOV R1,R3 ;Point to the filename
134 SWI XOS_File ;Delete it as much as we can
135 MOV R0,R10 ;Restore the error pointer
136
137 98xsave_save BL xsave__loseBuff ;Free up the buffer space
138
139 99xsave_save ADD R13,R13,#4 ;Don't restore R0 on exit
140 LDMFD R13!,{R1-R5,R10,R12,R14} ;Unstack all the registers
141 ORRS PC,R14,#V_flag ;And return to caller
142
143 ; --- xsave_send ---
144 ;
145 ; On entry: R0 == pointer to saver routine
146 ; R1 == R10 value to pass to saver
147 ; R2 == R12 value to pass to saver
148 ;
149 ; On exit: R0 == pointer to block to send
150 ; R1 == size of block
151 ; CS if this is the last block, else CC
152 ; May return an error
153 ;
154 ; Use: Calls a generalised saver routine to write data to another
155 ; application, using RAM transfer. Note that you must call
156 ; this routine from your send entry point throughout the
157 ; save operation.
158
159 EXPORT xsave_send
160 xsave_send ROUT
161
162 STMFD R13!,{R0-R4,R12,R14} ;Save some registers away
163 WSPACE xsave__wSpace ;Find my workspace address
164
165 ; --- Find out if we need to set anything up ---
166
167 LDR R14,xsave__flags ;Load my flags word
168 TST R14,#xsFlag__ramTran ;Are we doing RAM transfer?
169 BNE %50xsave_send ;Yes -- continue te job then
170
171 ; --- Clear all the flags for now ---
172
173 AND R4,R14,#xsFlag__inited ;Leave only `initialised'
174 STR R4,xsave__flags ;And save these flags back
175
176 ; --- Set things up for RAM transfer ---
177
178 BL xsave__setBuff ;Set up my buffer nicely
179 BVS %99xsave_send ;If it failed, tidy up
180
181 ADR R0,xsave__startCo ;Point to my coroutine
182 MOV R1,R13 ;Point R10 at the stack
183 MOV R2,R12 ;Pass workspace in R12
184 MOV R3,#0 ;Use a default stack
185 BL coRout_create ;Create a coroutine
186 BVS %98xsave_send ;If it failed, tidy up
187 STR R0,xsave__coRout ;Save the coroutine handle
188
189 ; --- Set up the flags properly now ---
190
191 ORR R4,R4,#xsFlag__ramTran ;Say we're RAM transfering
192 STR R4,xsave__flags ;And save these flags back
193
194 ; --- Get some more data to send ---
195
196 50xsave_send LDR R0,xsave__coRout ;Get the coroutine handle
197 BL coRout_switch ;Switch to it for a bit
198
199 LDR R14,xsave__flags ;Get the newly updated flags
200 TST R14,#xsFlag__error ;Was there an error?
201 LDRNE R0,xsave__error ;Yes -- load the error ptr
202 BNE %99xsave_send ;And tidy everything up
203
204 ; --- Get the returned block ---
205
206 ADR R0,xsave__start ;Point to the block info
207 LDMIA R0,{R0,R1} ;Load the start and length
208 TST R14,#xsFlag__finish ;Has the transfer finished?
209 ADD R13,R13,#8 ;Don't restore R0,R1
210 LDMFD R13!,{R2-R4,R12,R14} ;Unstack lots of registers
211 ORRNES PC,R14,#C_flag ;If finished, set C flag
212 BICEQS PC,R14,#C_flag ;Otherwise say more to come
213
214 ; --- Handle errors from various things ---
215
216 98xsave_send BL xsave__loseBuff ;Close the buffer
217
218 99xsave_send ADD R13,R13,#4 ;Don't restore R0 on exit
219 LDMFD R13!,{R1-R4,R12,R14} ;Unstack lots of registers
220 ORRS PC,R14,#V_flag ;And return the error
221
222 LTORG
223
224 ; --- xsave__startCo ---
225 ;
226 ; On entry: R0 == my coroutine handle
227 ; R10 == pointer to block containing (routine,R10,R12)
228 ; R12 == my workspace
229 ;
230 ; On exit: Returns through coRout_end
231 ;
232 ; Use: Starts the coroutine for sending data by RAM transfer. It
233 ; handles errors reported by it, and terminates the transfer
234 ; properly.
235
236 xsave__startCo ROUT
237
238 LDMIA R10,{R0,R10,R12} ;Load the caller's registers
239 MOV R14,PC ;Set up a return address
240 MOV PC,R0 ;And call the saver routine
241
242 ; --- Handle its return values ---
243
244 WSPACE xsave__wSpace ;Locate my workspace address
245 LDR R14,xsave__flags ;Load the flags word
246 BVS %90xsave__startCo ;If error, handle it nicely
247
248 ; --- Just return the current buffer state ---
249
250 ORR R14,R14,#xsFlag__finish ;Set the finished flag
251 STR R14,xsave__flags ;Save the flags back again
252 ADR R14,xsave__buffer ;Point to the buffer info
253 LDMIA R14,{R0,R1} ;Load the start and size info
254 ADR R14,xsave__start ;Point to return information
255 STMIA R14,{R0,R1} ;Save this to be sent next
256 B coRout_end ;And terminate the coroutine
257
258 90 ORR R14,R14,#xsFlag__error ;Set the main error flag
259 STR R14,xsave__flags ;Save the flags back again
260 STR R0,xsave__error ;And save the error pointer
261 B coRout_end ;And finish the coroutine
262
263 LTORG
264
265 ; --- xsave_done ---
266 ;
267 ; On entry: --
268 ;
269 ; On exit: --
270 ;
271 ; Use: Tidies up after a successful save job.
272
273 EXPORT xsave_done
274 xsave_done ROUT
275
276 STMFD R13!,{R12,R14} ;Save some registers
277 WSPACE xsave__wSpace ;Find my workspace
278 LDR R14,xsave__flags ;Load my flags word
279 TST R14,#xsFlag__ramTran ;Are we using RAM transfer?
280 BLNE xsave__loseBuff ;Yes -- destroy the buffer
281 LDMFD R13!,{R12,PC}^ ;Return to caller
282
283 LTORG
284
285 ; --- xsave_failed ---
286 ;
287 ; On entry: R0 == pointer to error block
288 ;
289 ; On exit: --
290 ;
291 ; Use: Tidies up a RAM transfer after an error.
292
293 EXPORT xsave_failed
294 xsave_failed ROUT
295
296 STMFD R13!,{R12,R14} ;Save some registers
297 WSPACE xsave__wSpace ;Find my workspace
298 LDR R14,xsave__flags ;Load my flags word
299 TST R14,#xsFlag__ramTran ;Are we using RAM transfer?
300 LDMEQFD R13!,{R12,PC}^ ;No -- return right now then
301
302 ; --- Find out if the user has seen the error yet ---
303 ;
304 ; We also don't want to inform the user if the save is
305 ; complete -- his coroutine will already be destroyed.
306
307 STMFD R13!,{R0} ;Save some more registers
308 TST R14,#xsFlag__finish :OR: xsFlag__error
309 BNE %30xsave_failed ;Yes -- then don't switch
310
311 ; --- Get xsave__write to return an error ---
312
313 ORR R14,R14,#xsFlag__error ;Set the error flag
314 STR R0,xsave__error ;And save the error pointer
315 LDR R0,xsave__coRout ;Load the coroutine handle
316 BL coRout_switch ;And switch to it
317
318 ; --- Now tidy everything up ---
319 ;
320 ; The coroutine should have killed itself by now
321
322 30xsave_failed BL xsave__loseBuff ;Kill off the data buffer
323 LDMFD R13!,{R0,R12,PC}^ ;Return to caller
324
325 LTORG
326
327 ; --- xsave__setBuff ---
328 ;
329 ; On entry: --
330 ;
331 ; On exit: May return an error
332 ;
333 ; Use: Sets up the buffer for a data transfer.
334
335 xsave__setBuff ROUT
336
337 STMFD R13!,{R0-R2,R14} ;Save some registers
338
339 ; --- Allocate the buffer memory ---
340
341 MOV R0,#xsave__buffSize ;Get the buffer size
342 BL alloc ;Try to allocate the buffer
343 BLCS alloc_error ;Get an error if it failed
344 BCS %90xsave__setBuff ;And tidy things up
345
346 ; --- Set up los of variables ---
347
348 ADR R14,xsave__buffer ;Point at the buffer info
349 MOV R1,#0 ;No buffer used yet
350 MOV R2,#0 ;No data sent yet either
351 STMIA R14,{R0-R2} ;Save these values away
352 LDMFD R13!,{R0-R2,R14} ;Restore all the registers
353 BICS PC,R14,#V_flag ;And return with V clear
354
355 ; --- Report an error ---
356
357 90 ADD R13,R13,#4 ;Don't restore R0 on exit
358 LDMFD R13!,{R1,R2,R14} ;Restore all the registers
359 ORRS PC,R14,#V_flag ;And return with V set
360
361 LTORG
362
363 ; --- xsave__loseBuff ---
364 ;
365 ; On entry: --
366 ;
367 ; On exit: --
368 ;
369 ; Use: Kills off the buffer.
370
371 xsave__loseBuff ROUT
372
373 STMFD R13!,{R0,R14} ;Save some registers
374 LDR R0,xsave__buffer ;Load the buffer address
375 BL free ;Free the buffer
376 LDR R14,xsave__flags ;Load my current flags word
377 AND R14,R14,#xsFlag__inited ;Only leave inited flag
378 STR R14,xsave__flags ;Save the flags back again
379 LDMFD R13!,{R0,PC}^ ;And return to caller
380
381 LTORG
382
383 ; --- xsave_byte ---
384 ;
385 ; On entry: R0 == byte to write in lowest 8 bits
386 ;
387 ; On exit: May return an error
388 ;
389 ; Use: Writes a single byte to the current output.
390
391 EXPORT xsave_byte
392 xsave_byte ROUT
393
394 STMFD R13!,{R0,R1,R14} ;Save some registers
395 MOV R0,R13 ;Point to saved byte
396 MOV R1,#1 ;Just write one byte
397 BL xsave_block ;Send it to the output
398 STRVS R0,[R13,#0] ;Save any error pointers
399 LDMFD R13!,{R0,R1,PC} ;And return to caller
400
401 LTORG
402
403 ; --- xsave_word ---
404 ;
405 ; On entry: R0 == word to write
406 ;
407 ; On exit: May return an error
408 ;
409 ; Use: Writes a single word to the current output.
410
411 EXPORT xsave_word
412 xsave_word ROUT
413
414 STMFD R13!,{R0,R1,R14} ;Save some registers
415 MOV R0,R13 ;Point to saved word
416 MOV R1,#4 ;Just write one word
417 BL xsave_block ;Send it to the output
418 STRVS R0,[R13,#0] ;Save any error pointers
419 LDMFD R13!,{R0,R1,PC} ;And return to caller
420
421 LTORG
422
423 ; --- xsave_string ---
424 ;
425 ; On entry: R0 == pointer to a control-terminated string
426 ;
427 ; On exit: May return an error
428 ;
429 ; Use: Writes a control-terminated string to the current output.
430 ; The string is null terminated in the output file.
431
432 EXPORT xsave_string
433 xsave_string ROUT
434
435 STMFD R13!,{R0,R14} ;Save some registers
436 00xsave_string LDRB R14,[R0],#1 ;Load a byte from the string
437 CMP R14,#32 ;Is it a control character?
438 MOVLO R14,#0 ;Yes -- make it a zero then
439 BL xsave_byte ;Write it out
440 BVS %90xsave_string ;If it failed, return error
441 BHS %00xsave_string ;Otherwise go round again
442 LDMFD R13!,{R0,R14} ;Restore the registers
443 BICS PC,R14,#V_flag ;And don't return an error
444
445 90xsave_string ADD R13,R13,#4 ;Don't restore R0 on exit
446 LDMFD R13!,{R14} ;Restore the link register
447 ORRS PC,R14,#V_flag ;And return an error
448
449 LTORG
450
451 ; --- xsave_block ---
452 ;
453 ; On entry: R0 == pointer to buffer to write
454 ; R1 == size of buffer to write
455 ;
456 ; On exit: May return an error
457 ;
458 ; Use: Writes out a block of data. Data is buffered, so this is
459 ; fairly quick for reading small objects. Large data blocks
460 ; are sent directly to avoid buffering overhead.
461
462 EXPORT xsave_block
463 xsave_block ROUT
464
465 CMP R1,#0 ;Is there anything there?
466 BICEQS PC,R14,#V_flag ;No -- return with no error
467
468 STMFD R13!,{R0-R4,R12,R14} ;Save a load of registers
469 WSPACE xsave__wSpace ;Load my workspace address
470
471 ; --- Fix up the total data sent ---
472
473 LDR R14,xsave__total ;Load the total sent so far
474 ADD R14,R14,R1 ;Add on the size of this one
475 STR R14,xsave__total ;And save the total back
476
477 ; --- Work out what we have to do ---
478
479 CMP R1,#xsave__buffSize ;Is the block really big?
480 BGE %50xsave_block ;Yes -- then deal with that
481
482 ; --- Write as much as possible to the buffer ---
483
484 ADR R14,xsave__buffer ;Point to buffer data
485 LDMIA R14,{R2,R3} ;Load address and size
486 RSB R4,R3,#xsave__buffSize ;How much is free in there?
487 CMP R1,R4 ;Is there enough space?
488 BLT %30xsave_block ;Yes -- just add some more
489
490 ; --- Fill the buffer right up now ---
491
492 MOV R1,R0 ;Point to the new block
493 ADD R0,R2,R3 ;Point to free part of buffer
494 MOV R2,R4 ;And get the size to copy
495 BL fastMove ;Copy it all over then
496 LDR R0,xsave__buffer ;Point to the buffer
497 MOV R1,#xsave__buffSize ;And get its full size
498 BL xsave__write ;Write a bufferfull out
499 BVS %99xsave_block ;Handle an error from this
500
501 ; --- Fix up all the pointers ---
502
503 LDMIA R13,{R0,R1} ;Reload the buffer addresses
504 ADD R0,R0,R2 ;Move on the block pointer
505 SUB R1,R1,R2 ;And chop off correctly
506 LDR R2,xsave__buffer ;Point to the buffer start
507 MOV R3,#0 ;And now it's empty
508
509 ; --- Just top up the buffer then ---
510
511 30xsave_block MOV R14,R0 ;Point to client's buffer
512 ADD R0,R2,R3 ;Point to free part of buff
513 MOVS R2,R1 ;Get the block size to copy
514 MOV R1,R14 ;Set up source pointer now
515 BLNE fastMove ;Do the copy job now
516 ADD R3,R3,R2 ;Add on the block size
517 STR R3,xsave__buffUsed ;Save the new buffer size
518 B %90xsave_block ;And finish it all up
519
520 ; --- Send a really big block ---
521
522 50xsave_block ADR R14,xsave__buffer ;Point to buffer info
523 LDMIA R14,{R0,R1} ;Load the buffer stuff
524 BL xsave__write ;Write it all out
525 BVS %99xsave_block ;Handle an error from this
526 MOV R14,#0 ;Nothing left there now
527 STR R14,xsave__buffUsed ;So clear the buffer size
528 LDMIA R13,{R0,R1} ;Get caller's block size
529 BL xsave__write ;Write it out nicely
530 BVS %99xsave_block ;Handle an error from this
531
532 90xsave_block LDMFD R13!,{R0-R4,R12,R14} ;Restore all the registers
533 BICS PC,R14,#V_flag ;And return no errors
534
535 99xsave_block ADD R13,R13,#4 ;Don't restore R0 on exit
536 LDMFD R13!,{R1-R4,R12,R14} ;Restore all the registers
537 ORRS PC,R14,#V_flag ;And return the error
538
539 LTORG
540
541 ; --- xsave__write ---
542 ;
543 ; On entry: R0 == pointer to buffer to write
544 ; R1 == size of buffer to write
545 ;
546 ; On exit: May return an error
547 ;
548 ; Use: Writes a block of data to the file or application. This is
549 ; one of the few bits of save/send dependent code in the
550 ; module.
551
552 xsave__write ROUT
553
554 CMP R1,#0 ;Is there anything there?
555 BICEQS PC,R14,#V_flag ;No -- return with no error
556
557 STMFD R13!,{R14} ;Save some registers
558 LDR R14,xsave__flags ;Find my flags word
559 TST R14,#xsFlag__ramTran ;Am I using RAM transfer?
560 BNE %50xsave__write ;Yes -- do that then
561
562 ; --- Use OS_HeebieJeebie to send the data ---
563
564 STMFD R13!,{R0-R4} ;Save some more registers
565 MOV R2,R0 ;Point to the user's buffer
566 MOV R3,R1 ;And get the buffer size
567 LDR R1,xsave__file ;Get the file's handle
568 MOV R0,#2 ;Write at current position
569 SWI XOS_GBPB ;Write the data out nicely
570 STRVS R0,[R13,#0] ;If error, save error pointer
571 LDMFD R13!,{R0-R4,R14} ;Unstack the registers
572 ORRVSS PC,R14,#V_flag ;Return V set as required
573 BICVCS PC,R14,#V_flag
574
575 ; --- Get the main coroutine to send the buffer ---
576
577 50xsave__write STMFD R13!,{R0} ;Save another register
578 ADR R14,xsave__start ;Point to the buffer info
579 STMIA R14,{R0,R1} ;Save for main coroutine
580 MOV R0,#0 ;Get magic coroutine handle
581 BL coRout_switch ;And switch to main code
582 LDR R14,xsave__flags ;Reload the flags
583 TST R14,#xsFlag__error ;Was there a problem?
584 LDMFD R13!,{R0,R14} ;Restore the registers
585 BICEQS PC,R14,#V_flag ;No -- just clear V then
586 LDRNE R0,xsave__error ;Otherwise load error pointer
587 ORRNES PC,R14,#V_flag ;And return with V set
588
589 LTORG
590
591 xsave__wSpace DCD 0
592
593 ;----- Constants ------------------------------------------------------------
594
595 xsave__buffSize EQU 1024 ;1K buffer should be enough
596
597 ;----- Workspace ------------------------------------------------------------
598
599 ^ 0,R12
600 xsave__wStart # 0
601
602 xsave__flags # 4 ;Various run-time flags
603 xsave__coRout # 0 ;The send coroutine handle
604 xsave__file # 4 ;The save file handle
605 xsave__buffer # 4 ;Pointer to my 1K buffer
606 xsave__buffUsed # 4 ;Amount of data in buffer
607 xsave__total # 4 ;How much data sent so far
608 xsave__error # 0 ;Error pointer from corout
609 xsave__start # 4 ;Start of buffer to send
610 xsave__length # 4 ;Size of next buffer to send
611
612 xsave__wSize EQU {VAR}-xsave__wStart
613
614 xsFlag__inited EQU (1<<0) ;Are we initialised already?
615 xsFlag__ramTran EQU (1<<1) ;Are we doing RAM transfer?
616 xsFlag__finish EQU (1<<2) ;This is the very last block
617 xsFlag__error EQU (1<<3) ;Should return an error
618
619 AREA |Sapphire$$LibData|,CODE,READONLY
620
621 DCD xsave__wSize
622 DCD xsave__wSpace
623 DCD 0
624 DCD 0
625
626 ;----- That's all, folks ----------------------------------------------------
627
628 END
The Straylight Source Distribution (obsolete software for RISC OS)