~mdw / ssr / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Create readable text `.bas' for each tokenized BASIC `,ffb' file.
[ssr] / StraySrc / SapphToys / !SWIlist / bs / swiList.bas
CommitLineData
c1b567d8
MW		 1REM
2REM swiList.bs
3REM
4REM Build SWI name include files
5REM
6REM © 1995 Straylight
7REM
8
9REM -- Standard header ------------------------------------------------------
10
11ON ERROR ERROR 0,"*** ERROR: "+REPORT$+" ["+STR$(ERL)+"]"
12
13LIBRARY "libs:BAS"
14PROCbas_init
15
16PROCbas_aofInit(&8000)
17
18V_flag=1<<28
19C_flag=1<<29
20
21FOR o=4 TO 6 STEP 2
22
23[ opt o
24 FNpass
25
26;----- Revision history -----------------------------------------------------
27;
28; Version By Change
29;
30; 1.xx MDW Old version written in C using STEEL.
31;
32; 2.00 MDW Rewrite from scratch in assembler using Sapphire.
33; Keep SWI names in flex block, allow user format
34; files, and add SWIs from modules dropped onto icon.
35;
36; 2.01 MDW Replaced format file loading with a chunk file, to
37; support multiple programming languages. Added
38; submenu to `Save list' for selecting which language
39; to use.
40;
41; 2.02 MDW Added %d format specifier to output generation time/
42; date in given style. Also added revision history ;-)
43;
44; 2.03 MDW Added confirm on quit option, and prevented saving
45; a dump from SWIList back into itself.
46;
47; 2.04 MDW Tidied up initialisation a little, and made it
48; register the heap routines as allocators for smaller
49; WimpSlot.
50;
51; 2.05 MDW Fiddled help message generation a little to (a)
52; do message translation of the format names and (b)
53; use %0 rather than the less pretty %9 in the help
54; skeleton.
55;
56; 2.06 MDW Added full pathname for dump save, so you don't have
57; to dig up the application to save the dump each time.
58;
59; 2.07 MDW Used SEH for error handling, instead of raw except-
60; level stuff.
61
62;----- External dependencies ------------------------------------------------
63
64 ; --- Sapphire library ---
65
66 FNget ("sapphire:alloc")
67 FNget ("sapphire:buttons")
68 FNget ("sapphire:chunk")
69 FNget ("sapphire:defHandler")
70 FNget ("sapphire:errorBox")
71 FNget ("sapphire:event")
72 FNget ("sapphire:fastMove")
73 FNget ("sapphire:flex")
74 FNget ("sapphire:heap")
75 FNget ("sapphire:help")
76 FNget ("sapphire:hour")
77 FNget ("sapphire:ibicon")
78 FNget ("sapphire:libOpts")
79 FNget ("sapphire:menu")
80 FNget ("sapphire:menuDefs")
81 FNget ("sapphire:msgs")
82 FNget ("sapphire:note")
83 FNget ("sapphire:progInfo")
84 FNget ("sapphire:ptr")
85 FNget ("sapphire:report")
86 FNget ("sapphire:res")
87 FNget ("sapphire:resources")
88 FNget ("sapphire:sapphire")
89 FNget ("sapphire:seh")
90 FNget ("sapphire:string")
91 FNget ("sapphire:warning")
92
93 FNget ("sapphire:choices.choices")
94
95 FNget ("sapphire:xfer.load")
96 FNget ("sapphire:xfer.saveAs")
97 FNget ("sapphire:xfer.save")
98 FNget ("sapphire:xfer.xsave")
99
100 ; --- Link-time generated strings ---
101
102 FNimport("cright")
103 FNimport("version")
104
105;----- Initialisation -------------------------------------------------------
106
107 FNarea ("Client$$Code","CODE,READONLY")
108
109; --- main ---
110;
111; On entry; --
112;
113; On exit; Via OS_Exit
114;
115; Use; Allows saving of header files containing SWI name-number
116; mappings.
117
118.main FNentry
119
120 adr r0,FNlitsz("SWIList") ;Point to application name
121 mov r1,#sl__wSize ;Get my workspace size
122 mov r2,#0 ;Default stack size
123 bl sapphire_init ;Start up the library
124 bl sl__preInit ;Do pre-initialisation stuff
125 bl sapphire_libInit ;Initialise rest of library
126 bl sl__init ;Initialise me
127
128 bl seh_throwErrors ;Make errors throw exceptions
129 bl report_catchAll ;And catch exceptions
130
131.sl__pollLoop mov r0,#1 ;Don't have idle events
132 add r1,r12,#sl__pollBlock ;Point to the poll block
133 bl event_poll ;Handle an event
134 blcc sl__unknowns ;Handle unknown events
135 blcc defHandler ;Pass it on if unrecognised
136 b sl__pollLoop ;And carry on round forever
137
138 FNltorg
139
140; --- sl__preInit ---
141;
142; On entry; --
143;
144; On exit; R0-R10 corrupted
145;
146; Use; Does initialisation of things before the main Sapphire
147; library awakes.
148
149.sl__preInit stmfd r13!,{r14} ;Save a register away
150 bl resources_init ;Use shared resource DLL
151 bl hour_init ;Wake up the hourglass system
152 bl hour_on ;And turn it on
153 ldr r0,[r11,#sapph_appName] ;Find the application name
154 bl heap_init ;Initialise the resizing heap
155 bl heap_useHeap ;Register it as an allocator
156 adr r0,sl__sapphOpts ;Point to options block
157 bl libOpts_register ;Register the options
158 ldmfd r13!,{pc}^ ;Return to caller when done
159
160.sl__sapphOpts FNlibOpt("MENU")
161 dcd 8192
162 FNlibOpts_end
163
164 FNltorg
165
166; --- sl__init ---
167;
168; On entry; --
169;
170; On exit; --
171;
172; Use; Initialises SWIList's workspace.
173
174.sl__init stmfd r13!,{r14} ;Save some registers
175 bl sl__initWS ;Set up my workspace
176 bl sl__loadFormat ;Load the user's format file
177 bl sl__initList ;Create the SWI list
178 bl sl__iconBar ;Create my icon
179 bl sl__setFlags ;Finally set the flags up
180 ldmfd r13!,{pc}^ ;And return to caller
181
182 FNltorg
183
184; --- sl__initWS ---
185;
186; On entry; --
187;
188; On exit; R0-R10 corrupted
189;
190; Use; Initialises the application's workspace.
191
192.sl__initWS stmfd r13!,{r14} ;Save the link register
193 mov r14,#0 ;Zero the anchor pointer
194 str r14,[r12,#sl__flags] ;Clear the flags initially
195 str r14,[r12,#sl__anchor] ;Say we have no block yet
196 str r14,[r12,#sl__modNames] ;No module name table
197 str r14,[r12,#sl__format] ;No format loaded yet
198 ldmfd r13!,{pc}^ ;And return to caller
199
200 FNltorg
201
202; --- sl__loadFormat ---
203;
204; On entry; --
205;
206; On exit; R0-R10 corrupted
207;
208; Use; Loads SWIList's format file.
209
210.sl__loadFormat stmfd r13!,{r14} ;Save the link register
211
212 ; --- Enable the Choices support ---
213
214 mov r0,#1 ;Enable `Choices' support
215 bl choices_useChoices ;Allow read-only use nicely
216
217 ; --- Create the format chunk file ---
218
219 bl chunk_create ;Create a chunk file
220 swivs "OS_GenerateError" ;Be unhappy if it fails
221 str r0,[r12,#sl__format] ;Save this away
222
223 ; --- Now do the actual load operation ---
224
225 adr r0,FNlitsz("Format") ;Point to the leafname
226 mov r1,r11 ;Build name in scratchpad
227 mov r2,#0 ;I want to read the file
228 bl choices_find ;Translate the name
229 mov r1,r0 ;Point to the name
230 sub r13,r13,#4 ;Make a flex anchor
231 mov r2,r13 ;Point to this anchor
232 bl load_file ;Load the file into it
233 ldrvc r0,[r12,#sl__format] ;Find the format handle
234 movvc r1,r13 ;And point to the anchor
235 blvc chunk_read ;Add that to the chunks
236 mov r0,r13 ;Point to that anchor again
237 bl flex_free ;Get rid of the block
238 add r13,r13,#4 ;And restore the stack
239
240 ; --- Set flag if any format chunks found ---
241
242 ldr r0,[r12,#sl__format] ;Find the format handle
243 mov r1,#0 ;Start enumerating
244 bl chunk_enum ;Are there any chunks?
245 ldrcc r14,[r12,#sl__flags] ;Yes -- get the flags
246 orrcc r14,r14,#slFlag__format ;Set the format flag
247 strcc r14,[r12,#sl__flags] ;And save them back again
248 ldmfd r13!,{pc}^ ;Return to caller when done
249
250 FNltorg
251
252; --- sl__initList ---
253;
254; On entry; --
255;
256; On exit; R0-R10 corrupted
257;
258; Use; Initialises the SWI table, either by loading a saved dump
259; or by scanning the modules in memory.
260
261.sl__initList stmfd r13!,{r14} ;Save the link register
262 adr r0,FNlitsz("SWIDump") ;Point to the leafname
263 mov r1,r11 ;Build name in scratchpad
264 mov r2,#0 ;I want to read the file
265 bl choices_find ;Translate the name
266 mov r1,r0 ;Point to the name
267 bl sl__loadDmp ;Load the default dump
268 blvc sl__doneDmp ;If OK, set the rest up
269 blvs sl__initBlock ;Otherwise, scan the modules
270 ldmfd r13!,{pc}^ ;Return to caller when done
271
272 FNltorg
273
274; --- sl__iconBar ---
275;
276; On entry; --
277;
278; On exit; --
279;
280; Use; Sets up the icon bar icon.
281
282.sl__iconBar stmfd r13!,{r0-r6,r14} ;Save some registers
283 adr r0,FNlitsz("!swilist") ;Point to sprite to use
284 mov r1,#0 ;No text buffer here
285 mvn r2,#NOT(-1) ;Put icon on the left
286 mov r3,#0 ;Normal priority please
287 adr r4,sl__ibEvents ;Point to event handler
288 mov r5,#0 ;Pass no document handle
289 mov r6,r12 ;Pass workspace pointer
290 bl ibicon_create ;Create the icon nicely
291 swivs "OS_GenerateError" ;If it failed, halt program
292 ldmfd r13!,{r0-r6,pc}^ ;And return to caller
293
294 FNltorg
295
296; --- sl__ibEvents ---
297;
298; On entry; R0 == event code
299;
300; On exit; --
301;
302; Use; Handles events for the icon bar icon.
303
304.sl__ibEvents cmp r0,#(sl__ibe10-sl__ibe00)/4
305 addcc pc,pc,r0,lsl #2 ;Dispatch through branch tbl
306 movs pc,r14 ;Ignore unknown events
307
308.sl__ibe00 movs pc,r14 ;Ignore Select clicks
309 b sl__ibMenu ;Handle a menu click
310 movs pc,r14 ;Ignore Adjust clicks
311 b sl__ibLoad ;Handle a load/save request
312 b sl__ibLoad ;We treat them all the same
313 b sl__ibHelp ;Handle a help request
314.sl__ibe10
315 ; --- Handle a menu click ---
316
317.sl__ibMenu stmfd r13!,{r0-r3,r14} ;Save some registers
318 adr r0,sl__imDef ;Point to the menu definition
319 adr r1,sl__imEvents ;Point to menu handler code
320 mov r2,r10 ;Pass it the doc handle
321 mov r3,r12 ;And my workspace address
322 bl menu_create ;Display the menu nicely
323 ldmfd r13!,{r0-r3,pc}^ ;And return to caller
324
325.sl__imDef FNmenu("SWIList")
326 FNmenu_item("slINF")
327 FNmenu_subWarn
328 FNmenu_ruleOff
329 FNmenu_item("slSVL")
330 FNmenu_r12Data
331 FNmenu_iShade(sl__flags,slFlag__savable)
332 FNmenu_subWarn
333 FNmenu_noWarn
334 FNmenu_item("slSVD")
335 FNmenu_r12Data
336 FNmenu_iShade(sl__flags,slFlag__block)
337 FNmenu_subWarn
338 FNmenu_noWarn
339 FNmenu_item("slSCN")
340 FNmenu_item("slRFM")
341 FNmenu_subWarn
342 FNmenu_ruleOff
343 FNmenu_item("slQUT")
344 FNmenu_end
345
346 ; --- Handle a help request ---
347
348.sl__ibHelp stmfd r13!,{r0,r14} ;Save some registers
349 adr r0,FNlitsz("slhIB") ;Point to a message tag
350 bl msgs_lookup ;Translate the tag
351 bl help_add ;And add it to the help
352 ldmfd r13!,{r0,pc}^ ;Return to caller
353
354 ; --- Handle a load event ---
355
356.sl__ibLoad stmfd r13!,{r0-r2,r14} ;Save some registers
357 bl event_last ;Find the last event
358 ldr r0,[r1,#40] ;Load the filetype
359 ldr r14,FNlitw(&FFA) ;Get the module filetype
360 cmp r0,r14 ;Do these match
361 beq sl__ibLdMod ;Yes -- handle that then
362 ldr r14,FNlitw(&FFD) ;Get the data filetype
363 cmp r0,r14 ;Do these match
364 beq sl__ibLdDump ;Yes -- handle that then
365 ldmfd r13!,{r0-r2,pc}^ ;Return to caller
366
367 ; --- Handle loading a module ---
368
369.sl__ibLdMod adr r0,sl__lMod ;Point to load block
370 mov r1,r10 ;Get document handle
371 mov r2,r12 ;And workspace address
372 bl load ;Do the load operation
373 ldmfd r13!,{r0-r2,pc}^ ;And return when done
374
375.sl__lMod b sl__ibMod
376 b load_killBuf
377 b load_extendBuf
378 b load_doneBuf
379 b sl__loadMod
380 b sl__doneMod
381 b sl__lfMod
382
383 ; --- Handle loading a dump ---
384
385.sl__ibLdDump ldr r14,[r12,#sl__flags] ;Load the flags word
386 tst r14,#slFlag__saving ;Are we saving currently?
387 bne sl__ild50 ;Yes -- moan at user then
388
389 adr r0,sl__lDmp ;Point to load block
390 mov r1,r10 ;Get document handle
391 mov r2,r12 ;And workspace address
392 bl load ;Yes -- start a load op
393 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
394
395.sl__ild50 adr r0,FNliterr(1,"slCSII") ;Point to error block
396 bl msgs_error ;Translate the message
397 mov r1,#1 ;Only display OK button
398 bl errorBox ;Display the error
399 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
400
401.sl__lDmp b sl__ibDmp
402 b load_killBuf
403 b load_extendBuf
404 b load_doneBuf
405 b sl__loadDmp
406 b sl__doneDmp
407 b sl__lfDmp
408
409 FNltorg
410
411; --- sl__imEvents ---
412;
413; On entry; R0 == event code
414; R1 == item number
415;
416; On exit; --
417;
418; Use; Handles events from the icon bar menu.
419
420.sl__imEvents cmp r0,#mEvent_help ;A help request, perchance?
421 beq sl__imHelp ;Yes -- deliver help on it
422 cmp r0,#mEvent_select ;Is this a select event?
423 cmpne r0,#mEvent_subMenu ;Or a submenu opening?
424 movnes pc,r14 ;No -- ignore the event
425
426 cmp r1,#(sl__ime10-sl__ime00)/4
427 addcc pc,pc,r1,lsl #2 ;Dispatch by item number
428 movs pc,r14 ;Ignore unknown item numbers
429
430.sl__ime00 b sl__imInfo ;Display the info box
431 b sl__imSave ;Save the SWI list
432 b sl__imDump ;Save a SWI dump
433 b sl__initBlock ;Reset the block
434 b sl__imRefresh ;Refresh a particular module
435 b sl__imQuit ;Close down the program
436.sl__ime10
437
438 ; --- Send a help message ---
439
440.sl__imHelp stmfd r13!,{r0,r14} ;Save some registers
441 adr r0,FNlitsz("slhIM") ;Find the message base tag
442 bl menu_help ;Give help on the item
443 ldmfd r13!,{r0,pc}^ ;And return to caller
444
445 ; --- Display the info window ---
446
447.sl__imInfo stmfd r13!,{r0-r2,r14} ;Save some registers
448 adr r0,FNlitsz("slPUR") ;Point to purpose message
449 bl msgs_lookup ;Translate message tag
450 ldr r1,FNlitw(cright) ;Find the copyright string
451 ldr r2,FNlitw(version) ;And the version string
452 bl progInfo ;Display the box
453 movvs r1,#1 ;If it failed, display error
454 blvs errorBox ;In a pretty error box
455 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
456
457 FNltorg
458
459 ; --- Dislplay the menu of formats ---
460
461.sl__imSave cmp r0,#mEvent_subMenu ;Make sure this is a submenu
462 movnes pc,r14 ;No -- not interested
463
464 stmfd r13!,{r0-r5,r14} ;Save some registers
465 adr r0,sl__fmtTitle ;Point to the title
466 mov r1,#0 ;No handler for that
467 bl menu_create ;Set that up to display
468
469 ldr r4,[r12,#sl__format] ;Load the format chunk file
470 mov r1,#0 ;Read first chunk name
471.loop mov r0,r4 ;Pop it in R0 for a bit
472 bl chunk_enum ;Get the next chunk
473 ldmcsfd r13!,{r0-r5,pc}^ ;Return when finished
474 str r2,[r1,#4] ;Save pointer to name
475 mov r2,r1 ;Point to the anchor
476 mov r5,r1 ;Look after continuation
477 adr r0,sl__fmtMenu ;Point to menu skeleton
478 adr r1,sl__fmtHandler ;Point to handler routine
479 mov r3,r12 ;Pass workspace in R12
480 bl menu_create ;Add that to the list
481 mov r1,r5 ;Get the continuation value
482 b loop ;And go back to the loop
483
484.sl__fmtTitle FNmenu("slSVFT")
485 FNmenu_end
486
487.sl__fmtMenu FNmenu_itemInd(4)
488 FNmenu_subWarn
489 FNmenu_end
490
491 FNltorg
492
493 ; --- Dislplay the dump box ---
494
495.sl__imDump stmfd r13!,{r0-r5,r14} ;Save some registers
496 ldr r0,[r12,#sl__used] ;Load the actual block size
497 ldr r1,FNlitw(&ffd) ;Output as a data file
498 add r2,r12,#sl__dumpFile ;Point to the dump file name
499 adr r3,sl__dumpDef ;Point to handler block
500 mov r4,r10 ;Pass document handle
501 mov r5,r12 ;And pass the workspace addr
502 bl saveAs ;Try to do the save op
503 bvs sl__imd90 ;Tidy up if it failed
504 ldr r14,[r12,#sl__flags] ;Load the current flags
505 orr r14,r14,#slFlag__saving ;Say we're now saving
506 str r14,[r12,#sl__flags] ;Save the flags back again
507 ldmfd r13!,{r0-r5,pc}^ ;And return to caller
508
509.sl__imd90 mov r1,#1 ;If it failed, report error
510 bl errorBox ;In a nice error box
511 ldmfd r13!,{r0-r5,pc}^ ;And return to caller
512
513.sl__dumpDef FNs ("slSDT") ;Title for the save box
514 b sl__svdDone ;Handle box closing
515 b sl__saveDump ;Save to a disk file
516 b sl__sendDump ;Send to another application
517 movs pc,r14 ;Ignore completion
518 b sl__svdFail ;Tidy up after a failure
519
520 FNltorg
521
522 ; --- Display a menu of modules to refresh ---
523
524.sl__imRefresh cmp r0,#mEvent_subMenu ;Is this a submenu?
525 movnes pc,r14 ;No -- go away then
526 stmfd r13!,{r0-r7,r14} ;Save some registers
527
528 ; --- Free the old title block ---
529
530 ldr r0,[r12,#sl__modNames] ;Load the pointer
531 cmp r0,#0 ;Is the block allocated?
532 blne free ;Yes -- deallocate it them
533 movne r14,#0 ;And clear the pointer out
534 strne r14,[r12,#sl__modNames] ;Done that
535
536 ; --- Enumerate interesting modules ---
537
538 mov r6,#0 ;Size of block required
539 mov r1,#0 ;Start at the beginning
540
541 ; --- Read the next module ---
542
543.loop mov r0,#12 ;Enumerate module names
544 mov r2,#0 ;Not interested in instances
545 swi "XOS_Module" ;Read the next module
546 bvs sl__imRefAlloc ;No more -- go to next phase
547
548 ; --- Update the arguments for next call ---
549
550 cmp r2,#0 ;Is there another instance?
551 addne r1,r1,#1 ;No -- update manually
552
553 ; --- See whether this module was interesting ---
554
555 ldr r14,[r3,#&20] ;Load the SWI handler offset
556 cmp r14,#0 ;Does this look sensible?
557 addne r6,r6,#8 ;Yes -- add another word
558 b loop ;Get more modules
559
560 ; --- Allocate the block ---
561
562.sl__imRefAlloc mov r0,r6 ;Get the required size
563 bl alloc ;Allocate the block
564 blcs alloc_error ;If it failed, point to error
565 bcs sl__imRefError ;And handle that
566 str r0,[r12,#sl__modNames] ;Store pointer for later
567 mov r7,r0 ;Point to the block start
568
569 ; --- Set up the title block ---
570
571 adr r0,sl__rfmTitle ;Point to the title block
572 adr r1,sl__rfmKernel ;Point to event handler
573 mov r2,r10 ;Pass my R10 value
574 mov r3,r12 ;And my R12 value
575 bl menu_create ;Create the title
576
577 ; --- Initialise for module scanning ---
578
579 mov r6,#0 ;Current module number
580
581 ; --- Read the next module ---
582
583.loop mov r0,#12 ;Enumerate module names
584 mov r1,r6 ;Get next module number
585 mov r2,#0 ;And next module name
586 swi "XOS_Module" ;Read the next module
587 ldmvsfd r13!,{r0-r7,pc}^ ;Return when done
588
589 ; --- Update the arguments for next call ---
590
591 cmp r2,#0 ;Is there another instance?
592 moveq r6,r1 ;Yes -- store it normally
593 addne r6,r1,#1 ;No -- update manually
594
595 ; --- See whether this module was interesting ---
596
597 ldr r14,[r3,#&20] ;Load the SWI handler offset
598 cmp r14,#0 ;Does this look sensible?
599 beq loop ;No -- loop round for more
600
601 ; --- Add the menu item for this module ---
602
603 ldr r14,[r3,#&10] ;Load the module name offset
604 add r14,r3,r14 ;Add this on to the base
605 stmia r7!,{r3,r14} ;Store base and name string
606 adr r0,sl__rfmItem ;Point to the menu block
607 adr r1,sl__rfmModule ;Point to the handler
608 sub r2,r7,#8 ;Point to name pointer
609 mov r3,r12 ;And get my workspace addr
610 bl menu_create ;Add to the current menu
611 b loop ;Keep on looping
612
613 ; --- Report an error ---
614
615.sl__imRefError add r2,r0,#4 ;Point to error message
616 adr r0,FNliterr(1,"slMLE") ;Point to skeleton
617 bl str_error ;Mangle the message
618 mov r1,#1 ;Just an OK button
619 bl errorBox ;Report the message
620 ldmfd r13!,{r0-r7,pc}^ ;And return to caller
621
622 ; --- Refresh module title ---
623
624.sl__rfmTitle FNmenu("slMDS")
625 ;FNmenu_item("slKNL") ;Not implemented
626 FNmenu_end
627
628 ; --- Refresh module items ---
629
630.sl__rfmItem FNmenu_itemInd(4)
631 FNmenu_end
632
633 FNltorg
634
635 ; --- Quit the application ---
636
637.sl__imQuit stmfd r13!,{r14} ;Save return address away
638 bl sl__okToQuit ;Make sure it's all right
639 swics "OS_Exit" ;Yes -- just kill everything
640 ldmfd r13!,{pc}^ ;Otherwise ignore the request
641
642 FNltorg
643
644; --- sl__rfmKernel ---
645;
646; On entry; --
647;
648; On exit; --
649;
650; Use; Refreshes the kernel SWIs table.
651
652.sl__rfmKernel movs pc,r14 ;Not implemented
653
654 FNltorg
655
656; --- sl__rfmModule ---
657;
658; On entry; --
659;
660; On exit; --
661;
662; Use; Refreshes a particular module.
663
664.sl__rfmModule stmfd r13!,{r0,r1,r14} ;Save link
665 ldr r0,[r10,#0] ;Load module base
666 bl sl__scanMod ;Scan the module
667 movvs r1,#1 ;If it failed
668 blvs errorBox ;Report the error
669 ldmfd r13!,{r0,r1,pc}^ ;And return to caller
670
671 FNltorg
672
673; --- sl__setFlags ---
674;
675; On entry; --
676;
677; On exit; --
678;
679; Use; Sets up the flags from the flex anchors we have.
680
681.sl__setFlags stmfd r13!,{r0,r14} ;Save some registers
682 ldr r0,[r12,#sl__flags] ;Load the flags word
683 ldr r14,[r12,#sl__anchor] ;Load the block anchor
684 cmp r14,#0 ;Is that defined?
685 orrne r0,r0,#slFlag__block ;Yes -- set the flag
686 biceq r0,r0,#slFlag__block ;No -- clear it
687 tstne r0,#slFlag__format ;Is there a format chunk?
688 orrne r0,r0,#slFlag__savable ;Yes -- set savable flag
689 biceq r0,r0,#slFlag__savable ;No -- clear it then
690 str r0,[r12,#sl__flags] ;Save modified flags
691 ldmfd r13!,{r0,pc}^ ;And return to caller
692
693 FNltorg
694
695; --- sl__unknowns ---
696;
697; On entry; R0 == event code
698; R1 == pointer to event data
699;
700; On exit; CS if event interesting, else CC
701; R2-R10 corrupted
702;
703; Use; Handles interesting messages (e.g. PreQuit)
704
705.sl__unknowns cmp r0,#17 ;Is this a User_Message?
706 cmpne r0,#18 ;Or a User_Message_Recorded?
707 movnes pc,r14 ;No -- ignore it then
708
709 ldr r2,[r1,#16] ;Load the event code
710 cmp r2,#8 ;Is this a pre-quit message?
711 movnes pc,r14 ;No -- not interested then
712
713 ; --- Handle a PreQuit message ---
714
715 orrs r14,r14,#C_flag ;We claim this event now
716 stmfd r13!,{r14} ;Save return address
717 bl sl__okToQuit ;Ask user if required
718 ldmcsfd r13!,{pc}^ ;If OK then continue normally
719
720 stmfd r13!,{r0-r2} ;Save some more registers
721 mov r0,r11 ;Point to scratchpad
722 ldr r2,[r1,#0] ;Load the message size
723 bl fastMove ;Copy the message data over
724 ldr r14,[r0,#8] ;Load his reference number
725 str r14,[r0,#12] ;Set this as a reply to it
726 mov r1,r0 ;Point to my copy
727 mov r0,#19 ;Send this as an acknowledge
728 ldr r2,[r1,#4] ;Load his task handle out
729 swi "Wimp_SendMessage" ;Send the message back
730 ldmfd r13!,{r0-r2,pc}^ ;Now return to caller
731
732 FNltorg
733
734; --- sl__okToQuit ---
735;
736; On entry; --
737;
738; On exit; CS if we're allowed to quit, else CC
739;
740; Use; Works out if we're allowed to quit the application. If it
741; isn't sure, it pops up a warning box and asks.
742
743.sl__okToQuit stmfd r13!,{r0,r1,r14} ;Save some registers
744 ldr r14,[r12,#sl__flags] ;Load the flags word out
745 tst r14,#slFlag__modified ;Has the block been changed?
746 beq sl__otq90 ;No -- then skip onwards
747
748 adr r0,FNlitsz("slOTQ") ;Point to warning messae
749 bl msgs_lookup ;Translate the tag
750 adr r1,sl__quitButts ;Point to buttons block
751 bl warning ;Pop up the warning box
752 ldmfd r13!,{r0,r1,r14} ;Unstack the registers
753 orrcss pc,r14,#C_flag ;If OK, set the C flag
754 bicccs pc,r14,#C_flag ;Otherwise clear it
755
756.sl__otq90 ldmfd r13!,{r0,r1,r14} ;Unstack the registers
757 orrs pc,r14,#C_flag ;Set C -- we're OK
758
759.sl__quitButts FNbutton("slQUTB")
760 FNbuttons_cancel
761 FNbuttons_end
762
763 FNltorg
764
765;----- Save a SWI file ------------------------------------------------------
766
767; --- sl__fmtHandler ---
768;
769; On entry; R0 == menu event
770; R1 == menu item
771; R10 == pointer to chunk name
772;
773; On exit; --
774;
775; Use; Handles events on the save menu.
776
777.sl__fmtHandler cmp r0,#mEvent_help ;Is this a help request?
778 beq sl__fmtHelp ;Yes -- give help then
779 cmp r0,#mEvent_subMenu ;Is this a submenu?
780 cmpne r0,#mEvent_select ;Or a click?
781 movnes pc,r14 ;No -- ignore this
782
783 stmfd r13!,{r0-r5,r14} ;Save some registers
784 ldr r0,[r12,#sl__used] ;Load the actual block size
785 ldr r1,FNlitw(&fff) ;Output as a data file
786 adr r2,FNlitsz("swis") ;Point to the dummy name
787 adr r3,sl__saveDef ;Point to handler block
788 mov r4,r10 ;Pass document handle
789 mov r5,r12 ;And pass the workspace addr
790 bl saveAs ;Try to do the save op
791 movvs r1,#1 ;If it failed, report error
792 blvs errorBox ;In a nice error box
793 ldmfd r13!,{r0-r5,pc}^ ;And return to caller
794
795.sl__saveDef FNs ("slSVT") ;Title for the save box
796 movs pc,r14 ;Don't care when it closes
797 b sl__saveFile ;Save to a disk file
798 b sl__send ;Send to another application
799 b xsave_done ;Tell xsave it's all done
800 b sl__failed ;Tidy up after a failure
801
802.sl__fmtHelp stmfd r13!,{r0-r2,r14} ;Save some registers
803 ldr r0,[r10,#4] ;Find the format chunk name
804 bl msgs_lookup ;Translate in case of tag
805 mov r1,r0 ;Point to the result
806 mov r0,r11 ;Point to scratchpad
807 bl str_cpy ;Copy the string over
808.loop ldrb r14,[r0,#-1]! ;Load last byte of string
809 subs r14,r14,#ASC(".") ;Is it part of an ellipsis?
810 streqb r14,[r0,#0] ;Yes -- nobble that byte
811 beq loop ;And try again
812 adr r0,FNlitsz("slhSVF") ;Point to help message tag
813 bl msgs_lookup ;Translate the message
814 bl str_buffer ;Find an output buffer
815 mov r2,r11 ;Point to scratchpad string
816 bl str_subst ;And build the help string
817 bl help_add ;Add this to help message
818 ldmfd r13!,{r0-r2,pc}^ ;Return to caller
819
820 FNltorg
821
822; --- sl__saveFile ---
823;
824; On entry; R0 == pointer to file name
825; R1 == safe flag
826;
827; On exit; --
828;
829; Use; Saves the SWI block to a file.
830
831.sl__saveFile stmfd r13!,{r0-r5,r14} ;Save some registers
832 mov r2,#0 ;No current name for this
833 bl sl__replace ;Do we replace the file?
834 movcc r0,#0 ;No -- return null error
835 bcc sl__sf20 ;But cancel the save op
836
837 ; --- Get on with saving the file ---
838
839.sl__sf10 mov r3,r0 ;Look after the file name
840 adr r0,sl__writeList ;Point to saver routine
841 mov r1,r10 ;Pass it the document handle
842 mov r2,r12 ;And my workspace pointer
843 ldr r4,FNlitw(&FFF) ;Pass the filetype over
844 bl xsave_save ;Try to save the file
845 bvs sl__sf20 ;If failed, abort now
846
847 ; --- Now retrostamp the file ---
848
849 mov r0,#17 ;Read info on the file
850 mov r1,r3 ;Point to the filename
851 swi "XOS_File" ;Read info on the file
852 movvc r0,#1 ;Now we set the info
853 bicvc r2,r2,#&FF ;Leave filetype alone
854 orrvc r2,r2,#&3A ;Put in our dummy datestamp
855 ldrvc r3,FNlitw(&BD896000) ;Set up rest of datestamp
856 swivc "XOS_File" ;Now retrostamp it nicely
857 ldmvcfd r13!,{r0-r5,pc}^ ;If it worked OK, return
858
859 ; --- It failed ---
860
861.sl__sf20 add r13,r13,#4 ;Don't restore R0 on exit
862 ldmfd r13!,{r1-r5,r14} ;Unstack saved registers
863 orrs pc,r14,#V_flag ;And return to caller
864
865 FNltorg
866
867; --- sl__send ---
868;
869; On entry; R2 == accumulator value (initially 0)
870;
871; On exit; R0 == pointer to block to send
872; R1 == size of block to send
873; CS if this is the last block, else CC
874;
875; Use; Sends a block of data to another application.
876
877.sl__send adr r0,sl__writeList ;Point to my saver routine
878 mov r1,r10 ;Pass the document handle
879 mov r2,r12 ;Pass my workspace too
880 b xsave_send ;And get another block
881
882 FNltorg
883
884; --- sl__failed ---
885;
886; On entry; R0 == pointer to error, or 0
887; R1 == 1
888;
889; On exit; --
890;
891; Use; Terminates a save job, and reports an error.
892
893.sl__failed stmfd r13!,{r0-r2,r14} ;Save some registers
894 bl xsave_failed ;Tell xsave it's finished
895 cmp r0,#0 ;Is there an actual error?
896 addne r2,r0,#4 ;Point to error text
897 adrne r0,FNliterr(1,"slSFE")
898 blne msgs_error ;Translate and substitute
899 movne r1,#1 ;Display just an OK button
900 blne errorBox ;Yes -- report it then
901 ldmfd r13!,{r0-r2,pc}^ ;Return to caller
902
903 FNltorg
904
905; --- sl__replace ---
906;
907; On entry; R0 == filename
908; R1 == safeness flag
909; R2 == pointer to current name, or 0
910;
911; On exit; --
912;
913; Use; CS to save, CC to cancel
914
915.sl__replace stmfd r13!,{r0-r2,r14} ;Save some registers
916 cmp r1,#0 ;Is the file marked as safe?
917 beq sl__replace10 ;No -- then don't ask
918
919 movs r1,r2 ;Is there a current name?
920 beq sl__replace05 ;No -- can't do this check
921 bl str_icmp ;Compare the file names
922 beq sl__replace10 ;The same name -- don't ask
923
924.sl__replace05 bl res_exists ;Does the file exist?
925 bcc sl__replace10 ;No -- then don't ask
926
927 ; --- Ask the user if this is right ---
928
929 mov r2,r0 ;Get the filename pointer
930 adr r0,FNlitsz("slRPP") ;Point to the prompt message
931 bl msgs_lookup ;Translate the message
932 bl str_buffer ;Find a handy string buffer
933 bl str_subst ;Build the prompt string
934 adr r1,sl__exWarn ;Point to the buttons def
935 bl warning ;Display the warning box
936 ldmccfd r13!,{r0-r2,r14} ;If no, abort the job
937 bicccs pc,r14,#C_flag ;Tell caller it's all off
938
939.sl__replace10 ldmfd r13!,{r0-r2,r14} ;Restore registers
940 orrs pc,r14,#C_flag ;And let it all go ahead
941
942.sl__exWarn FNbutton("slRPL")
943 FNbuttons_cancel
944 FNbuttons_end
945
946 FNltorg
947
948;----- Write out a dump file ------------------------------------------------
949
950; --- sl__svdDone ---
951;
952; On entry; --
953;
954; On exit; --
955;
956; Use; Handles the save box closing. We allow loads of dump files
957; again.
958
959.sl__svdDone stmfd r13!,{r14} ;Save some registers
960 ldr r14,[r12,#sl__flags] ;Load the flags word
961 bic r14,r14,#slFlag__saving ;Turn off the saving flag
962 str r14,[r12,#sl__flags] ;Save the flags back
963 ldmfd r13!,{pc}^ ;And return to caller
964
965 FNltorg
966
967; --- sl__saveDump ---
968;
969; On entry; R0 == pointer to file name
970; R1 == safeness flag
971;
972; On exit; --
973;
974; Use; Saves a dump of the current SWI names
975
976.sl__saveDump stmfd r13!,{r0-r5,r14} ;Save some registers
977 add r2,r12,#sl__dumpFile ;Point to current name
978 bl sl__replace ;Do we actually do this?
979 movcc r0,#0 ;If not, return null error
980 bcc sl__saved90 ;To cancel the save op
981
982 mov r1,r0 ;Point to the filename
983 mov r0,#10 ;Save memory as a file
984 ldr r2,FNlitw(&FFD) ;Save as a data file
985 add r14,r12,#sl__anchor ;Point to dump anchor
986 ldmia r14,{r4,r5} ;Load base and size
987 add r5,r4,r5 ;Turn size into limit
988 swi "XOS_File" ;Try to save the file
989 bvs sl__saved90 ;If it failed, abort
990
991 ldr r14,[r13,#4] ;Load the safeness flag
992 cmp r14,#0 ;Is the flag safe?
993 beq sl__saved50 ;No -- skip onwards then
994
995 ; --- Do special things when file saved properly ---
996
997 ldr r14,[r12,#sl__flags] ;Yes -- load flags then
998 bic r14,r14,#slFlag__modified ;Clear the modified bit
999 str r14,[r12,#sl__flags] ;And store the flags back
1000
1001 bl sl__setDumpName ;Go and set the name
1002
1003.sl__saved50 ldmfd r13!,{r0-r5,pc}^ ;Return to caller
1004
1005.sl__saved90 add r13,r13,#4 ;Don't restore R0 on exit
1006 ldmfd r13!,{r1-r5,r14} ;Restore registers
1007 orrs pc,r14,#V_flag ;And return with V set
1008
1009 FNltorg
1010
1011; --- sl__sendDump ---
1012;
1013; On entry; --
1014;
1015; On exit; R0 == pointer to block to send
1016; R1 == size of block
1017; CS for last block, CC otherwise
1018;
1019; Use; Sends the SWI dump block to another application
1020
1021.sl__sendDump add r0,r12,#sl__anchor ;Find the anchor block
1022 ldmia r0,{r0,r1} ;Load the values out
1023 orrs pc,r14,#C_flag ;And return the only block
1024
1025 FNltorg
1026
1027; --- sl__svdFail ---
1028;
1029; On entry; R0 == pointer to error, or 0
1030; R1 == 1
1031;
1032; On exit; --
1033;
1034; Use; Terminates a save job, and reports an error.
1035
1036.sl__svdFail stmfd r13!,{r0-r2,r14} ;Save some registers
1037 cmp r0,#0 ;Is there an actual error?
1038 addne r2,r0,#4 ;Point to error text
1039 adrne r0,FNliterr(1,"slSDE")
1040 blne msgs_error ;Translate and substitute
1041 movne r1,#1 ;Display just an OK button
1042 blne errorBox ;Yes -- report it then
1043 ldmfd r13!,{r0-r2,pc}^ ;Return to caller
1044
1045 FNltorg
1046
1047;----- Writing out a list of SWIs -------------------------------------------
1048
1049; --- sl__writeList ---
1050;
1051; On entry; --
1052;
1053; On exit; --
1054;
1055; Use; Writes the list of SWIs to the current xsave output.
1056
1057.sl__writeList stmfd r13!,{r0-r10,r14} ;Save some registers
1058
1059 ; --- Make sure we can do this ---
1060
1061 ldr r14,[r12,#sl__anchor] ;Load the block anchor
1062 cmp r14,#0 ;Is it created currently?
1063 adreq r0,FNliterr(1,"slNSS")
1064 bleq msgs_error ;Translate the error
1065 beq sl__wl90 ;And return the error
1066 ldr r14,[r12,#sl__format] ;Load the format anchor
1067 cmp r14,#0 ;Is it created currently?
1068 adreq r0,FNliterr(1,"slNFD")
1069 bleq msgs_error ;Translate the error
1070 beq sl__wl90 ;And return the error
1071
1072 ; --- Get on with saving then ---
1073
1074 swi "Hourglass_On" ;Start an hourglass going
1075
1076 ; --- Set up initial registers ---
1077
1078 ldr r9,[r10,#0] ;Load the block base
1079 mov r0,r10 ;Point to the anchor
1080 bl flex_size ;Get the block size
1081 add r10,r9,r0 ;Find the format limit
1082 adr r8,FNlitsz("*UNDEFINED*") ;No module name defined yet
1083 mov r7,r8 ;No prefix string yet either
1084 mov r6,r8 ;And no actual SWI name
1085 mvn r5,#NOT(-1) ;No SWI number defined either
1086
1087 ; --- Write out the preamble ---
1088
1089 bl sl__doString ;Write out this format
1090 bvs sl__wl90 ;If it failed, bail out
1091
1092 ; --- We've found the module header ---
1093 ;
1094 ; Now we set up for the main loop, by remembering the index
1095 ; into the format string; we then embark on the first item
1096 ; in the SWI list.
1097
1098 mov r4,r9 ;Remember this position
1099 ldr r3,[r12,#sl__anchor] ;Load the anchor base address
1100 mov r2,#0 ;Start at the beginning
1101
1102 ; --- The main output loop ---
1103
1104.sl__wl15 add r1,r3,r2 ;Work out address of block
1105 ldr r5,[r1,#4] ;Load the SWI chunk number
1106 bic r5,r5,#&ff000000 ;Clear the flags bits
1107 add r8,r1,#8 ;Point to the module name
1108 mov r9,r4 ;Start from preamble position
1109 bl sl__doString ;Write out this format string
1110 bvs sl__wl90 ;If it failed, bail out
1111
1112 ; --- Written the header -- now do the SWIs ---
1113
1114 mov r2,r9 ;Remeber format index
1115 mov r7,r8 ;Work out prefix string pos
1116.sl__wl20 ldrb r14,[r7],#1 ;Load next byte
1117 cmp r14,#0 ;Is this end of module name?
1118 bne sl__wl20 ;No -- keep going round
1119
1120 mov r6,r7 ;Work out SWI name position
1121.sl__wl25 ldrb r14,[r6],#1 ;Load next byte from string
1122 cmp r14,#0 ;Is this the end yet?
1123 bne sl__wl25 ;No -- keep going
1124.sl__wl26 ldrb r14,[r6,#0] ;Load the first byte
1125 cmp r14,#0 ;Is it a null string?
1126 beq sl__wl30 ;Yes -- move on to next mod
1127 cmp r14,#1 ;Is this a dummy SWI?
1128 addeq r6,r6,#1 ;Yes -- move pointer on
1129 addeq r5,r5,#1 ;And move on the SWI counter
1130 beq sl__wl26 ;And start again
1131
1132 mov r9,r2 ;Point to format string
1133 bl sl__doString ;Write this string out
1134 bvs sl__wl90 ;If it failed, bail out
1135 add r5,r5,#1 ;Bump up the SWI number
1136 b sl__wl25 ;And go round for more
1137
1138 ; --- Finished a module ---
1139
1140.sl__wl30 ldr r2,[r1,#0] ;Load the size word
1141 sub r14,r1,r3 ;Work out old offset
1142 add r2,r14,r2 ;Add it onto previous offset
1143 ldr r14,[r12,#sl__used] ;Load current size of block
1144 cmp r2,r14 ;Is this the last one?
1145 bcc sl__wl15 ;No -- do this module too
1146
1147 ; --- Do the end bit of the file ---
1148
1149 bl sl__doString ;Write out the postamble
1150 bvs sl__wl90 ;If it failed, bail out
1151
1152 swi "Hourglass_Off" ;Turn off the hourglass
1153 ldmfd r13!,{r0-r10,pc}^ ;Return to caller
1154
1155 ; --- It failed -- return an error
1156
1157.sl__wl90 swi "Hourglass_Off" ;Turn off the hourglass
1158 add r13,r13,#4 ;Don't restore R0
1159 ldmfd r13!,{r1-r10,r14} ;Restore registers
1160 orrs pc,r14,#V_flag ;And return the error
1161
1162 FNltorg
1163
1164; --- sl__doString ---
1165;
1166; On entry; R5 == current SWI number
1167; R6 == pointer to current SWI postfix
1168; R7 == pointer to current SWI prefix
1169; R8 == pointer to current module name
1170; R9 == pointer to format string input
1171; R10 == pointer to end of format string
1172;
1173; On exit; R1, R2, R4 and R6-R10 may be flex relocated
1174; R0 corrupted
1175; R9 == pointer to format string when processing stopped
1176; May return an error
1177;
1178; Use; Outputs a string, based on a format with the following
1179; syntax:
1180;
1181; All characters are echoed directly except `%' which is
1182; an escape for the following character. Escape codes defined
1183; are:
1184;
1185; %s == current SWI name
1186; %m == current module name
1187; %n == current SWI number
1188; %x == current X SWI number (i.e. SWI number OR &20000)
1189; %% == end of formatting section
1190
1191.sl__doString stmfd r13!,{r3,r14} ;Save some registers
1192 FNflex_save("r1,r2,r4") ;Save caller's registers
1193 sub r13,r13,#128 ;Make a small buffer
1194 orr r3,r5,#&20000 ;Get the X version number
1195
1196.sl__dostr10 cmp r9,r10 ;Are we at the end yet?
1197 bcs sl__dostr50 ;Yes -- return then
1198 ldrb r0,[r9],#1 ;Load next byte from string
1199 cmp r0,#ASC("%") ;Is this a magic `%' sign?
1200 beq sl__dostr20 ;Yes -- do clever things
1201
1202 bl sl__byte ;Write this byte out
1203 b sl__dostr10 ;And continue formatting
1204
1205 ; --- Handle an escape character ---
1206
1207.sl__dostr20 ldrb r0,[r9],#1 ;Load next byte from string
1208 orr r0,r0,#&20 ;Make sure char is lowercase
1209 cmp r0,#ASC("s") ;Is this a SWI name?
1210 adreq r0,FNlitsz("%5_%4") ;Yes -- point to skeleton
1211 cmp r0,#ASC("m") ;Or the module name?
1212 adreq r0,FNlitsz("%6") ;Yes -- point to skeleton
1213 cmp r0,#ASC("n") ;Or the SWI number?
1214 adreq r0,FNlitsz("%x3") ;Yes -- point to skeleton
1215 cmp r0,#ASC("x") ;Or the SWI X number?
1216 adreq r0,FNlitsz("%x1") ;Yes -- point to skeleton
1217 cmp r0,#ASC("d") ;Or a date string?
1218 beq sl__dostr40 ;Yes -- process specially
1219 cmp r0,#ASC("p") ;Or a literal percent?
1220 adreq r0,FNlitsz("%%") ;Yes -- point to skeleton
1221 cmp r0,#ASC("%") ;Or a percent sign?
1222 addeq r9,r9,#1 ;Yes -- skip a newline char
1223 beq sl__dostr50 ;Yes -- handle that
1224
1225 cmp r0,#256 ;Do we have an address?
1226 bcc sl__dostr10 ;No -- go round for more then
1227
1228 mov r1,r13 ;Build string in it
1229 bl str_subst ;Build output string
1230 mov r2,r0 ;Point to the string
1231.sl__dostr30 ldrb r0,[r2],#1 ;Load next byte
1232 cmp r0,#32 ;Is it the terminator?
1233 blcs sl__byte ;No -- output it then
1234 bcs sl__dostr30 ;And loop back round again
1235 b sl__dostr10 ;Carry on with the string
1236
1237 FNltorg
1238
1239 ; --- Handle a date format string ---
1240
1241.sl__dostr40 stmfd r13!,{r3} ;I need this register
1242 sub r13,r13,#8 ;Make time buffer on stack
1243 mov r14,#3 ;Get the subreason code
1244 strb r14,[r13,#0] ;Save that in the block
1245 mov r1,r13 ;Point to the buffer
1246 mov r0,#14 ;Get the main reason code
1247 swi "OS_Word" ;Read the current time
1248
1249 ldrb r0,[r9,#0] ;Load the next byte ready
1250 cmp r0,#ASC("[") ;Is this an argument?
1251 adrne r0,FNlitsz("slDFMT") ;No -- point to default
1252 blne msgs_lookup ;Translate nicely
1253 movne r3,r0 ;And put it in the right reg
1254 bne sl__dostr45 ;And skip onwards a bit
1255
1256 ; --- Read the format string argument ---
1257
1258 mov r1,r11 ;Point to a spare buffer
1259 add r9,r9,#1 ;Skip past the `[' char
1260.a ldrb r14,[r9],#1 ;Load the next byte
1261 cmp r14,#ASC("]") ;Is that the end yet?
1262 cmpne r14,#&0D ;Check return for safety
1263 moveq r14,#0 ;Yes -- terminate string
1264 strb r14,[r1],#1 ;Store the byte away
1265 bne a ;Loop until all done
1266 mov r3,r11 ;Point to the format string
1267
1268 ; --- Now read the actual string ---
1269
1270.sl__dostr45 mov r0,r13 ;Point to the time block
1271 add r1,r13,#12 ;Point to output buffer
1272 mov r2,#128 ;Get the buffer size
1273 swi "OS_ConvertDateAndTime" ;Translate the string
1274 add r13,r13,#8 ;Don't need the time any more
1275 ldmfd r13!,{r3} ;Restore register I saved
1276 mov r2,r13 ;Point to buffer start
1277 b sl__dostr30 ;Now output this string
1278
1279 ; --- Finished reading the input ---
1280
1281.sl__dostr50 add r13,r13,#128 ;Reclaim my little buffer
1282 FNflex_load("r1,r2,r4") ;Restore caller's pointers
1283 ldmfd r13!,{r3,r14} ;Restore other registers
1284 bics pc,r14,#V_flag ;Return without an error
1285
1286 ; --- Write byte in R0 to output ---
1287
1288.sl__byte mov r1,r14 ;Look after return address
1289 FNflex_save("r6-r10") ;Save lots of values
1290 bl xsave_byte ;Write this byte out
1291 FNflex_load("r6-r10") ;Restore our registers
1292 movvcs pc,r1 ;If OK, return to caller
1293
1294 add r13,r13,#128 ;Reclaim my little buffer
1295 FNflex_load("r1,r2,r4") ;Restore caller's pointers
1296 ldmfd r13!,{r3,r14} ;Restore other registers
1297 orrs pc,r14,#V_flag ;And return the error
1298
1299 FNltorg
1300
1301;----- Loading modules ------------------------------------------------------
1302
1303; --- sl__loadMod ---
1304;
1305; On entry; R1 == pointer to filename
1306;
1307; On exit; May return an error
1308;
1309; Use; Loads a module and adds its SWIs to the current list.
1310
1311.sl__loadMod stmfd r13!,{r0-r2,r14} ;Save some registers
1312 add r2,r12,#sl__module ;Point to anchor for this
1313 bl load_file ;Try to load the file
1314 strvs r0,[r13,#0] ;If failed, return error
1315 ldmfd r13!,{r0-r2,pc} ;Return to caller
1316
1317 FNltorg
1318
1319; --- sl__ibMod ---
1320;
1321; On entry; R1 == estimated file size
1322;
1323; On exit; May return an error
1324;
1325; Use; Sets up a buffer for RAM loading.
1326
1327.sl__ibMod add r2,r12,#sl__module ;Point to anchor
1328 b load_initBuf ;Start the load op
1329
1330 FNltorg
1331
1332; --- sl__doneMod ---
1333;
1334; On entry; --
1335;
1336; On exit; --
1337;
1338; Use; Adds a module to the SWI list.
1339
1340.sl__doneMod stmfd r13!,{r0-r2,r14} ;Save some registers
1341 ldr r0,[r12,#sl__module] ;Load the flex anchor
1342 bl sl__scanMod ;Scan the module
1343 bvs sl__doneMod50 ;If it failed, quit now
1344 add r0,r12,#sl__module ;Point to the anchor
1345 bl flex_free ;Free the block
1346 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
1347
1348.sl__doneMod50 add r2,r0,#4 ;Look after the error
1349 add r0,r12,#sl__module ;Point to the anchor
1350 bl flex_free ;Free the block
1351 adr r0,FNliterr(1,"slMAA")
1352 bl msgs_error ;Translate and substitute
1353 mov r1,#1 ;Only have one button
1354 bl errorBox ;Report the error
1355 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
1356
1357 FNltorg
1358
1359; --- sl__lfMod ---
1360;
1361; On entry; R0 == pointer to error
1362; R1 == 1
1363;
1364; On exit; --
1365;
1366; Use; Reports an error when an attemt to load a module failed.
1367
1368.sl__lfMod stmfd r13!,{r0-r2,r14} ;Save some registers
1369 cmp r0,#0 ;Is there a real error?
1370 addne r2,r0,#4 ;Point to error text
1371 adrne r0,FNliterr(1,"slLFM")
1372 blne msgs_error ;Translate and substitute
1373 movne r1,#1 ;Only use one button
1374 blne errorBox ;Report the error
1375 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
1376
1377 FNltorg
1378
1379;----- Loading dump files ---------------------------------------------------
1380
1381; --- sl__loadDmp ---
1382;
1383; On entry; R1 == pointer to filename
1384;
1385; On exit; May return an error
1386;
1387; Use; Loads a module and adds its SWIs to the current list.
1388
1389.sl__loadDmp stmfd r13!,{r0-r2,r14} ;Save some registers
1390 add r0,r12,#sl__anchor ;Point to the anchor
1391 ldr r14,[r12,#sl__anchor] ;Load the current anchor
1392 cmp r14,#0 ;Is it defined currently?
1393 blne flex_free ;Yes -- free the block
1394 add r2,r12,#sl__anchor ;Point to anchor for this
1395 bl load_file ;Try to load the file
1396 strvs r0,[r13,#0] ;On error, return pointer
1397 ldmfd r13!,{r0-r2,pc} ;And return to caller
1398
1399 FNltorg
1400
1401; --- sl__ibDmp ---
1402;
1403; On entry; R1 == estimated file size
1404;
1405; On exit; May return an error
1406;
1407; Use; Sets up a buffer for RAM loading.
1408
1409.sl__ibDmp stmfd r13!,{r0,r14} ;Save some registers
1410 add r0,r12,#sl__anchor ;Point to the anchor
1411 ldr r14,[r12,#sl__anchor] ;Load the current anchor
1412 cmp r14,#0 ;Is it defined currently?
1413 blne flex_free ;Yes -- free the block
1414 ldmfd r13!,{r0,r14} ;Unstack the registers
1415 add r2,r12,#sl__anchor ;Point to anchor
1416 b load_initBuf ;Start the load op
1417
1418 FNltorg
1419
1420; --- sl__doneDmp ---
1421;
1422; On entry; R0 == pointer to `filename'
1423;
1424; On exit; --
1425;
1426; Use; Handles a completed load of a dump file.
1427
1428.sl__doneDmp stmfd r13!,{r0,r1,r14} ;Save some registers
1429 mov r1,r0 ;Point to the file's name
1430 bl sl__setDumpName ;Set the name up correctly
1431 add r0,r12,#sl__anchor ;Point to the anchor block
1432 bl flex_size ;Read the block's size
1433 str r0,[r12,#sl__used] ;Save the size as used value
1434 str r0,[r12,#sl__size] ;And as the size value
1435 ldr r14,[r12,#sl__flags] ;Load the flags word
1436 bic r14,r14,#slFlag__modified ;Got it from someone else
1437 str r14,[r12,#sl__flags] ;Store the flags back
1438 bl sl__setFlags ;Reset the flags nicely
1439 ldmfd r13!,{r0,r1,pc}^ ;Return to caller
1440
1441 FNltorg
1442
1443; --- sl__lfDmp ---
1444;
1445; On entry; R0 == pointer to error
1446; R1 == 1
1447;
1448; On exit; --
1449;
1450; Use; Reports an error when an attemt to load a module failed.
1451
1452.sl__lfDmp stmfd r13!,{r0-r2,r14} ;Save some registers
1453 bl sl__setFlags ;Update the flags
1454 cmp r0,#0 ;Is there a real error?
1455 addne r2,r0,#4 ;Point to error text
1456 adrne r0,FNliterr(1,"slLFM")
1457 blne msgs_error ;Translate and substitute
1458 movne r1,#1 ;Only use one button
1459 blne errorBox ;Report the error
1460 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
1461
1462 FNltorg
1463
1464;----- Format of the SWI table ----------------------------------------------
1465;
1466; In order to speed things up, we maintain a table of SWI names in memory,
1467; and write this out to a file when the user wants us to. This also means
1468; that we can build up a list of SWIs over a period of time, by the user
1469; dropping module files onto our icon or window -- this saves having to load
1470; large numbers of modules into the RMA.
1471;
1472; The format is fairly simple. We keep a linked list of module blocks in
1473; a flex block. The blocks are sorted by ascending order of SWI chunk base
1474; numbers. Each module block looks like this;
1475;
1476; word; size of this link block
1477; word; SWI chunk base number for module and flags in top 8 bits
1478; string; name of module which provides these SWIs (null-terminated)
1479; string; SWI prefix for following SWI names (null-terminated)
1480; string; name of first SWI provided by module (null-terminated)
1481; string; name of second SWI provided by module (null-terminated)
1482; ... ...
1483; string; name of last SWI provided by module (null-terminated)
1484; byte; 0 (list terminator)
1485; align; to word boundary
1486
1487; --- sl__setDumpName ---
1488;
1489; On entry; R1 == 0 for default `SWIDump' or pointer to name
1490;
1491; On exit; --
1492;
1493; Use; Sets the name of the current dump file.
1494
1495.sl__setDumpName stmfd r13!,{r0-r2,r14} ;Save some registers
1496 movs r0,r1 ;Point to the source string
1497 adreq r0,FNlitsz("SWIDump") ;No string -- use default
1498 add r1,r12,#sl__dumpFile ;Point to the name buffer
1499 mov r2,#256 ;The buffer size
1500 orr r2,r2,#&C0000000 ;Don't do `|'s or `""'s
1501 swi "OS_GSTrans" ;Expand system variables
1502 ldmfd r13!,{r0-r2,pc}^ ;And return to caller
1503
1504 FNltorg
1505
1506; --- sl__initBlock ---
1507;
1508; On entry; --
1509;
1510; On exit; May return an error
1511;
1512; Use; Initialises the SWI list block with the currently recognised
1513; OS SWIs.
1514
1515.sl__initBlock stmfd r13!,{r0-r3,r14} ;Save some registers
1516
1517 add r0,r12,#sl__anchor ;Point to the anchor
1518 ldr r14,[r12,#sl__anchor] ;Load the current anchor
1519 cmp r14,#0 ;Is it defined currently?
1520 blne flex_free ;Yes -- free the block
1521
1522 ; --- Reset the dump file name ---
1523
1524 mov r1,#0 ;Use the default name
1525 bl sl__setDumpName ;Go and do that please
1526
1527 ; --- Create the flex block ---
1528
1529 mov r1,#1024 ;Initially make it 1K
1530 bl flex_alloc ;Allocate the block
1531 blcs alloc_error ;If it failed, get an error
1532 bcs sl__initBlk90 ;And abort now
1533
1534 mov r14,r1 ;Get the size created
1535 mov r1,#0 ;Start output at beginning
1536 stmib r0,{r1,r14} ;Store sizes after anchor
1537
1538 ; --- Now build the kernel SWIs ---
1539 ;
1540 ; First do OS_WriteI. Then we do the kernel SWIs lower than
1541 ; &100.
1542
1543 adr r0,FNlitsz("Kernel") ;Point to string `Kernel'
1544 adr r1,FNlitsz("OS") ;Point to string `OS'
1545 mov r2,#&100 ;Get SWI chunk number
1546 bl sl__newLink ;Add in a new link block
1547 bvs sl__initBlk89 ;If it failed, stop going
1548 bcs sl__initBlk05 ;If already done, skip
1549 add r0,r12,#sl__anchor ;Point to the anchor
1550 adr r1,FNlitsz("WriteI") ;Point to string `WriteI'
1551 bl sl__string ;Add it to the block
1552 blvc sl__endLink ;Terminate this link
1553 bvs sl__initBlk89 ;If it failed, stop going
1554
1555 ; --- Now do the kernel SWIs ---
1556
1557.sl__initBlk05 adr r0,FNlitsz("Kernel") ;Point to string `Kernel'
1558 adr r1,FNlitsz("OS") ;Point to string `OS'
1559 mov r2,#&0 ;Get SWI chunk number
1560 bl sl__newLink ;Add in a new link block
1561 bvs sl__initBlk89 ;If it failed, stop going
1562 bcs sl__initBlk17 ;Already there -- skip on
1563 mov r3,#0 ;Start at SWI number 0
1564
1565.sl__initBlk10 mov r0,r3 ;Get the SWI number
1566 mov r1,r11 ;Build string in scratchpad
1567 mov r2,#256 ;And give the block size
1568 swi "OS_SWINumberToString" ;Read the SWI name
1569 swi "XOS_SWINumberFromString" ;Try to convert back
1570 cmp r0,r3 ;Is this what we expected?
1571 bne sl__initBlk13 ;No -- skip to end of loop
1572
1573 add r0,r12,#sl__anchor ;Point to the anchor
1574 add r1,r11,#3 ;Skip past `OS_' prefix
1575 bl sl__string ;Add it to the list
1576 bvs sl__initBlk89 ;If it failed, stop going
1577 b sl__initBlk15 ;Skip past the next bit
1578
1579.sl__initBlk13 add r0,r12,#sl__anchor ;Point to the anchor
1580 mov r1,#1 ;Want one extra byte
1581 bl sl__ensure ;Make sure I've got it
1582 bvs sl__initBlk89 ;If it failed, stop going
1583 mov r14,#1 ;Mark this as nonexistant
1584 strb r14,[r0],#1 ;Store it in the block
1585
1586.sl__initBlk15 add r3,r3,#1 ;Bump the SWI number
1587 cmp r3,#&100 ;Reached the end yet?
1588 blt sl__initBlk10 ;No -- go back round then
1589
1590 ; --- Finished that; end the link block ---
1591
1592 bl sl__endLink ;Terminate the link block
1593 bvs sl__initBlk89 ;If it failed, stop going
1594
1595 ; --- Now go through the module list ---
1596
1597.sl__initBlk17 mov r1,#0 ;Start on first module
1598.sl__initBlk20 mov r2,#0 ;Start on first instance
1599 mov r0,#12 ;Enumerate module addresses
1600 swi "XOS_Module" ;Read next module number
1601 bvs sl__initBlk30 ;If error must have finished
1602 mov r0,r3 ;Point to module base address
1603 bl sl__scanMod ;Scan module for SWIs
1604 bvs sl__initBlk90 ;If it failed, stop going
1605 cmp r2,#0 ;Are there more instances?
1606 addne r1,r1,#1 ;Yes -- move to next module
1607 b sl__initBlk20 ;Go handle the next module
1608
1609 ; --- Finished the module list ---
1610
1611.sl__initBlk30 bl sl__setFlags ;Reset the flags
1612 ldmfd r13!,{r0-r3,r14} ;Unstack the registers
1613 bics pc,r14,#V_flag ;And return without error
1614
1615 ; --- Something went wrong ---
1616
1617.sl__initBlk89 mov r3,r0 ;Look after error pointer
1618 add r0,r12,#sl__anchor ;Point to the anchor
1619 bl flex_free ;Free the block
1620 mov r1,#0 ;Clear the anchor pointer
1621 str r1,[r12,#sl__anchor] ;Save it in the block
1622 bl sl__setFlags ;Reset the flags nicely
1623 mov r0,r3 ;And restore error pointer
1624
1625.sl__initBlk90 add r13,r13,#4 ;Don't restore R0 on exit
1626 ldmfd r13!,{r1-r3,r14} ;Restore registers
1627 orrs pc,r14,#V_flag ;And return the error
1628
1629 FNltorg
1630
1631; --- sl__scanMod ---
1632;
1633; On entry; R0 == pointer to module
1634;
1635; On exit; May return an error
1636;
1637; Use; Scans a module, and adds its SWIs to the list.
1638
1639.sl__scanMod stmfd r13!,{r0-r4,r14} ;Save some registers
1640 mov r3,r0 ;Look after module base
1641
1642 ; --- Make sure this module's OK ---
1643
1644 ldr r0,[r3,#16] ;Load the name offset
1645 ldr r1,[r3,#36] ;Load the SWI name table
1646 ldr r2,[r3,#28] ;And the SWI chunk number
1647 cmp r0,#256*1024 ;Make sure these are valid
1648 cmpcc r1,#256*1024 ;Both offsets please
1649 bcs sl__scanMod80 ;If not, ignore this module
1650
1651 tst r2,#&FF000000 ;Make sure SWI chunk's OK
1652 tsteq r2,#&0000003f
1653 tsteq r2,#&00020000
1654 bne sl__scanMod80 ;If not, ignore this module
1655 cmp r2,#&200 ;Is chunk in user range?
1656 bcc sl__scanMod80 ;No -- ignore this module
1657
1658 ; --- Set the file modified flag ---
1659
1660 ldr r14,[r12,#sl__flags] ;Load the flags word
1661 orr r14,r14,#slFlag__modified ;Set the flag
1662 str r14,[r12,#sl__flags] ;Save the flags back again
1663
1664 ; --- We now have a module to add ---
1665 ;
1666 ; For error recovery, we read the current block sizes, so
1667 ; we can reset them if all goes wrong.
1668
1669 add r0,r3,r0 ;Translate offset to address
1670 add r1,r3,r1 ;For both offsets
1671 add r14,r12,#sl__used ;Point to block size info
1672 ldmia r14,{r3,r4} ;Load the size counts
1673 FNflex_save("r1") ;Look after this pointer
1674 bl sl__newLink ;Add a new link in
1675 FNflex_load("r1") ;Restore pointer afterwards
1676 bvs sl__scanMod90 ;If it failed, return error
1677
1678 ; --- Now just add the SWI names in ---
1679
1680.sl__scanMod10 ldrb r14,[r1],#1 ;Load a SWI prefix byte
1681 cmp r14,#0 ;Is this the end yet?
1682 bne sl__scanMod10 ;No -- keep on going
1683
1684 ldrb r14,[r1],#0 ;Load the next byte out
1685 cmp r14,#0 ;Is this the double-0?
1686 beq sl__scanMod15 ;Yes -- end right now
1687 add r0,r12,#sl__anchor ;Point to anchor block
1688 FNflex_save("r1") ;Save this pointer away
1689 bl sl__string ;Add string to the list
1690 FNflex_load("r1") ;Restore this pointer
1691 bvs sl__scanMod89 ;If it failed, report error
1692 b sl__scanMod10 ;Keep on adding names
1693
1694 ; --- Finished that -- wrap everything up ---
1695
1696.sl__scanMod15 bl sl__endLink ;Terminate this block
1697 bvs sl__scanMod89 ;If it failed, tidy up
1698.sl__scanMod80 ldmfd r13!,{r0-r4,r14} ;Restore registers
1699 bics pc,r14,#V_flag ;And return with V clear
1700
1701 ; --- Failed to do the job ---
1702
1703.sl__scanMod89 mov r2,r0 ;Save the error pointer
1704 add r0,r12,#sl__anchor ;Point to the flex anchor
1705 mov r1,r4 ;Get the old size value
1706 bl flex_extend ;Reset the size
1707 stmib r0,{r3,r4} ;Save old index values
1708 mov r0,r2 ;Restore the error pointer
1709
1710.sl__scanMod90 add r13,r13,#4 ;Don't restore R0 on exit
1711 ldmfd r13!,{r1-r4,r14} ;Restore the other registers
1712 orrs pc,r14,#V_flag ;And return to caller
1713
1714 FNltorg
1715
1716; --- sl__newLink ---
1717;
1718; On entry; R0 == pointer to module name
1719; R1 == pointer to SWI prefix
1720; R2 == SWI chunk number
1721;
1722; On exit; May return an error
1723;
1724; Use; Ensures that a link block for the given module exists. If
1725; it doesn't exist already, it is created at the end of the
1726; flex block. The index of the last link is returned, so it
1727; can be cleared if the actual SWI names can't be added.
1728
1729.sl__newLink stmfd r13!,{r0-r7,r14} ;Save some registers
1730
1731 ; --- Set up for checking loop ---
1732
1733 mov r3,r0 ;Look after module name
1734 mov r4,r1 ;And the SWI prefix string
1735 FNflex_save("r1,r3") ;Save these for relocation
1736 add r14,r12,#sl__anchor ;Point to the anchor
1737 ldmia r14,{r5,r6} ;Load base and size
1738
1739 ; --- Wade on through the block ---
1740
1741 mov r7,#0 ;Start at offset 0
1742.sl__newl10 cmp r7,r6 ;Reached the end yet?
1743 bcs sl__newl30 ;Yes -- better stop then
1744
1745 ; --- See if this is a match ---
1746
1747 add r14,r5,r7 ;Find current address
1748 ldr r0,[r14,#4] ;Load the SWI chunk number
1749 bic r0,r0,#&ff000000 ;Clear the flags byte
1750 cmp r0,r2 ;Does this match our one?
1751 bne sl__newl15 ;No -- move along then
1752
1753 add r0,r14,#8 ;Point to the module name
1754 mov r1,r3 ;Point to our module name
1755 bl str_cmp ;Compare the strings
1756 bne sl__newl15 ;No match -- move along then
1757
1758.sl__newl13 ldrb r14,[r0],#1 ;Load module name byte
1759 cmp r14,#32 ;Is this the end?
1760 bcs sl__newl13 ;No -- keep going
1761
1762 mov r1,r4 ;Point to the SWI prefix
1763 bl str_cmp ;Do these match?
1764 beq sl__newl20 ;Yes -- remove this chunk
1765
1766.sl__newl15 ldr r14,[r5,r7] ;Load the length of this one
1767 add r7,r7,r14 ;Move on to the next block
1768 b sl__newl10 ;And keep on going
1769
1770 ; --- Found a match -- remove a chunk ---
1771
1772.sl__newl20 add r0,r12,#sl__anchor ;Point to the anchor
1773 ldr r2,[r5,r7] ;Get the block's size
1774 add r1,r7,r2 ;Start at the end of it
1775 rsb r2,r2,#0 ;And reduce block by this
1776 bl flex_midExtend ;Remove this chunk of data
1777 add r6,r6,r2 ;Modify the block size
1778 str r6,[r12,#sl__used] ;Save this size back
1779 ldr r14,[r12,#sl__size] ;Load the total block size
1780 add r14,r14,r2 ;Adjust that value too
1781 str r14,[r12,#sl__size] ;Store my modified value back
1782 ldr r2,[r13,#8] ;Restore caller's SWI base
1783
1784 ; --- Add a new chunk onto the block ---
1785
1786.sl__newl30 str r6,[r12,#sl__last] ;Save the base of this block
1787 ldr r7,[r12,#sl__size] ;Get the block total size
1788
1789 add r0,r12,#sl__anchor ;Point to anchor and info
1790 mov r1,#8 ;Add in fixed size info
1791 bl sl__ensure ;Make sure there's enough
1792 strvc r2,[r0,#4] ;Save the SWI chunk number
1793
1794 addvc r0,r12,#sl__anchor ;Point to anchor and info
1795 FNflex_load("r1") ;Unstack module name pointer
1796 blvc sl__string ;Add the string in
1797 FNflex_load("r1") ;Unstack SWI prefix string
1798 blvc sl__string ;Add the string in
1799
1800 ldmvcfd r13!,{r0-r7,r14} ;Unstack registers
1801 bicvcs pc,r14,#V_flag ;And return to caller
1802
1803 ; --- It failed -- better tidy up ---
1804
1805 mov r2,r0 ;Look after error number
1806 add r0,r12,#sl__anchor ;Point to the anchor
1807 mov r1,r7 ;Get the old size back
1808 bl flex_extend ;Reset the block size
1809 stmib r0,{r6,r7} ;Save the old values back
1810 mov r0,r2 ;Get the error pointer
1811 add r13,r13,#4 ;Don't restore R0 on exit
1812 ldmfd r13!,{r1-r7,r14} ;Restore registers
1813 orrs pc,r14,#V_flag ;Return the error
1814
1815 FNltorg
1816
1817; --- sl__endLink ---
1818;
1819; On entry; --
1820;
1821; On exit; May return an error
1822;
1823; Use; Terminates a link block.
1824
1825.sl__endLink stmfd r13!,{r0,r1,r14} ;Save some registers
1826 add r0,r12,#sl__anchor ;Find the flex block
1827 mov r1,#1 ;Want to add a single byte
1828 bl sl__ensure ;Make sure we've got enough
1829 bvs sl__endl90 ;If it failed, return
1830
1831 mov r14,#0 ;Get the NULL byte ready
1832 strb r14,[r0,#0] ;Save it at the end nicely
1833 add r0,r12,#sl__anchor ;Find the flex block again
1834 bl sl__align ;Word align output pointer
1835
1836 ldmia r0,{r0,r14} ;Load block base and size
1837 ldr r1,[r12,#sl__last] ;Load the offset of the block
1838 sub r14,r14,r1 ;Get the last chunk size?
1839 str r14,[r0,r1] ;Save the length word
1840
1841 ldmfd r13!,{r0,r1,r14} ;And return to caller
1842 bics pc,r14,#V_flag ;Return without error
1843
1844.sl__endl90 add r13,r13,#4 ;Don't return R0 on exit
1845 ldmfd r13!,{r1,r14} ;Restore registers
1846 orrs pc,r14,#V_flag ;And return the error
1847
1848 FNltorg
1849
1850;----- Block management routines --------------------------------------------
1851
1852; --- sl__ensure ---
1853;
1854; On entry; R0 == pointer to anchor/size block
1855; R1 == number of bytes to add
1856;
1857; On exit; R0 == pointer to allocated area
1858; May return an error
1859;
1860; Use; Ensures that there are R1 bytes free at the end of the given
1861; flex block.
1862
1863.sl__ensure stmfd r13!,{r1,r2,r14} ;Save some registers
1864 ldmib r0,{r2,r14} ;Load the base and sizes
1865 add r1,r1,r2 ;Find new total size
1866 str r1,[r0,#4] ;Save this back
1867 add r1,r1,#255 ;Align up to next 256
1868 bic r1,r1,#255 ;For niceness's sake
1869 cmp r1,r14 ;Do we already have enough
1870 bhi sl__ensure50 ;No -- allocate some more
1871.sl__ensure10 str r1,[r0,#8] ;Save new total size
1872 ldr r0,[r0,#0] ;Load address of block
1873 add r0,r0,r2 ;Point to first free byte
1874 ldmfd r13!,{r1,r2,r14} ;Unstack registers
1875 bics pc,r14,#V_flag ;And return without error
1876
1877.sl__ensure50 bl flex_extend ;Extend the block nicely
1878 bcc sl__ensure10 ;Rejoin program if OK
1879 bl alloc_error ;Get the error message
1880 ldmfd r13!,{r1,r2,pc} ;Return error to caller
1881
1882 FNltorg
1883
1884; --- sl__string ---
1885;
1886; On entry; R0 == pointer to flex block and size information
1887; R1 == pointer to string
1888;
1889; On exit; May return an error
1890;
1891; Use; Adds a string to a flex block.
1892
1893.sl__string stmfd r13!,{r0-r3,r14} ;Save some registers
1894 mov r2,r0 ;Look after anchor address
1895 FNflex_save("r1") ;Save the string address
1896 mov r0,r1 ;Point to the string
1897 bl str_len ;Work out the length
1898 add r1,r0,#1 ;Get the required size
1899 mov r0,r2 ;Point to anchor and sizes
1900 bl sl__ensure ;Make sure the space is OK
1901 FNflex_load("r1") ;Restore R1 from stack
1902 blvc str_cpy ;And copy it into the block
1903 strvs r0,[r13,#0] ;Otherwise store the error
1904 ldmfd r13!,{r0-r3,pc} ;And return to caller
1905
1906 FNltorg
1907
1908; --- sl__align ---
1909;
1910; On entry; R0 == pointer to flex anchor and size info
1911;
1912; On exit; --
1913;
1914; Use; Word aligns the output pointer of a flex block.
1915
1916.sl__align stmfd r13!,{r14} ;Save a register
1917 ldr r14,[r0,#4] ;Load the output offset
1918 add r14,r14,#3 ;Word align this offset
1919 bic r14,r14,#3 ;Mask off bottom bits
1920 str r14,[r0,#4] ;Store new offset back
1921 ldmfd r13!,{pc}^ ;And return to caller
1922
1923 FNltorg
1924
1925;----- Workspace ------------------------------------------------------------
1926]
1927 PROCws_start
1928
1929sl__flags =FNws_word :REM ;Various flags bits
1930sl__anchor =FNws_word :REM ;Flex anchor for SWI table
1931sl__used =FNws_word :REM ;Size used in flex block
1932sl__size =FNws_word :REM ;Actual size of flex block
1933sl__last =FNws_word :REM ;Offset of last block
1934sl__modNames =FNws_word :REM ;Block for module names
1935sl__format =FNws_word :REM ;Format chunk handle
1936sl__module =FNws_word :REM ;Anchor for loading modules
1937sl__pollBlock =FNws (256) :REM ;Wimp_Poll data block
1938sl__dumpFile =FNws (256) :REM ;Full pathname of dump file
1939
1940sl__wSize =FNws (0)
1941
1942slFlag__block = (1<<0) :REM ;We have a SWI block
1943slFlag__format = (1<<1) :REM ;There is a format
1944slFlag__savable = (1<<2) :REM ;We can save a SWI list
1945slFlag__modified= (1<<3) :REM ;SWI block is unsaved
1946slFlag__saving = (1<<4) :REM ;We're saving a dump
1947
1948[ opt o
1949
1950]
1951NEXT
1952
1953PROCbas_aofSave
1954END
1955
1956REM -- Macros ---------------------------------------------------------------
1957
1958DEF FNs(s$)
1959[ opt 4
1960 equs s$
1961 dcb 0
1962]
1963=0
1964DEFFNP(i%):PRINT~i%:=0
The Straylight Source Distribution (obsolete software for RISC OS)